@bamboocss/vite 1.45.5 → 1.46.1

package/dist/index.cjs

@@ -2,161 +2,69 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-let _bamboocss_config = require("@bamboocss/config");
-let _bamboocss_node = require("@bamboocss/node");
+require("./chunk.cjs");
+const require_class_name = require("./class-name.cjs");
 let _bamboocss_logger = require("@bamboocss/logger");
 let _bamboocss_shared = require("@bamboocss/shared");
-let _ampproject_remapping = require("@ampproject/remapping");
-_ampproject_remapping = __toESM(_ampproject_remapping);
-let magic_string = require("magic-string");
-magic_string = __toESM(magic_string);
-let postcss = require("postcss");
-postcss = __toESM(postcss);
-let postcss_selector_parser = require("postcss-selector-parser");
-postcss_selector_parser = __toESM(postcss_selector_parser);
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
-let _bamboocss_config_ts_path = require("@bamboocss/config/ts-path");
-let _bamboocss_extractor = require("@bamboocss/extractor");
-let ts_morph = require("ts-morph");
-//#region src/prune-static-css.ts
-/** The generated declaration that identifies a Bamboo stylesheet after minification. */
-const SENTINEL = "--made-with-bamboo";
+let _bamboocss_node_static_compiler = require("@bamboocss/node/static-compiler");
+//#region src/lazy-modules.ts
 /**
-* A class name with its CSS escapes removed, which is the only spelling both sides agree on.
-*
-* The same class reaches the stylesheet either escaped or not — `--bottom-mask-size_16px` is a
-* valid selector as written, since a CSS ident may begin with `--`, while `esc` produces the
-* escaped `\--…` form that reachability keys are stored in. Comparing raw spellings therefore
-* missed a rule written the other way, and pruning removed an atom whose rule was in the sheet
-* all along. It could only ever affect names needing an escape, which is why it presented as
-* every custom property and vendor-prefixed declaration losing its rule at once.
+* Keep one asynchronous initialization in flight, retain its fulfilled value, and forget only
+* a rejected attempt so a later Vite rebuild can recover.
 *
-* Stripping backslashes is unambiguous here: a semantic atom name never contains a literal one.
+* Starting through a resolved promise also turns a synchronous loader throw into the same
+* rejected-promise contract as a failed dynamic import.
+*/
+const createRetryableLazy = (load) => {
+	let pending;
+	return () => {
+		if (pending) return pending;
+		const attempt = Promise.resolve().then(load);
+		pending = attempt;
+		attempt.catch(() => {
+			if (pending === attempt) pending = void 0;
+		});
+		return attempt;
+	};
+};
+/** Process-wide module loading; individual plugin instances still own their mutable state. */
+const loadNodeModule = createRetryableLazy(() => Promise.resolve().then(() => require("./node-module.cjs")));
+const loadConfigModule = createRetryableLazy(() => Promise.resolve().then(() => require("./config-module.cjs")));
+/**
+* Keep stylesheet parsing, selector inventory and late sourcemap rewriting behind one built
+* chunk. The injectable loader proves sharing and retry without exposing a package subpath.
 */
-const bare = (className) => className.replaceAll("\\", "");
+const createLazyCssOutputModule = (loadCssOutput = () => Promise.resolve().then(() => require("./css-output-module.cjs"))) => createRetryableLazy(loadCssOutput);
+/** One process-wide CSS-output load shared by every plugin instance and Vite environment. */
+const loadCssOutputModule = createLazyCssOutputModule();
 /**
-* Remove source-graph atoms no transformed module can emit.
-*
-* `prunableClasses` contains only atoms extracted from the source graph. Explicit `staticCss`
-* additions are absent and survive as a safelist; graph atoms are governed by the transformed
-* module reachability set, regardless of whether they originated in `css()` or a recipe.
+* Keep the AST fold behind its own built chunk. The injectable loader is an architectural
+* seam: callers can prove sharing and retry without a production-only switch, while the
+* default remains a statically discoverable dynamic import for both published formats.
 */
-const pruneStaticCss = (css, session, { prune = true } = {}) => {
-	if (!css.includes(SENTINEL)) return css;
-	const root = postcss.default.parse(css);
-	const prunable = new Set([...session.prunableClasses].map(bare));
-	const used = new Set([...session.usedClasses].map(bare));
-	const isUtilityRule = (rule) => {
-		let parent = rule.parent;
-		while (parent) {
-			if (parent.type === "atrule") {
-				const atRule = parent;
-				if (atRule.name === "layer" && atRule.params === session.utilityLayer) return true;
-			}
-			parent = parent.parent;
-		}
-		return false;
+const createLazyFoldModule = (loadFold = () => Promise.resolve().then(() => require("./fold-module.cjs"))) => 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. */
+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);
+	return {
+		context,
+		foldSource: fold.foldSource,
+		runtimeCss,
+		styleCompiler
 	};
-	if (prune) root.walkRules((rule) => {
-		if (!isUtilityRule(rule)) return;
-		let removedAny = false;
-		let selector;
-		try {
-			selector = (0, postcss_selector_parser.default)((selectors) => {
-				selectors.each((candidate) => {
-					const classes = /* @__PURE__ */ new Set();
-					candidate.walkClasses((classNode) => {
-						classes.add(bare(classNode.toString().slice(1)));
-					});
-					if (classes.size !== 1) return;
-					const [className] = classes;
-					if (!className || !prunable.has(className) || used.has(className)) return;
-					candidate.remove();
-					removedAny = true;
-					session.prunedClasses.add(className);
-				});
-			}).processSync(rule.selector);
-		} catch {
-			return;
-		}
-		if (!removedAny) return;
-		if (!selector.trim()) {
-			rule.remove();
-			return;
-		}
-		rule.selector = selector;
-	});
-	let removed = true;
-	while (removed) {
-		removed = false;
-		root.walkAtRules((rule) => {
-			if (rule.nodes?.length !== 0) return;
-			rule.remove();
-			removed = true;
-		});
-	}
-	if (prune) {
-		const present = /* @__PURE__ */ new Set();
-		root.walkRules((rule) => {
-			if (!isUtilityRule(rule)) return;
-			try {
-				(0, postcss_selector_parser.default)((selectors) => {
-					selectors.walkClasses((classNode) => {
-						present.add(bare(classNode.toString().slice(1)));
-					});
-				}).processSync(rule.selector);
-			} catch {}
-		});
-		const orphaned = [];
-		for (const className of session.usedClasses) {
-			if (/\s/.test(className)) {
-				orphaned.push(className);
-				continue;
-			}
-			if (!prunable.has(bare(className))) continue;
-			if (present.has(bare(className))) continue;
-			orphaned.push(className);
-		}
-		if (orphaned.length) {
-			const describe = (className) => {
-				if (/\s/.test(className)) return `  ${className}\n      (malformed key: a class name cannot contain whitespace)`;
-				const extracted = session.prunableClasses.has(className) ? "in the extracted atoms" : "NOT extracted";
-				const bare = className.replaceAll("\\", "");
-				const near = [...present].filter((candidate) => candidate !== className && candidate.replaceAll("\\", "") === bare);
-				return `  ${className}\n      (${extracted}; no rule in the sheet` + (near.length ? `; a rule exists under ${near.map((n) => JSON.stringify(n)).join(", ")}` : "") + `)`;
-			};
-			throw new Error(`bamboocss: ${orphaned.length} compiled class(es) have no rule in the emitted stylesheet. Elements carrying them would render unstyled.\n\n${(0, _bamboocss_shared.truncateList)(orphaned.map(describe), {
-				unit: "class",
-				separator: "\n"
-			})}\n\nThis is a compiler bug rather than anything to fix in your source. Please report it with the block above — the parenthesised part is what distinguishes an atom that was never emitted from one whose rule is present under a different spelling.`);
-		}
-	}
-	return root.toString();
-};
+});
 //#endregion
 //#region src/static-session.ts
 const createStaticCompilationSession = () => {
@@ -170,8 +78,19 @@ const createStaticCompilationSession = () => {
 		viewTransitionClasses: /* @__PURE__ */ new Set(),
 		usedClasses: /* @__PURE__ */ new Set(),
 		expectedEnvironments: void 0,
-		startedEnvironments: /* @__PURE__ */ new Set(),
+		participatingEnvironments: /* @__PURE__ */ new Set(),
+		completedEnvironments: /* @__PURE__ */ new Set(),
 		prunedClasses: /* @__PURE__ */ new Set(),
+		beginOutputProjection(_environment, _outputOptions, _bundle, replacesGeneratedStylesheet) {
+			if (replacesGeneratedStylesheet) session.prunedClasses.clear();
+			const prunable = new Set([...session.prunableClasses].map((className) => className.replaceAll("\\", "")));
+			const requiredClasses = new Set([...session.usedClasses].filter((className) => prunable.has(className.replaceAll("\\", ""))));
+			return {
+				cssLoaded: session.cssLoaded,
+				requiredClasses,
+				restore() {}
+			};
+		},
 		markClassUsed(className) {
 			for (const token of className.split(" ")) {
 				if (!token) continue;
@@ -182,30 +101,28 @@ const createStaticCompilationSession = () => {
 	return session;
 };
 /**
-* Environments this run intends to build that have not been compiled yet.
+* Expected or observed environments whose current generation has not completed yet.
 *
 * Empty means everything the run will contribute has been contributed, which is the condition
 * every whole-run judgement here waits for: pruning the stylesheet against reachability, and
 * the two guards that ask whether the compiled modules and the extraction graph agree. Each of
 * those is false about a build in progress and true only about a finished one.
 *
-* Empty is also the answer for a single-environment build, where nothing announced an
-* environment list because there is only ever one — so that path is unchanged.
+* The environment currently at `buildEnd` may be supplied as the candidate completing this
+* call. That keeps publication transactional: whole-run checks can include its finished graph
+* without marking it complete before those checks themselves succeed.
+*
+* Empty is also the answer for a single-environment build, where the only participant is the
+* completing candidate — so that path is unchanged.
 *
 * An environment a run declares and then never builds leaves this permanently non-empty, and
 * those judgements are skipped for the run. Every one of them errs towards shipping more CSS
 * or asserting less, so that is the safe direction to be wrong in.
 */
-const remainingEnvironments = (session) => [...session.expectedEnvironments ?? []].filter((name) => !session.startedEnvironments.has(name));
-const resetStaticCompilationSession = (session) => {
-	session.cssLoaded = false;
-	session.transformedFiles.clear();
-	session.extractedFiles.clear();
-	session.prunableClasses.clear();
-	session.viewTransitionClasses.clear();
-	session.usedClasses.clear();
-	session.startedEnvironments.clear();
-	session.prunedClasses.clear();
+const remainingEnvironments = (session, completingEnvironment) => {
+	const participating = new Set(session.expectedEnvironments ?? []);
+	for (const environment of session.participatingEnvironments) participating.add(environment);
+	return [...participating].filter((name) => name !== completingEnvironment && !session.completedEnvironments.has(name));
 };
 //#endregion
 //#region src/css.ts
@@ -252,95 +169,6 @@ const queryOf = (id) => {
 * `transform`, and both are answered by the same middleware.
 */
 const asError = (error, context) => error instanceof Error ? error : new Error(`bamboocss: ${context}: ${String(error)}`, { cause: error });
-const INLINE_SOURCE_MAP = /\n?\/\/# sourceMappingURL=data:application\/json[^\n]*$/;
-/** Rewrite one generated chunk without invalidating all mappings after the changed string. */
-const replaceChunkReference = (chunk, bundle, previous, next, sourcemap) => {
-	if (!chunk.code.includes(previous)) return;
-	const magic = new magic_string.default(chunk.code);
-	let index = chunk.code.indexOf(previous);
-	while (index !== -1) {
-		magic.overwrite(index, index + previous.length, next);
-		index = chunk.code.indexOf(previous, index + previous.length);
-	}
-	chunk.code = magic.toString();
-	if (!chunk.map) return;
-	const file = chunk.map.file;
-	const debugId = chunk.map.debugId;
-	const combined = (0, _ampproject_remapping.default)([magic.generateMap({
-		source: chunk.fileName,
-		hires: "boundary"
-	}), chunk.map], () => null);
-	if (file) combined.file = file;
-	if (debugId) combined.debugId = debugId;
-	const rollupMap = combined;
-	rollupMap.toUrl = () => `data:application/json;charset=utf-8;base64,${Buffer.from(combined.toString()).toString("base64")}`;
-	chunk.map = rollupMap;
-	if (sourcemap === "inline") {
-		chunk.code = chunk.code.replace(INLINE_SOURCE_MAP, "");
-		chunk.code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${Buffer.from(combined.toString()).toString("base64")}`;
-		return;
-	}
-	const mapAsset = bundle[`${chunk.fileName}.map`];
-	if (mapAsset?.type === "asset") mapAsset.source = combined.toString();
-};
-/** Replace an emitted filename wherever Vite or Rollup has already recorded it. */
-const replaceAssetReferences = (bundle, previous, next, sourcemap) => {
-	const replace = (value) => value.replaceAll(previous, next);
-	for (const output of Object.values(bundle)) {
-		if (output.type === "asset") {
-			if (typeof output.source === "string") output.source = replace(output.source);
-			continue;
-		}
-		replaceChunkReference(output, bundle, previous, next, sourcemap);
-		const referencedFiles = output.referencedFiles;
-		if (referencedFiles) output.referencedFiles = referencedFiles.map(replace);
-		const importedCss = output.viteMetadata?.importedCss;
-		if (importedCss?.delete(previous)) importedCss.add(next);
-	}
-};
-/**
-* Could this bundle entry be the generated stylesheet?
-*
-* The filename is checked before the bytes because the alternative decodes every asset in the
-* bundle to a UTF-8 string in order to search it — fonts, images and sourcemaps included. On an
-* app with a large asset graph that is seconds of decode and a lot of garbage, twice over, to
-* answer a question the extension already answers. The marker is a CSS custom property, so it
-* cannot occur anywhere but CSS.
-*/
-const carriesGeneratedCss = (output) => output.type === "asset" && output.fileName.endsWith(".css");
-/**
-* Prune compiler-owned CSS, then give any sheet whose bytes changed a hash of those bytes.
-*
-* Rollup has already expanded `[hash]` when `generateBundle` runs. Mutating only `source`
-* would therefore leave two different reachable subsets under one CDN key. The extra final
-* hash is not cosmetic: it makes late graph reachability cache-safe.
-*
-* Renaming is therefore not a choice this takes. Pruned bytes under the unpruned sheet's name
-* is the one outcome that must never be reachable, and a sheet nothing was removed from keeps
-* its name because its bytes are unchanged — so "rename" is a consequence of "the bytes moved",
-* not a second option. `prune` is the only knob.
-*/
-const optimizeStaticCssAssets = (bundle, session, options = {}) => {
-	const { prune = true, sourcemap = session.sourcemap } = options;
-	/** Assets in this bundle that carry the generated stylesheet, pruned or not. */
-	let sheets = 0;
-	for (const output of Object.values(bundle)) {
-		if (!carriesGeneratedCss(output)) continue;
-		const source = typeof output.source === "string" ? output.source : Buffer.from(output.source).toString();
-		if (!source.includes("--made-with-bamboo")) continue;
-		sheets++;
-		if (!prune) continue;
-		const optimized = pruneStaticCss(source, session);
-		output.source = optimized;
-		if (optimized === source) continue;
-		const nextName = output.fileName.replace(/\.css$/, `.b-${(0, _bamboocss_shared.toHash)(optimized)}.css`);
-		if (bundle[nextName] && bundle[nextName] !== output) throw new Error(`bamboocss: final CSS asset name collision at ${JSON.stringify(nextName)}.`);
-		const previous = output.fileName;
-		output.fileName = nextName;
-		replaceAssetReferences(bundle, previous, nextName, sourcemap);
-	}
-	return { sheets };
-};
 /**
 * Serve bamboo's stylesheet as a virtual module, in dev and in build.
 *
@@ -355,28 +183,50 @@ const optimizeStaticCssAssets = (bundle, session, options = {}) => {
 * process just wrote, which is a race on any watch rebuild.
 */
 const bamboocssCss = (options) => {
-	const { configPath, cwd, session, pruneCss = true } = options;
-	/**
-	* Environments whose `load` served the virtual stylesheet.
-	*
-	* The lost-sheet guard below is about an asset that existed and then went missing, so it
-	* can only be asked of an environment that asked for one. An SSR bundle never imports the
-	* stylesheet — the client build emits it — and firing there turned a correct two-environment
-	* build into a hard failure.
-	*/
-	const servedEnvironments = /* @__PURE__ */ new Set();
-	const builder = new _bamboocss_node.Builder();
+	const { configPath, cwd, loadCssOutput = loadCssOutputModule, session, 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. */
+	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)))];
+	};
 	/**
 	* Serialised, because both `load` and the watcher can reach it and `Builder` keeps one
 	* context. Two overlapping passes would extract into the same encoder and emit the
 	* stylesheet twice over.
 	*/
 	let pending;
+	/**
+	* Which change the current `pending` was generated for, and the validated sheet it produced.
+	*
+	* Every environment loads the virtual stylesheet — a react-router dev server loads it once
+	* for the client graph and once for SSR — and each load used to run a complete extraction
+	* and optimization pass to produce byte-identical CSS. The sheet is a function of the source
+	* files alone, and the watcher below is the single point every event that can reach it
+	* passes through — Vite's own propagation only arrives via the watch edges `load` registers,
+	* over the same extracted files the watcher checks. A monotonic counter bumped there is
+	* therefore enough to know whether a build already reflects the world a load is asking about.
+	*
+	* Dev only. A production build has no dev watcher to advance the counter, so serving the
+	* memo there would hand `vite build --watch` a stale sheet; builds regenerate per load.
+	*/
+	let changeGeneration = 0;
+	let pendingGeneration = -1;
+	let servedCss;
 	const build = async () => {
+		const builder = await ensureBuilder();
 		await builder.setup({
 			configPath,
 			cwd,
@@ -388,7 +238,7 @@ const bamboocssCss = (options) => {
 		if (builder.context) {
 			session.utilityLayer = builder.context.config.layers?.utilities ?? "utilities";
 			session.extractedFiles.clear();
-			for (const file of builder.context.getFiles()) session.extractedFiles.add(builder.context.runtime.path.abs(builder.context.config.cwd, file));
+			for (const file of extractedSourceFiles()) session.extractedFiles.add(file);
 		}
 		let graphAtomHashes;
 		if (builder.context) {
@@ -409,9 +259,11 @@ const bamboocssCss = (options) => {
 				session.prunableClasses.add((0, _bamboocss_shared.esc)(transition.className));
 			}
 		}
-		return command === "serve" ? pruneStaticCss(css, session, { prune: false }) : css;
+		return css;
 	};
 	const generate = () => {
+		if (command === "serve" && pending && pendingGeneration === changeGeneration) return pending;
+		pendingGeneration = changeGeneration;
 		pending = Promise.resolve(pending).catch(() => void 0).then(build);
 		return pending;
 	};
@@ -435,10 +287,43 @@ const bamboocssCss = (options) => {
 	let prebuilt;
 	let prebuildStarted = false;
 	const prebuild = async () => {
-		if (prebuildStarted) return;
-		prebuildStarted = true;
-		prebuilt = generate();
-		await prebuilt;
+		if (!prebuildStarted) {
+			prebuildStarted = true;
+			prebuilt = generate();
+		}
+		const attempt = prebuilt ?? pending;
+		if (!attempt) return;
+		try {
+			await attempt;
+		} catch (error) {
+			if (prebuilt === attempt || prebuilt === void 0 && pending === attempt) {
+				prebuildStarted = false;
+				prebuilt = void 0;
+			}
+			throw error;
+		}
+	};
+	/**
+	* The dev config graph is independent of Builder setup and is needed one hook earlier. Keep
+	* its module load and graph walk single-flight as well: shared plugins may be resolved for
+	* client and SSR concurrently, but both describe the same Vite config.
+	*/
+	const configDependencyLoaders = /* @__PURE__ */ new Map();
+	const discoverConfigDependencies = (root) => {
+		const projectRoot = cwd ?? root;
+		let discover = configDependencyLoaders.get(projectRoot);
+		if (!discover) {
+			const created = createRetryableLazy(async () => {
+				const { findConfig, getConfigDependencies } = await loadConfigModule();
+				return getConfigDependencies(findConfig({
+					cwd: projectRoot,
+					file: configPath
+				})).deps;
+			});
+			configDependencyLoaders.set(projectRoot, created);
+			discover = created;
+		}
+		return discover();
 	};
 	return {
 		name: "bamboocss:css",
@@ -453,7 +338,7 @@ const bamboocssCss = (options) => {
 		* happened once per environment.
 		*/
 		sharedDuringBuild: true,
-		configResolved(config) {
+		async configResolved(config) {
 			command = config.command;
 			session.sourcemap = config.build.sourcemap;
 			ssrBuildOptions = {
@@ -487,10 +372,7 @@ const bamboocssCss = (options) => {
 			* that meant.
 			*/
 			if (config.command === "serve") try {
-				const { deps } = (0, _bamboocss_config.getConfigDependencies)((0, _bamboocss_config.findConfig)({
-					cwd: cwd ?? config.root,
-					file: configPath
-				}));
+				const deps = await discoverConfigDependencies(config.root);
 				config.configFileDependencies.push(...deps);
 			} catch {}
 			if (config.builder && config.environments) session.expectedEnvironments = new Set(Object.keys(config.environments));
@@ -519,2600 +401,153 @@ const bamboocssCss = (options) => {
 			} catch (error) {
 				throw asError(error, `failed to generate ${VIRTUAL_CSS_ID}`);
 			}
-		},
-		resolveId(id) {
-			const query = queryOf(id);
-			const base = id.slice(0, id.length - query.length);
-			if (base !== "virtual:bamboo.css" && base !== RESOLVED_ID) return null;
-			return `${RESOLVED_ID}${query}`;
-		},
-		async load(id) {
-			const query = queryOf(id);
-			if (id.slice(0, id.length - query.length) !== RESOLVED_ID) return null;
-			servedEnvironments.add(this.environment?.name ?? "default");
-			session.cssLoaded = true;
-			let css;
-			try {
-				const first = prebuilt;
-				prebuilt = void 0;
-				css = await (first ?? generate());
-			} catch (error) {
-				throw asError(error, `failed to generate ${VIRTUAL_CSS_ID}`);
-			}
-			if (this.addWatchFile) for (const file of builder.context?.getFiles() ?? []) this.addWatchFile(builder.context.runtime.path.abs(builder.context.config.cwd, file));
-			return css;
-		},
-		configureServer(devServer) {
-			server = devServer;
-			/**
-			* The graph the stylesheet's own module lives in, which is the one that has to reach it.
-			*
-			* `load` registers every extracted file with `addWatchFile`, and `vite:css-analysis`
-			* turns those into real importer edges — the virtual module ends up a direct importer of
-			* each file the extractor read. So an edit to any of them propagates to the stylesheet on
-			* Vite's own pass, in whichever environment holds that edge.
-			*
-			* The client one, because CSS is a client concern: an ssr environment never applies a
-			* stylesheet update, and asking whether *any* environment matched would skip the forced
-			* reload below for a server-only module whose styles the client still has to be told
-			* 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;
-				if (!ctx) return;
-				if (!ctx.getFiles().some((f) => ctx.runtime.path.abs(ctx.config.cwd, f) === file)) return;
-				prebuilt = void 0;
-				const mod = server?.moduleGraph.getModuleById(RESOLVED_ID);
-				if (!mod) return;
-				if (clientGraph.getModulesByFile(file)?.size) return;
-				server?.moduleGraph.invalidateModule(mod);
-				server?.reloadModule(mod);
-				_bamboocss_logger.logger.debug("vite", `styles invalidated by ${file}`);
-			};
-			devServer.watcher.on("change", invalidate);
-			devServer.watcher.on("add", invalidate);
-			devServer.watcher.on("unlink", invalidate);
-		},
-		generateBundle: {
-			order: "post",
-			handler(_, bundle) {
-				const environment = this.environment;
-				/**
-				* Every environment of this run has already had its modules compiled.
-				*
-				* Reachability is what pruning removes rules against, and it is only complete once
-				* nothing is left to contribute to it. The stylesheet is emitted and finalized by the
-				* environment that *imports* it, which in an SSR app is the client — and the client
-				* builds first, before the server environment has transformed a single module. Pruning
-				* there deletes every rule for a class only the server graph reaches, and the pages
-				* link the pruned copy: one project lost 39% of its atoms that way, presenting as
-				* rarely-used classes such as `md:{display:inline-block}` silently not applying.
-				*
-				* So the full extracted stylesheet ships instead, which is what `pruneCss: false` asks
-				* for by hand. Being the last environment is not the common case — frameworks build the
-				* client first — but it is the only one where the answer is knowable, and a framework
-				* that builds its server bundle first does get pruned output.
-				*/
-				const pending = remainingEnvironments(session);
-				const { sheets } = optimizeStaticCssAssets(bundle, session, {
-					prune: pruneCss && pending.length === 0,
-					sourcemap: environment?.config?.build?.sourcemap
-				});
-				if (sheets && !pruneCss) _bamboocss_logger.logger.info("vite", "Reachability pruning is off (`pruneCss: false`). The full extracted stylesheet ships.");
-				else if (sheets && pending.length) _bamboocss_logger.logger.info("vite", `Reachability pruning skipped: the stylesheet is emitted by the ${JSON.stringify(environment?.name ?? "default")} environment, and ${(0, _bamboocss_shared.truncateList)(pending, {
-					unit: "environment",
-					separator: ", "
-				})} ${pending.length === 1 ? "has" : "have"} not been compiled in this run. The full extracted stylesheet ships — nothing is missing from it.`);
-				if (!servedEnvironments.has(environment?.name ?? "default")) return;
-				if (!session.transformedFiles.size) return;
-				/**
-				* An SSR bundle emits no CSS assets, and is not supposed to.
-				*
-				* `build.ssrEmitAssets` is off by default, so Vite discards them: the client build is
-				* what carries the stylesheet, and a server bundle that imports `virtual:bamboo.css`
-				* from shared code — a root component, a layout — still asks this plugin to load it.
-				* Which means the environment *served* the sheet and then emitted nothing, and the
-				* check below read that as the failure it exists to catch.
-				*
-				* It fails a build that is entirely correct. Qwik's `vite build --ssr` is the shape
-				* that showed it: 7/7 calls compiled, the client bundle carrying the stylesheet, and
-				* the server bundle refusing to finish. React Router does not hit it only because its
-				* plugin turns `ssrEmitAssets` on.
-				*
-				* Read per environment where that exists, falling back to the run's own config, so
-				* Vite 5's single-config builds are answered by the same question.
-				*/
-				const buildOptions = environment?.config?.build ?? ssrBuildOptions;
-				if (buildOptions?.ssr && !buildOptions.ssrEmitAssets) return;
-				if (!Object.values(bundle).some((output) => {
-					if (!carriesGeneratedCss(output)) return false;
-					return (typeof output.source === "string" ? output.source : Buffer.from(output.source).toString()).includes("--made-with-bamboo");
-				})) throw new Error(`bamboocss: ${session.transformedFiles.size} module(s) were compiled to Bamboo class values, but no emitted asset carries the generated stylesheet. The build would ship unstyled.\n\nThis happens when another plugin, or the bundler itself, drops or replaces the CSS asset after it is emitted. If you are on Rolldown, report this — the rename that used to cause it is already disabled there. Otherwise look for a plugin running in \`generateBundle\` that rewrites CSS assets.`);
-			}
-		}
-	};
-};
-//#endregion
-//#region src/fold-analysis.ts
-/**
-* Nodes that *compose* a value out of their children rather than computing one.
-*
-* The boundary of the walk below, and the whole of its precision. Climbing through these
-* keeps a value's provenance: `'red.300'` inside `{ color: 'red.300' }` inside a default is
-* still the default's. Anything else — a call, a function body, a JSX element — produces its
-* value by being evaluated, so what is written inside it is an argument to that evaluation
-* and not the enclosing default's value.
-*
-* Without the boundary, `({ cls = css({ color: 'red.300' }) }) => cls` is rejected: the call's
-* own literal argument is syntactically inside a default, so an unbounded walk calls it one.
-* That is correct code, and rejecting it fails the build.
-*/
-const composesValue = (node) => ts_morph.Node.isObjectLiteralExpression(node) || ts_morph.Node.isArrayLiteralExpression(node) || ts_morph.Node.isPropertyAssignment(node) || ts_morph.Node.isShorthandPropertyAssignment(node) || ts_morph.Node.isSpreadAssignment(node) || ts_morph.Node.isSpreadElement(node) || ts_morph.Node.isAsExpression(node) || ts_morph.Node.isParenthesizedExpression(node) || ts_morph.Node.isNonNullExpression(node) || ts_morph.Node.isTypeAssertion(node) || ts_morph.Node.isSatisfiesExpression(node);
-/** Is `inner` written within `outer`? Positions rather than a walk, so it is O(1). */
-const contains = (outer, inner) => outer.getSourceFile() === inner.getSourceFile() && outer.getStart() <= inner.getStart() && inner.getEnd() <= outer.getEnd();
-/**
-* Did this value come from the `= …` of a destructuring binding?
-*
-* `const { tone = 'red.300' } = source` boxes as the literal `'red.300'`: the extractor's
-* `maybeDefinitionValue` tests for an initializer first and returns the boxed default, never
-* reaching the branch that would read `source`. So the default is reported as the value whether
-* or not it is the one that applies.
-*
-* For extraction that is merely optimistic, and deliberately so: a CLI or PostCSS build ships a
-* runtime `css()`, where the default genuinely does apply when the caller omits the key, and it
-* needs a rule behind it. Folding is where the same resolution turns into a wrong answer,
-* because the call is *replaced* by that value.
-*
-* Stops at the first non-composing parent, so a call written inside a default keeps its own
-* provenance, and checks that the binding element was reached through its initializer, so
-* `{ tone = X }`'s name node is not mistaken for its default.
-*/
-const isBindingElementDefault = (node) => {
-	if (node && ts_morph.Node.isCallExpression(node)) return false;
-	let current = node;
-	while (current) {
-		const parent = current.getParent();
-		if (!parent) return false;
-		if (ts_morph.Node.isBindingElement(parent)) return parent.getInitializer() === current;
-		if (!composesValue(parent)) return false;
-		current = parent;
-	}
-	return false;
-};
-/**
-* The same question asked of a whole box, including how it was resolved.
-*
-* The node a box reports is not always the one its value came from — an empty `{}` default
-* boxes against the call rather than against the `{}` — so the resolution stack is consulted
-* too. A binding element reaches that stack by having been resolved *through*, which is the
-* signal the extractor itself reads when one of these is a conditional's test.
-*
-* Only the entries that are binding elements are examined. Walking up from every other entry
-* was tried and never once changed a verdict across the default spellings or the sandbox's own
-* modules, while accounting for most of the parent hops this does — the stack carries nodes
-* that were never resolved through, including a call's own arguments, so walking from them is
-* both the expensive half and the one that reaches conclusions it has no basis for.
-*
-* A binding element without an initializer carries no default to mistrust: `const { tone } =
-* source` either resolves from `source` or does not resolve at all.
-*/
-const isFromBindingDefault = (node) => {
-	const own = node.getNode?.();
-	if (isBindingElementDefault(own)) return true;
-	for (const entry of node.getStack?.() ?? []) {
-		if (!ts_morph.Node.isBindingElement(entry) || !entry.getInitializer()) continue;
-		if (own && contains(entry, own)) continue;
-		return true;
-	}
-	return false;
-};
-/**
-* Statically resolvable means: every box in the tree carries a known value.
-*
-* `unresolvable` is the extractor saying it could not evaluate a node.
-* `conditional` is a ternary — two possible values, so there is no single string to
-* fold to. `box.fallback` produces an object with no `type` at all, which is likewise
-* not something we can trust.
-*/
-const isStaticBox = (node, seen = /* @__PURE__ */ new Set()) => {
-	if (!node) return false;
-	if (seen.has(node)) return true;
-	seen.add(node);
-	if (_bamboocss_extractor.box.isUnresolvable(node) || _bamboocss_extractor.box.isConditional(node)) return false;
-	if (!("type" in node) || node.type == null) return false;
-	if (isFromBindingDefault(node)) return false;
-	if (_bamboocss_extractor.box.isLiteral(node) && node.value === void 0) {
-		const source = node.getNode?.();
-		return Boolean(source && ts_morph.Node.isIdentifier(source) && source.getText() === "undefined");
-	}
-	if (_bamboocss_extractor.box.isMap(node)) {
-		for (const child of node.value.values()) if (!isStaticBox(child, seen)) return false;
-		return true;
-	}
-	if (_bamboocss_extractor.box.isArray(node)) {
-		for (const child of node.value) if (!isStaticBox(child, seen)) return false;
-		return true;
-	}
-	return true;
-};
-/**
-* Strip the wrappers the extractor strips before it builds a box, so the source node
-* compared against a box is the same node the box was built from.
-*
-* A local copy of the extractor's `unwrapExpression`, which is not part of its public
-* surface. Recognising fewer wrappers than it does is not a cosmetic difference: an
-* unrecognised one leaves an object literal wrapped, and the object checks below skip it.
-*/
-const unwrapExpression = (node) => ts_morph.Node.isAsExpression(node) || ts_morph.Node.isParenthesizedExpression(node) || ts_morph.Node.isNonNullExpression(node) || ts_morph.Node.isTypeAssertion(node) || ts_morph.Node.isSatisfiesExpression(node) ? unwrapExpression(node.getExpression()) : node;
-/**
-* Mirrors the parser's evaluator environment, so re-boxing an operand here gets the same
-* answer the extraction did. Left to its default, ts-evaluator presets to `NODE` and
-* would resolve expressions the parser cannot see — making this check *more* permissive
-* than the extraction it is auditing, which is the one thing it must never be.
-*/
-const REBOXED = { getEvaluateOptions: () => ({ environment: { preset: "ECMA" } }) };
-const rebox = (node) => (0, _bamboocss_extractor.maybeBoxNode)(unwrapExpression(node), [], REBOXED);
-/**
-* Did this operand resolve to a value the program will actually produce?
-*
-* Producing a box is not enough when the operand is itself a choice: `a || b || c` parses
-* as `(a || b) || c`, so the outer operator is handed whatever the inner one answered —
-* including an arm the extractor invented. Asking only "is there a box" reads that
-* invention as an ordinary literal.
-*/
-const resolvesExactly = (node) => {
-	const inner = unwrapExpression(node);
-	if (!rebox(inner)) return false;
-	return ts_morph.Node.isConditionalExpression(inner) || isCollapsedBinary(inner) ? decidedAtBuildTime(inner) : true;
-};
-/**
-* Is this operand's value written here, rather than named?
-*
-* A box records what the extractor resolved a name *through* — a `let`'s initializer, a
-* parameter's default — none of which is what the operand holds when the call runs.
-* `let m = '1'; m = undefined` still boxes as `'1'`, and `({ c = 'red.300' })` still boxes
-* as `'red.300'` for a caller that passed something else. Only a value written at the call
-* site is what it appears to be, so only that can be judged truthy or nullish here.
-*/
-const isWrittenHere = (node) => {
-	const inner = unwrapExpression(node);
-	return ts_morph.Node.isStringLiteral(inner) || ts_morph.Node.isNumericLiteral(inner) || ts_morph.Node.isNoSubstitutionTemplateLiteral(inner) || ts_morph.Node.isObjectLiteralExpression(inner) || ts_morph.Node.isArrayLiteralExpression(inner) || ts_morph.Node.isTrueLiteral(inner) || ts_morph.Node.isFalseLiteral(inner) || inner.getKind() === ts_morph.SyntaxKind.NullKeyword || ts_morph.Node.isPrefixUnaryExpression(inner) && ts_morph.Node.isNumericLiteral(inner.getOperand());
-};
-/** An inline value's truthiness, which its box carries directly. */
-const isTruthy = (boxNode) => _bamboocss_extractor.box.isLiteral(boxNode) ? Boolean(boxNode.value) : _bamboocss_extractor.box.isMap(boxNode) || _bamboocss_extractor.box.isArray(boxNode) || _bamboocss_extractor.box.isObject(boxNode);
-/**
-* Did the extractor *decide* this choice, or guess at it?
-*
-* `a ? b : c`, `a || b` and `a && b` are asked "what styles could this produce", and when
-* one arm does not evaluate the extractor answers with the other rather than refusing
-* (`maybe-box-node.ts`, `whenTrueValue && !whenFalseValue`). That is right for generating
-* CSS — emit rules for whatever might be used — and wrong for rewriting source, where the
-* arm it kept becomes the only one that runs.
-*
-* For a ternary the tell is the arms: it guessed exactly when one produced a box and the
-* other did not. For a short-circuit the answer is always the left operand, so what has to
-* be established is that the left is the side that wins.
-*/
-const decidedAtBuildTime = (node) => {
-	if (ts_morph.Node.isConditionalExpression(node)) return resolvesExactly(node.getWhenTrue()) && resolvesExactly(node.getWhenFalse());
-	const operator = node.getOperatorToken().getKind();
-	if (!SHORT_CIRCUIT.includes(operator)) return false;
-	if (!isWrittenHere(node.getLeft())) return false;
-	const left = rebox(node.getLeft());
-	if (!left) return false;
-	if (operator === ts_morph.SyntaxKind.BarBarToken) return isTruthy(left);
-	if (operator === ts_morph.SyntaxKind.QuestionQuestionToken) return !_bamboocss_extractor.box.isLiteral(left) || left.value != null;
-	return isTruthy(left) ? resolvesExactly(node.getRight()) : true;
-};
-const SHORT_CIRCUIT = [
-	ts_morph.SyntaxKind.AmpersandAmpersandToken,
-	ts_morph.SyntaxKind.BarBarToken,
-	ts_morph.SyntaxKind.QuestionQuestionToken
-];
-/**
-* Every binary form the extractor collapses to one operand — the short-circuits plus the
-* comparisons, which `isLogicalSyntax` sends down the same path even though their value is
-* a boolean rather than either side.
-*
-* Hoisted rather than built per call: `accountsForSource` asks this for every property of
-* every candidate, and rebuilding a thirteen-element list each time is not free.
-*/
-const COLLAPSED_BINARY = new Set([
-	...SHORT_CIRCUIT,
-	ts_morph.SyntaxKind.EqualsEqualsToken,
-	ts_morph.SyntaxKind.EqualsEqualsEqualsToken,
-	ts_morph.SyntaxKind.ExclamationEqualsToken,
-	ts_morph.SyntaxKind.ExclamationEqualsEqualsToken,
-	ts_morph.SyntaxKind.GreaterThanToken,
-	ts_morph.SyntaxKind.GreaterThanEqualsToken,
-	ts_morph.SyntaxKind.LessThanToken,
-	ts_morph.SyntaxKind.LessThanEqualsToken,
-	ts_morph.SyntaxKind.InKeyword,
-	ts_morph.SyntaxKind.InstanceOfKeyword
-]);
-const isCollapsedBinary = (node) => ts_morph.Node.isBinaryExpression(node) && COLLAPSED_BINARY.has(node.getOperatorToken().getKind());
-/**
-* Does the extracted box account for every property the source declares?
-*
-* `isStaticBox` is not sufficient on its own. The extractor *omits* what it cannot
-* evaluate rather than marking it unresolvable, so `css({ color: 'red.300', ...rest })`
-* yields a perfectly static-looking map holding only `color`. Folding that produces
-* `"c_red.300"` and silently drops everything `rest` contributed.
-*
-* So the source is the authority on what the call contains, and anything the box does
-* not account for disqualifies the fold:
-*
-* - a declared property missing from the map (its value did not evaluate)
-* - a computed key, which we cannot match against the map by name
-* - a spread, unless it is an inline object literal
-*
-* Spreads are the conservative case. `{ ...base }` where `base` is a static local
-* object *is* resolved by the extractor, but a resolved spread and an unresolved one
-* are indistinguishable once flattened into the map — both just contribute keys, or
-* fail to. Rather than guess and erase evaluation the compiler cannot reproduce, the call
-* is rejected.
-*/
-/**
-* What a property's value is written as. A shorthand names it, so the name *is* the
-* expression — reading an initializer that is not there reports the property as having no
-* source, and everything hidden behind the name goes unchecked.
-*/
-const valueOf = (property) => ts_morph.Node.isPropertyAssignment(property) ? property.getInitializer() : ts_morph.Node.isShorthandPropertyAssignment(property) ? property.getNameNode() : void 0;
-const accountsForSource = (node, boxNode) => {
-	if (!node) return true;
-	const unwrapped = unwrapExpression(node);
-	if ((ts_morph.Node.isConditionalExpression(unwrapped) || isCollapsedBinary(unwrapped)) && !_bamboocss_extractor.box.isConditional(boxNode) && !decidedAtBuildTime(unwrapped)) return false;
-	if (ts_morph.Node.isArrayLiteralExpression(unwrapped)) {
-		if (!_bamboocss_extractor.box.isArray(boxNode)) return false;
-		const elements = unwrapped.getElements();
-		if (elements.length !== boxNode.value.length) return false;
-		return elements.every((element, index) => accountsForSource(element, boxNode.value[index]));
-	}
-	if (!ts_morph.Node.isObjectLiteralExpression(unwrapped)) {
-		const origin = _bamboocss_extractor.box.isMap(boxNode) ? boxNode.getNode() : void 0;
-		return !origin || origin === unwrapped || !ts_morph.Node.isObjectLiteralExpression(origin) ? true : accountsForSource(origin, boxNode);
-	}
-	if (!_bamboocss_extractor.box.isMap(boxNode)) return false;
-	for (const property of unwrapped.getProperties()) {
-		if (ts_morph.Node.isSpreadAssignment(property)) {
-			const expression = unwrapExpression(property.getExpression());
-			if (ts_morph.Node.isObjectLiteralExpression(expression)) continue;
-			const walked = boxNode.resolvedSpreads?.find((entry) => entry.node === expression);
-			if (!walked) return false;
-			if (!accountsForSource(walked.box.getNode(), walked.box)) return false;
-			continue;
-		}
-		if (ts_morph.Node.isMethodDeclaration(property) || ts_morph.Node.isGetAccessorDeclaration(property) || ts_morph.Node.isSetAccessorDeclaration(property)) return false;
-		if (!ts_morph.Node.isPropertyAssignment(property) && !ts_morph.Node.isShorthandPropertyAssignment(property)) return false;
-		const nameNode = property.getNameNode();
-		if (ts_morph.Node.isComputedPropertyName(nameNode)) return false;
-		const key = ts_morph.Node.isStringLiteral(nameNode) || ts_morph.Node.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
-		const value = valueOf(property);
-		if (value && ts_morph.Node.isIdentifier(value) && value.getText() === "undefined") continue;
-		if (!boxNode.value.has(key)) return false;
-		if (!accountsForSource(value, boxNode.value.get(key))) return false;
-	}
-	return true;
-};
-/**
-* Memo keyed on a file, thrown away when its text is replaced.
-*
-* A plain `WeakMap<SourceFile, …>` is wrong here: ts-morph reuses the wrapper when a path
-* is re-added with new text — which is what a watch rebuild does — so it would answer for
-* the previous revision. Comparing against the text it was computed from costs a
-* reference check while the file is unchanged, since `getFullText()` hands back the same
-* string instance.
-*/
-const byText = (cache, sourceFile, compute) => {
-	const text = sourceFile.getFullText();
-	const hit = cache.get(sourceFile);
-	if (hit && hit.text === text) return hit.value;
-	const value = compute();
-	cache.set(sourceFile, {
-		text,
-		value
-	});
-	return value;
-};
-/**
-* Every name declared at module scope, which is what an added import could collide with.
-*
-* This replaced `sourceFile.getLocals()`. That was precise, but it goes through the
-* compiler's symbol table, and reaching for it binds the program — including every
-* `.d.ts` the module's imports pull in. It cost ~8ms on a ten-line file and grew with the
-* project, which was invisible while only a partial split reached it and became the
-* dominant cost once open-ended values started lowering too.
-*
-* A syntactic walk answers the same question: a binding in a nested *function* cannot
-* collide with a module-scope import, and one that shadows it *at the call site* is what
-* `isShadowed` is for. Memoized against the file's text rather than the file, since
-* ts-morph reuses the wrapper across a re-add and a plain `WeakMap` would answer for the
-* previous revision. Uncached it is re-walked per candidate, which is quadratic in a
-* module of many elements.
-*/
-const moduleScopeCache = /* @__PURE__ */ new WeakMap();
-const declaredAtModuleScope = (sourceFile) => byText(moduleScopeCache, sourceFile, () => collectModuleScopeNames(sourceFile));
-const collectModuleScopeNames = (sourceFile) => {
-	const names = /* @__PURE__ */ new Set();
-	const addBinding = (node) => {
-		if (!node) return;
-		if (ts_morph.Node.isObjectBindingPattern(node) || ts_morph.Node.isArrayBindingPattern(node)) {
-			for (const element of node.getElements()) if (ts_morph.Node.isBindingElement(element)) addBinding(element.getNameNode());
-			return;
-		}
-		if (ts_morph.Node.isIdentifier(node)) names.add(node.getText());
-	};
-	const addDeclarations = (list) => {
-		if (ts_morph.Node.isVariableStatement(list)) {
-			for (const declaration of list.getDeclarations()) addBinding(declaration.getNameNode());
-			return;
-		}
-		if (ts_morph.Node.isVariableDeclarationList(list)) for (const declaration of list.getDeclarations()) addBinding(declaration.getNameNode());
-	};
-	const isVar = (node) => (ts_morph.Node.isVariableStatement(node) || ts_morph.Node.isVariableDeclarationList(node)) && node.getDeclarationKind() === ts_morph.VariableDeclarationKind.Var;
-	/**
-	* `var` is scoped to the enclosing *function*, not the enclosing block, so one written
-	* inside any statement at the top level still binds at module scope. Walking only the
-	* top-level statements missed every one of them, and each emitted a duplicate binding.
-	*
-	* Only statement containers are followed. A function or class body opens a new variable
-	* scope, so a `var` inside one cannot collide with a module-level import.
-	*/
-	const addHoistedVars = (node) => {
-		if (isVar(node)) {
-			addDeclarations(node);
-			return;
-		}
-		if (ts_morph.Node.isBlock(node)) {
-			for (const statement of node.getStatements()) addHoistedVars(statement);
-			return;
-		}
-		if (ts_morph.Node.isIfStatement(node)) {
-			addHoistedVars(node.getThenStatement());
-			const otherwise = node.getElseStatement();
-			if (otherwise) addHoistedVars(otherwise);
-			return;
-		}
-		if (ts_morph.Node.isForStatement(node)) {
-			const initializer = node.getInitializer();
-			if (initializer) addHoistedVars(initializer);
-			addHoistedVars(node.getStatement());
-			return;
-		}
-		if (ts_morph.Node.isForInStatement(node) || ts_morph.Node.isForOfStatement(node)) {
-			addHoistedVars(node.getInitializer());
-			addHoistedVars(node.getStatement());
-			return;
-		}
-		if (ts_morph.Node.isWhileStatement(node) || ts_morph.Node.isDoStatement(node) || ts_morph.Node.isWithStatement(node)) {
-			addHoistedVars(node.getStatement());
-			return;
-		}
-		if (ts_morph.Node.isLabeledStatement(node)) {
-			addHoistedVars(node.getStatement());
-			return;
-		}
-		if (ts_morph.Node.isTryStatement(node)) {
-			addHoistedVars(node.getTryBlock());
-			const caught = node.getCatchClause();
-			if (caught) addHoistedVars(caught.getBlock());
-			const finally_ = node.getFinallyBlock();
-			if (finally_) addHoistedVars(finally_);
-			return;
-		}
-		if (ts_morph.Node.isSwitchStatement(node)) for (const clause of node.getCaseBlock().getClauses()) for (const statement of clause.getStatements()) addHoistedVars(statement);
-	};
-	for (const statement of sourceFile.getStatements()) {
-		if (ts_morph.Node.isVariableStatement(statement)) {
-			addDeclarations(statement);
-			continue;
-		}
-		if (ts_morph.Node.isImportDeclaration(statement)) {
-			addBinding(statement.getDefaultImport());
-			addBinding(statement.getNamespaceImport());
-			for (const named of statement.getNamedImports()) addBinding(named.getAliasNode() ?? named.getNameNode());
-			continue;
-		}
-		if (ts_morph.Node.isImportEqualsDeclaration(statement)) {
-			addBinding(statement.getNameNode());
-			continue;
-		}
-		if (ts_morph.Node.isFunctionDeclaration(statement) || ts_morph.Node.isClassDeclaration(statement) || ts_morph.Node.isEnumDeclaration(statement) || ts_morph.Node.isModuleDeclaration(statement) || ts_morph.Node.isTypeAliasDeclaration(statement) || ts_morph.Node.isInterfaceDeclaration(statement)) {
-			addBinding(statement.getNameNode());
-			continue;
-		}
-		addHoistedVars(statement);
-	}
-	return names;
-};
-/**
-* Every identifier in the module, grouped by the name it spells.
-*
-* Built once per pass and handed to each lookup, because walking the whole tree per binding
-* made that O(bindings x identifiers): a module declaring ten recipes walked its identifiers
-* ten times.
-*
-* ## Why this is a raw walk rather than `getDescendantsOfKind`
-*
-* `SyntaxKind.Identifier` sorts *below* `SyntaxKind.FirstNode`, which is what ts-morph tests to
-* decide whether it may search the parse tree. For a kind below that line it falls back to
-* materialising the whole **token** tree — every brace, comma and keyword becomes a ts-morph node
-* on the way to collecting the identifiers. On 55 KB of real tsx that measured 22ms against
-* 0.22ms for the same collection over compiler nodes, and the node cache does not help: a second
-* call cost the same 22ms.
-*
-* Wrapping is what costs, so only the buckets a caller actually reads are wrapped, on the first
-* read and cached after. Nothing enumerates this index — both callers ask for one name — so the
-* rest is never built. `_getNodeFromCompilerNode` is ts-morph's own memoized wrapper factory, so
-* a node handed back here is the very object `getDescendantsOfKind` would have returned, which
-* `localReferencesTo` depends on: it compares against the declaration by identity.
-*
-* JSDoc is walked explicitly. `ts.forEachChild` does not descend into it, while the token path
-* this replaces does, so a name mentioned only in a `@type` annotation was previously found and
-* would otherwise stop being — a silent narrowing of what counts as a surviving reference.
-* Keyed on `escapedText` because that is what ts-morph's `Identifier.getText()` returns: the name
-* as the compiler resolves it, so `\u0062adge` and `badge` share a bucket exactly as before.
-*
-* Deliberately *not* memoized across passes, unlike the module-scope names beside it. That
-* cache holds strings, which outlive anything; this one holds nodes, and a node does not
-* survive its source file being replaced — `addSourceFile` overwrites, which forgets every
-* node previously taken from it. Keying on the source text does not help, because identical
-* text re-parsed is a fresh tree: the cache hits and returns nodes that throw
-* `Attempted to get information from a node that was removed or forgotten` on the next read.
-*/
-const identifierIndex = (sourceFile) => {
-	const compilerNodes = /* @__PURE__ */ new Map();
-	const collect = (node) => {
-		if (node.kind === ts_morph.ts.SyntaxKind.Identifier) {
-			const name = String(node.escapedText);
-			const known = compilerNodes.get(name);
-			if (known) known.push(node);
-			else compilerNodes.set(name, [node]);
-		}
-		const jsDoc = node.jsDoc;
-		if (jsDoc) for (const doc of jsDoc) collect(doc);
-		ts_morph.ts.forEachChild(node, collect);
-	};
-	ts_morph.ts.forEachChild(sourceFile.compilerNode, collect);
-	const wrapped = /* @__PURE__ */ new Map();
-	const wrap = sourceFile;
-	return { get: (name) => {
-		const known = wrapped.get(name);
-		if (known) return known;
-		const nodes = (compilerNodes.get(name) ?? []).map((node) => wrap._getNodeFromCompilerNode(node));
-		wrapped.set(name, nodes);
-		return nodes;
-	} };
-};
-const localReferencesTo = (index, name, declaration) => {
-	const references = [];
-	for (const identifier of index.get(name)) {
-		if (identifier === declaration) continue;
-		const parent = identifier.getParent();
-		if (!parent) continue;
-		if (ts_morph.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === identifier) continue;
-		if (ts_morph.Node.isPropertyAssignment(parent) && parent.getNameNode() === identifier) continue;
-		if (ts_morph.Node.isBindingElement(parent) && parent.getPropertyNameNode() === identifier) continue;
-		if ((ts_morph.Node.isJsxOpeningElement(parent) || ts_morph.Node.isJsxSelfClosingElement(parent) || ts_morph.Node.isJsxClosingElement(parent)) && parent.getTagNameNode() === identifier) continue;
-		if (ts_morph.Node.isJsxAttribute(parent) && parent.getNameNode() === identifier) continue;
-		if ((ts_morph.Node.isMethodDeclaration(parent) || ts_morph.Node.isPropertyDeclaration(parent) || ts_morph.Node.isGetAccessorDeclaration(parent) || ts_morph.Node.isSetAccessorDeclaration(parent) || ts_morph.Node.isMethodSignature(parent) || ts_morph.Node.isPropertySignature(parent) || ts_morph.Node.isEnumMember(parent)) && parent.getNameNode() === identifier) continue;
-		if ((ts_morph.Node.isVariableDeclaration(parent) || ts_morph.Node.isParameterDeclaration(parent) || ts_morph.Node.isFunctionDeclaration(parent) || ts_morph.Node.isClassDeclaration(parent) || ts_morph.Node.isBindingElement(parent)) && parent.getNameNode() === identifier) continue;
-		if (ts_morph.Node.isImportSpecifier(parent) || ts_morph.Node.isExportSpecifier(parent)) {
-			if (parent.getNameNode() !== identifier) continue;
-			if (ts_morph.Node.isExportSpecifier(parent)) {
-				references.push(identifier);
-				continue;
-			}
-			continue;
-		}
-		references.push(identifier);
-	}
-	return references;
-};
-//#endregion
-//#region src/fold-recipe.ts
-/**
-* Binding name → the config it was declared with.
-*
-* Built from the definitions the parser already recorded, walking each one to the declaration
-* that names it. The parser records a definition under the name it was *imported* as (`cva`),
-* and a call under the name the file *bound* (`badge`); this is what joins the two.
-*
-* Slot and ordinary recipes share one representation.
-*/
-const collectRecipeConfigs = (parserResult) => {
-	const configs = /* @__PURE__ */ new Map();
-	const definitions = [...parserResult.cva, ...parserResult.sva];
-	for (const definition of definitions) {
-		const node = definition.box?.getNode?.();
-		if (!node) continue;
-		const nameNode = ((ts_morph.Node.isCallExpression(node) ? node : node.getFirstAncestorByKind(ts_morph.SyntaxKind.CallExpression))?.getFirstAncestorByKind(ts_morph.SyntaxKind.VariableDeclaration))?.getNameNode();
-		if (!nameNode || !ts_morph.Node.isIdentifier(nameNode)) continue;
-		if (definition.data?.length !== 1) {
-			configs.set(nameNode.getText(), AMBIGUOUS);
-			continue;
-		}
-		const config = definition.data[0];
-		if (!config || typeof config !== "object") continue;
-		if (configs.has(nameNode.getText())) {
-			configs.set(nameNode.getText(), AMBIGUOUS);
-			continue;
-		}
-		configs.set(nameNode.getText(), {
-			config,
-			box: definition.box
-		});
-	}
-	return configs;
-};
-/** Pick a complete precompiled StyleSet for one or more runtime recipe axes. */
-const RECIPE_MAP_HELPER = "cvaMap";
-/** Guard the exact compiler against accidentally materialising an enormous Cartesian product. */
-const DEFAULT_MAX_RECIPE_STATES = 65536;
-/** What `recipe.splitVariantProps` calls, reached directly once the call is lowered. */
-const SPLIT_PROPS_HELPER = "splitProps";
-/** Marker for a binding the fold must never resolve — declared twice, or unresolvable. */
-const AMBIGUOUS = Object.freeze({
-	config: {},
-	box: void 0
-});
-/** `.size`, or `["x-large"]` when the variant is not a valid identifier. */
-const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
-const propertyAccess = (key) => IDENTIFIER.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
-const LITERAL_KINDS = new Set([
-	ts_morph.SyntaxKind.StringLiteral,
-	ts_morph.SyntaxKind.NoSubstitutionTemplateLiteral,
-	ts_morph.SyntaxKind.NumericLiteral,
-	ts_morph.SyntaxKind.TrueKeyword,
-	ts_morph.SyntaxKind.FalseKeyword
-]);
-/**
-* The value a literal node denotes, or `undefined` for anything else.
-*
-* Read off the node rather than from the extractor's resolved data, because that data is lossy
-* in the direction that matters: a property it could not resolve is *dropped*, so `badge({ tone })`
-* and `badge({})` are identical there. Folding the first as if it were the second emits a class
-* string missing the variant — the element renders, wrongly, with no report.
-*/
-const literalValue = (node) => {
-	if (!node || !LITERAL_KINDS.has(node.getKind())) return void 0;
-	if (ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNoSubstitutionTemplateLiteral(node)) return node.getLiteralValue();
-	if (ts_morph.Node.isNumericLiteral(node)) return node.getLiteralValue();
-	if (node.getKind() === ts_morph.SyntaxKind.TrueKeyword) return true;
-	if (node.getKind() === ts_morph.SyntaxKind.FalseKeyword) return false;
-};
-/**
-* The property name a key node denotes.
-*
-* Read off the node rather than unquoted from its text. `{ '\\u0074one': 'a' }` names the
-* variant `tone`, and stripping the surrounding quotes leaves the escape uninterpreted — so
-* the variant did not match, its class was dropped, and the element rendered without it. A
-* numeric key normalises the same way: `{ 0x10: 'a' }` is the key `16`.
-*/
-const propertyKey = (nameNode) => {
-	if (ts_morph.Node.isIdentifier(nameNode)) return nameNode.getText();
-	if (ts_morph.Node.isStringLiteral(nameNode) || ts_morph.Node.isNoSubstitutionTemplateLiteral(nameNode)) return nameNode.getLiteralValue();
-	if (ts_morph.Node.isNumericLiteral(nameNode)) return String(nameNode.getLiteralValue());
-};
-/**
-* Make a generated compile helper callable at this call site, by whatever name the file gives it.
-*
-* Unlike `cx`, an inline recipe's callee is a local binding, so
-* there is nothing to match — the host here is any import of the generated css module, which
-* a file defining a recipe necessarily has, since `cva` came from it.
-*/
-const ensureRecipeHelperImport = (imported, call, isBambooCssModule, isGeneratedCssModule, isShadowed, newImportModule, helperModuleFromSubpath) => {
-	const sourceFile = call.getSourceFile();
-	let host;
-	let subpathModule;
-	for (const declaration of sourceFile.getImportDeclarations()) {
-		const mod = declaration.getModuleSpecifierValue();
-		if (declaration.isTypeOnly()) continue;
-		for (const named of declaration.getNamedImports()) {
-			if (named.isTypeOnly()) continue;
-			if (named.getNameNode().getText() === imported) {
-				if (!isBambooCssModule(mod)) return void 0;
-				const local = (named.getAliasNode() ?? named.getNameNode()).getText();
-				return isShadowed(call, local) ? void 0 : { name: local };
-			}
-		}
-		if (!host && isGeneratedCssModule(mod) && declaration.getNamedImports().length > 0) host = declaration;
-		if (!subpathModule) subpathModule = helperModuleFromSubpath?.(mod);
-	}
-	const fallbackModule = newImportModule ?? subpathModule;
-	if (!host && !fallbackModule) return void 0;
-	if (declaredAtModuleScope(sourceFile).has(imported)) return void 0;
-	if (isShadowed(call, imported)) return void 0;
-	if (!host) {
-		const anchor = sourceFile.getImportDeclarations().at(-1);
-		if (!anchor) return void 0;
-		return {
-			name: imported,
-			insert: {
-				pos: anchor.getEnd(),
-				names: [imported],
-				module: fallbackModule
-			}
-		};
-	}
-	const last = host.getNamedImports().at(-1);
-	if (!last) return void 0;
-	return {
-		name: imported,
-		insert: {
-			pos: last.getEnd(),
-			names: [imported]
-		}
-	};
-};
-/**
-* Lower one invocation, or say why not.
-*
-* Every property written at the call site has to be a literal. A selection is not additive —
-* an unresolved variant does not merely omit a class, it can change which of several the
-* recipe applies — so a partially-known selection is not foldable at all.
-*/
-const lowerRecipeCall = (call, entry, styleCompiler, isInert, resolvedSelection, slot, maxRecipeStates = DEFAULT_MAX_RECIPE_STATES) => {
-	if (!entry || entry === AMBIGUOUS) return {
-		kind: "decline",
-		reason: "unknown-recipe"
-	};
-	const { config } = entry;
-	if (config.slots !== void 0) {
-		if (!Array.isArray(config.slots) || slot !== void 0 && !config.slots.includes(slot)) return {
-			kind: "decline",
-			reason: "unsupported-shape"
-		};
-	} else if (slot) return {
-		kind: "decline",
-		reason: "unsupported-shape"
-	};
-	if (!config.base && !config.variants && !config.className) return {
-		kind: "decline",
-		reason: "unknown-recipe"
-	};
-	if (!ts_morph.Node.isCallExpression(call)) return {
-		kind: "decline",
-		reason: "unsupported-shape"
-	};
-	const args = call.getArguments();
-	if (args.length > 1) return {
-		kind: "decline",
-		reason: "unsupported-shape"
-	};
-	const selection = {};
-	/** Variant → the source expression selecting it, for axes that stay runtime decisions. */
-	const dynamicAxes = /* @__PURE__ */ new Map();
-	/**
-	* Variants whose expression could run something, in the order the source evaluates them.
-	*
-	* The text is kept, not just the key: a later property writing the same key replaces the
-	* entry in `dynamicAxes`, and the expression recorded here would then never be emitted.
-	*/
-	const effectful = [];
-	if (args.length === 1) {
-		const arg = args[0];
-		if (!arg) return {
-			kind: "decline",
-			reason: "dynamic"
-		};
-		/**
-		* `input(variantProps)` — a selection the build cannot see inside.
-		*
-		* The compiled recipe contract accepts scalar declared variant values. A conditional
-		* object is not a finite selection value; responsiveness belongs inside a variant's style
-		* declaration, where the compiler can materialize its conditions ahead of time.
-		*
-		* The complete StyleSets are knowable: the config declares every scalar value each axis
-		* accepts. This is the shape a wrapper component takes, where variants are its public API
-		* and therefore cannot be literals by definition.
-		*
-		* An identifier only. Each variant reads the binding again, and re-reading anything else —
-		* a call, a property access — would evaluate it once per axis instead of once.
-		*/
-		if (ts_morph.Node.isIdentifier(arg)) {
-			const binding = arg.getText();
-			for (const key of Object.keys(config.variants ?? {})) dynamicAxes.set(key, `${binding}${propertyAccess(key)}`);
-		} else if (!ts_morph.Node.isObjectLiteralExpression(arg)) return {
-			kind: "decline",
-			reason: "dynamic"
-		};
-		else for (const property of arg.getProperties()) {
-			if (ts_morph.Node.isSpreadAssignment(property)) return {
-				kind: "decline",
-				reason: "dynamic"
-			};
-			if (ts_morph.Node.isShorthandPropertyAssignment(property)) {
-				dynamicAxes.set(property.getName(), property.getName());
-				delete selection[property.getName()];
-				continue;
-			}
-			if (!ts_morph.Node.isPropertyAssignment(property)) return {
-				kind: "decline",
-				reason: "dynamic"
-			};
-			const nameNode = property.getNameNode();
-			if (ts_morph.Node.isComputedPropertyName(nameNode)) return {
-				kind: "decline",
-				reason: "dynamic"
-			};
-			const key = propertyKey(nameNode);
-			if (key === void 0) return {
-				kind: "decline",
-				reason: "dynamic"
-			};
-			const initializer = property.getInitializer();
-			if (initializer && !isInert(initializer)) {
-				if (!Object.hasOwn(config.variants ?? {}, key)) return {
-					kind: "decline",
-					reason: "dynamic"
-				};
-				effectful.push({
-					key,
-					text: initializer.getText()
-				});
-				dynamicAxes.set(key, initializer.getText());
-				delete selection[key];
-				continue;
-			}
-			const literal = literalValue(initializer);
-			if (literal !== void 0) {
-				selection[key] = literal;
-				dynamicAxes.delete(key);
-				continue;
-			}
-			if (!resolvedSelection || !Object.hasOwn(resolvedSelection, key)) {
-				if (!initializer) return {
-					kind: "decline",
-					reason: "dynamic"
-				};
-				dynamicAxes.set(key, initializer.getText());
-				delete selection[key];
-				continue;
-			}
-			const value = resolvedSelection[key];
-			if (value !== null && typeof value === "object") return {
-				kind: "decline",
-				reason: "dynamic"
-			};
-			selection[key] = value;
-			dynamicAxes.delete(key);
-		}
-	}
-	/**
-	* Every expression that could run something has to reach the output carrying its own text.
-	*
-	* A later property writing the same key replaces it in `dynamicAxes` — `badge({ tone: a(),
-	* tone: 'b' })` is last-wins for the *value*, but `a()` still runs, and emitting only the
-	* literal would delete it. Duplicate keys are a type error in TypeScript; the fold does not
-	* typecheck and does transform `.js`, so this is reachable.
-	*/
-	const everyEffectSurvives = () => effectful.every(({ key, text }) => dynamicAxes.get(key) === text);
-	const compiledSelection = (selected) => {
-		if (Array.isArray(config.slots) && slot === void 0) {
-			const slots = {};
-			const classNames = /* @__PURE__ */ new Set();
-			for (const slotName of config.slots) {
-				const styles = styleCompiler.resolveRecipe(config, selected, slotName);
-				if (!styles) return void 0;
-				const className = styleCompiler.className(styles);
-				slots[slotName] = className;
-				for (const token of className.split(" ")) if (token) classNames.add(token);
-			}
-			return {
-				value: slots,
-				classNames: [...classNames]
-			};
-		}
-		const styles = styleCompiler.resolveRecipe(config, selected, slot);
-		if (!styles) return void 0;
-		const className = styleCompiler.className(styles);
-		return {
-			value: className,
-			classNames: className.split(" ").filter(Boolean),
-			styles
-		};
-	};
-	if (dynamicAxes.size === 0) {
-		if (!everyEffectSurvives()) return {
-			kind: "decline",
-			reason: "dynamic"
-		};
-		const compiled = compiledSelection(selection);
-		if (!compiled) return {
-			kind: "decline",
-			reason: "dynamic"
-		};
-		if (typeof compiled.value === "string") return {
-			kind: "class",
-			className: compiled.value,
-			styles: compiled.styles
-		};
-		return {
-			kind: "slots",
-			expression: JSON.stringify(compiled.value),
-			classNames: compiled.classNames,
-			dynamic: false
-		};
-	}
-	if (!everyEffectSurvives()) return {
-		kind: "decline",
-		reason: "dynamic"
-	};
-	if (effectful.length > 1) {
-		const variantOrder = Object.keys(config.variants ?? {});
-		const keys = effectful.map((entry) => entry.key);
-		if ([...keys].sort((a, b) => variantOrder.indexOf(a) - variantOrder.indexOf(b)).join("\0") !== keys.join("\0")) return {
-			kind: "decline",
-			reason: "dynamic"
-		};
-	}
-	for (const key of [...dynamicAxes.keys()]) if (!Object.hasOwn(config.variants ?? {}, key)) dynamicAxes.delete(key);
-	if (dynamicAxes.size === 0) {
-		const compiled = compiledSelection(selection);
-		if (!compiled) return {
-			kind: "decline",
-			reason: "dynamic"
-		};
-		if (typeof compiled.value === "string") return {
-			kind: "class",
-			className: compiled.value,
-			styles: compiled.styles
-		};
-		return {
-			kind: "slots",
-			expression: JSON.stringify(compiled.value),
-			classNames: compiled.classNames,
-			dynamic: false
-		};
-	}
-	/**
-	* Compile the finite recipe state space into a reduced decision table.
-	*
-	* Each leaf is a *complete* final StyleSet. This matters for declarations overridden by
-	* variants and compounds: selecting independent per-axis atoms would put both values in
-	* the utility layer and let stylesheet order, rather than the recipe's merge order, pick
-	* the winner. Complete leaves retain the same precedence while sharing their atoms with
-	* every `css()` and recipe in the build.
-	*
-	* `undefined` is its own edge because it restores a default variant. `null` and any
-	* undeclared value take the miss edge and explicitly suppress that default. Declared
-	* values use string keys, matching JavaScript's property-key coercion in the recipe
-	* runtime. A flat alternating key/value array avoids the special `__proto__` semantics
-	* of an object literal.
-	*/
-	const axes = Object.keys(config.variants ?? {}).filter((key) => dynamicAxes.has(key));
-	const stateCount = axes.reduce((product, axis) => product * (Object.keys(config.variants?.[axis] ?? {}).length + 2), 1);
-	if (stateCount > maxRecipeStates) throw new Error(`Static recipe compilation would inspect ${stateCount.toLocaleString("en-US")} selections across ${axes.length} runtime variant axes, above maxRecipeStates=${maxRecipeStates.toLocaleString("en-US")}. Make one or more axes statically known, split the recipe, or raise the limit explicitly.`);
-	const expressions = axes.map((axis) => dynamicAxes.get(axis));
-	const wholeSlots = Array.isArray(config.slots) && slot === void 0;
-	return {
-		kind: "dynamic-style",
-		map: {
-			outputKind: wholeSlots ? "slots" : "class",
-			compile(before = [], after = []) {
-				const nodes = [];
-				const nodeByShape = /* @__PURE__ */ new Map();
-				const leaves = [];
-				const leafByShape = /* @__PURE__ */ new Map();
-				const emittedClasses = /* @__PURE__ */ new Set();
-				const leaf = (dynamicSelection) => {
-					const selected = {
-						...selection,
-						...dynamicSelection
-					};
-					if (wholeSlots) {
-						const compiled = compiledSelection(selected);
-						if (!compiled || typeof compiled.value === "string") return internLeaf("");
-						for (const token of compiled.classNames) emittedClasses.add(token);
-						return internLeaf(compiled.value);
-					}
-					const styles = styleCompiler.resolveRecipe(config, selected, slot);
-					if (!styles) return internLeaf("");
-					const className = styleCompiler.className(styleCompiler.compose(...before, styles, ...after));
-					for (const token of className.split(" ")) if (token) emittedClasses.add(token);
-					return internLeaf(className);
-				};
-				function internLeaf(value) {
-					const shape = JSON.stringify(value);
-					const known = leafByShape.get(shape);
-					if (known !== void 0) return ~known;
-					const id = leaves.length;
-					leaves.push(value);
-					leafByShape.set(shape, id);
-					return ~id;
-				}
-				const buildNode = (index, dynamicSelection) => {
-					if (index === axes.length) return leaf(dynamicSelection);
-					const axis = axes[index];
-					const values = Object.keys(config.variants?.[axis] ?? {});
-					const miss = buildNode(index + 1, {
-						...dynamicSelection,
-						[axis]: null
-					});
-					const absentSelection = { ...dynamicSelection };
-					delete absentSelection[axis];
-					const absent = buildNode(index + 1, absentSelection);
-					const byValue = [];
-					for (const value of values) byValue.push(value, buildNode(index + 1, {
-						...dynamicSelection,
-						[axis]: value
-					}));
-					const refs = [
-						miss,
-						absent,
-						...byValue.filter((_, valueIndex) => valueIndex % 2 === 1)
-					];
-					if (refs.every((ref) => ref === refs[0])) return refs[0];
-					const node = [
-						miss,
-						absent,
-						byValue
-					];
-					const shape = JSON.stringify(node);
-					const known = nodeByShape.get(shape);
-					if (known !== void 0) return known;
-					const id = nodes.length;
-					nodes.push(node);
-					nodeByShape.set(shape, id);
-					return id;
-				};
-				const root = buildNode(0, {});
-				const staticLeaf = root < 0 ? leaves[~root] : void 0;
-				return {
-					expression: root < 0 && effectful.length === 0 ? JSON.stringify(staticLeaf) : `${RECIPE_MAP_HELPER}([${expressions.join(", ")}], ${JSON.stringify(nodes)}, ${JSON.stringify(leaves)}, ${root})`,
-					classNames: [...emittedClasses],
-					staticClasses: typeof staticLeaf === "string" ? staticLeaf : "",
-					outputKind: wholeSlots ? "slots" : "class",
-					usesHelper: !(root < 0 && effectful.length === 0)
-				};
-			}
-		}
-	};
-};
-//#endregion
-//#region src/runtime-css.ts
-/** The shape `createCss` and `createMergeCss` both take, derived from a resolved context. */
-const createCssContext = (ctx) => ({
-	hash: Boolean(ctx.hash.className),
-	conditions: {
-		shift: ctx.conditions.shift,
-		finalize: ctx.conditions.finalize
-	},
-	utility: {
-		prefix: ctx.utility.prefix,
-		hasShorthand: ctx.utility.hasShorthand,
-		resolveShorthand: ctx.utility.resolveShorthand.bind(ctx.utility),
-		transform: ctx.utility.transform.bind(ctx.utility),
-		toHash: ctx.utility.toHash.bind(ctx.utility)
-	}
-});
-const createRuntimeCss = (ctx) => {
-	const cssContext = createCssContext(ctx);
-	const cssFn = (0, _bamboocss_shared.createCssUncached)(cssContext);
-	const { mergeCssUncached } = (0, _bamboocss_shared.createMergeCss)(cssContext);
-	return (0, _bamboocss_shared.memo)((...styles) => cssFn(mergeCssUncached(...styles)));
-};
-/**
-* The map is every token in the project, so it is built once per context and shared by
-* every module in the build — not once per `foldSource`, which would price a whole token
-* table into each of the overwhelming majority of modules that call `token()` zero times.
-* Keyed weakly so a context that goes out of scope takes its table with it.
-*
-* Both halves of the generated entry are stored, because `token()` and `token.value()` read
-* different ones and building a second table would pay the same per-project cost twice.
-*/
-const tokenValues = /* @__PURE__ */ new WeakMap();
-const tokenValuesFor = (ctx) => {
-	let values = tokenValues.get(ctx);
-	if (values) return values;
-	values = /* @__PURE__ */ new Map();
-	for (const token of ctx.tokens.allTokens) {
-		const { varRef, isVirtual, condition } = token.extensions;
-		values.set(token.name, {
-			value: ctx.tokens.view.get(token.name) ?? (isVirtual || condition !== "base" ? varRef : token.value),
-			variable: ctx.tokens.view.getVar(token.name) ?? varRef
-		});
-	}
-	tokenValues.set(ctx, values);
-	return values;
-};
-const createRuntimeTokenValue = (ctx) => (path) => {
-	const value = tokenValuesFor(ctx).get(path)?.value;
-	return typeof value === "string" ? value : void 0;
-};
-/**
-* The generated runtime's `token()`, rebuilt in-process.
-*
-* Reads the `variable` half of the same entry `token.value()` reads the `value` half of.
-* That half is `varRef` for every token regardless of condition, so unlike
-* `createRuntimeTokenValue` there is no split to get wrong and no non-string case to
-* decline: a `var()` reference is a string or the token does not exist. Which is what makes
-* the default form the trivially foldable one.
-*/
-const createRuntimeToken = (ctx) => (path) => tokenValuesFor(ctx).get(path)?.variable || void 0;
-//#endregion
-//#region src/fold.ts
-/**
-* `cva`/`sva` return a function, so their definitions are compile-time declarations rather
-* than class-producing calls; once their uses are lowered, the factory calls are erased.
-* `token` also resolves to no class, but it does resolve to a literal, so it compiles through
-* its own path rather than being declined outright. A static `viewTransition` bag resolves to
-* its extracted class and uses the ordinary class candidate path.
-*
-* Recipe invocations compile through `fold-recipe`. Inline calls
-* are recorded under the name the file bound; config calls arrive as `recipe`. Routing both
-* through one exact finite-state lowering keeps their selection contract identical.
-*/
-const FOLDABLE_TYPES = new Set([
-	"css",
-	"pattern",
-	"viewTransition"
-]);
-/**
-* The skip reasons that leave a `css()`-family call in the output.
-*
-* `overlapping` is handled by the enclosing fold, and `not-imported` is somebody else's
-* function of the same name — neither leaves a call of ours.
-*/
-const SURVIVES_TO_RUNTIME = new Set([
-	"dynamic",
-	"runtime-binding",
-	"raw-call",
-	"unsupported-kind",
-	"no-call-expression",
-	"unresolved-token",
-	"compile-failed"
-]);
-/**
-* A call of a recipe the file bound itself: `const badge = cva(...)`, then `badge({ tone })`.
-*
-* Folded when the whole selection resolves, reported under this reason when it does not.
-* Deliberately all-or-nothing: an unresolved variant does not merely omit its own class, so a
-* partially-known selection is not foldable at all.
-*
-* Visible at all because it used to not be. The parser matched calls by imported name, so a
-* local binding was never recorded, and an unfoldable invocation looked identical to code
-* nothing had parsed.
-*/
-const RECIPE_CALL_TYPE = "cva-call";
-/**
-* An identifier that actually reads the binding.
-*
-* `getDescendantsOfKind(Identifier)` yields every name in the file, and most of them bind or
-* label rather than read: a JSX tag (`<button/>` against a recipe called `button`), an object
-* key, a property name, a declaration. Counting those failed builds on modules that had
-* folded completely — and `button`, `input`, `label`, `select`, `table`, `dialog` and `form`
-* are all ordinary recipe names as well as intrinsic elements.
-*
-* A type position is excluded for a different reason: it is erased, and with it the import.
-*/
-const isValueReference = (identifier) => {
-	const parent = identifier.getParent();
-	if (!parent) return false;
-	if (ts_morph.Node.isImportSpecifier(parent) || ts_morph.Node.isExportSpecifier(parent)) return false;
-	if (ts_morph.Node.isImportClause(parent) || ts_morph.Node.isNamespaceImport(parent)) return false;
-	if (ts_morph.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === identifier) return false;
-	if (ts_morph.Node.isQualifiedName(parent) && parent.getRight() === identifier) return false;
-	if (ts_morph.Node.isPropertyAssignment(parent) && parent.getNameNode() === identifier) return false;
-	if (ts_morph.Node.isMethodDeclaration(parent) || ts_morph.Node.isPropertyDeclaration(parent) || ts_morph.Node.isGetAccessorDeclaration(parent) || ts_morph.Node.isSetAccessorDeclaration(parent) || ts_morph.Node.isMethodSignature(parent) || ts_morph.Node.isPropertySignature(parent) || ts_morph.Node.isEnumMember(parent)) {
-		if (parent.getNameNode() === identifier) return false;
-	}
-	if (ts_morph.Node.isLabeledStatement(parent) || ts_morph.Node.isBreakStatement(parent) || ts_morph.Node.isContinueStatement(parent)) return false;
-	if (ts_morph.Node.isJsxOpeningElement(parent) || ts_morph.Node.isJsxSelfClosingElement(parent) || ts_morph.Node.isJsxClosingElement(parent)) {
-		if (parent.getTagNameNode() === identifier) return identifier.getText()[0] === identifier.getText()[0]?.toUpperCase();
-	}
-	if (ts_morph.Node.isJsxAttribute(parent)) return false;
-	if (ts_morph.Node.isBindingElement(parent) && parent.getPropertyNameNode() === identifier) return false;
-	if ((ts_morph.Node.isVariableDeclaration(parent) || ts_morph.Node.isParameterDeclaration(parent) || ts_morph.Node.isBindingElement(parent) || ts_morph.Node.isFunctionDeclaration(parent) || ts_morph.Node.isClassDeclaration(parent)) && parent.getNameNode() === identifier) return false;
-	return !identifier.getFirstAncestor((ancestor) => ts_morph.Node.isTypeNode(ancestor) || ts_morph.Node.isTypeAliasDeclaration(ancestor) || ts_morph.Node.isInterfaceDeclaration(ancestor));
-};
-/**
-* Imports a surviving reference to is not a failure.
-*
-* These are what the compiler itself writes; all live in `cx` and pull no engine, so a
-* reference to one is the fold having worked.
-*/
-const PERMITTED_BINDINGS = new Set([
-	"cx",
-	RECIPE_MAP_HELPER,
-	SPLIT_PROPS_HELPER
-]);
-/**
-* Whether a module's text could hold a `splitVariantProps` property access.
-*
-* A necessary condition, deliberately not a sufficient one: the name inside a string or a
-* comment opens the walk, which costs what the walk always cost. What it must never do is
-* close on a module that has one, and an identifier may be spelled with unicode escapes —
-* `badge.splitVariantProps(p)` reads as the name to the compiler and contains none of it
-* as text. Both escape forms start `\u`, so one test covers every spelling.
-*/
-const mayNameSplitVariantProps = (text) => text.includes("splitVariantProps") || text.includes("\\u");
-/**
-* The pieces `trim` reduces a module specifier by, hoisted because a regex literal
-* constructs a new object every time it is evaluated and `trim` runs per specifier per
-* import declaration per module.
-*/
-const LEADING_RELATIVE = /^(?:\.\.?\/)+/;
-const TRAILING_SLASH = /\/$/;
-const MODULE_EXTENSION = /\.[mc]?[jt]sx?$/;
-const TRAILING_INDEX = /\/index$/;
-/**
-* An argument that cannot run anything when it is evaluated.
-*
-* `token()` takes one argument, but javascript evaluates every argument a call site passes
-* before the call — so a fold that drops an extra one also drops whatever evaluating it would
-* have done. `token('x', compute())` is pathological and no longer type-checks, and the fold's
-* contract is behaviour preservation regardless: a literal is the cheap way to prove it, since
-* it means no call, no property read, no getter.
-*/
-const isInertArgument = (node) => ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNumericLiteral(node) || ts_morph.Node.isNoSubstitutionTemplateLiteral(node) || node.getKind() === ts_morph.SyntaxKind.TrueKeyword || node.getKind() === ts_morph.SyntaxKind.FalseKeyword || node.getKind() === ts_morph.SyntaxKind.NullKeyword || ts_morph.Node.isIdentifier(node) && node.getText() === "undefined";
-/**
-* An expression whose evaluation cannot do anything observable, so deleting it preserves
-* behaviour.
-*
-* `isInertArgument` covers the leaves; this walks the object and array literals a recipe
-* call is actually written with. A spread runs the source's getters, a computed key runs an
-* expression, a getter or method definition is a function — none of those are safe to
-* delete, so they are declined rather than enumerated.
-*/
-const isInertExpression = (node) => {
-	if (isInertArgument(node)) return true;
-	if (ts_morph.Node.isIdentifier(node)) return true;
-	if (ts_morph.Node.isAsExpression(node) || ts_morph.Node.isSatisfiesExpression(node) || ts_morph.Node.isNonNullExpression(node) || ts_morph.Node.isTypeAssertion(node) || ts_morph.Node.isParenthesizedExpression(node)) return isInertExpression(node.getExpression());
-	if (ts_morph.Node.isArrowFunction(node) || ts_morph.Node.isFunctionExpression(node)) return true;
-	if (ts_morph.Node.isRegularExpressionLiteral(node) || ts_morph.Node.isBigIntLiteral(node)) return true;
-	if (ts_morph.Node.isPrefixUnaryExpression(node)) {
-		const operator = node.getOperatorToken();
-		return (operator === ts_morph.SyntaxKind.MinusToken || operator === ts_morph.SyntaxKind.PlusToken || operator === ts_morph.SyntaxKind.ExclamationToken || operator === ts_morph.SyntaxKind.TildeToken) && isInertExpression(node.getOperand());
-	}
-	if (ts_morph.Node.isBinaryExpression(node)) {
-		const operator = node.getOperatorToken().getKind();
-		return (operator === ts_morph.SyntaxKind.QuestionQuestionToken || operator === ts_morph.SyntaxKind.BarBarToken || operator === ts_morph.SyntaxKind.AmpersandAmpersandToken) && isInertExpression(node.getLeft()) && isInertExpression(node.getRight());
-	}
-	if (ts_morph.Node.isObjectLiteralExpression(node)) return node.getProperties().every((property) => {
-		if (ts_morph.Node.isShorthandPropertyAssignment(property)) return true;
-		if (!ts_morph.Node.isPropertyAssignment(property)) return false;
-		if (ts_morph.Node.isComputedPropertyName(property.getNameNode())) return false;
-		const initializer = property.getInitializer();
-		return initializer !== void 0 && isInertExpression(initializer);
-	});
-	if (ts_morph.Node.isArrayLiteralExpression(node)) return node.getElements().every(isInertExpression);
-	return false;
-};
-/**
-* Source files a box tree reaches, other than the one being folded.
-*
-* When the extractor resolves an imported identifier it boxes the *declaration's*
-* node, which lives in the defining module. Walking the tree and reading each node's
-* source file therefore recovers exactly the files a fold depended on — narrower and
-* more accurate than treating every import of the module as a dependency.
-*/
-const collectSourceFiles = (node, ctx, seen = /* @__PURE__ */ new Set()) => {
-	if (!node || seen.has(node)) return;
-	seen.add(node);
-	ctx.record(node.getNode?.());
-	if (_bamboocss_extractor.box.isMap(node)) {
-		for (const child of node.value.values()) collectSourceFiles(child, ctx, seen);
-		return;
-	}
-	if (_bamboocss_extractor.box.isArray(node)) for (const child of node.value) collectSourceFiles(child, ctx, seen);
-};
-const createDependencyScan = (ownFile) => {
-	const results = /* @__PURE__ */ new Set();
-	const paths = /* @__PURE__ */ new Map();
-	return {
-		results,
-		record(node) {
-			if (!node) return;
-			const sourceFile = node.getSourceFile();
-			if (sourceFile === ownFile) return;
-			let path = paths.get(sourceFile);
-			if (path === void 0) {
-				path = sourceFile.getFilePath();
-				paths.set(sourceFile, path);
-			}
-			if (path) results.add(path);
-		}
-	};
-};
-/**
-* The call expression to replace.
-*
-* `extractCallExpressionArguments` boxes the argument list against the call node and
-* pushes `[callNode, argNode]` onto each argument's stack, so the call is reachable
-* from either shape the parser stores: the argument array (multi-arg) or the first
-* argument's map (single-arg).
-*/
-const findCallExpression = (node) => {
-	const own = node.getNode?.();
-	if (own && ts_morph.Node.isCallExpression(own)) return own;
-	const stack = node.getStack?.() ?? [];
-	for (const entry of stack) if (ts_morph.Node.isCallExpression(entry)) return entry;
-	let current = own;
-	for (let depth = 0; current && depth < 3; depth++) {
-		if (ts_morph.Node.isCallExpression(current)) return current;
-		current = current.getParent();
-	}
-};
-/**
-* `css.raw(...)` must keep returning a style object — folding it to a class string
-* breaks every caller composing those styles. The file matcher strips `.raw` when it
-* normalizes function names, so the parser result cannot tell us; the callee text can.
-*/
-const isRawCall = (call) => {
-	if (!ts_morph.Node.isCallExpression(call)) return false;
-	const callee = call.getExpression().getText();
-	return callee === "raw" || callee.endsWith(".raw");
-};
-/** The identifier a callee is rooted at: `css` for `css(…)`, `panda` for `panda.css(…)`. */
-const calleeRootName = (call) => {
-	if (!ts_morph.Node.isCallExpression(call)) return void 0;
-	let current = call.getExpression();
-	while (ts_morph.Node.isPropertyAccessExpression(current)) current = current.getExpression();
-	return ts_morph.Node.isIdentifier(current) ? current.getText() : void 0;
-};
-/**
-* Local names a module binds to an import of bamboo's own generated system.
-*
-* The parser matches by name and asks neither question this does — deliberately, since
-* for CSS extraction the worst case is a few unused rules. A transform cannot be that
-* relaxed, and it needs both halves:
-*
-* - imported at all, or a user's `const css = (s) => JSON.stringify(s)` gets rewritten
-* - imported *from bamboo*, or `import { css } from '@emotion/css'` does, which is the
-*   likelier accident of the two since a migrating project has both in the tree
-*
-* Answered together and once per file, because the scan is the expensive part and both
-* answers fall out of the same pass. Per call site instead of per file, this scan
-* measured +74% on the largest sandbox module.
-*/
-const bambooImportedNames = (sourceFile, ctx) => {
-	const names = /* @__PURE__ */ new Set();
-	for (const declaration of sourceFile.getImportDeclarations()) {
-		const mod = declaration.getModuleSpecifierValue();
-		for (const named of declaration.getNamedImports()) {
-			const name = named.getNameNode().getText();
-			const alias = named.getAliasNode()?.getText() ?? name;
-			if (ctx.imports.match({
-				mod,
-				name,
-				alias
-			})) names.add(alias);
-		}
-		const namespace = declaration.getNamespaceImport();
-		if (namespace) {
-			const alias = namespace.getText();
-			if (ctx.imports.match({
-				mod,
-				name: alias,
-				alias,
-				kind: "namespace"
-			})) names.add(alias);
-		}
-	}
-	return names;
-};
-/**
-* Is the callee the imported binding, or a local one that shadows it?
-*
-* A block-scoped binding of the same name is legal alongside the import, and it is
-* the one the call actually reaches. Walking ancestors is the precise answer; the
-* cost is kept off the common path by only inspecting the two node kinds that can
-* introduce a binding. Ancestors of a call in JSX are overwhelmingly elements and
-* attributes, which match neither and cost nothing.
-*/
-const isShadowed = (call, name) => {
-	for (let node = call.getParent(); node; node = node.getParent()) {
-		if (ts_morph.Node.isSourceFile(node)) return false;
-		if (bindsName(node, name)) return true;
-	}
-	return false;
-};
-/**
-* Does a binding name introduce `name`?
-*
-* A plain identifier check is not enough: destructuring is the likeliest way a
-* same-named local reaches a call, since `({ css }) => css(…)` is what a component
-* taking a `css` prop looks like. Nested and rest elements bind too, so the pattern
-* is walked rather than inspected at the top level.
-*/
-const bindingIntroduces = (nameNode, name) => {
-	if (!nameNode) return false;
-	if (ts_morph.Node.isIdentifier(nameNode)) return nameNode.getText() === name;
-	if (ts_morph.Node.isObjectBindingPattern(nameNode) || ts_morph.Node.isArrayBindingPattern(nameNode)) return nameNode.getElements().some((element) => ts_morph.Node.isBindingElement(element) && bindingIntroduces(element.getNameNode(), name));
-	return false;
-};
-const declarationsBind = (list, name) => ts_morph.Node.isVariableDeclarationList(list) && list.getDeclarations().some((declaration) => bindingIntroduces(declaration.getNameNode(), name));
-const bindsName = (scope, name) => {
-	if (ts_morph.Node.isBlock(scope)) return scope.getStatements().some((statement) => statementBinds(statement, name));
-	if (ts_morph.Node.isFunctionDeclaration(scope) || ts_morph.Node.isArrowFunction(scope) || ts_morph.Node.isFunctionExpression(scope) || ts_morph.Node.isMethodDeclaration(scope)) return scope.getParameters().some((parameter) => bindingIntroduces(parameter.getNameNode(), name));
-	if (ts_morph.Node.isCatchClause(scope)) return bindingIntroduces(scope.getVariableDeclaration()?.getNameNode(), name);
-	if (ts_morph.Node.isForStatement(scope) || ts_morph.Node.isForOfStatement(scope) || ts_morph.Node.isForInStatement(scope)) return declarationsBind(scope.getInitializer(), name);
-	return false;
-};
-const statementBinds = (statement, name) => {
-	if (ts_morph.Node.isVariableStatement(statement)) return statement.getDeclarations().some((declaration) => bindingIntroduces(declaration.getNameNode(), name));
-	if (ts_morph.Node.isFunctionDeclaration(statement) || ts_morph.Node.isClassDeclaration(statement)) return statement.getNameNode()?.getText() === name;
-	return false;
-};
-const hasStyles = (data) => data.length > 0 && data.every((entry) => entry != null && typeof entry === "object");
-/**
-* Pair each source argument with the box the parser stored for it, and require the
-* box to account for all of it. The parser keeps either the whole argument array
-* (multi-arg calls) or just the first argument's map (single-arg calls).
-*/
-const argumentsAccountedFor = (call, boxNode) => {
-	if (!ts_morph.Node.isCallExpression(call)) return false;
-	const args = call.getArguments();
-	if (args.length === 0) return true;
-	if (_bamboocss_extractor.box.isArray(boxNode) && boxNode.getNode() === call) {
-		if (boxNode.value.length !== args.length) return false;
-		return args.every((arg, index) => accountsForSource(arg, boxNode.value[index]));
-	}
-	if (args.length !== 1) return false;
-	return accountsForSource(args[0], boxNode);
-};
-const foldSource = (options) => {
-	const { ctx, code, parserResult, runtimeCss = createRuntimeCss(ctx), styleCompiler, maxRecipeStates, parseModule, recipeConfigCache, reportSurvivors, sourceFile: ownSourceFile } = options;
-	const runtimeToken = createRuntimeToken(ctx);
-	const runtimeTokenValue = createRuntimeTokenValue(ctx);
-	/**
-	* Does this specifier name a module that exports the css API, exactly?
-	*
-	* `ImportMap.match` is substring-based, which is right for deciding whether a call is
-	* bamboo's and wrong for deciding whether a module can be imported *from*:
-	* `styled-system/css/css` matches while exporting no `cx`. So the comparison is
-	* equality, not containment.
-	*
-	* A tsconfig path alias is resolved first, the same way `ImportMap.match` does. Without
-	* that, `@site/styled-system/css` — the spelling this repo's own website uses — fails
-	* the check and silently loses helper lowering, which is indistinguishable in the
-	* diagnostics from a genuinely dynamic call.
-	*/
-	const cssModules = ctx.imports.matchers.css?.mods ?? [];
-	/**
-	* The generated css module, the only one whose exports are known.
-	*
-	* A configured `importMap.css` points at the user's own wrapper, and a wrapper that
-	* re-exports `css` need not re-export `cx` — adding one there imports a binding that
-	* may not exist. Reusing a `cx` the user already imported from it stays fine, since
-	* that binding demonstrably resolves; only *adding* one is restricted.
-	*/
-	const generatedCssModule = [ctx.imports.outdir, "css"].join("/");
-	const pathMappings = ctx.conf.tsOptions?.pathMappings;
-	/**
-	* The spelling reduced to the module it names.
-	*
-	* The extension and `/index` are stripped because bamboo's own output makes a file
-	* import them: `outExtension: 'js'` under NodeNext resolution is written
-	* `styled-system/css/index.js`, which is neither equal to `styled-system/css` nor a
-	* tail of it. Extraction admitted such a file anyway — `ImportMap.match` is
-	* substring-based — so the call was folded while the *insert* was refused, and the
-	* result was reported as `dynamic`: the same silent downgrade the alias case above
-	* describes, reached through the extension instead.
-	*
-	* This does not weaken the equality the comment above insists on. `styled-system/css/css`
-	* still names neither, because only a trailing `/index` is a module's own directory.
-	*
-	* `.d.ts` is deliberately not stripped. A declaration file exports no runtime binding, so
-	* matching one would authorise inserting an import that resolves to nothing — and a value
-	* import cannot name one anyway, which is what makes leaving it out free.
-	*/
-	const trim = (value) => value.replaceAll("\\", "/").replace(LEADING_RELATIVE, "").replace(TRAILING_SLASH, "").replace(MODULE_EXTENSION, "").replace(TRAILING_INDEX, "");
-	const matchesModule = (mod, entries) => {
-		const candidates = [mod];
-		if (pathMappings) {
-			const resolved = (0, _bamboocss_config_ts_path.resolveTsPathPattern)(pathMappings, mod);
-			if (resolved) candidates.push(resolved);
-		}
-		return candidates.some((candidate) => {
-			const normalized = trim(candidate);
-			return entries.some((entry) => {
-				const target = trim(entry);
-				return normalized === target || normalized.endsWith(`/${target}`);
-			});
-		});
-	};
-	const isBambooCssModule = (mod) => matchesModule(mod, cssModules);
-	const isGeneratedCssModule = (mod) => matchesModule(mod, [generatedCssModule]);
-	/**
-	* Where the compiler's helpers can be imported from, for a file that imports the generated
-	* css module by *subpath* rather than through its barrel.
-	*
-	* `styled-system/css/cva.js` is a real spelling, and it cannot host the helper: that module
-	* exports `cva`, not `cvaMap`. Matching only the barrel meant no host was found and every
-	* runtime recipe selection in the file declined — a failure whose reported reason said
-	* nothing about import spelling, and whose suggested remedies all pointed elsewhere.
-	*
-	* The sibling `cx` module is what actually exports them. The prefix is verified against the
-	* configured output before anything is derived, so an unrelated `foo/css/bar.js` is left
-	* alone, and the caller's extension is preserved rather than guessed at.
-	*/
-	const helperModuleFromSubpath = (mod) => {
-		const normalized = mod.replaceAll("\\", "/");
-		const at = normalized.lastIndexOf("/css/");
-		if (at < 0) return void 0;
-		const prefix = normalized.slice(0, at + 5 - 1);
-		if (!isGeneratedCssModule(prefix)) return void 0;
-		const rest = normalized.slice(at + 5);
-		if (!rest || rest.includes("/")) return void 0;
-		const dot = rest.lastIndexOf(".");
-		const extension = dot > 0 ? rest.slice(dot) : "";
-		if (rest === `cx${extension}`) return void 0;
-		return `${prefix}/cx${extension}`;
-	};
-	/**
-	* The generated css entry as spelled beside an imported config recipe.
-	*
-	* A decision table needs only `cvaMap`, but a module importing a config recipe often has
-	* no css import to extend. Preserve a relative/aliased styled-system spelling by replacing
-	* its `/recipes` suffix; falling back to the configured generated entry covers bare imports.
-	*/
-	const configRecipeCssSpecifier = (call, binding) => {
-		for (const declaration of call.getSourceFile().getImportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			if (!declaration.getNamedImports().some((named) => {
-				if (named.isTypeOnly()) return false;
-				return (named.getAliasNode() ?? named.getNameNode()).getText() === binding;
-			})) continue;
-			const mod = declaration.getModuleSpecifierValue().replaceAll("\\", "/");
-			const at = mod.lastIndexOf("/recipes");
-			if (at >= 0) return `${mod.slice(0, at)}/css`;
-		}
-		return generatedCssModule;
-	};
-	/**
-	* How *this* module would have to spell the css module, learnt from one that already does.
-	*
-	* A file calling an imported recipe need not import the css module at all, so when the
-	* lowering needs a decision-table helper there is no spelling in the file to copy. The declaring module
-	* necessarily has one — `cva` came from it — and that is the spelling reused here.
-	*
-	* A bare or aliased specifier resolves identically from any file, so it is taken as
-	* written. A relative one is re-based: resolved against the module that wrote it, then
-	* expressed from the module being folded.
-	*/
-	const cssModuleSpecifierFrom = (declaring) => {
-		for (const declaration of declaring.getImportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			const mod = declaration.getModuleSpecifierValue();
-			if (isGeneratedCssModule(mod)) return mod;
-		}
-	};
-	/**
-	* That spelling, said from the module being folded.
-	*
-	* A bare or aliased specifier resolves identically from any file, so it is taken as
-	* written. A relative one is re-based: resolved against the module that wrote it, then
-	* expressed from the module being folded. Pure path arithmetic, so it holds a string
-	* rather than a node — a cached node does not survive the next `addSourceFile`, which
-	* ts-morph implements by forgetting the file's whole tree.
-	*/
-	const rebaseSpecifier = (specifier, declaringPath, consumingPath) => {
-		if (!specifier.startsWith(".")) return specifier;
-		const absolute = (0, node_path.resolve)((0, node_path.dirname)(declaringPath), specifier);
-		const rebased = (0, node_path.relative)((0, node_path.dirname)(consumingPath), absolute).replaceAll("\\", "/");
-		if (!rebased) return void 0;
-		return rebased.startsWith(".") ? rebased : `./${rebased}`;
-	};
-	/**
-	* Configs of one foreign module, parsed once however many of its recipes are called.
-	*
-	* Falls back to a per-call map when the caller supplies none, so the fold stays correct
-	* standalone — only repeated, which is what the shared cache exists to avoid.
-	*/
-	const configsByModule = recipeConfigCache ?? /* @__PURE__ */ new Map();
-	/** The specifier each imported recipe's module used for the css module, when it needs one. */
-	const helperModules = /* @__PURE__ */ new Map();
-	/** Declaring modules a fold read, recorded as paths because their nodes do not persist. */
-	const foreignDependencies = /* @__PURE__ */ new Set();
-	/** Resolutions for this module's own call sites, keyed by the name the call site writes. */
-	const importedRecipes = /* @__PURE__ */ new Map();
-	/**
-	* The config of a recipe this module imports.
-	*
-	* The binding is followed with ts-morph's symbol aliasing rather than by re-reading import
-	* declarations, because that is what already understands the shapes these are reached
-	* through: `export { badge } from './styles'`, `export * from './styles'`, and an alias at
-	* either end. Each hop is an alias symbol, so following them to a non-alias lands on the
-	* declaration wherever it lives.
-	*
-	* The selected declarations do not depend on which module the call is in. A recipe lowered
-	* here therefore reaches the same globally shared atoms as a call in its declaring module.
-	*/
-	const resolveImportedRecipe = (call, name, origin) => {
-		if (importedRecipes.has(name)) return importedRecipes.get(name);
-		const resolve = () => {
-			if (!parseModule) return void 0;
-			const consuming = call.getSourceFile();
-			if (origin.filePath === consuming.getFilePath()) return void 0;
-			let foreign = configsByModule.get(origin.filePath);
-			if (!foreign) {
-				const result = parseModule(origin.filePath);
-				if (!result) return void 0;
-				const collected = collectRecipeConfigs(result);
-				const declaring = [...collected.values()].find((entry) => entry.box)?.box?.getNode?.()?.getSourceFile();
-				const configs = /* @__PURE__ */ new Map();
-				for (const [key, entry] of collected) configs.set(key, entry === AMBIGUOUS ? entry : {
-					config: entry.config,
-					box: void 0
-				});
-				foreign = {
-					configs,
-					cssSpecifier: declaring ? cssModuleSpecifierFrom(declaring) : void 0
-				};
-				configsByModule.set(origin.filePath, foreign);
-			}
-			const entry = foreign.configs.get(origin.name);
-			if (!entry || entry === AMBIGUOUS) return void 0;
-			foreignDependencies.add(origin.filePath);
-			helperModules.set(name, foreign.cssSpecifier ? rebaseSpecifier(foreign.cssSpecifier, origin.filePath, consuming.getFilePath()) : void 0);
-			return entry;
-		};
-		const resolved = resolve();
-		importedRecipes.set(name, resolved);
-		return resolved;
-	};
-	const folded = [];
-	const skipped = [];
-	const candidates = [];
-	const seenRanges = /* @__PURE__ */ new Set();
-	const recipeConfigs = collectRecipeConfigs(parserResult);
-	const recipeDefinitions = [];
-	for (const [name, entry] of recipeConfigs) {
-		if (entry === AMBIGUOUS) continue;
-		const definition = entry.box?.getNode?.();
-		if (!definition) continue;
-		const call = ts_morph.Node.isCallExpression(definition) ? definition : definition.getFirstAncestorByKind(ts_morph.SyntaxKind.CallExpression);
-		if (!call || code.slice(call.getStart(), call.getEnd()) !== call.getText()) continue;
-		recipeDefinitions.push({
-			name,
-			call
-		});
-	}
-	/** Ranges already reported as declined, so one call is never counted twice. */
-	const reportedRanges = /* @__PURE__ */ new Set();
-	const importCache = /* @__PURE__ */ new Map();
-	const importsFor = (sourceFile) => {
-		let names = importCache.get(sourceFile);
-		if (!names) {
-			names = bambooImportedNames(sourceFile, ctx);
-			importCache.set(sourceFile, names);
-		}
-		return names;
-	};
-	for (const item of parserResult.toArray()) {
-		const type = item.type ?? "";
-		const name = item.name ?? type;
-		if (!item.box) continue;
-		const call = findCallExpression(item.box);
-		if (type === "token" || type === "tokenValue") {
-			if (!call) {
-				skipped.push({
-					name,
-					reason: "no-call-expression",
-					start: 0,
-					end: 0
-				});
-				continue;
-			}
-			const start = call.getStart();
-			const end = call.getEnd();
-			if (code.slice(start, end) !== call.getText()) {
-				skipped.push({
-					name,
-					reason: "no-call-expression",
-					start: 0,
-					end: 0
-				});
-				continue;
-			}
-			const rangeKey = `${start}:${end}`;
-			if (seenRanges.has(rangeKey)) continue;
-			seenRanges.add(rangeKey);
-			const rootName = calleeRootName(call);
-			if (!rootName || !importsFor(call.getSourceFile()).has(rootName) || isShadowed(call, rootName)) {
-				skipped.push({
-					name,
-					reason: "not-imported",
-					start,
-					end
-				});
-				continue;
-			}
-			const callee = ts_morph.Node.isCallExpression(call) ? call.getExpression() : void 0;
-			const propertyName = ts_morph.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getText() : void 0;
-			const wantsValue = type === "tokenValue";
-			if (wantsValue !== (propertyName === "value")) {
-				skipped.push({
-					name,
-					reason: "unsupported-kind",
-					start,
-					end
-				});
-				continue;
-			}
-			if (!wantsValue && propertyName !== void 0 && !ctx.imports.matchers.tokens.match(propertyName)) {
-				skipped.push({
-					name,
-					reason: "unsupported-kind",
-					start,
-					end
-				});
-				continue;
-			}
-			if (!isStaticBox(item.box) || item.data.length !== 1) {
-				skipped.push({
-					name,
-					reason: "dynamic",
-					start,
-					end
-				});
-				continue;
-			}
-			const path = item.data[0];
-			if (typeof path !== "string") {
-				skipped.push({
-					name,
-					reason: "dynamic",
-					start,
-					end
-				});
-				continue;
-			}
-			if (!(ts_morph.Node.isCallExpression(call) ? call.getArguments().slice(1) : []).every(isInertArgument)) {
-				skipped.push({
-					name,
-					reason: "dynamic",
-					start,
-					end
-				});
-				continue;
-			}
-			const value = wantsValue ? runtimeTokenValue(path) : runtimeToken(path);
-			if (!value) {
-				skipped.push({
-					name,
-					reason: "unresolved-token",
-					start,
-					end
-				});
-				continue;
-			}
-			candidates.push({
-				item,
-				call,
-				node: call,
-				start,
-				end,
-				value
-			});
-			continue;
-		}
-		if (!FOLDABLE_TYPES.has(type)) {
-			if (call && (type === RECIPE_CALL_TYPE || type === "recipe") && !isShadowed(call, name)) {
-				const start = call.getStart();
-				const end = call.getEnd();
-				const rangeKey = `${start}:${end}`;
-				if (!reportedRanges.has(rangeKey)) {
-					reportedRanges.add(rangeKey);
-					if (code.slice(start, end) !== call.getText()) {
-						skipped.push({
-							name,
-							reason: "no-call-expression",
-							start: 0,
-							end: 0
-						});
-						continue;
-					}
-					if (isRawCall(call)) {
-						skipped.push({
-							name,
-							reason: "raw-call",
-							start,
-							end
-						});
-						continue;
-					}
-					if (!recipeConfigs.has(name)) {
-						if (type === "recipe") {
-							const config = ctx.recipes.getConfig(name);
-							if (config) {
-								recipeConfigs.set(name, {
-									config,
-									box: void 0
-								});
-								helperModules.set(name, configRecipeCssSpecifier(call, name));
-							}
-						} else if (item.origin) {
-							const imported = resolveImportedRecipe(call, name, item.origin);
-							if (imported) recipeConfigs.set(name, imported);
-						}
-					}
-					const resolvedSelection = item.data?.length === 1 ? item.data[0] : void 0;
-					const entry = recipeConfigs.get(name);
-					let inlineSlot;
-					let inlineEnd = end;
-					if (Array.isArray(entry?.config.slots)) {
-						const parent = call.getParent();
-						if (ts_morph.Node.isPropertyAccessExpression(parent) && parent.getExpression() === call) {
-							const accessed = parent.getName();
-							if (entry.config.slots.includes(accessed)) {
-								inlineSlot = accessed;
-								inlineEnd = parent.getEnd();
-							}
-						} else if (ts_morph.Node.isElementAccessExpression(parent) && parent.getExpression() === call) {
-							const argument = parent.getArgumentExpression();
-							const accessed = argument && (ts_morph.Node.isStringLiteral(argument) || ts_morph.Node.isNoSubstitutionTemplateLiteral(argument)) ? argument.getLiteralValue() : void 0;
-							if (typeof accessed === "string" && entry.config.slots.includes(accessed)) {
-								inlineSlot = accessed;
-								inlineEnd = parent.getEnd();
-							}
-						}
-					}
-					const lowered = lowerRecipeCall(call, entry, styleCompiler, isInertExpression, resolvedSelection, inlineSlot, maxRecipeStates);
-					if (lowered.kind === "dynamic-style") {
-						const helper = ensureRecipeHelperImport(RECIPE_MAP_HELPER, call, isBambooCssModule, isGeneratedCssModule, isShadowed, helperModules.get(name), helperModuleFromSubpath);
-						if (helper) {
-							candidates.push({
-								item,
-								call,
-								node: call,
-								start,
-								end: inlineEnd,
-								className: "",
-								classNames: [],
-								styleMap: lowered.map,
-								mapHelperName: helper.name,
-								insert: helper.insert,
-								configBox: entry?.box,
-								outputKind: lowered.map.outputKind === "slots" ? "slots" : void 0
-							});
-							continue;
-						}
-						skipped.push({
-							name,
-							reason: "recipe-call",
-							start,
-							end
-						});
-						continue;
-					}
-					if (lowered.kind === "slots") {
-						const helper = lowered.helper ? ensureRecipeHelperImport(lowered.helper, call, isBambooCssModule, isGeneratedCssModule, isShadowed, helperModules.get(name), helperModuleFromSubpath) : void 0;
-						if (!lowered.helper || helper) {
-							const replacement = lowered.helper && helper && helper.name !== lowered.helper ? lowered.expression.replaceAll(`${lowered.helper}(`, `${helper.name}(`) : lowered.expression;
-							candidates.push({
-								item,
-								call,
-								node: call,
-								start,
-								end: inlineEnd,
-								replacement,
-								className: "",
-								classNames: lowered.classNames,
-								insert: helper?.insert,
-								configBox: entry?.box,
-								outputKind: "slots"
-							});
-							continue;
-						}
-						skipped.push({
-							name,
-							reason: "recipe-call",
-							start,
-							end
-						});
-						continue;
-					}
-					if (lowered.kind === "class") {
-						candidates.push({
-							item,
-							call,
-							node: call,
-							start,
-							end: inlineEnd,
-							replacement: JSON.stringify(lowered.className),
-							className: lowered.className,
-							classNames: lowered.className.split(" ").filter(Boolean),
-							styleSet: lowered.styles,
-							configBox: entry?.box
-						});
-						continue;
-					}
-					skipped.push({
-						name,
-						reason: "recipe-call",
-						start,
-						end
-					});
-				}
-			}
-			continue;
-		}
-		if (!call) {
-			skipped.push({
-				name,
-				reason: "no-call-expression",
-				start: 0,
-				end: 0
-			});
-			continue;
-		}
-		const start = call.getStart();
-		const end = call.getEnd();
-		const memberParent = call.getParent();
-		const accessed = type === "recipe" && ts_morph.Node.isPropertyAccessExpression(memberParent) && memberParent.getExpression() === call ? memberParent : void 0;
-		const accessedName = accessed?.getNameNode().getText();
-		const declaredSlots = accessed ? ctx.recipes.getConfig(name)?.slots ?? [] : [];
-		const memberAccess = accessedName && declaredSlots.includes(accessedName) ? accessed : void 0;
-		const slot = memberAccess ? accessedName : void 0;
-		const foldEnd = memberAccess ? memberAccess.getEnd() : end;
-		if (code.slice(start, end) !== call.getText()) {
-			skipped.push({
-				name,
-				reason: "no-call-expression",
-				start: 0,
-				end: 0
-			});
-			continue;
-		}
-		const rangeKey = `${start}:${foldEnd}`;
-		if (seenRanges.has(rangeKey)) continue;
-		seenRanges.add(rangeKey);
-		if (isRawCall(call)) {
-			skipped.push({
-				name,
-				reason: "raw-call",
-				start,
-				end
-			});
-			continue;
-		}
-		const rootName = calleeRootName(call);
-		if (!rootName || !importsFor(call.getSourceFile()).has(rootName) || isShadowed(call, rootName)) {
-			skipped.push({
-				name,
-				reason: "not-imported",
-				start,
-				end
-			});
-			continue;
-		}
-		if (!(ts_morph.Node.isCallExpression(call) && call.getArguments().length === 0 && item.data.length === 1) && !isStaticBox(item.box) || !hasStyles(item.data) || !argumentsAccountedFor(call, item.box)) {
-			skipped.push({
-				name,
-				reason: "dynamic",
-				start,
-				end
-			});
-			continue;
-		}
-		candidates.push({
-			item,
-			call,
-			node: call,
-			start,
-			end: foldEnd,
-			slot
-		});
-	}
-	/**
-	* Resolve every fully static candidate to symbolic declarations before allocating a class.
-	*
-	* The normal fold can wait until the rewrite loop to compute a class string. Semantic
-	* composition cannot: an enclosing `cx()` needs the declarations of its arguments so it can
-	* discard overridden values before any string exists.
-	*/
-	{
-		for (const candidate of candidates) {
-			if (candidate.styleSet || candidate.value !== void 0 || candidate.replacement) continue;
-			const { item } = candidate;
-			if (item.type === "css") {
-				candidate.styleSet = styleCompiler.compose(...item.data);
-				continue;
-			}
-			if (item.type === "pattern") {
-				candidate.styleSet = styleCompiler.compose(...item.data.map((entry) => ctx.patterns.transform(item.name ?? "", entry)));
-				continue;
-			}
-			if (item.type === "viewTransition") {
-				const semantic = (0, _bamboocss_shared.viewTransitionClassName)(item.data[0], ctx.utility.prefix);
-				candidate.className = styleCompiler.allocateClassString(semantic);
-				candidate.classNames = [candidate.className];
-				candidate.replacement = JSON.stringify(candidate.className);
-				continue;
-			}
-		}
-		const sourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile();
-		if (sourceFile) {
-			const cxBindings = /* @__PURE__ */ new Set();
-			for (const declaration of sourceFile.getImportDeclarations()) {
-				if (declaration.isTypeOnly() || !isBambooCssModule(declaration.getModuleSpecifierValue())) continue;
-				for (const named of declaration.getNamedImports()) {
-					if (named.isTypeOnly() || named.getNameNode().getText() !== "cx") continue;
-					cxBindings.add((named.getAliasNode() ?? named.getNameNode()).getText());
-				}
-			}
-			const byRange = new Map(candidates.map((candidate) => [`${candidate.start}:${candidate.end}`, candidate]));
-			for (const call of cxBindings.size ? sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.CallExpression) : []) {
-				const callee = call.getExpression();
-				if (!ts_morph.Node.isIdentifier(callee) || !cxBindings.has(callee.getText()) || isShadowed(call, callee.getText())) continue;
-				const matched = [];
-				const parts = [];
-				const dynamic = [];
-				const constantCandidates = [];
-				let supported = true;
-				const take = (arg) => {
-					const candidate = byRange.get(`${arg.getStart()}:${arg.getEnd()}`);
-					if (candidate?.styleMap?.outputKind === "class") {
-						dynamic.push(candidate);
-						parts.push({
-							kind: "dynamic",
-							candidate
-						});
-						return true;
-					}
-					if (candidate?.styleSet) {
-						matched.push(candidate);
-						parts.push({
-							kind: "style",
-							candidate
-						});
-						return true;
-					}
-					if (candidate?.item.type === "viewTransition" && candidate.replacement && candidate.className) {
-						constantCandidates.push(candidate);
-						parts.push({
-							kind: "class",
-							value: candidate.className,
-							candidate
-						});
-						return true;
-					}
-					if (ts_morph.Node.isStringLiteral(arg) || ts_morph.Node.isNoSubstitutionTemplateLiteral(arg)) {
-						parts.push({
-							kind: "class",
-							value: arg.getLiteralValue()
-						});
-						return true;
-					}
-					if (ts_morph.Node.isArrayLiteralExpression(arg)) {
-						for (const element of arg.getElements()) if (ts_morph.Node.isSpreadElement(element) || !take(element)) return false;
-						return true;
-					}
-					if (arg.getKind() === ts_morph.SyntaxKind.FalseKeyword || arg.getKind() === ts_morph.SyntaxKind.TrueKeyword || ts_morph.Node.isNumericLiteral(arg) || arg.getKind() === ts_morph.SyntaxKind.NullKeyword || ts_morph.Node.isIdentifier(arg) && arg.getText() === "undefined") return true;
-					return false;
-				};
-				for (const arg of call.getArguments()) {
-					if (take(arg)) continue;
-					supported = false;
-					break;
-				}
-				if (dynamic.length > 1) {
-					skipped.push({
-						name: "cx",
-						reason: "dynamic",
-						start: call.getStart(),
-						end: call.getEnd()
-					});
-					continue;
-				}
-				if (!supported) {
-					skipped.push({
-						name: "cx",
-						reason: "dynamic",
-						start: call.getStart(),
-						end: call.getEnd()
-					});
-					continue;
-				}
-				if (dynamic.length === 1 && matched.length > 0) {
-					const dynamicCandidate = dynamic[0];
-					const styleParts = parts.filter((part) => part.kind !== "class");
-					const dynamicIndex = styleParts.findIndex((part) => part.kind === "dynamic");
-					const before = styleParts.slice(0, dynamicIndex).filter((part) => part.kind === "style").map((part) => part.candidate.styleSet);
-					const after = styleParts.slice(dynamicIndex + 1).filter((part) => part.kind === "style").map((part) => part.candidate.styleSet);
-					const compiled = dynamicCandidate.styleMap.compile(before, after);
-					const expression = compiled.usesHelper && dynamicCandidate.mapHelperName && dynamicCandidate.mapHelperName !== "cvaMap" ? compiled.expression.replaceAll(`${RECIPE_MAP_HELPER}(`, `${dynamicCandidate.mapHelperName}(`) : compiled.expression;
-					const arguments_ = [];
-					let wroteCompiled = false;
-					for (const part of parts) {
-						if (part.kind === "class") {
-							if (part.value) arguments_.push(JSON.stringify(part.value));
-							continue;
-						}
-						if (!wroteCompiled) {
-							arguments_.push(expression);
-							wroteCompiled = true;
-						}
-					}
-					dynamicCandidate.subsumed = true;
-					const first = styleParts[0].candidate;
-					candidates.push({
-						...first,
-						call,
-						node: call,
-						start: call.getStart(),
-						end: call.getEnd(),
-						displayName: "cx",
-						replacement: arguments_.length === 1 ? arguments_[0] : `${callee.getText()}(${arguments_.join(", ")})`,
-						className: "",
-						classNames: [...compiled.classNames, ...parts.filter((part) => part.kind === "class").flatMap((part) => part.value.split(" "))].filter(Boolean),
-						styleSet: void 0,
-						styleMap: void 0,
-						outputKind: void 0,
-						insert: compiled.usesHelper ? dynamicCandidate.insert : void 0,
-						sourceBoxes: styleParts.flatMap((part) => [part.candidate.item.box, part.candidate.configBox]).concat(constantCandidates.map((candidate) => candidate.item.box)).filter(Boolean)
-					});
-					continue;
-				}
-				if (matched.length === 0) {
-					if (constantCandidates.length === 0) continue;
-					const className = parts.filter((part) => part.kind === "class").map((part) => part.value).filter(Boolean).join(" ");
-					const first = constantCandidates[0];
-					candidates.push({
-						...first,
-						call,
-						node: call,
-						start: call.getStart(),
-						end: call.getEnd(),
-						displayName: "cx",
-						replacement: JSON.stringify(className),
-						className,
-						classNames: className.split(" ").filter(Boolean),
-						sourceBoxes: constantCandidates.map((candidate) => candidate.item.box).filter(Boolean)
-					});
-					continue;
-				}
-				const merged = styleCompiler.compose(...matched.map((candidate) => candidate.styleSet));
-				const compiled = styleCompiler.className(merged);
-				const classParts = [];
-				let wroteCompiled = false;
-				for (const part of parts) {
-					if (part.kind === "class") {
-						if (part.value) classParts.push(part.value);
-						continue;
-					}
-					if (!wroteCompiled && compiled) {
-						classParts.push(compiled);
-						wroteCompiled = true;
-					}
-				}
-				const first = matched[0];
-				candidates.push({
-					...first,
-					call,
-					node: call,
-					start: call.getStart(),
-					end: call.getEnd(),
-					displayName: "cx",
-					replacement: JSON.stringify(classParts.join(" ")),
-					className: classParts.join(" "),
-					classNames: classParts.flatMap((part) => part.split(" ")).filter(Boolean),
-					styleSet: merged,
-					sourceBoxes: [...matched.flatMap((candidate) => [candidate.item.box, candidate.configBox]), ...constantCandidates.map((candidate) => candidate.item.box)].filter(Boolean)
-				});
-			}
-		}
-		for (const candidate of candidates) {
-			if (!candidate.styleMap || candidate.subsumed || candidate.replacement) continue;
-			const compiled = candidate.styleMap.compile();
-			candidate.replacement = compiled.usesHelper && candidate.mapHelperName && candidate.mapHelperName !== "cvaMap" ? compiled.expression.replaceAll(`${RECIPE_MAP_HELPER}(`, `${candidate.mapHelperName}(`) : compiled.expression;
-			if (!compiled.usesHelper) candidate.insert = void 0;
-			candidate.className = compiled.staticClasses;
-			candidate.classNames = compiled.classNames;
-			candidate.outputKind = compiled.outputKind === "slots" ? "slots" : void 0;
-		}
-	}
-	/**
-	* Ranges the rewrite actually replaced. Declared before the early return below, because
-	* that return is now also a reporting point: a module with nothing to fold is exactly the
-	* shape `reportSurvivors` exists to catch.
-	*/
-	const applied = [];
-	if (candidates.length === 0 && recipeDefinitions.length === 0) {
-		if (reportSurvivors) reportRuntimeBindings();
-		return {
-			code,
-			map: null,
-			folded,
-			skipped,
-			dependencies: []
-		};
-	}
-	const rewriteSourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile() ?? recipeDefinitions[0]?.call.getSourceFile();
-	if (!rewriteSourceFile) return {
-		code,
-		map: null,
-		folded,
-		skipped,
-		dependencies: []
-	};
-	const dependencyScan = createDependencyScan(rewriteSourceFile);
-	candidates.sort((a, b) => a.start - b.start || b.end - a.end);
-	const magic = new magic_string.default(code);
-	const insertedNames = /* @__PURE__ */ new Set();
-	const applyInsert = (insert) => {
-		if (!insert) return;
-		const missing = insert.names.filter((name) => !insertedNames.has(name));
-		if (!missing.length) return;
-		magic.appendLeft(insert.pos, insert.module ? `\nimport { ${missing.join(", ")} } from '${insert.module}'` : missing.map((name) => `, ${name}`).join(""));
-		for (const name of missing) insertedNames.add(name);
-	};
-	const collides = (edits) => edits.some(([start, end]) => applied.some(([from, to]) => start < to && from < end));
-	for (const candidate of candidates) {
-		const { item, start, end } = candidate;
-		const name = candidate.displayName ?? item.name ?? item.type ?? "";
-		const ranges = [[start, end]];
-		if (collides(ranges)) {
-			skipped.push({
-				name,
-				reason: "overlapping",
-				start,
-				end
-			});
-			continue;
-		}
-		if (candidate.value !== void 0) {
-			magic.overwrite(start, end, JSON.stringify(candidate.value));
-			applied.push(...ranges);
-			folded.push({
-				name,
-				kind: "value",
-				className: "",
-				classNames: [],
-				value: candidate.value,
-				start,
-				end
-			});
-			collectSourceFiles(item.box, dependencyScan);
-			continue;
-		}
-		if (candidate.replacement) {
-			magic.overwrite(start, end, candidate.replacement);
-			applyInsert(candidate.insert);
-			applied.push(...ranges);
-			folded.push({
-				name,
-				kind: candidate.outputKind ?? "class",
-				className: candidate.className,
-				classNames: (candidate.classNames ?? [candidate.className]).filter(Boolean),
-				start,
-				end
-			});
-			collectSourceFiles(item.box, dependencyScan);
-			if (candidate.configBox) collectSourceFiles(candidate.configBox, dependencyScan);
-			for (const box of candidate.sourceBoxes ?? []) collectSourceFiles(box, dependencyScan);
-			continue;
-		}
-		let className;
-		try {
-			if (item.type === "pattern") className = runtimeCss(...item.data.map((entry) => ctx.patterns.transform(name, entry)));
-			else className = runtimeCss(...item.data);
-		} catch {
-			skipped.push({
-				name,
-				reason: "dynamic",
-				start,
-				end
-			});
-			continue;
-		}
-		magic.overwrite(start, end, JSON.stringify(className));
-		applied.push(...ranges);
-		folded.push({
-			name,
-			kind: "class",
-			className,
-			classNames: className ? [className] : [],
-			start,
-			end
-		});
-		collectSourceFiles(item.box, dependencyScan);
-	}
-	const recipeSourceFile = candidates[0]?.node.getSourceFile();
-	if (recipeSourceFile && mayNameSplitVariantProps(recipeSourceFile.getFullText())) for (const access of recipeSourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.PropertyAccessExpression)) {
-		if (access.getName() !== "splitVariantProps") continue;
-		const target = access.getExpression();
-		if (!ts_morph.Node.isIdentifier(target)) continue;
-		if (isShadowed(access, target.getText())) continue;
-		const local = recipeConfigs?.get(target.getText());
-		const importedConfig = !local && importsFor(recipeSourceFile).has(target.getText()) ? ctx.recipes.getConfig(target.getText()) : void 0;
-		const entry = local && local !== AMBIGUOUS ? local : importedConfig ? {
-			config: importedConfig,
-			box: void 0
-		} : void 0;
-		if (!entry) continue;
-		const call = access.getParent();
-		if (!ts_morph.Node.isCallExpression(call) || call.getExpression() !== access) continue;
-		const args = call.getArguments();
-		if (args.length !== 1) continue;
-		const start = call.getStart();
-		const end = call.getEnd();
-		if (code.slice(start, end) !== call.getText()) continue;
-		if (collides([[start, end]])) continue;
-		const helper = ensureRecipeHelperImport(SPLIT_PROPS_HELPER, call, isBambooCssModule, isGeneratedCssModule, isShadowed, helperModules.get(target.getText()), helperModuleFromSubpath);
-		if (!helper) continue;
-		const keys = Object.keys(entry.config.variants ?? {});
-		magic.overwrite(start, end, `${helper.name}(${args[0].getText()}, ${JSON.stringify(keys)})`);
-		applyInsert(helper.insert);
-		applied.push([start, end]);
-	}
-	for (const { name, call } of recipeDefinitions) {
-		const start = call.getStart();
-		const end = call.getEnd();
-		if (collides([[start, end]])) continue;
-		magic.overwrite(start, end, "undefined");
-		applied.push([start, end]);
-		folded.push({
-			name,
-			kind: "definition",
-			className: "",
-			classNames: [],
-			start,
-			end
-		});
-	}
-	/**
-	* Bindings from a bamboo module still referenced once every rewrite is applied.
-	*
-	* Deliberately not driven by `parserResult`: that is the recogniser, and the point here is
-	* to catch what it did not see. A namespace import called as `s.cva(...)`, a default
-	* import, a specifier that resolved to nothing — each leaves a live reference and no ledger
-	* entry at all, which used to let a build silently ship the engine.
-	*
-	* The helpers the compiler writes are excluded because they pull no style engine. `cx` is
-	* also allowed to remain when it joins an arbitrary external class; only fully analyzable
-	* arguments receive Bamboo's semantic composition guarantee.
-	*/
-	/** The specifier this module imported `binding` through, if it did. */
-	function importSpecifierFor(sourceFile, binding) {
-		for (const declaration of sourceFile.getImportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			for (const named of declaration.getNamedImports()) {
-				if (named.isTypeOnly()) continue;
-				if ((named.getAliasNode() ?? named.getNameNode()).getText() === binding) return named.getAliasNode() ?? named.getNameNode();
-			}
-		}
-	}
-	function reportRuntimeBindings() {
-		const sourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile() ?? recipeDefinitions[0]?.call.getSourceFile();
-		if (!sourceFile) return;
-		const importedRecipeBindings = new Set(parserResult.importedRecipes?.keys() ?? []);
-		/**
-		* Every identifier in the module, grouped by the name it spells — built at most once per
-		* pass, and only when something below has a name to look up.
-		*
-		* One index answers for every binding, rather than a walk per binding. Built here rather
-		* than cached across passes: it holds nodes, and a node does not outlive its source file
-		* being replaced.
-		*
-		* Deferred because most modules in an app neither declare nor import a recipe, and the
-		* walk is not cheap — `getDescendantsOfKind` wraps every identifier in the file in a
-		* ts-morph node to answer a question those modules never ask. It was 11% of a 6,307-file
-		* build, most of it spent producing an index nothing read.
-		*/
-		let identifiers;
-		const identifiersByName = () => identifiers ??= identifierIndex(sourceFile);
-		for (const binding of new Set([...recipeConfigs.keys(), ...importedRecipeBindings])) {
-			const entry = recipeConfigs.get(binding);
-			if (entry === AMBIGUOUS) continue;
-			if (!entry && !importedRecipeBindings.has(binding)) continue;
-			const definition = entry?.box?.getNode?.();
-			const nameNode = definition?.getSourceFile() === sourceFile ? definition?.getFirstAncestorByKind(ts_morph.SyntaxKind.VariableDeclaration)?.getNameNode() : importSpecifierFor(sourceFile, binding);
-			if (!nameNode || !ts_morph.Node.isIdentifier(nameNode)) continue;
-			const references = localReferencesTo(identifiersByName(), binding, nameNode);
-			if (skipped.filter((item) => SURVIVES_TO_RUNTIME.has(item.reason) && item.end > item.start).some((item) => references.some((ref) => ref.getStart() >= item.start && ref.getStart() < item.end))) continue;
-			const survivor = references.find((ref) => !applied.some(([from, to]) => ref.getStart() >= from && ref.getStart() < to));
-			if (!survivor) continue;
-			skipped.push({
-				name: binding,
-				reason: "runtime-binding",
-				start: survivor.getStart(),
-				end: survivor.getEnd()
-			});
-		}
-		const bambooModules = [
-			...cssModules,
-			...ctx.imports.matchers.recipe?.mods ?? [],
-			...ctx.imports.matchers.pattern?.mods ?? [],
-			...ctx.imports.matchers.tokens?.mods ?? []
-		];
-		const runtimeCalls = [];
-		const importEquals = [];
-		sourceFile.forEachDescendant((node) => {
-			if (ts_morph.Node.isCallExpression(node)) runtimeCalls.push(node);
-			else if (ts_morph.Node.isImportEqualsDeclaration(node)) importEquals.push(node);
-		});
-		for (const call of runtimeCalls) {
-			const callee = call.getExpression();
-			const argument = call.getArguments()[0];
-			if (!argument || !ts_morph.Node.isStringLiteral(argument) && !ts_morph.Node.isNoSubstitutionTemplateLiteral(argument)) continue;
-			if (!matchesModule(argument.getLiteralValue(), bambooModules)) continue;
-			const isDynamicImport = callee.getKind() === ts_morph.SyntaxKind.ImportKeyword;
-			const isRequire = ts_morph.Node.isIdentifier(callee) && callee.getText() === "require" && !isShadowed(call, "require");
-			if (!isDynamicImport && !isRequire) continue;
-			skipped.push({
-				name: isDynamicImport ? "import" : "require",
-				reason: "runtime-binding",
-				start: call.getStart(),
-				end: call.getEnd()
-			});
-		}
-		for (const declaration of importEquals) {
-			if (declaration.isTypeOnly()) continue;
-			const reference = declaration.getModuleReference();
-			if (!ts_morph.Node.isExternalModuleReference(reference)) continue;
-			const expression = reference.getExpression();
-			if (!expression || !ts_morph.Node.isStringLiteral(expression) || !matchesModule(expression.getLiteralValue(), bambooModules)) continue;
-			skipped.push({
-				name: declaration.getName(),
-				reason: "runtime-binding",
-				start: declaration.getStart(),
-				end: declaration.getEnd()
-			});
-		}
-		/** Local name -> what to call it in the report. */
-		const watched = /* @__PURE__ */ new Map();
-		for (const declaration of sourceFile.getImportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			if (!matchesModule(declaration.getModuleSpecifierValue(), bambooModules)) continue;
-			for (const named of declaration.getNamedImports()) {
-				if (named.isTypeOnly()) continue;
-				const imported = named.getNameNode().getText();
-				if (PERMITTED_BINDINGS.has(imported)) continue;
-				watched.set((named.getAliasNode() ?? named.getNameNode()).getText(), imported);
-			}
-			const namespace = declaration.getNamespaceImport();
-			if (namespace) watched.set(namespace.getText(), `${namespace.getText()}.*`);
-			const defaultImport = declaration.getDefaultImport();
-			if (defaultImport) watched.set(defaultImport.getText(), defaultImport.getText());
-		}
-		for (const declaration of sourceFile.getExportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			if (!matchesModule(declaration.getModuleSpecifierValue() ?? "", bambooModules)) continue;
-			if (declaration.isNamespaceExport()) {
-				skipped.push({
-					name: declaration.getNamespaceExport()?.getName() ?? "*",
-					reason: "runtime-binding",
-					start: declaration.getStart(),
-					end: declaration.getEnd()
-				});
-				continue;
+		},
+		resolveId(id) {
+			const query = queryOf(id);
+			const base = id.slice(0, id.length - query.length);
+			if (base !== "virtual:bamboo.css" && base !== RESOLVED_ID) return null;
+			return `${RESOLVED_ID}${query}`;
+		},
+		async load(id) {
+			const query = queryOf(id);
+			if (id.slice(0, id.length - query.length) !== RESOLVED_ID) return null;
+			session.cssLoaded = true;
+			const generationAtStart = changeGeneration;
+			if (command === "serve" && servedCss?.generation === generationAtStart) {
+				if (this.addWatchFile) for (const file of extractedSourceFiles()) this.addWatchFile(file);
+				return servedCss.css;
 			}
-			for (const named of declaration.getNamedExports()) {
-				if (named.isTypeOnly()) continue;
-				const imported = named.getNameNode().getText();
-				if (PERMITTED_BINDINGS.has(imported)) continue;
-				skipped.push({
-					name: imported,
-					reason: "runtime-binding",
-					start: named.getStart(),
-					end: named.getEnd()
-				});
+			let css;
+			try {
+				const validateDevCss = command === "serve" ? (await loadCssOutput()).pruneStaticCss : void 0;
+				const first = prebuilt;
+				prebuilt = void 0;
+				css = await (first ?? generate());
+				if (validateDevCss) css = validateDevCss(css, session, { prune: false });
+			} catch (error) {
+				throw asError(error, `failed to generate ${VIRTUAL_CSS_ID}`);
 			}
-		}
-		for (const declaration of sourceFile.getExportDeclarations()) {
-			if (declaration.isTypeOnly() || declaration.getModuleSpecifier()) continue;
-			for (const named of declaration.getNamedExports()) {
-				if (named.isTypeOnly()) continue;
-				const imported = watched.get(named.getNameNode().getText());
-				if (imported === void 0) continue;
-				skipped.push({
-					name: imported,
-					reason: "runtime-binding",
-					start: named.getStart(),
-					end: named.getEnd()
-				});
+			if (command === "serve" && generationAtStart === changeGeneration) servedCss = {
+				generation: generationAtStart,
+				css
+			};
+			if (this.addWatchFile) for (const file of extractedSourceFiles()) this.addWatchFile(file);
+			return css;
+		},
+		configureServer(devServer) {
+			server = devServer;
+			/**
+			* The graph the stylesheet's own module lives in, which is the one that has to reach it.
+			*
+			* `load` registers every extracted file with `addWatchFile`, and `vite:css-analysis`
+			* turns those into real importer edges — the virtual module ends up a direct importer of
+			* each file the extractor read. So an edit to any of them propagates to the stylesheet on
+			* Vite's own pass, in whichever environment holds that edge.
+			*
+			* The client one, because CSS is a client concern: an ssr environment never applies a
+			* stylesheet update, and asking whether *any* environment matched would skip the forced
+			* reload below for a server-only module whose styles the client still has to be told
+			* 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;
+				if (!ctx) return;
+				const absoluteFile = ctx.runtime.path.abs(ctx.config.cwd, file);
+				if (!session.extractedFiles.has(absoluteFile)) return;
+				changeGeneration++;
+				prebuilt = void 0;
+				const mod = server?.moduleGraph.getModuleById(RESOLVED_ID);
+				if (!mod) return;
+				if (clientGraph.getModulesByFile(absoluteFile)?.size) return;
+				server?.moduleGraph.invalidateModule(mod);
+				server?.reloadModule(mod);
+				_bamboocss_logger.logger.debug("vite", `styles invalidated by ${absoluteFile}`);
+			};
+			devServer.watcher.on("change", invalidate);
+			devServer.watcher.on("add", invalidate);
+			devServer.watcher.on("unlink", invalidate);
+		},
+		generateBundle: {
+			order: "post",
+			async handler(outputOptions, bundle) {
+				const { containsGeneratedCssAsset, optimizeStaticCssAssets } = await loadCssOutputModule();
+				const environment = this.environment;
+				const environmentName = environment?.name ?? "default";
+				const replacesGeneratedStylesheet = containsGeneratedCssAsset(bundle);
+				const outputProjection = session.beginOutputProjection(environmentName, outputOptions, bundle, replacesGeneratedStylesheet);
+				try {
+					/**
+					* Pruned against what this environment compiled, without waiting for the rest.
+					*
+					* The stylesheet is emitted and finalized by the environment that *imports* it, which
+					* in an SSR app is the client — and the client builds first, before the server
+					* environment has transformed a single module. Waiting for a complete answer therefore
+					* meant never pruning at all in any SSR framework: react-router, Remix, Nuxt, SvelteKit
+					* and Qwik all build the client first, and the client's output is on disk before the
+					* server environment starts. That is most production apps, and the feature was inert in
+					* every one of them — silently, since a build with nothing to prune looks identical.
+					*
+					* The reason for waiting was real: a class only the server graph reaches is not in this
+					* environment's reachability set, so pruning here removes rules the server-rendered
+					* markup still names. What makes it safe to prune anyway is that the mistake is
+					* *detectable* rather than silent — `buildEnd` in `plugin.ts` intersects every later
+					* environment's compiled classes against `prunedClasses` and fails the build naming
+					* them. A styled component that only ever renders on the server is the shape that
+					* trips it, and `pruneCss: false` is the answer when it does.
+					*
+					* So the trade is deliberate: a loud build failure in the rare case, in exchange for
+					* the feature working at all in the common one. It is the same reasoning as the
+					* unimported-`virtual:bamboo.css` check — a class with no rule behind it must never
+					* leave the build quietly.
+					*/
+					const pending = remainingEnvironments(session);
+					if (pending.length) _bamboocss_logger.logger.debug("vite", `Pruning against the ${JSON.stringify(environment?.name ?? "default")} environment with ${(0, _bamboocss_shared.truncateList)(pending, {
+						unit: "environment",
+						separator: ", "
+					})} still to compile. A class only those reach fails the build rather than shipping without its rule.`);
+					const { sheets } = optimizeStaticCssAssets(bundle, session, {
+						environment: environmentName,
+						prune: pruneCss,
+						requiredClasses: outputProjection.requiredClasses,
+						sourcemap: environment?.config?.build?.sourcemap
+					});
+					if (sheets && !pruneCss) _bamboocss_logger.logger.info("vite", "Reachability pruning is off (`pruneCss: false`). The full extracted stylesheet ships.");
+					if (!outputProjection.cssLoaded) return;
+					if (!session.transformedFiles.size) return;
+					/**
+					* An SSR bundle emits no CSS assets, and is not supposed to.
+					*
+					* `build.ssrEmitAssets` is off by default, so Vite discards them: the client build is
+					* what carries the stylesheet, and a server bundle that imports `virtual:bamboo.css`
+					* from shared code — a root component, a layout — still asks this plugin to load it.
+					* Which means the environment *served* the sheet and then emitted nothing, and the
+					* check below read that as the failure it exists to catch.
+					*
+					* It fails a build that is entirely correct. Qwik's `vite build --ssr` is the shape
+					* that showed it: 7/7 calls compiled, the client bundle carrying the stylesheet, and
+					* the server bundle refusing to finish. React Router does not hit it only because its
+					* plugin turns `ssrEmitAssets` on.
+					*
+					* Read per environment where that exists, falling back to the run's own config, so
+					* Vite 5's single-config builds are answered by the same question.
+					*/
+					const buildOptions = environment?.config?.build ?? ssrBuildOptions;
+					if (buildOptions?.ssr && !buildOptions.ssrEmitAssets) return;
+					if (!replacesGeneratedStylesheet) throw new Error(`bamboocss: ${session.transformedFiles.size} module(s) were compiled to Bamboo class values, but no emitted asset carries the generated stylesheet. The build would ship unstyled.\n\nThis happens when another plugin, or the bundler itself, drops or replaces the CSS asset after it is emitted. If you are on Rolldown, report this — the rename that used to cause it is already disabled there. Otherwise look for a plugin running in \`generateBundle\` that rewrites CSS assets.`);
+				} finally {
+					outputProjection.restore();
+				}
 			}
 		}
-		if (watched.size === 0) return;
-		const declined = skipped.filter((entry) => SURVIVES_TO_RUNTIME.has(entry.reason) && entry.end > entry.start).map((entry) => [entry.start, entry.end]);
-		const survivors = [];
-		for (const [local, imported] of watched) for (const identifier of identifiersByName().get(local)) {
-			const start = identifier.getStart();
-			if (identifier.getFirstAncestorByKind(ts_morph.SyntaxKind.ImportDeclaration)) continue;
-			if (applied.some(([from, to]) => start >= from && start < to)) continue;
-			if (declined.some(([from, to]) => start >= from && start < to)) continue;
-			if (!isValueReference(identifier)) continue;
-			if (isShadowed(identifier, local)) continue;
-			survivors.push({
-				name: imported,
-				reason: "runtime-binding",
-				start,
-				end: identifier.getEnd()
-			});
-			break;
-		}
-		survivors.sort((a, b) => a.start - b.start);
-		skipped.push(...survivors);
-	}
-	if (reportSurvivors) reportRuntimeBindings();
-	if (folded.length === 0) return {
-		code,
-		map: null,
-		folded,
-		skipped,
-		dependencies: []
-	};
-	return {
-		code: magic.toString(),
-		map: magic.generateMap({
-			source: options.filePath,
-			hires: true,
-			includeContent: true
-		}),
-		folded,
-		skipped,
-		dependencies: [...dependencyScan.results, ...foreignDependencies]
-	};
-};
-//#endregion
-//#region src/style-set.ts
-const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-/** A compound selector matches only through variant classes the recipe actually emits. */
-const matchesCompound = (compound, selection, variants) => {
-	for (const [key, expected] of Object.entries(compound)) {
-		if (key === "css") continue;
-		const declared = variants?.[key];
-		const selected = selection[key];
-		if (selected == null || !declared || !Object.hasOwn(declared, String(selected))) return false;
-		if (!(Array.isArray(expected) ? expected : [expected]).some((value) => value != null && String(selected) === String(value))) return false;
-	}
-	return true;
-};
-/**
-* Resolve the style fragments one recipe call contributes, in emitted-rule precedence.
-*
-* This intentionally rejects conditional variant *selections*. A scalar selects a style
-* object; an object such as `{ base: 'sm', md: 'lg' }` selects several objects under
-* conditions and needs a separate lowering. Returning `undefined` rejects that call instead
-* of silently compiling only one branch.
-*/
-const createStaticStyleSetCompiler = (ctx, runtimeCss, allocateClassString = (className) => className) => {
-	const { mergeCssUncached } = (0, _bamboocss_shared.createMergeCss)(createCssContext(ctx));
-	const compose = (...styles) => mergeCssUncached(...styles);
-	const resolveRecipe = (config, input = {}, slot) => {
-		const slots = Array.isArray(config.slots) ? config.slots : void 0;
-		if (Boolean(slots) !== Boolean(slot)) return void 0;
-		if (slot && !slots?.includes(slot)) return void 0;
-		const selection = {
-			...config.defaultVariants ?? {},
-			...(0, _bamboocss_shared.compact)(input)
-		};
-		if (Object.values(selection).some((value) => isRecord(value))) return void 0;
-		const fragments = [];
-		const take = (candidate) => {
-			if (!isRecord(candidate)) return;
-			const styles = slot ? candidate[slot] : candidate;
-			if (isRecord(styles)) fragments.push(styles);
-		};
-		take(config.base);
-		for (const variant of Object.keys(config.variants ?? {})) {
-			const value = selection[variant];
-			if (value == null) continue;
-			take(config.variants?.[variant]?.[String(value)]);
-		}
-		for (const compound of config.compoundVariants ?? []) {
-			if (!isRecord(compound) || !matchesCompound(compound, selection, config.variants)) continue;
-			take(compound.css);
-		}
-		return compose(...fragments);
-	};
-	return {
-		compose,
-		resolveRecipe,
-		className: (...styles) => runtimeCss(...styles),
-		allocateClassString
 	};
 };
 //#endregion
 //#region src/plugin.ts
 const DEFAULT_EXTENSIONS = /\.(?:[cm]?[jt]sx?)$/;
 const NODE_MODULES = /node_modules/;
+const TRANSFORM_META_KEY = "bamboocss:transform";
+const TRANSFORM_ARTIFACT_VERSION = 3;
 /**
 * Queries that make Vite serve something other than the module's own source.
 *
@@ -3213,46 +648,181 @@ const formatSkipped = (id, skipped) => {
 */
 const bamboocss = (options = {}) => {
 	const { configPath, cwd, reportSkipped = false, reportSummary = true, maxRecipeStates, pruneCss = true } = options;
-	(0, _bamboocss_node.markStaticCompilerActive)();
+	(0, _bamboocss_node_static_compiler.markStaticCompilerActive)();
 	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();
+	const transformArtifactIntegrityKey = (0, node_crypto.randomBytes)(32);
+	const serializeTransformArtifact = (environment, artifact) => JSON.stringify([
+		TRANSFORM_META_KEY,
+		environment,
+		artifact.version,
+		artifact.moduleId,
+		artifact.file,
+		artifact.folded,
+		artifact.skipped.map(([reason, count]) => [reason, count]),
+		artifact.survivors.map(({ line, name, reason }) => [
+			line,
+			name,
+			reason
+		]),
+		artifact.transformedFile,
+		[...artifact.classNames],
+		[...artifact.dependencies],
+		artifact.signature ? [
+			artifact.signature.input,
+			artifact.signature.output,
+			artifact.signature.path
+		] : null
+	]);
+	const transformArtifactIntegrity = (environment, artifact) => (0, node_crypto.createHmac)("sha256", transformArtifactIntegrityKey).update(serializeTransformArtifact(environment, artifact)).digest("base64url");
+	const sealTransformArtifact = (environment, artifact) => ({
+		...artifact,
+		integrity: transformArtifactIntegrity(environment, artifact)
+	});
+	const skipReasons = new Set([
+		"dynamic",
+		"raw-call",
+		"recipe-call",
+		"unsupported-kind",
+		"not-imported",
+		"no-call-expression",
+		"overlapping",
+		"unresolved-token",
+		"runtime-binding",
+		"compile-failed"
+	]);
+	const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+	const isNonNegativeInteger = (value) => Number.isSafeInteger(value) && value >= 0;
+	const isPositiveInteger = (value) => Number.isSafeInteger(value) && value > 0;
+	const isTransformArtifact = (value) => {
+		if (!isRecord(value) || value.version !== TRANSFORM_ARTIFACT_VERSION) return false;
+		if (typeof value.moduleId !== "string" || typeof value.file !== "string") return false;
+		if (!isNonNegativeInteger(value.folded) || typeof value.transformedFile !== "boolean") return false;
+		if (typeof value.integrity !== "string" || !/^[\w-]{43}$/.test(value.integrity)) return false;
+		if (!Array.isArray(value.classNames) || !value.classNames.every((entry) => typeof entry === "string")) return false;
+		if (!Array.isArray(value.dependencies) || !value.dependencies.every((entry) => typeof entry === "string")) return false;
+		if (!Array.isArray(value.skipped) || !value.skipped.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && skipReasons.has(entry[0]) && isPositiveInteger(entry[1]))) return false;
+		if (!Array.isArray(value.survivors) || !value.survivors.every((entry) => isRecord(entry) && Number.isSafeInteger(entry.line) && entry.line >= 1 && typeof entry.name === "string" && typeof entry.reason === "string" && skipReasons.has(entry.reason))) return false;
+		if (value.signature === void 0) return true;
+		return isRecord(value.signature) && typeof value.signature.input === "string" && typeof value.signature.output === "string" && value.signature.path === value.file;
+	};
+	const hasValidTransformArtifactIntegrity = (environment, artifact) => {
+		const expected = Buffer.from(transformArtifactIntegrity(environment, artifact));
+		const actual = Buffer.from(artifact.integrity);
+		return actual.length === expected.length && (0, node_crypto.timingSafeEqual)(actual, expected);
+	};
+	const cachedArtifactError = (id, environment, value, snapshotProblem) => {
+		let problem;
+		if (snapshotProblem) problem = snapshotProblem;
+		else if (!isRecord(value) || value.version !== TRANSFORM_ARTIFACT_VERSION) problem = isRecord(value) && (typeof value.version === "number" || typeof value.version === "string") ? `uses version ${JSON.stringify(value.version)}; expected schema version ${TRANSFORM_ARTIFACT_VERSION}` : `is malformed and has no valid version; expected schema version ${TRANSFORM_ARTIFACT_VERSION}`;
+		else if (!isTransformArtifact(value)) problem = `is malformed for schema version ${TRANSFORM_ARTIFACT_VERSION}`;
+		else if (value.moduleId !== id || value.file !== id.split("?")[0]) problem = `does not belong to this module id and physical file`;
+		else if (!hasValidTransformArtifactIntegrity(environment, value)) problem = `failed its schema version ${TRANSFORM_ARTIFACT_VERSION} integrity check`;
+		else problem = `could not be validated for schema version ${TRANSFORM_ARTIFACT_VERSION}`;
+		return /* @__PURE__ */ new Error(`bamboocss: cached transform metadata for ${JSON.stringify(id)} in the ${JSON.stringify(environment)} environment ${problem}.\n\nBamboo cannot safely rebuild from this entry because cached JavaScript may still name CSS classes whose rules would be dropped. Restart Vite to invalidate its in-memory transform cache. If this persists, clear Vite's cache directory and rebuild.`);
+	};
+	const transformStateByEnvironment = /* @__PURE__ */ new Map();
 	/**
-	* What each file's transform found, for the summary. Keyed by file rather than summed as it
-	* goes, because a build has more than one environment and they share most of their modules.
+	* One fold per file content per change event, shared across environments and hooks.
 	*
-	* Running totals double-counted every shared module once per environment — a two-environment
-	* build of one shared file and one entry each reported "2/2 across 2/4 files" for three
-	* source modules. Coverage is a property of the source, not of how many times a bundler
-	* handed the same file over. It also grew without bound in dev, where every HMR
-	* re-transform of a file counted as another file.
+	* A single edit folds the same bytes repeatedly: `hotUpdate` provisionally re-folds every
+	* dependent once per environment to decide what to invalidate, then `transform` folds the
+	* edited module for the client graph, again for SSR, and once more for each update a
+	* framework re-drives — react-router's server-change trigger calls `reloadModule` per pass.
+	* All of them read the same shared ts-morph project under the same config, so the result is
+	* a function of the bytes alone and the repeats were pure cost: on the app this was measured
+	* on, four transforms of a 46 kB route module per edit, ~10 ms each.
 	*
-	* A second pass over a file replaces its entry rather than adding to it. Both environments
-	* are assumed to compute the same answer for the same module — true of this compiler, though
-	* not something the plugin can enforce, since another `pre` plugin may hand each environment
-	* different code. Where they disagree the last one wins, which is a cosmetic number either
-	* way.
+	* `watchChange` clears it, which is the exact validity window: entries are correct until a
+	* file event changes what a fold could resolve, and `watchChange` is the one hook Vite calls
+	* for every such event before any update work begins. The per-environment resolution closure
+	* is deliberately not memoized — `withResolutionClosure` is recomputed per consumer against
+	* that environment's own recorded dependencies.
+	*
+	* Keyed by path *and* content digest, not path alone, because one physical file is served
+	* as more than one module shape in the same event — react-router clips a route module down
+	* to its route exports for the client graph while SSR gets the full file — and a last-write
+	* key would make the two shapes evict each other on every pass.
+	*
+	* Dev only, like the verdict memo it sits beside: a build transforms each module once per
+	* environment with no bracketing events, and holding every module's fold for the length of a
+	* build is memory a one-shot pass has no reason to spend.
 	*/
-	const perFile = /* @__PURE__ */ new Map();
-	const staticSession = createStaticCompilationSession();
+	const foldMemoByContent = /* @__PURE__ */ new Map();
+	const foldMemoKey = (filePath, inputDigest) => `${filePath}\0${inputDigest}`;
 	/**
-	* Indexed by file, because the only bulk operation on it is "forget this one's".
+	* The Project resolution walk `withResolutionClosure` runs, memoized per change event.
 	*
-	* A flat array meant every transform scanned every survivor and then rebuilt the dedupe key
-	* set from scratch — O(modules x survivors) across a build, and worst exactly when a build is
-	* already failing and the user is iterating on it. One project had 736 of them across 9,461
-	* modules, which is seven million string builds to discard.
+	* The walk is the dominant per-dependent cost once the fold itself is memoized — it runs
+	* once per dependent per environment with identical inputs, since both environments record
+	* the same fold dependencies for byte-identical source. Same bracketing as the fold memo:
+	* `watchChange` clears it, so no entry outlives the project state it was computed against.
 	*/
-	const survivorsByFile = /* @__PURE__ */ new Map();
-	const allSurvivors = () => [...survivorsByFile.values()].flat();
-	const addSurvivor = (entry) => {
-		const forFile = survivorsByFile.get(entry.file) ?? [];
-		if (forFile.some((seen) => seen.line === entry.line && seen.name === entry.name && seen.reason === entry.reason)) return;
-		forFile.push(entry);
-		survivorsByFile.set(entry.file, forFile);
-	};
-	const clearSurvivorsFor = (file) => {
-		survivorsByFile.delete(file);
+	const resolutionClosureMemo = /* @__PURE__ */ new Map();
+	/** The immutable generation currently occupying each configured output on disk. */
+	const liveOutputSlotsByEnvironment = /* @__PURE__ */ new Map();
+	/** Graphs which passed `buildEnd`, but whose output has not succeeded yet. */
+	const preparedGenerations = /* @__PURE__ */ new Map();
+	/** Success accumulated across hosts which run one buildStart/buildEnd pair per output. */
+	const pendingOutputCycles = /* @__PURE__ */ new Map();
+	/** Last configured output whose render phase actually began, for missing-marker recovery. */
+	const lastStartedOutputSlotByEnvironment = /* @__PURE__ */ new Map();
+	const nextBuildSerialByEnvironment = /* @__PURE__ */ new Map();
+	const observedBuildSerialByEnvironment = /* @__PURE__ */ new Map();
+	const buildSerialByState = /* @__PURE__ */ new WeakMap();
+	/** Output finalizers installed by the `options` hook for the next generation. */
+	const outputTokensByEnvironment = /* @__PURE__ */ new Map();
+	const OUTPUT_FINALIZER = Symbol("bamboocss-output-finalizer");
+	const OUTPUT_START_MARKER = Symbol("bamboocss-output-start-marker");
+	const DIRECT_OUTPUT_TOKEN = 0;
+	let nextOutputToken = 0;
+	let nextEpochId = 0;
+	const outputIdentityByBundle = /* @__PURE__ */ new WeakMap();
+	const outputIdentityByOptions = /* @__PURE__ */ new WeakMap();
+	const outputStageByBundle = /* @__PURE__ */ new WeakMap();
+	const outputStageByOptions = /* @__PURE__ */ new WeakMap();
+	const environmentOf = (context) => context.environment;
+	const environmentName = (context) => environmentOf(context)?.name ?? "default";
+	const newEnvironmentState = () => ({
+		transformArtifactsByModule: /* @__PURE__ */ new Map(),
+		dependentsByDependency: /* @__PURE__ */ new Map(),
+		dependenciesByModule: /* @__PURE__ */ new Map(),
+		filesByModule: /* @__PURE__ */ new Map(),
+		foldSignatures: /* @__PURE__ */ new Map(),
+		recipeConfigCache: /* @__PURE__ */ new Map(),
+		transformedModulesThisRun: /* @__PURE__ */ new Set(),
+		unchangedFolds: /* @__PURE__ */ new Map(),
+		changedRun: 0,
+		cssLoaded: false
+	});
+	const cloneEnvironmentState = (state) => ({
+		transformArtifactsByModule: new Map(state.transformArtifactsByModule),
+		dependentsByDependency: new Map([...state.dependentsByDependency].map(([dependency, dependents]) => [dependency, new Set(dependents)])),
+		dependenciesByModule: new Map([...state.dependenciesByModule].map(([moduleId, dependencies]) => [moduleId, new Set(dependencies)])),
+		filesByModule: new Map(state.filesByModule),
+		foldSignatures: new Map(state.foldSignatures),
+		recipeConfigCache: new Map(state.recipeConfigCache),
+		transformedModulesThisRun: new Set(state.transformedModulesThisRun),
+		unchangedFolds: new Map(state.unchangedFolds),
+		changedRun: state.changedRun,
+		cssLoaded: state.cssLoaded
+	});
+	const environmentState = (context) => {
+		const identity = environmentName(context);
+		let state = transformStateByEnvironment.get(identity);
+		if (!state) {
+			state = newEnvironmentState();
+			transformStateByEnvironment.set(identity, state);
+		}
+		return state;
 	};
+	const allSurvivors = (states) => [...states].flatMap((state) => [...state.transformArtifactsByModule.values()].flatMap((artifact) => artifact.survivors.map(({ line, name, reason }) => ({
+		file: artifact.file,
+		line,
+		name,
+		reason
+	}))));
 	const createSurvivorError = (entries) => {
 		const byFile = /* @__PURE__ */ new Map();
 		for (const entry of entries) {
@@ -3269,13 +839,6 @@ const bamboocss = (options = {}) => {
 		return /* @__PURE__ */ new Error(`bamboocss: ${entries.length} call(s) could not be compiled.\n\n${detail}\n\n` + (threw ? "`compile-failed` is a module the compiler threw on — see the error logged for it above. Nothing was established about its calls either way.\n\n" : "") + (entries.some((entry) => entry.reason === "runtime-binding") ? "`runtime-binding` is a Bamboo value read rather than called. An inline `cva`/`sva` declaration is erased, so its binding is `undefined` at runtime: calling it compiles, including from another module, but reading the value itself — `const alias = badge`, `badge.raw(...)`, re-exporting it — has nothing behind it. The location given is the read to change, not the declaration.\n\n" : "") + "Bamboo emits no runtime styling fallback or recipe layer. Make the values finite and statically analyzable, move variation into declared recipe variants, or safelist intentional dynamic classes with `staticCss`.\n\nSet `BAMBOO_DIAGNOSTIC_LIMIT=all` to list every finding rather than the first few.");
 	};
 	/**
-	* Recipe configs read out of modules other than the one being transformed.
-	*
-	* Per build rather than per module: a recipe declared once and imported by fifty components
-	* would otherwise re-parse its module fifty times, which is the transform path.
-	*/
-	const recipeConfigCache = /* @__PURE__ */ new Map();
-	/**
 	* Which modules folded a value read out of which other module, for dev invalidation.
 	*
 	* `addWatchFile` reports the same edges, and in a build that is enough — Rollup discards a
@@ -3300,26 +863,27 @@ const bamboocss = (options = {}) => {
 	* Keyed by dependency, since "what changed" is the question asked, and tracked in the other
 	* direction as well so a re-transform can retract edges the module no longer has.
 	*/
-	const dependentsByDependency = /* @__PURE__ */ new Map();
-	const dependenciesByFile = /* @__PURE__ */ new Map();
-	const recordFoldDependencies = (file, dependencies) => {
-		const next = new Set(dependencies.map(normalizeFsPath).filter((dependency) => dependency !== file));
-		const previous = dependenciesByFile.get(file);
+	const recordFoldDependencies = (state, moduleId, file, dependencies) => {
+		const { dependenciesByModule, dependentsByDependency, filesByModule } = state;
+		const normalizedFile = normalizeFsPath(file);
+		const next = new Set(dependencies.map(normalizeFsPath).filter((dependency) => dependency !== normalizedFile));
+		const previous = dependenciesByModule.get(moduleId);
+		filesByModule.set(moduleId, file);
 		for (const dependency of previous ?? []) {
 			if (next.has(dependency)) continue;
 			const dependents = dependentsByDependency.get(dependency);
-			if (!dependents?.delete(file)) continue;
+			if (!dependents?.delete(moduleId)) continue;
 			if (!dependents.size) dependentsByDependency.delete(dependency);
 		}
 		if (!next.size) {
-			dependenciesByFile.delete(file);
+			dependenciesByModule.delete(moduleId);
 			return;
 		}
-		dependenciesByFile.set(file, next);
+		dependenciesByModule.set(moduleId, next);
 		for (const dependency of next) {
 			const dependents = dependentsByDependency.get(dependency);
-			if (dependents) dependents.add(file);
-			else dependentsByDependency.set(dependency, new Set([file]));
+			if (dependents) dependents.add(moduleId);
+			else dependentsByDependency.set(dependency, new Set([moduleId]));
 		}
 	};
 	/**
@@ -3333,7 +897,7 @@ const bamboocss = (options = {}) => {
 	* Digests, not text. Retaining every consumer's source and compiled output for the life of the
 	* process is the same order of memory as the ts-morph project already holding it; two 44-byte
 	* strings per entry is not, and it does not grow with module size. The set is bounded the way
-	* `dependenciesByFile` is — an entry exists only while a module's fold actually reads another
+	* `dependenciesByModule` is — an entry exists only while a module's fold actually reads another
 	* file, which most modules never do — so a project that folds nothing across a boundary pays
 	* neither the bytes nor the hashing.
 	*
@@ -3343,16 +907,343 @@ const bamboocss = (options = {}) => {
 	* that comparison and is treated as changed. `path` is the spelling `transform` used, because
 	* ts-morph and the fold both key on it and Windows spells it more than one way.
 	*/
-	const foldSignatures = /* @__PURE__ */ new Map();
 	const digest = (text) => (0, node_crypto.createHash)("sha256").update(text).digest("base64");
+	/** Fingerprint the generated Bamboo assets after every plugin which may rewrite the bundle. */
+	const bambooCssDigest = (bundle) => {
+		const assets = [];
+		for (const output of Object.values(bundle)) {
+			if (!isRecord(output) || output.type !== "asset") continue;
+			const { source } = output;
+			if (typeof source !== "string" && !(source instanceof Uint8Array)) continue;
+			const text = typeof source === "string" ? source : Buffer.from(source).toString();
+			if (!text.includes("--made-with-bamboo")) continue;
+			assets.push(text);
+		}
+		if (!assets.length) return void 0;
+		return digest(JSON.stringify(assets.sort()));
+	};
+	/** Add one detached transform contribution to the global reachability projection. */
+	const applyStaticTransformContribution = (artifact) => {
+		if (artifact.transformedFile) staticSession.transformedFiles.add((0, node_path.resolve)(artifact.file));
+		for (const className of artifact.classNames) staticSession.markClassUsed(className);
+	};
+	/**
+	* Re-derive the two global sets CSS pruning consumes from environment-owned artifacts.
+	*
+	* A watch run may rebuild one environment or several at once. The candidate being judged
+	* replaces its own previous contribution; every sibling contributes its committed generation,
+	* even when a replacement for that sibling is already in flight. Its old JavaScript remains
+	* the live output until the replacement succeeds, so pruning against a half-filled candidate
+	* would remove rules that output still names.
+	*/
+	const contributionStates = (candidateEnvironment, candidateState) => {
+		const states = [];
+		const seenEpochs = /* @__PURE__ */ new Set();
+		let candidateIncluded = false;
+		for (const [environment, slots] of liveOutputSlotsByEnvironment) if (environment === candidateEnvironment && candidateState) {
+			states.push(candidateState);
+			candidateIncluded = true;
+		} else for (const { epoch } of slots.values()) {
+			if (seenEpochs.has(epoch.id)) continue;
+			seenEpochs.add(epoch.id);
+			states.push(epoch.state);
+		}
+		if (candidateEnvironment && candidateState && !candidateIncluded) states.push(candidateState);
+		return states;
+	};
+	const rebuildStaticTransformContributions = (candidateEnvironment, candidateState) => {
+		staticSession.transformedFiles.clear();
+		staticSession.usedClasses.clear();
+		staticSession.cssLoaded = false;
+		for (const state of contributionStates(candidateEnvironment, candidateState)) {
+			if (state.cssLoaded) staticSession.cssLoaded = true;
+			for (const artifact of state.transformArtifactsByModule.values()) applyStaticTransformContribution(artifact);
+		}
+	};
+	/**
+	* Snapshot which reported classes Bamboo actually extracted for this JavaScript generation.
+	*
+	* Fold artifacts also report literal classes passed through helpers such as `cx('external',
+	* css(...))`. Intersecting with the extraction inventory keeps those useful reachability facts
+	* without later demanding that Bamboo provide a rule it never owned.
+	*/
+	const ownedClassesForState = (state) => {
+		const extracted = new Map([...staticSession.prunableClasses].map((className) => [require_class_name.bare(className), className]));
+		const owned = /* @__PURE__ */ new Set();
+		for (const artifact of state.transformArtifactsByModule.values()) for (const reported of artifact.classNames) for (const token of reported.split(" ")) {
+			if (!token) continue;
+			const extractedClass = extracted.get(require_class_name.bare(token));
+			if (extractedClass !== void 0) owned.add(extractedClass);
+		}
+		return owned;
+	};
+	const createTransformEpoch = (state) => {
+		const detachedState = cloneEnvironmentState(state);
+		return {
+			id: ++nextEpochId,
+			state: detachedState,
+			ownedClasses: ownedClassesForState(detachedState)
+		};
+	};
+	/** Apply the same candidate-replaces-its-environment rule as the reachability projection. */
+	const requiredClassesForProjection = (candidateEnvironment, candidateOwnedClasses) => {
+		const required = /* @__PURE__ */ new Set();
+		let candidateIncluded = false;
+		const seenEpochs = /* @__PURE__ */ new Set();
+		for (const [environment, slots] of liveOutputSlotsByEnvironment) {
+			if (environment === candidateEnvironment) {
+				for (const className of candidateOwnedClasses) required.add(className);
+				candidateIncluded = true;
+				continue;
+			}
+			for (const { epoch } of slots.values()) {
+				if (seenEpochs.has(epoch.id)) continue;
+				seenEpochs.add(epoch.id);
+				for (const className of epoch.ownedClasses) required.add(className);
+			}
+		}
+		if (!candidateIncluded) for (const className of candidateOwnedClasses) required.add(className);
+		return required;
+	};
+	const currentRequiredClasses = () => {
+		const prunable = new Set([...staticSession.prunableClasses].map(require_class_name.bare));
+		return new Set([...staticSession.usedClasses].filter((className) => prunable.has(require_class_name.bare(className))));
+	};
+	/** Derive loss history from the stylesheet outputs which are still observable. */
+	const rebuildLivePrunedClasses = () => {
+		staticSession.prunedClasses.clear();
+		for (const slots of liveOutputSlotsByEnvironment.values()) for (const slot of slots.values()) for (const className of slot.prunedClasses ?? []) staticSession.prunedClasses.add(className);
+	};
+	const observeEnvironmentBuildStart = (environment) => {
+		const serial = (nextBuildSerialByEnvironment.get(environment) ?? 0) + 1;
+		nextBuildSerialByEnvironment.set(environment, serial);
+		observedBuildSerialByEnvironment.set(environment, serial);
+	};
+	/** Open a replacement without discarding the generation a failed rebuild can fall back to. */
+	const beginEnvironmentGeneration = (environment) => {
+		preparedGenerations.delete(environment);
+		const state = newEnvironmentState();
+		const observedSerial = observedBuildSerialByEnvironment.get(environment);
+		const buildSerial = observedSerial ?? (nextBuildSerialByEnvironment.get(environment) ?? 0) + 1;
+		if (observedSerial === void 0) nextBuildSerialByEnvironment.set(environment, buildSerial);
+		else observedBuildSerialByEnvironment.delete(environment);
+		buildSerialByState.set(state, buildSerial);
+		transformStateByEnvironment.set(environment, state);
+		staticSession.participatingEnvironments.add(environment);
+		if (liveOutputSlotsByEnvironment.get(environment)?.size) staticSession.completedEnvironments.add(environment);
+		else staticSession.completedEnvironments.delete(environment);
+		rebuildStaticTransformContributions();
+		return state;
+	};
+	/** Collapse an environment to a generation which replaced all of its observable outputs. */
+	const completeEnvironmentGeneration = (environment, state) => {
+		if (transformStateByEnvironment.get(environment) !== state) return;
+		const epoch = createTransformEpoch(state);
+		liveOutputSlotsByEnvironment.set(environment, new Map([[DIRECT_OUTPUT_TOKEN, { epoch }]]));
+		staticSession.completedEnvironments.add(environment);
+		rebuildStaticTransformContributions();
+		rebuildLivePrunedClasses();
+	};
+	const prepareEnvironmentGeneration = (environment, state) => {
+		if (transformStateByEnvironment.get(environment) !== state) return;
+		preparedGenerations.set(environment, {
+			state,
+			epoch: createTransformEpoch(state),
+			buildSerial: buildSerialByState.get(state) ?? 0,
+			outputTokens: new Set(outputTokensByEnvironment.get(environment) ?? []),
+			stagedOutputs: /* @__PURE__ */ new Map()
+		});
+		rebuildStaticTransformContributions();
+	};
+	const sameTokens = (left, right) => left.size === right.size && [...left].every((token) => right.has(token));
+	/** The first configured output is an observable boundary even when its later hooks throw. */
+	const beginOutputCycle = (environment, outputSlot) => {
+		const previousSlot = lastStartedOutputSlotByEnvironment.get(environment);
+		if (outputSlot === 0 || previousSlot !== void 0 && outputSlot <= previousSlot) pendingOutputCycles.delete(environment);
+		lastStartedOutputSlotByEnvironment.set(environment, outputSlot);
+	};
+	const completeOutputCycle = (environment, cycle) => {
+		liveOutputSlotsByEnvironment.set(environment, new Map(cycle.candidatesBySlot));
+		pendingOutputCycles.delete(environment);
+		preparedGenerations.delete(environment);
+		staticSession.completedEnvironments.add(environment);
+		rebuildStaticTransformContributions();
+		rebuildLivePrunedClasses();
+	};
+	const publishPreparedOutput = (environment, outputToken, outputSlot, wasWritten) => {
+		const generation = preparedGenerations.get(environment);
+		if (!generation || transformStateByEnvironment.get(environment) !== generation.state) return;
+		if (!generation.outputTokens.has(outputToken)) return;
+		const mode = wasWritten ? "write" : "memory";
+		let cycle = pendingOutputCycles.get(environment);
+		const serialContinues = cycle !== void 0 && outputSlot > cycle.lastOutputSlot && (generation.buildSerial === cycle.lastBuildSerial || generation.buildSerial === cycle.lastBuildSerial + (outputSlot - cycle.lastOutputSlot));
+		if (!cycle || cycle.mode !== mode || !sameTokens(cycle.expectedTokens, generation.outputTokens) || cycle.successfulTokens.has(outputToken) || !serialContinues) {
+			cycle = {
+				expectedTokens: new Set(generation.outputTokens),
+				successfulTokens: /* @__PURE__ */ new Set(),
+				candidatesBySlot: /* @__PURE__ */ new Map(),
+				lastBuildSerial: generation.buildSerial,
+				lastOutputSlot: outputSlot,
+				mode
+			};
+			pendingOutputCycles.set(environment, cycle);
+		}
+		const stage = generation.stagedOutputs.get(outputToken);
+		const candidateSlot = {
+			epoch: generation.epoch,
+			...stage?.prunedClasses ? { prunedClasses: new Set(stage.prunedClasses) } : {}
+		};
+		cycle.successfulTokens.add(outputToken);
+		cycle.candidatesBySlot.set(outputSlot, candidateSlot);
+		cycle.lastBuildSerial = generation.buildSerial;
+		cycle.lastOutputSlot = outputSlot;
+		const allOutputsSucceeded = cycle.successfulTokens.size === cycle.expectedTokens.size;
+		if (wasWritten) {
+			const slots = liveOutputSlotsByEnvironment.get(environment) ?? /* @__PURE__ */ new Map();
+			slots.set(outputSlot, candidateSlot);
+			liveOutputSlotsByEnvironment.set(environment, slots);
+			staticSession.completedEnvironments.add(environment);
+			rebuildStaticTransformContributions();
+			rebuildLivePrunedClasses();
+		}
+		if (!allOutputsSucceeded || !wasWritten) return;
+		completeOutputCycle(environment, cycle);
+	};
+	const closePreparedMemoryOutputs = (environment) => {
+		const cycle = pendingOutputCycles.get(environment);
+		if (!cycle || cycle.mode !== "memory" || cycle.successfulTokens.size !== cycle.expectedTokens.size) return;
+		completeOutputCycle(environment, cycle);
+	};
+	/** Restore the still-live output contribution when the replacement generation fails. */
+	const rollbackEnvironmentGeneration = (environment, state) => {
+		if (transformStateByEnvironment.get(environment) !== state) return;
+		preparedGenerations.delete(environment);
+		pendingOutputCycles.delete(environment);
+		const slots = liveOutputSlotsByEnvironment.get(environment);
+		const liveEpochs = /* @__PURE__ */ new Map();
+		for (const { epoch } of slots?.values() ?? []) liveEpochs.set(epoch.id, epoch);
+		const latestLive = [...liveEpochs.values()].sort((a, b) => a.id - b.id).at(-1);
+		if (latestLive) {
+			transformStateByEnvironment.set(environment, cloneEnvironmentState(latestLive.state));
+			staticSession.completedEnvironments.add(environment);
+		} else {
+			transformStateByEnvironment.delete(environment);
+			staticSession.completedEnvironments.delete(environment);
+		}
+		rebuildStaticTransformContributions();
+		rebuildLivePrunedClasses();
+	};
+	staticSession.beginOutputProjection = (environment, outputOptions, bundle, replacesGeneratedStylesheet) => {
+		const generation = preparedGenerations.get(environment);
+		if (!generation || transformStateByEnvironment.get(environment) !== generation.state) {
+			const currentState = transformStateByEnvironment.get(environment);
+			return {
+				cssLoaded: currentState?.cssLoaded ?? staticSession.cssLoaded,
+				requiredClasses: requiredClassesForProjection(environment, currentState ? ownedClassesForState(currentState) : currentRequiredClasses()),
+				restore() {}
+			};
+		}
+		const committedPrunedClasses = staticSession.prunedClasses;
+		staticSession.prunedClasses = new Set(committedPrunedClasses);
+		rebuildStaticTransformContributions(environment, generation.epoch.state);
+		const requiredClasses = requiredClassesForProjection(environment, generation.epoch.ownedClasses);
+		if (replacesGeneratedStylesheet) staticSession.prunedClasses.clear();
+		let restored = false;
+		return {
+			cssLoaded: generation.epoch.state.cssLoaded,
+			requiredClasses,
+			restore() {
+				if (restored) return;
+				restored = true;
+				const stage = replacesGeneratedStylesheet ? {
+					cssDigest: bambooCssDigest(bundle),
+					prunedClasses: new Set(staticSession.prunedClasses)
+				} : {};
+				outputStageByBundle.set(bundle, stage);
+				outputStageByOptions.set(outputOptions, stage);
+				staticSession.prunedClasses = committedPrunedClasses;
+				rebuildStaticTransformContributions();
+			}
+		};
+	};
+	/** Aggregate environment-owned coverage once the participating generation is complete. */
+	const reportTransformCoverage = (states) => {
+		const perFile = /* @__PURE__ */ new Map();
+		const reportedCoverageByModule = /* @__PURE__ */ new Map();
+		for (const state of states) for (const artifact of state.transformArtifactsByModule.values()) {
+			const coverageKey = JSON.stringify([
+				artifact.file,
+				artifact.folded,
+				artifact.skipped
+			]);
+			const reported = reportedCoverageByModule.get(artifact.moduleId);
+			if (reported?.has(coverageKey)) continue;
+			if (reported) reported.add(coverageKey);
+			else reportedCoverageByModule.set(artifact.moduleId, new Set([coverageKey]));
+			const entry = perFile.get(artifact.file) ?? {
+				folded: 0,
+				skipped: /* @__PURE__ */ new Map()
+			};
+			entry.folded += artifact.folded;
+			for (const [reason, count] of artifact.skipped) entry.skipped.set(reason, (entry.skipped.get(reason) ?? 0) + count);
+			perFile.set(artifact.file, entry);
+		}
+		let folded = 0;
+		let filesWithFolds = 0;
+		const skipped = /* @__PURE__ */ new Map();
+		for (const entry of perFile.values()) {
+			folded += entry.folded;
+			if (entry.folded) filesWithFolds++;
+			for (const [reason, count] of entry.skipped) skipped.set(reason, (skipped.get(reason) ?? 0) + count);
+		}
+		const declined = Array.from(skipped.values()).reduce((sum, count) => sum + count, 0);
+		const total = folded + declined;
+		if (!total) return;
+		const share = Math.round(folded / total * 100);
+		const reasons = Array.from(skipped.entries()).sort((a, b) => b[1] - a[1]).map(([reason, count]) => `${reason}=${count}`).join(" ");
+		_bamboocss_logger.logger.info("vite:transform", `Compiled ${folded}/${total} (${share}%) across ${filesWithFolds}/${perFile.size} files` + (reasons ? ` — declined: ${reasons}` : ""));
+	};
+	/** Restore every per-build fact established by one successful transform. */
+	const applyTransformArtifact = (state, value, expectedModuleId, environment) => {
+		let snapshot;
+		try {
+			snapshot = structuredClone(value);
+		} catch {
+			throw cachedArtifactError(expectedModuleId, environment, void 0, `could not be snapshotted as serializable schema version ${TRANSFORM_ARTIFACT_VERSION} data`);
+		}
+		if (!isTransformArtifact(snapshot) || snapshot.moduleId !== expectedModuleId || snapshot.file !== expectedModuleId.split("?")[0] || !hasValidTransformArtifactIntegrity(environment, snapshot)) throw cachedArtifactError(expectedModuleId, environment, snapshot);
+		const artifact = snapshot;
+		const { file, moduleId } = artifact;
+		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);
+	};
 	/**
-	* Consumers this edit cannot move, resolved once per watcher event.
+	* Replay transform metadata for modules Rollup reused from its cache.
 	*
-	* `hotUpdate` runs once per environment — client and ssr both — and the answer is a property
-	* of the files, not of which environment is asking. Cleared in `watchChange`, which every Vite
-	* in the peer range calls for every file event, before either update hook.
+	* `buildStart` has to clear reachability because a watch rebuild may have a different graph,
+	* but Rollup does not call `transform` again for an unchanged module. The transform result is
+	* still present on that module as serializable metadata, and `buildEnd` is the common Rollup
+	* and Rolldown point where the complete graph can be enumerated while CSS generation is still
+	* ahead of us. Replaying here restores the exact state pruning and the finished-build guards
+	* would have observed after a clean build.
+	*
+	* Freshly transformed module IDs are skipped inside this environment only. Besides avoiding
+	* duplicate work, that makes a failed transform authoritative: an older cached artifact must
+	* not overwrite the diagnostic and signature retraction established by the failing pass.
 	*/
-	const unchangedFolds = /* @__PURE__ */ new Map();
+	const replayCachedTransformArtifacts = (pluginContext) => {
+		if (!pluginContext.getModuleIds || !pluginContext.getModuleInfo) return;
+		const state = environmentState(pluginContext);
+		for (const id of pluginContext.getModuleIds()) {
+			if (state.transformedModulesThisRun.has(id)) continue;
+			const meta = pluginContext.getModuleInfo(id)?.meta;
+			if (!meta || !Object.prototype.hasOwnProperty.call(meta, TRANSFORM_META_KEY)) continue;
+			const artifact = meta[TRANSFORM_META_KEY];
+			applyTransformArtifact(state, artifact, id, environmentName(pluginContext));
+		}
+	};
 	/**
 	* How many dependents in a row may come back changed before the check gives up for this event.
 	*
@@ -3379,7 +1270,6 @@ const bamboocss = (options = {}) => {
 	* run to reach eight, the consumers seen so far have to be uniformly changed.
 	*/
 	const CHANGED_RUN_LIMIT = 8;
-	let changedRun = 0;
 	/**
 	* Whether re-folding `dependent` now produces exactly the bytes it produced last time.
 	*
@@ -3394,64 +1284,72 @@ const bamboocss = (options = {}) => {
 	* that returns nothing, a fold that throws — because "changed" is what this path did before,
 	* and a wrong "unchanged" is a stale class string in the browser.
 	*/
-	const foldOutputUnchanged = (dependent) => {
-		const memoized = unchangedFolds.get(dependent);
+	const foldOutputUnchanged = (state, dependent) => {
+		const memoized = state.unchangedFolds.get(dependent);
 		if (memoized !== void 0) return memoized;
-		const unchanged = changedRun < CHANGED_RUN_LIMIT && refoldMatchesSignature(dependent);
-		changedRun = unchanged ? 0 : changedRun + 1;
-		unchangedFolds.set(dependent, unchanged);
+		const unchanged = state.changedRun < CHANGED_RUN_LIMIT && refoldMatchesSignature(state, dependent);
+		state.changedRun = unchanged ? 0 : state.changedRun + 1;
+		state.unchangedFolds.set(dependent, unchanged);
 		return unchanged;
 	};
-	const refoldMatchesSignature = (dependent) => {
-		const signature = foldSignatures.get(dependent);
-		if (!signature || !ctx || !runtimeCss || !styleCompiler) return false;
+	const refoldMatchesSignature = (state, dependent) => {
+		const signature = state.foldSignatures.get(dependent);
+		if (!signature || !ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return false;
 		try {
 			const code = (0, node_fs.readFileSync)(signature.path, "utf8");
-			if (digest(code) !== signature.input) return false;
-			const sourceFile = ctx.project.addSourceFile(signature.path, code);
-			const parserResult = ctx.project.parseSourceFile(signature.path);
-			if (!parserResult) return false;
-			const result = foldSource({
-				ctx,
-				code,
-				parserResult,
-				filePath: signature.path,
-				runtimeCss,
-				styleCompiler,
-				maxRecipeStates,
-				parseModule: (path) => ctx?.project.parseSourceFile(path),
-				recipeConfigCache,
-				reportSurvivors: false,
-				sourceFile
-			});
+			const inputDigest = digest(code);
+			if (inputDigest !== signature.input) return false;
+			let raw;
+			let parserDependencies;
+			const memoKey = foldMemoKey(signature.path, 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);
+				if (!parserResult) return false;
+				raw = foldSourceImpl({
+					ctx,
+					code,
+					parserResult,
+					filePath: signature.path,
+					runtimeCss,
+					styleCompiler,
+					maxRecipeStates,
+					parseModule: (path) => ctx?.project.parseSourceFile(path),
+					recipeConfigCache: state.recipeConfigCache,
+					reportSurvivors: false,
+					sourceFile
+				});
+				parserDependencies = parserResult.getDependencies();
+				foldMemoByContent.set(memoKey, {
+					result: raw,
+					parserDependencies,
+					reportedSurvivors: false
+				});
+			}
+			const result = withResolutionClosure(signature.path, raw, parserDependencies, state.dependenciesByModule.get(dependent));
 			const unchanged = digest(result.code) === signature.output;
 			/**
-			* Edges re-recorded on the way to suppressing a module, and never on the way to
-			* invalidating one.
+			* Edges re-recorded exactly on the way to suppressing a module. A changed provisional
+			* fold may add newly observed edges, but never retracts the last recoverable ones.
 			*
 			* The first is necessary: *which* files a module folds from can move while the bytes it
 			* emits do not — a value now re-exported through a different module, say — and suppressing
 			* the announcement means no transform will run to notice. Leaving the old edges would make
 			* the next edit to the new dependency reach nobody.
 			*
-			* The second would be a bug, and is the reason this is a branch rather than an
-			* unconditional write. `hotUpdate` runs once per environment, client then ssr, against one
-			* shared map. A fold that now yields nothing — an export renamed, a call commented out, any
-			* ordinary mid-edit state — returns `dependencies: []`, so writing it here would retract the
-			* consumer's edge during the *client* pass and leave the *ssr* pass finding an empty set and
-			* returning without invalidating anything: the stale compiled class kept in the SSR cache,
-			* with the client half correctly updated. That is the shape of the bug the self-accepting
-			* fix was about, one environment over. `transform` performs the same retraction, but only
-			* after every environment has already invalidated, which is why it is safe there.
-			*
-			* Confining the write to the unchanged branch removes the hazard rather than sequencing
-			* around it, because a retraction cannot reach that branch: `dependencies` is empty only
-			* when `folded.length === 0`, and a fold that folds nothing returns the module's own source,
-			* which cannot equal an output digest recorded from a pass that replaced a call with a
-			* literal. And where an unchanged verdict *does* narrow the edges, both passes agree anyway
-			* — neither invalidates a module it has just called unchanged.
+			* A changed result is only a provisional check on the way to a real transform. Its reads
+			* can warm the extractor cache, so the authoritative parse may not cross every nested
+			* module again; retaining the union gives that transform semantic targets to validate
+			* against the current Project ledger. It then records the exact answer. If that pass
+			* throws, the additive update has kept every old edge while also making a fix in a newly
+			* observed dependency able to retry it.
 			*/
-			if (unchanged) recordFoldDependencies(dependent, result.dependencies);
+			if (unchanged) recordFoldDependencies(state, dependent, signature.path, result.dependencies);
+			else recordFoldDependencies(state, dependent, signature.path, [...state.dependenciesByModule.get(dependent) ?? [], ...result.dependencies]);
 			return unchanged;
 		} catch {
 			return false;
@@ -3488,8 +1386,8 @@ const bamboocss = (options = {}) => {
 	* one can end in a page reload, which is the honest outcome: its compiled classes really did
 	* change, and a reload is what Vite does with any update nothing accepts.
 	*/
-	const foldDependentModules = (file, modules, graph) => {
-		const dependents = dependentsByDependency.get(normalizeFsPath(file));
+	const foldDependentModules = (state, file, modules, graph) => {
+		const dependents = state.dependentsByDependency.get(normalizeFsPath(file));
 		if (!dependents?.size) return;
 		const added = [];
 		for (const dependent of [...dependents]) {
@@ -3526,8 +1424,11 @@ const bamboocss = (options = {}) => {
 			* the edited module for a runtime value is still reached by `propagateUpdate` exactly as
 			* it would be with no plugin here at all — that direction was never this list's to decide.
 			*/
-			if (foldOutputUnchanged(dependent)) continue;
-			for (const module of graph.getModulesByFile(dependent) ?? []) {
+			if (foldOutputUnchanged(state, dependent)) continue;
+			const exact = graph.getModuleById?.(dependent);
+			const dependentFile = state.filesByModule.get(dependent) ?? dependent;
+			const candidates = exact ? [exact] : graph.getModulesByFile(normalizeFsPath(dependentFile)) ?? [];
+			for (const module of candidates) {
 				if (modules.includes(module) || added.includes(module)) continue;
 				graph.invalidateModule(module);
 				added.push(module);
@@ -3556,52 +1457,196 @@ const bamboocss = (options = {}) => {
 		return [...modules, ...added];
 	};
 	let ctx;
+	let foldSourceImpl;
 	let runtimeCss;
 	let styleCompiler;
 	let command = "build";
-	let setup;
-	const ensureContext = async () => {
-		if (!setup) setup = (0, _bamboocss_node.loadConfigAndCreateContext)({
+	let defaultEmitAssets = true;
+	/**
+	* Expand semantic leaf reads through the Project's exact resolution paths.
+	*
+	* Most boxed values point at their final declaration, which the fold reports directly. An
+	* evaluated imported helper is different: its returned box belongs to the local call node,
+	* while ParserResult records the modules crossed during that evaluation. Seed from both so
+	* neither form can leave compiled JavaScript stale. A re-export or barrel on either path can
+	* change which declaration the same import selects and must be watched too. Supplying only
+	* these semantic leaves back to Project keeps unrelated runtime-import branches out and walks
+	* only the indexed closure rather than scanning the global ledger.
+	*/
+	const withResolutionClosure = (filePath, result, parserDependencies = [], previousDependencies = void 0) => {
+		if (!ctx || !result.folded.length) return result;
+		const dependencies = new Set(result.dependencies);
+		for (const dependency of parserDependencies) if (!isGeneratedOutput(dependency, ctx)) dependencies.add(dependency);
+		const targets = new Set(dependencies);
+		for (const dependency of previousDependencies ?? []) targets.add(dependency);
+		if (!targets.size) return result;
+		const targetList = [...targets];
+		const closureKey = command === "serve" ? `${filePath}\0${targetList.slice().sort().join("|")}` : void 0;
+		let reachable = closureKey ? resolutionClosureMemo.get(closureKey) : void 0;
+		if (!reachable) {
+			reachable = ctx.project.getDependencies(filePath, targetList);
+			if (closureKey) resolutionClosureMemo.set(closureKey, reachable);
+		}
+		for (const dependency of reachable) if (!isGeneratedOutput(dependency, ctx)) dependencies.add(dependency);
+		const expanded = [...dependencies];
+		if (expanded.length === result.dependencies.length && expanded.every((dependency, index) => dependency === result.dependencies[index])) return result;
+		return {
+			...result,
+			dependencies: expanded
+		};
+	};
+	const loadContext = createRetryableLazy(async () => {
+		const { loadConfigAndCreateContext } = await loadNodeModule();
+		return loadConfigAndCreateContext({
 			configPath,
 			cwd,
 			dev: command === "serve"
-		}).then((loaded) => {
-			ctx = loaded;
-			runtimeCss = createRuntimeCss(loaded);
-			styleCompiler = createStaticStyleSetCompiler(loaded, runtimeCss);
 		});
-		await setup;
+	});
+	const loadCompilerState = createLazyCompilerState(loadContext, loadFoldModule);
+	const ensureContext = async () => {
+		ctx = await loadContext();
 	};
-	return [bamboocssCss({
-		configPath,
-		cwd,
-		session: staticSession,
-		pruneCss
-	}), {
+	const ensureCompilerState = async () => {
+		const loaded = await loadCompilerState();
+		ctx = loaded.context;
+		foldSourceImpl = loaded.foldSource;
+		runtimeCss = loaded.runtimeCss;
+		styleCompiler = loaded.styleCompiler;
+	};
+	const outputFinalizerTag = (value) => {
+		if (!value || typeof value !== "object") return void 0;
+		return value[OUTPUT_FINALIZER];
+	};
+	const outputStartMarkerTag = (value) => {
+		if (!value || typeof value !== "object") return void 0;
+		return value[OUTPUT_START_MARKER];
+	};
+	const findOutputFinalizer = (value, environment, outputSlot) => {
+		if (Array.isArray(value)) {
+			for (const entry of value) {
+				const found = findOutputFinalizer(entry, environment, outputSlot);
+				if (found) return found;
+			}
+			return;
+		}
+		const identity = outputFinalizerTag(value);
+		return identity?.environment === environment && identity.outputSlot === outputSlot ? value : void 0;
+	};
+	const findOutputStartMarker = (value, environment, outputSlot) => {
+		if (Array.isArray(value)) {
+			for (const entry of value) {
+				const found = findOutputStartMarker(entry, environment, outputSlot);
+				if (found) return found;
+			}
+			return;
+		}
+		const identity = outputStartMarkerTag(value);
+		return identity?.environment === environment && identity.outputSlot === outputSlot ? value : void 0;
+	};
+	const stripOutputLifecyclePlugins = (value) => {
+		if (Array.isArray(value)) return value.flatMap(stripOutputLifecyclePlugins);
+		return value == null || outputFinalizerTag(value) || outputStartMarkerTag(value) ? [] : [value];
+	};
+	const createOutputStartMarker = (environment, outputSlot) => {
+		return Object.assign({
+			name: `bamboocss:output-start:${environment}:${outputSlot}`,
+			renderStart: {
+				order: "pre",
+				sequential: true,
+				handler() {
+					beginOutputCycle(environment, outputSlot);
+				}
+			}
+		}, { [OUTPUT_START_MARKER]: {
+			environment,
+			outputSlot
+		} });
+	};
+	const createOutputFinalizer = (environment, outputSlot) => {
+		const outputToken = ++nextOutputToken;
+		return Object.assign({
+			name: `bamboocss:output-finalizer:${environment}:${outputSlot}`,
+			generateBundle: {
+				order: "post",
+				handler(outputOptions, bundle, isWrite) {
+					if (!bundle || typeof bundle !== "object") return;
+					const identity = {
+						environment,
+						outputSlot,
+						outputToken
+					};
+					outputIdentityByBundle.set(bundle, identity);
+					if (outputOptions && typeof outputOptions === "object") outputIdentityByOptions.set(outputOptions, identity);
+					const generation = preparedGenerations.get(environment);
+					const stage = outputStageByBundle.get(bundle) ?? (outputOptions && typeof outputOptions === "object" ? outputStageByOptions.get(outputOptions) : void 0);
+					if (stage?.cssDigest && bambooCssDigest(bundle) !== stage.cssDigest) throw new Error("bamboocss: an output plugin changed or removed the generated stylesheet after Bamboo finalized its reachability. The cached prune history would no longer describe the emitted CSS. Preserve the Bamboo asset in later `generateBundle` hooks, or run that transformation before Bamboo.");
+					if (generation && stage) generation.stagedOutputs.set(outputToken, stage);
+					if (!isWrite) publishPreparedOutput(environment, outputToken, outputSlot, false);
+				}
+			}
+		}, { [OUTPUT_FINALIZER]: {
+			environment,
+			outputSlot,
+			outputToken
+		} });
+	};
+	const installOutputFinalizers = (inputOptions, environment) => {
+		if (!inputOptions.output) {
+			outputTokensByEnvironment.delete(environment);
+			return;
+		}
+		const outputs = Array.isArray(inputOptions.output) ? inputOptions.output : [inputOptions.output];
+		const outputTokens = /* @__PURE__ */ new Set();
+		const installed = outputs.map((output, outputSlot) => {
+			const existing = findOutputFinalizer(output.plugins, environment, outputSlot);
+			const existingStart = findOutputStartMarker(output.plugins, environment, outputSlot);
+			if (existing && existingStart) {
+				outputTokens.add(existing[OUTPUT_FINALIZER].outputToken);
+				return output;
+			}
+			const finalizer = existing ?? createOutputFinalizer(environment, outputSlot);
+			const startMarker = existingStart ?? createOutputStartMarker(environment, outputSlot);
+			outputTokens.add(finalizer[OUTPUT_FINALIZER].outputToken);
+			output.plugins = [
+				startMarker,
+				...stripOutputLifecyclePlugins(output.plugins),
+				finalizer
+			];
+			return output;
+		});
+		inputOptions.output = Array.isArray(inputOptions.output) ? installed : installed[0];
+		outputTokensByEnvironment.set(environment, outputTokens);
+	};
+	const compiler = {
 		name: "bamboocss:compiler",
 		enforce: "pre",
 		/** See the same declaration on the css plugin: one instance per build, not per environment. */
 		sharedDuringBuild: true,
+		options(inputOptions) {
+			installOutputFinalizers(inputOptions, environmentName(this));
+			return inputOptions;
+		},
 		configResolved(config) {
 			command = config.command;
+			defaultEmitAssets = config.build?.emitAssets ?? (!config.build?.ssr || config.build?.ssrEmitAssets === true);
+			const plugins = config.plugins;
+			if (plugins) {
+				for (const finalizer of [outputWriteObserver, memoryOutputCommitter]) {
+					const index = plugins.indexOf(finalizer);
+					if (index !== -1) plugins.splice(index, 1);
+				}
+				plugins.unshift(outputWriteObserver);
+				plugins.push(memoryOutputCommitter);
+			}
 		},
 		async buildStart() {
-			const environment = this.environment?.name ?? "default";
-			if (staticSession.startedEnvironments.has(environment)) {
-				perFile.clear();
-				survivorsByFile.clear();
-				recipeConfigCache.clear();
-				dependentsByDependency.clear();
-				dependenciesByFile.clear();
-				foldSignatures.clear();
-				unchangedFolds.clear();
-				changedRun = 0;
-				resetStaticCompilationSession(staticSession);
-			}
-			staticSession.startedEnvironments.add(environment);
+			const environment = environmentName(this);
+			const state = beginEnvironmentGeneration(environment);
 			try {
 				await ensureContext();
 			} catch (error) {
+				rollbackEnvironmentGeneration(environment, state);
 				throw asError(error, "failed to load the bamboo config");
 			}
 		},
@@ -3626,17 +1671,27 @@ const bamboocss = (options = {}) => {
 		* the parser still holds the file.
 		*/
 		watchChange(id, change) {
-			unchangedFolds.clear();
-			changedRun = 0;
+			foldMemoByContent.clear();
+			resolutionClosureMemo.clear();
+			for (const state of transformStateByEnvironment.values()) {
+				state.unchangedFolds.clear();
+				state.changedRun = 0;
+			}
 			if (!ctx) return;
 			if (!shouldTransform(id)) return;
 			const [filePath] = id.split("?");
 			if (!filePath) return;
-			recipeConfigCache.clear();
+			for (const state of transformStateByEnvironment.values()) state.recipeConfigCache.clear();
 			if (change.event === "delete") {
 				ctx.project.removeSourceFile(filePath);
-				recordFoldDependencies(normalizeFsPath(filePath), []);
-				foldSignatures.delete(normalizeFsPath(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.transformArtifactsByModule.delete(moduleId);
+					state.filesByModule.delete(moduleId);
+				}
 				return;
 			}
 			ctx.project.reloadSourceFile(filePath);
@@ -3663,138 +1718,220 @@ const bamboocss = (options = {}) => {
 		hotUpdate({ file, modules }) {
 			const graph = this.environment?.moduleGraph;
 			if (!graph) return;
-			return foldDependentModules(file, modules, graph);
+			return foldDependentModules(environmentState(this), file, modules, graph);
 		},
 		handleHotUpdate({ file, modules, server }) {
 			const legacy = server;
 			if (legacy.environments) return;
-			return foldDependentModules(file, modules, legacy.moduleGraph);
+			return foldDependentModules(environmentState(this), file, modules, legacy.moduleGraph);
 		},
 		async transform(code, id) {
 			if (!shouldTransform(id)) return null;
 			try {
-				await ensureContext();
+				await ensureCompilerState();
 			} catch (error) {
-				throw asError(error, "failed to load the bamboo config");
+				throw asError(error, "failed to initialize the bamboo compiler");
 			}
-			if (!ctx || !runtimeCss || !styleCompiler) return null;
+			if (!ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return null;
 			const [filePath] = id.split("?");
-			clearSurvivorsFor(filePath);
 			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 sourceFile = ctx.project.addSourceFile(filePath, code);
-				const parserResult = ctx.project.parseSourceFile(filePath);
-				if (!parserResult) return null;
-				result = foldSource({
-					ctx,
-					code,
-					parserResult,
-					filePath,
-					runtimeCss,
-					styleCompiler,
-					maxRecipeStates,
-					parseModule: (path) => ctx?.project.parseSourceFile(path),
-					recipeConfigCache,
-					reportSurvivors: true,
-					sourceFile
-				});
+				const memoKey = command === "serve" ? foldMemoKey(filePath, inputDigest ??= digest(code)) : void 0;
+				const memoized = memoKey ? foldMemoByContent.get(memoKey) : void 0;
+				if (memoized?.reportedSurvivors) 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();
+					if (memoKey) foldMemoByContent.set(memoKey, {
+						result: folded,
+						parserDependencies,
+						reportedSurvivors: true
+					});
+					result = withResolutionClosure(filePath, folded, parserDependencies, previousDependencies);
+				}
 			} catch (error) {
 				_bamboocss_logger.logger.caughtError("vite:transform", `Failed to compile ${filePath}`, error);
-				perFile.set(filePath, {
-					folded: 0,
-					skipped: new Map([["compile-failed", 1]])
-				});
-				foldSignatures.delete(normalizeFsPath(filePath));
-				addSurvivor({
+				const previousDependencies = [...state.dependenciesByModule.get(id) ?? []];
+				applyTransformArtifact(state, sealTransformArtifact(environmentName(this), {
+					version: TRANSFORM_ARTIFACT_VERSION,
+					moduleId: id,
 					file: filePath,
-					line: 1,
-					name: "compiler",
-					reason: "compile-failed"
-				});
+					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;
 			}
-			let skippedHere;
-			for (const entry of result.skipped) {
-				skippedHere ??= /* @__PURE__ */ new Map();
-				skippedHere.set(entry.reason, (skippedHere.get(entry.reason) ?? 0) + 1);
-			}
-			perFile.set(filePath, {
-				folded: result.folded.length,
-				skipped: skippedHere
-			});
-			if (result.folded.some((entry) => entry.kind === "class" || entry.kind === "slots")) staticSession.transformedFiles.add((0, node_path.resolve)(filePath));
-			for (const entry of result.folded) for (const className of entry.classNames) staticSession.markClassUsed(className);
+			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;
-				addSurvivor({
-					file: filePath,
+				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) _bamboocss_logger.logger.info("vite:transform", formatSkipped(filePath, result.skipped));
 			for (const dependency of result.dependencies) this.addWatchFile?.(dependency);
-			const dependentKey = normalizeFsPath(filePath);
-			recordFoldDependencies(dependentKey, result.dependencies);
-			if (result.dependencies.length) foldSignatures.set(dependentKey, {
-				input: digest(code),
-				output: digest(result.code),
-				path: filePath
-			});
-			else foldSignatures.delete(dependentKey);
-			const forFile = survivorsByFile.get(filePath);
-			if (command === "serve" && forFile?.length) {
-				foldSignatures.delete(dependentKey);
-				throw createSurvivorError(forFile);
+			if (command === "serve" && artifact.survivors.length) {
+				state.foldSignatures.delete(id);
+				throw createSurvivorError(artifact.survivors.map((survivor) => ({
+					file: filePath,
+					...survivor
+				})));
 			}
-			if (!result.folded.length) return null;
+			const meta = { [TRANSFORM_META_KEY]: artifact };
+			if (!result.folded.length) return typeof this.getModuleInfo === "function" ? {
+				code,
+				map: null,
+				meta
+			} : null;
 			_bamboocss_logger.logger.debug("vite:transform", `Compiled ${result.folded.length} call(s) in ${filePath}`);
 			return {
 				code: result.code,
-				map: result.map
+				map: result.map,
+				meta
 			};
 		},
-		buildEnd() {
-			const survivors = allSurvivors();
-			if (survivors.length) throw createSurvivorError(survivors);
-			const lost = [...staticSession.usedClasses].filter((className) => staticSession.prunedClasses.has(bare(className)));
-			if (lost.length) {
-				const environment = this.environment?.name ?? "default";
-				throw new Error(`bamboocss: ${lost.length} class(es) compiled in the ${JSON.stringify(environment)} environment were already pruned out of a stylesheet emitted by an earlier one. Elements carrying them would render unstyled.\n\n${(0, _bamboocss_shared.truncateList)(lost.map((className) => `  ${className}`), {
+		buildEnd(buildError) {
+			const environment = environmentName(this);
+			const state = environmentState(this);
+			if (buildError) {
+				rollbackEnvironmentGeneration(environment, state);
+				return;
+			}
+			try {
+				replayCachedTransformArtifacts(this);
+				let currentWillEmitCss = false;
+				if (typeof this.getModuleIds === "function") {
+					state.cssLoaded = [...this.getModuleIds()].some((id) => id.split("?")[0] === `\0${VIRTUAL_CSS_ID}`);
+					currentWillEmitCss = state.cssLoaded && (this.environment?.config?.build?.emitAssets ?? defaultEmitAssets);
+				}
+				const states = contributionStates(environment, state);
+				rebuildStaticTransformContributions(environment, state);
+				const survivors = allSurvivors(states);
+				if (survivors.length) throw createSurvivorError(survivors);
+				const lost = currentWillEmitCss ? [] : [...staticSession.usedClasses].filter((className) => staticSession.prunedClasses.has(require_class_name.bare(className)));
+				if (lost.length) throw new Error(`bamboocss: ${lost.length} class(es) compiled in the ${JSON.stringify(environment)} environment were already pruned out of a stylesheet emitted by an earlier one. Elements carrying them would render unstyled.\n\n${(0, _bamboocss_shared.truncateList)(lost.map((className) => `  ${className}`), {
 					unit: "class",
 					separator: "\n"
-				})}\n\nThe stylesheet is finalized by the environment that imports it, so pruning it is only safe once every environment has been compiled. This build did not say how many there would be: it called \`builder.build(environment)\` directly. Run it through \`vite build\`, call \`builder.buildApp()\`, or set \`builder: {}\` in the Vite config so the environments are known before the first one builds. \`bamboocss({ pruneCss: false })\` also turns pruning off entirely.`);
+				})}\n\nThe stylesheet is finalized by the environment that imports it — the client, which builds first — so it is pruned against what that environment compiled. These classes are reached only from here, so no rule for them survived.\n\nThat usually means a styled component which renders only on the server. Either give the client a path to it, or set \`bamboocss({ pruneCss: false })\` to ship the whole extracted stylesheet.`);
+				const remaining = remainingEnvironments(staticSession, environment);
+				if (typeof this.getModuleInfo === "function" && !remaining.length) {
+					if (!staticSession.cssLoaded) throw new Error(`bamboocss: compiled class values were produced, but ${JSON.stringify(VIRTUAL_CSS_ID)} was not imported. Add \`import ${JSON.stringify(VIRTUAL_CSS_ID)}\` once, from a JavaScript or TypeScript module in the application entry graph.\n\nIt has to be a JS import. \`@import\` from a stylesheet does not reach it: the id names a virtual module resolved by this plugin, and Vite resolves CSS \`@import\` before plugin resolution, so it fails as an unresolvable path. A project that ships one preloaded stylesheet imports this from its entry module instead, and lets Vite emit the CSS asset.`);
+					const outsideExtraction = [...staticSession.transformedFiles].filter((file) => !staticSession.extractedFiles.has(file));
+					if (outsideExtraction.length) throw new Error(`bamboocss: ${outsideExtraction.length} statically compiled module(s) are outside the CSS extraction graph:\n\n${(0, _bamboocss_shared.truncateList)(outsideExtraction.map((file) => `  ${file}`), {
+						unit: "file",
+						separator: "\n"
+					})}\n\nAdd them to \`include\` in bamboo.config, or no CSS rule can back their emitted classes.`);
+				}
+				if (reportSummary && (command !== "build" || !remaining.length)) reportTransformCoverage(states);
+				if (command === "serve" || !outputTokensByEnvironment.get(environment)?.size) completeEnvironmentGeneration(environment, state);
+				else prepareEnvironmentGeneration(environment, state);
+			} catch (error) {
+				rollbackEnvironmentGeneration(environment, state);
+				throw error;
 			}
-			if (typeof this.getModuleInfo === "function" && !remainingEnvironments(staticSession).length) {
-				if (!staticSession.cssLoaded) throw new Error(`bamboocss: compiled class values were produced, but ${JSON.stringify(VIRTUAL_CSS_ID)} was not imported. Add \`import ${JSON.stringify(VIRTUAL_CSS_ID)}\` once, from a JavaScript or TypeScript module in the application entry graph.\n\nIt has to be a JS import. \`@import\` from a stylesheet does not reach it: the id names a virtual module resolved by this plugin, and Vite resolves CSS \`@import\` before plugin resolution, so it fails as an unresolvable path. A project that ships one preloaded stylesheet imports this from its entry module instead, and lets Vite emit the CSS asset.`);
-				const outsideExtraction = [...staticSession.transformedFiles].filter((file) => !staticSession.extractedFiles.has(file));
-				if (outsideExtraction.length) throw new Error(`bamboocss: ${outsideExtraction.length} statically compiled module(s) are outside the CSS extraction graph:\n\n${(0, _bamboocss_shared.truncateList)(outsideExtraction.map((file) => `  ${file}`), {
-					unit: "file",
-					separator: "\n"
-				})}\n\nAdd them to \`include\` in bamboo.config, or no CSS rule can back their emitted classes.`);
+		},
+		renderError() {
+			const environment = environmentName(this);
+			const state = transformStateByEnvironment.get(environment);
+			if (state) rollbackEnvironmentGeneration(environment, state);
+		}
+	};
+	const outputWriteObserver = {
+		name: "bamboocss:output-write-observer",
+		enforce: "pre",
+		sharedDuringBuild: true,
+		buildStart: {
+			order: "pre",
+			sequential: true,
+			handler() {
+				observeEnvironmentBuildStart(environmentName(this));
+			}
+		},
+		writeBundle: {
+			order: "pre",
+			sequential: true,
+			handler(outputOptions, bundle) {
+				const identity = outputIdentityByBundle.get(bundle) ?? outputIdentityByOptions.get(outputOptions);
+				if (identity?.environment === environmentName(this)) publishPreparedOutput(identity.environment, identity.outputToken, identity.outputSlot, true);
 			}
-			if (!reportSummary) return;
-			if (command === "build" && remainingEnvironments(staticSession).length) return;
-			let folded = 0;
-			let filesWithFolds = 0;
-			const skipped = /* @__PURE__ */ new Map();
-			for (const entry of perFile.values()) {
-				folded += entry.folded;
-				if (entry.folded) filesWithFolds++;
-				for (const [reason, count] of entry.skipped ?? []) skipped.set(reason, (skipped.get(reason) ?? 0) + count);
+		}
+	};
+	const memoryOutputCommitter = {
+		name: "bamboocss:output-memory-committer",
+		enforce: "post",
+		sharedDuringBuild: true,
+		closeBundle: {
+			order: "post",
+			sequential: true,
+			handler() {
+				closePreparedMemoryOutputs(environmentName(this));
 			}
-			const declined = Array.from(skipped.values()).reduce((sum, count) => sum + count, 0);
-			const total = folded + declined;
-			if (!total) return;
-			const share = Math.round(folded / total * 100);
-			const reasons = Array.from(skipped.entries()).sort((a, b) => b[1] - a[1]).map(([reason, count]) => `${reason}=${count}`).join(" ");
-			_bamboocss_logger.logger.info("vite:transform", `Compiled ${folded}/${total} (${share}%) across ${filesWithFolds}/${perFile.size} files` + (reasons ? ` — declined: ${reasons}` : ""));
 		}
-	}];
+	};
+	return [bamboocssCss({
+		configPath,
+		cwd,
+		session: staticSession,
+		pruneCss
+	}), compiler];
 };
 //#endregion
 exports.VIRTUAL_CSS_ID = VIRTUAL_CSS_ID;