@bamboocss/vite 1.45.4 → 1.46.0

package/dist/fold-module.mjs

@@ -0,0 +1,2483 @@
+import { compact, createCssUncached, createMergeCss, memo, viewTransitionClassName } from "@bamboocss/shared";
+import { dirname, relative, resolve } from "node:path";
+import MagicString from "magic-string";
+import { resolveTsPathPattern } from "@bamboocss/config/ts-path";
+import { box, maybeBoxNode } from "@bamboocss/extractor";
+import { Node, SyntaxKind, VariableDeclarationKind, ts } from "ts-morph";
+//#region src/fold-analysis.ts
+/**
+* Nodes that *compose* a value out of their children rather than computing one.
+*
+* The boundary of the walk below, and the whole of its precision. Climbing through these
+* keeps a value's provenance: `'red.300'` inside `{ color: 'red.300' }` inside a default is
+* still the default's. Anything else — a call, a function body, a JSX element — produces its
+* value by being evaluated, so what is written inside it is an argument to that evaluation
+* and not the enclosing default's value.
+*
+* Without the boundary, `({ cls = css({ color: 'red.300' }) }) => cls` is rejected: the call's
+* own literal argument is syntactically inside a default, so an unbounded walk calls it one.
+* That is correct code, and rejecting it fails the build.
+*/
+const composesValue = (node) => Node.isObjectLiteralExpression(node) || Node.isArrayLiteralExpression(node) || Node.isPropertyAssignment(node) || Node.isShorthandPropertyAssignment(node) || Node.isSpreadAssignment(node) || Node.isSpreadElement(node) || Node.isAsExpression(node) || Node.isParenthesizedExpression(node) || Node.isNonNullExpression(node) || Node.isTypeAssertion(node) || Node.isSatisfiesExpression(node);
+/** Is `inner` written within `outer`? Positions rather than a walk, so it is O(1). */
+const contains = (outer, inner) => outer.getSourceFile() === inner.getSourceFile() && outer.getStart() <= inner.getStart() && inner.getEnd() <= outer.getEnd();
+/**
+* Did this value come from the `= …` of a destructuring binding?
+*
+* `const { tone = 'red.300' } = source` boxes as the literal `'red.300'`: the extractor's
+* `maybeDefinitionValue` tests for an initializer first and returns the boxed default, never
+* reaching the branch that would read `source`. So the default is reported as the value whether
+* or not it is the one that applies.
+*
+* For extraction that is merely optimistic, and deliberately so: a CLI or PostCSS build ships a
+* runtime `css()`, where the default genuinely does apply when the caller omits the key, and it
+* needs a rule behind it. Folding is where the same resolution turns into a wrong answer,
+* because the call is *replaced* by that value.
+*
+* Stops at the first non-composing parent, so a call written inside a default keeps its own
+* provenance, and checks that the binding element was reached through its initializer, so
+* `{ tone = X }`'s name node is not mistaken for its default.
+*/
+const isBindingElementDefault = (node) => {
+	if (node && Node.isCallExpression(node)) return false;
+	let current = node;
+	while (current) {
+		const parent = current.getParent();
+		if (!parent) return false;
+		if (Node.isBindingElement(parent)) return parent.getInitializer() === current;
+		if (!composesValue(parent)) return false;
+		current = parent;
+	}
+	return false;
+};
+/**
+* The same question asked of a whole box, including how it was resolved.
+*
+* The node a box reports is not always the one its value came from — an empty `{}` default
+* boxes against the call rather than against the `{}` — so the resolution stack is consulted
+* too. A binding element reaches that stack by having been resolved *through*, which is the
+* signal the extractor itself reads when one of these is a conditional's test.
+*
+* Only the entries that are binding elements are examined. Walking up from every other entry
+* was tried and never once changed a verdict across the default spellings or the sandbox's own
+* modules, while accounting for most of the parent hops this does — the stack carries nodes
+* that were never resolved through, including a call's own arguments, so walking from them is
+* both the expensive half and the one that reaches conclusions it has no basis for.
+*
+* A binding element without an initializer carries no default to mistrust: `const { tone } =
+* source` either resolves from `source` or does not resolve at all.
+*/
+const isFromBindingDefault = (node) => {
+	const own = node.getNode?.();
+	if (isBindingElementDefault(own)) return true;
+	for (const entry of node.getStack?.() ?? []) {
+		if (!Node.isBindingElement(entry) || !entry.getInitializer()) continue;
+		if (own && contains(entry, own)) continue;
+		return true;
+	}
+	return false;
+};
+/**
+* Statically resolvable means: every box in the tree carries a known value.
+*
+* `unresolvable` is the extractor saying it could not evaluate a node.
+* `conditional` is a ternary — two possible values, so there is no single string to
+* fold to. `box.fallback` produces an object with no `type` at all, which is likewise
+* not something we can trust.
+*/
+const isStaticBox = (node, seen = /* @__PURE__ */ new Set()) => {
+	if (!node) return false;
+	if (seen.has(node)) return true;
+	seen.add(node);
+	if (box.isUnresolvable(node) || box.isConditional(node)) return false;
+	if (!("type" in node) || node.type == null) return false;
+	if (isFromBindingDefault(node)) 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;
+	}
+	if (box.isArray(node)) {
+		for (const child of node.value) if (!isStaticBox(child, seen)) return false;
+		return true;
+	}
+	return true;
+};
+/**
+* Strip the wrappers the extractor strips before it builds a box, so the source node
+* compared against a box is the same node the box was built from.
+*
+* A local copy of the extractor's `unwrapExpression`, which is not part of its public
+* surface. Recognising fewer wrappers than it does is not a cosmetic difference: an
+* unrecognised one leaves an object literal wrapped, and the object checks below skip it.
+*/
+const unwrapExpression = (node) => Node.isAsExpression(node) || Node.isParenthesizedExpression(node) || Node.isNonNullExpression(node) || Node.isTypeAssertion(node) || Node.isSatisfiesExpression(node) ? unwrapExpression(node.getExpression()) : node;
+/**
+* Mirrors the parser's evaluator environment, so re-boxing an operand here gets the same
+* answer the extraction did. Left to its default, ts-evaluator presets to `NODE` and
+* would resolve expressions the parser cannot see — making this check *more* permissive
+* than the extraction it is auditing, which is the one thing it must never be.
+*/
+const REBOXED = { getEvaluateOptions: () => ({ environment: { preset: "ECMA" } }) };
+const rebox = (node) => maybeBoxNode(unwrapExpression(node), [], REBOXED);
+/**
+* Did this operand resolve to a value the program will actually produce?
+*
+* Producing a box is not enough when the operand is itself a choice: `a || b || c` parses
+* as `(a || b) || c`, so the outer operator is handed whatever the inner one answered —
+* including an arm the extractor invented. Asking only "is there a box" reads that
+* invention as an ordinary literal.
+*/
+const resolvesExactly = (node) => {
+	const inner = unwrapExpression(node);
+	if (!rebox(inner)) return false;
+	return Node.isConditionalExpression(inner) || isCollapsedBinary(inner) ? decidedAtBuildTime(inner) : true;
+};
+/**
+* Is this operand's value written here, rather than named?
+*
+* A box records what the extractor resolved a name *through* — a `let`'s initializer, a
+* parameter's default — none of which is what the operand holds when the call runs.
+* `let m = '1'; m = undefined` still boxes as `'1'`, and `({ c = 'red.300' })` still boxes
+* as `'red.300'` for a caller that passed something else. Only a value written at the call
+* site is what it appears to be, so only that can be judged truthy or nullish here.
+*/
+const isWrittenHere = (node) => {
+	const inner = unwrapExpression(node);
+	return Node.isStringLiteral(inner) || Node.isNumericLiteral(inner) || Node.isNoSubstitutionTemplateLiteral(inner) || Node.isObjectLiteralExpression(inner) || Node.isArrayLiteralExpression(inner) || Node.isTrueLiteral(inner) || Node.isFalseLiteral(inner) || inner.getKind() === SyntaxKind.NullKeyword || Node.isPrefixUnaryExpression(inner) && Node.isNumericLiteral(inner.getOperand());
+};
+/** An inline value's truthiness, which its box carries directly. */
+const isTruthy = (boxNode) => box.isLiteral(boxNode) ? Boolean(boxNode.value) : box.isMap(boxNode) || box.isArray(boxNode) || box.isObject(boxNode);
+/**
+* Did the extractor *decide* this choice, or guess at it?
+*
+* `a ? b : c`, `a || b` and `a && b` are asked "what styles could this produce", and when
+* one arm does not evaluate the extractor answers with the other rather than refusing
+* (`maybe-box-node.ts`, `whenTrueValue && !whenFalseValue`). That is right for generating
+* CSS — emit rules for whatever might be used — and wrong for rewriting source, where the
+* arm it kept becomes the only one that runs.
+*
+* For a ternary the tell is the arms: it guessed exactly when one produced a box and the
+* other did not. For a short-circuit the answer is always the left operand, so what has to
+* be established is that the left is the side that wins.
+*/
+const decidedAtBuildTime = (node) => {
+	if (Node.isConditionalExpression(node)) return resolvesExactly(node.getWhenTrue()) && resolvesExactly(node.getWhenFalse());
+	const operator = node.getOperatorToken().getKind();
+	if (!SHORT_CIRCUIT.includes(operator)) return false;
+	if (!isWrittenHere(node.getLeft())) return false;
+	const left = rebox(node.getLeft());
+	if (!left) return false;
+	if (operator === SyntaxKind.BarBarToken) return isTruthy(left);
+	if (operator === SyntaxKind.QuestionQuestionToken) return !box.isLiteral(left) || left.value != null;
+	return isTruthy(left) ? resolvesExactly(node.getRight()) : true;
+};
+const SHORT_CIRCUIT = [
+	SyntaxKind.AmpersandAmpersandToken,
+	SyntaxKind.BarBarToken,
+	SyntaxKind.QuestionQuestionToken
+];
+/**
+* Every binary form the extractor collapses to one operand — the short-circuits plus the
+* comparisons, which `isLogicalSyntax` sends down the same path even though their value is
+* a boolean rather than either side.
+*
+* Hoisted rather than built per call: `accountsForSource` asks this for every property of
+* every candidate, and rebuilding a thirteen-element list each time is not free.
+*/
+const COLLAPSED_BINARY = new Set([
+	...SHORT_CIRCUIT,
+	SyntaxKind.EqualsEqualsToken,
+	SyntaxKind.EqualsEqualsEqualsToken,
+	SyntaxKind.ExclamationEqualsToken,
+	SyntaxKind.ExclamationEqualsEqualsToken,
+	SyntaxKind.GreaterThanToken,
+	SyntaxKind.GreaterThanEqualsToken,
+	SyntaxKind.LessThanToken,
+	SyntaxKind.LessThanEqualsToken,
+	SyntaxKind.InKeyword,
+	SyntaxKind.InstanceOfKeyword
+]);
+const isCollapsedBinary = (node) => Node.isBinaryExpression(node) && COLLAPSED_BINARY.has(node.getOperatorToken().getKind());
+/**
+* Does the extracted box account for every property the source declares?
+*
+* `isStaticBox` is not sufficient on its own. The extractor *omits* what it cannot
+* evaluate rather than marking it unresolvable, so `css({ color: 'red.300', ...rest })`
+* yields a perfectly static-looking map holding only `color`. Folding that produces
+* `"c_red.300"` and silently drops everything `rest` contributed.
+*
+* So the source is the authority on what the call contains, and anything the box does
+* not account for disqualifies the fold:
+*
+* - a declared property missing from the map (its value did not evaluate)
+* - a computed key, which we cannot match against the map by name
+* - a spread, unless it is an inline object literal
+*
+* Spreads are the conservative case. `{ ...base }` where `base` is a static local
+* object *is* resolved by the extractor, but a resolved spread and an unresolved one
+* are indistinguishable once flattened into the map — both just contribute keys, or
+* fail to. Rather than guess and erase evaluation the compiler cannot reproduce, the call
+* is rejected.
+*/
+/**
+* What a property's value is written as. A shorthand names it, so the name *is* the
+* expression — reading an initializer that is not there reports the property as having no
+* source, and everything hidden behind the name goes unchecked.
+*/
+const valueOf = (property) => Node.isPropertyAssignment(property) ? property.getInitializer() : Node.isShorthandPropertyAssignment(property) ? property.getNameNode() : void 0;
+const accountsForSource = (node, boxNode) => {
+	if (!node) return true;
+	const unwrapped = unwrapExpression(node);
+	if ((Node.isConditionalExpression(unwrapped) || isCollapsedBinary(unwrapped)) && !box.isConditional(boxNode) && !decidedAtBuildTime(unwrapped)) return false;
+	if (Node.isArrayLiteralExpression(unwrapped)) {
+		if (!box.isArray(boxNode)) return false;
+		const elements = unwrapped.getElements();
+		if (elements.length !== boxNode.value.length) return false;
+		return elements.every((element, index) => accountsForSource(element, boxNode.value[index]));
+	}
+	if (!Node.isObjectLiteralExpression(unwrapped)) {
+		const origin = box.isMap(boxNode) ? boxNode.getNode() : void 0;
+		return !origin || origin === unwrapped || !Node.isObjectLiteralExpression(origin) ? true : accountsForSource(origin, boxNode);
+	}
+	if (!box.isMap(boxNode)) return false;
+	for (const property of unwrapped.getProperties()) {
+		if (Node.isSpreadAssignment(property)) {
+			const expression = unwrapExpression(property.getExpression());
+			if (Node.isObjectLiteralExpression(expression)) continue;
+			const walked = boxNode.resolvedSpreads?.find((entry) => entry.node === expression);
+			if (!walked) return false;
+			if (!accountsForSource(walked.box.getNode(), walked.box)) return false;
+			continue;
+		}
+		if (Node.isMethodDeclaration(property) || Node.isGetAccessorDeclaration(property) || Node.isSetAccessorDeclaration(property)) return false;
+		if (!Node.isPropertyAssignment(property) && !Node.isShorthandPropertyAssignment(property)) return false;
+		const nameNode = property.getNameNode();
+		if (Node.isComputedPropertyName(nameNode)) return false;
+		const key = Node.isStringLiteral(nameNode) || Node.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
+		const value = valueOf(property);
+		if (value && Node.isIdentifier(value) && value.getText() === "undefined") continue;
+		if (!boxNode.value.has(key)) return false;
+		if (!accountsForSource(value, boxNode.value.get(key))) return false;
+	}
+	return true;
+};
+/**
+* Memo keyed on a file, thrown away when its text is replaced.
+*
+* A plain `WeakMap<SourceFile, …>` is wrong here: ts-morph reuses the wrapper when a path
+* is re-added with new text — which is what a watch rebuild does — so it would answer for
+* the previous revision. Comparing against the text it was computed from costs a
+* reference check while the file is unchanged, since `getFullText()` hands back the same
+* string instance.
+*/
+const byText = (cache, sourceFile, compute) => {
+	const text = sourceFile.getFullText();
+	const hit = cache.get(sourceFile);
+	if (hit && hit.text === text) return hit.value;
+	const value = compute();
+	cache.set(sourceFile, {
+		text,
+		value
+	});
+	return value;
+};
+/**
+* Every name declared at module scope, which is what an added import could collide with.
+*
+* This replaced `sourceFile.getLocals()`. That was precise, but it goes through the
+* compiler's symbol table, and reaching for it binds the program — including every
+* `.d.ts` the module's imports pull in. It cost ~8ms on a ten-line file and grew with the
+* project, which was invisible while only a partial split reached it and became the
+* dominant cost once open-ended values started lowering too.
+*
+* A syntactic walk answers the same question: a binding in a nested *function* cannot
+* collide with a module-scope import, and one that shadows it *at the call site* is what
+* `isShadowed` is for. Memoized against the file's text rather than the file, since
+* ts-morph reuses the wrapper across a re-add and a plain `WeakMap` would answer for the
+* previous revision. Uncached it is re-walked per candidate, which is quadratic in a
+* module of many elements.
+*/
+const moduleScopeCache = /* @__PURE__ */ new WeakMap();
+const declaredAtModuleScope = (sourceFile) => byText(moduleScopeCache, sourceFile, () => collectModuleScopeNames(sourceFile));
+const collectModuleScopeNames = (sourceFile) => {
+	const names = /* @__PURE__ */ new Set();
+	const addBinding = (node) => {
+		if (!node) return;
+		if (Node.isObjectBindingPattern(node) || Node.isArrayBindingPattern(node)) {
+			for (const element of node.getElements()) if (Node.isBindingElement(element)) addBinding(element.getNameNode());
+			return;
+		}
+		if (Node.isIdentifier(node)) names.add(node.getText());
+	};
+	const addDeclarations = (list) => {
+		if (Node.isVariableStatement(list)) {
+			for (const declaration of list.getDeclarations()) addBinding(declaration.getNameNode());
+			return;
+		}
+		if (Node.isVariableDeclarationList(list)) for (const declaration of list.getDeclarations()) addBinding(declaration.getNameNode());
+	};
+	const isVar = (node) => (Node.isVariableStatement(node) || Node.isVariableDeclarationList(node)) && node.getDeclarationKind() === VariableDeclarationKind.Var;
+	/**
+	* `var` is scoped to the enclosing *function*, not the enclosing block, so one written
+	* inside any statement at the top level still binds at module scope. Walking only the
+	* top-level statements missed every one of them, and each emitted a duplicate binding.
+	*
+	* Only statement containers are followed. A function or class body opens a new variable
+	* scope, so a `var` inside one cannot collide with a module-level import.
+	*/
+	const addHoistedVars = (node) => {
+		if (isVar(node)) {
+			addDeclarations(node);
+			return;
+		}
+		if (Node.isBlock(node)) {
+			for (const statement of node.getStatements()) addHoistedVars(statement);
+			return;
+		}
+		if (Node.isIfStatement(node)) {
+			addHoistedVars(node.getThenStatement());
+			const otherwise = node.getElseStatement();
+			if (otherwise) addHoistedVars(otherwise);
+			return;
+		}
+		if (Node.isForStatement(node)) {
+			const initializer = node.getInitializer();
+			if (initializer) addHoistedVars(initializer);
+			addHoistedVars(node.getStatement());
+			return;
+		}
+		if (Node.isForInStatement(node) || Node.isForOfStatement(node)) {
+			addHoistedVars(node.getInitializer());
+			addHoistedVars(node.getStatement());
+			return;
+		}
+		if (Node.isWhileStatement(node) || Node.isDoStatement(node) || Node.isWithStatement(node)) {
+			addHoistedVars(node.getStatement());
+			return;
+		}
+		if (Node.isLabeledStatement(node)) {
+			addHoistedVars(node.getStatement());
+			return;
+		}
+		if (Node.isTryStatement(node)) {
+			addHoistedVars(node.getTryBlock());
+			const caught = node.getCatchClause();
+			if (caught) addHoistedVars(caught.getBlock());
+			const finally_ = node.getFinallyBlock();
+			if (finally_) addHoistedVars(finally_);
+			return;
+		}
+		if (Node.isSwitchStatement(node)) for (const clause of node.getCaseBlock().getClauses()) for (const statement of clause.getStatements()) addHoistedVars(statement);
+	};
+	for (const statement of sourceFile.getStatements()) {
+		if (Node.isVariableStatement(statement)) {
+			addDeclarations(statement);
+			continue;
+		}
+		if (Node.isImportDeclaration(statement)) {
+			addBinding(statement.getDefaultImport());
+			addBinding(statement.getNamespaceImport());
+			for (const named of statement.getNamedImports()) addBinding(named.getAliasNode() ?? named.getNameNode());
+			continue;
+		}
+		if (Node.isImportEqualsDeclaration(statement)) {
+			addBinding(statement.getNameNode());
+			continue;
+		}
+		if (Node.isFunctionDeclaration(statement) || Node.isClassDeclaration(statement) || Node.isEnumDeclaration(statement) || Node.isModuleDeclaration(statement) || Node.isTypeAliasDeclaration(statement) || Node.isInterfaceDeclaration(statement)) {
+			addBinding(statement.getNameNode());
+			continue;
+		}
+		addHoistedVars(statement);
+	}
+	return names;
+};
+/**
+* Every identifier in the module, grouped by the name it spells.
+*
+* Built once per pass and handed to each lookup, because walking the whole tree per binding
+* made that O(bindings x identifiers): a module declaring ten recipes walked its identifiers
+* ten times.
+*
+* ## Why this is a raw walk rather than `getDescendantsOfKind`
+*
+* `SyntaxKind.Identifier` sorts *below* `SyntaxKind.FirstNode`, which is what ts-morph tests to
+* decide whether it may search the parse tree. For a kind below that line it falls back to
+* materialising the whole **token** tree — every brace, comma and keyword becomes a ts-morph node
+* on the way to collecting the identifiers. On 55 KB of real tsx that measured 22ms against
+* 0.22ms for the same collection over compiler nodes, and the node cache does not help: a second
+* call cost the same 22ms.
+*
+* Wrapping is what costs, so only the buckets a caller actually reads are wrapped, on the first
+* read and cached after. Nothing enumerates this index — both callers ask for one name — so the
+* rest is never built. `_getNodeFromCompilerNode` is ts-morph's own memoized wrapper factory, so
+* a node handed back here is the very object `getDescendantsOfKind` would have returned, which
+* `localReferencesTo` depends on: it compares against the declaration by identity.
+*
+* JSDoc is walked explicitly. `ts.forEachChild` does not descend into it, while the token path
+* this replaces does, so a name mentioned only in a `@type` annotation was previously found and
+* would otherwise stop being — a silent narrowing of what counts as a surviving reference.
+* Keyed on `escapedText` because that is what ts-morph's `Identifier.getText()` returns: the name
+* as the compiler resolves it, so `\u0062adge` and `badge` share a bucket exactly as before.
+*
+* Deliberately *not* memoized across passes, unlike the module-scope names beside it. That
+* cache holds strings, which outlive anything; this one holds nodes, and a node does not
+* survive its source file being replaced — `addSourceFile` overwrites, which forgets every
+* node previously taken from it. Keying on the source text does not help, because identical
+* text re-parsed is a fresh tree: the cache hits and returns nodes that throw
+* `Attempted to get information from a node that was removed or forgotten` on the next read.
+*/
+const identifierIndex = (sourceFile) => {
+	const compilerNodes = /* @__PURE__ */ new Map();
+	const collect = (node) => {
+		if (node.kind === ts.SyntaxKind.Identifier) {
+			const name = String(node.escapedText);
+			const known = compilerNodes.get(name);
+			if (known) known.push(node);
+			else compilerNodes.set(name, [node]);
+		}
+		const jsDoc = node.jsDoc;
+		if (jsDoc) for (const doc of jsDoc) collect(doc);
+		ts.forEachChild(node, collect);
+	};
+	ts.forEachChild(sourceFile.compilerNode, collect);
+	const wrapped = /* @__PURE__ */ new Map();
+	const wrap = sourceFile;
+	return { get: (name) => {
+		const known = wrapped.get(name);
+		if (known) return known;
+		const nodes = (compilerNodes.get(name) ?? []).map((node) => wrap._getNodeFromCompilerNode(node));
+		wrapped.set(name, nodes);
+		return nodes;
+	} };
+};
+const localReferencesTo = (index, name, declaration) => {
+	const references = [];
+	for (const identifier of index.get(name)) {
+		if (identifier === declaration) continue;
+		const parent = identifier.getParent();
+		if (!parent) continue;
+		if (Node.isPropertyAccessExpression(parent) && parent.getNameNode() === identifier) continue;
+		if (Node.isPropertyAssignment(parent) && parent.getNameNode() === identifier) continue;
+		if (Node.isBindingElement(parent) && parent.getPropertyNameNode() === identifier) continue;
+		if ((Node.isJsxOpeningElement(parent) || Node.isJsxSelfClosingElement(parent) || Node.isJsxClosingElement(parent)) && parent.getTagNameNode() === identifier) continue;
+		if (Node.isJsxAttribute(parent) && parent.getNameNode() === identifier) continue;
+		if ((Node.isMethodDeclaration(parent) || Node.isPropertyDeclaration(parent) || Node.isGetAccessorDeclaration(parent) || Node.isSetAccessorDeclaration(parent) || Node.isMethodSignature(parent) || Node.isPropertySignature(parent) || Node.isEnumMember(parent)) && parent.getNameNode() === identifier) continue;
+		if ((Node.isVariableDeclaration(parent) || Node.isParameterDeclaration(parent) || Node.isFunctionDeclaration(parent) || Node.isClassDeclaration(parent) || Node.isBindingElement(parent)) && parent.getNameNode() === identifier) continue;
+		if (Node.isImportSpecifier(parent) || Node.isExportSpecifier(parent)) {
+			if (parent.getNameNode() !== identifier) continue;
+			if (Node.isExportSpecifier(parent)) {
+				references.push(identifier);
+				continue;
+			}
+			continue;
+		}
+		references.push(identifier);
+	}
+	return references;
+};
+//#endregion
+//#region src/fold-recipe.ts
+/**
+* Binding name → the config it was declared with.
+*
+* Built from the definitions the parser already recorded, walking each one to the declaration
+* that names it. The parser records a definition under the name it was *imported* as (`cva`),
+* and a call under the name the file *bound* (`badge`); this is what joins the two.
+*
+* Slot and ordinary recipes share one representation.
+*/
+const collectRecipeConfigs = (parserResult) => {
+	const configs = /* @__PURE__ */ new Map();
+	const definitions = [...parserResult.cva, ...parserResult.sva];
+	for (const definition of definitions) {
+		const node = definition.box?.getNode?.();
+		if (!node) continue;
+		const nameNode = ((Node.isCallExpression(node) ? node : node.getFirstAncestorByKind(SyntaxKind.CallExpression))?.getFirstAncestorByKind(SyntaxKind.VariableDeclaration))?.getNameNode();
+		if (!nameNode || !Node.isIdentifier(nameNode)) continue;
+		if (definition.data?.length !== 1) {
+			configs.set(nameNode.getText(), AMBIGUOUS);
+			continue;
+		}
+		const config = definition.data[0];
+		if (!config || typeof config !== "object") continue;
+		if (configs.has(nameNode.getText())) {
+			configs.set(nameNode.getText(), AMBIGUOUS);
+			continue;
+		}
+		configs.set(nameNode.getText(), {
+			config,
+			box: definition.box
+		});
+	}
+	return configs;
+};
+/** Pick a complete precompiled StyleSet for one or more runtime recipe axes. */
+const RECIPE_MAP_HELPER = "cvaMap";
+/** Guard the exact compiler against accidentally materialising an enormous Cartesian product. */
+const DEFAULT_MAX_RECIPE_STATES = 65536;
+/** What `recipe.splitVariantProps` calls, reached directly once the call is lowered. */
+const SPLIT_PROPS_HELPER = "splitProps";
+/** Marker for a binding the fold must never resolve — declared twice, or unresolvable. */
+const AMBIGUOUS = Object.freeze({
+	config: {},
+	box: void 0
+});
+/** `.size`, or `["x-large"]` when the variant is not a valid identifier. */
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+const propertyAccess = (key) => IDENTIFIER.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+const LITERAL_KINDS = new Set([
+	SyntaxKind.StringLiteral,
+	SyntaxKind.NoSubstitutionTemplateLiteral,
+	SyntaxKind.NumericLiteral,
+	SyntaxKind.TrueKeyword,
+	SyntaxKind.FalseKeyword
+]);
+/**
+* The value a literal node denotes, or `undefined` for anything else.
+*
+* Read off the node rather than from the extractor's resolved data, because that data is lossy
+* in the direction that matters: a property it could not resolve is *dropped*, so `badge({ tone })`
+* and `badge({})` are identical there. Folding the first as if it were the second emits a class
+* string missing the variant — the element renders, wrongly, with no report.
+*/
+const literalValue = (node) => {
+	if (!node || !LITERAL_KINDS.has(node.getKind())) return void 0;
+	if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) return node.getLiteralValue();
+	if (Node.isNumericLiteral(node)) return node.getLiteralValue();
+	if (node.getKind() === SyntaxKind.TrueKeyword) return true;
+	if (node.getKind() === SyntaxKind.FalseKeyword) return false;
+};
+/**
+* The property name a key node denotes.
+*
+* Read off the node rather than unquoted from its text. `{ '\\u0074one': 'a' }` names the
+* variant `tone`, and stripping the surrounding quotes leaves the escape uninterpreted — so
+* the variant did not match, its class was dropped, and the element rendered without it. A
+* numeric key normalises the same way: `{ 0x10: 'a' }` is the key `16`.
+*/
+const propertyKey = (nameNode) => {
+	if (Node.isIdentifier(nameNode)) return nameNode.getText();
+	if (Node.isStringLiteral(nameNode) || Node.isNoSubstitutionTemplateLiteral(nameNode)) return nameNode.getLiteralValue();
+	if (Node.isNumericLiteral(nameNode)) return String(nameNode.getLiteralValue());
+};
+/**
+* Make a generated compile helper callable at this call site, by whatever name the file gives it.
+*
+* Unlike `cx`, an inline recipe's callee is a local binding, so
+* there is nothing to match — the host here is any import of the generated css module, which
+* a file defining a recipe necessarily has, since `cva` came from it.
+*/
+const ensureRecipeHelperImport = (imported, call, isBambooCssModule, isGeneratedCssModule, isShadowed, newImportModule, helperModuleFromSubpath) => {
+	const sourceFile = call.getSourceFile();
+	let host;
+	let subpathModule;
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		const mod = declaration.getModuleSpecifierValue();
+		if (declaration.isTypeOnly()) continue;
+		for (const named of declaration.getNamedImports()) {
+			if (named.isTypeOnly()) continue;
+			if (named.getNameNode().getText() === imported) {
+				if (!isBambooCssModule(mod)) return void 0;
+				const local = (named.getAliasNode() ?? named.getNameNode()).getText();
+				return isShadowed(call, local) ? void 0 : { name: local };
+			}
+		}
+		if (!host && isGeneratedCssModule(mod) && declaration.getNamedImports().length > 0) host = declaration;
+		if (!subpathModule) subpathModule = helperModuleFromSubpath?.(mod);
+	}
+	const fallbackModule = newImportModule ?? subpathModule;
+	if (!host && !fallbackModule) return void 0;
+	if (declaredAtModuleScope(sourceFile).has(imported)) return void 0;
+	if (isShadowed(call, imported)) return void 0;
+	if (!host) {
+		const anchor = sourceFile.getImportDeclarations().at(-1);
+		if (!anchor) return void 0;
+		return {
+			name: imported,
+			insert: {
+				pos: anchor.getEnd(),
+				names: [imported],
+				module: fallbackModule
+			}
+		};
+	}
+	const last = host.getNamedImports().at(-1);
+	if (!last) return void 0;
+	return {
+		name: imported,
+		insert: {
+			pos: last.getEnd(),
+			names: [imported]
+		}
+	};
+};
+/**
+* Lower one invocation, or say why not.
+*
+* Every property written at the call site has to be a literal. A selection is not additive —
+* an unresolved variant does not merely omit a class, it can change which of several the
+* recipe applies — so a partially-known selection is not foldable at all.
+*/
+const lowerRecipeCall = (call, entry, styleCompiler, isInert, resolvedSelection, slot, maxRecipeStates = DEFAULT_MAX_RECIPE_STATES) => {
+	if (!entry || entry === AMBIGUOUS) return {
+		kind: "decline",
+		reason: "unknown-recipe"
+	};
+	const { config } = entry;
+	if (config.slots !== void 0) {
+		if (!Array.isArray(config.slots) || slot !== void 0 && !config.slots.includes(slot)) return {
+			kind: "decline",
+			reason: "unsupported-shape"
+		};
+	} else if (slot) return {
+		kind: "decline",
+		reason: "unsupported-shape"
+	};
+	if (!config.base && !config.variants && !config.className) return {
+		kind: "decline",
+		reason: "unknown-recipe"
+	};
+	if (!Node.isCallExpression(call)) return {
+		kind: "decline",
+		reason: "unsupported-shape"
+	};
+	const args = call.getArguments();
+	if (args.length > 1) return {
+		kind: "decline",
+		reason: "unsupported-shape"
+	};
+	const selection = {};
+	/** Variant → the source expression selecting it, for axes that stay runtime decisions. */
+	const dynamicAxes = /* @__PURE__ */ new Map();
+	/**
+	* Variants whose expression could run something, in the order the source evaluates them.
+	*
+	* The text is kept, not just the key: a later property writing the same key replaces the
+	* entry in `dynamicAxes`, and the expression recorded here would then never be emitted.
+	*/
+	const effectful = [];
+	if (args.length === 1) {
+		const arg = args[0];
+		if (!arg) return {
+			kind: "decline",
+			reason: "dynamic"
+		};
+		/**
+		* `input(variantProps)` — a selection the build cannot see inside.
+		*
+		* The compiled recipe contract accepts scalar declared variant values. A conditional
+		* object is not a finite selection value; responsiveness belongs inside a variant's style
+		* declaration, where the compiler can materialize its conditions ahead of time.
+		*
+		* The complete StyleSets are knowable: the config declares every scalar value each axis
+		* accepts. This is the shape a wrapper component takes, where variants are its public API
+		* and therefore cannot be literals by definition.
+		*
+		* An identifier only. Each variant reads the binding again, and re-reading anything else —
+		* a call, a property access — would evaluate it once per axis instead of once.
+		*/
+		if (Node.isIdentifier(arg)) {
+			const binding = arg.getText();
+			for (const key of Object.keys(config.variants ?? {})) dynamicAxes.set(key, `${binding}${propertyAccess(key)}`);
+		} else if (!Node.isObjectLiteralExpression(arg)) return {
+			kind: "decline",
+			reason: "dynamic"
+		};
+		else for (const property of arg.getProperties()) {
+			if (Node.isSpreadAssignment(property)) return {
+				kind: "decline",
+				reason: "dynamic"
+			};
+			if (Node.isShorthandPropertyAssignment(property)) {
+				dynamicAxes.set(property.getName(), property.getName());
+				delete selection[property.getName()];
+				continue;
+			}
+			if (!Node.isPropertyAssignment(property)) return {
+				kind: "decline",
+				reason: "dynamic"
+			};
+			const nameNode = property.getNameNode();
+			if (Node.isComputedPropertyName(nameNode)) return {
+				kind: "decline",
+				reason: "dynamic"
+			};
+			const key = propertyKey(nameNode);
+			if (key === void 0) return {
+				kind: "decline",
+				reason: "dynamic"
+			};
+			const initializer = property.getInitializer();
+			if (initializer && !isInert(initializer)) {
+				if (!Object.hasOwn(config.variants ?? {}, key)) return {
+					kind: "decline",
+					reason: "dynamic"
+				};
+				effectful.push({
+					key,
+					text: initializer.getText()
+				});
+				dynamicAxes.set(key, initializer.getText());
+				delete selection[key];
+				continue;
+			}
+			const literal = literalValue(initializer);
+			if (literal !== void 0) {
+				selection[key] = literal;
+				dynamicAxes.delete(key);
+				continue;
+			}
+			if (!resolvedSelection || !Object.hasOwn(resolvedSelection, key)) {
+				if (!initializer) return {
+					kind: "decline",
+					reason: "dynamic"
+				};
+				dynamicAxes.set(key, initializer.getText());
+				delete selection[key];
+				continue;
+			}
+			const value = resolvedSelection[key];
+			if (value !== null && typeof value === "object") return {
+				kind: "decline",
+				reason: "dynamic"
+			};
+			selection[key] = value;
+			dynamicAxes.delete(key);
+		}
+	}
+	/**
+	* Every expression that could run something has to reach the output carrying its own text.
+	*
+	* A later property writing the same key replaces it in `dynamicAxes` — `badge({ tone: a(),
+	* tone: 'b' })` is last-wins for the *value*, but `a()` still runs, and emitting only the
+	* literal would delete it. Duplicate keys are a type error in TypeScript; the fold does not
+	* typecheck and does transform `.js`, so this is reachable.
+	*/
+	const everyEffectSurvives = () => effectful.every(({ key, text }) => dynamicAxes.get(key) === text);
+	const compiledSelection = (selected) => {
+		if (Array.isArray(config.slots) && slot === void 0) {
+			const slots = {};
+			const classNames = /* @__PURE__ */ new Set();
+			for (const slotName of config.slots) {
+				const styles = styleCompiler.resolveRecipe(config, selected, slotName);
+				if (!styles) return void 0;
+				const className = styleCompiler.className(styles);
+				slots[slotName] = className;
+				for (const token of className.split(" ")) if (token) classNames.add(token);
+			}
+			return {
+				value: slots,
+				classNames: [...classNames]
+			};
+		}
+		const styles = styleCompiler.resolveRecipe(config, selected, slot);
+		if (!styles) return void 0;
+		const className = styleCompiler.className(styles);
+		return {
+			value: className,
+			classNames: className.split(" ").filter(Boolean),
+			styles
+		};
+	};
+	if (dynamicAxes.size === 0) {
+		if (!everyEffectSurvives()) return {
+			kind: "decline",
+			reason: "dynamic"
+		};
+		const compiled = compiledSelection(selection);
+		if (!compiled) return {
+			kind: "decline",
+			reason: "dynamic"
+		};
+		if (typeof compiled.value === "string") return {
+			kind: "class",
+			className: compiled.value,
+			styles: compiled.styles
+		};
+		return {
+			kind: "slots",
+			expression: JSON.stringify(compiled.value),
+			classNames: compiled.classNames,
+			dynamic: false
+		};
+	}
+	if (!everyEffectSurvives()) return {
+		kind: "decline",
+		reason: "dynamic"
+	};
+	if (effectful.length > 1) {
+		const variantOrder = Object.keys(config.variants ?? {});
+		const keys = effectful.map((entry) => entry.key);
+		if ([...keys].sort((a, b) => variantOrder.indexOf(a) - variantOrder.indexOf(b)).join("\0") !== keys.join("\0")) return {
+			kind: "decline",
+			reason: "dynamic"
+		};
+	}
+	for (const key of [...dynamicAxes.keys()]) if (!Object.hasOwn(config.variants ?? {}, key)) dynamicAxes.delete(key);
+	if (dynamicAxes.size === 0) {
+		const compiled = compiledSelection(selection);
+		if (!compiled) return {
+			kind: "decline",
+			reason: "dynamic"
+		};
+		if (typeof compiled.value === "string") return {
+			kind: "class",
+			className: compiled.value,
+			styles: compiled.styles
+		};
+		return {
+			kind: "slots",
+			expression: JSON.stringify(compiled.value),
+			classNames: compiled.classNames,
+			dynamic: false
+		};
+	}
+	/**
+	* Compile the finite recipe state space into a reduced decision table.
+	*
+	* Each leaf is a *complete* final StyleSet. This matters for declarations overridden by
+	* variants and compounds: selecting independent per-axis atoms would put both values in
+	* the utility layer and let stylesheet order, rather than the recipe's merge order, pick
+	* the winner. Complete leaves retain the same precedence while sharing their atoms with
+	* every `css()` and recipe in the build.
+	*
+	* `undefined` is its own edge because it restores a default variant. `null` and any
+	* undeclared value take the miss edge and explicitly suppress that default. Declared
+	* values use string keys, matching JavaScript's property-key coercion in the recipe
+	* runtime. A flat alternating key/value array avoids the special `__proto__` semantics
+	* of an object literal.
+	*/
+	const axes = Object.keys(config.variants ?? {}).filter((key) => dynamicAxes.has(key));
+	const stateCount = axes.reduce((product, axis) => product * (Object.keys(config.variants?.[axis] ?? {}).length + 2), 1);
+	if (stateCount > maxRecipeStates) throw new Error(`Static recipe compilation would inspect ${stateCount.toLocaleString("en-US")} selections across ${axes.length} runtime variant axes, above maxRecipeStates=${maxRecipeStates.toLocaleString("en-US")}. Make one or more axes statically known, split the recipe, or raise the limit explicitly.`);
+	const expressions = axes.map((axis) => dynamicAxes.get(axis));
+	const wholeSlots = Array.isArray(config.slots) && slot === void 0;
+	return {
+		kind: "dynamic-style",
+		map: {
+			outputKind: wholeSlots ? "slots" : "class",
+			compile(before = [], after = []) {
+				const nodes = [];
+				const nodeByShape = /* @__PURE__ */ new Map();
+				const leaves = [];
+				const leafByShape = /* @__PURE__ */ new Map();
+				const emittedClasses = /* @__PURE__ */ new Set();
+				const leaf = (dynamicSelection) => {
+					const selected = {
+						...selection,
+						...dynamicSelection
+					};
+					if (wholeSlots) {
+						const compiled = compiledSelection(selected);
+						if (!compiled || typeof compiled.value === "string") return internLeaf("");
+						for (const token of compiled.classNames) emittedClasses.add(token);
+						return internLeaf(compiled.value);
+					}
+					const styles = styleCompiler.resolveRecipe(config, selected, slot);
+					if (!styles) return internLeaf("");
+					const className = styleCompiler.className(styleCompiler.compose(...before, styles, ...after));
+					for (const token of className.split(" ")) if (token) emittedClasses.add(token);
+					return internLeaf(className);
+				};
+				function internLeaf(value) {
+					const shape = JSON.stringify(value);
+					const known = leafByShape.get(shape);
+					if (known !== void 0) return ~known;
+					const id = leaves.length;
+					leaves.push(value);
+					leafByShape.set(shape, id);
+					return ~id;
+				}
+				const buildNode = (index, dynamicSelection) => {
+					if (index === axes.length) return leaf(dynamicSelection);
+					const axis = axes[index];
+					const values = Object.keys(config.variants?.[axis] ?? {});
+					const miss = buildNode(index + 1, {
+						...dynamicSelection,
+						[axis]: null
+					});
+					const absentSelection = { ...dynamicSelection };
+					delete absentSelection[axis];
+					const absent = buildNode(index + 1, absentSelection);
+					const byValue = [];
+					for (const value of values) byValue.push(value, buildNode(index + 1, {
+						...dynamicSelection,
+						[axis]: value
+					}));
+					const refs = [
+						miss,
+						absent,
+						...byValue.filter((_, valueIndex) => valueIndex % 2 === 1)
+					];
+					if (refs.every((ref) => ref === refs[0])) return refs[0];
+					const node = [
+						miss,
+						absent,
+						byValue
+					];
+					const shape = JSON.stringify(node);
+					const known = nodeByShape.get(shape);
+					if (known !== void 0) return known;
+					const id = nodes.length;
+					nodes.push(node);
+					nodeByShape.set(shape, id);
+					return id;
+				};
+				const root = buildNode(0, {});
+				const staticLeaf = root < 0 ? leaves[~root] : void 0;
+				return {
+					expression: root < 0 && effectful.length === 0 ? JSON.stringify(staticLeaf) : `${RECIPE_MAP_HELPER}([${expressions.join(", ")}], ${JSON.stringify(nodes)}, ${JSON.stringify(leaves)}, ${root})`,
+					classNames: [...emittedClasses],
+					staticClasses: typeof staticLeaf === "string" ? staticLeaf : "",
+					outputKind: wholeSlots ? "slots" : "class",
+					usesHelper: !(root < 0 && effectful.length === 0)
+				};
+			}
+		}
+	};
+};
+//#endregion
+//#region src/runtime-css.ts
+/** The shape `createCss` and `createMergeCss` both take, derived from a resolved context. */
+const createCssContext = (ctx) => ({
+	hash: Boolean(ctx.hash.className),
+	conditions: {
+		shift: ctx.conditions.shift,
+		finalize: ctx.conditions.finalize
+	},
+	utility: {
+		prefix: ctx.utility.prefix,
+		hasShorthand: ctx.utility.hasShorthand,
+		resolveShorthand: ctx.utility.resolveShorthand.bind(ctx.utility),
+		transform: ctx.utility.transform.bind(ctx.utility),
+		toHash: ctx.utility.toHash.bind(ctx.utility)
+	}
+});
+const createRuntimeCss = (ctx) => {
+	const cssContext = createCssContext(ctx);
+	const cssFn = createCssUncached(cssContext);
+	const { mergeCssUncached } = createMergeCss(cssContext);
+	return memo((...styles) => cssFn(mergeCssUncached(...styles)));
+};
+/**
+* The map is every token in the project, so it is built once per context and shared by
+* every module in the build — not once per `foldSource`, which would price a whole token
+* table into each of the overwhelming majority of modules that call `token()` zero times.
+* Keyed weakly so a context that goes out of scope takes its table with it.
+*
+* Both halves of the generated entry are stored, because `token()` and `token.value()` read
+* different ones and building a second table would pay the same per-project cost twice.
+*/
+const tokenValues = /* @__PURE__ */ new WeakMap();
+const tokenValuesFor = (ctx) => {
+	let values = tokenValues.get(ctx);
+	if (values) return values;
+	values = /* @__PURE__ */ new Map();
+	for (const token of ctx.tokens.allTokens) {
+		const { varRef, isVirtual, condition } = token.extensions;
+		values.set(token.name, {
+			value: ctx.tokens.view.get(token.name) ?? (isVirtual || condition !== "base" ? varRef : token.value),
+			variable: ctx.tokens.view.getVar(token.name) ?? varRef
+		});
+	}
+	tokenValues.set(ctx, values);
+	return values;
+};
+const createRuntimeTokenValue = (ctx) => (path) => {
+	const value = tokenValuesFor(ctx).get(path)?.value;
+	return typeof value === "string" ? value : void 0;
+};
+/**
+* The generated runtime's `token()`, rebuilt in-process.
+*
+* Reads the `variable` half of the same entry `token.value()` reads the `value` half of.
+* That half is `varRef` for every token regardless of condition, so unlike
+* `createRuntimeTokenValue` there is no split to get wrong and no non-string case to
+* decline: a `var()` reference is a string or the token does not exist. Which is what makes
+* the default form the trivially foldable one.
+*/
+const createRuntimeToken = (ctx) => (path) => tokenValuesFor(ctx).get(path)?.variable || void 0;
+//#endregion
+//#region src/fold.ts
+/**
+* `cva`/`sva` return a function, so their definitions are compile-time declarations rather
+* than class-producing calls; once their uses are lowered, the factory calls are erased.
+* `token` also resolves to no class, but it does resolve to a literal, so it compiles through
+* its own path rather than being declined outright. A static `viewTransition` bag resolves to
+* its extracted class and uses the ordinary class candidate path.
+*
+* Recipe invocations compile through `fold-recipe`. Inline calls
+* are recorded under the name the file bound; config calls arrive as `recipe`. Routing both
+* through one exact finite-state lowering keeps their selection contract identical.
+*/
+const FOLDABLE_TYPES = new Set([
+	"css",
+	"pattern",
+	"viewTransition"
+]);
+/**
+* The skip reasons that leave a `css()`-family call in the output.
+*
+* `overlapping` is handled by the enclosing fold, and `not-imported` is somebody else's
+* function of the same name — neither leaves a call of ours.
+*/
+const SURVIVES_TO_RUNTIME = new Set([
+	"dynamic",
+	"runtime-binding",
+	"raw-call",
+	"unsupported-kind",
+	"no-call-expression",
+	"unresolved-token",
+	"compile-failed"
+]);
+/**
+* A call of a recipe the file bound itself: `const badge = cva(...)`, then `badge({ tone })`.
+*
+* Folded when the whole selection resolves, reported under this reason when it does not.
+* Deliberately all-or-nothing: an unresolved variant does not merely omit its own class, so a
+* partially-known selection is not foldable at all.
+*
+* Visible at all because it used to not be. The parser matched calls by imported name, so a
+* local binding was never recorded, and an unfoldable invocation looked identical to code
+* nothing had parsed.
+*/
+const RECIPE_CALL_TYPE = "cva-call";
+/**
+* An identifier that actually reads the binding.
+*
+* `getDescendantsOfKind(Identifier)` yields every name in the file, and most of them bind or
+* label rather than read: a JSX tag (`<button/>` against a recipe called `button`), an object
+* key, a property name, a declaration. Counting those failed builds on modules that had
+* folded completely — and `button`, `input`, `label`, `select`, `table`, `dialog` and `form`
+* are all ordinary recipe names as well as intrinsic elements.
+*
+* A type position is excluded for a different reason: it is erased, and with it the import.
+*/
+const isValueReference = (identifier) => {
+	const parent = identifier.getParent();
+	if (!parent) return false;
+	if (Node.isImportSpecifier(parent) || Node.isExportSpecifier(parent)) return false;
+	if (Node.isImportClause(parent) || Node.isNamespaceImport(parent)) return false;
+	if (Node.isPropertyAccessExpression(parent) && parent.getNameNode() === identifier) return false;
+	if (Node.isQualifiedName(parent) && parent.getRight() === identifier) return false;
+	if (Node.isPropertyAssignment(parent) && parent.getNameNode() === identifier) return false;
+	if (Node.isMethodDeclaration(parent) || Node.isPropertyDeclaration(parent) || Node.isGetAccessorDeclaration(parent) || Node.isSetAccessorDeclaration(parent) || Node.isMethodSignature(parent) || Node.isPropertySignature(parent) || Node.isEnumMember(parent)) {
+		if (parent.getNameNode() === identifier) return false;
+	}
+	if (Node.isLabeledStatement(parent) || Node.isBreakStatement(parent) || Node.isContinueStatement(parent)) return false;
+	if (Node.isJsxOpeningElement(parent) || Node.isJsxSelfClosingElement(parent) || Node.isJsxClosingElement(parent)) {
+		if (parent.getTagNameNode() === identifier) return identifier.getText()[0] === identifier.getText()[0]?.toUpperCase();
+	}
+	if (Node.isJsxAttribute(parent)) return false;
+	if (Node.isBindingElement(parent) && parent.getPropertyNameNode() === identifier) return false;
+	if ((Node.isVariableDeclaration(parent) || Node.isParameterDeclaration(parent) || Node.isBindingElement(parent) || Node.isFunctionDeclaration(parent) || Node.isClassDeclaration(parent)) && parent.getNameNode() === identifier) return false;
+	return !identifier.getFirstAncestor((ancestor) => Node.isTypeNode(ancestor) || Node.isTypeAliasDeclaration(ancestor) || Node.isInterfaceDeclaration(ancestor));
+};
+/**
+* Imports a surviving reference to is not a failure.
+*
+* These are what the compiler itself writes; all live in `cx` and pull no engine, so a
+* reference to one is the fold having worked.
+*/
+const PERMITTED_BINDINGS = new Set([
+	"cx",
+	RECIPE_MAP_HELPER,
+	SPLIT_PROPS_HELPER
+]);
+/**
+* Whether a module's text could hold a `splitVariantProps` property access.
+*
+* A necessary condition, deliberately not a sufficient one: the name inside a string or a
+* comment opens the walk, which costs what the walk always cost. What it must never do is
+* close on a module that has one, and an identifier may be spelled with unicode escapes —
+* `badge.splitVariantProps(p)` reads as the name to the compiler and contains none of it
+* as text. Both escape forms start `\u`, so one test covers every spelling.
+*/
+const mayNameSplitVariantProps = (text) => text.includes("splitVariantProps") || text.includes("\\u");
+/**
+* The pieces `trim` reduces a module specifier by, hoisted because a regex literal
+* constructs a new object every time it is evaluated and `trim` runs per specifier per
+* import declaration per module.
+*/
+const LEADING_RELATIVE = /^(?:\.\.?\/)+/;
+const TRAILING_SLASH = /\/$/;
+const MODULE_EXTENSION = /\.[mc]?[jt]sx?$/;
+const TRAILING_INDEX = /\/index$/;
+/**
+* An argument that cannot run anything when it is evaluated.
+*
+* `token()` takes one argument, but javascript evaluates every argument a call site passes
+* before the call — so a fold that drops an extra one also drops whatever evaluating it would
+* have done. `token('x', compute())` is pathological and no longer type-checks, and the fold's
+* contract is behaviour preservation regardless: a literal is the cheap way to prove it, since
+* it means no call, no property read, no getter.
+*/
+const isInertArgument = (node) => Node.isStringLiteral(node) || Node.isNumericLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node) || node.getKind() === SyntaxKind.TrueKeyword || node.getKind() === SyntaxKind.FalseKeyword || node.getKind() === SyntaxKind.NullKeyword || Node.isIdentifier(node) && node.getText() === "undefined";
+/**
+* An expression whose evaluation cannot do anything observable, so deleting it preserves
+* behaviour.
+*
+* `isInertArgument` covers the leaves; this walks the object and array literals a recipe
+* call is actually written with. A spread runs the source's getters, a computed key runs an
+* expression, a getter or method definition is a function — none of those are safe to
+* delete, so they are declined rather than enumerated.
+*/
+const isInertExpression = (node) => {
+	if (isInertArgument(node)) return true;
+	if (Node.isIdentifier(node)) return true;
+	if (Node.isAsExpression(node) || Node.isSatisfiesExpression(node) || Node.isNonNullExpression(node) || Node.isTypeAssertion(node) || Node.isParenthesizedExpression(node)) return isInertExpression(node.getExpression());
+	if (Node.isArrowFunction(node) || Node.isFunctionExpression(node)) return true;
+	if (Node.isRegularExpressionLiteral(node) || Node.isBigIntLiteral(node)) return true;
+	if (Node.isPrefixUnaryExpression(node)) {
+		const operator = node.getOperatorToken();
+		return (operator === SyntaxKind.MinusToken || operator === SyntaxKind.PlusToken || operator === SyntaxKind.ExclamationToken || operator === SyntaxKind.TildeToken) && isInertExpression(node.getOperand());
+	}
+	if (Node.isBinaryExpression(node)) {
+		const operator = node.getOperatorToken().getKind();
+		return (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken || operator === SyntaxKind.AmpersandAmpersandToken) && isInertExpression(node.getLeft()) && isInertExpression(node.getRight());
+	}
+	if (Node.isObjectLiteralExpression(node)) return node.getProperties().every((property) => {
+		if (Node.isShorthandPropertyAssignment(property)) return true;
+		if (!Node.isPropertyAssignment(property)) return false;
+		if (Node.isComputedPropertyName(property.getNameNode())) return false;
+		const initializer = property.getInitializer();
+		return initializer !== void 0 && isInertExpression(initializer);
+	});
+	if (Node.isArrayLiteralExpression(node)) return node.getElements().every(isInertExpression);
+	return false;
+};
+/**
+* Source files a box tree reaches, other than the one being folded.
+*
+* When the extractor resolves an imported identifier it boxes the *declaration's*
+* node, which lives in the defining module. Walking the tree and reading each node's
+* source file therefore recovers exactly the files a fold depended on — narrower and
+* more accurate than treating every import of the module as a dependency.
+*/
+const collectSourceFiles = (node, ctx, seen = /* @__PURE__ */ new Set()) => {
+	if (!node || seen.has(node)) return;
+	seen.add(node);
+	ctx.record(node.getNode?.());
+	if (box.isMap(node)) {
+		for (const child of node.value.values()) collectSourceFiles(child, ctx, seen);
+		return;
+	}
+	if (box.isArray(node)) for (const child of node.value) collectSourceFiles(child, ctx, seen);
+};
+const createDependencyScan = (ownFile) => {
+	const results = /* @__PURE__ */ new Set();
+	const paths = /* @__PURE__ */ new Map();
+	return {
+		results,
+		record(node) {
+			if (!node) return;
+			const sourceFile = node.getSourceFile();
+			if (sourceFile === ownFile) return;
+			let path = paths.get(sourceFile);
+			if (path === void 0) {
+				path = sourceFile.getFilePath();
+				paths.set(sourceFile, path);
+			}
+			if (path) results.add(path);
+		}
+	};
+};
+/**
+* The call expression to replace.
+*
+* `extractCallExpressionArguments` boxes the argument list against the call node and
+* pushes `[callNode, argNode]` onto each argument's stack, so the call is reachable
+* from either shape the parser stores: the argument array (multi-arg) or the first
+* argument's map (single-arg).
+*/
+const findCallExpression = (node) => {
+	const own = node.getNode?.();
+	if (own && Node.isCallExpression(own)) return own;
+	const stack = node.getStack?.() ?? [];
+	for (const entry of stack) if (Node.isCallExpression(entry)) return entry;
+	let current = own;
+	for (let depth = 0; current && depth < 3; depth++) {
+		if (Node.isCallExpression(current)) return current;
+		current = current.getParent();
+	}
+};
+/**
+* `css.raw(...)` must keep returning a style object — folding it to a class string
+* breaks every caller composing those styles. The file matcher strips `.raw` when it
+* normalizes function names, so the parser result cannot tell us; the callee text can.
+*/
+const isRawCall = (call) => {
+	if (!Node.isCallExpression(call)) return false;
+	const callee = call.getExpression().getText();
+	return callee === "raw" || callee.endsWith(".raw");
+};
+/** The identifier a callee is rooted at: `css` for `css(…)`, `panda` for `panda.css(…)`. */
+const calleeRootName = (call) => {
+	if (!Node.isCallExpression(call)) return void 0;
+	let current = call.getExpression();
+	while (Node.isPropertyAccessExpression(current)) current = current.getExpression();
+	return Node.isIdentifier(current) ? current.getText() : void 0;
+};
+/**
+* Local names a module binds to an import of bamboo's own generated system.
+*
+* The parser matches by name and asks neither question this does — deliberately, since
+* for CSS extraction the worst case is a few unused rules. A transform cannot be that
+* relaxed, and it needs both halves:
+*
+* - imported at all, or a user's `const css = (s) => JSON.stringify(s)` gets rewritten
+* - imported *from bamboo*, or `import { css } from '@emotion/css'` does, which is the
+*   likelier accident of the two since a migrating project has both in the tree
+*
+* Answered together and once per file, because the scan is the expensive part and both
+* answers fall out of the same pass. Per call site instead of per file, this scan
+* measured +74% on the largest sandbox module.
+*/
+const bambooImportedNames = (sourceFile, ctx) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		const mod = declaration.getModuleSpecifierValue();
+		for (const named of declaration.getNamedImports()) {
+			const name = named.getNameNode().getText();
+			const alias = named.getAliasNode()?.getText() ?? name;
+			if (ctx.imports.match({
+				mod,
+				name,
+				alias
+			})) names.add(alias);
+		}
+		const namespace = declaration.getNamespaceImport();
+		if (namespace) {
+			const alias = namespace.getText();
+			if (ctx.imports.match({
+				mod,
+				name: alias,
+				alias,
+				kind: "namespace"
+			})) names.add(alias);
+		}
+	}
+	return names;
+};
+/**
+* Is the callee the imported binding, or a local one that shadows it?
+*
+* A block-scoped binding of the same name is legal alongside the import, and it is
+* the one the call actually reaches. Walking ancestors is the precise answer; the
+* cost is kept off the common path by only inspecting the two node kinds that can
+* introduce a binding. Ancestors of a call in JSX are overwhelmingly elements and
+* attributes, which match neither and cost nothing.
+*/
+const isShadowed = (call, name) => {
+	for (let node = call.getParent(); node; node = node.getParent()) {
+		if (Node.isSourceFile(node)) return false;
+		if (bindsName(node, name)) return true;
+	}
+	return false;
+};
+/**
+* Does a binding name introduce `name`?
+*
+* A plain identifier check is not enough: destructuring is the likeliest way a
+* same-named local reaches a call, since `({ css }) => css(…)` is what a component
+* taking a `css` prop looks like. Nested and rest elements bind too, so the pattern
+* is walked rather than inspected at the top level.
+*/
+const bindingIntroduces = (nameNode, name) => {
+	if (!nameNode) return false;
+	if (Node.isIdentifier(nameNode)) return nameNode.getText() === name;
+	if (Node.isObjectBindingPattern(nameNode) || Node.isArrayBindingPattern(nameNode)) return nameNode.getElements().some((element) => Node.isBindingElement(element) && bindingIntroduces(element.getNameNode(), name));
+	return false;
+};
+const declarationsBind = (list, name) => Node.isVariableDeclarationList(list) && list.getDeclarations().some((declaration) => bindingIntroduces(declaration.getNameNode(), name));
+const bindsName = (scope, name) => {
+	if (Node.isBlock(scope)) return scope.getStatements().some((statement) => statementBinds(statement, name));
+	if (Node.isFunctionDeclaration(scope) || Node.isArrowFunction(scope) || Node.isFunctionExpression(scope) || Node.isMethodDeclaration(scope)) return scope.getParameters().some((parameter) => bindingIntroduces(parameter.getNameNode(), name));
+	if (Node.isCatchClause(scope)) return bindingIntroduces(scope.getVariableDeclaration()?.getNameNode(), name);
+	if (Node.isForStatement(scope) || Node.isForOfStatement(scope) || Node.isForInStatement(scope)) return declarationsBind(scope.getInitializer(), name);
+	return false;
+};
+const statementBinds = (statement, name) => {
+	if (Node.isVariableStatement(statement)) return statement.getDeclarations().some((declaration) => bindingIntroduces(declaration.getNameNode(), name));
+	if (Node.isFunctionDeclaration(statement) || Node.isClassDeclaration(statement)) return statement.getNameNode()?.getText() === name;
+	return false;
+};
+const hasStyles = (data) => data.length > 0 && data.every((entry) => entry != null && typeof entry === "object");
+/**
+* Pair each source argument with the box the parser stored for it, and require the
+* box to account for all of it. The parser keeps either the whole argument array
+* (multi-arg calls) or just the first argument's map (single-arg calls).
+*/
+const argumentsAccountedFor = (call, boxNode) => {
+	if (!Node.isCallExpression(call)) return false;
+	const args = call.getArguments();
+	if (args.length === 0) return true;
+	if (box.isArray(boxNode) && boxNode.getNode() === call) {
+		if (boxNode.value.length !== args.length) return false;
+		return args.every((arg, index) => accountsForSource(arg, boxNode.value[index]));
+	}
+	if (args.length !== 1) return false;
+	return accountsForSource(args[0], boxNode);
+};
+const foldSource = (options) => {
+	const { ctx, code, parserResult, runtimeCss = createRuntimeCss(ctx), styleCompiler, maxRecipeStates, parseModule, recipeConfigCache, reportSurvivors, sourceFile: ownSourceFile } = options;
+	const runtimeToken = createRuntimeToken(ctx);
+	const runtimeTokenValue = createRuntimeTokenValue(ctx);
+	/**
+	* Does this specifier name a module that exports the css API, exactly?
+	*
+	* `ImportMap.match` is substring-based, which is right for deciding whether a call is
+	* bamboo's and wrong for deciding whether a module can be imported *from*:
+	* `styled-system/css/css` matches while exporting no `cx`. So the comparison is
+	* equality, not containment.
+	*
+	* A tsconfig path alias is resolved first, the same way `ImportMap.match` does. Without
+	* that, `@site/styled-system/css` — the spelling this repo's own website uses — fails
+	* the check and silently loses helper lowering, which is indistinguishable in the
+	* diagnostics from a genuinely dynamic call.
+	*/
+	const cssModules = ctx.imports.matchers.css?.mods ?? [];
+	/**
+	* The generated css module, the only one whose exports are known.
+	*
+	* A configured `importMap.css` points at the user's own wrapper, and a wrapper that
+	* re-exports `css` need not re-export `cx` — adding one there imports a binding that
+	* may not exist. Reusing a `cx` the user already imported from it stays fine, since
+	* that binding demonstrably resolves; only *adding* one is restricted.
+	*/
+	const generatedCssModule = [ctx.imports.outdir, "css"].join("/");
+	const pathMappings = ctx.conf.tsOptions?.pathMappings;
+	/**
+	* The spelling reduced to the module it names.
+	*
+	* The extension and `/index` are stripped because bamboo's own output makes a file
+	* import them: `outExtension: 'js'` under NodeNext resolution is written
+	* `styled-system/css/index.js`, which is neither equal to `styled-system/css` nor a
+	* tail of it. Extraction admitted such a file anyway — `ImportMap.match` is
+	* substring-based — so the call was folded while the *insert* was refused, and the
+	* result was reported as `dynamic`: the same silent downgrade the alias case above
+	* describes, reached through the extension instead.
+	*
+	* This does not weaken the equality the comment above insists on. `styled-system/css/css`
+	* still names neither, because only a trailing `/index` is a module's own directory.
+	*
+	* `.d.ts` is deliberately not stripped. A declaration file exports no runtime binding, so
+	* matching one would authorise inserting an import that resolves to nothing — and a value
+	* import cannot name one anyway, which is what makes leaving it out free.
+	*/
+	const trim = (value) => value.replaceAll("\\", "/").replace(LEADING_RELATIVE, "").replace(TRAILING_SLASH, "").replace(MODULE_EXTENSION, "").replace(TRAILING_INDEX, "");
+	const matchesModule = (mod, entries) => {
+		const candidates = [mod];
+		if (pathMappings) {
+			const resolved = resolveTsPathPattern(pathMappings, mod);
+			if (resolved) candidates.push(resolved);
+		}
+		return candidates.some((candidate) => {
+			const normalized = trim(candidate);
+			return entries.some((entry) => {
+				const target = trim(entry);
+				return normalized === target || normalized.endsWith(`/${target}`);
+			});
+		});
+	};
+	const isBambooCssModule = (mod) => matchesModule(mod, cssModules);
+	const isGeneratedCssModule = (mod) => matchesModule(mod, [generatedCssModule]);
+	/**
+	* Where the compiler's helpers can be imported from, for a file that imports the generated
+	* css module by *subpath* rather than through its barrel.
+	*
+	* `styled-system/css/cva.js` is a real spelling, and it cannot host the helper: that module
+	* exports `cva`, not `cvaMap`. Matching only the barrel meant no host was found and every
+	* runtime recipe selection in the file declined — a failure whose reported reason said
+	* nothing about import spelling, and whose suggested remedies all pointed elsewhere.
+	*
+	* The sibling `cx` module is what actually exports them. The prefix is verified against the
+	* configured output before anything is derived, so an unrelated `foo/css/bar.js` is left
+	* alone, and the caller's extension is preserved rather than guessed at.
+	*/
+	const helperModuleFromSubpath = (mod) => {
+		const normalized = mod.replaceAll("\\", "/");
+		const at = normalized.lastIndexOf("/css/");
+		if (at < 0) return void 0;
+		const prefix = normalized.slice(0, at + 5 - 1);
+		if (!isGeneratedCssModule(prefix)) return void 0;
+		const rest = normalized.slice(at + 5);
+		if (!rest || rest.includes("/")) return void 0;
+		const dot = rest.lastIndexOf(".");
+		const extension = dot > 0 ? rest.slice(dot) : "";
+		if (rest === `cx${extension}`) return void 0;
+		return `${prefix}/cx${extension}`;
+	};
+	/**
+	* The generated css entry as spelled beside an imported config recipe.
+	*
+	* A decision table needs only `cvaMap`, but a module importing a config recipe often has
+	* no css import to extend. Preserve a relative/aliased styled-system spelling by replacing
+	* its `/recipes` suffix; falling back to the configured generated entry covers bare imports.
+	*/
+	const configRecipeCssSpecifier = (call, binding) => {
+		for (const declaration of call.getSourceFile().getImportDeclarations()) {
+			if (declaration.isTypeOnly()) continue;
+			if (!declaration.getNamedImports().some((named) => {
+				if (named.isTypeOnly()) return false;
+				return (named.getAliasNode() ?? named.getNameNode()).getText() === binding;
+			})) continue;
+			const mod = declaration.getModuleSpecifierValue().replaceAll("\\", "/");
+			const at = mod.lastIndexOf("/recipes");
+			if (at >= 0) return `${mod.slice(0, at)}/css`;
+		}
+		return generatedCssModule;
+	};
+	/**
+	* How *this* module would have to spell the css module, learnt from one that already does.
+	*
+	* A file calling an imported recipe need not import the css module at all, so when the
+	* lowering needs a decision-table helper there is no spelling in the file to copy. The declaring module
+	* necessarily has one — `cva` came from it — and that is the spelling reused here.
+	*
+	* A bare or aliased specifier resolves identically from any file, so it is taken as
+	* written. A relative one is re-based: resolved against the module that wrote it, then
+	* expressed from the module being folded.
+	*/
+	const cssModuleSpecifierFrom = (declaring) => {
+		for (const declaration of declaring.getImportDeclarations()) {
+			if (declaration.isTypeOnly()) continue;
+			const mod = declaration.getModuleSpecifierValue();
+			if (isGeneratedCssModule(mod)) return mod;
+		}
+	};
+	/**
+	* That spelling, said from the module being folded.
+	*
+	* A bare or aliased specifier resolves identically from any file, so it is taken as
+	* written. A relative one is re-based: resolved against the module that wrote it, then
+	* expressed from the module being folded. Pure path arithmetic, so it holds a string
+	* rather than a node — a cached node does not survive the next `addSourceFile`, which
+	* ts-morph implements by forgetting the file's whole tree.
+	*/
+	const rebaseSpecifier = (specifier, declaringPath, consumingPath) => {
+		if (!specifier.startsWith(".")) return specifier;
+		const absolute = resolve(dirname(declaringPath), specifier);
+		const rebased = relative(dirname(consumingPath), absolute).replaceAll("\\", "/");
+		if (!rebased) return void 0;
+		return rebased.startsWith(".") ? rebased : `./${rebased}`;
+	};
+	/**
+	* Configs of one foreign module, parsed once however many of its recipes are called.
+	*
+	* Falls back to a per-call map when the caller supplies none, so the fold stays correct
+	* standalone — only repeated, which is what the shared cache exists to avoid.
+	*/
+	const configsByModule = recipeConfigCache ?? /* @__PURE__ */ new Map();
+	/** The specifier each imported recipe's module used for the css module, when it needs one. */
+	const helperModules = /* @__PURE__ */ new Map();
+	/** Declaring modules a fold read, recorded as paths because their nodes do not persist. */
+	const foreignDependencies = /* @__PURE__ */ new Set();
+	/** Resolutions for this module's own call sites, keyed by the name the call site writes. */
+	const importedRecipes = /* @__PURE__ */ new Map();
+	/**
+	* The config of a recipe this module imports.
+	*
+	* The binding is followed with ts-morph's symbol aliasing rather than by re-reading import
+	* declarations, because that is what already understands the shapes these are reached
+	* through: `export { badge } from './styles'`, `export * from './styles'`, and an alias at
+	* either end. Each hop is an alias symbol, so following them to a non-alias lands on the
+	* declaration wherever it lives.
+	*
+	* The selected declarations do not depend on which module the call is in. A recipe lowered
+	* here therefore reaches the same globally shared atoms as a call in its declaring module.
+	*/
+	const resolveImportedRecipe = (call, name, origin) => {
+		if (importedRecipes.has(name)) return importedRecipes.get(name);
+		const resolve = () => {
+			if (!parseModule) return void 0;
+			const consuming = call.getSourceFile();
+			if (origin.filePath === consuming.getFilePath()) return void 0;
+			let foreign = configsByModule.get(origin.filePath);
+			if (!foreign) {
+				const result = parseModule(origin.filePath);
+				if (!result) return void 0;
+				const collected = collectRecipeConfigs(result);
+				const declaring = [...collected.values()].find((entry) => entry.box)?.box?.getNode?.()?.getSourceFile();
+				const configs = /* @__PURE__ */ new Map();
+				for (const [key, entry] of collected) configs.set(key, entry === AMBIGUOUS ? entry : {
+					config: entry.config,
+					box: void 0
+				});
+				foreign = {
+					configs,
+					cssSpecifier: declaring ? cssModuleSpecifierFrom(declaring) : void 0
+				};
+				configsByModule.set(origin.filePath, foreign);
+			}
+			const entry = foreign.configs.get(origin.name);
+			if (!entry || entry === AMBIGUOUS) return void 0;
+			foreignDependencies.add(origin.filePath);
+			helperModules.set(name, foreign.cssSpecifier ? rebaseSpecifier(foreign.cssSpecifier, origin.filePath, consuming.getFilePath()) : void 0);
+			return entry;
+		};
+		const resolved = resolve();
+		importedRecipes.set(name, resolved);
+		return resolved;
+	};
+	const folded = [];
+	const skipped = [];
+	const candidates = [];
+	const seenRanges = /* @__PURE__ */ new Set();
+	const recipeConfigs = collectRecipeConfigs(parserResult);
+	const recipeDefinitions = [];
+	for (const [name, entry] of recipeConfigs) {
+		if (entry === AMBIGUOUS) continue;
+		const definition = entry.box?.getNode?.();
+		if (!definition) continue;
+		const call = 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();
+	const importsFor = (sourceFile) => {
+		let names = importCache.get(sourceFile);
+		if (!names) {
+			names = bambooImportedNames(sourceFile, ctx);
+			importCache.set(sourceFile, names);
+		}
+		return names;
+	};
+	for (const item of parserResult.toArray()) {
+		const type = item.type ?? "";
+		const name = item.name ?? type;
+		if (!item.box) continue;
+		const call = findCallExpression(item.box);
+		if (type === "token" || type === "tokenValue") {
+			if (!call) {
+				skipped.push({
+					name,
+					reason: "no-call-expression",
+					start: 0,
+					end: 0
+				});
+				continue;
+			}
+			const start = call.getStart();
+			const end = call.getEnd();
+			if (code.slice(start, end) !== call.getText()) {
+				skipped.push({
+					name,
+					reason: "no-call-expression",
+					start: 0,
+					end: 0
+				});
+				continue;
+			}
+			const rangeKey = `${start}:${end}`;
+			if (seenRanges.has(rangeKey)) continue;
+			seenRanges.add(rangeKey);
+			const rootName = calleeRootName(call);
+			if (!rootName || !importsFor(call.getSourceFile()).has(rootName) || isShadowed(call, rootName)) {
+				skipped.push({
+					name,
+					reason: "not-imported",
+					start,
+					end
+				});
+				continue;
+			}
+			const callee = Node.isCallExpression(call) ? call.getExpression() : void 0;
+			const propertyName = Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getText() : void 0;
+			const wantsValue = type === "tokenValue";
+			if (wantsValue !== (propertyName === "value")) {
+				skipped.push({
+					name,
+					reason: "unsupported-kind",
+					start,
+					end
+				});
+				continue;
+			}
+			if (!wantsValue && propertyName !== void 0 && !ctx.imports.matchers.tokens.match(propertyName)) {
+				skipped.push({
+					name,
+					reason: "unsupported-kind",
+					start,
+					end
+				});
+				continue;
+			}
+			if (!isStaticBox(item.box) || item.data.length !== 1) {
+				skipped.push({
+					name,
+					reason: "dynamic",
+					start,
+					end
+				});
+				continue;
+			}
+			const path = item.data[0];
+			if (typeof path !== "string") {
+				skipped.push({
+					name,
+					reason: "dynamic",
+					start,
+					end
+				});
+				continue;
+			}
+			if (!(Node.isCallExpression(call) ? call.getArguments().slice(1) : []).every(isInertArgument)) {
+				skipped.push({
+					name,
+					reason: "dynamic",
+					start,
+					end
+				});
+				continue;
+			}
+			const value = wantsValue ? runtimeTokenValue(path) : runtimeToken(path);
+			if (!value) {
+				skipped.push({
+					name,
+					reason: "unresolved-token",
+					start,
+					end
+				});
+				continue;
+			}
+			candidates.push({
+				item,
+				call,
+				node: call,
+				start,
+				end,
+				value
+			});
+			continue;
+		}
+		if (!FOLDABLE_TYPES.has(type)) {
+			if (call && (type === RECIPE_CALL_TYPE || type === "recipe") && !isShadowed(call, name)) {
+				const start = call.getStart();
+				const end = call.getEnd();
+				const rangeKey = `${start}:${end}`;
+				if (!reportedRanges.has(rangeKey)) {
+					reportedRanges.add(rangeKey);
+					if (code.slice(start, end) !== call.getText()) {
+						skipped.push({
+							name,
+							reason: "no-call-expression",
+							start: 0,
+							end: 0
+						});
+						continue;
+					}
+					if (isRawCall(call)) {
+						skipped.push({
+							name,
+							reason: "raw-call",
+							start,
+							end
+						});
+						continue;
+					}
+					if (!recipeConfigs.has(name)) {
+						if (type === "recipe") {
+							const config = ctx.recipes.getConfig(name);
+							if (config) {
+								recipeConfigs.set(name, {
+									config,
+									box: void 0
+								});
+								helperModules.set(name, configRecipeCssSpecifier(call, name));
+							}
+						} else if (item.origin) {
+							const imported = resolveImportedRecipe(call, name, item.origin);
+							if (imported) recipeConfigs.set(name, imported);
+						}
+					}
+					const resolvedSelection = item.data?.length === 1 ? item.data[0] : void 0;
+					const entry = recipeConfigs.get(name);
+					let inlineSlot;
+					let inlineEnd = end;
+					if (Array.isArray(entry?.config.slots)) {
+						const parent = call.getParent();
+						if (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), helperModuleFromSubpath);
+						if (helper) {
+							candidates.push({
+								item,
+								call,
+								node: call,
+								start,
+								end: inlineEnd,
+								className: "",
+								classNames: [],
+								styleMap: lowered.map,
+								mapHelperName: helper.name,
+								insert: helper.insert,
+								configBox: entry?.box,
+								outputKind: lowered.map.outputKind === "slots" ? "slots" : void 0
+							});
+							continue;
+						}
+						skipped.push({
+							name,
+							reason: "recipe-call",
+							start,
+							end
+						});
+						continue;
+					}
+					if (lowered.kind === "slots") {
+						const helper = lowered.helper ? ensureRecipeHelperImport(lowered.helper, call, isBambooCssModule, isGeneratedCssModule, isShadowed, helperModules.get(name), helperModuleFromSubpath) : void 0;
+						if (!lowered.helper || helper) {
+							const replacement = lowered.helper && helper && helper.name !== lowered.helper ? lowered.expression.replaceAll(`${lowered.helper}(`, `${helper.name}(`) : lowered.expression;
+							candidates.push({
+								item,
+								call,
+								node: call,
+								start,
+								end: inlineEnd,
+								replacement,
+								className: "",
+								classNames: lowered.classNames,
+								insert: helper?.insert,
+								configBox: entry?.box,
+								outputKind: "slots"
+							});
+							continue;
+						}
+						skipped.push({
+							name,
+							reason: "recipe-call",
+							start,
+							end
+						});
+						continue;
+					}
+					if (lowered.kind === "class") {
+						candidates.push({
+							item,
+							call,
+							node: call,
+							start,
+							end: inlineEnd,
+							replacement: JSON.stringify(lowered.className),
+							className: lowered.className,
+							classNames: lowered.className.split(" ").filter(Boolean),
+							styleSet: lowered.styles,
+							configBox: entry?.box
+						});
+						continue;
+					}
+					skipped.push({
+						name,
+						reason: "recipe-call",
+						start,
+						end
+					});
+				}
+			}
+			continue;
+		}
+		if (!call) {
+			skipped.push({
+				name,
+				reason: "no-call-expression",
+				start: 0,
+				end: 0
+			});
+			continue;
+		}
+		const start = call.getStart();
+		const end = call.getEnd();
+		const memberParent = call.getParent();
+		const accessed = type === "recipe" && Node.isPropertyAccessExpression(memberParent) && memberParent.getExpression() === call ? memberParent : void 0;
+		const accessedName = accessed?.getNameNode().getText();
+		const declaredSlots = accessed ? ctx.recipes.getConfig(name)?.slots ?? [] : [];
+		const memberAccess = accessedName && declaredSlots.includes(accessedName) ? accessed : void 0;
+		const slot = memberAccess ? accessedName : void 0;
+		const foldEnd = memberAccess ? memberAccess.getEnd() : end;
+		if (code.slice(start, end) !== call.getText()) {
+			skipped.push({
+				name,
+				reason: "no-call-expression",
+				start: 0,
+				end: 0
+			});
+			continue;
+		}
+		const rangeKey = `${start}:${foldEnd}`;
+		if (seenRanges.has(rangeKey)) continue;
+		seenRanges.add(rangeKey);
+		if (isRawCall(call)) {
+			skipped.push({
+				name,
+				reason: "raw-call",
+				start,
+				end
+			});
+			continue;
+		}
+		const rootName = calleeRootName(call);
+		if (!rootName || !importsFor(call.getSourceFile()).has(rootName) || isShadowed(call, rootName)) {
+			skipped.push({
+				name,
+				reason: "not-imported",
+				start,
+				end
+			});
+			continue;
+		}
+		if (!(Node.isCallExpression(call) && call.getArguments().length === 0 && item.data.length === 1) && !isStaticBox(item.box) || !hasStyles(item.data) || !argumentsAccountedFor(call, item.box)) {
+			skipped.push({
+				name,
+				reason: "dynamic",
+				start,
+				end
+			});
+			continue;
+		}
+		candidates.push({
+			item,
+			call,
+			node: call,
+			start,
+			end: foldEnd,
+			slot
+		});
+	}
+	/**
+	* Resolve every fully static candidate to symbolic declarations before allocating a class.
+	*
+	* The normal fold can wait until the rewrite loop to compute a class string. Semantic
+	* composition cannot: an enclosing `cx()` needs the declarations of its arguments so it can
+	* discard overridden values before any string exists.
+	*/
+	{
+		for (const candidate of candidates) {
+			if (candidate.styleSet || candidate.value !== void 0 || candidate.replacement) continue;
+			const { item } = candidate;
+			if (item.type === "css") {
+				candidate.styleSet = styleCompiler.compose(...item.data);
+				continue;
+			}
+			if (item.type === "pattern") {
+				candidate.styleSet = styleCompiler.compose(...item.data.map((entry) => ctx.patterns.transform(item.name ?? "", entry)));
+				continue;
+			}
+			if (item.type === "viewTransition") {
+				const semantic = viewTransitionClassName(item.data[0], ctx.utility.prefix);
+				candidate.className = styleCompiler.allocateClassString(semantic);
+				candidate.classNames = [candidate.className];
+				candidate.replacement = JSON.stringify(candidate.className);
+				continue;
+			}
+		}
+		const sourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile();
+		if (sourceFile) {
+			const cxBindings = /* @__PURE__ */ new Set();
+			for (const declaration of sourceFile.getImportDeclarations()) {
+				if (declaration.isTypeOnly() || !isBambooCssModule(declaration.getModuleSpecifierValue())) continue;
+				for (const named of declaration.getNamedImports()) {
+					if (named.isTypeOnly() || named.getNameNode().getText() !== "cx") continue;
+					cxBindings.add((named.getAliasNode() ?? named.getNameNode()).getText());
+				}
+			}
+			const byRange = new Map(candidates.map((candidate) => [`${candidate.start}:${candidate.end}`, candidate]));
+			for (const call of cxBindings.size ? sourceFile.getDescendantsOfKind(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 && recipeDefinitions.length === 0) {
+		if (reportSurvivors) reportRuntimeBindings();
+		return {
+			code,
+			map: null,
+			folded,
+			skipped,
+			dependencies: []
+		};
+	}
+	const rewriteSourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile() ?? recipeDefinitions[0]?.call.getSourceFile();
+	if (!rewriteSourceFile) return {
+		code,
+		map: null,
+		folded,
+		skipped,
+		dependencies: []
+	};
+	const dependencyScan = createDependencyScan(rewriteSourceFile);
+	candidates.sort((a, b) => a.start - b.start || b.end - a.end);
+	const magic = new MagicString(code);
+	const insertedNames = /* @__PURE__ */ new Set();
+	const applyInsert = (insert) => {
+		if (!insert) return;
+		const missing = insert.names.filter((name) => !insertedNames.has(name));
+		if (!missing.length) return;
+		magic.appendLeft(insert.pos, insert.module ? `\nimport { ${missing.join(", ")} } from '${insert.module}'` : missing.map((name) => `, ${name}`).join(""));
+		for (const name of missing) insertedNames.add(name);
+	};
+	const collides = (edits) => edits.some(([start, end]) => applied.some(([from, to]) => start < to && from < end));
+	for (const candidate of candidates) {
+		const { item, start, end } = candidate;
+		const name = candidate.displayName ?? item.name ?? item.type ?? "";
+		const ranges = [[start, end]];
+		if (collides(ranges)) {
+			skipped.push({
+				name,
+				reason: "overlapping",
+				start,
+				end
+			});
+			continue;
+		}
+		if (candidate.value !== void 0) {
+			magic.overwrite(start, end, JSON.stringify(candidate.value));
+			applied.push(...ranges);
+			folded.push({
+				name,
+				kind: "value",
+				className: "",
+				classNames: [],
+				value: candidate.value,
+				start,
+				end
+			});
+			collectSourceFiles(item.box, dependencyScan);
+			continue;
+		}
+		if (candidate.replacement) {
+			magic.overwrite(start, end, candidate.replacement);
+			applyInsert(candidate.insert);
+			applied.push(...ranges);
+			folded.push({
+				name,
+				kind: candidate.outputKind ?? "class",
+				className: candidate.className,
+				classNames: (candidate.classNames ?? [candidate.className]).filter(Boolean),
+				start,
+				end
+			});
+			collectSourceFiles(item.box, dependencyScan);
+			if (candidate.configBox) collectSourceFiles(candidate.configBox, dependencyScan);
+			for (const box of candidate.sourceBoxes ?? []) collectSourceFiles(box, dependencyScan);
+			continue;
+		}
+		let className;
+		try {
+			if (item.type === "pattern") className = runtimeCss(...item.data.map((entry) => ctx.patterns.transform(name, entry)));
+			else className = runtimeCss(...item.data);
+		} catch {
+			skipped.push({
+				name,
+				reason: "dynamic",
+				start,
+				end
+			});
+			continue;
+		}
+		magic.overwrite(start, end, JSON.stringify(className));
+		applied.push(...ranges);
+		folded.push({
+			name,
+			kind: "class",
+			className,
+			classNames: className ? [className] : [],
+			start,
+			end
+		});
+		collectSourceFiles(item.box, dependencyScan);
+	}
+	const recipeSourceFile = candidates[0]?.node.getSourceFile();
+	if (recipeSourceFile && mayNameSplitVariantProps(recipeSourceFile.getFullText())) for (const access of recipeSourceFile.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)) {
+		if (access.getName() !== "splitVariantProps") continue;
+		const target = access.getExpression();
+		if (!Node.isIdentifier(target)) continue;
+		if (isShadowed(access, target.getText())) continue;
+		const local = recipeConfigs?.get(target.getText());
+		const importedConfig = !local && importsFor(recipeSourceFile).has(target.getText()) ? ctx.recipes.getConfig(target.getText()) : void 0;
+		const entry = local && local !== AMBIGUOUS ? local : importedConfig ? {
+			config: importedConfig,
+			box: void 0
+		} : void 0;
+		if (!entry) continue;
+		const call = access.getParent();
+		if (!Node.isCallExpression(call) || call.getExpression() !== access) continue;
+		const args = call.getArguments();
+		if (args.length !== 1) continue;
+		const start = call.getStart();
+		const end = call.getEnd();
+		if (code.slice(start, end) !== call.getText()) continue;
+		if (collides([[start, end]])) continue;
+		const helper = ensureRecipeHelperImport(SPLIT_PROPS_HELPER, call, isBambooCssModule, isGeneratedCssModule, isShadowed, helperModules.get(target.getText()), helperModuleFromSubpath);
+		if (!helper) continue;
+		const keys = Object.keys(entry.config.variants ?? {});
+		magic.overwrite(start, end, `${helper.name}(${args[0].getText()}, ${JSON.stringify(keys)})`);
+		applyInsert(helper.insert);
+		applied.push([start, end]);
+	}
+	for (const { name, call } of recipeDefinitions) {
+		const start = call.getStart();
+		const end = call.getEnd();
+		if (collides([[start, end]])) continue;
+		magic.overwrite(start, end, "undefined");
+		applied.push([start, end]);
+		folded.push({
+			name,
+			kind: "definition",
+			className: "",
+			classNames: [],
+			start,
+			end
+		});
+	}
+	/**
+	* Bindings from a bamboo module still referenced once every rewrite is applied.
+	*
+	* Deliberately not driven by `parserResult`: that is the recogniser, and the point here is
+	* to catch what it did not see. A namespace import called as `s.cva(...)`, a default
+	* import, a specifier that resolved to nothing — each leaves a live reference and no ledger
+	* entry at all, which used to let a build silently ship the engine.
+	*
+	* The helpers the compiler writes are excluded because they pull no style engine. `cx` is
+	* also allowed to remain when it joins an arbitrary external class; only fully analyzable
+	* arguments receive Bamboo's semantic composition guarantee.
+	*/
+	/** The specifier this module imported `binding` through, if it did. */
+	function importSpecifierFor(sourceFile, binding) {
+		for (const declaration of sourceFile.getImportDeclarations()) {
+			if (declaration.isTypeOnly()) continue;
+			for (const named of declaration.getNamedImports()) {
+				if (named.isTypeOnly()) continue;
+				if ((named.getAliasNode() ?? named.getNameNode()).getText() === binding) return named.getAliasNode() ?? named.getNameNode();
+			}
+		}
+	}
+	function reportRuntimeBindings() {
+		const sourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile() ?? recipeDefinitions[0]?.call.getSourceFile();
+		if (!sourceFile) return;
+		const importedRecipeBindings = new Set(parserResult.importedRecipes?.keys() ?? []);
+		/**
+		* Every identifier in the module, grouped by the name it spells — built at most once per
+		* pass, and only when something below has a name to look up.
+		*
+		* One index answers for every binding, rather than a walk per binding. Built here rather
+		* than cached across passes: it holds nodes, and a node does not outlive its source file
+		* being replaced.
+		*
+		* Deferred because most modules in an app neither declare nor import a recipe, and the
+		* walk is not cheap — `getDescendantsOfKind` wraps every identifier in the file in a
+		* ts-morph node to answer a question those modules never ask. It was 11% of a 6,307-file
+		* build, most of it spent producing an index nothing read.
+		*/
+		let identifiers;
+		const identifiersByName = () => identifiers ??= identifierIndex(sourceFile);
+		for (const binding of new Set([...recipeConfigs.keys(), ...importedRecipeBindings])) {
+			const entry = recipeConfigs.get(binding);
+			if (entry === AMBIGUOUS) continue;
+			if (!entry && !importedRecipeBindings.has(binding)) continue;
+			const definition = entry?.box?.getNode?.();
+			const nameNode = definition?.getSourceFile() === sourceFile ? definition?.getFirstAncestorByKind(SyntaxKind.VariableDeclaration)?.getNameNode() : importSpecifierFor(sourceFile, binding);
+			if (!nameNode || !Node.isIdentifier(nameNode)) continue;
+			const references = localReferencesTo(identifiersByName(), binding, nameNode);
+			if (skipped.filter((item) => SURVIVES_TO_RUNTIME.has(item.reason) && item.end > item.start).some((item) => references.some((ref) => ref.getStart() >= item.start && ref.getStart() < item.end))) continue;
+			const survivor = references.find((ref) => !applied.some(([from, to]) => ref.getStart() >= from && ref.getStart() < to));
+			if (!survivor) continue;
+			skipped.push({
+				name: binding,
+				reason: "runtime-binding",
+				start: survivor.getStart(),
+				end: survivor.getEnd()
+			});
+		}
+		const bambooModules = [
+			...cssModules,
+			...ctx.imports.matchers.recipe?.mods ?? [],
+			...ctx.imports.matchers.pattern?.mods ?? [],
+			...ctx.imports.matchers.tokens?.mods ?? []
+		];
+		const runtimeCalls = [];
+		const importEquals = [];
+		sourceFile.forEachDescendant((node) => {
+			if (Node.isCallExpression(node)) runtimeCalls.push(node);
+			else if (Node.isImportEqualsDeclaration(node)) importEquals.push(node);
+		});
+		for (const call of runtimeCalls) {
+			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 importEquals) {
+			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()) {
+			if (declaration.isTypeOnly()) continue;
+			if (!matchesModule(declaration.getModuleSpecifierValue(), bambooModules)) continue;
+			for (const named of declaration.getNamedImports()) {
+				if (named.isTypeOnly()) continue;
+				const imported = named.getNameNode().getText();
+				if (PERMITTED_BINDINGS.has(imported)) continue;
+				watched.set((named.getAliasNode() ?? named.getNameNode()).getText(), imported);
+			}
+			const namespace = declaration.getNamespaceImport();
+			if (namespace) watched.set(namespace.getText(), `${namespace.getText()}.*`);
+			const defaultImport = declaration.getDefaultImport();
+			if (defaultImport) watched.set(defaultImport.getText(), defaultImport.getText());
+		}
+		for (const declaration of sourceFile.getExportDeclarations()) {
+			if (declaration.isTypeOnly()) continue;
+			if (!matchesModule(declaration.getModuleSpecifierValue() ?? "", bambooModules)) continue;
+			if (declaration.isNamespaceExport()) {
+				skipped.push({
+					name: declaration.getNamespaceExport()?.getName() ?? "*",
+					reason: "runtime-binding",
+					start: declaration.getStart(),
+					end: declaration.getEnd()
+				});
+				continue;
+			}
+			for (const named of declaration.getNamedExports()) {
+				if (named.isTypeOnly()) continue;
+				const imported = named.getNameNode().getText();
+				if (PERMITTED_BINDINGS.has(imported)) continue;
+				skipped.push({
+					name: imported,
+					reason: "runtime-binding",
+					start: named.getStart(),
+					end: named.getEnd()
+				});
+			}
+		}
+		for (const declaration of sourceFile.getExportDeclarations()) {
+			if (declaration.isTypeOnly() || declaration.getModuleSpecifier()) continue;
+			for (const named of declaration.getNamedExports()) {
+				if (named.isTypeOnly()) continue;
+				const imported = watched.get(named.getNameNode().getText());
+				if (imported === void 0) continue;
+				skipped.push({
+					name: imported,
+					reason: "runtime-binding",
+					start: named.getStart(),
+					end: named.getEnd()
+				});
+			}
+		}
+		if (watched.size === 0) return;
+		const declined = skipped.filter((entry) => SURVIVES_TO_RUNTIME.has(entry.reason) && entry.end > entry.start).map((entry) => [entry.start, entry.end]);
+		const survivors = [];
+		for (const [local, imported] of watched) for (const identifier of identifiersByName().get(local)) {
+			const start = identifier.getStart();
+			if (identifier.getFirstAncestorByKind(SyntaxKind.ImportDeclaration)) continue;
+			if (applied.some(([from, to]) => start >= from && start < to)) continue;
+			if (declined.some(([from, to]) => start >= from && start < to)) continue;
+			if (!isValueReference(identifier)) continue;
+			if (isShadowed(identifier, local)) continue;
+			survivors.push({
+				name: imported,
+				reason: "runtime-binding",
+				start,
+				end: identifier.getEnd()
+			});
+			break;
+		}
+		survivors.sort((a, b) => a.start - b.start);
+		skipped.push(...survivors);
+	}
+	if (reportSurvivors) reportRuntimeBindings();
+	if (folded.length === 0) return {
+		code,
+		map: null,
+		folded,
+		skipped,
+		dependencies: []
+	};
+	return {
+		code: magic.toString(),
+		map: magic.generateMap({
+			source: options.filePath,
+			hires: true,
+			includeContent: true
+		}),
+		folded,
+		skipped,
+		dependencies: [...dependencyScan.results, ...foreignDependencies]
+	};
+};
+//#endregion
+//#region src/style-set.ts
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+/** A compound selector matches only through variant classes the recipe actually emits. */
+const matchesCompound = (compound, selection, variants) => {
+	for (const [key, expected] of Object.entries(compound)) {
+		if (key === "css") continue;
+		const declared = variants?.[key];
+		const selected = selection[key];
+		if (selected == null || !declared || !Object.hasOwn(declared, String(selected))) return false;
+		if (!(Array.isArray(expected) ? expected : [expected]).some((value) => value != null && String(selected) === String(value))) return false;
+	}
+	return true;
+};
+/**
+* Resolve the style fragments one recipe call contributes, in emitted-rule precedence.
+*
+* This intentionally rejects conditional variant *selections*. A scalar selects a style
+* object; an object such as `{ base: 'sm', md: 'lg' }` selects several objects under
+* conditions and needs a separate lowering. Returning `undefined` rejects that call instead
+* of silently compiling only one branch.
+*/
+const createStaticStyleSetCompiler = (ctx, runtimeCss, allocateClassString = (className) => className) => {
+	const { mergeCssUncached } = 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
+export { createRuntimeCss, createStaticStyleSetCompiler, foldSource };