@bamboocss/vite 1.26.0 → 1.28.1

package/dist/index.cjs

@@ -30,10 +30,10 @@ 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 node_path = require("node:path");
 let ts_morph = require("ts-morph");
 let _bamboocss_core = require("@bamboocss/core");
 let _bamboocss_shared = require("@bamboocss/shared");
-let node_path = require("node:path");
 //#region src/css.ts
 /**
 * What a project imports to get the stylesheet.
@@ -850,7 +850,7 @@ const propertyKey = (nameNode) => {
 * 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) => {
+const ensureRecipeHelperImport = (imported, call, isBambooCssModule, isGeneratedCssModule, isShadowed, newImportModule) => {
 	const sourceFile = call.getSourceFile();
 	let host;
 	for (const declaration of sourceFile.getImportDeclarations()) {
@@ -866,9 +866,21 @@ const ensureRecipeHelperImport = (imported, call, isBambooCssModule, isGenerated
 		}
 		if (!host && isGeneratedCssModule(mod) && declaration.getNamedImports().length > 0) host = declaration;
 	}
-	if (!host) return void 0;
+	if (!host && !newImportModule) 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: newImportModule
+			}
+		};
+	}
 	const last = host.getNamedImports().at(-1);
 	if (!last) return void 0;
 	return {
@@ -928,6 +940,13 @@ const lowerRecipeCall = (call, entry, ctx, isInert, resolvedSelection) => {
 		/**
 		* `input(variantProps)` — a selection the build cannot see inside.
 		*
+		* Inline recipes only. `cva` resolves a selection with `getRecipeClassNames`, which reads
+		* a variant value as a key and so cannot take a conditional — a `{ base, md }` object finds
+		* no entry and names no class, exactly as `cvaPick` does. A **config** recipe routes its
+		* selection through `createCss`, which *expands* conditions into one class per breakpoint,
+		* so a scalar lookup silently drops them. That is why this lowering is not applied to
+		* config recipes: for a dynamic axis the build cannot know which kind of value arrives.
+		*
 		* The classes are still knowable: a recipe emits one per declared variant, so the call is
 		* one term per variant reading that binding. This is the shape a wrapper component takes,
 		* where the variants are the component's public API and cannot be literals by definition.
@@ -1111,6 +1130,9 @@ const createRuntimeCss = (ctx) => {
 * 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.var()` read
+* different ones and building a second table would pay the same per-project cost twice.
 */
 const tokenValues = /* @__PURE__ */ new WeakMap();
 const tokenValuesFor = (ctx) => {
@@ -1119,16 +1141,29 @@ const tokenValuesFor = (ctx) => {
 	values = /* @__PURE__ */ new Map();
 	for (const token of ctx.tokens.allTokens) {
 		const { varRef, isVirtual, condition } = token.extensions;
-		values.set(token.name, isVirtual || condition !== "base" ? varRef : token.value);
+		values.set(token.name, {
+			value: isVirtual || condition !== "base" ? varRef : token.value,
+			variable: varRef
+		});
 	}
 	tokenValues.set(ctx, values);
 	return values;
 };
 const createRuntimeToken = (ctx) => (path) => {
-	const value = tokenValuesFor(ctx).get(path);
+	const value = tokenValuesFor(ctx).get(path)?.value;
 	return typeof value === "string" ? value : void 0;
 };
 /**
+* The generated runtime's `token.var`, rebuilt in-process.
+*
+* Mirrors `tokenVar` in `generateTokenJs`, which reads the `variable` half of the same
+* entry `token()` reads the `value` half of. That half is `varRef` for every token
+* regardless of condition, so unlike `createRuntimeToken` 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 this the more foldable of the two.
+*/
+const createRuntimeTokenVar = (ctx) => (path) => tokenValuesFor(ctx).get(path)?.variable || void 0;
+/**
 * Whether a slot's class is independent of the variant props.
 *
 * A scoped slot recipe delivers variants through `@scope` rules anchored on an enclosing
@@ -1175,11 +1210,24 @@ const createRuntimeRecipe = (ctx) => {
 				}
 			}
 		});
-		const recipeStyles = isConstantSlot ? { [className]: "__ignore__" } : {
+		const declaredValues = config.variants ?? {};
+		/**
+		* The same filter the generated `createRecipe` applies: only a value the config declares
+		* names a class.
+		*
+		* Scalars only — a conditional or responsive value is an object of leaves, and the leaves
+		* are what name classes when `createCss` walks them.
+		*/
+		const onlyDeclared = (styles) => Object.fromEntries(Object.entries(styles).filter(([prop, value]) => {
+			if (prop === className) return true;
+			if (value === null || typeof value === "object") return true;
+			return Object.hasOwn(declaredValues, prop) && Object.hasOwn(declaredValues[prop] ?? {}, String(value));
+		}));
+		const recipeStyles = isConstantSlot ? { [className]: "__ignore__" } : onlyDeclared({
 			[className]: "__ignore__",
 			...defaultVariants,
 			...(0, _bamboocss_shared.compact)(variants)
-		};
+		});
 		if (compoundVariants.length > 0 && Object.keys(recipeStyles).some((prop) => typeof variants[prop] === "object")) return;
 		if (isSlotRecipe) {
 			const evaluated = anchors.length > 0 ? anchors : config.slots;
@@ -1219,6 +1267,22 @@ const literalsIn = (expression) => [...expression.matchAll(/"((?:[^"\\]|\\.)*)"/
 */
 const UNFOLDABLE_TYPES = new Set(["cva", "sva"]);
 /**
+* The skip reasons that leave a `css()`-family call in the output.
+*
+* `overlapping` is handled by the enclosing fold, and `not-imported` is somebody else's
+* function of the same name — neither leaves a call of ours. `not-foldable` is a `cva`/`sva`
+* definition, which keeps the recipe runtime rather than the css engine; see `strict`.
+*/
+const SURVIVES_TO_RUNTIME = new Set([
+	"dynamic",
+	"runtime-binding",
+	"raw-call",
+	"unsupported-kind",
+	"no-call-expression",
+	"empty",
+	"unresolved-token"
+]);
+/**
 * 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.
@@ -1231,6 +1295,65 @@ const UNFOLDABLE_TYPES = new Set(["cva", "sva"]);
 */
 const RECIPE_CALL_TYPE = "cva-call";
 /**
+* An identifier that actually reads the binding.
+*
+* `getDescendantsOfKind(Identifier)` yields every name in the file, and most of them bind or
+* label rather than read: a JSX tag (`<button/>` against a recipe called `button`), an object
+* key, a property name, a declaration. Counting those failed builds on modules that had
+* folded completely — and `button`, `input`, `label`, `select`, `table`, `dialog` and `form`
+* are all ordinary recipe names as well as intrinsic elements.
+*
+* A type position is excluded for a different reason: it is erased, and with it the import.
+*/
+const isValueReference = (identifier) => {
+	const parent = identifier.getParent();
+	if (!parent) return false;
+	if (ts_morph.Node.isImportSpecifier(parent) || ts_morph.Node.isExportSpecifier(parent)) return false;
+	if (ts_morph.Node.isImportClause(parent) || ts_morph.Node.isNamespaceImport(parent)) return false;
+	if (ts_morph.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === identifier) return false;
+	if (ts_morph.Node.isQualifiedName(parent) && parent.getRight() === identifier) return false;
+	if (ts_morph.Node.isPropertyAssignment(parent) && parent.getNameNode() === identifier) return false;
+	if (ts_morph.Node.isMethodDeclaration(parent) || ts_morph.Node.isPropertyDeclaration(parent) || ts_morph.Node.isGetAccessorDeclaration(parent) || ts_morph.Node.isSetAccessorDeclaration(parent) || ts_morph.Node.isMethodSignature(parent) || ts_morph.Node.isPropertySignature(parent) || ts_morph.Node.isEnumMember(parent)) {
+		if (parent.getNameNode() === identifier) return false;
+	}
+	if (ts_morph.Node.isLabeledStatement(parent) || ts_morph.Node.isBreakStatement(parent) || ts_morph.Node.isContinueStatement(parent)) return false;
+	if (ts_morph.Node.isJsxOpeningElement(parent) || ts_morph.Node.isJsxSelfClosingElement(parent) || ts_morph.Node.isJsxClosingElement(parent)) {
+		if (parent.getTagNameNode() === identifier) return identifier.getText()[0] === identifier.getText()[0]?.toUpperCase();
+	}
+	if (ts_morph.Node.isJsxAttribute(parent)) return false;
+	if (ts_morph.Node.isBindingElement(parent) && parent.getPropertyNameNode() === identifier) return false;
+	if ((ts_morph.Node.isVariableDeclaration(parent) || ts_morph.Node.isParameterDeclaration(parent) || ts_morph.Node.isBindingElement(parent) || ts_morph.Node.isFunctionDeclaration(parent) || ts_morph.Node.isClassDeclaration(parent)) && parent.getNameNode() === identifier) return false;
+	return !identifier.getFirstAncestor((ancestor) => ts_morph.Node.isTypeNode(ancestor) || ts_morph.Node.isTypeAliasDeclaration(ancestor) || ts_morph.Node.isInterfaceDeclaration(ancestor));
+};
+/**
+* Imports a surviving reference to is not a failure.
+*
+* The first four are what the fold itself writes; all live in `cx` and pull no engine, so a
+* reference to one is the fold having worked.
+*
+* `cva` and `sva` are there for the reason `SURVIVES_TO_RUNTIME` omits `not-foldable`: a
+* recipe *definition* cannot fold to a class string and never could, and what it keeps is the
+* recipe runtime rather than the css engine — which `strict` accepts. Their unfoldable
+* invocations are reported separately, as `recipe-call`.
+*/
+const PERMITTED_BINDINGS = new Set([
+	"cx",
+	"cva",
+	"sva",
+	RECIPE_PICK_HELPER,
+	SPLIT_PROPS_HELPER,
+	LEAF_HELPER
+]);
+/**
+* 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(path, fallback)` evaluates both arguments before the call, so a fold that drops
@@ -1446,7 +1569,7 @@ const argumentsAccountedFor = (call, boxNode) => {
 	return accountsForSource(args[0], boxNode);
 };
 const foldSource = (options) => {
-	const { ctx, code, parserResult, partial: partial_ = true, runtimeCss = createRuntimeCss(ctx) } = options;
+	const { ctx, code, parserResult, partial: partial_ = true, runtimeCss = createRuntimeCss(ctx), parseModule, recipeConfigCache, reportSurvivors, sourceFile: ownSourceFile } = options;
 	/**
 	* Recover the static half of a call the whole-call path gave up on. Only a
 	* single-argument `css()` qualifies: a pattern or recipe call takes props rather than a
@@ -1498,12 +1621,14 @@ const foldSource = (options) => {
 			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
+			insert: cx.insert,
+			runtimeCallee: runtimePart ? callee : void 0
 		};
 	};
 	const runtimeRecipe = createRuntimeRecipe(ctx);
 	const isConstantSlot = createConstantSlotCheck(ctx);
 	const runtimeToken = createRuntimeToken(ctx);
+	const runtimeTokenVar = createRuntimeTokenVar(ctx);
 	/**
 	* Does this specifier name a module that exports the css API, exactly?
 	*
@@ -1528,7 +1653,25 @@ const foldSource = (options) => {
 	*/
 	const generatedCssModule = [ctx.imports.outdir, "css"].join("/");
 	const pathMappings = ctx.conf.tsOptions?.pathMappings;
-	const trim = (value) => value.replaceAll("\\", "/").replace(/^(?:\.\.?\/)+/, "").replace(/\/$/, "");
+	/**
+	* 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) {
@@ -1545,6 +1688,100 @@ const foldSource = (options) => {
 	};
 	const isBambooCssModule = (mod) => matchesModule(mod, cssModules);
 	const isGeneratedCssModule = (mod) => matchesModule(mod, [generatedCssModule]);
+	/**
+	* How *this* module would have to spell the css module, learnt from one that already does.
+	*
+	* A file calling an imported recipe need not import the css module at all, so when the
+	* lowering needs `cvaPick` there is no spelling in the file to copy. The declaring module
+	* necessarily has one — `cva` came from it — and that is the spelling reused here.
+	*
+	* A bare or aliased specifier resolves identically from any file, so it is taken as
+	* written. A relative one is re-based: resolved against the module that wrote it, then
+	* expressed from the module being folded.
+	*/
+	const cssModuleSpecifierFrom = (declaring) => {
+		for (const declaration of declaring.getImportDeclarations()) {
+			if (declaration.isTypeOnly()) continue;
+			const mod = declaration.getModuleSpecifierValue();
+			if (isGeneratedCssModule(mod)) return mod;
+		}
+	};
+	/**
+	* That spelling, said from the module being folded.
+	*
+	* A bare or aliased specifier resolves identically from any file, so it is taken as
+	* written. A relative one is re-based: resolved against the module that wrote it, then
+	* expressed from the module being folded. Pure path arithmetic, so it holds a string
+	* rather than a node — a cached node does not survive the next `addSourceFile`, which
+	* ts-morph implements by forgetting the file's whole tree.
+	*/
+	const rebaseSpecifier = (specifier, declaringPath, consumingPath) => {
+		if (!specifier.startsWith(".")) return specifier;
+		const absolute = (0, node_path.resolve)((0, node_path.dirname)(declaringPath), specifier);
+		const rebased = (0, node_path.relative)((0, node_path.dirname)(consumingPath), absolute).replaceAll("\\", "/");
+		if (!rebased) return void 0;
+		return rebased.startsWith(".") ? rebased : `./${rebased}`;
+	};
+	/**
+	* Configs of one foreign module, parsed once however many of its recipes are called.
+	*
+	* Falls back to a per-call map when the caller supplies none, so the fold stays correct
+	* standalone — only repeated, which is what the shared cache exists to avoid.
+	*/
+	const configsByModule = recipeConfigCache ?? /* @__PURE__ */ new Map();
+	/** The specifier each imported recipe's module used for the css module, when it needs one. */
+	const helperModules = /* @__PURE__ */ new Map();
+	/** Declaring modules a fold read, recorded as paths because their nodes do not persist. */
+	const foreignDependencies = /* @__PURE__ */ new Set();
+	/** Resolutions for this module's own call sites, keyed by the name the call site writes. */
+	const importedRecipes = /* @__PURE__ */ new Map();
+	/**
+	* The config of a recipe this module imports.
+	*
+	* The binding is followed with ts-morph's symbol aliasing rather than by re-reading import
+	* declarations, because that is what already understands the shapes these are reached
+	* through: `export { badge } from './styles'`, `export * from './styles'`, and an alias at
+	* either end. Each hop is an alias symbol, so following them to a non-alias lands on the
+	* declaration wherever it lives.
+	*
+	* The class names do not depend on which module the call is in — `getRecipeIdentity` hashes
+	* the config — so a recipe lowered here produces exactly the string its own module's call
+	* sites produce, and exactly the one the runtime would have.
+	*/
+	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,
+					name: entry.name,
+					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 = [];
@@ -1575,64 +1812,12 @@ const foldSource = (options) => {
 		}
 		return names;
 	};
-	/**
-	* Is this binding the variant half of `<recipe>.splitVariantProps(...)`?
-	*
-	* Read off the declaration rather than the type, so it is the same recipe and the same
-	* destructuring position the source actually wrote.
-	*/
-	const isSplitVariantPropsOf = (binding, recipe) => {
-		for (const declaration of binding.getSourceFile().getDescendantsOfKind(ts_morph.SyntaxKind.VariableDeclaration)) {
-			const nameNode = declaration.getNameNode();
-			if (!ts_morph.Node.isArrayBindingPattern(nameNode)) continue;
-			const first = nameNode.getElements()[0];
-			if (!first || !ts_morph.Node.isBindingElement(first)) continue;
-			if (first.getNameNode().getText() !== binding.getText()) continue;
-			const initializer = declaration.getInitializer();
-			if (!initializer || !ts_morph.Node.isCallExpression(initializer)) return false;
-			const callee = initializer.getExpression();
-			if (!ts_morph.Node.isPropertyAccessExpression(callee)) return false;
-			return callee.getName() === "splitVariantProps" && callee.getExpression().getText() === recipe;
-		}
-		return false;
-	};
-	/**
-	* Lower a config recipe call the same way an inline one lowers.
-	*
-	* The config lives in `ctx.recipes` rather than in the module, and the classes are named
-	* from it identically — so this is the same `lowerRecipeCall`, handed the config from a
-	* different place. Slot recipes are excluded by the caller: they resolve to one class per
-	* slot rather than to a string.
-	*/
-	const lowerConfigRecipeCall = (call, name) => {
-		const config = ctx.recipes.getConfig(name);
-		if (!config || config.slots !== void 0) return void 0;
-		const className = config.className;
-		if (!className) return void 0;
-		if (!ts_morph.Node.isCallExpression(call)) return void 0;
-		const argument = call.getArguments()[0];
-		if (!argument || !ts_morph.Node.isIdentifier(argument) || !isSplitVariantPropsOf(argument, name)) return void 0;
-		const lowered = lowerRecipeCall(call, {
-			config,
-			name: className,
-			box: void 0
-		}, ctx, isInertExpression);
-		if (lowered.kind !== "expression") return void 0;
-		const helper = ensureRecipeHelperImport(RECIPE_PICK_HELPER, call, isBambooCssModule, isGeneratedCssModule, isShadowed);
-		if (!helper) return void 0;
-		return {
-			replacement: helper.name === "cvaPick" ? lowered.expression : lowered.expression.replaceAll(`${RECIPE_PICK_HELPER}(`, `${helper.name}(`),
-			className: lowered.staticClasses,
-			classNames: lowered.classNames,
-			insert: helper.insert
-		};
-	};
 	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") {
+		if (type === "token" || type === "tokenVar") {
 			if (!call) {
 				skipped.push({
 					name,
@@ -1667,7 +1852,18 @@ const foldSource = (options) => {
 				continue;
 			}
 			const callee = ts_morph.Node.isCallExpression(call) ? call.getExpression() : void 0;
-			if (ts_morph.Node.isPropertyAccessExpression(callee) && !ctx.imports.matchers.tokens.match(callee.getNameNode().getText())) {
+			const propertyName = ts_morph.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getText() : void 0;
+			const wantsVar = type === "tokenVar";
+			if (wantsVar !== (propertyName === "var")) {
+				skipped.push({
+					name,
+					reason: "unsupported-kind",
+					start,
+					end
+				});
+				continue;
+			}
+			if (!wantsVar && propertyName !== void 0 && !ctx.imports.matchers.tokens.match(propertyName)) {
 				skipped.push({
 					name,
 					reason: "unsupported-kind",
@@ -1704,7 +1900,7 @@ const foldSource = (options) => {
 				});
 				continue;
 			}
-			const value = runtimeToken(path);
+			const value = wantsVar ? runtimeTokenVar(path) : runtimeToken(path);
 			if (!value) {
 				skipped.push({
 					name,
@@ -1747,6 +1943,10 @@ const foldSource = (options) => {
 						continue;
 					}
 					recipeConfigs ??= collectRecipeConfigs(parserResult);
+					if (!recipeConfigs.has(name) && item.origin) {
+						const imported = resolveImportedRecipe(call, name, item.origin);
+						if (imported) recipeConfigs.set(name, imported);
+					}
 					const tally = recipeCalls.get(name) ?? {
 						seen: 0,
 						lowered: 0
@@ -1757,7 +1957,7 @@ const foldSource = (options) => {
 					const entry = recipeConfigs.get(name);
 					const lowered = lowerRecipeCall(call, entry, ctx, isInertExpression, resolvedSelection);
 					if (lowered.kind === "expression") {
-						const helper = ensureRecipeHelperImport(RECIPE_PICK_HELPER, call, isBambooCssModule, isGeneratedCssModule, isShadowed);
+						const helper = ensureRecipeHelperImport(RECIPE_PICK_HELPER, call, isBambooCssModule, isGeneratedCssModule, isShadowed, helperModules.get(name));
 						if (helper) {
 							tally.lowered++;
 							candidates.push({
@@ -1871,25 +2071,19 @@ const foldSource = (options) => {
 		if (!(ts_morph.Node.isCallExpression(call) && call.getArguments().length === 0 && item.data.length === 1) && !isStaticBox(item.box) || !hasStyles(item.data) || !argumentsAccountedFor(call, item.box)) {
 			const partial = partial_ ? tryPartial(item, call, rootName) : void 0;
 			if (partial) {
-				candidates.push({
-					item,
-					call,
-					node: call,
+				if (reportSurvivors && partial.runtimeCallee) skipped.push({
+					name,
+					reason: "runtime-binding",
 					start,
-					end,
-					...partial
+					end
 				});
-				continue;
-			}
-			const lowered = type === "recipe" && !slot ? lowerConfigRecipeCall(call, name) : void 0;
-			if (lowered) {
 				candidates.push({
 					item,
 					call,
 					node: call,
 					start,
 					end,
-					...lowered
+					...partial
 				});
 				continue;
 			}
@@ -1910,13 +2104,22 @@ const foldSource = (options) => {
 			slot
 		});
 	}
-	if (candidates.length === 0) return {
-		code,
-		map: null,
-		folded,
-		skipped,
-		dependencies: []
-	};
+	/**
+	* Ranges the rewrite actually replaced. Declared before the early return below, because
+	* that return is now also a reporting point: a module with nothing to fold is exactly the
+	* shape `reportSurvivors` exists to catch.
+	*/
+	const applied = [];
+	if (candidates.length === 0) {
+		if (reportSurvivors) reportRuntimeBindings();
+		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);
@@ -1925,10 +2128,9 @@ const foldSource = (options) => {
 		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(""));
+		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 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;
@@ -2020,7 +2222,7 @@ const foldSource = (options) => {
 		});
 		collectSourceFiles(item.box, dependencyScan);
 	}
-	const recipeSourceFile = [...recipeConfigs?.values() ?? []].find((entry) => entry.box)?.box?.getNode?.()?.getSourceFile() ?? candidates[0]?.node.getSourceFile();
+	const recipeSourceFile = candidates[0]?.node.getSourceFile();
 	if (recipeSourceFile) for (const access of recipeSourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.PropertyAccessExpression)) {
 		if (access.getName() !== "splitVariantProps") continue;
 		const target = access.getExpression();
@@ -2042,7 +2244,7 @@ const foldSource = (options) => {
 		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);
+		const helper = ensureRecipeHelperImport(SPLIT_PROPS_HELPER, call, isBambooCssModule, isGeneratedCssModule, isShadowed, helperModules.get(target.getText()));
 		if (!helper) continue;
 		const keys = Object.keys(entry.config.variants ?? {});
 		magic.overwrite(start, end, `${helper.name}(${args[0].getText()}, ${JSON.stringify(keys)})`);
@@ -2060,6 +2262,104 @@ const foldSource = (options) => {
 		if (code.slice(start, call.getEnd()) !== call.getText()) continue;
 		magic.appendLeft(start, "/*#__PURE__*/");
 	}
+	/**
+	* 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 is how `strict` came to pass a build that still shipped the engine.
+	*
+	* The helpers the fold itself writes are excluded: `cx`, `cvaPick`, `splitProps` and the
+	* leaf helper live in `cx` and pull no engine, so a reference to one is the fold working
+	* rather than failing.
+	*/
+	function reportRuntimeBindings() {
+		const sourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile();
+		if (!sourceFile) return;
+		const bambooModules = [
+			...cssModules,
+			...ctx.imports.matchers.recipe?.mods ?? [],
+			...ctx.imports.matchers.pattern?.mods ?? [],
+			...ctx.imports.matchers.tokens?.mods ?? []
+		];
+		/** 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 reported = /* @__PURE__ */ new Set();
+		for (const identifier of sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.Identifier)) {
+			const local = identifier.getText();
+			const imported = watched.get(local);
+			if (imported === void 0 || reported.has(local)) continue;
+			const start = identifier.getStart();
+			if (identifier.getFirstAncestorByKind(ts_morph.SyntaxKind.ImportDeclaration)) continue;
+			if (applied.some(([from, to]) => start >= from && start < to)) continue;
+			if (declined.some(([from, to]) => start >= from && start < to)) continue;
+			if (!isValueReference(identifier)) continue;
+			if (isShadowed(identifier, local)) continue;
+			reported.add(local);
+			skipped.push({
+				name: imported,
+				reason: "runtime-binding",
+				start,
+				end: identifier.getEnd()
+			});
+		}
+	}
+	if (reportSurvivors) reportRuntimeBindings();
 	if (folded.length === 0) return {
 		code,
 		map: null,
@@ -2076,7 +2376,7 @@ const foldSource = (options) => {
 		}),
 		folded,
 		skipped,
-		dependencies: Array.from(dependencyScan.results)
+		dependencies: [...dependencyScan.results, ...foreignDependencies]
 	};
 };
 //#endregion
@@ -2110,21 +2410,6 @@ const isGeneratedOutput = (filePath, ctx) => {
 	const file = slashed(filePath);
 	return file === root || file.startsWith(`${root}/`);
 };
-/**
-* The skip reasons that leave a `css()`-family call in the output.
-*
-* `overlapping` is handled by the enclosing fold, and `not-imported` is somebody else's
-* function of the same name — neither leaves a call of ours. `not-foldable` is a `cva`/`sva`
-* definition, which keeps the recipe runtime rather than the css engine; see `strict`.
-*/
-const SURVIVES_TO_RUNTIME = new Set([
-	"dynamic",
-	"raw-call",
-	"unsupported-kind",
-	"no-call-expression",
-	"empty",
-	"unresolved-token"
-]);
 /** 1-indexed line of a source offset, for an error a user can navigate to. */
 const lineAt = (code, offset) => code.slice(0, offset).split("\n").length;
 const formatSkipped = (id, skipped) => {
@@ -2155,6 +2440,13 @@ const bamboocss = (options = {}) => {
 	};
 	/** Under `strict`, every call that would still reach the runtime. */
 	const survivors = [];
+	/**
+	* Recipe configs read out of modules other than the one being transformed.
+	*
+	* Per build rather than per module: a recipe declared once and imported by fifty components
+	* would otherwise re-parse its module fifty times, which is the transform path.
+	*/
+	const recipeConfigCache = /* @__PURE__ */ new Map();
 	let ctx;
 	let runtimeCss;
 	let setup;
@@ -2182,6 +2474,7 @@ const bamboocss = (options = {}) => {
 			totals.filesWithFolds = 0;
 			totals.skipped.clear();
 			survivors.length = 0;
+			recipeConfigCache.clear();
 			await ensureContext();
 		},
 		/**
@@ -2209,6 +2502,7 @@ const bamboocss = (options = {}) => {
 			if (!shouldTransform(id)) return;
 			const [filePath] = id.split("?");
 			if (!filePath) return;
+			recipeConfigCache.clear();
 			if (change.event === "delete") {
 				ctx.project.removeSourceFile(filePath);
 				return;
@@ -2224,16 +2518,20 @@ const bamboocss = (options = {}) => {
 			if (isGeneratedOutput(filePath, ctx)) return null;
 			let result;
 			try {
-				ctx.project.addSourceFile(filePath, code);
+				const sourceFile = ctx.project.addSourceFile(filePath, code);
 				const parserResult = ctx.project.parseSourceFile(filePath);
-				if (!parserResult || parserResult.isEmpty()) return null;
+				if (!parserResult || parserResult.isEmpty() && !strict) return null;
 				result = foldSource({
 					ctx,
 					code,
 					parserResult,
 					filePath,
 					runtimeCss,
-					partial
+					partial,
+					parseModule: (path) => ctx?.project.parseSourceFile(path),
+					recipeConfigCache,
+					reportSurvivors: strict,
+					sourceFile
 				});
 			} catch (error) {
 				_bamboocss_logger.logger.caughtError("vite:transform", `Failed to fold ${filePath}`, error);
@@ -2277,7 +2575,7 @@ const bamboocss = (options = {}) => {
 					list.push(entry);
 					byFile.set(entry.file, list);
 				}
-				const detail = Array.from(byFile.entries()).map(([file, entries]) => [`  ${file}`, ...entries.map((e) => `    ${e.line}: ${e.name}() — ${e.reason}`)].join("\n")).join("\n");
+				const detail = Array.from(byFile.entries()).map(([file, entries]) => [`  ${file}`, ...entries.map((e) => `    ${e.line}: ${e.name}${e.reason === "runtime-binding" ? "" : "()"} — ${e.reason}`)].join("\n")).join("\n");
 				throw new Error(`bamboocss: ${survivors.length} call(s) could not be folded, and \`strict\` is on.\n\n${detail}\n\nEach one keeps \`styled-system/css\` in the bundle, so the engine cannot be dropped however many other calls folded. Make the values static, move the variation into a \`cva\` variant, or generate them with \`staticCss\` — or set \`strict: false\` to accept the runtime.`);
 			}
 			if (!transform || !reportSummary) return;