@bamboocss/vite 1.37.13 → 1.38.0

package/dist/index.cjs

@@ -306,14 +306,19 @@ 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, prune = true, sourcemap = session.sourcemap } = 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)) {
@@ -325,12 +330,7 @@ const optimizeStaticCssAssets = (bundle, session, options = {}) => {
 		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;
@@ -352,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.
 	*
@@ -489,18 +489,18 @@ const bamboocssCss = (options) => {
 				* 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, exactly as `renameCssAsset: false`
-				* already does. 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.
+				* 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, {
-					rename: renameCssAsset,
-					prune: pending.length === 0,
+					prune: pruneCss && pending.length === 0,
 					sourcemap: environment?.config?.build?.sourcemap
 				});
-				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, {
+				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.`);
@@ -517,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.
@@ -530,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");
@@ -2892,8 +2965,47 @@ const createStaticStyleSetCompiler = (ctx, runtimeCss, allocateClassString = (cl
 //#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;
@@ -2940,15 +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.");
-	/** 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".
@@ -3011,7 +3134,7 @@ const bamboocss = (options = {}) => {
 		configPath,
 		cwd,
 		session: staticSession,
-		renameCssAsset
+		pruneCss
 	}), {
 		name: "bamboocss:compiler",
 		enforce: "pre",
@@ -3023,10 +3146,7 @@ const bamboocss = (options = {}) => {
 		async buildStart() {
 			const environment = this.environment?.name ?? "default";
 			if (staticSession.startedEnvironments.has(environment)) {
-				totals.folded = 0;
-				totals.files = 0;
-				totals.filesWithFolds = 0;
-				totals.skipped.clear();
+				perFile.clear();
 				survivorsByFile.clear();
 				recipeConfigCache.clear();
 				resetStaticCompilationSession(staticSession);
@@ -3101,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,
@@ -3112,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) {
@@ -3148,7 +3275,7 @@ const bamboocss = (options = {}) => {
 				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({ renameCssAsset: false })\` also turns pruning off entirely.`);
+				})}\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.`);
@@ -3159,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

@@ -276,14 +276,19 @@ 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, prune = true, sourcemap = session.sourcemap } = 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)) {
@@ -295,12 +300,7 @@ const optimizeStaticCssAssets = (bundle, session, options = {}) => {
 		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;
@@ -322,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.
 	*
@@ -459,18 +459,18 @@ const bamboocssCss = (options) => {
 				* 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, exactly as `renameCssAsset: false`
-				* already does. 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.
+				* 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, {
-					rename: renameCssAsset,
-					prune: pending.length === 0,
+					prune: pruneCss && pending.length === 0,
 					sourcemap: environment?.config?.build?.sourcemap
 				});
-				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, {
+				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.`);
@@ -487,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.
@@ -500,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");
@@ -2862,8 +2935,47 @@ const createStaticStyleSetCompiler = (ctx, runtimeCss, allocateClassString = (cl
 //#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;
@@ -2910,15 +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.");
-	/** 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".
@@ -2981,7 +3104,7 @@ const bamboocss = (options = {}) => {
 		configPath,
 		cwd,
 		session: staticSession,
-		renameCssAsset
+		pruneCss
 	}), {
 		name: "bamboocss:compiler",
 		enforce: "pre",
@@ -2993,10 +3116,7 @@ const bamboocss = (options = {}) => {
 		async buildStart() {
 			const environment = this.environment?.name ?? "default";
 			if (staticSession.startedEnvironments.has(environment)) {
-				totals.folded = 0;
-				totals.files = 0;
-				totals.filesWithFolds = 0;
-				totals.skipped.clear();
+				perFile.clear();
 				survivorsByFile.clear();
 				recipeConfigCache.clear();
 				resetStaticCompilationSession(staticSession);
@@ -3071,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,
@@ -3082,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) {
@@ -3118,7 +3245,7 @@ const bamboocss = (options = {}) => {
 				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({ renameCssAsset: false })\` also turns pruning off entirely.`);
+				})}\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.`);
@@ -3129,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.13",
+  "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.13",
-    "@bamboocss/core": "1.37.13",
-    "@bamboocss/extractor": "1.37.13",
-    "@bamboocss/logger": "1.37.13",
-    "@bamboocss/node": "1.37.13",
-    "@bamboocss/types": "1.37.13",
-    "@bamboocss/shared": "1.37.13"
+    "@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.13"
+    "@bamboocss/fixture": "1.38.0"
   },
   "peerDependencies": {
     "vite": ">=5"