@bamboocss/vite 1.34.0 → 1.35.0

package/dist/index.mjs

@@ -1,12 +1,84 @@
 import { Builder, loadConfigAndCreateContext } from "@bamboocss/node";
 import { logger } from "@bamboocss/logger";
-import { resolveTsPathPattern } from "@bamboocss/config/ts-path";
-import { box, maybeBoxNode, unbox } from "@bamboocss/extractor";
+import { compact, createCssUncached, createMergeCss, esc, memo, toHash, truncateList, viewTransitionClassName } from "@bamboocss/shared";
+import remapping from "@ampproject/remapping";
 import MagicString from "magic-string";
+import postcss from "postcss";
+import selectorParser from "postcss-selector-parser";
 import { dirname, relative, resolve } from "node:path";
+import { resolveTsPathPattern } from "@bamboocss/config/ts-path";
+import { box, maybeBoxNode } from "@bamboocss/extractor";
 import { Node, SyntaxKind, VariableDeclarationKind } from "ts-morph";
-import { Recipes, classFormatter } from "@bamboocss/core";
-import { compact, createCssUncached, createMergeCss, getRecipeClassNames, getRecipeIdentity, getSlotCompoundVariant, memo, truncateList, withoutSpace } from "@bamboocss/shared";
+//#region src/prune-static-css.ts
+/** The generated declaration that identifies a Bamboo stylesheet after minification. */
+const SENTINEL = "--made-with-bamboo";
+/**
+* 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.
+*/
+const pruneStaticCss = (css, session, { prune = true } = {}) => {
+	if (!css.includes(SENTINEL)) return css;
+	const root = postcss.parse(css);
+	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;
+	};
+	if (prune) root.walkRules((rule) => {
+		if (!isUtilityRule(rule)) return;
+		const classes = /* @__PURE__ */ new Set();
+		try {
+			selectorParser((selectors) => {
+				selectors.walkClasses((classNode) => {
+					classes.add(classNode.toString().slice(1));
+				});
+			}).processSync(rule.selector);
+		} catch {
+			return;
+		}
+		if (classes.size !== 1) return;
+		const [className] = classes;
+		if (!className || !session.prunableClasses.has(className) || session.usedClasses.has(className)) return;
+		rule.remove();
+	});
+	let removed = true;
+	while (removed) {
+		removed = false;
+		root.walkAtRules((rule) => {
+			if (rule.nodes?.length !== 0) return;
+			rule.remove();
+			removed = true;
+		});
+	}
+	if (session.denseClassNames) root.walkRules((rule) => {
+		if (!isUtilityRule(rule)) return;
+		const transitionClasses = /* @__PURE__ */ new Set();
+		try {
+			rule.selector = selectorParser((selectors) => {
+				selectors.walkClasses((classNode) => {
+					if (!session.prunableClasses.has(classNode.toString().slice(1))) return;
+					if (session.viewTransitionClasses.has(classNode.value)) transitionClasses.add(classNode.value);
+					classNode.value = session.allocateClassString(classNode.value);
+				});
+			}).processSync(rule.selector);
+		} catch {}
+		if (transitionClasses.size) rule.walkDecls("view-transition-class", (declaration) => {
+			if (!transitionClasses.has(declaration.value)) return;
+			declaration.value = session.allocateClassString(declaration.value);
+		});
+	});
+	return root.toString();
+};
+//#endregion
 //#region src/css.ts
 /**
 * What a project imports to get the stylesheet.
@@ -21,6 +93,76 @@ const VIRTUAL_CSS_ID = "virtual:bamboo.css";
 * not to try reading it off disk.
 */
 const RESOLVED_ID = `\0${VIRTUAL_CSS_ID}`;
+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 MagicString(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 = remapping([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);
+		output.referencedFiles = output.referencedFiles.map(replace);
+		const importedCss = output.viteMetadata?.importedCss;
+		if (importedCss?.delete(previous)) importedCss.add(next);
+	}
+};
+/**
+* Prune and rename compiler-owned CSS, then give changed assets a hash of their final 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.
+*/
+const optimizeStaticCssAssets = (bundle, session) => {
+	for (const [bundleName, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const source = typeof output.source === "string" ? output.source : Buffer.from(output.source).toString();
+		if (!source.includes("--made-with-bamboo")) continue;
+		const optimized = pruneStaticCss(source, session);
+		output.source = optimized;
+		if (optimized === source) continue;
+		const nextName = output.fileName.replace(/\.css$/, `.b-${toHash(optimized)}.css`);
+		if (nextName === output.fileName) continue;
+		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, session.sourcemap);
+		delete bundle[bundleName];
+		bundle[nextName] = output;
+	}
+};
 /**
 * Serve bamboo's stylesheet as a virtual module, in dev and in build.
 *
@@ -34,10 +176,11 @@ const RESOLVED_ID = `\0${VIRTUAL_CSS_ID}`;
 * `styles.css` and asking the project to import it means the build reads a file the same
 * process just wrote, which is a race on any watch rebuild.
 */
-const bamboocssCss = (options = {}) => {
-	const { configPath, cwd } = options;
+const bamboocssCss = (options) => {
+	const { configPath, cwd, session } = options;
 	const builder = new Builder();
 	let server;
+	let command = "build";
 	/**
 	* 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
@@ -51,7 +194,33 @@ const bamboocssCss = (options = {}) => {
 		});
 		await builder.emit();
 		builder.extract();
-		return builder.toCss({ layerParams: true });
+		if (builder.context?.config.polyfill) throw new Error("bamboocss: the cascade-layer polyfill is incompatible with compiled atomic styles. The polyfill removes the utility-layer boundary required for safe atom reachability and renaming.");
+		if (builder.context) {
+			session.cssLoaded = true;
+			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));
+		}
+		let graphAtomHashes;
+		if (builder.context) {
+			builder.context.encoder.atomizeObservedRecipes();
+			graphAtomHashes = new Set(builder.context.encoder.atomic);
+		}
+		const css = builder.toCss({
+			layerParams: true,
+			includeRecipes: false
+		});
+		session.prunableClasses.clear();
+		session.viewTransitionClasses.clear();
+		if (graphAtomHashes && builder.context) {
+			const decoder = builder.context.decoder.collect(builder.context.encoder);
+			for (const atom of decoder.atomic) if (graphAtomHashes.has(atom.hash)) session.prunableClasses.add(atom.className);
+			for (const transition of decoder.view_transitions) {
+				session.viewTransitionClasses.add(transition.className);
+				session.prunableClasses.add(esc(transition.className));
+			}
+		}
+		return command === "serve" ? pruneStaticCss(css, session, { prune: false }) : css;
 	};
 	const generate = () => {
 		pending = Promise.resolve(pending).catch(() => void 0).then(build);
@@ -59,6 +228,10 @@ const bamboocssCss = (options = {}) => {
 	};
 	return {
 		name: "bamboocss:css",
+		configResolved(config) {
+			command = config.command;
+			session.sourcemap = config.build.sourcemap;
+		},
 		resolveId(id) {
 			if (id === "virtual:bamboo.css") return RESOLVED_ID;
 			return null;
@@ -78,20 +251,23 @@ const bamboocssCss = (options = {}) => {
 				const mod = server?.moduleGraph.getModuleById(RESOLVED_ID);
 				if (!mod) return;
 				server?.moduleGraph.invalidateModule(mod);
-				server?.ws.send({
-					type: "update",
-					updates: []
-				});
+				server?.reloadModule(mod);
 				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) {
+				optimizeStaticCssAssets(bundle, session);
+			}
 		}
 	};
 };
 //#endregion
-//#region src/fold-partial.ts
+//#region src/fold-analysis.ts
 /**
 * Statically resolvable means: every box in the tree carries a known value.
 *
@@ -106,7 +282,10 @@ const isStaticBox = (node, seen = /* @__PURE__ */ new Set()) => {
 	seen.add(node);
 	if (box.isUnresolvable(node) || box.isConditional(node)) return false;
 	if (!("type" in node) || node.type == null) return false;
-	if (box.isLiteral(node) && node.value === void 0) return false;
+	if (box.isLiteral(node) && node.value === void 0) {
+		const source = node.getNode?.();
+		return Boolean(source && Node.isIdentifier(source) && source.getText() === "undefined");
+	}
 	if (box.isMap(node)) {
 		for (const child of node.value.values()) if (!isStaticBox(child, seen)) return false;
 		return true;
@@ -231,8 +410,8 @@ const isCollapsedBinary = (node) => Node.isBinaryExpression(node) && COLLAPSED_B
 * 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, phase 1 declines them. Partial folding is where this
-* gets revisited.
+* 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
@@ -277,37 +456,6 @@ const accountsForSource = (node, boxNode) => {
 	return true;
 };
 /**
-* A property whose value is a ternary is not dynamic, it is *finite*: both branches are
-* known, so each can be resolved now and the choice left to a ternary between two
-* literals. That removes the `css()` call without needing to know which branch runs.
-*
-* Independent conditionals stay linear rather than multiplying, because each property
-* contributes its own ternary. Two conditionals give two ternaries, not four
-* combinations — which is only sound because `collides()` already rules out two
-* properties resolving to the same class, so no combination can interact with another.
-*/
-const finiteBranches = (key, value, boxNode, deps) => {
-	if (!box.isConditional(boxNode)) return void 0;
-	const node = boxNode.getNode();
-	if (!Node.isConditionalExpression(node)) return void 0;
-	if (!value || unwrapExpression(value) !== node) return void 0;
-	const [whenTrue, whenFalse] = [[node.getWhenTrue(), boxNode.whenTrue], [node.getWhenFalse(), boxNode.whenFalse]].map(([source, branch]) => {
-		if (!deps.isStatic(branch)) return void 0;
-		if (!deps.isAccounted(source, branch)) return void 0;
-		const value = unbox(branch).raw;
-		try {
-			return deps.runtimeCss({ [key]: value });
-		} catch {
-			return;
-		}
-	});
-	if (whenTrue === void 0 || whenFalse === void 0) return void 0;
-	if (!whenTrue && !whenFalse) return void 0;
-	return `${node.getCondition().getText()} ? ${JSON.stringify(whenTrue)} : ${JSON.stringify(whenFalse)}`;
-};
-/** The binding the leaf fold calls, exported by the generated css module. */
-const LEAF_HELPER = "cssLeaf";
-/**
 * 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
@@ -328,18 +476,6 @@ const byText = (cache, sourceFile, compute) => {
 	return value;
 };
 /**
-* The modules this file imports from, as specifiers.
-*
-* Only strings are cached. A ts-morph *node* cannot be: re-adding a path forgets the old
-* nodes even when the text is identical, so the memo would hand back wrappers that throw
-* on access. Strings outlive that, and answer the one question worth asking before the
-* helper resolution walks the declarations — whether this file imports from bamboo at
-* all. On a module of many elements that never fold, that walk was the entire cost of
-* trying.
-*/
-const specifierCache = /* @__PURE__ */ new WeakMap();
-const importsAnything = (sourceFile, matches) => byText(specifierCache, sourceFile, () => sourceFile.getImportDeclarations().map((declaration) => declaration.getModuleSpecifierValue())).some(matches);
-/**
 * 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
@@ -450,282 +586,6 @@ const collectModuleScopeNames = (sourceFile) => {
 	}
 	return names;
 };
-/**
-* The local name an already-imported bamboo binding goes by.
-*
-* `ensureCxImport` answers this too, but it also decides whether a *missing* binding can
-* be added, which needs `getLocals()` — the compiler's binder over the whole module. This
-* runs for every candidate whether it folds or not, so it stops at what the import
-* declarations already say and never forces that.
-*/
-const findBambooBinding = (call, imported, isBambooCssModule, isShadowed) => {
-	if (!importsAnything(call.getSourceFile(), isBambooCssModule)) return void 0;
-	for (const declaration of call.getSourceFile().getImportDeclarations()) {
-		if (declaration.isTypeOnly() || !isBambooCssModule(declaration.getModuleSpecifierValue())) continue;
-		for (const named of declaration.getNamedImports()) {
-			if (named.isTypeOnly() || named.getNameNode().getText() !== imported) continue;
-			const local = (named.getAliasNode() ?? named.getNameNode()).getText();
-			return isShadowed(call, local) ? void 0 : local;
-		}
-	}
-};
-/**
-* A value that survives the class pipeline unchanged, so the class built around it is the
-* prefix and nothing else: no whitespace for `sanitize` to collapse, no `!` for the
-* important regex, no space for `withoutSpace`, and nothing a token or condition could
-* plausibly be named.
-*/
-const LEAF_SENTINEL = "bamboo0leaf0sentinel0";
-/**
-* A property the extractor could not resolve is *open-ended* rather than finite — but its
-* class is still `prefix + value`, and the prefix is known now.
-*
-* `utility.transform` is string construction over a table fixed at build time, and
-* nothing consults which rules were emitted. So `css({ color: tone })` already returns
-* `c_<tone>` for a value the extractor never saw, with no CSS behind it. Emitting that
-* string directly cannot be less correct than the call it replaces.
-*
-* The prefix is read off the real implementation rather than rebuilt: resolving a
-* sentinel through `runtimeCss` applies the shorthand table and the utility's class name
-* in one step. It also self-gates — a hashed or grouped class does not contain the
-* sentinel, so both modes decline here without this having to read the config.
-*
-* Shared with the element surface, which asks the same question about a JSX style prop.
-*
-* Top level only, like the finite lowering beside it. A nested leaf's class carries its
-* condition path, which the prefix would describe correctly — but the helper's fallback
-* rebuilds `{ [prop]: value }` to hand back to `css()`, and that reconstruction has to
-* carry the same path or the declined shape resolves without its condition.
-*/
-const leafPrefix = (key, ctx, runtimeCss) => {
-	if (ctx.conditions.isCondition(key)) return void 0;
-	let resolved;
-	try {
-		resolved = runtimeCss({ [key]: LEAF_SENTINEL });
-	} catch {
-		return;
-	}
-	if (!resolved.endsWith(LEAF_SENTINEL)) return void 0;
-	const prefix = resolved.slice(0, -21);
-	return !prefix || prefix.includes(" ") ? void 0 : prefix;
-};
-/**
-* Written as an object or an array, this is a condition block or a responsive list: one
-* class per entry rather than one class. `leafClass` declines both at runtime and falls
-* back, so lowering one is not wrong — it is a guaranteed round trip through the fallback,
-* which is the same reason a condition key is declined.
-*/
-const isWrittenAsCollection = (value) => {
-	const inner = unwrapExpression(value);
-	return Node.isObjectLiteralExpression(inner) || Node.isArrayLiteralExpression(inner);
-};
-/** The call this surface emits in place of the property. */
-const leafCall = (prefix, key, valueText, name = LEAF_HELPER) => `${name}(${JSON.stringify(prefix)}, ${JSON.stringify(key)}, ${valueText})`;
-const dynamicLeaf = (key, value, deps) => {
-	if (!deps.allowLeaf || !value) return void 0;
-	if (isWrittenAsCollection(value)) return void 0;
-	const prefix = leafPrefix(key, deps.ctx, deps.runtimeCss);
-	return prefix === void 0 ? void 0 : leafCall(prefix, key, value.getText(), deps.leafName ?? "cssLeaf");
-};
-/**
-* Properties are partitioned whole rather than recursed into. A top-level property is
-* either entirely static or entirely dynamic, which keeps the reconstructed object a
-* verbatim slice of the source and avoids rebuilding nested conditions by hand.
-*/
-const planPartialFold = (argument, boxNode, styles, deps) => {
-	const partition = partitionObject(argument, boxNode, styles, deps);
-	if (!partition) return void 0;
-	const className = deps.runtimeCss(partition.staticStyles);
-	if (!className && !partition.finite.length) return void 0;
-	return {
-		className,
-		dynamicText: partition.dynamicText.length ? `{ ${partition.dynamicText.join(", ")} }` : void 0,
-		finite: partition.finite,
-		finiteFirst: partition.finiteFirst
-	};
-};
-/**
-* Split one object level, recursing into a block that is part static and part dynamic.
-*
-* Without the recursion a single dynamic leaf sends its whole block to the runtime:
-* `{ _hover: { color: 'red.300', bg: p } }` loses the resolved `color` even though
-* nothing about it depends on `p`. That is a precision loss rather than a wrong answer,
-* but it costs exactly the calls a component re-renders most.
-*
-* A class is identified by its condition path *and* its property, so `_hover.color` in
-* one half and `_hover.bg` in the other cannot collide, and neither can `color` against
-* `_hover.color`. Collision is therefore checked per level, among siblings.
-*
-* The static subtree is read from the extracted data rather than rebuilt: the extractor
-* has already dropped the unresolvable leaves, so `styles[key]` for a mixed block is
-* exactly the resolvable part. The dynamic side is taken from source text, so nothing
-* depends on that pruning being complete.
-*/
-const partitionObject = (node, boxNode, styles, deps, topLevel = true) => {
-	if (!box.isMap(boxNode)) return void 0;
-	const { ctx, isAccounted, isStatic } = deps;
-	const staticKeys = [];
-	const staticStyles = {};
-	const seenKeys = /* @__PURE__ */ new Set();
-	/**
-	* Everything not resolved outright, in source order. Kept as one list because a ternary
-	* that cannot be lowered has to become a runtime property *in its original position*,
-	* and because whether the two kinds interleave is a property of that order.
-	*/
-	const slots = [];
-	for (const property of node.getProperties()) {
-		if (!Node.isPropertyAssignment(property) && !Node.isShorthandPropertyAssignment(property)) return void 0;
-		const nameNode = property.getNameNode();
-		if (Node.isComputedPropertyName(nameNode)) return void 0;
-		const key = Node.isStringLiteral(nameNode) || Node.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
-		if (seenKeys.has(key)) return void 0;
-		seenKeys.add(key);
-		const value = valueOf(property);
-		const valueBox = boxNode.value.get(key);
-		if (key in styles && isStatic(valueBox) && isAccounted(value, valueBox)) {
-			staticKeys.push(key);
-			staticStyles[key] = styles[key];
-			continue;
-		}
-		if (topLevel) {
-			const branches = finiteBranches(key, value, valueBox, deps);
-			if (branches) {
-				slots.push({
-					key,
-					kind: "finite",
-					lowered: {
-						expression: branches,
-						emitsLiterals: true
-					},
-					text: property.getText()
-				});
-				continue;
-			}
-			const leaf = dynamicLeaf(key, value, deps);
-			if (leaf) {
-				slots.push({
-					key,
-					kind: "finite",
-					lowered: {
-						expression: leaf,
-						emitsLiterals: false
-					},
-					text: property.getText()
-				});
-				continue;
-			}
-		}
-		const nested = value && Node.isObjectLiteralExpression(value) && isAccounted(value, valueBox) ? partitionObject(value, valueBox, styles[key] ?? {}, deps, false) : void 0;
-		if (nested && Object.keys(nested.staticStyles).length && nested.dynamicText.length) {
-			staticKeys.push(key);
-			staticStyles[key] = nested.staticStyles;
-			slots.push({
-				key,
-				kind: "dynamic",
-				split: true,
-				text: `${property.getNameNode().getText()}: { ${nested.dynamicText.join(", ")} }`
-			});
-			continue;
-		}
-		slots.push({
-			key,
-			kind: "dynamic",
-			text: property.getText()
-		});
-	}
-	const demote = (slot) => {
-		slot.kind = "dynamic";
-		slot.lowered = void 0;
-	};
-	const contested = () => slots.filter((slot) => slot.kind === "dynamic" && !slot.split).map((slot) => slot.key);
-	for (;;) {
-		const lowered = slots.filter((slot) => slot.kind === "finite");
-		const dynamic = contested();
-		const offender = lowered.find((slot, index) => collides([slot.key], [
-			...staticKeys,
-			...dynamic,
-			...lowered.slice(0, index).map((kept) => kept.key)
-		], ctx));
-		if (!offender) break;
-		demote(offender);
-	}
-	const written = () => slots.map((slot) => slot.kind === "finite" ? "f" : "d").join("");
-	while (!/^f*d*$/.test(written()) && !/^d*f*$/.test(written())) demote(slots.findLast((slot) => slot.kind === "finite"));
-	const dynamicText = slots.filter((slot) => slot.kind === "dynamic").map((slot) => slot.text);
-	const finite = slots.filter((slot) => slot.kind === "finite").map((slot) => slot.lowered);
-	if (!staticKeys.length && !finite.length) return void 0;
-	if (!dynamicText.length && !finite.length) return void 0;
-	if (collides(staticKeys, contested(), ctx)) return void 0;
-	return {
-		staticStyles,
-		dynamicText,
-		finite,
-		finiteFirst: !written().startsWith("d")
-	};
-};
-/**
-* Do the two halves resolve to a shared property?
-*
-* Compared after shorthand resolution, since that is where distinct keys become the same
-* property. An unrecognised key resolves to itself, so two distinct unknown keys are read
-* as distinct — which is right for atomic output, where one class is emitted per key.
-*/
-const collides = (staticKeys, dynamicKeys, ctx) => {
-	if (staticKeys.includes("base") || dynamicKeys.includes("base")) return true;
-	const resolve = (key) => ctx.utility.hasShorthand ? ctx.utility.resolveShorthand(key) : key;
-	const resolvedStatic = new Set(staticKeys.map(resolve));
-	return dynamicKeys.some((key) => resolvedStatic.has(resolve(key)));
-};
-/**
-* The `cx` binding to call, adding it to the import that already brings in the style
-* helper when it is not there yet.
-*
-* Reusing that declaration rather than writing a new one avoids having to guess the
-* module specifier, which varies with `importMap`, path aliases and how the project
-* spells its outdir.
-*/
-const ensureCxImport = (call, calleeRoot, isBambooCssModule, isGeneratedCssModule, isShadowed, extra = []) => {
-	const sourceFile = call.getSourceFile();
-	const wanted = ["cx", ...extra];
-	const resolved = {};
-	let host;
-	for (const declaration of sourceFile.getImportDeclarations()) {
-		const mod = declaration.getModuleSpecifierValue();
-		for (const named of declaration.getNamedImports()) {
-			const local = (named.getAliasNode() ?? named.getNameNode()).getText();
-			const imported = named.getNameNode().getText();
-			if (wanted.includes(imported) && !(imported in resolved)) {
-				if (declaration.isTypeOnly() || named.isTypeOnly()) return void 0;
-				if (!isBambooCssModule(mod)) return void 0;
-				if (isShadowed(call, local)) return void 0;
-				resolved[imported] = local;
-			}
-			if (local === calleeRoot) host = declaration;
-		}
-	}
-	const missing = wanted.filter((name) => !(name in resolved));
-	if (!missing.length) return {
-		name: resolved.cx,
-		names: resolved
-	};
-	if (!host) return void 0;
-	if (!isGeneratedCssModule(host.getModuleSpecifierValue())) return void 0;
-	const declared = declaredAtModuleScope(sourceFile);
-	for (const name of missing) {
-		if (declared.has(name) || isShadowed(call, name)) return void 0;
-		resolved[name] = name;
-	}
-	const last = host.getNamedImports().at(-1);
-	if (!last) return void 0;
-	return {
-		name: resolved.cx,
-		names: resolved,
-		insert: {
-			pos: last.getEnd(),
-			names: missing
-		}
-	};
-};
 //#endregion
 //#region src/fold-recipe.ts
 /**
@@ -735,15 +595,12 @@ const ensureCxImport = (call, calleeRoot, isBambooCssModule, isGeneratedCssModul
 * 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.
 *
-* Reads `cva` and not `sva`, which is load-bearing rather than an omission. The parser records
-* a call of *either* as a recipe call, but an `sva` invocation returns one class per slot — an
-* object, not a string — so there is no literal to substitute. Leaving slot recipes out of this
-* map is what makes them decline as `unknown-recipe` instead of folding to a string that would
-* break every consumer reading `.root` off it.
+* Slot and ordinary recipes share one representation.
 */
 const collectRecipeConfigs = (parserResult) => {
 	const configs = /* @__PURE__ */ new Map();
-	for (const definition of parserResult.cva) {
+	const definitions = [...parserResult.cva, ...parserResult.sva];
+	for (const definition of definitions) {
 		const node = definition.box?.getNode?.();
 		if (!node) continue;
 		const nameNode = ((Node.isCallExpression(node) ? node : node.getFirstAncestorByKind(SyntaxKind.CallExpression))?.getFirstAncestorByKind(SyntaxKind.VariableDeclaration))?.getNameNode();
@@ -760,21 +617,20 @@ const collectRecipeConfigs = (parserResult) => {
 		}
 		configs.set(nameNode.getText(), {
 			config,
-			name: getRecipeIdentity(config),
 			box: definition.box
 		});
 	}
 	return configs;
 };
-/** The generated binding a lowered dynamic axis calls. Lives in `cx`, which pulls no engine. */
-const RECIPE_PICK_HELPER = "cvaPick";
+/** 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";
-const HELPER = RECIPE_PICK_HELPER;
 /** Marker for a binding the fold must never resolve — declared twice, or unresolvable. */
 const AMBIGUOUS = Object.freeze({
 	config: {},
-	name: "",
 	box: void 0
 });
 /** `.size`, or `["x-large"]` when the variant is not a valid identifier. */
@@ -816,10 +672,9 @@ const propertyKey = (nameNode) => {
 	if (Node.isNumericLiteral(nameNode)) return String(nameNode.getLiteralValue());
 };
 /**
-* Make `cvaPick` callable at this call site, by whatever name the file gives it.
+* Make a generated compile helper callable at this call site, by whatever name the file gives it.
 *
-* Not `ensureCxImport`: that one resolves `cx` and finds the declaration to extend by
-* matching the *callee* against an import. An inline recipe's callee is a local binding, so
+* 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.
 */
@@ -871,13 +726,18 @@ const ensureRecipeHelperImport = (imported, call, isBambooCssModule, isGenerated
 * 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, ctx, isInert, resolvedSelection) => {
+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, name } = entry;
-	if (config.slots !== void 0) return {
+	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"
 	};
@@ -913,16 +773,13 @@ const lowerRecipeCall = (call, entry, ctx, isInert, resolvedSelection) => {
 		/**
 		* `input(variantProps)` — a selection the build cannot see inside.
 		*
-		* Inline recipes only. `cva` resolves a selection with `getRecipeClassNames`, which reads
-		* a variant value as a key and so cannot take a conditional — a `{ base, md }` object finds
-		* no entry and names no class, exactly as `cvaPick` does. A **config** recipe routes its
-		* selection through `createCss`, which *expands* conditions into one class per breakpoint,
-		* so a scalar lookup silently drops them. That is why this lowering is not applied to
-		* config recipes: for a dynamic axis the build cannot know which kind of value arrives.
+		* 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 classes are still knowable: a recipe emits one per declared variant, so the call is
-		* one term per variant reading that binding. This is the shape a wrapper component takes,
-		* where the variants are the component's public API and cannot be literals by definition.
+		* 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.
@@ -1005,19 +862,51 @@ const lowerRecipeCall = (call, entry, ctx, isInert, resolvedSelection) => {
 	* typecheck and does transform `.js`, so this is reachable.
 	*/
 	const everyEffectSurvives = () => effectful.every(({ key, text }) => dynamicAxes.get(key) === text);
-	const merged = {
-		...config.defaultVariants ?? {},
-		...compact(selection)
+	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
+		};
 	};
-	const format = classFormatter(ctx);
 	if (dynamicAxes.size === 0) {
 		if (!everyEffectSurvives()) return {
 			kind: "decline",
 			reason: "dynamic"
 		};
-		return {
+		const compiled = compiledSelection(selection);
+		if (!compiled) return {
+			kind: "decline",
+			reason: "dynamic"
+		};
+		if (typeof compiled.value === "string") return {
 			kind: "class",
-			className: getRecipeClassNames(name, config.variants, merged, ctx.utility.separator, format)
+			className: compiled.value,
+			styles: compiled.styles
+		};
+		return {
+			kind: "slots",
+			expression: JSON.stringify(compiled.value),
+			classNames: compiled.classNames,
+			dynamic: false
 		};
 	}
 	if (!everyEffectSurvives()) return {
@@ -1033,45 +922,126 @@ const lowerRecipeCall = (call, entry, ctx, isInert, resolvedSelection) => {
 		};
 	}
 	for (const key of [...dynamicAxes.keys()]) if (!Object.hasOwn(config.variants ?? {}, key)) dynamicAxes.delete(key);
-	if (dynamicAxes.size === 0) return {
-		kind: "class",
-		className: getRecipeClassNames(name, config.variants, merged, ctx.utility.separator, format)
-	};
-	const ownClass = format(name);
-	const parts = [JSON.stringify(ownClass)];
-	const classNames = [ownClass];
-	for (const key of Object.keys(config.variants ?? {})) {
-		const expression = dynamicAxes.get(key);
-		if (expression === void 0) {
-			const value = merged[key];
-			if (value == null) continue;
-			const declared = config.variants?.[key];
-			if (!declared || !Object.hasOwn(declared, value) || declared[value] == null) continue;
-			const className = format(`${name}--${key}${ctx.utility.separator}${withoutSpace(value)}`);
-			parts.push(JSON.stringify(` ${className}`));
-			classNames.push(className);
-			continue;
-		}
-		const values = config.variants[key];
-		const table = {};
-		for (const value of Object.keys(values)) {
-			const className = format(`${name}--${key}${ctx.utility.separator}${withoutSpace(value)}`);
-			table[value] = ` ${className}`;
-			classNames.push(className);
-		}
-		const fallbackValue = config.defaultVariants?.[key];
-		const fallback = fallbackValue != null && values[fallbackValue] != null ? ` ${format(`${name}--${key}${ctx.utility.separator}${withoutSpace(fallbackValue)}`)}` : void 0;
-		parts.push(`${HELPER}(${expression}, ${JSON.stringify(table)}${fallback === void 0 ? "" : `, ${JSON.stringify(fallback)}`})`);
+	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
+		};
 	}
-	if (parts.length === 1) return {
-		kind: "class",
-		className: ownClass
-	};
+	/**
+	* 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: "expression",
-		expression: parts.join(" + "),
-		classNames,
-		staticClasses: ownClass
+		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
@@ -1135,114 +1105,29 @@ const createRuntimeTokenValue = (ctx) => (path) => {
 * the default form the trivially foldable one.
 */
 const createRuntimeToken = (ctx) => (path) => tokenValuesFor(ctx).get(path)?.variable || void 0;
-/**
-* Whether a slot's class is independent of the variant props.
-*
-* A scoped slot recipe delivers variants through `@scope` rules anchored on an enclosing
-* slot, so every *other* slot carries a constant class — the same string whatever the props
-* are. That is what makes `recipe(anything).slot` foldable even when the variant is fully
-* dynamic, which was not true before scoping existed.
-*/
-const createConstantSlotCheck = (ctx) => (name, slot) => {
-	const config = ctx.recipes.getConfig(name);
-	if (!config || !("slots" in config)) return false;
-	if (!config.slots.includes(slot)) return false;
-	const anchors = Recipes.getScopeRoots(config);
-	return anchors.length > 0 && !anchors.includes(slot);
-};
-const createRuntimeRecipe = (ctx) => {
-	const separator = ctx.utility.separator;
-	return (name, variants, slot) => {
-		const config = ctx.recipes.getConfig(name);
-		const node = ctx.recipes.getRecipe(name);
-		if (!config || !node) return void 0;
-		const isSlotRecipe = "slots" in config;
-		if (isSlotRecipe !== Boolean(slot)) return void 0;
-		if (slot && !config.slots.includes(slot)) return void 0;
-		const anchors = isSlotRecipe ? Recipes.getScopeRoots(config) : [];
-		const isConstantSlot = Boolean(slot) && anchors.length > 0 && !anchors.includes(slot);
-		const className = slot ? ctx.recipes.getSlotKey(node.className, slot) : node.className;
-		const { defaultVariants = {} } = config;
-		const compoundVariants = slot ? getSlotCompoundVariant(config.compoundVariants ?? [], slot) : config.compoundVariants ?? [];
-		const recipeCss = createCssUncached({
-			hash: Boolean(ctx.hash.className),
-			conditions: {
-				shift: ctx.conditions.shift,
-				finalize: ctx.conditions.finalize
-			},
-			utility: {
-				prefix: ctx.utility.prefix,
-				hasShorthand: false,
-				resolveShorthand: (prop) => prop,
-				toHash: ctx.utility.toHash.bind(ctx.utility),
-				transform: (prop, value) => {
-					if (value === "__ignore__") return { className };
-					return { className: `${className}--${prop}${separator}${withoutSpace(value)}` };
-				}
-			}
-		});
-		const declaredValues = config.variants ?? {};
-		/**
-		* The same filter the generated `createRecipe` applies: only a value the config declares
-		* names a class.
-		*
-		* Scalars only — a conditional or responsive value is an object of leaves, and the leaves
-		* are what name classes when `createCss` walks them.
-		*/
-		const onlyDeclared = (styles) => Object.fromEntries(Object.entries(styles).filter(([prop, value]) => {
-			if (prop === className) return true;
-			if (value === null || typeof value === "object") return true;
-			return Object.hasOwn(declaredValues, prop) && Object.hasOwn(declaredValues[prop] ?? {}, String(value));
-		}));
-		const recipeStyles = isConstantSlot ? { [className]: "__ignore__" } : onlyDeclared({
-			[className]: "__ignore__",
-			...defaultVariants,
-			...compact(variants)
-		});
-		if (compoundVariants.length > 0 && Object.keys(recipeStyles).some((prop) => typeof variants[prop] === "object")) return;
-		if (isSlotRecipe) {
-			const evaluated = anchors.length > 0 ? anchors : config.slots;
-			if (Object.values(variants).some((value) => typeof value === "object" && value !== null) && evaluated.some((slotName) => getSlotCompoundVariant(config.compoundVariants ?? [], slotName).length > 0)) return void 0;
-		}
-		return recipeCss(recipeStyles);
-	};
-};
 //#endregion
 //#region src/fold.ts
 /**
-* `cva`/`sva` return a function, so neither *definition* can collapse to a class string.
-* `token` also resolves to no class, but it does resolve to a literal, so it folds through
-* its own path rather than being declined outright.
+* `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.
 *
-* Their invocations are a different matter and do fold — `cva`'s through `fold-recipe`,
-* which is a separate set because the call is recorded under the name the file bound rather
-* than the name it imported. `sva`'s do not: a slot recipe resolves to one class per slot.
+* 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",
-	"recipe"
+	"viewTransition"
 ]);
 /**
-* The class strings inside a lowered ternary — `e ? "c_red" : "c_blue"` gives both arms.
-*
-* They are read back out of the emitted text rather than threaded through the planner,
-* because the planner's product *is* that text: anything it did not write cannot appear
-* here, and anything it did cannot be missed.
-*/
-const literalsIn = (expression) => [...expression.matchAll(/"((?:[^"\\]|\\.)*)"/g)].flatMap((match) => JSON.parse(match[0]).split(" ")).filter(Boolean);
-/**
-* The kinds reported as `not-foldable`, which is permanent rather than a limit of this
-* phase — hence separate from `unsupported-kind`, where a slot recipe lands because it
-* resolves to one class per slot rather than to a single string.
-*/
-const UNFOLDABLE_TYPES = new Set(["cva", "sva"]);
-/**
 * 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. `not-foldable` is a `cva`/`sva`
-* definition, which keeps the recipe runtime rather than the css engine; see `failOnUnfolded`.
+* function of the same name — neither leaves a call of ours.
 */
 const SURVIVES_TO_RUNTIME = new Set([
 	"dynamic",
@@ -1250,9 +1135,8 @@ const SURVIVES_TO_RUNTIME = new Set([
 	"raw-call",
 	"unsupported-kind",
 	"no-call-expression",
-	"empty",
 	"unresolved-token",
-	"fold-failed"
+	"compile-failed"
 ]);
 /**
 * A call of a recipe the file bound itself: `const badge = cva(...)`, then `badge({ tone })`.
@@ -1300,21 +1184,13 @@ const isValueReference = (identifier) => {
 /**
 * Imports a surviving reference to is not a failure.
 *
-* The first four are what the fold itself writes; all live in `cx` and pull no engine, so a
+* 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.
-*
-* `cva` and `sva` are there for the reason `SURVIVES_TO_RUNTIME` omits `not-foldable`: a
-* recipe *definition* cannot fold to a class string and never could, and what it keeps is the
-* recipe runtime rather than the css engine — which `failOnUnfolded` accepts. Their unfoldable
-* invocations are reported separately, as `recipe-call`.
 */
 const PERMITTED_BINDINGS = new Set([
 	"cx",
-	"cva",
-	"sva",
-	RECIPE_PICK_HELPER,
-	SPLIT_PROPS_HELPER,
-	LEAF_HELPER
+	RECIPE_MAP_HELPER,
+	SPLIT_PROPS_HELPER
 ]);
 /**
 * The pieces `trim` reduces a module specifier by, hoisted because a regex literal
@@ -1542,64 +1418,7 @@ const argumentsAccountedFor = (call, boxNode) => {
 	return accountsForSource(args[0], boxNode);
 };
 const foldSource = (options) => {
-	const { ctx, code, parserResult, partial: partial_ = true, runtimeCss = createRuntimeCss(ctx), parseModule, recipeConfigCache, reportSurvivors, sourceFile: ownSourceFile } = options;
-	/**
-	* Recover the static half of a call the whole-call path gave up on. Only a
-	* single-argument `css()` qualifies: a pattern or recipe call takes props rather than a
-	* style object, and a multi-argument `css` is later-wins across the whole object.
-	*/
-	const tryPartial = (item, call, rootName) => {
-		if (item.type !== "css" || !rootName) return void 0;
-		if (!Node.isCallExpression(call)) return void 0;
-		const args = call.getArguments();
-		if (args.length !== 1) return void 0;
-		const unboxed = box.isMap(item.box) ? unbox(item.box) : void 0;
-		if (!unboxed?.raw) return void 0;
-		const raw = unboxed.raw;
-		if (unboxed.spreadConditions?.length) return void 0;
-		const argument = args[0];
-		if (!argument || !Node.isObjectLiteralExpression(argument)) return void 0;
-		const leafName = findBambooBinding(call, LEAF_HELPER, isBambooCssModule, isShadowed);
-		const plan_ = (allowLeaf) => {
-			try {
-				return planPartialFold(argument, item.box, raw, {
-					ctx,
-					runtimeCss,
-					isAccounted: accountsForSource,
-					isStatic: (boxNode) => isStaticBox(boxNode),
-					allowLeaf,
-					leafName: leafName ?? "cssLeaf"
-				});
-			} catch {
-				return;
-			}
-		};
-		let plan = plan_(true);
-		if (!plan) return void 0;
-		const usesLeaf = () => plan.finite.some((entry) => !entry.emitsLiterals);
-		let cx = ensureCxImport(call, rootName, isBambooCssModule, isGeneratedCssModule, isShadowed, usesLeaf() ? [LEAF_HELPER] : []);
-		if (!cx && usesLeaf()) {
-			plan = plan_(false);
-			if (!plan) return void 0;
-			cx = ensureCxImport(call, rootName, isBambooCssModule, isGeneratedCssModule, isShadowed);
-		}
-		if (!cx) return void 0;
-		const callee = call.getExpression().getText();
-		const runtimePart = plan.dynamicText ? `${callee}(${plan.dynamicText})` : void 0;
-		const runtimeParts = runtimePart ? [runtimePart] : [];
-		const lowered = plan.finite.map((entry) => entry.expression);
-		const parts = [...plan.className ? [JSON.stringify(plan.className)] : [], ...plan.finiteFirst ? [...lowered, ...runtimeParts] : [...runtimeParts, ...lowered]];
-		if (!parts.length || parts.length === 1 && runtimePart) return void 0;
-		return {
-			className: plan.className,
-			classNames: [plan.className, ...plan.finite.filter((entry) => entry.emitsLiterals).flatMap((entry) => literalsIn(entry.expression))].filter(Boolean),
-			replacement: `${cx.name}(${parts.join(", ")})`,
-			insert: cx.insert,
-			runtimeCallee: runtimePart ? callee : void 0
-		};
-	};
-	const runtimeRecipe = createRuntimeRecipe(ctx);
-	const isConstantSlot = createConstantSlotCheck(ctx);
+	const { ctx, code, parserResult, runtimeCss = createRuntimeCss(ctx), styleCompiler, maxRecipeStates, parseModule, recipeConfigCache, reportSurvivors, sourceFile: ownSourceFile } = options;
 	const runtimeToken = createRuntimeToken(ctx);
 	const runtimeTokenValue = createRuntimeTokenValue(ctx);
 	/**
@@ -1612,7 +1431,7 @@ const foldSource = (options) => {
 	*
 	* 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 partial folding, which is indistinguishable in the
+	* 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 ?? [];
@@ -1662,10 +1481,30 @@ const foldSource = (options) => {
 	const isBambooCssModule = (mod) => matchesModule(mod, cssModules);
 	const isGeneratedCssModule = (mod) => matchesModule(mod, [generatedCssModule]);
 	/**
+	* 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 `cvaPick` there is no spelling in the file to copy. The declaring module
+	* 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
@@ -1717,9 +1556,8 @@ const foldSource = (options) => {
 	* either end. Each hop is an alias symbol, so following them to a non-alias lands on the
 	* declaration wherever it lives.
 	*
-	* The class names do not depend on which module the call is in — `getRecipeIdentity` hashes
-	* the config — so a recipe lowered here produces exactly the string its own module's call
-	* sites produce, and exactly the one the runtime would have.
+	* 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);
@@ -1736,7 +1574,6 @@ const foldSource = (options) => {
 				const configs = /* @__PURE__ */ new Map();
 				for (const [key, entry] of collected) configs.set(key, entry === AMBIGUOUS ? entry : {
 					config: entry.config,
-					name: entry.name,
 					box: void 0
 				});
 				foreign = {
@@ -1759,21 +1596,19 @@ const foldSource = (options) => {
 	const skipped = [];
 	const candidates = [];
 	const seenRanges = /* @__PURE__ */ new Set();
-	/** Built on first use: most modules declare no inline recipe. */
-	let recipeConfigs;
-	/**
-	* Per inline recipe binding: calls seen, calls lowered.
-	*
-	* A binding whose every call lowered is no longer read, so its `cva({ … })` config can leave
-	* the bundle — which is the whole point, the config being far larger than the runtime. But a
-	* bundler will not drop the call on its own: `cva` closes over the config and builds an
-	* object, and Rollup cannot prove that is side-effect free, so it keeps the expression and
-	* the module ends up *larger* than before folding. The annotation below is what makes the
-	* saving real, and it is only correct to claim it once nothing reads the binding.
-	*/
-	const recipeCalls = /* @__PURE__ */ new Map();
-	/** Bindings whose `splitVariantProps` was rewritten, so that access no longer reads them. */
-	const loweredSplitProps = /* @__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 = Node.isCallExpression(definition) ? definition : definition.getFirstAncestorByKind(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();
@@ -1894,13 +1729,7 @@ const foldSource = (options) => {
 			continue;
 		}
 		if (!FOLDABLE_TYPES.has(type)) {
-			if (call && UNFOLDABLE_TYPES.has(type)) skipped.push({
-				name,
-				reason: "not-foldable",
-				start: call.getStart(),
-				end: call.getEnd()
-			});
-			if (call && type === RECIPE_CALL_TYPE && !isShadowed(call, name)) {
+			if (call && (type === RECIPE_CALL_TYPE || type === "recipe") && !isShadowed(call, name)) {
 				const start = call.getStart();
 				const end = call.getEnd();
 				const rangeKey = `${start}:${end}`;
@@ -1915,35 +1744,95 @@ const foldSource = (options) => {
 						});
 						continue;
 					}
-					recipeConfigs ??= collectRecipeConfigs(parserResult);
-					if (!recipeConfigs.has(name) && item.origin) {
-						const imported = resolveImportedRecipe(call, name, item.origin);
-						if (imported) recipeConfigs.set(name, imported);
+					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 tally = recipeCalls.get(name) ?? {
-						seen: 0,
-						lowered: 0
-					};
-					tally.seen++;
-					recipeCalls.set(name, tally);
 					const resolvedSelection = item.data?.length === 1 ? item.data[0] : void 0;
 					const entry = recipeConfigs.get(name);
-					const lowered = lowerRecipeCall(call, entry, ctx, isInertExpression, resolvedSelection);
-					if (lowered.kind === "expression") {
-						const helper = ensureRecipeHelperImport(RECIPE_PICK_HELPER, call, isBambooCssModule, isGeneratedCssModule, isShadowed, helperModules.get(name));
+					let inlineSlot;
+					let inlineEnd = end;
+					if (Array.isArray(entry?.config.slots)) {
+						const parent = call.getParent();
+						if (Node.isPropertyAccessExpression(parent) && parent.getExpression() === call) {
+							const accessed = parent.getName();
+							if (entry.config.slots.includes(accessed)) {
+								inlineSlot = accessed;
+								inlineEnd = parent.getEnd();
+							}
+						} else if (Node.isElementAccessExpression(parent) && parent.getExpression() === call) {
+							const argument = parent.getArgumentExpression();
+							const accessed = argument && (Node.isStringLiteral(argument) || 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));
 						if (helper) {
-							tally.lowered++;
 							candidates.push({
 								item,
 								call,
 								node: call,
 								start,
-								end,
-								replacement: helper.name === "cvaPick" ? lowered.expression : lowered.expression.replaceAll(`${RECIPE_PICK_HELPER}(`, `${helper.name}(`),
-								className: lowered.staticClasses,
-								classNames: lowered.classNames,
+								end: inlineEnd,
+								className: "",
+								classNames: [],
+								styleMap: lowered.map,
+								mapHelperName: helper.name,
 								insert: helper.insert,
-								configBox: entry?.box
+								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)) : 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;
 						}
@@ -1956,16 +1845,16 @@ const foldSource = (options) => {
 						continue;
 					}
 					if (lowered.kind === "class") {
-						tally.lowered++;
 						candidates.push({
 							item,
 							call,
 							node: call,
 							start,
-							end,
+							end: inlineEnd,
 							replacement: JSON.stringify(lowered.className),
 							className: lowered.className,
 							classNames: lowered.className.split(" ").filter(Boolean),
+							styleSet: lowered.styles,
 							configBox: entry?.box
 						});
 						continue;
@@ -2029,37 +1918,7 @@ const foldSource = (options) => {
 			});
 			continue;
 		}
-		if (slot && isConstantSlot(name, slot) && Node.isCallExpression(call) && call.getArguments().every(isInertExpression)) {
-			candidates.push({
-				item,
-				call,
-				node: call,
-				start,
-				end: foldEnd,
-				slot,
-				constantSlot: true
-			});
-			continue;
-		}
 		if (!(Node.isCallExpression(call) && call.getArguments().length === 0 && item.data.length === 1) && !isStaticBox(item.box) || !hasStyles(item.data) || !argumentsAccountedFor(call, item.box)) {
-			const partial = partial_ ? tryPartial(item, call, rootName) : void 0;
-			if (partial) {
-				if (reportSurvivors && partial.runtimeCallee) skipped.push({
-					name,
-					reason: "runtime-binding",
-					start,
-					end
-				});
-				candidates.push({
-					item,
-					call,
-					node: call,
-					start,
-					end,
-					...partial
-				});
-				continue;
-			}
 			skipped.push({
 				name,
 				reason: "dynamic",
@@ -2078,12 +1937,220 @@ const foldSource = (options) => {
 		});
 	}
 	/**
+	* 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 = 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 sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+				const callee = call.getExpression();
+				if (!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 (Node.isStringLiteral(arg) || Node.isNoSubstitutionTemplateLiteral(arg)) {
+						parts.push({
+							kind: "class",
+							value: arg.getLiteralValue()
+						});
+						return true;
+					}
+					if (Node.isArrayLiteralExpression(arg)) {
+						for (const element of arg.getElements()) if (Node.isSpreadElement(element) || !take(element)) return false;
+						return true;
+					}
+					if (arg.getKind() === SyntaxKind.FalseKeyword || arg.getKind() === SyntaxKind.TrueKeyword || Node.isNumericLiteral(arg) || arg.getKind() === SyntaxKind.NullKeyword || 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) {
+	if (candidates.length === 0 && recipeDefinitions.length === 0) {
 		if (reportSurvivors) reportRuntimeBindings();
 		return {
 			code,
@@ -2093,7 +2160,15 @@ const foldSource = (options) => {
 			dependencies: []
 		};
 	}
-	const dependencyScan = createDependencyScan(candidates[0].node.getSourceFile());
+	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 MagicString(code);
 	const insertedNames = /* @__PURE__ */ new Set();
@@ -2107,7 +2182,7 @@ const foldSource = (options) => {
 	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 = item.name ?? item.type ?? "";
+		const name = candidate.displayName ?? item.name ?? item.type ?? "";
 		const ranges = [[start, end]];
 		if (collides(ranges)) {
 			skipped.push({
@@ -2139,7 +2214,7 @@ const foldSource = (options) => {
 			applied.push(...ranges);
 			folded.push({
 				name,
-				kind: "class",
+				kind: candidate.outputKind ?? "class",
 				className: candidate.className,
 				classNames: (candidate.classNames ?? [candidate.className]).filter(Boolean),
 				start,
@@ -2147,24 +2222,13 @@ const foldSource = (options) => {
 			});
 			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 if (item.type === "recipe") {
-				const resolved = candidate.constantSlot ? runtimeRecipe(name, {}, candidate.slot) : item.data.length === 1 ? runtimeRecipe(name, item.data[0], candidate.slot) : void 0;
-				if (resolved == null) {
-					skipped.push({
-						name,
-						reason: "unsupported-kind",
-						start,
-						end
-					});
-					continue;
-				}
-				className = resolved;
-			} else className = runtimeCss(...item.data);
+			else className = runtimeCss(...item.data);
 		} catch {
 			skipped.push({
 				name,
@@ -2174,22 +2238,13 @@ const foldSource = (options) => {
 			});
 			continue;
 		}
-		if (!className) {
-			skipped.push({
-				name,
-				reason: "empty",
-				start,
-				end
-			});
-			continue;
-		}
 		magic.overwrite(start, end, JSON.stringify(className));
 		applied.push(...ranges);
 		folded.push({
 			name,
 			kind: "class",
 			className,
-			classNames: [className],
+			classNames: className ? [className] : [],
 			start,
 			end
 		});
@@ -2205,7 +2260,6 @@ const foldSource = (options) => {
 		const importedConfig = !local && importsFor(recipeSourceFile).has(target.getText()) ? ctx.recipes.getConfig(target.getText()) : void 0;
 		const entry = local && local !== AMBIGUOUS ? local : importedConfig ? {
 			config: importedConfig,
-			name: "",
 			box: void 0
 		} : void 0;
 		if (!entry) continue;
@@ -2223,17 +2277,21 @@ const foldSource = (options) => {
 		magic.overwrite(start, end, `${helper.name}(${args[0].getText()}, ${JSON.stringify(keys)})`);
 		applyInsert(helper.insert);
 		applied.push([start, end]);
-		loweredSplitProps.add(target.getText());
 	}
-	for (const [binding, tally] of recipeCalls) {
-		if (!tally.seen || tally.lowered !== tally.seen) continue;
-		const definition = recipeConfigs?.get(binding)?.box?.getNode?.();
-		if (!definition) continue;
-		const call = Node.isCallExpression(definition) ? definition : definition.getFirstAncestorByKind(SyntaxKind.CallExpression);
-		if (!call) continue;
+	for (const { name, call } of recipeDefinitions) {
 		const start = call.getStart();
-		if (code.slice(start, call.getEnd()) !== call.getText()) continue;
-		magic.appendLeft(start, "/*#__PURE__*/");
+		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.
@@ -2241,21 +2299,65 @@ const foldSource = (options) => {
 	* 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 is how `failOnUnfolded` came to pass a build that still shipped the engine.
+	* entry at all, which used to let a build silently ship the engine.
 	*
-	* The helpers the fold itself writes are excluded: `cx`, `cvaPick`, `splitProps` and the
-	* leaf helper live in `cx` and pull no engine, so a reference to one is the fold working
-	* rather than failing.
+	* 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.
 	*/
 	function reportRuntimeBindings() {
-		const sourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile();
+		const sourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile() ?? recipeDefinitions[0]?.call.getSourceFile();
 		if (!sourceFile) return;
+		for (const [binding, entry] of recipeConfigs) {
+			if (entry === AMBIGUOUS) continue;
+			const definition = entry.box?.getNode?.();
+			if (!definition || definition.getSourceFile() !== sourceFile) continue;
+			const nameNode = definition.getFirstAncestorByKind(SyntaxKind.VariableDeclaration)?.getNameNode();
+			if (!nameNode || !Node.isIdentifier(nameNode)) continue;
+			if (skipped.filter((item) => SURVIVES_TO_RUNTIME.has(item.reason) && item.end > item.start).some((item) => nameNode.findReferencesAsNodes().some((ref) => ref.getStart() >= item.start && ref.getStart() < item.end))) continue;
+			const survivor = nameNode.findReferencesAsNodes().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 ?? []
 		];
+		for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+			const callee = call.getExpression();
+			const argument = call.getArguments()[0];
+			if (!argument || !Node.isStringLiteral(argument) && !Node.isNoSubstitutionTemplateLiteral(argument)) continue;
+			if (!matchesModule(argument.getLiteralValue(), bambooModules)) continue;
+			const isDynamicImport = callee.getKind() === SyntaxKind.ImportKeyword;
+			const isRequire = 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 sourceFile.getDescendantsOfKind(SyntaxKind.ImportEqualsDeclaration)) {
+			if (declaration.isTypeOnly()) continue;
+			const reference = declaration.getModuleReference();
+			if (!Node.isExternalModuleReference(reference)) continue;
+			const expression = reference.getExpression();
+			if (!expression || !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()) {
@@ -2353,6 +2455,122 @@ const foldSource = (options) => {
 	};
 };
 //#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 } = 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 ?? {},
+			...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/static-session.ts
+const ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const denseName = (index) => {
+	let value = index;
+	let result = "";
+	do {
+		result = ALPHABET[value % 52] + result;
+		value = Math.floor(value / 52) - 1;
+	} while (value >= 0);
+	return `_${result}`;
+};
+const createStaticCompilationSession = (denseClassNames = true) => {
+	const mode = denseClassNames === true ? "stable" : denseClassNames;
+	const session = {
+		utilityLayer: "utilities",
+		sourcemap: false,
+		cssLoaded: false,
+		transformedFiles: /* @__PURE__ */ new Set(),
+		extractedFiles: /* @__PURE__ */ new Set(),
+		prunableClasses: /* @__PURE__ */ new Set(),
+		viewTransitionClasses: /* @__PURE__ */ new Set(),
+		usedClasses: /* @__PURE__ */ new Set(),
+		denseClasses: /* @__PURE__ */ new Map(),
+		semanticClasses: /* @__PURE__ */ new Map(),
+		denseClassNames: Boolean(mode),
+		allocateClassString(className) {
+			if (!mode) return className;
+			return className.split(" ").filter(Boolean).map((semantic) => {
+				let dense = session.denseClasses.get(semantic);
+				if (!dense) {
+					dense = mode === "local" ? denseName(session.denseClasses.size) : `_${toHash(semantic)}`;
+					const collision = session.semanticClasses.get(dense);
+					if (collision && collision !== semantic) throw new Error(`Bamboo compact class collision between ${JSON.stringify(collision)} and ${JSON.stringify(semantic)}. Disable \`denseClassNames\` for this build.`);
+					session.denseClasses.set(semantic, dense);
+					session.semanticClasses.set(dense, semantic);
+				}
+				return dense;
+			}).join(" ");
+		},
+		markClassUsed(className) {
+			const semantic = session.semanticClasses.get(className) ?? className;
+			session.usedClasses.add(esc(semantic));
+		}
+	};
+	return session;
+};
+const resetStaticCompilationSession = (session) => {
+	session.cssLoaded = false;
+	session.transformedFiles.clear();
+	session.extractedFiles.clear();
+	session.prunableClasses.clear();
+	session.viewTransitionClasses.clear();
+	session.usedClasses.clear();
+	session.denseClasses.clear();
+	session.semanticClasses.clear();
+};
+//#endregion
 //#region src/plugin.ts
 const DEFAULT_EXTENSIONS = /\.(?:[cm]?[jt]sx?)$/;
 const NODE_MODULES = /node_modules/;
@@ -2395,15 +2613,17 @@ const formatSkipped = (id, skipped) => {
 *
 * Two plugins, because they do unrelated jobs on different schedules. The first emits the
 * stylesheet as a virtual module and runs in dev and build alike — that is the integration,
-* and nothing styles without it. The second is the optional build-time fold.
+* and nothing styles without it. The second compiles every Bamboo source call in both dev
+* and build; there is no runtime styling fallback.
 *
-* The fold runs with `enforce: 'pre'` so it sees module source as close as possible to what
+* The compiler runs with `enforce: 'pre'` so it sees module source as close as possible to what
 * the CSS extractor reads off disk. A plugin that rewrites style calls before bamboo
 * sees them would otherwise make the two disagree, and a folded class could end up
 * with no matching rule.
 */
 const bamboocss = (options = {}) => {
-	const { transform = true, partial, configPath, cwd, reportSkipped = false, reportSummary = true, failOnUnfolded = false } = options;
+	const { configPath, cwd, reportSkipped = false, reportSummary = true, denseClassNames = true, maxRecipeStates } = options;
+	if (maxRecipeStates !== void 0 && (!Number.isSafeInteger(maxRecipeStates) || maxRecipeStates < 1)) throw new Error("bamboocss: `maxRecipeStates` must be a positive safe integer.");
 	/** Totals across the build, for the summary. */
 	const totals = {
 		folded: 0,
@@ -2411,8 +2631,35 @@ const bamboocss = (options = {}) => {
 		filesWithFolds: 0,
 		skipped: /* @__PURE__ */ new Map()
 	};
-	/** Under `failOnUnfolded`, every call that would still reach the runtime. */
+	const staticSession = createStaticCompilationSession(denseClassNames);
 	const survivors = [];
+	const survivorKeys = /* @__PURE__ */ new Set();
+	const addSurvivor = (entry) => {
+		const key = `${entry.file}:${entry.line}:${entry.name}:${entry.reason}`;
+		if (survivorKeys.has(key)) return;
+		survivorKeys.add(key);
+		survivors.push(entry);
+	};
+	const clearSurvivorsFor = (file) => {
+		for (let index = survivors.length - 1; index >= 0; index--) if (survivors[index]?.file === file) survivors.splice(index, 1);
+		survivorKeys.clear();
+		for (const entry of survivors) survivorKeys.add(`${entry.file}:${entry.line}:${entry.name}:${entry.reason}`);
+	};
+	const createSurvivorError = (entries) => {
+		const byFile = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const list = byFile.get(entry.file) ?? [];
+			list.push(entry);
+			byFile.set(entry.file, list);
+		}
+		const named = (entry) => entry.reason === "runtime-binding" || entry.reason === "compile-failed" ? entry.name : `${entry.name}()`;
+		const detail = truncateList(Array.from(byFile.entries(), ([file, fileEntries]) => [`  ${file}`, ...fileEntries.map((entry) => `    ${entry.line}: ${named(entry)} — ${entry.reason}`)].join("\n")), {
+			unit: "file",
+			separator: "\n"
+		});
+		const threw = entries.some((entry) => entry.reason === "compile-failed");
+		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" : "") + "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`.");
+	};
 	/**
 	* Recipe configs read out of modules other than the one being transformed.
 	*
@@ -2422,6 +2669,8 @@ const bamboocss = (options = {}) => {
 	const recipeConfigCache = /* @__PURE__ */ new Map();
 	let ctx;
 	let runtimeCss;
+	let styleCompiler;
+	let command = "build";
 	let setup;
 	const ensureContext = async () => {
 		if (!setup) setup = loadConfigAndCreateContext({
@@ -2429,25 +2678,31 @@ const bamboocss = (options = {}) => {
 			cwd
 		}).then((loaded) => {
 			ctx = loaded;
-			runtimeCss = createRuntimeCss(loaded);
+			const semanticCss = createRuntimeCss(loaded);
+			runtimeCss = (...styles) => staticSession.allocateClassString(semanticCss(...styles));
+			styleCompiler = createStaticStyleSetCompiler(loaded, runtimeCss, staticSession.allocateClassString);
 		});
 		await setup;
 	};
 	return [bamboocssCss({
 		configPath,
-		cwd
+		cwd,
+		session: staticSession
 	}), {
-		name: "bamboocss:fold",
+		name: "bamboocss:compiler",
 		enforce: "pre",
-		apply: "build",
+		configResolved(config) {
+			command = config.command;
+		},
 		async buildStart() {
-			if (!transform) return;
 			totals.folded = 0;
 			totals.files = 0;
 			totals.filesWithFolds = 0;
 			totals.skipped.clear();
 			survivors.length = 0;
+			survivorKeys.clear();
 			recipeConfigCache.clear();
+			resetStaticCompilationSession(staticSession);
 			await ensureContext();
 		},
 		/**
@@ -2471,7 +2726,7 @@ const bamboocss = (options = {}) => {
 		* the parser still holds the file.
 		*/
 		watchChange(id, change) {
-			if (!transform || !ctx) return;
+			if (!ctx) return;
 			if (!shouldTransform(id)) return;
 			const [filePath] = id.split("?");
 			if (!filePath) return;
@@ -2483,96 +2738,88 @@ const bamboocss = (options = {}) => {
 			ctx.project.reloadSourceFile(filePath);
 		},
 		async transform(code, id) {
-			if (!transform) return null;
 			if (!shouldTransform(id)) return null;
 			await ensureContext();
-			if (!ctx || !runtimeCss) return null;
+			if (!ctx || !runtimeCss || !styleCompiler) return null;
 			const [filePath] = id.split("?");
+			clearSurvivorsFor(filePath);
 			if (isGeneratedOutput(filePath, ctx)) return null;
 			let result;
 			try {
 				const sourceFile = ctx.project.addSourceFile(filePath, code);
 				const parserResult = ctx.project.parseSourceFile(filePath);
-				if (!parserResult || parserResult.isEmpty() && !failOnUnfolded) return null;
+				if (!parserResult) return null;
 				result = foldSource({
 					ctx,
 					code,
 					parserResult,
 					filePath,
 					runtimeCss,
-					partial,
+					styleCompiler,
+					maxRecipeStates,
 					parseModule: (path) => ctx?.project.parseSourceFile(path),
 					recipeConfigCache,
-					reportSurvivors: failOnUnfolded,
+					reportSurvivors: true,
 					sourceFile
 				});
 			} catch (error) {
-				logger.caughtError("vite:transform", `Failed to fold ${filePath}`, error);
+				logger.caughtError("vite:transform", `Failed to compile ${filePath}`, error);
 				totals.files++;
-				totals.skipped.set("fold-failed", (totals.skipped.get("fold-failed") ?? 0) + 1);
-				if (failOnUnfolded) survivors.push({
+				totals.skipped.set("compile-failed", (totals.skipped.get("compile-failed") ?? 0) + 1);
+				addSurvivor({
 					file: filePath,
 					line: 1,
-					name: "fold",
-					reason: "fold-failed"
+					name: "compiler",
+					reason: "compile-failed"
 				});
+				if (command === "serve") throw error;
 				return null;
 			}
 			totals.files++;
 			totals.folded += result.folded.length;
 			if (result.folded.length) totals.filesWithFolds++;
 			for (const entry of result.skipped) totals.skipped.set(entry.reason, (totals.skipped.get(entry.reason) ?? 0) + 1);
-			if (failOnUnfolded) {
-				for (const entry of result.skipped) {
-					if (!SURVIVES_TO_RUNTIME.has(entry.reason)) continue;
-					survivors.push({
-						file: filePath,
-						line: lineAt(code, entry.start),
-						name: entry.name,
-						reason: entry.reason
-					});
-				}
-				if ((ctx.config.leafFallback ?? true) && result.code.includes("cssLeaf(")) survivors.push({
+			if (result.folded.some((entry) => entry.kind === "class" || entry.kind === "slots")) staticSession.transformedFiles.add(resolve(filePath));
+			for (const entry of result.folded) for (const className of entry.classNames) staticSession.markClassUsed(className);
+			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,
-					line: lineAt(result.code, result.code.indexOf("cssLeaf(")),
-					name: "cssLeaf",
-					reason: "lowered-leaf"
+					line: lineAt(code, entry.start),
+					name: entry.name,
+					reason: entry.reason
 				});
 			}
 			if (reportSkipped && result.skipped.length) logger.info("vite:transform", formatSkipped(filePath, result.skipped));
 			for (const dependency of result.dependencies) this.addWatchFile?.(dependency);
+			if (command === "serve" && survivors.some((entry) => entry.file === filePath)) throw createSurvivorError(survivors.filter((entry) => entry.file === filePath));
 			if (!result.folded.length) return null;
-			logger.debug("vite:transform", `Folded ${result.folded.length} call(s) in ${filePath}`);
+			logger.debug("vite:transform", `Compiled ${result.folded.length} call(s) in ${filePath}`);
 			return {
 				code: result.code,
 				map: result.map
 			};
 		},
 		buildEnd() {
-			if (failOnUnfolded && survivors.length) {
-				const byFile = /* @__PURE__ */ new Map();
-				for (const entry of survivors) {
-					const list = byFile.get(entry.file) ?? [];
-					list.push(entry);
-					byFile.set(entry.file, list);
-				}
-				const named = (e) => e.reason === "runtime-binding" || e.reason === "fold-failed" ? e.name : `${e.name}()`;
-				const detail = truncateList(Array.from(byFile.entries(), ([file, entries]) => [`  ${file}`, ...entries.map((e) => `    ${e.line}: ${named(e)} — ${e.reason}`)].join("\n")), {
+			if (survivors.length) throw createSurvivorError(survivors);
+			if (typeof this.getModuleInfo === "function") {
+				if (!staticSession.cssLoaded) throw new Error(`bamboocss: compiled class values were produced, but ${JSON.stringify(VIRTUAL_CSS_ID)} was not imported. Import it once from the application entry so the compiled rules are emitted.`);
+				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${truncateList(outsideExtraction.map((file) => `  ${file}`), {
 					unit: "file",
 					separator: "\n"
-				});
-				const threw = survivors.some((entry) => entry.reason === "fold-failed");
-				throw new Error(`bamboocss: ${survivors.length} call(s) could not be folded, and \`failOnUnfolded\` is on.\n\n${detail}\n\n` + (threw ? "`fold-failed` is a module the fold threw on — see the error logged for it above. Nothing was established about its calls either way, so it cannot support the guarantee this option makes.\n\n" : "") + "Each one keeps `styled-system/css` in the bundle, so the engine cannot be dropped however many other calls folded. Make the values static, move the variation into a `cva` variant, or generate them with `staticCss` — or set `failOnUnfolded: false` to accept the runtime.");
+				})}\n\nAdd them to \`include\` in bamboo.config, or no CSS rule can back their emitted classes.`);
 			}
-			if (!transform || !reportSummary) return;
+			if (!reportSummary) return;
 			const declined = Array.from(totals.skipped.values()).reduce((sum, count) => sum + count, 0);
 			const total = totals.folded + declined;
 			if (!total) return;
 			const share = Math.round(totals.folded / total * 100);
 			const reasons = Array.from(totals.skipped.entries()).sort((a, b) => b[1] - a[1]).map(([reason, count]) => `${reason}=${count}`).join(" ");
-			logger.info("vite:transform", `Folded ${totals.folded}/${total} (${share}%) across ${totals.filesWithFolds}/${totals.files} files` + (reasons ? ` — declined: ${reasons}` : ""));
+			logger.info("vite:transform", `Compiled ${totals.folded}/${total} (${share}%) across ${totals.filesWithFolds}/${totals.files} files` + (reasons ? ` — declined: ${reasons}` : ""));
 		}
 	}];
 };
 //#endregion
-export { VIRTUAL_CSS_ID, bamboocss, bamboocss as default, bamboocssCss, createRuntimeCss, foldSource };
+export { VIRTUAL_CSS_ID, bamboocss, bamboocss as default };