@bamboocss/vite 1.37.13 → 1.39.0

package/dist/index.cjs

@@ -24,6 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
+let _bamboocss_config = require("@bamboocss/config");
 let _bamboocss_node = require("@bamboocss/node");
 let _bamboocss_logger = require("@bamboocss/logger");
 let _bamboocss_shared = require("@bamboocss/shared");
@@ -306,14 +307,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 +331,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 +353,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.
 	*
@@ -426,6 +427,39 @@ const bamboocssCss = (options) => {
 		configResolved(config) {
 			command = config.command;
 			session.sourcemap = config.build.sourcemap;
+			/**
+			* Tell Vite that `bamboo.config.ts` is a config file, so editing one restarts the server.
+			*
+			* Tokens live there, and they are what a designer iterates on most — "restart the dev
+			* server to see a colour change" is the wrong instruction for the file most likely to be
+			* edited all afternoon. Nothing watched it: `watch` is the CLI's own watcher, and a
+			* project running `vite dev` never reaches it.
+			*
+			* A restart rather than re-emitting the stylesheet, because this plugin and the compiler
+			* hold *separate* contexts and only this one reloads its config. A token *value* edit
+			* came out right on the next source change, and an edit that changes what compiles —
+			* adding a token, a condition, a utility — left the compiler naming classes from the old
+			* config against a sheet emitted from the new one. Half-updated is worse than stale.
+			*
+			* Through Vite's own list rather than a watcher of ours. Vite adds these paths to the
+			* files it watches, which is what reaches a config *outside* `root` — a monorepo with one
+			* config above `apps/web`, or a preset resolved into `node_modules`, neither of which the
+			* project watcher covers. It also means the restart is Vite's, with its own concurrency
+			* guard and its own error reporting, rather than a second implementation of both.
+			*
+			* The config's own import graph is resolved the way `Builder` resolves it, minus the
+			* tsconfig paths it has not loaded yet at this point. `dependencies` globs are not
+			* expanded here: they are declared as an escape hatch for a *config reload*, and turning
+			* every file matching one into a full server restart is not what a project asking for
+			* that meant.
+			*/
+			if (config.command === "serve") try {
+				const { deps } = (0, _bamboocss_config.getConfigDependencies)((0, _bamboocss_config.findConfig)({
+					cwd: cwd ?? config.root,
+					file: configPath
+				}));
+				config.configFileDependencies.push(...deps);
+			} catch {}
 			if (config.builder && config.environments) session.expectedEnvironments = new Set(Object.keys(config.environments));
 		},
 		/**
@@ -489,18 +523,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 +551,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 +636,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 +2999,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;
@@ -2921,6 +3067,18 @@ const isGeneratedOutput = (filePath, ctx) => {
 };
 /** 1-indexed line of a source offset, for an error a user can navigate to. */
 const lineAt = (code, offset) => code.slice(0, offset).split("\n").length;
+/**
+* One spelling for a path used as a map key against paths from somewhere else.
+*
+* The fold reports dependencies as ts-morph sees them and Vite reports a changed file as its
+* watcher saw it. On Windows those differ by separator, and can differ by the case of the
+* drive letter alone — chokidar reports what the OS handed it, `path.resolve` preserves
+* whatever the cwd had. Either would make every lookup below miss and restore the exact
+* staleness they exist to fix, silently, since a miss is indistinguishable from a module that
+* folded nothing. Only the drive letter is case-folded: the rest of the path is compared as
+* written, because elsewhere the filesystem may well be case-sensitive.
+*/
+const normalizeFsPath = (file) => (0, node_path.resolve)(file).replaceAll("\\", "/").replace(/^[a-z]:\//, (drive) => drive.toUpperCase());
 const formatSkipped = (id, skipped) => {
 	const counts = /* @__PURE__ */ new Map();
 	for (const entry of skipped) counts.set(entry.reason, (counts.get(entry.reason) ?? 0) + 1);
@@ -2940,15 +3098,27 @@ 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;
+	(0, _bamboocss_node.markStaticCompilerActive)();
 	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".
@@ -2991,6 +3161,84 @@ const bamboocss = (options = {}) => {
 	* would otherwise re-parse its module fifty times, which is the transform path.
 	*/
 	const recipeConfigCache = /* @__PURE__ */ new Map();
+	/**
+	* Which modules folded a value read out of which other module, for dev invalidation.
+	*
+	* `addWatchFile` reports the same edges, and in a build that is enough — Rollup discards a
+	* module whose watched file changed. Vite's dev server does not: a module that *statically
+	* imports* the changed one is only **soft**-invalidated, which by design keeps its cached
+	* transform result and rewrites nothing but the timestamps on its import specifiers. That
+	* cached result is where the compiled class string lives, so the edit never reaches it.
+	*
+	* The recipe case is the one users meet, because it is the one where the class is compiled
+	* into somebody else's module: an inline `cva` declaration is erased, and each *call site*
+	* becomes a literal in the module that calls it. Editing the recipe then updates the class
+	* in a module Vite has decided not to re-transform, so the browser and the SSR render keep
+	* the old class — with no error, and with Vite and Bamboo both logging as if the edit landed.
+	* A restart applies it, which is what makes it read as "recipes do not hot-reload".
+	*
+	* `css(sharedObject)` across modules fails identically; it is rarer only because a consumer
+	* that folds *nothing but* recipe calls has its import erased, and an erased import is not a
+	* static one, so Vite hard-invalidates it and the bug hides. Import one more value from the
+	* same module — the shape any real `ui.ts` has — and the import survives, and so does the
+	* stale class.
+	*
+	* Keyed by dependency, since "what changed" is the question asked, and tracked in the other
+	* direction as well so a re-transform can retract edges the module no longer has.
+	*/
+	const dependentsByDependency = /* @__PURE__ */ new Map();
+	const dependenciesByFile = /* @__PURE__ */ new Map();
+	const recordFoldDependencies = (file, dependencies) => {
+		const next = new Set(dependencies.map(normalizeFsPath).filter((dependency) => dependency !== file));
+		const previous = dependenciesByFile.get(file);
+		for (const dependency of previous ?? []) {
+			if (next.has(dependency)) continue;
+			const dependents = dependentsByDependency.get(dependency);
+			if (!dependents?.delete(file)) continue;
+			if (!dependents.size) dependentsByDependency.delete(dependency);
+		}
+		if (!next.size) {
+			dependenciesByFile.delete(file);
+			return;
+		}
+		dependenciesByFile.set(file, next);
+		for (const dependency of next) {
+			const dependents = dependentsByDependency.get(dependency);
+			if (dependents) dependents.add(file);
+			else dependentsByDependency.set(dependency, new Set([file]));
+		}
+	};
+	/**
+	* Modules to re-transform because `file` changed, hard-invalidated on the way out.
+	*
+	* Both halves are load-bearing. Invalidating drops the stale compiled result, which is the
+	* defect itself; returning the modules is what makes Vite propagate an update for them, so
+	* the client applies one rather than waiting for whatever request happens next.
+	*
+	* Invalidating here rather than leaving it to `updateModules` also survives another plugin
+	* filtering the list afterwards — a framework's own `hotUpdate` decides what its route
+	* modules do, and the stale bytes have to go either way.
+	*
+	* A consumer Vite already reached costs nothing: `propagateUpdate` skips a module it has
+	* traversed, and every consumer of a *resolvable* dependency is one, since `addWatchFile`
+	* makes it an importer whether or not the import survived the fold. What is left is the
+	* consumer of a dependency with no module of its own, where Vite matched nothing and would
+	* have done nothing at all. That one can end in a page reload, which is the honest outcome:
+	* its compiled classes really did change, and a reload is what Vite does with any update
+	* nothing accepts.
+	*/
+	const foldDependentModules = (file, modules, graph) => {
+		const dependents = dependentsByDependency.get(normalizeFsPath(file));
+		if (!dependents?.size) return;
+		const added = [];
+		for (const dependent of dependents) for (const module of graph.getModulesByFile(dependent) ?? []) {
+			if (modules.includes(module) || added.includes(module)) continue;
+			graph.invalidateModule(module);
+			added.push(module);
+		}
+		if (!added.length) return;
+		return [...modules, ...added];
+	};
 	let ctx;
 	let runtimeCss;
 	let styleCompiler;
@@ -3011,7 +3259,7 @@ const bamboocss = (options = {}) => {
 		configPath,
 		cwd,
 		session: staticSession,
-		renameCssAsset
+		pruneCss
 	}), {
 		name: "bamboocss:compiler",
 		enforce: "pre",
@@ -3023,12 +3271,11 @@ 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();
+				dependentsByDependency.clear();
+				dependenciesByFile.clear();
 				resetStaticCompilationSession(staticSession);
 			}
 			staticSession.startedEnvironments.add(environment);
@@ -3066,10 +3313,40 @@ const bamboocss = (options = {}) => {
 			recipeConfigCache.clear();
 			if (change.event === "delete") {
 				ctx.project.removeSourceFile(filePath);
+				recordFoldDependencies(normalizeFsPath(filePath), []);
 				return;
 			}
 			ctx.project.reloadSourceFile(filePath);
 		},
+		/**
+		* Re-transform whatever folded a value out of the file that just changed.
+		*
+		* Dev only — `hotUpdate` does not run in a build, where Rollup's own invalidation already
+		* covers this — and additive: the modules Vite matched are returned alongside, so this
+		* decides nothing about them.
+		*
+		* `handleHotUpdate` below stands in on Vite 5, which has no `hotUpdate`. Not quite the
+		* same thing: Vite 5 calls that hook for an update and not for a file appearing or being
+		* deleted, so a recipe file *created* while the server runs leaves its consumers stale
+		* there. Vite 6 and up call `hotUpdate` for all three, and never call `handleHotUpdate`
+		* when a plugin has both — including its deprecation warning — so exactly one of the two
+		* runs on any supported version.
+		*
+		* `environment` optional-chained for the same reason `addWatchFile` is in `transform`:
+		* a harness driving the hook need not supply a full plugin context, and a `TypeError`
+		* here is swallowed into an HMR error payload that a middleware-mode server sends
+		* nowhere.
+		*/
+		hotUpdate({ file, modules }) {
+			const graph = this.environment?.moduleGraph;
+			if (!graph) return;
+			return foldDependentModules(file, modules, graph);
+		},
+		handleHotUpdate({ file, modules, server }) {
+			const legacy = server;
+			if (legacy.environments) return;
+			return foldDependentModules(file, modules, legacy.moduleGraph);
+		},
 		async transform(code, id) {
 			if (!shouldTransform(id)) return null;
 			try {
@@ -3101,8 +3378,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 +3391,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) {
@@ -3130,6 +3414,7 @@ const bamboocss = (options = {}) => {
 			}
 			if (reportSkipped && result.skipped.length) _bamboocss_logger.logger.info("vite:transform", formatSkipped(filePath, result.skipped));
 			for (const dependency of result.dependencies) this.addWatchFile?.(dependency);
+			recordFoldDependencies(normalizeFsPath(filePath), result.dependencies);
 			const forFile = survivorsByFile.get(filePath);
 			if (command === "serve" && forFile?.length) throw createSurvivorError(forFile);
 			if (!result.folded.length) return null;
@@ -3148,7 +3433,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 +3444,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

@@ -1,4 +1,5 @@
-import { Builder, loadConfigAndCreateContext } from "@bamboocss/node";
+import { findConfig, getConfigDependencies } from "@bamboocss/config";
+import { Builder, loadConfigAndCreateContext, markStaticCompilerActive } from "@bamboocss/node";
 import { logger } from "@bamboocss/logger";
 import { compact, createCssUncached, createMergeCss, esc, memo, toHash, truncateList, viewTransitionClassName } from "@bamboocss/shared";
 import remapping from "@ampproject/remapping";
@@ -276,14 +277,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 +301,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 +323,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.
 	*
@@ -396,6 +397,39 @@ const bamboocssCss = (options) => {
 		configResolved(config) {
 			command = config.command;
 			session.sourcemap = config.build.sourcemap;
+			/**
+			* Tell Vite that `bamboo.config.ts` is a config file, so editing one restarts the server.
+			*
+			* Tokens live there, and they are what a designer iterates on most — "restart the dev
+			* server to see a colour change" is the wrong instruction for the file most likely to be
+			* edited all afternoon. Nothing watched it: `watch` is the CLI's own watcher, and a
+			* project running `vite dev` never reaches it.
+			*
+			* A restart rather than re-emitting the stylesheet, because this plugin and the compiler
+			* hold *separate* contexts and only this one reloads its config. A token *value* edit
+			* came out right on the next source change, and an edit that changes what compiles —
+			* adding a token, a condition, a utility — left the compiler naming classes from the old
+			* config against a sheet emitted from the new one. Half-updated is worse than stale.
+			*
+			* Through Vite's own list rather than a watcher of ours. Vite adds these paths to the
+			* files it watches, which is what reaches a config *outside* `root` — a monorepo with one
+			* config above `apps/web`, or a preset resolved into `node_modules`, neither of which the
+			* project watcher covers. It also means the restart is Vite's, with its own concurrency
+			* guard and its own error reporting, rather than a second implementation of both.
+			*
+			* The config's own import graph is resolved the way `Builder` resolves it, minus the
+			* tsconfig paths it has not loaded yet at this point. `dependencies` globs are not
+			* expanded here: they are declared as an escape hatch for a *config reload*, and turning
+			* every file matching one into a full server restart is not what a project asking for
+			* that meant.
+			*/
+			if (config.command === "serve") try {
+				const { deps } = getConfigDependencies(findConfig({
+					cwd: cwd ?? config.root,
+					file: configPath
+				}));
+				config.configFileDependencies.push(...deps);
+			} catch {}
 			if (config.builder && config.environments) session.expectedEnvironments = new Set(Object.keys(config.environments));
 		},
 		/**
@@ -459,18 +493,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 +521,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 +606,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 +2969,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;
@@ -2891,6 +3037,18 @@ const isGeneratedOutput = (filePath, ctx) => {
 };
 /** 1-indexed line of a source offset, for an error a user can navigate to. */
 const lineAt = (code, offset) => code.slice(0, offset).split("\n").length;
+/**
+* One spelling for a path used as a map key against paths from somewhere else.
+*
+* The fold reports dependencies as ts-morph sees them and Vite reports a changed file as its
+* watcher saw it. On Windows those differ by separator, and can differ by the case of the
+* drive letter alone — chokidar reports what the OS handed it, `path.resolve` preserves
+* whatever the cwd had. Either would make every lookup below miss and restore the exact
+* staleness they exist to fix, silently, since a miss is indistinguishable from a module that
+* folded nothing. Only the drive letter is case-folded: the rest of the path is compared as
+* written, because elsewhere the filesystem may well be case-sensitive.
+*/
+const normalizeFsPath = (file) => resolve(file).replaceAll("\\", "/").replace(/^[a-z]:\//, (drive) => drive.toUpperCase());
 const formatSkipped = (id, skipped) => {
 	const counts = /* @__PURE__ */ new Map();
 	for (const entry of skipped) counts.set(entry.reason, (counts.get(entry.reason) ?? 0) + 1);
@@ -2910,15 +3068,27 @@ 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;
+	markStaticCompilerActive();
 	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".
@@ -2961,6 +3131,84 @@ const bamboocss = (options = {}) => {
 	* would otherwise re-parse its module fifty times, which is the transform path.
 	*/
 	const recipeConfigCache = /* @__PURE__ */ new Map();
+	/**
+	* Which modules folded a value read out of which other module, for dev invalidation.
+	*
+	* `addWatchFile` reports the same edges, and in a build that is enough — Rollup discards a
+	* module whose watched file changed. Vite's dev server does not: a module that *statically
+	* imports* the changed one is only **soft**-invalidated, which by design keeps its cached
+	* transform result and rewrites nothing but the timestamps on its import specifiers. That
+	* cached result is where the compiled class string lives, so the edit never reaches it.
+	*
+	* The recipe case is the one users meet, because it is the one where the class is compiled
+	* into somebody else's module: an inline `cva` declaration is erased, and each *call site*
+	* becomes a literal in the module that calls it. Editing the recipe then updates the class
+	* in a module Vite has decided not to re-transform, so the browser and the SSR render keep
+	* the old class — with no error, and with Vite and Bamboo both logging as if the edit landed.
+	* A restart applies it, which is what makes it read as "recipes do not hot-reload".
+	*
+	* `css(sharedObject)` across modules fails identically; it is rarer only because a consumer
+	* that folds *nothing but* recipe calls has its import erased, and an erased import is not a
+	* static one, so Vite hard-invalidates it and the bug hides. Import one more value from the
+	* same module — the shape any real `ui.ts` has — and the import survives, and so does the
+	* stale class.
+	*
+	* Keyed by dependency, since "what changed" is the question asked, and tracked in the other
+	* direction as well so a re-transform can retract edges the module no longer has.
+	*/
+	const dependentsByDependency = /* @__PURE__ */ new Map();
+	const dependenciesByFile = /* @__PURE__ */ new Map();
+	const recordFoldDependencies = (file, dependencies) => {
+		const next = new Set(dependencies.map(normalizeFsPath).filter((dependency) => dependency !== file));
+		const previous = dependenciesByFile.get(file);
+		for (const dependency of previous ?? []) {
+			if (next.has(dependency)) continue;
+			const dependents = dependentsByDependency.get(dependency);
+			if (!dependents?.delete(file)) continue;
+			if (!dependents.size) dependentsByDependency.delete(dependency);
+		}
+		if (!next.size) {
+			dependenciesByFile.delete(file);
+			return;
+		}
+		dependenciesByFile.set(file, next);
+		for (const dependency of next) {
+			const dependents = dependentsByDependency.get(dependency);
+			if (dependents) dependents.add(file);
+			else dependentsByDependency.set(dependency, new Set([file]));
+		}
+	};
+	/**
+	* Modules to re-transform because `file` changed, hard-invalidated on the way out.
+	*
+	* Both halves are load-bearing. Invalidating drops the stale compiled result, which is the
+	* defect itself; returning the modules is what makes Vite propagate an update for them, so
+	* the client applies one rather than waiting for whatever request happens next.
+	*
+	* Invalidating here rather than leaving it to `updateModules` also survives another plugin
+	* filtering the list afterwards — a framework's own `hotUpdate` decides what its route
+	* modules do, and the stale bytes have to go either way.
+	*
+	* A consumer Vite already reached costs nothing: `propagateUpdate` skips a module it has
+	* traversed, and every consumer of a *resolvable* dependency is one, since `addWatchFile`
+	* makes it an importer whether or not the import survived the fold. What is left is the
+	* consumer of a dependency with no module of its own, where Vite matched nothing and would
+	* have done nothing at all. That one can end in a page reload, which is the honest outcome:
+	* its compiled classes really did change, and a reload is what Vite does with any update
+	* nothing accepts.
+	*/
+	const foldDependentModules = (file, modules, graph) => {
+		const dependents = dependentsByDependency.get(normalizeFsPath(file));
+		if (!dependents?.size) return;
+		const added = [];
+		for (const dependent of dependents) for (const module of graph.getModulesByFile(dependent) ?? []) {
+			if (modules.includes(module) || added.includes(module)) continue;
+			graph.invalidateModule(module);
+			added.push(module);
+		}
+		if (!added.length) return;
+		return [...modules, ...added];
+	};
 	let ctx;
 	let runtimeCss;
 	let styleCompiler;
@@ -2981,7 +3229,7 @@ const bamboocss = (options = {}) => {
 		configPath,
 		cwd,
 		session: staticSession,
-		renameCssAsset
+		pruneCss
 	}), {
 		name: "bamboocss:compiler",
 		enforce: "pre",
@@ -2993,12 +3241,11 @@ 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();
+				dependentsByDependency.clear();
+				dependenciesByFile.clear();
 				resetStaticCompilationSession(staticSession);
 			}
 			staticSession.startedEnvironments.add(environment);
@@ -3036,10 +3283,40 @@ const bamboocss = (options = {}) => {
 			recipeConfigCache.clear();
 			if (change.event === "delete") {
 				ctx.project.removeSourceFile(filePath);
+				recordFoldDependencies(normalizeFsPath(filePath), []);
 				return;
 			}
 			ctx.project.reloadSourceFile(filePath);
 		},
+		/**
+		* Re-transform whatever folded a value out of the file that just changed.
+		*
+		* Dev only — `hotUpdate` does not run in a build, where Rollup's own invalidation already
+		* covers this — and additive: the modules Vite matched are returned alongside, so this
+		* decides nothing about them.
+		*
+		* `handleHotUpdate` below stands in on Vite 5, which has no `hotUpdate`. Not quite the
+		* same thing: Vite 5 calls that hook for an update and not for a file appearing or being
+		* deleted, so a recipe file *created* while the server runs leaves its consumers stale
+		* there. Vite 6 and up call `hotUpdate` for all three, and never call `handleHotUpdate`
+		* when a plugin has both — including its deprecation warning — so exactly one of the two
+		* runs on any supported version.
+		*
+		* `environment` optional-chained for the same reason `addWatchFile` is in `transform`:
+		* a harness driving the hook need not supply a full plugin context, and a `TypeError`
+		* here is swallowed into an HMR error payload that a middleware-mode server sends
+		* nowhere.
+		*/
+		hotUpdate({ file, modules }) {
+			const graph = this.environment?.moduleGraph;
+			if (!graph) return;
+			return foldDependentModules(file, modules, graph);
+		},
+		handleHotUpdate({ file, modules, server }) {
+			const legacy = server;
+			if (legacy.environments) return;
+			return foldDependentModules(file, modules, legacy.moduleGraph);
+		},
 		async transform(code, id) {
 			if (!shouldTransform(id)) return null;
 			try {
@@ -3071,8 +3348,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 +3361,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) {
@@ -3100,6 +3384,7 @@ const bamboocss = (options = {}) => {
 			}
 			if (reportSkipped && result.skipped.length) logger.info("vite:transform", formatSkipped(filePath, result.skipped));
 			for (const dependency of result.dependencies) this.addWatchFile?.(dependency);
+			recordFoldDependencies(normalizeFsPath(filePath), result.dependencies);
 			const forFile = survivorsByFile.get(filePath);
 			if (command === "serve" && forFile?.length) throw createSurvivorError(forFile);
 			if (!result.folded.length) return null;
@@ -3118,7 +3403,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 +3414,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.39.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/core": "1.39.0",
+    "@bamboocss/extractor": "1.39.0",
+    "@bamboocss/config": "1.39.0",
+    "@bamboocss/logger": "1.39.0",
+    "@bamboocss/node": "1.39.0",
+    "@bamboocss/shared": "1.39.0",
+    "@bamboocss/types": "1.39.0"
   },
   "devDependencies": {
     "@jridgewell/trace-mapping": "^0.3.31",
     "vite": "7.2.6",
-    "@bamboocss/fixture": "1.37.13"
+    "@bamboocss/fixture": "1.39.0"
   },
   "peerDependencies": {
     "vite": ">=5"