@bamboocss/vite 1.13.0

package/dist/index.cjs

@@ -0,0 +1,1935 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _bamboocss_config_ts_path = require("@bamboocss/config/ts-path");
+let _bamboocss_extractor = require("@bamboocss/extractor");
+let magic_string = require("magic-string");
+magic_string = __toESM(magic_string);
+let ts_morph = require("ts-morph");
+let _bamboocss_shared = require("@bamboocss/shared");
+let node_path = require("node:path");
+let _bamboocss_logger = require("@bamboocss/logger");
+let _bamboocss_node = require("@bamboocss/node");
+//#region src/fold-partial.ts
+/**
+* Statically resolvable means: every box in the tree carries a known value.
+*
+* `unresolvable` is the extractor saying it could not evaluate a node.
+* `conditional` is a ternary — two possible values, so there is no single string to
+* fold to. `box.fallback` produces an object with no `type` at all, which is likewise
+* not something we can trust.
+*/
+const isStaticBox = (node, seen = /* @__PURE__ */ new Set()) => {
+	if (!node) return false;
+	if (seen.has(node)) return true;
+	seen.add(node);
+	if (_bamboocss_extractor.box.isUnresolvable(node) || _bamboocss_extractor.box.isConditional(node)) return false;
+	if (!("type" in node) || node.type == null) return false;
+	if (_bamboocss_extractor.box.isLiteral(node) && node.value === void 0) return false;
+	if (_bamboocss_extractor.box.isMap(node)) {
+		for (const child of node.value.values()) if (!isStaticBox(child, seen)) return false;
+		return true;
+	}
+	if (_bamboocss_extractor.box.isArray(node)) {
+		for (const child of node.value) if (!isStaticBox(child, seen)) return false;
+		return true;
+	}
+	return true;
+};
+/**
+* Strip the wrappers the extractor strips before it builds a box, so the source node
+* compared against a box is the same node the box was built from.
+*
+* A local copy of the extractor's `unwrapExpression`, which is not part of its public
+* surface. Recognising fewer wrappers than it does is not a cosmetic difference: an
+* unrecognised one leaves an object literal wrapped, and the object checks below skip it.
+*/
+const unwrapExpression = (node) => ts_morph.Node.isAsExpression(node) || ts_morph.Node.isParenthesizedExpression(node) || ts_morph.Node.isNonNullExpression(node) || ts_morph.Node.isTypeAssertion(node) || ts_morph.Node.isSatisfiesExpression(node) ? unwrapExpression(node.getExpression()) : node;
+/**
+* Mirrors the parser's evaluator environment, so re-boxing an operand here gets the same
+* answer the extraction did. Left to its default, ts-evaluator presets to `NODE` and
+* would resolve expressions the parser cannot see — making this check *more* permissive
+* than the extraction it is auditing, which is the one thing it must never be.
+*/
+const REBOXED = { getEvaluateOptions: () => ({ environment: { preset: "ECMA" } }) };
+const rebox = (node) => (0, _bamboocss_extractor.maybeBoxNode)(unwrapExpression(node), [], REBOXED);
+/**
+* Did this operand resolve to a value the program will actually produce?
+*
+* Producing a box is not enough when the operand is itself a choice: `a || b || c` parses
+* as `(a || b) || c`, so the outer operator is handed whatever the inner one answered —
+* including an arm the extractor invented. Asking only "is there a box" reads that
+* invention as an ordinary literal.
+*/
+const resolvesExactly = (node) => {
+	const inner = unwrapExpression(node);
+	if (!rebox(inner)) return false;
+	return ts_morph.Node.isConditionalExpression(inner) || isCollapsedBinary(inner) ? decidedAtBuildTime(inner) : true;
+};
+/**
+* Is this operand's value written here, rather than named?
+*
+* A box records what the extractor resolved a name *through* — a `let`'s initializer, a
+* parameter's default — none of which is what the operand holds when the call runs.
+* `let m = '1'; m = undefined` still boxes as `'1'`, and `({ c = 'red.300' })` still boxes
+* as `'red.300'` for a caller that passed something else. Only a value written at the call
+* site is what it appears to be, so only that can be judged truthy or nullish here.
+*/
+const isWrittenHere = (node) => {
+	const inner = unwrapExpression(node);
+	return ts_morph.Node.isStringLiteral(inner) || ts_morph.Node.isNumericLiteral(inner) || ts_morph.Node.isNoSubstitutionTemplateLiteral(inner) || ts_morph.Node.isObjectLiteralExpression(inner) || ts_morph.Node.isArrayLiteralExpression(inner) || ts_morph.Node.isTrueLiteral(inner) || ts_morph.Node.isFalseLiteral(inner) || inner.getKind() === ts_morph.SyntaxKind.NullKeyword || ts_morph.Node.isPrefixUnaryExpression(inner) && ts_morph.Node.isNumericLiteral(inner.getOperand());
+};
+/** An inline value's truthiness, which its box carries directly. */
+const isTruthy = (boxNode) => _bamboocss_extractor.box.isLiteral(boxNode) ? Boolean(boxNode.value) : _bamboocss_extractor.box.isMap(boxNode) || _bamboocss_extractor.box.isArray(boxNode) || _bamboocss_extractor.box.isObject(boxNode);
+/**
+* Did the extractor *decide* this choice, or guess at it?
+*
+* `a ? b : c`, `a || b` and `a && b` are asked "what styles could this produce", and when
+* one arm does not evaluate the extractor answers with the other rather than refusing
+* (`maybe-box-node.ts`, `whenTrueValue && !whenFalseValue`). That is right for generating
+* CSS — emit rules for whatever might be used — and wrong for rewriting source, where the
+* arm it kept becomes the only one that runs.
+*
+* For a ternary the tell is the arms: it guessed exactly when one produced a box and the
+* other did not. For a short-circuit the answer is always the left operand, so what has to
+* be established is that the left is the side that wins.
+*/
+const decidedAtBuildTime = (node) => {
+	if (ts_morph.Node.isConditionalExpression(node)) return resolvesExactly(node.getWhenTrue()) && resolvesExactly(node.getWhenFalse());
+	const operator = node.getOperatorToken().getKind();
+	if (!SHORT_CIRCUIT.includes(operator)) return false;
+	if (!isWrittenHere(node.getLeft())) return false;
+	const left = rebox(node.getLeft());
+	if (!left) return false;
+	if (operator === ts_morph.SyntaxKind.BarBarToken) return isTruthy(left);
+	if (operator === ts_morph.SyntaxKind.QuestionQuestionToken) return !_bamboocss_extractor.box.isLiteral(left) || left.value != null;
+	return isTruthy(left) ? resolvesExactly(node.getRight()) : true;
+};
+const SHORT_CIRCUIT = [
+	ts_morph.SyntaxKind.AmpersandAmpersandToken,
+	ts_morph.SyntaxKind.BarBarToken,
+	ts_morph.SyntaxKind.QuestionQuestionToken
+];
+/**
+* Every binary form the extractor collapses to one operand — the short-circuits plus the
+* comparisons, which `isLogicalSyntax` sends down the same path even though their value is
+* a boolean rather than either side.
+*
+* Hoisted rather than built per call: `accountsForSource` asks this for every property of
+* every candidate, and rebuilding a thirteen-element list each time is not free.
+*/
+const COLLAPSED_BINARY = new Set([
+	...SHORT_CIRCUIT,
+	ts_morph.SyntaxKind.EqualsEqualsToken,
+	ts_morph.SyntaxKind.EqualsEqualsEqualsToken,
+	ts_morph.SyntaxKind.ExclamationEqualsToken,
+	ts_morph.SyntaxKind.ExclamationEqualsEqualsToken,
+	ts_morph.SyntaxKind.GreaterThanToken,
+	ts_morph.SyntaxKind.GreaterThanEqualsToken,
+	ts_morph.SyntaxKind.LessThanToken,
+	ts_morph.SyntaxKind.LessThanEqualsToken,
+	ts_morph.SyntaxKind.InKeyword,
+	ts_morph.SyntaxKind.InstanceOfKeyword
+]);
+const isCollapsedBinary = (node) => ts_morph.Node.isBinaryExpression(node) && COLLAPSED_BINARY.has(node.getOperatorToken().getKind());
+/**
+* Does the extracted box account for every property the source declares?
+*
+* `isStaticBox` is not sufficient on its own. The extractor *omits* what it cannot
+* evaluate rather than marking it unresolvable, so `css({ color: 'red.300', ...rest })`
+* yields a perfectly static-looking map holding only `color`. Folding that produces
+* `"c_red.300"` and silently drops everything `rest` contributed.
+*
+* So the source is the authority on what the call contains, and anything the box does
+* not account for disqualifies the fold:
+*
+* - a declared property missing from the map (its value did not evaluate)
+* - a computed key, which we cannot match against the map by name
+* - a spread, unless it is an inline object literal
+*
+* Spreads are the conservative case. `{ ...base }` where `base` is a static local
+* object *is* resolved by the extractor, but a resolved spread and an unresolved one
+* are indistinguishable once flattened into the map — both just contribute keys, or
+* fail to. Rather than guess, phase 1 declines them. Partial folding is where this
+* gets revisited.
+*/
+/**
+* What a property's value is written as. A shorthand names it, so the name *is* the
+* expression — reading an initializer that is not there reports the property as having no
+* source, and everything hidden behind the name goes unchecked.
+*/
+const valueOf = (property) => ts_morph.Node.isPropertyAssignment(property) ? property.getInitializer() : ts_morph.Node.isShorthandPropertyAssignment(property) ? property.getNameNode() : void 0;
+const accountsForSource = (node, boxNode) => {
+	if (!node) return true;
+	const unwrapped = unwrapExpression(node);
+	if ((ts_morph.Node.isConditionalExpression(unwrapped) || isCollapsedBinary(unwrapped)) && !_bamboocss_extractor.box.isConditional(boxNode) && !decidedAtBuildTime(unwrapped)) return false;
+	if (ts_morph.Node.isArrayLiteralExpression(unwrapped)) {
+		if (!_bamboocss_extractor.box.isArray(boxNode)) return false;
+		const elements = unwrapped.getElements();
+		if (elements.length !== boxNode.value.length) return false;
+		return elements.every((element, index) => accountsForSource(element, boxNode.value[index]));
+	}
+	if (!ts_morph.Node.isObjectLiteralExpression(unwrapped)) {
+		const origin = _bamboocss_extractor.box.isMap(boxNode) ? boxNode.getNode() : void 0;
+		return !origin || origin === unwrapped || !ts_morph.Node.isObjectLiteralExpression(origin) ? true : accountsForSource(origin, boxNode);
+	}
+	if (!_bamboocss_extractor.box.isMap(boxNode)) return false;
+	for (const property of unwrapped.getProperties()) {
+		if (ts_morph.Node.isSpreadAssignment(property)) {
+			const expression = property.getExpression();
+			if (!ts_morph.Node.isObjectLiteralExpression(expression)) return false;
+			continue;
+		}
+		if (ts_morph.Node.isMethodDeclaration(property) || ts_morph.Node.isGetAccessorDeclaration(property) || ts_morph.Node.isSetAccessorDeclaration(property)) return false;
+		if (!ts_morph.Node.isPropertyAssignment(property) && !ts_morph.Node.isShorthandPropertyAssignment(property)) return false;
+		const nameNode = property.getNameNode();
+		if (ts_morph.Node.isComputedPropertyName(nameNode)) return false;
+		const key = ts_morph.Node.isStringLiteral(nameNode) || ts_morph.Node.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
+		const value = valueOf(property);
+		if (value && ts_morph.Node.isIdentifier(value) && value.getText() === "undefined") continue;
+		if (!boxNode.value.has(key)) return false;
+		if (!accountsForSource(value, boxNode.value.get(key))) return false;
+	}
+	return true;
+};
+/**
+* A property whose value is a ternary is not dynamic, it is *finite*: both branches are
+* known, so each can be resolved now and the choice left to a ternary between two
+* literals. That removes the `css()` call without needing to know which branch runs.
+*
+* Independent conditionals stay linear rather than multiplying, because each property
+* contributes its own ternary. Two conditionals give two ternaries, not four
+* combinations — which is only sound because `collides()` already rules out two
+* properties resolving to the same class, so no combination can interact with another.
+*/
+const finiteBranches = (key, value, boxNode, deps) => {
+	if (!_bamboocss_extractor.box.isConditional(boxNode)) return void 0;
+	const node = boxNode.getNode();
+	if (!ts_morph.Node.isConditionalExpression(node)) return void 0;
+	if (!value || unwrapExpression(value) !== node) return void 0;
+	const [whenTrue, whenFalse] = [[node.getWhenTrue(), boxNode.whenTrue], [node.getWhenFalse(), boxNode.whenFalse]].map(([source, branch]) => {
+		if (!deps.isStatic(branch)) return void 0;
+		if (!deps.isAccounted(source, branch)) return void 0;
+		const value = (0, _bamboocss_extractor.unbox)(branch).raw;
+		try {
+			return deps.runtimeCss({ [key]: value });
+		} catch {
+			return;
+		}
+	});
+	if (whenTrue === void 0 || whenFalse === void 0) return void 0;
+	if (!whenTrue && !whenFalse) return void 0;
+	return `${node.getCondition().getText()} ? ${JSON.stringify(whenTrue)} : ${JSON.stringify(whenFalse)}`;
+};
+/** The binding the leaf fold calls, exported by the generated css module. */
+const LEAF_HELPER = "cssLeaf";
+/**
+* Memo keyed on a file, thrown away when its text is replaced.
+*
+* A plain `WeakMap<SourceFile, …>` is wrong here: ts-morph reuses the wrapper when a path
+* 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;
+};
+/**
+* The modules this file imports from, as specifiers.
+*
+* Only strings are cached. A ts-morph *node* cannot be: re-adding a path forgets the old
+* nodes even when the text is identical, so the memo would hand back wrappers that throw
+* on access. Strings outlive that, and answer the one question worth asking before the
+* helper resolution walks the declarations — whether this file imports from bamboo at
+* all. On a module of many elements that never fold, that walk was the entire cost of
+* trying.
+*/
+const specifierCache = /* @__PURE__ */ new WeakMap();
+const importsAnything = (sourceFile, matches) => byText(specifierCache, sourceFile, () => sourceFile.getImportDeclarations().map((declaration) => declaration.getModuleSpecifierValue())).some(matches);
+/**
+* Every name declared at module scope, which is what an added import could collide with.
+*
+* This replaced `sourceFile.getLocals()`. That was precise, but it goes through the
+* compiler's symbol table, and reaching for it binds the program — including every
+* `.d.ts` the module's imports pull in. It cost ~8ms on a ten-line file and grew with the
+* project, which was invisible while only a partial split reached it and became the
+* dominant cost once open-ended values started lowering too.
+*
+* A syntactic walk answers the same question: a binding in a nested *function* cannot
+* collide with a module-scope import, and one that shadows it *at the call site* is what
+* `isShadowed` is for. Memoized against the file's text rather than the file, since
+* ts-morph reuses the wrapper across a re-add and a plain `WeakMap` would answer for the
+* previous revision. Uncached it is re-walked per candidate, which is quadratic in a
+* module of many elements.
+*/
+const moduleScopeCache = /* @__PURE__ */ new WeakMap();
+const declaredAtModuleScope = (sourceFile) => byText(moduleScopeCache, sourceFile, () => collectModuleScopeNames(sourceFile));
+const collectModuleScopeNames = (sourceFile) => {
+	const names = /* @__PURE__ */ new Set();
+	const addBinding = (node) => {
+		if (!node) return;
+		if (ts_morph.Node.isObjectBindingPattern(node) || ts_morph.Node.isArrayBindingPattern(node)) {
+			for (const element of node.getElements()) if (ts_morph.Node.isBindingElement(element)) addBinding(element.getNameNode());
+			return;
+		}
+		if (ts_morph.Node.isIdentifier(node)) names.add(node.getText());
+	};
+	const addDeclarations = (list) => {
+		if (ts_morph.Node.isVariableStatement(list)) {
+			for (const declaration of list.getDeclarations()) addBinding(declaration.getNameNode());
+			return;
+		}
+		if (ts_morph.Node.isVariableDeclarationList(list)) for (const declaration of list.getDeclarations()) addBinding(declaration.getNameNode());
+	};
+	const isVar = (node) => (ts_morph.Node.isVariableStatement(node) || ts_morph.Node.isVariableDeclarationList(node)) && node.getDeclarationKind() === ts_morph.VariableDeclarationKind.Var;
+	/**
+	* `var` is scoped to the enclosing *function*, not the enclosing block, so one written
+	* inside any statement at the top level still binds at module scope. Walking only the
+	* top-level statements missed every one of them, and each emitted a duplicate binding.
+	*
+	* Only statement containers are followed. A function or class body opens a new variable
+	* scope, so a `var` inside one cannot collide with a module-level import.
+	*/
+	const addHoistedVars = (node) => {
+		if (isVar(node)) {
+			addDeclarations(node);
+			return;
+		}
+		if (ts_morph.Node.isBlock(node)) {
+			for (const statement of node.getStatements()) addHoistedVars(statement);
+			return;
+		}
+		if (ts_morph.Node.isIfStatement(node)) {
+			addHoistedVars(node.getThenStatement());
+			const otherwise = node.getElseStatement();
+			if (otherwise) addHoistedVars(otherwise);
+			return;
+		}
+		if (ts_morph.Node.isForStatement(node)) {
+			const initializer = node.getInitializer();
+			if (initializer) addHoistedVars(initializer);
+			addHoistedVars(node.getStatement());
+			return;
+		}
+		if (ts_morph.Node.isForInStatement(node) || ts_morph.Node.isForOfStatement(node)) {
+			addHoistedVars(node.getInitializer());
+			addHoistedVars(node.getStatement());
+			return;
+		}
+		if (ts_morph.Node.isWhileStatement(node) || ts_morph.Node.isDoStatement(node) || ts_morph.Node.isWithStatement(node)) {
+			addHoistedVars(node.getStatement());
+			return;
+		}
+		if (ts_morph.Node.isLabeledStatement(node)) {
+			addHoistedVars(node.getStatement());
+			return;
+		}
+		if (ts_morph.Node.isTryStatement(node)) {
+			addHoistedVars(node.getTryBlock());
+			const caught = node.getCatchClause();
+			if (caught) addHoistedVars(caught.getBlock());
+			const finally_ = node.getFinallyBlock();
+			if (finally_) addHoistedVars(finally_);
+			return;
+		}
+		if (ts_morph.Node.isSwitchStatement(node)) for (const clause of node.getCaseBlock().getClauses()) for (const statement of clause.getStatements()) addHoistedVars(statement);
+	};
+	for (const statement of sourceFile.getStatements()) {
+		if (ts_morph.Node.isVariableStatement(statement)) {
+			addDeclarations(statement);
+			continue;
+		}
+		if (ts_morph.Node.isImportDeclaration(statement)) {
+			addBinding(statement.getDefaultImport());
+			addBinding(statement.getNamespaceImport());
+			for (const named of statement.getNamedImports()) addBinding(named.getAliasNode() ?? named.getNameNode());
+			continue;
+		}
+		if (ts_morph.Node.isImportEqualsDeclaration(statement)) {
+			addBinding(statement.getNameNode());
+			continue;
+		}
+		if (ts_morph.Node.isFunctionDeclaration(statement) || ts_morph.Node.isClassDeclaration(statement) || ts_morph.Node.isEnumDeclaration(statement) || ts_morph.Node.isModuleDeclaration(statement) || ts_morph.Node.isTypeAliasDeclaration(statement) || ts_morph.Node.isInterfaceDeclaration(statement)) {
+			addBinding(statement.getNameNode());
+			continue;
+		}
+		addHoistedVars(statement);
+	}
+	return names;
+};
+/**
+* The local name an already-imported bamboo binding goes by.
+*
+* `ensureCxImport` answers this too, but it also decides whether a *missing* binding can
+* be added, which needs `getLocals()` — the compiler's binder over the whole module. This
+* runs for every candidate whether it folds or not, so it stops at what the import
+* declarations already say and never forces that.
+*/
+const findBambooBinding = (call, imported, isBambooCssModule, isShadowed) => {
+	if (!importsAnything(call.getSourceFile(), isBambooCssModule)) return void 0;
+	for (const declaration of call.getSourceFile().getImportDeclarations()) {
+		if (declaration.isTypeOnly() || !isBambooCssModule(declaration.getModuleSpecifierValue())) continue;
+		for (const named of declaration.getNamedImports()) {
+			if (named.isTypeOnly() || named.getNameNode().getText() !== imported) continue;
+			const local = (named.getAliasNode() ?? named.getNameNode()).getText();
+			return isShadowed(call, local) ? void 0 : local;
+		}
+	}
+};
+/**
+* A value that survives the class pipeline unchanged, so the class built around it is the
+* prefix and nothing else: no whitespace for `sanitize` to collapse, no `!` for the
+* important regex, no space for `withoutSpace`, and nothing a token or condition could
+* plausibly be named.
+*/
+const LEAF_SENTINEL = "bamboo0leaf0sentinel0";
+/**
+* A property the extractor could not resolve is *open-ended* rather than finite — but its
+* class is still `prefix + value`, and the prefix is known now.
+*
+* `utility.transform` is string construction over a table fixed at build time, and
+* nothing consults which rules were emitted. So `css({ color: tone })` already returns
+* `c_<tone>` for a value the extractor never saw, with no CSS behind it. Emitting that
+* string directly cannot be less correct than the call it replaces.
+*
+* The prefix is read off the real implementation rather than rebuilt: resolving a
+* sentinel through `runtimeCss` applies the shorthand table and the utility's class name
+* in one step. It also self-gates — a hashed or grouped class does not contain the
+* sentinel, so both modes decline here without this having to read the config.
+*
+* Shared with the element surface, which asks the same question about a JSX style prop.
+*
+* Top level only, like the finite lowering beside it. A nested leaf's class carries its
+* condition path, which the prefix would describe correctly — but the helper's fallback
+* rebuilds `{ [prop]: value }` to hand back to `css()`, and that reconstruction has to
+* carry the same path or the declined shape resolves without its condition.
+*/
+const leafPrefix = (key, ctx, runtimeCss) => {
+	if (ctx.isTemplateLiteralSyntax) return void 0;
+	if (ctx.conditions.isCondition(key)) return void 0;
+	let resolved;
+	try {
+		resolved = runtimeCss({ [key]: LEAF_SENTINEL });
+	} catch {
+		return;
+	}
+	if (!resolved.endsWith(LEAF_SENTINEL)) return void 0;
+	const prefix = resolved.slice(0, -21);
+	return !prefix || prefix.includes(" ") ? void 0 : prefix;
+};
+/**
+* Written as an object or an array, this is a condition block or a responsive list: one
+* class per entry rather than one class. `leafClass` declines both at runtime and falls
+* back, so lowering one is not wrong — it is a guaranteed round trip through the fallback,
+* which is the same reason a condition key is declined.
+*/
+const isWrittenAsCollection = (value) => {
+	const inner = unwrapExpression(value);
+	return ts_morph.Node.isObjectLiteralExpression(inner) || ts_morph.Node.isArrayLiteralExpression(inner);
+};
+/** The call this surface emits in place of the property. */
+const leafCall = (prefix, key, valueText, name = LEAF_HELPER) => `${name}(${JSON.stringify(prefix)}, ${JSON.stringify(key)}, ${valueText})`;
+const dynamicLeaf = (key, value, deps) => {
+	if (!deps.allowLeaf || !value) return void 0;
+	if (isWrittenAsCollection(value)) return void 0;
+	const prefix = leafPrefix(key, deps.ctx, deps.runtimeCss);
+	return prefix === void 0 ? void 0 : leafCall(prefix, key, value.getText(), deps.leafName ?? "cssLeaf");
+};
+/**
+* Properties are partitioned whole rather than recursed into. A top-level property is
+* either entirely static or entirely dynamic, which keeps the reconstructed object a
+* verbatim slice of the source and avoids rebuilding nested conditions by hand.
+*/
+const planPartialFold = (argument, boxNode, styles, deps) => {
+	const partition = partitionObject(argument, boxNode, styles, deps);
+	if (!partition) return void 0;
+	const className = deps.runtimeCss(partition.staticStyles);
+	if (!className && !partition.finite.length) return void 0;
+	return {
+		className,
+		dynamicText: partition.dynamicText.length ? `{ ${partition.dynamicText.join(", ")} }` : void 0,
+		finite: partition.finite,
+		finiteFirst: partition.finiteFirst
+	};
+};
+/**
+* Split one object level, recursing into a block that is part static and part dynamic.
+*
+* Without the recursion a single dynamic leaf sends its whole block to the runtime:
+* `{ _hover: { color: 'red.300', bg: p } }` loses the resolved `color` even though
+* nothing about it depends on `p`. That is a precision loss rather than a wrong answer,
+* but it costs exactly the calls a component re-renders most.
+*
+* A class is identified by its condition path *and* its property, so `_hover.color` in
+* one half and `_hover.bg` in the other cannot collide, and neither can `color` against
+* `_hover.color`. Collision is therefore checked per level, among siblings.
+*
+* The static subtree is read from the extracted data rather than rebuilt: the extractor
+* has already dropped the unresolvable leaves, so `styles[key]` for a mixed block is
+* exactly the resolvable part. The dynamic side is taken from source text, so nothing
+* depends on that pruning being complete.
+*/
+const partitionObject = (node, boxNode, styles, deps, topLevel = true) => {
+	if (!_bamboocss_extractor.box.isMap(boxNode)) return void 0;
+	const { ctx, isAccounted, isStatic } = deps;
+	const staticKeys = [];
+	const staticStyles = {};
+	const seenKeys = /* @__PURE__ */ new Set();
+	/**
+	* Everything not resolved outright, in source order. Kept as one list because a ternary
+	* that cannot be lowered has to become a runtime property *in its original position*,
+	* and because whether the two kinds interleave is a property of that order.
+	*/
+	const slots = [];
+	for (const property of node.getProperties()) {
+		if (!ts_morph.Node.isPropertyAssignment(property) && !ts_morph.Node.isShorthandPropertyAssignment(property)) return void 0;
+		const nameNode = property.getNameNode();
+		if (ts_morph.Node.isComputedPropertyName(nameNode)) return void 0;
+		const key = ts_morph.Node.isStringLiteral(nameNode) || ts_morph.Node.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
+		if (seenKeys.has(key)) return void 0;
+		seenKeys.add(key);
+		const value = valueOf(property);
+		const valueBox = boxNode.value.get(key);
+		if (key in styles && isStatic(valueBox) && isAccounted(value, valueBox)) {
+			staticKeys.push(key);
+			staticStyles[key] = styles[key];
+			continue;
+		}
+		if (topLevel) {
+			const branches = finiteBranches(key, value, valueBox, deps);
+			if (branches) {
+				slots.push({
+					key,
+					kind: "finite",
+					lowered: {
+						expression: branches,
+						emitsLiterals: true
+					},
+					text: property.getText()
+				});
+				continue;
+			}
+			const leaf = dynamicLeaf(key, value, deps);
+			if (leaf) {
+				slots.push({
+					key,
+					kind: "finite",
+					lowered: {
+						expression: leaf,
+						emitsLiterals: false
+					},
+					text: property.getText()
+				});
+				continue;
+			}
+		}
+		const nested = value && ts_morph.Node.isObjectLiteralExpression(value) && isAccounted(value, valueBox) ? partitionObject(value, valueBox, styles[key] ?? {}, deps, false) : void 0;
+		if (nested && Object.keys(nested.staticStyles).length && nested.dynamicText.length) {
+			staticKeys.push(key);
+			staticStyles[key] = nested.staticStyles;
+			slots.push({
+				key,
+				kind: "dynamic",
+				split: true,
+				text: `${property.getNameNode().getText()}: { ${nested.dynamicText.join(", ")} }`
+			});
+			continue;
+		}
+		slots.push({
+			key,
+			kind: "dynamic",
+			text: property.getText()
+		});
+	}
+	const demote = (slot) => {
+		slot.kind = "dynamic";
+		slot.lowered = void 0;
+	};
+	const contested = () => slots.filter((slot) => slot.kind === "dynamic" && !slot.split).map((slot) => slot.key);
+	for (;;) {
+		const lowered = slots.filter((slot) => slot.kind === "finite");
+		const dynamic = contested();
+		const offender = lowered.find((slot, index) => collides([slot.key], [
+			...staticKeys,
+			...dynamic,
+			...lowered.slice(0, index).map((kept) => kept.key)
+		], ctx));
+		if (!offender) break;
+		demote(offender);
+	}
+	const written = () => slots.map((slot) => slot.kind === "finite" ? "f" : "d").join("");
+	while (!/^f*d*$/.test(written()) && !/^d*f*$/.test(written())) demote(slots.findLast((slot) => slot.kind === "finite"));
+	const dynamicText = slots.filter((slot) => slot.kind === "dynamic").map((slot) => slot.text);
+	const finite = slots.filter((slot) => slot.kind === "finite").map((slot) => slot.lowered);
+	if (!staticKeys.length && !finite.length) return void 0;
+	if (!dynamicText.length && !finite.length) return void 0;
+	if (collides(staticKeys, contested(), ctx)) return void 0;
+	return {
+		staticStyles,
+		dynamicText,
+		finite,
+		finiteFirst: !written().startsWith("d")
+	};
+};
+/**
+* Do the two halves resolve to a shared property?
+*
+* Compared after shorthand resolution, since that is where distinct keys become the same
+* property. An unrecognised key resolves to itself, so two distinct unknown keys are read
+* as distinct — which is right for atomic output, where one class is emitted per key.
+*/
+const collides = (staticKeys, dynamicKeys, ctx) => {
+	if (staticKeys.includes("base") || dynamicKeys.includes("base")) return true;
+	const resolve = (key) => ctx.utility.hasShorthand ? ctx.utility.resolveShorthand(key) : key;
+	const resolvedStatic = new Set(staticKeys.map(resolve));
+	return dynamicKeys.some((key) => resolvedStatic.has(resolve(key)));
+};
+/**
+* The `cx` binding to call, adding it to the import that already brings in the style
+* helper when it is not there yet.
+*
+* Reusing that declaration rather than writing a new one avoids having to guess the
+* module specifier, which varies with `importMap`, path aliases and how the project
+* spells its outdir.
+*/
+const ensureCxImport = (call, calleeRoot, isBambooCssModule, isGeneratedCssModule, isShadowed, extra = []) => {
+	const sourceFile = call.getSourceFile();
+	const wanted = ["cx", ...extra];
+	const resolved = {};
+	let host;
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		const mod = declaration.getModuleSpecifierValue();
+		for (const named of declaration.getNamedImports()) {
+			const local = (named.getAliasNode() ?? named.getNameNode()).getText();
+			const imported = named.getNameNode().getText();
+			if (wanted.includes(imported) && !(imported in resolved)) {
+				if (declaration.isTypeOnly() || named.isTypeOnly()) return void 0;
+				if (!isBambooCssModule(mod)) return void 0;
+				if (isShadowed(call, local)) return void 0;
+				resolved[imported] = local;
+			}
+			if (local === calleeRoot) host = declaration;
+		}
+	}
+	const missing = wanted.filter((name) => !(name in resolved));
+	if (!missing.length) return {
+		name: resolved.cx,
+		names: resolved
+	};
+	if (!host) return void 0;
+	if (!isGeneratedCssModule(host.getModuleSpecifierValue())) return void 0;
+	const declared = declaredAtModuleScope(sourceFile);
+	for (const name of missing) {
+		if (declared.has(name) || isShadowed(call, name)) return void 0;
+		resolved[name] = name;
+	}
+	const last = host.getNamedImports().at(-1);
+	if (!last) return void 0;
+	return {
+		name: resolved.cx,
+		names: resolved,
+		insert: {
+			pos: last.getEnd(),
+			names: missing
+		}
+	};
+};
+/**
+* The `css` and `cx` bindings a partially folded JSX element needs.
+*
+* Splitting an element sends its dynamic style props to a `css()` call, so unlike the
+* call-site split this needs *two* bindings rather than one. Both are taken from an
+* existing bamboo `css` import: writing a new import declaration would mean guessing a
+* module specifier, and the spelling varies with `importMap`, path aliases and how the
+* project reaches its outdir. An element in a file that does not already import `css` is
+* left alone instead.
+*/
+const resolveCssHelpers = (node, isBambooCssModule, isGeneratedCssModule, isShadowed, wantLeaf = false) => {
+	const sourceFile = node.getSourceFile();
+	if (!importsAnything(sourceFile, isBambooCssModule)) return void 0;
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		const mod = declaration.getModuleSpecifierValue();
+		if (declaration.isTypeOnly() || !isBambooCssModule(mod)) continue;
+		const named = declaration.getNamedImports();
+		const cssImport = named.find((entry) => entry.getNameNode().getText() === "css" && !entry.isTypeOnly());
+		if (!cssImport) continue;
+		const cssName = (cssImport.getAliasNode() ?? cssImport.getNameNode()).getText();
+		if (isShadowed(node, cssName)) return void 0;
+		const wanted = wantLeaf ? ["cx", LEAF_HELPER] : ["cx"];
+		const resolved = {};
+		const missing = [];
+		for (const want of wanted) {
+			const existing = named.find((entry) => entry.getNameNode().getText() === want && !entry.isTypeOnly());
+			if (existing) {
+				const local = (existing.getAliasNode() ?? existing.getNameNode()).getText();
+				if (isShadowed(node, local)) return void 0;
+				resolved[want] = local;
+				continue;
+			}
+			missing.push(want);
+		}
+		if (!missing.length) return {
+			css: cssName,
+			cx: resolved.cx,
+			leaf: resolved[LEAF_HELPER]
+		};
+		if (!isGeneratedCssModule(mod)) return void 0;
+		const declared = declaredAtModuleScope(sourceFile);
+		for (const name of missing) {
+			if (isShadowed(node, name) || declared.has(name)) return void 0;
+			resolved[name] = name;
+		}
+		const last = named.at(-1);
+		if (!last) return void 0;
+		return {
+			css: cssName,
+			cx: resolved.cx,
+			leaf: resolved[LEAF_HELPER],
+			insert: {
+				pos: last.getEnd(),
+				names: missing
+			}
+		};
+	}
+};
+//#endregion
+//#region src/fold-jsx.ts
+const RANK = {
+	constant: 0,
+	reads: 1,
+	unknown: 2
+};
+const worst = (a, b) => RANK[a] >= RANK[b] ? a : b;
+const purityOf = (node) => {
+	if (ts_morph.Node.isIdentifier(node)) return "reads";
+	if (ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNumericLiteral(node) || ts_morph.Node.isNoSubstitutionTemplateLiteral(node) || ts_morph.Node.isTrueLiteral(node) || ts_morph.Node.isFalseLiteral(node) || node.getKind() === ts_morph.SyntaxKind.NullKeyword) return "constant";
+	if (ts_morph.Node.isPrefixUnaryExpression(node) && ts_morph.Node.isNumericLiteral(node.getOperand())) return "constant";
+	if (ts_morph.Node.isObjectLiteralExpression(node)) return node.getProperties().reduce((acc, property) => {
+		if (!ts_morph.Node.isPropertyAssignment(property)) return "unknown";
+		if (ts_morph.Node.isComputedPropertyName(property.getNameNode())) return "unknown";
+		const value = property.getInitializer();
+		return worst(acc, value ? purityOf(value) : "unknown");
+	}, "constant");
+	if (ts_morph.Node.isArrayLiteralExpression(node)) return node.getElements().reduce((acc, element) => worst(acc, purityOf(element)), "constant");
+	return "unknown";
+};
+/**
+* The same question for a whole attribute.
+*
+* A `JsxElement` or `JsxFragment` initializer — `title=<Tag x={f()} />` — is legal, holds
+* arbitrary expressions, and is not a `JsxExpression`, so this asks what an initializer
+* *is* rather than listing the kinds that carry code.
+*/
+const attributePurity = (attribute) => {
+	const initializer = attribute.getInitializer();
+	if (!initializer) return "constant";
+	if (ts_morph.Node.isStringLiteral(initializer)) return "constant";
+	if (!ts_morph.Node.isJsxExpression(initializer)) return "unknown";
+	const expression = initializer.getExpression();
+	return expression ? purityOf(expression) : "constant";
+};
+/**
+* Props the factory gives extra *styling* meaning to, which is why they block a fold.
+*
+* `unstyled` skips the recipe and `css` merges at a higher precedence than the style
+* props, so neither is expressible as a class the fold can compute alongside the rest.
+*
+* `ref`, `key` and `children` used to be here too, and do not belong: none of them
+* changes what the element is styled with. The factory takes `ref` through `forwardRef`
+* and hands it straight to `createElement`, so an intrinsic tag — or whatever `as` names
+* — receives the identical prop. `key` never reaches the component at all; React consumes
+* it. And `children ?? combinedProps.children` mirrors `createElement`'s own rule that
+* the third argument beats `props.children`. Each is a passthrough, and travels as one.
+*/
+const RESERVED_PROPS = new Set(["unstyled", "css"]);
+/**
+* Props that carry no styling, and so block a fold only where the framework gives them a
+* meaning the rewrite would change.
+*/
+const MECHANICAL_PROPS = new Set([
+	"ref",
+	"key",
+	"children"
+]);
+/**
+* Where a mechanical prop may travel as an ordinary passthrough.
+*
+* React only, and measured rather than reasoned about. Its factory forwards the ref to
+* the element it renders, so moving the ref onto that element changes nothing.
+*
+* Preact was in this list on the strength of `forwardRef` appearing in its factory too,
+* and that inference was wrong: under this repo's compat setup an unfolded
+* `<styled.div ref={r}>` binds the *component instance* and the folded `<div ref={r}>`
+* binds the DOM node. A hand-written `forwardRef` behaves the same way, so it is Preact's
+* own handling rather than anything the factory does. Vue diverges for the plain reason —
+* a ref on a component is the instance, on an element it is the node.
+*
+* An allowlist rather than a denylist, because the failure is silent and the list of
+* runtimes is open. Every other framework keeps the behaviour it had before.
+*/
+const MECHANICAL_FRAMEWORKS = new Set(["react"]);
+/**
+* Is this a tag JSX reads as an intrinsic element?
+*
+* Anchored and dot-free, because both halves matter. `Section` is a variable reference,
+* and `foo.bar` is a member expression — a property read off something in scope — where
+* the runtime would have created an element named literally that.
+*/
+const isIntrinsicTag = (tag) => /^[a-z][\w-]*$/.test(tag);
+/**
+* The tag an `as` prop names, when it names one statically.
+*
+* The factory destructures `{ as: Element = __base__ }` and hands `Element` to
+* `createElement`, so a static `as` is simply a different tag with the same class and
+* the same forwarded props — `splitProps` keys off the factory's own config, not off
+* what `as` points at, so the split is unchanged.
+*
+* Casing is load-bearing, because JSX and `createElement` disagree about it. JSX reads a
+* lowercase tag as an intrinsic element and a capitalised one as a variable, while
+* `createElement` takes a string as intrinsic and anything else as a component. So the
+* two forms only survive the rewrite when their casing already agrees:
+*
+* - `as="section"` -> `<section>`, intrinsic both ways.
+* - `as={Link}` -> `<Link>`, a component reference both ways.
+*
+* The mismatched pair render something else entirely. `as={thing}` would fold to
+* `<thing>`, a DOM element named `thing` rather than the component; `as="Section"` would
+* fold to `<Section>`, a variable reference rather than the intrinsic the factory would
+* have created. Both bail.
+*
+* A dot is the same hazard spelled differently, and it survives lowercasing. `<foo.bar>`
+* is a JSX member expression — `createElement(foo.bar)`, a property read off a variable
+* in scope — where the factory would have created an intrinsic element named literally
+* `foo.bar`. So a dotted value bails even though its casing agrees.
+*/
+const asTag = (attribute) => {
+	const initializer = attribute.getInitializer();
+	if (!initializer) return void 0;
+	if (ts_morph.Node.isStringLiteral(initializer)) {
+		const value = initializer.getLiteralValue();
+		return /^[a-z][\w-]*$/.test(value) ? value : void 0;
+	}
+	if (!ts_morph.Node.isJsxExpression(initializer)) return void 0;
+	const expression = initializer.getExpression();
+	if (!expression || !ts_morph.Node.isIdentifier(expression)) return void 0;
+	const name = expression.getText();
+	return /^[A-Z]/.test(name) ? name : void 0;
+};
+/**
+* `normalizeHTMLProps` renames these on the way to the DOM (`htmlSize` -> `size`).
+* Reproducing the rename is easy; noticing that it exists is the hard part, so they bail.
+*/
+const HTML_PROPS = new Set([
+	"htmlSize",
+	"htmlTranslate",
+	"htmlWidth",
+	"htmlHeight"
+]);
+/**
+* The intrinsic tag a factory expression names, if it names one statically.
+*
+* Only `styled.div` and friends fold. `styled(Component)` and `styled('div')` are call
+* expressions whose result is bound elsewhere, and a capitalised tag is a component
+* rather than an intrinsic element.
+*/
+const intrinsicTag = (tagName, factoryName) => {
+	const prefix = `${factoryName}.`;
+	if (!tagName.startsWith(prefix)) return void 0;
+	const tag = tagName.slice(prefix.length);
+	if (!/^[a-z][a-z0-9-]*$/.test(tag)) return void 0;
+	return tag;
+};
+/**
+* Collapse a pattern element (`<Stack gap="4">`) to the tag it renders.
+*
+* A pattern component is a second layer on top of the factory: it splits its own props
+* out, runs them through the pattern's transform, and hands the result to
+* `styled.<jsxElement>`, which then does everything described above. Folding one removes
+* both layers.
+*
+* The class is computed through `patterns.transform`, the same call the encoder makes
+* when it decides what css to emit — so a folded pattern class is backed by a rule by
+* construction, and the render-parity test is what confirms it also matches the runtime.
+*
+* Only the default `jsxStyleProps: 'all'` folds. Under `minimal` and `none` the pattern's
+* styles reach the factory through the `css` prop instead of being spread, which reverses
+* which side wins when a prop is set in both places.
+*/
+const planPatternFold = (item, ctx, runtimeCss) => {
+	const node = item.box?.getNode?.();
+	if (!node || !ts_morph.Node.isJsxOpeningElement(node) && !ts_morph.Node.isJsxSelfClosingElement(node)) return { reason: "unsupported-kind" };
+	if (ctx.jsx.styleProps !== "all") return { reason: "unsupported-kind" };
+	const jsxName = node.getTagNameNode().getText();
+	const detail = ctx.patterns.details.find((entry) => entry.jsxName === jsxName);
+	if (!detail) return { reason: "unsupported-kind" };
+	const styles = item.data?.[0] ?? {};
+	const passthrough = [];
+	let staticClassName = "";
+	let sawChildrenProp = false;
+	let tag = detail.config.jsxElement ?? "div";
+	let tagFromAs = false;
+	for (const attribute of node.getAttributes()) {
+		if (!ts_morph.Node.isJsxAttribute(attribute)) return { reason: "dynamic" };
+		const name = attribute.getNameNode().getText();
+		if (name === "className") {
+			const initializer = attribute.getInitializer();
+			if (!initializer || !ts_morph.Node.isStringLiteral(initializer)) return { reason: "dynamic" };
+			staticClassName = initializer.getLiteralValue();
+			continue;
+		}
+		if (name === "as") {
+			const resolved = asTag(attribute);
+			if (!resolved) return { reason: "dynamic" };
+			tag = resolved;
+			tagFromAs = true;
+			continue;
+		}
+		if (RESERVED_PROPS.has(name) || HTML_PROPS.has(name)) return { reason: "dynamic" };
+		if (MECHANICAL_PROPS.has(name) && !MECHANICAL_FRAMEWORKS.has(ctx.jsx.framework ?? "")) return { reason: "dynamic" };
+		if (name === "children") sawChildrenProp = true;
+		if (detail.props.includes(name) || ctx.isValidProperty(name)) {
+			if (!(name in styles)) return { reason: "dynamic" };
+			continue;
+		}
+		passthrough.push(attribute.getText());
+	}
+	if (!tagFromAs && !isIntrinsicTag(tag)) return { reason: "unsupported-kind" };
+	if (sawChildrenProp && !isIntrinsicTag(tag)) return { reason: "dynamic" };
+	let resolved;
+	try {
+		resolved = runtimeCss(ctx.patterns.transform(detail.baseName, styles));
+	} catch {
+		return { reason: "dynamic" };
+	}
+	const className = [resolved, staticClassName].filter(Boolean).join(" ");
+	if (!className) return { reason: "dynamic" };
+	return buildEdits(node, tag, passthrough, className);
+};
+const planJsxFold = (item, ctx, runtimeCss, deps) => {
+	const node = item.box?.getNode?.();
+	if (!node || !ts_morph.Node.isJsxOpeningElement(node) && !ts_morph.Node.isJsxSelfClosingElement(node)) return { reason: "unsupported-kind" };
+	const baseTag = intrinsicTag(node.getTagNameNode().getText(), ctx.jsx.factoryName);
+	if (!baseTag) return { reason: "unsupported-kind" };
+	let tag = baseTag;
+	const styles = item.data?.[0] ?? {};
+	const propBoxes = _bamboocss_extractor.box.isMap(item.box) ? item.box.value : void 0;
+	const passthrough = [];
+	const staticProps = [];
+	const dynamicProps = [];
+	let staticClassName = "";
+	let dynamicClassName = "";
+	let sawClassName = false;
+	let sawChildrenProp = false;
+	/**
+	* Where a dynamic `className` was written, and where the attributes that outlive the
+	* fold were.
+	*
+	* The factory appends `className` after the styles, so a folded one is emitted last and
+	* anything written after it runs before it instead. That covers more than the style
+	* props — a passthrough keeps its own place among the attributes — but only where the
+	* expression survives at all. A static style prop is not among them: it is *deleted*,
+	* its value having been resolved at build time. That is a larger change than reordering
+	* and a separate pre-existing gap — `<styled.div color={counted()} />` folds and never
+	* calls it, with or without this — rather than a reason the reordering is moot.
+	*/
+	let classNameIndex = -1;
+	let classNamePurity = "constant";
+	const survivors = [];
+	let index = -1;
+	for (const attribute of node.getAttributes()) {
+		if (!ts_morph.Node.isJsxAttribute(attribute)) return { reason: "dynamic" };
+		index += 1;
+		const name = attribute.getNameNode().getText();
+		if (name === "className") {
+			const initializer = attribute.getInitializer();
+			if (!initializer) return { reason: "dynamic" };
+			if (sawClassName && (dynamicClassName || !ts_morph.Node.isStringLiteral(initializer))) return { reason: "dynamic" };
+			sawClassName = true;
+			if (ts_morph.Node.isStringLiteral(initializer)) {
+				staticClassName = initializer.getLiteralValue();
+				continue;
+			}
+			const expression = ts_morph.Node.isJsxExpression(initializer) ? initializer.getExpression() : void 0;
+			if (!expression) return { reason: "dynamic" };
+			dynamicClassName = expression.getText();
+			classNameIndex = index;
+			classNamePurity = purityOf(expression);
+			continue;
+		}
+		if (name === "as") {
+			const resolved = asTag(attribute);
+			if (!resolved) return { reason: "dynamic" };
+			survivors.push({
+				index,
+				purity: attributePurity(attribute)
+			});
+			tag = resolved;
+			continue;
+		}
+		if (RESERVED_PROPS.has(name) || HTML_PROPS.has(name)) return { reason: "dynamic" };
+		if (MECHANICAL_PROPS.has(name) && !MECHANICAL_FRAMEWORKS.has(ctx.jsx.framework ?? "")) return { reason: "dynamic" };
+		if (name === "children") sawChildrenProp = true;
+		if (ctx.isValidProperty(name)) {
+			const attributeValue = attribute.getInitializer();
+			const valueExpression = attributeValue && ts_morph.Node.isJsxExpression(attributeValue) ? attributeValue.getExpression() : void 0;
+			const propBox = propBoxes?.get(name);
+			if (name in styles && isStaticBox(propBox) && accountsForSource(valueExpression, propBox)) {
+				staticProps.push(name);
+				continue;
+			}
+			if (!valueExpression) return { reason: "dynamic" };
+			const expression = valueExpression;
+			survivors.push({
+				index,
+				purity: attributePurity(attribute)
+			});
+			dynamicProps.push({
+				name,
+				text: expression.getText(),
+				expression
+			});
+			continue;
+		}
+		survivors.push({
+			index,
+			purity: attributePurity(attribute)
+		});
+		passthrough.push(attribute.getText());
+	}
+	if (sawChildrenProp && !isIntrinsicTag(tag)) return { reason: "dynamic" };
+	/**
+	* Would emitting the className last move it past something that can observe it?
+	*
+	* A constant survivor commutes with anything. One that only reads commutes only while
+	* the className expression cannot write — `className={cn} onClick={h}` is safe, and
+	* `className={assigns()} bg={tone}` is not, because moving the read after the write
+	* hands it the other value.
+	*
+	* This answers for the className and nothing else. `buildEdits` emits
+	* `[...passthrough, className={cx(…)}]`, so a passthrough is also hoisted ahead of every
+	* dynamic style prop's expression — `<styled.div bg={writes()} data-x={reads} />`
+	* reorders those two with no className present at all. That is pre-existing and
+	* reproduces on an unchanged tree; folding a dynamic className only makes it reachable
+	* for more elements. Closing it means comparing every survivor against everything it
+	* crosses rather than against one attribute, which is a different change.
+	*/
+	const reordered = () => classNameIndex >= 0 && survivors.some((entry) => entry.index > classNameIndex && entry.purity !== "constant" && !(entry.purity === "reads" && classNamePurity !== "unknown"));
+	if (dynamicProps.length) {
+		if (!deps || item.data.length !== 1) return { reason: "dynamic" };
+		if (collides(staticProps, dynamicProps.map((prop) => prop.name), ctx)) return { reason: "dynamic" };
+		const resolveProp = (name) => ctx.utility.hasShorthand ? ctx.utility.resolveShorthand(name) : name;
+		const claimed = /* @__PURE__ */ new Map();
+		for (const prop of dynamicProps) claimed.set(resolveProp(prop.name), (claimed.get(resolveProp(prop.name)) ?? 0) + 1);
+		const prefixes = /* @__PURE__ */ new Map();
+		for (const prop of dynamicProps) {
+			if (claimed.get(resolveProp(prop.name)) !== 1) continue;
+			if (isWrittenAsCollection(prop.expression)) continue;
+			const prefix = leafPrefix(prop.name, ctx, runtimeCss);
+			if (prefix !== void 0) prefixes.set(prop.name, prefix);
+		}
+		const kinds = dynamicProps.map((prop) => prefixes.has(prop.name) ? "l" : "r").join("");
+		if (!/^l*r*$/.test(kinds) && !/^r*l*$/.test(kinds)) prefixes.clear();
+		if (reordered()) return { reason: "dynamic" };
+		const helpers = resolveCssHelpers(node, deps.isBambooCssModule, deps.isGeneratedCssModule, deps.isShadowed, prefixes.size > 0);
+		if (!helpers) return { reason: "dynamic" };
+		if (!helpers.leaf) prefixes.clear();
+		const staticStyles = {};
+		for (const name of staticProps) staticStyles[name] = styles[name];
+		const resolved = [runtimeCss(staticStyles), staticClassName].filter(Boolean).join(" ");
+		const lowered = dynamicProps.filter((prop) => prefixes.has(prop.name)).map((prop) => leafCall(prefixes.get(prop.name), prop.name, prop.text, helpers.leaf));
+		const residue = dynamicProps.filter((prop) => !prefixes.has(prop.name));
+		const runtime = residue.length ? [`${helpers.css}({ ${residue.map((prop) => `${prop.name}: ${prop.text}`).join(", ")} })`] : [];
+		if (!resolved && !lowered.length) return { reason: "dynamic" };
+		const ordered = kinds.startsWith("r") ? [...runtime, ...lowered] : [...lowered, ...runtime];
+		const parts = dynamicClassName ? [...ordered, dynamicClassName] : ordered;
+		const plan = buildEdits(node, tag, passthrough, resolved, `${helpers.cx}(${[...resolved ? [JSON.stringify(resolved)] : [], ...parts].join(", ")})`);
+		return "reason" in plan ? plan : {
+			...plan,
+			insert: helpers.insert
+		};
+	}
+	if (item.data.length !== 1) return { reason: "dynamic" };
+	const className = [runtimeCss(styles), staticClassName].filter(Boolean).join(" ");
+	if (dynamicClassName) {
+		if (reordered()) return { reason: "dynamic" };
+		const helpers = deps && resolveCssHelpers(node, deps.isBambooCssModule, deps.isGeneratedCssModule, deps.isShadowed);
+		if (!helpers) return { reason: "dynamic" };
+		const args = [...className ? [JSON.stringify(className)] : [], dynamicClassName];
+		const plan = buildEdits(node, tag, passthrough, className, `${helpers.cx}(${args.join(", ")})`);
+		return "reason" in plan ? plan : {
+			...plan,
+			insert: helpers.insert
+		};
+	}
+	if (!className) return { reason: "dynamic" };
+	return buildEdits(node, tag, passthrough, className);
+};
+/** Rewrite the opening element, and the closing one when there is a pair. */
+const buildEdits = (node, tag, passthrough, className, classExpression) => {
+	const attributes = [...passthrough, `className={${classExpression ?? JSON.stringify(className)}}`].join(" ");
+	const selfClosing = ts_morph.Node.isJsxSelfClosingElement(node);
+	const edits = [{
+		start: node.getStart(),
+		end: node.getEnd(),
+		text: `<${tag} ${attributes}${selfClosing ? " />" : ">"}`
+	}];
+	let end = node.getEnd();
+	if (!selfClosing) {
+		const parent = node.getParent();
+		if (!ts_morph.Node.isJsxElement(parent)) return { reason: "unsupported-kind" };
+		const closing = parent.getClosingElement();
+		edits.push({
+			start: closing.getStart(),
+			end: closing.getEnd(),
+			text: `</${tag}>`
+		});
+		end = closing.getEnd();
+	}
+	return {
+		edits,
+		className,
+		start: node.getStart(),
+		end
+	};
+};
+//#endregion
+//#region src/runtime-css.ts
+/** The shape `createCss` and `createMergeCss` both take, derived from a resolved context. */
+const createCssContext = (ctx) => ({
+	grouped: ctx.config.cssMode === "grouped",
+	hash: Boolean(ctx.hash.className),
+	conditions: {
+		shift: ctx.conditions.shift,
+		finalize: ctx.conditions.finalize,
+		breakpoints: { keys: ctx.conditions.breakpoints.keys }
+	},
+	utility: {
+		prefix: ctx.utility.prefix,
+		hasShorthand: ctx.utility.hasShorthand,
+		resolveShorthand: ctx.utility.resolveShorthand.bind(ctx.utility),
+		transform: ctx.utility.transform.bind(ctx.utility),
+		toHash: ctx.utility.toHash.bind(ctx.utility)
+	}
+});
+const createRuntimeCss = (ctx) => {
+	const cssContext = createCssContext(ctx);
+	const cssFn = (0, _bamboocss_shared.createCss)(cssContext);
+	const { mergeCss } = (0, _bamboocss_shared.createMergeCss)(cssContext);
+	return (...styles) => cssFn(mergeCss(...styles));
+};
+const createRuntimeRecipe = (ctx, runtimeCss) => {
+	const separator = ctx.utility.separator;
+	const { mergeCss } = (0, _bamboocss_shared.createMergeCss)(createCssContext(ctx));
+	return (name, variants) => {
+		const config = ctx.recipes.getConfig(name);
+		const node = ctx.recipes.getRecipe(name);
+		if (!config || !node) return void 0;
+		if ("slots" in config) return void 0;
+		const className = node.className;
+		const { defaultVariants = {}, compoundVariants = [] } = config;
+		const recipeCss = (0, _bamboocss_shared.createCss)({
+			hash: Boolean(ctx.hash.className),
+			conditions: {
+				shift: ctx.conditions.shift,
+				finalize: ctx.conditions.finalize,
+				breakpoints: { keys: ctx.conditions.breakpoints.keys }
+			},
+			utility: {
+				prefix: ctx.utility.prefix,
+				hasShorthand: false,
+				resolveShorthand: (prop) => prop,
+				toHash: ctx.utility.toHash.bind(ctx.utility),
+				transform: (prop, value) => {
+					if (value === "__ignore__") return { className };
+					return { className: `${className}--${prop}${separator}${(0, _bamboocss_shared.withoutSpace)(value)}` };
+				}
+			}
+		});
+		const recipeStyles = {
+			[className]: "__ignore__",
+			...defaultVariants,
+			...(0, _bamboocss_shared.compact)(variants)
+		};
+		if (compoundVariants.length > 0 && Object.keys(recipeStyles).some((prop) => typeof variants[prop] === "object")) return;
+		const compoundStyles = getCompoundVariantCss(compoundVariants, recipeStyles, mergeCss);
+		return [recipeCss(recipeStyles), runtimeCss(compoundStyles)].filter(Boolean).join(" ");
+	};
+};
+/**
+* Mirrors the function of the same name in the generated `cva` artifact, down to the
+* `mergeCss` it accumulates with.
+*
+* That merge has to be the deep one. More than one compound variant can match a single
+* selection, and their `css` objects then combine rather than replace: `_hover` set by
+* one and `_hover` set by another have to end up as a single condition holding both
+* declarations. `Object.assign` drops everything the earlier match contributed under a
+* shared key, which produces a shorter class list and no error at all.
+*
+* Taking `mergeCss` as an argument rather than importing one keeps it the same instance
+* the rest of the fold resolves through, built from the same context.
+*/
+const getCompoundVariantCss = (compoundVariants, variantMap, mergeCss) => {
+	let result = {};
+	for (const compoundVariant of compoundVariants) {
+		if (!compoundVariant) continue;
+		if (Object.entries(compoundVariant).every(([key, value]) => {
+			if (key === "css") return true;
+			return (Array.isArray(value) ? value : [value]).some((entry) => variantMap[key] === entry);
+		})) result = mergeCss(result, compoundVariant.css);
+	}
+	return result;
+};
+//#endregion
+//#region src/fold.ts
+/**
+* `cva`/`sva` return a function and `token` returns a value, so none of them can
+* collapse to a class string. Their *invocations* could, but those are separate call
+* sites the parser does not record as such.
+*/
+const FOLDABLE_TYPES = new Set([
+	"css",
+	"pattern",
+	"recipe"
+]);
+/**
+* The class strings inside a lowered ternary — `e ? "c_red" : "c_blue"` gives both arms.
+*
+* They are read back out of the emitted text rather than threaded through the planner,
+* because the planner's product *is* that text: anything it did not write cannot appear
+* here, and anything it did cannot be missed.
+*/
+const literalsIn = (expression) => [...expression.matchAll(/"((?:[^"\\]|\\.)*)"/g)].flatMap((match) => JSON.parse(match[0]).split(" ")).filter(Boolean);
+/**
+* The kinds reported as `not-foldable`, which is permanent rather than a limit of this
+* phase — hence separate from `unsupported-kind`, where a slot recipe lands because it
+* resolves to one class per slot rather than to a single string.
+*/
+const UNFOLDABLE_TYPES = new Set([
+	"cva",
+	"sva",
+	"token"
+]);
+/** Element surfaces `foldJsx` handles, as opposed to call sites. */
+const JSX_TYPES = new Set(["jsx-factory", "jsx-pattern"]);
+/**
+* Source files a box tree reaches, other than the one being folded.
+*
+* When the extractor resolves an imported identifier it boxes the *declaration's*
+* node, which lives in the defining module. Walking the tree and reading each node's
+* source file therefore recovers exactly the files a fold depended on — narrower and
+* more accurate than treating every import of the module as a dependency.
+*/
+const collectSourceFiles = (node, ctx, seen = /* @__PURE__ */ new Set()) => {
+	if (!node || seen.has(node)) return;
+	seen.add(node);
+	ctx.record(node.getNode?.());
+	if (_bamboocss_extractor.box.isMap(node)) {
+		for (const child of node.value.values()) collectSourceFiles(child, ctx, seen);
+		return;
+	}
+	if (_bamboocss_extractor.box.isArray(node)) for (const child of node.value) collectSourceFiles(child, ctx, seen);
+};
+const createDependencyScan = (ownFile) => {
+	const results = /* @__PURE__ */ new Set();
+	const paths = /* @__PURE__ */ new Map();
+	return {
+		results,
+		record(node) {
+			if (!node) return;
+			const sourceFile = node.getSourceFile();
+			if (sourceFile === ownFile) return;
+			let path = paths.get(sourceFile);
+			if (path === void 0) {
+				path = sourceFile.getFilePath();
+				paths.set(sourceFile, path);
+			}
+			if (path) results.add(path);
+		}
+	};
+};
+/**
+* The call expression to replace.
+*
+* `extractCallExpressionArguments` boxes the argument list against the call node and
+* pushes `[callNode, argNode]` onto each argument's stack, so the call is reachable
+* from either shape the parser stores: the argument array (multi-arg) or the first
+* argument's map (single-arg).
+*/
+const findCallExpression = (node) => {
+	const own = node.getNode?.();
+	if (own && ts_morph.Node.isCallExpression(own)) return own;
+	const stack = node.getStack?.() ?? [];
+	for (const entry of stack) if (ts_morph.Node.isCallExpression(entry)) return entry;
+	let current = own;
+	for (let depth = 0; current && depth < 3; depth++) {
+		if (ts_morph.Node.isCallExpression(current)) return current;
+		current = current.getParent();
+	}
+};
+/**
+* `css.raw(...)` must keep returning a style object — folding it to a class string
+* breaks every caller composing those styles. The file matcher strips `.raw` when it
+* normalizes function names, so the parser result cannot tell us; the callee text can.
+*/
+const isRawCall = (call) => {
+	if (!ts_morph.Node.isCallExpression(call)) return false;
+	const callee = call.getExpression().getText();
+	return callee === "raw" || callee.endsWith(".raw");
+};
+/** The identifier a callee is rooted at: `css` for `css(…)`, `panda` for `panda.css(…)`. */
+const calleeRootName = (call) => {
+	if (!ts_morph.Node.isCallExpression(call)) return void 0;
+	let current = call.getExpression();
+	while (ts_morph.Node.isPropertyAccessExpression(current)) current = current.getExpression();
+	return ts_morph.Node.isIdentifier(current) ? current.getText() : void 0;
+};
+/**
+* The identifier a JSX tag is rooted at: `styled` for `<styled.div>`, `bamboo` for
+* `<bamboo.styled.div>`. The same question `calleeRootName` answers for a call, and it
+* feeds the same import and shadowing checks.
+*/
+const tagRootName = (element) => {
+	if (!ts_morph.Node.isJsxOpeningElement(element) && !ts_morph.Node.isJsxSelfClosingElement(element)) return void 0;
+	let current = element.getTagNameNode();
+	while (ts_morph.Node.isPropertyAccessExpression(current)) current = current.getExpression();
+	return ts_morph.Node.isIdentifier(current) ? current.getText() : void 0;
+};
+/**
+* Local names a module binds to an import of bamboo's own generated system.
+*
+* The parser matches by name and asks neither question this does — deliberately, since
+* for CSS extraction the worst case is a few unused rules. A transform cannot be that
+* relaxed, and it needs both halves:
+*
+* - imported at all, or a user's `const css = (s) => JSON.stringify(s)` gets rewritten
+* - imported *from bamboo*, or `import { css } from '@emotion/css'` does, which is the
+*   likelier accident of the two since a migrating project has both in the tree
+*
+* Answered together and once per file, because the scan is the expensive part and both
+* answers fall out of the same pass. Per call site instead of per file, this scan
+* measured +74% on the largest sandbox module.
+*/
+const bambooImportedNames = (sourceFile, ctx) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		const mod = declaration.getModuleSpecifierValue();
+		for (const named of declaration.getNamedImports()) {
+			const name = named.getNameNode().getText();
+			const alias = named.getAliasNode()?.getText() ?? name;
+			if (ctx.imports.match({
+				mod,
+				name,
+				alias
+			})) names.add(alias);
+		}
+		const namespace = declaration.getNamespaceImport();
+		if (namespace) {
+			const alias = namespace.getText();
+			if (ctx.imports.match({
+				mod,
+				name: alias,
+				alias,
+				kind: "namespace"
+			})) names.add(alias);
+		}
+	}
+	return names;
+};
+/**
+* Is the callee the imported binding, or a local one that shadows it?
+*
+* A block-scoped binding of the same name is legal alongside the import, and it is
+* the one the call actually reaches. Walking ancestors is the precise answer; the
+* cost is kept off the common path by only inspecting the two node kinds that can
+* introduce a binding. Ancestors of a call in JSX are overwhelmingly elements and
+* attributes, which match neither and cost nothing.
+*/
+const isShadowed = (call, name) => {
+	for (let node = call.getParent(); node; node = node.getParent()) {
+		if (ts_morph.Node.isSourceFile(node)) return false;
+		if (bindsName(node, name)) return true;
+	}
+	return false;
+};
+/**
+* Does a binding name introduce `name`?
+*
+* A plain identifier check is not enough: destructuring is the likeliest way a
+* same-named local reaches a call, since `({ css }) => css(…)` is what a component
+* taking a `css` prop looks like. Nested and rest elements bind too, so the pattern
+* is walked rather than inspected at the top level.
+*/
+const bindingIntroduces = (nameNode, name) => {
+	if (!nameNode) return false;
+	if (ts_morph.Node.isIdentifier(nameNode)) return nameNode.getText() === name;
+	if (ts_morph.Node.isObjectBindingPattern(nameNode) || ts_morph.Node.isArrayBindingPattern(nameNode)) return nameNode.getElements().some((element) => ts_morph.Node.isBindingElement(element) && bindingIntroduces(element.getNameNode(), name));
+	return false;
+};
+const declarationsBind = (list, name) => ts_morph.Node.isVariableDeclarationList(list) && list.getDeclarations().some((declaration) => bindingIntroduces(declaration.getNameNode(), name));
+const bindsName = (scope, name) => {
+	if (ts_morph.Node.isBlock(scope)) return scope.getStatements().some((statement) => statementBinds(statement, name));
+	if (ts_morph.Node.isFunctionDeclaration(scope) || ts_morph.Node.isArrowFunction(scope) || ts_morph.Node.isFunctionExpression(scope) || ts_morph.Node.isMethodDeclaration(scope)) return scope.getParameters().some((parameter) => bindingIntroduces(parameter.getNameNode(), name));
+	if (ts_morph.Node.isCatchClause(scope)) return bindingIntroduces(scope.getVariableDeclaration()?.getNameNode(), name);
+	if (ts_morph.Node.isForStatement(scope) || ts_morph.Node.isForOfStatement(scope) || ts_morph.Node.isForInStatement(scope)) return declarationsBind(scope.getInitializer(), name);
+	return false;
+};
+const statementBinds = (statement, name) => {
+	if (ts_morph.Node.isVariableStatement(statement)) return statement.getDeclarations().some((declaration) => bindingIntroduces(declaration.getNameNode(), name));
+	if (ts_morph.Node.isFunctionDeclaration(statement) || ts_morph.Node.isClassDeclaration(statement)) return statement.getNameNode()?.getText() === name;
+	return false;
+};
+const hasStyles = (data) => data.length > 0 && data.every((entry) => entry != null && typeof entry === "object");
+/**
+* Pair each source argument with the box the parser stored for it, and require the
+* box to account for all of it. The parser keeps either the whole argument array
+* (multi-arg calls) or just the first argument's map (single-arg calls).
+*/
+const argumentsAccountedFor = (call, boxNode) => {
+	if (!ts_morph.Node.isCallExpression(call)) return false;
+	const args = call.getArguments();
+	if (args.length === 0) return false;
+	if (_bamboocss_extractor.box.isArray(boxNode) && boxNode.getNode() === call) {
+		if (boxNode.value.length !== args.length) return false;
+		return args.every((arg, index) => accountsForSource(arg, boxNode.value[index]));
+	}
+	if (args.length !== 1) return false;
+	return accountsForSource(args[0], boxNode);
+};
+const foldSource = (options) => {
+	const { ctx, code, parserResult, jsx = true, partial: partial_ = true, runtimeCss = createRuntimeCss(ctx) } = options;
+	/**
+	* Recover the static half of a call the whole-call path gave up on. Only a
+	* single-argument `css()` qualifies: a pattern or recipe call takes props rather than a
+	* style object, and a multi-argument `css` is later-wins across the whole object.
+	*/
+	const tryPartial = (item, call, rootName) => {
+		if (item.type !== "css" || !rootName) return void 0;
+		if (!ts_morph.Node.isCallExpression(call)) return void 0;
+		const args = call.getArguments();
+		if (args.length !== 1) return void 0;
+		const unboxed = _bamboocss_extractor.box.isMap(item.box) ? (0, _bamboocss_extractor.unbox)(item.box) : void 0;
+		if (!unboxed?.raw) return void 0;
+		const raw = unboxed.raw;
+		if (unboxed.spreadConditions?.length) return void 0;
+		const argument = args[0];
+		if (!argument || !ts_morph.Node.isObjectLiteralExpression(argument)) return void 0;
+		const leafName = findBambooBinding(call, LEAF_HELPER, isBambooCssModule, isShadowed);
+		const plan_ = (allowLeaf) => {
+			try {
+				return planPartialFold(argument, item.box, raw, {
+					ctx,
+					runtimeCss,
+					isAccounted: accountsForSource,
+					isStatic: (boxNode) => isStaticBox(boxNode),
+					allowLeaf,
+					leafName: leafName ?? "cssLeaf"
+				});
+			} catch {
+				return;
+			}
+		};
+		let plan = plan_(true);
+		if (!plan) return void 0;
+		const usesLeaf = () => plan.finite.some((entry) => !entry.emitsLiterals);
+		let cx = ensureCxImport(call, rootName, isBambooCssModule, isGeneratedCssModule, isShadowed, usesLeaf() ? [LEAF_HELPER] : []);
+		if (!cx && usesLeaf()) {
+			plan = plan_(false);
+			if (!plan) return void 0;
+			cx = ensureCxImport(call, rootName, isBambooCssModule, isGeneratedCssModule, isShadowed);
+		}
+		if (!cx) return void 0;
+		const callee = call.getExpression().getText();
+		const runtimePart = plan.dynamicText ? `${callee}(${plan.dynamicText})` : void 0;
+		const runtimeParts = runtimePart ? [runtimePart] : [];
+		const lowered = plan.finite.map((entry) => entry.expression);
+		const parts = [...plan.className ? [JSON.stringify(plan.className)] : [], ...plan.finiteFirst ? [...lowered, ...runtimeParts] : [...runtimeParts, ...lowered]];
+		if (!parts.length || parts.length === 1 && runtimePart) return void 0;
+		return {
+			className: plan.className,
+			classNames: [plan.className, ...plan.finite.filter((entry) => entry.emitsLiterals).flatMap((entry) => literalsIn(entry.expression))].filter(Boolean),
+			replacement: `${cx.name}(${parts.join(", ")})`,
+			insert: cx.insert
+		};
+	};
+	const runtimeRecipe = createRuntimeRecipe(ctx, runtimeCss);
+	/**
+	* 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 partial folding, 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;
+	const trim = (value) => value.replaceAll("\\", "/").replace(/^(?:\.\.?\/)+/, "").replace(/\/$/, "");
+	const matchesModule = (mod, entries) => {
+		const candidates = [mod];
+		if (pathMappings) {
+			const resolved = (0, _bamboocss_config_ts_path.resolveTsPathPattern)(pathMappings, mod);
+			if (resolved) candidates.push(resolved);
+		}
+		return candidates.some((candidate) => {
+			const normalized = trim(candidate);
+			return entries.some((entry) => {
+				const target = trim(entry);
+				return normalized === target || normalized.endsWith(`/${target}`);
+			});
+		});
+	};
+	const isBambooCssModule = (mod) => matchesModule(mod, cssModules);
+	const isGeneratedCssModule = (mod) => matchesModule(mod, [generatedCssModule]);
+	const jsxDeps = {
+		isBambooCssModule,
+		isGeneratedCssModule,
+		isShadowed
+	};
+	const folded = [];
+	const skipped = [];
+	const candidates = [];
+	const seenRanges = /* @__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 (jsx && JSX_TYPES.has(type)) {
+			const element = item.box.getNode?.();
+			if (!element) continue;
+			const elementStart = element.getStart();
+			const elementEnd = element.getEnd();
+			if (code.slice(elementStart, elementEnd) !== element.getText()) {
+				skipped.push({
+					name,
+					reason: "no-call-expression",
+					start: 0,
+					end: 0
+				});
+				continue;
+			}
+			const rootName = tagRootName(element);
+			if (!rootName || !importsFor(element.getSourceFile()).has(rootName) || isShadowed(element, rootName)) {
+				skipped.push({
+					name,
+					reason: "not-imported",
+					start: elementStart,
+					end: elementEnd
+				});
+				continue;
+			}
+			const plan = type === "jsx-pattern" ? planPatternFold(item, ctx, runtimeCss) : planJsxFold(item, ctx, runtimeCss, partial_ ? jsxDeps : void 0);
+			if ("reason" in plan) {
+				skipped.push({
+					name,
+					reason: plan.reason,
+					start: elementStart,
+					end: elementEnd
+				});
+				continue;
+			}
+			candidates.push({
+				item,
+				node: element,
+				edits: plan.edits,
+				className: plan.className,
+				insert: plan.insert,
+				start: plan.start,
+				end: plan.end
+			});
+			continue;
+		}
+		if (!FOLDABLE_TYPES.has(type)) {
+			if (call && UNFOLDABLE_TYPES.has(type)) skipped.push({
+				name,
+				reason: "not-foldable",
+				start: call.getStart(),
+				end: call.getEnd()
+			});
+			continue;
+		}
+		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);
+		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 (!isStaticBox(item.box) || !hasStyles(item.data) || !argumentsAccountedFor(call, item.box)) {
+			const partial = partial_ ? tryPartial(item, call, rootName) : void 0;
+			if (partial) {
+				candidates.push({
+					item,
+					call,
+					node: call,
+					start,
+					end,
+					...partial
+				});
+				continue;
+			}
+			skipped.push({
+				name,
+				reason: "dynamic",
+				start,
+				end
+			});
+			continue;
+		}
+		candidates.push({
+			item,
+			call,
+			node: call,
+			start,
+			end
+		});
+	}
+	if (candidates.length === 0) return {
+		code,
+		map: null,
+		folded,
+		skipped,
+		dependencies: []
+	};
+	const dependencyScan = createDependencyScan(candidates[0].node.getSourceFile());
+	candidates.sort((a, b) => a.start - b.start || b.end - a.end);
+	const magic = new magic_string.default(code);
+	const insertedNames = /* @__PURE__ */ new Set();
+	const applyInsert = (insert) => {
+		if (!insert) return;
+		const missing = insert.names.filter((name) => !insertedNames.has(name));
+		if (!missing.length) return;
+		magic.appendLeft(insert.pos, missing.map((name) => `, ${name}`).join(""));
+		for (const name of missing) insertedNames.add(name);
+	};
+	const applied = [];
+	const collides = (edits) => edits.some(([start, end]) => applied.some(([from, to]) => start < to && from < end));
+	for (const candidate of candidates) {
+		const { item, start, end } = candidate;
+		const name = item.name ?? item.type ?? "";
+		const ranges = candidate.edits ? candidate.edits.map((edit) => [edit.start, edit.end]) : [[start, end]];
+		if (collides(ranges)) {
+			skipped.push({
+				name,
+				reason: "overlapping",
+				start,
+				end
+			});
+			continue;
+		}
+		if (candidate.replacement) {
+			magic.overwrite(start, end, candidate.replacement);
+			applyInsert(candidate.insert);
+			applied.push(...ranges);
+			folded.push({
+				name,
+				className: candidate.className,
+				classNames: (candidate.classNames ?? [candidate.className]).filter(Boolean),
+				start,
+				end
+			});
+			collectSourceFiles(item.box, dependencyScan);
+			continue;
+		}
+		if (candidate.edits) {
+			for (const edit of candidate.edits) magic.overwrite(edit.start, edit.end, edit.text);
+			applyInsert(candidate.insert);
+			applied.push(...ranges);
+			folded.push({
+				name,
+				className: candidate.className,
+				classNames: (candidate.classNames ?? [candidate.className]).filter(Boolean),
+				start,
+				end
+			});
+			collectSourceFiles(item.box, dependencyScan);
+			continue;
+		}
+		let className;
+		try {
+			if (item.type === "pattern") className = runtimeCss(...item.data.map((entry) => ctx.patterns.transform(name, entry)));
+			else if (item.type === "recipe") {
+				const resolved = item.data.length === 1 ? runtimeRecipe(name, item.data[0]) : void 0;
+				if (resolved == null) {
+					skipped.push({
+						name,
+						reason: "unsupported-kind",
+						start,
+						end
+					});
+					continue;
+				}
+				className = resolved;
+			} else className = runtimeCss(...item.data);
+		} catch {
+			skipped.push({
+				name,
+				reason: "dynamic",
+				start,
+				end
+			});
+			continue;
+		}
+		if (!className) {
+			skipped.push({
+				name,
+				reason: "empty",
+				start,
+				end
+			});
+			continue;
+		}
+		magic.overwrite(start, end, JSON.stringify(className));
+		applied.push(...ranges);
+		folded.push({
+			name,
+			className,
+			classNames: [className],
+			start,
+			end
+		});
+		collectSourceFiles(item.box, dependencyScan);
+	}
+	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: Array.from(dependencyScan.results)
+	};
+};
+//#endregion
+//#region src/plugin.ts
+const DEFAULT_EXTENSIONS = /\.(?:[cm]?[jt]sx?)$/;
+const NODE_MODULES = /node_modules/;
+const shouldTransform = (id) => {
+	if (id.startsWith("\0")) return false;
+	const [filePath] = id.split("?");
+	if (!filePath) return false;
+	if (NODE_MODULES.test(filePath)) return false;
+	return DEFAULT_EXTENSIONS.test(filePath);
+};
+/**
+* Is this file part of the generated `styled-system` rather than the user's source?
+*
+* Resolved to a path and compared as a prefix, rather than by looking for the outdir's
+* last segment somewhere in the file's path. `outdir` is a user setting: a project that
+* generates into `src/styles` would otherwise have *every* directory named `styles`
+* treated as generated, and folding would quietly stop happening in the one place an app
+* is most likely to keep its style calls.
+*
+* `resolve` rather than `join`, so an absolute `outdir` is honoured rather than appended
+* to the cwd.
+*/
+const isGeneratedOutput = (filePath, ctx) => {
+	const { cwd, outdir } = ctx.config;
+	if (!outdir) return false;
+	const slashed = (value) => value.replaceAll("\\", "/").replace(/\/$/, "");
+	const root = slashed((0, node_path.resolve)(cwd, outdir));
+	const file = slashed(filePath);
+	return file === root || file.startsWith(`${root}/`);
+};
+const formatSkipped = (id, skipped) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const entry of skipped) counts.set(entry.reason, (counts.get(entry.reason) ?? 0) + 1);
+	return `${id}: ${Array.from(counts.entries()).map(([reason, count]) => `${reason}=${count}`).join(" ")}`;
+};
+/**
+* Vite integration for Bamboo CSS.
+*
+* This plugin does not emit CSS — keep your existing PostCSS setup for that. Its only
+* job is the optional build-time fold.
+*
+* It runs with `enforce: 'pre'` so it sees module source as close as possible to what
+* the CSS extractor reads off disk. A plugin that rewrites style calls before bamboo
+* sees them would otherwise make the two disagree, and a folded class could end up
+* with no matching rule.
+*/
+const bamboocss = (options = {}) => {
+	const { transform = false, jsx, partial, configPath, cwd, reportSkipped = false, reportSummary = true } = options;
+	/** Totals across the build, for the summary. */
+	const totals = {
+		folded: 0,
+		files: 0,
+		filesWithFolds: 0,
+		skipped: /* @__PURE__ */ new Map()
+	};
+	let ctx;
+	let runtimeCss;
+	let setup;
+	const ensureContext = async () => {
+		if (!setup) setup = (0, _bamboocss_node.loadConfigAndCreateContext)({
+			configPath,
+			cwd
+		}).then((loaded) => {
+			ctx = loaded;
+			runtimeCss = createRuntimeCss(loaded);
+		});
+		await setup;
+	};
+	return {
+		name: "bamboocss",
+		enforce: "pre",
+		apply: "build",
+		async buildStart() {
+			if (!transform) return;
+			totals.folded = 0;
+			totals.files = 0;
+			totals.filesWithFolds = 0;
+			totals.skipped.clear();
+			await ensureContext();
+		},
+		async transform(code, id) {
+			if (!transform) return null;
+			if (!shouldTransform(id)) return null;
+			await ensureContext();
+			if (!ctx || !runtimeCss) return null;
+			const [filePath] = id.split("?");
+			if (isGeneratedOutput(filePath, ctx)) return null;
+			let result;
+			try {
+				ctx.project.addSourceFile(filePath, code);
+				const parserResult = ctx.project.parseSourceFile(filePath);
+				if (!parserResult || parserResult.isEmpty()) return null;
+				result = foldSource({
+					ctx,
+					code,
+					parserResult,
+					filePath,
+					runtimeCss,
+					jsx,
+					partial
+				});
+			} catch (error) {
+				_bamboocss_logger.logger.caughtError("vite:transform", `Failed to fold ${filePath}`, error);
+				return null;
+			}
+			totals.files++;
+			totals.folded += result.folded.length;
+			if (result.folded.length) totals.filesWithFolds++;
+			for (const entry of result.skipped) totals.skipped.set(entry.reason, (totals.skipped.get(entry.reason) ?? 0) + 1);
+			if (reportSkipped && result.skipped.length) _bamboocss_logger.logger.info("vite:transform", formatSkipped(filePath, result.skipped));
+			for (const dependency of result.dependencies) this.addWatchFile?.(dependency);
+			if (!result.folded.length) return null;
+			_bamboocss_logger.logger.debug("vite:transform", `Folded ${result.folded.length} call(s) in ${filePath}`);
+			return {
+				code: result.code,
+				map: result.map
+			};
+		},
+		buildEnd() {
+			if (!transform || !reportSummary) return;
+			const declined = Array.from(totals.skipped.values()).reduce((sum, count) => sum + count, 0);
+			const total = totals.folded + declined;
+			if (!total) return;
+			const share = Math.round(totals.folded / total * 100);
+			const reasons = Array.from(totals.skipped.entries()).sort((a, b) => b[1] - a[1]).map(([reason, count]) => `${reason}=${count}`).join(" ");
+			_bamboocss_logger.logger.info("vite:transform", `Folded ${totals.folded}/${total} (${share}%) across ${totals.filesWithFolds}/${totals.files} files` + (reasons ? ` — declined: ${reasons}` : ""));
+		}
+	};
+};
+//#endregion
+exports.bamboocss = bamboocss;
+exports.createRuntimeCss = createRuntimeCss;
+exports.default = bamboocss;
+exports.foldSource = foldSource;