@bamboocss/vite 1.37.12 → 1.38.0

package/dist/index.cjs

@@ -94,6 +94,7 @@ const pruneStaticCss = (css, session, { prune = true } = {}) => {
 					if (!className || !prunable.has(className) || used.has(className)) return;
 					candidate.remove();
 					removedAny = true;
+					session.prunedClasses.add(className);
 				});
 			}).processSync(rule.selector);
 		} catch {
@@ -154,6 +155,56 @@ const pruneStaticCss = (css, session, { prune = true } = {}) => {
 	return root.toString();
 };
 //#endregion
+//#region src/static-session.ts
+const createStaticCompilationSession = () => {
+	const session = {
+		utilityLayer: "utilities",
+		sourcemap: false,
+		cssLoaded: false,
+		transformedFiles: /* @__PURE__ */ new Set(),
+		extractedFiles: /* @__PURE__ */ new Set(),
+		prunableClasses: /* @__PURE__ */ new Set(),
+		viewTransitionClasses: /* @__PURE__ */ new Set(),
+		usedClasses: /* @__PURE__ */ new Set(),
+		expectedEnvironments: void 0,
+		startedEnvironments: /* @__PURE__ */ new Set(),
+		prunedClasses: /* @__PURE__ */ new Set(),
+		markClassUsed(className) {
+			for (const token of className.split(" ")) {
+				if (!token) continue;
+				session.usedClasses.add(token.includes("\\") ? token : (0, _bamboocss_shared.esc)(token));
+			}
+		}
+	};
+	return session;
+};
+/**
+* Environments this run intends to build that have not been compiled yet.
+*
+* Empty means everything the run will contribute has been contributed, which is the condition
+* every whole-run judgement here waits for: pruning the stylesheet against reachability, and
+* the two guards that ask whether the compiled modules and the extraction graph agree. Each of
+* those is false about a build in progress and true only about a finished one.
+*
+* Empty is also the answer for a single-environment build, where nothing announced an
+* environment list because there is only ever one — so that path is unchanged.
+*
+* An environment a run declares and then never builds leaves this permanently non-empty, and
+* those judgements are skipped for the run. Every one of them errs towards shipping more CSS
+* or asserting less, so that is the safe direction to be wrong in.
+*/
+const remainingEnvironments = (session) => [...session.expectedEnvironments ?? []].filter((name) => !session.startedEnvironments.has(name));
+const resetStaticCompilationSession = (session) => {
+	session.cssLoaded = false;
+	session.transformedFiles.clear();
+	session.extractedFiles.clear();
+	session.prunableClasses.clear();
+	session.viewTransitionClasses.clear();
+	session.usedClasses.clear();
+	session.startedEnvironments.clear();
+	session.prunedClasses.clear();
+};
+//#endregion
 //#region src/css.ts
 /**
 * What a project imports to get the stylesheet.
@@ -255,32 +306,37 @@ const replaceAssetReferences = (bundle, previous, next, sourcemap) => {
 */
 const carriesGeneratedCss = (output) => output.type === "asset" && output.fileName.endsWith(".css");
 /**
-* Prune and rename compiler-owned CSS, then give changed assets a hash of their final bytes.
+* Prune compiler-owned CSS, then give any sheet whose bytes changed a hash of those bytes.
 *
 * Rollup has already expanded `[hash]` when `generateBundle` runs. Mutating only `source`
 * would therefore leave two different reachable subsets under one CDN key. The extra final
 * hash is not cosmetic: it makes late graph reachability cache-safe.
+*
+* Renaming is therefore not a choice this takes. Pruned bytes under the unpruned sheet's name
+* is the one outcome that must never be reachable, and a sheet nothing was removed from keeps
+* its name because its bytes are unchanged — so "rename" is a consequence of "the bytes moved",
+* not a second option. `prune` is the only knob.
 */
 const optimizeStaticCssAssets = (bundle, session, options = {}) => {
-	const { rename = true } = options;
+	const { prune = true, sourcemap = session.sourcemap } = options;
+	/** Assets in this bundle that carry the generated stylesheet, pruned or not. */
+	let sheets = 0;
 	for (const output of Object.values(bundle)) {
 		if (!carriesGeneratedCss(output)) continue;
 		const source = typeof output.source === "string" ? output.source : Buffer.from(output.source).toString();
 		if (!source.includes("--made-with-bamboo")) continue;
+		sheets++;
+		if (!prune) continue;
 		const optimized = pruneStaticCss(source, session);
 		output.source = optimized;
 		if (optimized === source) continue;
-		if (!rename) {
-			output.source = source;
-			continue;
-		}
 		const nextName = output.fileName.replace(/\.css$/, `.b-${(0, _bamboocss_shared.toHash)(optimized)}.css`);
-		if (nextName === output.fileName) continue;
 		if (bundle[nextName] && bundle[nextName] !== output) throw new Error(`bamboocss: final CSS asset name collision at ${JSON.stringify(nextName)}.`);
 		const previous = output.fileName;
 		output.fileName = nextName;
-		replaceAssetReferences(bundle, previous, nextName, session.sourcemap);
+		replaceAssetReferences(bundle, previous, nextName, sourcemap);
 	}
+	return { sheets };
 };
 /**
 * Serve bamboo's stylesheet as a virtual module, in dev and in build.
@@ -296,7 +352,7 @@ const optimizeStaticCssAssets = (bundle, session, options = {}) => {
 * process just wrote, which is a race on any watch rebuild.
 */
 const bamboocssCss = (options) => {
-	const { configPath, cwd, session, renameCssAsset = true } = options;
+	const { configPath, cwd, session, pruneCss = true } = options;
 	/**
 	* Environments whose `load` served the virtual stylesheet.
 	*
@@ -356,9 +412,32 @@ const bamboocssCss = (options) => {
 	};
 	return {
 		name: "bamboocss:css",
+		/**
+		* One instance for every environment of a build, rather than one per environment.
+		*
+		* Vite re-reads the config file once per environment, so a project that lists this plugin
+		* in `vite.config.ts` — every project — got a *fresh* instance per environment, each with
+		* its own compilation session, context and ts-morph project. Nothing an environment
+		* established could then be seen by the next one, which is the premise the reachability
+		* accounting below is built on, and it also meant the whole config load and extraction
+		* happened once per environment.
+		*/
+		sharedDuringBuild: true,
 		configResolved(config) {
 			command = config.command;
 			session.sourcemap = config.build.sourcemap;
+			if (config.builder && config.environments) session.expectedEnvironments = new Set(Object.keys(config.environments));
+		},
+		/**
+		* The definitive environment list, for a run that reaches `builder.buildApp()` without
+		* configuring `builder` — the shape `vite build` itself takes, where exactly one
+		* environment is set up and pruning is therefore safe.
+		*/
+		buildApp: {
+			order: "pre",
+			async handler(builder) {
+				session.expectedEnvironments = new Set(Object.keys(builder.environments));
+			}
 		},
 		resolveId(id) {
 			const query = queryOf(id);
@@ -398,8 +477,34 @@ const bamboocssCss = (options) => {
 		generateBundle: {
 			order: "post",
 			handler(_, bundle) {
-				optimizeStaticCssAssets(bundle, session, { rename: renameCssAsset });
-				if (!servedEnvironments.has(this.environment?.name ?? "default")) return;
+				const environment = this.environment;
+				/**
+				* Every environment of this run has already had its modules compiled.
+				*
+				* Reachability is what pruning removes rules against, and it is only complete once
+				* nothing is left to contribute to it. The stylesheet is emitted and finalized by the
+				* environment that *imports* it, which in an SSR app is the client — and the client
+				* builds first, before the server environment has transformed a single module. Pruning
+				* there deletes every rule for a class only the server graph reaches, and the pages
+				* link the pruned copy: one project lost 39% of its atoms that way, presenting as
+				* rarely-used classes such as `md:{display:inline-block}` silently not applying.
+				*
+				* So the full extracted stylesheet ships instead, which is what `pruneCss: false` asks
+				* for by hand. Being the last environment is not the common case — frameworks build the
+				* client first — but it is the only one where the answer is knowable, and a framework
+				* that builds its server bundle first does get pruned output.
+				*/
+				const pending = remainingEnvironments(session);
+				const { sheets } = optimizeStaticCssAssets(bundle, session, {
+					prune: pruneCss && pending.length === 0,
+					sourcemap: environment?.config?.build?.sourcemap
+				});
+				if (sheets && !pruneCss) _bamboocss_logger.logger.info("vite", "Reachability pruning is off (`pruneCss: false`). The full extracted stylesheet ships.");
+				else if (sheets && pending.length) _bamboocss_logger.logger.info("vite", `Reachability pruning skipped: the stylesheet is emitted by the ${JSON.stringify(environment?.name ?? "default")} environment, and ${(0, _bamboocss_shared.truncateList)(pending, {
+					unit: "environment",
+					separator: ", "
+				})} ${pending.length === 1 ? "has" : "have"} not been compiled in this run. The full extracted stylesheet ships — nothing is missing from it.`);
+				if (!servedEnvironments.has(environment?.name ?? "default")) return;
 				if (!session.transformedFiles.size) return;
 				if (!Object.values(bundle).some((output) => {
 					if (!carriesGeneratedCss(output)) return false;
@@ -412,6 +517,78 @@ const bamboocssCss = (options) => {
 //#endregion
 //#region src/fold-analysis.ts
 /**
+* Nodes that *compose* a value out of their children rather than computing one.
+*
+* The boundary of the walk below, and the whole of its precision. Climbing through these
+* keeps a value's provenance: `'red.300'` inside `{ color: 'red.300' }` inside a default is
+* still the default's. Anything else — a call, a function body, a JSX element — produces its
+* value by being evaluated, so what is written inside it is an argument to that evaluation
+* and not the enclosing default's value.
+*
+* Without the boundary, `({ cls = css({ color: 'red.300' }) }) => cls` is rejected: the call's
+* own literal argument is syntactically inside a default, so an unbounded walk calls it one.
+* That is correct code, and rejecting it fails the build.
+*/
+const composesValue = (node) => ts_morph.Node.isObjectLiteralExpression(node) || ts_morph.Node.isArrayLiteralExpression(node) || ts_morph.Node.isPropertyAssignment(node) || ts_morph.Node.isShorthandPropertyAssignment(node) || ts_morph.Node.isSpreadAssignment(node) || ts_morph.Node.isSpreadElement(node) || ts_morph.Node.isAsExpression(node) || ts_morph.Node.isParenthesizedExpression(node) || ts_morph.Node.isNonNullExpression(node) || ts_morph.Node.isTypeAssertion(node) || ts_morph.Node.isSatisfiesExpression(node);
+/** Is `inner` written within `outer`? Positions rather than a walk, so it is O(1). */
+const contains = (outer, inner) => outer.getSourceFile() === inner.getSourceFile() && outer.getStart() <= inner.getStart() && inner.getEnd() <= outer.getEnd();
+/**
+* Did this value come from the `= …` of a destructuring binding?
+*
+* `const { tone = 'red.300' } = source` boxes as the literal `'red.300'`: the extractor's
+* `maybeDefinitionValue` tests for an initializer first and returns the boxed default, never
+* reaching the branch that would read `source`. So the default is reported as the value whether
+* or not it is the one that applies.
+*
+* For extraction that is merely optimistic, and deliberately so: a CLI or PostCSS build ships a
+* runtime `css()`, where the default genuinely does apply when the caller omits the key, and it
+* needs a rule behind it. Folding is where the same resolution turns into a wrong answer,
+* because the call is *replaced* by that value.
+*
+* Stops at the first non-composing parent, so a call written inside a default keeps its own
+* provenance, and checks that the binding element was reached through its initializer, so
+* `{ tone = X }`'s name node is not mistaken for its default.
+*/
+const isBindingElementDefault = (node) => {
+	if (node && ts_morph.Node.isCallExpression(node)) return false;
+	let current = node;
+	while (current) {
+		const parent = current.getParent();
+		if (!parent) return false;
+		if (ts_morph.Node.isBindingElement(parent)) return parent.getInitializer() === current;
+		if (!composesValue(parent)) return false;
+		current = parent;
+	}
+	return false;
+};
+/**
+* The same question asked of a whole box, including how it was resolved.
+*
+* The node a box reports is not always the one its value came from — an empty `{}` default
+* boxes against the call rather than against the `{}` — so the resolution stack is consulted
+* too. A binding element reaches that stack by having been resolved *through*, which is the
+* signal the extractor itself reads when one of these is a conditional's test.
+*
+* Only the entries that are binding elements are examined. Walking up from every other entry
+* was tried and never once changed a verdict across the default spellings or the sandbox's own
+* modules, while accounting for most of the parent hops this does — the stack carries nodes
+* that were never resolved through, including a call's own arguments, so walking from them is
+* both the expensive half and the one that reaches conclusions it has no basis for.
+*
+* A binding element without an initializer carries no default to mistrust: `const { tone } =
+* source` either resolves from `source` or does not resolve at all.
+*/
+const isFromBindingDefault = (node) => {
+	const own = node.getNode?.();
+	if (isBindingElementDefault(own)) return true;
+	for (const entry of node.getStack?.() ?? []) {
+		if (!ts_morph.Node.isBindingElement(entry) || !entry.getInitializer()) continue;
+		if (own && contains(entry, own)) continue;
+		return true;
+	}
+	return false;
+};
+/**
 * Statically resolvable means: every box in the tree carries a known value.
 *
 * `unresolvable` is the extractor saying it could not evaluate a node.
@@ -425,6 +602,7 @@ const isStaticBox = (node, seen = /* @__PURE__ */ new Set()) => {
 	seen.add(node);
 	if (_bamboocss_extractor.box.isUnresolvable(node) || _bamboocss_extractor.box.isConditional(node)) return false;
 	if (!("type" in node) || node.type == null) return false;
+	if (isFromBindingDefault(node)) return false;
 	if (_bamboocss_extractor.box.isLiteral(node) && node.value === void 0) {
 		const source = node.getNode?.();
 		return Boolean(source && ts_morph.Node.isIdentifier(source) && source.getText() === "undefined");
@@ -2784,40 +2962,50 @@ const createStaticStyleSetCompiler = (ctx, runtimeCss, allocateClassString = (cl
 	};
 };
 //#endregion
-//#region src/static-session.ts
-const createStaticCompilationSession = () => {
-	const session = {
-		utilityLayer: "utilities",
-		sourcemap: false,
-		cssLoaded: false,
-		transformedFiles: /* @__PURE__ */ new Set(),
-		extractedFiles: /* @__PURE__ */ new Set(),
-		prunableClasses: /* @__PURE__ */ new Set(),
-		viewTransitionClasses: /* @__PURE__ */ new Set(),
-		usedClasses: /* @__PURE__ */ new Set(),
-		markClassUsed(className) {
-			for (const token of className.split(" ")) {
-				if (!token) continue;
-				session.usedClasses.add(token.includes("\\") ? token : (0, _bamboocss_shared.esc)(token));
-			}
-		}
-	};
-	return session;
-};
-const resetStaticCompilationSession = (session) => {
-	session.cssLoaded = false;
-	session.transformedFiles.clear();
-	session.extractedFiles.clear();
-	session.prunableClasses.clear();
-	session.viewTransitionClasses.clear();
-	session.usedClasses.clear();
-};
-//#endregion
 //#region src/plugin.ts
 const DEFAULT_EXTENSIONS = /\.(?:[cm]?[jt]sx?)$/;
 const NODE_MODULES = /node_modules/;
+/**
+* Queries that make Vite serve something other than the module's own source.
+*
+* `./theme.tsx?raw` is a module whose text is `export default "…"`, and `?url`, `?worker` and
+* `?sharedworker` are wrappers of the same kind. The query has to be stripped before the
+* extension is tested — otherwise nothing matches `.tsx` — and stripping it is what made these
+* look like the file itself. The transform then handed the wrapper's text to ts-morph *under
+* the real file's path*, overwriting the parsed module every fold reads for that path.
+*
+* That is not theoretical: a module folding `css(shared)` against a sibling the entry also
+* imported as `?raw` failed the build with "1 call(s) could not be compiled" — the compiler
+* had read `export default "…"` and found no `shared` to resolve. The advice it prints, to
+* make the value statically analyzable, is unfollowable, because the source already was.
+*
+* Whether it bites depends on which of the two ids Rollup transforms last, so the same project
+* can build and then stop building because an import moved.
+*
+* A deny list rather than an allow list of benign queries: dev ids carry `?t=` after an edit
+* and `?import` when a dynamic import is rewritten, and rejecting an unrecognised one of those
+* would silently stop folding a module rather than loudly refuse it.
+*
+* Exactly these four, matching Vite's own `SPECIAL_QUERY_RE`. The list was drafted wider —
+* `?inline`, `?no-inline`, `?worklet`, `?init` — and every one of those was wrong: Vite has no
+* `worklet` query at all, `?init` is `.wasm` only and that extension is already rejected below,
+* and `inline`/`no-inline` merely pick base64-versus-file for something that *already* matched
+* `raw`/`url`, so `./a.tsx?inline` is served as the module's own source. Rejecting an id that
+* carries real source is the expensive direction: the transform declines, its atoms never reach
+* the reachability set, pruning removes their rules, and the runtime still returns the class
+* names — unstyled elements, no error. Only names verified against Vite belong here.
+*
+* Note `?worker_file`, which is how dev serves a worker's *real* source, is deliberately absent
+* and must stay absent. It contains "worker" and is the obvious next entry; adding it would
+* stop folding every worker module in dev, silently, by the mechanism above.
+*
+* Tested against the whole id rather than a split-off query, so it cannot disagree with
+* `queryOf` in `css.ts` about where the query starts.
+*/
+const WRAPPED_MODULE_QUERY = /[?&](?:raw|url|worker|sharedworker)(?:&|=|$)/;
 const shouldTransform = (id) => {
 	if (id.startsWith("\0")) return false;
+	if (WRAPPED_MODULE_QUERY.test(id)) return false;
 	const [filePath] = id.split("?");
 	if (!filePath) return false;
 	if (NODE_MODULES.test(filePath)) return false;
@@ -2864,17 +3052,26 @@ const formatSkipped = (id, skipped) => {
 * with no matching rule.
 */
 const bamboocss = (options = {}) => {
-	const { configPath, cwd, reportSkipped = false, reportSummary = true, maxRecipeStates, renameCssAsset = true } = options;
+	const { configPath, cwd, reportSkipped = false, reportSummary = true, maxRecipeStates, pruneCss = true } = options;
 	if (maxRecipeStates !== void 0 && (!Number.isSafeInteger(maxRecipeStates) || maxRecipeStates < 1)) throw new Error("bamboocss: `maxRecipeStates` must be a positive safe integer.");
-	/** Environments whose `buildStart` has run in the build currently in progress. */
-	const seenEnvironments = /* @__PURE__ */ new Set();
-	/** Totals across the build, for the summary. */
-	const totals = {
-		folded: 0,
-		files: 0,
-		filesWithFolds: 0,
-		skipped: /* @__PURE__ */ new Map()
-	};
+	if ("renameCssAsset" in options) throw new Error("bamboocss: `renameCssAsset` has been replaced by `pruneCss`. Use `pruneCss: false` for what `renameCssAsset: false` did — it always disabled the pruning as well, since pruned bytes under the unpruned sheet's name is what lets a CDN serve a stale stylesheet. The new name says which of the two it is really about.");
+	/**
+	* What each file's transform found, for the summary. Keyed by file rather than summed as it
+	* goes, because a build has more than one environment and they share most of their modules.
+	*
+	* Running totals double-counted every shared module once per environment — a two-environment
+	* build of one shared file and one entry each reported "2/2 across 2/4 files" for three
+	* source modules. Coverage is a property of the source, not of how many times a bundler
+	* handed the same file over. It also grew without bound in dev, where every HMR
+	* re-transform of a file counted as another file.
+	*
+	* A second pass over a file replaces its entry rather than adding to it. Both environments
+	* are assumed to compute the same answer for the same module — true of this compiler, though
+	* not something the plugin can enforce, since another `pre` plugin may hand each environment
+	* different code. Where they disagree the last one wins, which is a cosmetic number either
+	* way.
+	*/
+	const perFile = /* @__PURE__ */ new Map();
 	const staticSession = createStaticCompilationSession();
 	/**
 	* Indexed by file, because the only bulk operation on it is "forget this one's".
@@ -2937,26 +3134,24 @@ const bamboocss = (options = {}) => {
 		configPath,
 		cwd,
 		session: staticSession,
-		renameCssAsset
+		pruneCss
 	}), {
 		name: "bamboocss:compiler",
 		enforce: "pre",
+		/** See the same declaration on the css plugin: one instance per build, not per environment. */
+		sharedDuringBuild: true,
 		configResolved(config) {
 			command = config.command;
 		},
 		async buildStart() {
 			const environment = this.environment?.name ?? "default";
-			if (seenEnvironments.has(environment)) {
-				seenEnvironments.clear();
-				totals.folded = 0;
-				totals.files = 0;
-				totals.filesWithFolds = 0;
-				totals.skipped.clear();
+			if (staticSession.startedEnvironments.has(environment)) {
+				perFile.clear();
 				survivorsByFile.clear();
 				recipeConfigCache.clear();
 				resetStaticCompilationSession(staticSession);
 			}
-			seenEnvironments.add(environment);
+			staticSession.startedEnvironments.add(environment);
 			try {
 				await ensureContext();
 			} catch (error) {
@@ -3026,8 +3221,10 @@ const bamboocss = (options = {}) => {
 				});
 			} catch (error) {
 				_bamboocss_logger.logger.caughtError("vite:transform", `Failed to compile ${filePath}`, error);
-				totals.files++;
-				totals.skipped.set("compile-failed", (totals.skipped.get("compile-failed") ?? 0) + 1);
+				perFile.set(filePath, {
+					folded: 0,
+					skipped: new Map([["compile-failed", 1]])
+				});
 				addSurvivor({
 					file: filePath,
 					line: 1,
@@ -3037,10 +3234,15 @@ const bamboocss = (options = {}) => {
 				if (command === "serve") throw asError(error, `failed to compile ${filePath}`);
 				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);
+			let skippedHere;
+			for (const entry of result.skipped) {
+				skippedHere ??= /* @__PURE__ */ new Map();
+				skippedHere.set(entry.reason, (skippedHere.get(entry.reason) ?? 0) + 1);
+			}
+			perFile.set(filePath, {
+				folded: result.folded.length,
+				skipped: skippedHere
+			});
 			if (result.folded.some((entry) => entry.kind === "class" || entry.kind === "slots")) staticSession.transformedFiles.add((0, node_path.resolve)(filePath));
 			for (const entry of result.folded) for (const className of entry.classNames) staticSession.markClassUsed(className);
 			for (const entry of result.skipped) {
@@ -3067,7 +3269,15 @@ const bamboocss = (options = {}) => {
 		buildEnd() {
 			const survivors = allSurvivors();
 			if (survivors.length) throw createSurvivorError(survivors);
-			if (typeof this.getModuleInfo === "function") {
+			const lost = [...staticSession.usedClasses].filter((className) => staticSession.prunedClasses.has(bare(className)));
+			if (lost.length) {
+				const environment = this.environment?.name ?? "default";
+				throw new Error(`bamboocss: ${lost.length} class(es) compiled in the ${JSON.stringify(environment)} environment were already pruned out of a stylesheet emitted by an earlier one. Elements carrying them would render unstyled.\n\n${(0, _bamboocss_shared.truncateList)(lost.map((className) => `  ${className}`), {
+					unit: "class",
+					separator: "\n"
+				})}\n\nThe stylesheet is finalized by the environment that imports it, so pruning it is only safe once every environment has been compiled. This build did not say how many there would be: it called \`builder.build(environment)\` directly. Run it through \`vite build\`, call \`builder.buildApp()\`, or set \`builder: {}\` in the Vite config so the environments are known before the first one builds. \`bamboocss({ pruneCss: false })\` also turns pruning off entirely.`);
+			}
+			if (typeof this.getModuleInfo === "function" && !remainingEnvironments(staticSession).length) {
 				if (!staticSession.cssLoaded) throw new Error(`bamboocss: compiled class values were produced, but ${JSON.stringify(VIRTUAL_CSS_ID)} was not imported. Add \`import ${JSON.stringify(VIRTUAL_CSS_ID)}\` once, from a JavaScript or TypeScript module in the application entry graph.\n\nIt has to be a JS import. \`@import\` from a stylesheet does not reach it: the id names a virtual module resolved by this plugin, and Vite resolves CSS \`@import\` before plugin resolution, so it fails as an unresolvable path. A project that ships one preloaded stylesheet imports this from its entry module instead, and lets Vite emit the CSS asset.`);
 				const outsideExtraction = [...staticSession.transformedFiles].filter((file) => !staticSession.extractedFiles.has(file));
 				if (outsideExtraction.length) throw new Error(`bamboocss: ${outsideExtraction.length} statically compiled module(s) are outside the CSS extraction graph:\n\n${(0, _bamboocss_shared.truncateList)(outsideExtraction.map((file) => `  ${file}`), {
@@ -3076,12 +3286,21 @@ const bamboocss = (options = {}) => {
 				})}\n\nAdd them to \`include\` in bamboo.config, or no CSS rule can back their emitted classes.`);
 			}
 			if (!reportSummary) return;
-			const declined = Array.from(totals.skipped.values()).reduce((sum, count) => sum + count, 0);
-			const total = totals.folded + declined;
+			if (command === "build" && remainingEnvironments(staticSession).length) return;
+			let folded = 0;
+			let filesWithFolds = 0;
+			const skipped = /* @__PURE__ */ new Map();
+			for (const entry of perFile.values()) {
+				folded += entry.folded;
+				if (entry.folded) filesWithFolds++;
+				for (const [reason, count] of entry.skipped ?? []) skipped.set(reason, (skipped.get(reason) ?? 0) + count);
+			}
+			const declined = Array.from(skipped.values()).reduce((sum, count) => sum + count, 0);
+			const total = 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", `Compiled ${totals.folded}/${total} (${share}%) across ${totals.filesWithFolds}/${totals.files} files` + (reasons ? ` — declined: ${reasons}` : ""));
+			const share = Math.round(folded / total * 100);
+			const reasons = Array.from(skipped.entries()).sort((a, b) => b[1] - a[1]).map(([reason, count]) => `${reason}=${count}`).join(" ");
+			_bamboocss_logger.logger.info("vite:transform", `Compiled ${folded}/${total} (${share}%) across ${filesWithFolds}/${perFile.size} files` + (reasons ? ` — declined: ${reasons}` : ""));
 		}
 	}];
 };

package/dist/index.d.cts

@@ -37,21 +37,32 @@ interface BambooVitePluginOptions {
    */
   maxRecipeStates?: number;
   /**
-   * Give the pruned stylesheet a final name derived from its own bytes.
+   * Remove rules for atoms no compiled module can emit. Builds only; dev never prunes.
    *
-   * Rollup and Rolldown both expand `[hash]` before `generateBundle`, so pruning after it can
-   * leave two different reachable subsets under one CDN key. Renaming the pruned stylesheet to
-   * a hash of its own bytes closes that.
+   * Off ships the whole extracted stylesheet: every rule the source graph produced, including
+   * ones nothing reaches. Larger, and never wrong *by pruning* — it also stands down the
+   * assertion that every compiled class has a rule, since that check exists to catch this pass
+   * removing too much. So this is a true escape hatch: it cannot fail a build over reachability.
    *
-   * Turning it off does not merely skip the rename — it skips the pruning with it. The two are
-   * one operation: pruned bytes under a name describing the unpruned ones is how a stale
-   * stylesheet outlives a deploy, which is worse than shipping a larger sheet. Reach for this
-   * only when something downstream cannot follow a renamed asset, and expect the full
-   * extracted stylesheet when you do.
+   * The pruned sheet is also renamed to a hash of its own bytes, and that is not a separate
+   * setting because it cannot safely be one. Rollup and Rolldown expand `[hash]` before
+   * `generateBundle`, where pruning has to run, so the name Vite assigned describes the sheet
+   * as it was *before* pruning. Leaving that name on pruned bytes is how a stale stylesheet
+   * outlives a deploy — a change to reachability alone, which is what upgrading Bamboo is,
+   * leaves identical source CSS under an identical name with different content, and a CDN
+   * holding that key keeps serving the old one. So the bytes and the name move together or
+   * neither does.
+   *
+   * Reach for this if something downstream derives an artifact from the stylesheet's *content*
+   * during `generateBundle` before Bamboo runs — subresource integrity is the clear case, since
+   * an `integrity` attribute is a digest of the bytes and no amount of reference rewriting can
+   * carry it across an edit — or to rule pruning out while diagnosing a missing rule. Where the
+   * consumer can be moved after Bamboo instead (`order: 'post'`, `writeBundle`, `closeBundle`),
+   * do that and keep the pruning.
    *
    * @default true
    */
-  renameCssAsset?: boolean;
+  pruneCss?: boolean;
 }
 /**
  * Vite integration for Bamboo CSS.

package/dist/index.d.mts

@@ -37,21 +37,32 @@ interface BambooVitePluginOptions {
    */
   maxRecipeStates?: number;
   /**
-   * Give the pruned stylesheet a final name derived from its own bytes.
+   * Remove rules for atoms no compiled module can emit. Builds only; dev never prunes.
    *
-   * Rollup and Rolldown both expand `[hash]` before `generateBundle`, so pruning after it can
-   * leave two different reachable subsets under one CDN key. Renaming the pruned stylesheet to
-   * a hash of its own bytes closes that.
+   * Off ships the whole extracted stylesheet: every rule the source graph produced, including
+   * ones nothing reaches. Larger, and never wrong *by pruning* — it also stands down the
+   * assertion that every compiled class has a rule, since that check exists to catch this pass
+   * removing too much. So this is a true escape hatch: it cannot fail a build over reachability.
    *
-   * Turning it off does not merely skip the rename — it skips the pruning with it. The two are
-   * one operation: pruned bytes under a name describing the unpruned ones is how a stale
-   * stylesheet outlives a deploy, which is worse than shipping a larger sheet. Reach for this
-   * only when something downstream cannot follow a renamed asset, and expect the full
-   * extracted stylesheet when you do.
+   * The pruned sheet is also renamed to a hash of its own bytes, and that is not a separate
+   * setting because it cannot safely be one. Rollup and Rolldown expand `[hash]` before
+   * `generateBundle`, where pruning has to run, so the name Vite assigned describes the sheet
+   * as it was *before* pruning. Leaving that name on pruned bytes is how a stale stylesheet
+   * outlives a deploy — a change to reachability alone, which is what upgrading Bamboo is,
+   * leaves identical source CSS under an identical name with different content, and a CDN
+   * holding that key keeps serving the old one. So the bytes and the name move together or
+   * neither does.
+   *
+   * Reach for this if something downstream derives an artifact from the stylesheet's *content*
+   * during `generateBundle` before Bamboo runs — subresource integrity is the clear case, since
+   * an `integrity` attribute is a digest of the bytes and no amount of reference rewriting can
+   * carry it across an edit — or to rule pruning out while diagnosing a missing rule. Where the
+   * consumer can be moved after Bamboo instead (`order: 'post'`, `writeBundle`, `closeBundle`),
+   * do that and keep the pruning.
    *
    * @default true
    */
-  renameCssAsset?: boolean;
+  pruneCss?: boolean;
 }
 /**
  * Vite integration for Bamboo CSS.

package/dist/index.mjs

@@ -64,6 +64,7 @@ const pruneStaticCss = (css, session, { prune = true } = {}) => {
 					if (!className || !prunable.has(className) || used.has(className)) return;
 					candidate.remove();
 					removedAny = true;
+					session.prunedClasses.add(className);
 				});
 			}).processSync(rule.selector);
 		} catch {
@@ -124,6 +125,56 @@ const pruneStaticCss = (css, session, { prune = true } = {}) => {
 	return root.toString();
 };
 //#endregion
+//#region src/static-session.ts
+const createStaticCompilationSession = () => {
+	const session = {
+		utilityLayer: "utilities",
+		sourcemap: false,
+		cssLoaded: false,
+		transformedFiles: /* @__PURE__ */ new Set(),
+		extractedFiles: /* @__PURE__ */ new Set(),
+		prunableClasses: /* @__PURE__ */ new Set(),
+		viewTransitionClasses: /* @__PURE__ */ new Set(),
+		usedClasses: /* @__PURE__ */ new Set(),
+		expectedEnvironments: void 0,
+		startedEnvironments: /* @__PURE__ */ new Set(),
+		prunedClasses: /* @__PURE__ */ new Set(),
+		markClassUsed(className) {
+			for (const token of className.split(" ")) {
+				if (!token) continue;
+				session.usedClasses.add(token.includes("\\") ? token : esc(token));
+			}
+		}
+	};
+	return session;
+};
+/**
+* Environments this run intends to build that have not been compiled yet.
+*
+* Empty means everything the run will contribute has been contributed, which is the condition
+* every whole-run judgement here waits for: pruning the stylesheet against reachability, and
+* the two guards that ask whether the compiled modules and the extraction graph agree. Each of
+* those is false about a build in progress and true only about a finished one.
+*
+* Empty is also the answer for a single-environment build, where nothing announced an
+* environment list because there is only ever one — so that path is unchanged.
+*
+* An environment a run declares and then never builds leaves this permanently non-empty, and
+* those judgements are skipped for the run. Every one of them errs towards shipping more CSS
+* or asserting less, so that is the safe direction to be wrong in.
+*/
+const remainingEnvironments = (session) => [...session.expectedEnvironments ?? []].filter((name) => !session.startedEnvironments.has(name));
+const resetStaticCompilationSession = (session) => {
+	session.cssLoaded = false;
+	session.transformedFiles.clear();
+	session.extractedFiles.clear();
+	session.prunableClasses.clear();
+	session.viewTransitionClasses.clear();
+	session.usedClasses.clear();
+	session.startedEnvironments.clear();
+	session.prunedClasses.clear();
+};
+//#endregion
 //#region src/css.ts
 /**
 * What a project imports to get the stylesheet.
@@ -225,32 +276,37 @@ const replaceAssetReferences = (bundle, previous, next, sourcemap) => {
 */
 const carriesGeneratedCss = (output) => output.type === "asset" && output.fileName.endsWith(".css");
 /**
-* Prune and rename compiler-owned CSS, then give changed assets a hash of their final bytes.
+* Prune compiler-owned CSS, then give any sheet whose bytes changed a hash of those bytes.
 *
 * Rollup has already expanded `[hash]` when `generateBundle` runs. Mutating only `source`
 * would therefore leave two different reachable subsets under one CDN key. The extra final
 * hash is not cosmetic: it makes late graph reachability cache-safe.
+*
+* Renaming is therefore not a choice this takes. Pruned bytes under the unpruned sheet's name
+* is the one outcome that must never be reachable, and a sheet nothing was removed from keeps
+* its name because its bytes are unchanged — so "rename" is a consequence of "the bytes moved",
+* not a second option. `prune` is the only knob.
 */
 const optimizeStaticCssAssets = (bundle, session, options = {}) => {
-	const { rename = true } = options;
+	const { prune = true, sourcemap = session.sourcemap } = options;
+	/** Assets in this bundle that carry the generated stylesheet, pruned or not. */
+	let sheets = 0;
 	for (const output of Object.values(bundle)) {
 		if (!carriesGeneratedCss(output)) continue;
 		const source = typeof output.source === "string" ? output.source : Buffer.from(output.source).toString();
 		if (!source.includes("--made-with-bamboo")) continue;
+		sheets++;
+		if (!prune) continue;
 		const optimized = pruneStaticCss(source, session);
 		output.source = optimized;
 		if (optimized === source) continue;
-		if (!rename) {
-			output.source = source;
-			continue;
-		}
 		const nextName = output.fileName.replace(/\.css$/, `.b-${toHash(optimized)}.css`);
-		if (nextName === output.fileName) continue;
 		if (bundle[nextName] && bundle[nextName] !== output) throw new Error(`bamboocss: final CSS asset name collision at ${JSON.stringify(nextName)}.`);
 		const previous = output.fileName;
 		output.fileName = nextName;
-		replaceAssetReferences(bundle, previous, nextName, session.sourcemap);
+		replaceAssetReferences(bundle, previous, nextName, sourcemap);
 	}
+	return { sheets };
 };
 /**
 * Serve bamboo's stylesheet as a virtual module, in dev and in build.
@@ -266,7 +322,7 @@ const optimizeStaticCssAssets = (bundle, session, options = {}) => {
 * process just wrote, which is a race on any watch rebuild.
 */
 const bamboocssCss = (options) => {
-	const { configPath, cwd, session, renameCssAsset = true } = options;
+	const { configPath, cwd, session, pruneCss = true } = options;
 	/**
 	* Environments whose `load` served the virtual stylesheet.
 	*
@@ -326,9 +382,32 @@ const bamboocssCss = (options) => {
 	};
 	return {
 		name: "bamboocss:css",
+		/**
+		* One instance for every environment of a build, rather than one per environment.
+		*
+		* Vite re-reads the config file once per environment, so a project that lists this plugin
+		* in `vite.config.ts` — every project — got a *fresh* instance per environment, each with
+		* its own compilation session, context and ts-morph project. Nothing an environment
+		* established could then be seen by the next one, which is the premise the reachability
+		* accounting below is built on, and it also meant the whole config load and extraction
+		* happened once per environment.
+		*/
+		sharedDuringBuild: true,
 		configResolved(config) {
 			command = config.command;
 			session.sourcemap = config.build.sourcemap;
+			if (config.builder && config.environments) session.expectedEnvironments = new Set(Object.keys(config.environments));
+		},
+		/**
+		* The definitive environment list, for a run that reaches `builder.buildApp()` without
+		* configuring `builder` — the shape `vite build` itself takes, where exactly one
+		* environment is set up and pruning is therefore safe.
+		*/
+		buildApp: {
+			order: "pre",
+			async handler(builder) {
+				session.expectedEnvironments = new Set(Object.keys(builder.environments));
+			}
 		},
 		resolveId(id) {
 			const query = queryOf(id);
@@ -368,8 +447,34 @@ const bamboocssCss = (options) => {
 		generateBundle: {
 			order: "post",
 			handler(_, bundle) {
-				optimizeStaticCssAssets(bundle, session, { rename: renameCssAsset });
-				if (!servedEnvironments.has(this.environment?.name ?? "default")) return;
+				const environment = this.environment;
+				/**
+				* Every environment of this run has already had its modules compiled.
+				*
+				* Reachability is what pruning removes rules against, and it is only complete once
+				* nothing is left to contribute to it. The stylesheet is emitted and finalized by the
+				* environment that *imports* it, which in an SSR app is the client — and the client
+				* builds first, before the server environment has transformed a single module. Pruning
+				* there deletes every rule for a class only the server graph reaches, and the pages
+				* link the pruned copy: one project lost 39% of its atoms that way, presenting as
+				* rarely-used classes such as `md:{display:inline-block}` silently not applying.
+				*
+				* So the full extracted stylesheet ships instead, which is what `pruneCss: false` asks
+				* for by hand. Being the last environment is not the common case — frameworks build the
+				* client first — but it is the only one where the answer is knowable, and a framework
+				* that builds its server bundle first does get pruned output.
+				*/
+				const pending = remainingEnvironments(session);
+				const { sheets } = optimizeStaticCssAssets(bundle, session, {
+					prune: pruneCss && pending.length === 0,
+					sourcemap: environment?.config?.build?.sourcemap
+				});
+				if (sheets && !pruneCss) logger.info("vite", "Reachability pruning is off (`pruneCss: false`). The full extracted stylesheet ships.");
+				else if (sheets && pending.length) logger.info("vite", `Reachability pruning skipped: the stylesheet is emitted by the ${JSON.stringify(environment?.name ?? "default")} environment, and ${truncateList(pending, {
+					unit: "environment",
+					separator: ", "
+				})} ${pending.length === 1 ? "has" : "have"} not been compiled in this run. The full extracted stylesheet ships — nothing is missing from it.`);
+				if (!servedEnvironments.has(environment?.name ?? "default")) return;
 				if (!session.transformedFiles.size) return;
 				if (!Object.values(bundle).some((output) => {
 					if (!carriesGeneratedCss(output)) return false;
@@ -382,6 +487,78 @@ const bamboocssCss = (options) => {
 //#endregion
 //#region src/fold-analysis.ts
 /**
+* Nodes that *compose* a value out of their children rather than computing one.
+*
+* The boundary of the walk below, and the whole of its precision. Climbing through these
+* keeps a value's provenance: `'red.300'` inside `{ color: 'red.300' }` inside a default is
+* still the default's. Anything else — a call, a function body, a JSX element — produces its
+* value by being evaluated, so what is written inside it is an argument to that evaluation
+* and not the enclosing default's value.
+*
+* Without the boundary, `({ cls = css({ color: 'red.300' }) }) => cls` is rejected: the call's
+* own literal argument is syntactically inside a default, so an unbounded walk calls it one.
+* That is correct code, and rejecting it fails the build.
+*/
+const composesValue = (node) => Node.isObjectLiteralExpression(node) || Node.isArrayLiteralExpression(node) || Node.isPropertyAssignment(node) || Node.isShorthandPropertyAssignment(node) || Node.isSpreadAssignment(node) || Node.isSpreadElement(node) || Node.isAsExpression(node) || Node.isParenthesizedExpression(node) || Node.isNonNullExpression(node) || Node.isTypeAssertion(node) || Node.isSatisfiesExpression(node);
+/** Is `inner` written within `outer`? Positions rather than a walk, so it is O(1). */
+const contains = (outer, inner) => outer.getSourceFile() === inner.getSourceFile() && outer.getStart() <= inner.getStart() && inner.getEnd() <= outer.getEnd();
+/**
+* Did this value come from the `= …` of a destructuring binding?
+*
+* `const { tone = 'red.300' } = source` boxes as the literal `'red.300'`: the extractor's
+* `maybeDefinitionValue` tests for an initializer first and returns the boxed default, never
+* reaching the branch that would read `source`. So the default is reported as the value whether
+* or not it is the one that applies.
+*
+* For extraction that is merely optimistic, and deliberately so: a CLI or PostCSS build ships a
+* runtime `css()`, where the default genuinely does apply when the caller omits the key, and it
+* needs a rule behind it. Folding is where the same resolution turns into a wrong answer,
+* because the call is *replaced* by that value.
+*
+* Stops at the first non-composing parent, so a call written inside a default keeps its own
+* provenance, and checks that the binding element was reached through its initializer, so
+* `{ tone = X }`'s name node is not mistaken for its default.
+*/
+const isBindingElementDefault = (node) => {
+	if (node && Node.isCallExpression(node)) return false;
+	let current = node;
+	while (current) {
+		const parent = current.getParent();
+		if (!parent) return false;
+		if (Node.isBindingElement(parent)) return parent.getInitializer() === current;
+		if (!composesValue(parent)) return false;
+		current = parent;
+	}
+	return false;
+};
+/**
+* The same question asked of a whole box, including how it was resolved.
+*
+* The node a box reports is not always the one its value came from — an empty `{}` default
+* boxes against the call rather than against the `{}` — so the resolution stack is consulted
+* too. A binding element reaches that stack by having been resolved *through*, which is the
+* signal the extractor itself reads when one of these is a conditional's test.
+*
+* Only the entries that are binding elements are examined. Walking up from every other entry
+* was tried and never once changed a verdict across the default spellings or the sandbox's own
+* modules, while accounting for most of the parent hops this does — the stack carries nodes
+* that were never resolved through, including a call's own arguments, so walking from them is
+* both the expensive half and the one that reaches conclusions it has no basis for.
+*
+* A binding element without an initializer carries no default to mistrust: `const { tone } =
+* source` either resolves from `source` or does not resolve at all.
+*/
+const isFromBindingDefault = (node) => {
+	const own = node.getNode?.();
+	if (isBindingElementDefault(own)) return true;
+	for (const entry of node.getStack?.() ?? []) {
+		if (!Node.isBindingElement(entry) || !entry.getInitializer()) continue;
+		if (own && contains(entry, own)) continue;
+		return true;
+	}
+	return false;
+};
+/**
 * Statically resolvable means: every box in the tree carries a known value.
 *
 * `unresolvable` is the extractor saying it could not evaluate a node.
@@ -395,6 +572,7 @@ const isStaticBox = (node, seen = /* @__PURE__ */ new Set()) => {
 	seen.add(node);
 	if (box.isUnresolvable(node) || box.isConditional(node)) return false;
 	if (!("type" in node) || node.type == null) return false;
+	if (isFromBindingDefault(node)) return false;
 	if (box.isLiteral(node) && node.value === void 0) {
 		const source = node.getNode?.();
 		return Boolean(source && Node.isIdentifier(source) && source.getText() === "undefined");
@@ -2754,40 +2932,50 @@ const createStaticStyleSetCompiler = (ctx, runtimeCss, allocateClassString = (cl
 	};
 };
 //#endregion
-//#region src/static-session.ts
-const createStaticCompilationSession = () => {
-	const session = {
-		utilityLayer: "utilities",
-		sourcemap: false,
-		cssLoaded: false,
-		transformedFiles: /* @__PURE__ */ new Set(),
-		extractedFiles: /* @__PURE__ */ new Set(),
-		prunableClasses: /* @__PURE__ */ new Set(),
-		viewTransitionClasses: /* @__PURE__ */ new Set(),
-		usedClasses: /* @__PURE__ */ new Set(),
-		markClassUsed(className) {
-			for (const token of className.split(" ")) {
-				if (!token) continue;
-				session.usedClasses.add(token.includes("\\") ? token : esc(token));
-			}
-		}
-	};
-	return session;
-};
-const resetStaticCompilationSession = (session) => {
-	session.cssLoaded = false;
-	session.transformedFiles.clear();
-	session.extractedFiles.clear();
-	session.prunableClasses.clear();
-	session.viewTransitionClasses.clear();
-	session.usedClasses.clear();
-};
-//#endregion
 //#region src/plugin.ts
 const DEFAULT_EXTENSIONS = /\.(?:[cm]?[jt]sx?)$/;
 const NODE_MODULES = /node_modules/;
+/**
+* Queries that make Vite serve something other than the module's own source.
+*
+* `./theme.tsx?raw` is a module whose text is `export default "…"`, and `?url`, `?worker` and
+* `?sharedworker` are wrappers of the same kind. The query has to be stripped before the
+* extension is tested — otherwise nothing matches `.tsx` — and stripping it is what made these
+* look like the file itself. The transform then handed the wrapper's text to ts-morph *under
+* the real file's path*, overwriting the parsed module every fold reads for that path.
+*
+* That is not theoretical: a module folding `css(shared)` against a sibling the entry also
+* imported as `?raw` failed the build with "1 call(s) could not be compiled" — the compiler
+* had read `export default "…"` and found no `shared` to resolve. The advice it prints, to
+* make the value statically analyzable, is unfollowable, because the source already was.
+*
+* Whether it bites depends on which of the two ids Rollup transforms last, so the same project
+* can build and then stop building because an import moved.
+*
+* A deny list rather than an allow list of benign queries: dev ids carry `?t=` after an edit
+* and `?import` when a dynamic import is rewritten, and rejecting an unrecognised one of those
+* would silently stop folding a module rather than loudly refuse it.
+*
+* Exactly these four, matching Vite's own `SPECIAL_QUERY_RE`. The list was drafted wider —
+* `?inline`, `?no-inline`, `?worklet`, `?init` — and every one of those was wrong: Vite has no
+* `worklet` query at all, `?init` is `.wasm` only and that extension is already rejected below,
+* and `inline`/`no-inline` merely pick base64-versus-file for something that *already* matched
+* `raw`/`url`, so `./a.tsx?inline` is served as the module's own source. Rejecting an id that
+* carries real source is the expensive direction: the transform declines, its atoms never reach
+* the reachability set, pruning removes their rules, and the runtime still returns the class
+* names — unstyled elements, no error. Only names verified against Vite belong here.
+*
+* Note `?worker_file`, which is how dev serves a worker's *real* source, is deliberately absent
+* and must stay absent. It contains "worker" and is the obvious next entry; adding it would
+* stop folding every worker module in dev, silently, by the mechanism above.
+*
+* Tested against the whole id rather than a split-off query, so it cannot disagree with
+* `queryOf` in `css.ts` about where the query starts.
+*/
+const WRAPPED_MODULE_QUERY = /[?&](?:raw|url|worker|sharedworker)(?:&|=|$)/;
 const shouldTransform = (id) => {
 	if (id.startsWith("\0")) return false;
+	if (WRAPPED_MODULE_QUERY.test(id)) return false;
 	const [filePath] = id.split("?");
 	if (!filePath) return false;
 	if (NODE_MODULES.test(filePath)) return false;
@@ -2834,17 +3022,26 @@ const formatSkipped = (id, skipped) => {
 * with no matching rule.
 */
 const bamboocss = (options = {}) => {
-	const { configPath, cwd, reportSkipped = false, reportSummary = true, maxRecipeStates, renameCssAsset = true } = options;
+	const { configPath, cwd, reportSkipped = false, reportSummary = true, maxRecipeStates, pruneCss = true } = options;
 	if (maxRecipeStates !== void 0 && (!Number.isSafeInteger(maxRecipeStates) || maxRecipeStates < 1)) throw new Error("bamboocss: `maxRecipeStates` must be a positive safe integer.");
-	/** Environments whose `buildStart` has run in the build currently in progress. */
-	const seenEnvironments = /* @__PURE__ */ new Set();
-	/** Totals across the build, for the summary. */
-	const totals = {
-		folded: 0,
-		files: 0,
-		filesWithFolds: 0,
-		skipped: /* @__PURE__ */ new Map()
-	};
+	if ("renameCssAsset" in options) throw new Error("bamboocss: `renameCssAsset` has been replaced by `pruneCss`. Use `pruneCss: false` for what `renameCssAsset: false` did — it always disabled the pruning as well, since pruned bytes under the unpruned sheet's name is what lets a CDN serve a stale stylesheet. The new name says which of the two it is really about.");
+	/**
+	* What each file's transform found, for the summary. Keyed by file rather than summed as it
+	* goes, because a build has more than one environment and they share most of their modules.
+	*
+	* Running totals double-counted every shared module once per environment — a two-environment
+	* build of one shared file and one entry each reported "2/2 across 2/4 files" for three
+	* source modules. Coverage is a property of the source, not of how many times a bundler
+	* handed the same file over. It also grew without bound in dev, where every HMR
+	* re-transform of a file counted as another file.
+	*
+	* A second pass over a file replaces its entry rather than adding to it. Both environments
+	* are assumed to compute the same answer for the same module — true of this compiler, though
+	* not something the plugin can enforce, since another `pre` plugin may hand each environment
+	* different code. Where they disagree the last one wins, which is a cosmetic number either
+	* way.
+	*/
+	const perFile = /* @__PURE__ */ new Map();
 	const staticSession = createStaticCompilationSession();
 	/**
 	* Indexed by file, because the only bulk operation on it is "forget this one's".
@@ -2907,26 +3104,24 @@ const bamboocss = (options = {}) => {
 		configPath,
 		cwd,
 		session: staticSession,
-		renameCssAsset
+		pruneCss
 	}), {
 		name: "bamboocss:compiler",
 		enforce: "pre",
+		/** See the same declaration on the css plugin: one instance per build, not per environment. */
+		sharedDuringBuild: true,
 		configResolved(config) {
 			command = config.command;
 		},
 		async buildStart() {
 			const environment = this.environment?.name ?? "default";
-			if (seenEnvironments.has(environment)) {
-				seenEnvironments.clear();
-				totals.folded = 0;
-				totals.files = 0;
-				totals.filesWithFolds = 0;
-				totals.skipped.clear();
+			if (staticSession.startedEnvironments.has(environment)) {
+				perFile.clear();
 				survivorsByFile.clear();
 				recipeConfigCache.clear();
 				resetStaticCompilationSession(staticSession);
 			}
-			seenEnvironments.add(environment);
+			staticSession.startedEnvironments.add(environment);
 			try {
 				await ensureContext();
 			} catch (error) {
@@ -2996,8 +3191,10 @@ const bamboocss = (options = {}) => {
 				});
 			} catch (error) {
 				logger.caughtError("vite:transform", `Failed to compile ${filePath}`, error);
-				totals.files++;
-				totals.skipped.set("compile-failed", (totals.skipped.get("compile-failed") ?? 0) + 1);
+				perFile.set(filePath, {
+					folded: 0,
+					skipped: new Map([["compile-failed", 1]])
+				});
 				addSurvivor({
 					file: filePath,
 					line: 1,
@@ -3007,10 +3204,15 @@ const bamboocss = (options = {}) => {
 				if (command === "serve") throw asError(error, `failed to compile ${filePath}`);
 				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);
+			let skippedHere;
+			for (const entry of result.skipped) {
+				skippedHere ??= /* @__PURE__ */ new Map();
+				skippedHere.set(entry.reason, (skippedHere.get(entry.reason) ?? 0) + 1);
+			}
+			perFile.set(filePath, {
+				folded: result.folded.length,
+				skipped: skippedHere
+			});
 			if (result.folded.some((entry) => entry.kind === "class" || entry.kind === "slots")) staticSession.transformedFiles.add(resolve(filePath));
 			for (const entry of result.folded) for (const className of entry.classNames) staticSession.markClassUsed(className);
 			for (const entry of result.skipped) {
@@ -3037,7 +3239,15 @@ const bamboocss = (options = {}) => {
 		buildEnd() {
 			const survivors = allSurvivors();
 			if (survivors.length) throw createSurvivorError(survivors);
-			if (typeof this.getModuleInfo === "function") {
+			const lost = [...staticSession.usedClasses].filter((className) => staticSession.prunedClasses.has(bare(className)));
+			if (lost.length) {
+				const environment = this.environment?.name ?? "default";
+				throw new Error(`bamboocss: ${lost.length} class(es) compiled in the ${JSON.stringify(environment)} environment were already pruned out of a stylesheet emitted by an earlier one. Elements carrying them would render unstyled.\n\n${truncateList(lost.map((className) => `  ${className}`), {
+					unit: "class",
+					separator: "\n"
+				})}\n\nThe stylesheet is finalized by the environment that imports it, so pruning it is only safe once every environment has been compiled. This build did not say how many there would be: it called \`builder.build(environment)\` directly. Run it through \`vite build\`, call \`builder.buildApp()\`, or set \`builder: {}\` in the Vite config so the environments are known before the first one builds. \`bamboocss({ pruneCss: false })\` also turns pruning off entirely.`);
+			}
+			if (typeof this.getModuleInfo === "function" && !remainingEnvironments(staticSession).length) {
 				if (!staticSession.cssLoaded) throw new Error(`bamboocss: compiled class values were produced, but ${JSON.stringify(VIRTUAL_CSS_ID)} was not imported. Add \`import ${JSON.stringify(VIRTUAL_CSS_ID)}\` once, from a JavaScript or TypeScript module in the application entry graph.\n\nIt has to be a JS import. \`@import\` from a stylesheet does not reach it: the id names a virtual module resolved by this plugin, and Vite resolves CSS \`@import\` before plugin resolution, so it fails as an unresolvable path. A project that ships one preloaded stylesheet imports this from its entry module instead, and lets Vite emit the CSS asset.`);
 				const outsideExtraction = [...staticSession.transformedFiles].filter((file) => !staticSession.extractedFiles.has(file));
 				if (outsideExtraction.length) throw new Error(`bamboocss: ${outsideExtraction.length} statically compiled module(s) are outside the CSS extraction graph:\n\n${truncateList(outsideExtraction.map((file) => `  ${file}`), {
@@ -3046,12 +3256,21 @@ const bamboocss = (options = {}) => {
 				})}\n\nAdd them to \`include\` in bamboo.config, or no CSS rule can back their emitted classes.`);
 			}
 			if (!reportSummary) return;
-			const declined = Array.from(totals.skipped.values()).reduce((sum, count) => sum + count, 0);
-			const total = totals.folded + declined;
+			if (command === "build" && remainingEnvironments(staticSession).length) return;
+			let folded = 0;
+			let filesWithFolds = 0;
+			const skipped = /* @__PURE__ */ new Map();
+			for (const entry of perFile.values()) {
+				folded += entry.folded;
+				if (entry.folded) filesWithFolds++;
+				for (const [reason, count] of entry.skipped ?? []) skipped.set(reason, (skipped.get(reason) ?? 0) + count);
+			}
+			const declined = Array.from(skipped.values()).reduce((sum, count) => sum + count, 0);
+			const total = folded + declined;
 			if (!total) return;
-			const share = Math.round(totals.folded / total * 100);
-			const reasons = Array.from(totals.skipped.entries()).sort((a, b) => b[1] - a[1]).map(([reason, count]) => `${reason}=${count}`).join(" ");
-			logger.info("vite:transform", `Compiled ${totals.folded}/${total} (${share}%) across ${totals.filesWithFolds}/${totals.files} files` + (reasons ? ` — declined: ${reasons}` : ""));
+			const share = Math.round(folded / total * 100);
+			const reasons = Array.from(skipped.entries()).sort((a, b) => b[1] - a[1]).map(([reason, count]) => `${reason}=${count}`).join(" ");
+			logger.info("vite:transform", `Compiled ${folded}/${total} (${share}%) across ${filesWithFolds}/${perFile.size} files` + (reasons ? ` — declined: ${reasons}` : ""));
 		}
 	}];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamboocss/vite",
-  "version": "1.37.12",
+  "version": "1.38.0",
   "description": "Vite integration for Bamboo CSS",
   "homepage": "https://bamboocss.com",
   "license": "MIT",
@@ -40,18 +40,18 @@
     "postcss": "8.5.26",
     "postcss-selector-parser": "7.1.5",
     "ts-morph": "28.0.0",
-    "@bamboocss/config": "1.37.12",
-    "@bamboocss/core": "1.37.12",
-    "@bamboocss/extractor": "1.37.12",
-    "@bamboocss/logger": "1.37.12",
-    "@bamboocss/node": "1.37.12",
-    "@bamboocss/shared": "1.37.12",
-    "@bamboocss/types": "1.37.12"
+    "@bamboocss/config": "1.38.0",
+    "@bamboocss/core": "1.38.0",
+    "@bamboocss/logger": "1.38.0",
+    "@bamboocss/node": "1.38.0",
+    "@bamboocss/extractor": "1.38.0",
+    "@bamboocss/shared": "1.38.0",
+    "@bamboocss/types": "1.38.0"
   },
   "devDependencies": {
     "@jridgewell/trace-mapping": "^0.3.31",
     "vite": "7.2.6",
-    "@bamboocss/fixture": "1.37.12"
+    "@bamboocss/fixture": "1.38.0"
   },
   "peerDependencies": {
     "vite": ">=5"