@bamboocss/vite 1.53.1 → 1.54.1

package/dist/index.cjs

@@ -4,11 +4,11 @@ Object.defineProperties(exports, {
 });
 require("./chunk.cjs");
 const require_class_name = require("./class-name.cjs");
+let node_path = require("node:path");
 let _bamboocss_logger = require("@bamboocss/logger");
 let _bamboocss_shared = require("@bamboocss/shared");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
-let node_path = require("node:path");
 let _bamboocss_node_static_compiler = require("@bamboocss/node/static-compiler");
 //#region src/lazy-modules.ts
 /**
@@ -64,6 +64,7 @@ const createCompilationHost = (options = {}) => {
 	const { configPath, cwd } = options;
 	const loadBuilder = options.loadBuilder ?? createLazyBuilder();
 	let command = "build";
+	let devSourcemap = false;
 	let builder;
 	let generation;
 	let nextGenerationId = 0;
@@ -126,6 +127,7 @@ const createCompilationHost = (options = {}) => {
 				configPath,
 				cwd,
 				dev: command === "serve",
+				atomOrigins: command === "serve" && devSourcemap,
 				...command === "serve" ? { sourceChanges } : {}
 			});
 			return publish();
@@ -158,6 +160,12 @@ const createCompilationHost = (options = {}) => {
 		setCommand(next) {
 			command = next;
 		},
+		setDevSourcemap(enabled) {
+			devSourcemap = enabled;
+		},
+		isSourceFile(filePath) {
+			return builder?.context ? builder.isPotentialSourceFile(filePath) : true;
+		},
 		current: () => generation,
 		async ensureGeneration() {
 			if (cssPass) await settled(cssPass);
@@ -216,6 +224,11 @@ const createStaticCompilationSession = () => {
 		participatingEnvironments: /* @__PURE__ */ new Set(),
 		completedEnvironments: /* @__PURE__ */ new Set(),
 		prunedClasses: /* @__PURE__ */ new Set(),
+		deferredSheets: [],
+		writtenOutputs: [],
+		prunedAssets: /* @__PURE__ */ new WeakSet(),
+		prunedSheetNames: /* @__PURE__ */ new WeakMap(),
+		splitCss: true,
 		beginOutputProjection(_environment, _outputOptions, _bundle, replacesGeneratedStylesheet) {
 			if (replacesGeneratedStylesheet) session.prunedClasses.clear();
 			const prunable = new Set([...session.prunableClasses].map((className) => className.replaceAll("\\", "")));
@@ -305,6 +318,173 @@ const queryOf = (id) => {
 */
 const asError = (error, context) => error instanceof Error ? error : new Error(`bamboocss: ${context}: ${String(error)}`, { cause: error });
 /**
+* Which lazily loaded chunk each atom exclusive to one belongs to.
+*
+* An atom belongs to a chunk when every module that emits it is in that chunk, and the chunk
+* is not loaded with an entry anyway — an entry, or anything an entry statically imports,
+* would put the atom in the entry sheet's own company either way. An atom two chunks share,
+* or one no compiled module emits — `staticCss` — has no owner and stays where every route
+* finds it. Loading with an entry is the static import closure of every entry, which is what
+* the browser fetches before the first render.
+*/
+const chunkOwnership = (bundle, environment, session) => {
+	const classNamesOf = session.classNamesOf;
+	const ownership = /* @__PURE__ */ new Map();
+	if (!classNamesOf) return ownership;
+	const chunks = Object.values(bundle).filter((output) => output.type === "chunk");
+	const byFileName = new Map(chunks.map((chunk) => [chunk.fileName, chunk]));
+	const eager = /* @__PURE__ */ new Set();
+	const visit = (fileName) => {
+		if (eager.has(fileName)) return;
+		eager.add(fileName);
+		for (const imported of byFileName.get(fileName)?.imports ?? []) visit(imported);
+	};
+	for (const chunk of chunks) if (chunk.isEntry) visit(chunk.fileName);
+	const owners = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const owner = eager.has(chunk.fileName) ? null : chunk.fileName;
+		for (const moduleId of Object.keys(chunk.modules)) for (const classNames of classNamesOf(environment, moduleId) ?? []) for (const token of classNames.split(" ")) {
+			if (!token) continue;
+			const className = require_class_name.bare(token);
+			const previous = owners.get(className);
+			if (previous === void 0) owners.set(className, owner);
+			else if (previous !== owner) owners.set(className, null);
+		}
+	}
+	for (const [className, owner] of owners) if (owner !== null) ownership.set(className, owner);
+	_bamboocss_logger.logger.debug("vite", `Split: ${chunks.length} chunk(s), ${eager.size} loaded with an entry, ${owners.size} atom(s) seen, ${ownership.size} owned by a lazy chunk.`);
+	return ownership;
+};
+/**
+* Prune every generated sheet in `bundle` this generation has not pruned yet.
+*
+* Reached twice per output. The early hook, ordered `pre`, reaches a sheet Vite emitted while
+* rendering chunks — every `cssCodeSplit: true` build — before any other plugin's
+* `generateBundle` reads its name, so a framework recording asset names records the final one.
+* That was not a courtesy: `@vitejs/plugin-rsc` snapshots the server build's stylesheet name in
+* a normal-order hook and writes it into a manifest at the end of the run, so a rename in a
+* `post` hook left every server-rendered page linking a stylesheet that no longer existed. The
+* late hook, ordered `post`, reaches what Vite emits from its own `generateBundle` — the single
+* `style.css` of a `cssCodeSplit: false` build. Exactly one of the two opens a projection for a
+* given sheet.
+*
+* Pruning waits for no one; finalizing does. The stylesheet is emitted by the environment that
+* *imports* it, which in an SSR app is the client — and the client builds first, before the
+* server environment has transformed a single module. Two answers were tried before this one.
+* Holding the sheet back until every environment had contributed meant never pruning in any SSR
+* framework, since the client's output is on disk before the server starts. Pruning against the
+* client alone, with a guard that failed the build when a later environment reached a rule it had
+* removed, made a styled component that renders only on the server a build failure — and under
+* React Server Components most components never reach the client graph at all.
+*
+* So while environments remain, the sheet is pruned against what the run knows so far and
+* written under a name hashed from those bytes, and it is recorded as deferred with its unpruned
+* source. When the last environment writes its output, `bamboocss:output-write-observer` prunes
+* that source again against the union of every environment's reachability. Usually the result is
+* the bytes already on disk, and nothing moves. When a later environment restored a rule, the
+* final bytes go under a new name, every written reference moves with them, and so does any copy
+* of the provisional sheet another output carries. A single-environment build, a run whose
+* sheet-carrying environment builds last, and an in-memory build take the direct path, where the
+* guard in `buildEnd` still fails a later environment that reaches a rule the sheet lost.
+*/
+const pruneEmittedSheets = async (context, session, outputOptions, bundle, isWrite, pruneCss, splitCss) => {
+	const { containsGeneratedCssAsset, optimizeStaticCssAssets } = await loadCssOutputModule();
+	let handledNames = session.prunedSheetNames.get(outputOptions);
+	if (!handledNames) {
+		handledNames = /* @__PURE__ */ new Set();
+		session.prunedSheetNames.set(outputOptions, handledNames);
+	}
+	const carriesSheet = containsGeneratedCssAsset(bundle, session.prunedAssets, handledNames);
+	const environmentName = context.environment?.name ?? "default";
+	const pending = remainingEnvironments(session, environmentName);
+	const completesRun = !pending.length && session.deferredSheets.length > 0;
+	if (!carriesSheet && !completesRun) return;
+	const outputProjection = session.beginOutputProjection(environmentName, outputOptions, bundle, carriesSheet);
+	try {
+		const outputDir = outputOptions.dir ?? (outputOptions.file ? (0, node_path.dirname)(outputOptions.file) : void 0);
+		const deferred = pruneCss && isWrite === true && outputDir !== void 0 && pending.length > 0;
+		const remaining = (0, _bamboocss_shared.truncateList)(pending, {
+			unit: "environment",
+			separator: ", "
+		});
+		const sourcemap = context.environment?.config?.build?.sourcemap ?? session.sourcemap;
+		if (completesRun) await session.finalizeDeferred?.({
+			environment: environmentName,
+			bundle,
+			sourcemap
+		});
+		if (!carriesSheet) return;
+		const cssCodeSplit = context.environment?.config?.build?.cssCodeSplit ?? session.cssCodeSplit ?? true;
+		const split = splitCss && session.splitCss && pruneCss && cssCodeSplit && context.emitFile && context.getFileName ? {
+			ownership: chunkOwnership(bundle, environmentName, session),
+			emit: (chunkFileName, css) => {
+				const chunk = bundle[chunkFileName];
+				const referenceId = context.emitFile({
+					type: "asset",
+					name: `${chunk?.name ?? "chunk"}.css`,
+					source: css
+				});
+				const fileName = context.getFileName(referenceId);
+				chunk?.viteMetadata?.importedCss?.add(fileName);
+				const emitted = bundle[fileName];
+				if (emitted) session.prunedAssets.add(emitted);
+			}
+		} : void 0;
+		const { sheets, results } = optimizeStaticCssAssets(bundle, session, {
+			environment: environmentName,
+			prune: pruneCss,
+			requiredClasses: outputProjection.requiredClasses,
+			sourcemap: context.environment?.config?.build?.sourcemap,
+			handled: session.prunedAssets,
+			handledNames,
+			split
+		});
+		if (sheets && !pruneCss) _bamboocss_logger.logger.info("vite", "Reachability pruning is off (`pruneCss: false`). The full extracted stylesheet ships.");
+		if (!sheets || !pruneCss || !pending.length) return;
+		if (deferred) {
+			for (const result of results) session.deferredSheets.push({
+				environment: environmentName,
+				dir: (0, node_path.resolve)(outputDir),
+				originalFileName: result.original,
+				fileName: result.fileName,
+				source: result.source,
+				provisional: result.optimized,
+				sourcemap,
+				asset: result.asset,
+				bundle,
+				moved: result.moved
+			});
+			_bamboocss_logger.logger.debug("vite", `Pruned the stylesheet against what the run knows, with ${remaining} still to compile. It is pruned again from source once the last environment has written its output, and renamed only if that restores a rule.`);
+		} else _bamboocss_logger.logger.debug("vite", `Pruning against the ${JSON.stringify(environmentName)} environment with ${remaining} still to compile. An in-memory build has no file to finalize, so a class only those reach fails the build rather than shipping without its rule.`);
+	} finally {
+		outputProjection.restore();
+	}
+};
+/**
+* The early half of the stylesheet's output lifecycle. @see `pruneEmittedSheets`
+*
+* A plugin of its own because one plugin carries one `generateBundle`, and this one has to be
+* ordered `pre` while the checks in `bamboocssCss` have to see the finished bundle.
+*/
+const bamboocssCssEarly = (options) => ({
+	name: "bamboocss:css-early",
+	sharedDuringBuild: true,
+	/**
+	* A watch rebuild renders into the same output options object, so the names pruned by the
+	* previous build would otherwise still read as handled, and the sheet a rebuild re-emits
+	* under an unchanged name would ship unpruned.
+	*/
+	renderStart(outputOptions) {
+		options.session.prunedSheetNames.delete(outputOptions);
+	},
+	generateBundle: {
+		order: "pre",
+		async handler(outputOptions, bundle, isWrite) {
+			await pruneEmittedSheets(this, options.session, outputOptions, bundle, isWrite, options.pruneCss ?? true, true);
+		}
+	}
+});
+/**
 * Serve bamboo's stylesheet as a virtual module, in dev and in build.
 *
 * This is the integration itself, not an optimisation: without it nothing emits css and
@@ -363,6 +543,13 @@ const bamboocssCss = (options) => {
 	let pendingGeneration = -1;
 	let servedCss;
 	/**
+	* Whether the served stylesheet carries a source map: a dev server with Vite's
+	* `css.devSourcemap` on. Off, and the extraction pass records no call sites at all.
+	*/
+	let devSourcemap = false;
+	/** Each atom's first call site, by class name, from the last pass. @see `Builder.getAtomOrigins` */
+	let atomOrigins;
+	/**
 	* Held by the host for its whole length, rather than only around each mutation.
 	*
 	* Extraction fills the encoder this sheet is emitted from and `toCss` reads it back, with a
@@ -388,6 +575,7 @@ const bamboocssCss = (options) => {
 			graphAtomHashes = new Set(activeBuilder.context.encoder.atomic);
 		}
 		const css = activeBuilder.toCss({ layerParams: true });
+		atomOrigins = devSourcemap ? activeBuilder.getAtomOrigins?.() : void 0;
 		session.prunableClasses.clear();
 		session.viewTransitionClasses.clear();
 		if (graphAtomHashes && activeBuilder.context) {
@@ -480,7 +668,10 @@ const bamboocssCss = (options) => {
 		async configResolved(config) {
 			command = config.command;
 			host.setCommand(config.command);
+			devSourcemap = config.command === "serve" && Boolean(config.css?.devSourcemap);
+			host.setDevSourcemap(devSourcemap);
 			session.sourcemap = config.build.sourcemap;
+			session.cssCodeSplit = config.build.cssCodeSplit;
 			ssrBuildOptions = {
 				ssr: config.build.ssr,
 				ssrEmitAssets: config.build.ssrEmitAssets
@@ -556,24 +747,34 @@ const bamboocssCss = (options) => {
 			const generationAtStart = changeGeneration;
 			if (command === "serve" && servedCss?.generation === generationAtStart) {
 				if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
-				return servedCss.css;
+				return servedCss.map ? {
+					code: servedCss.css,
+					map: servedCss.map
+				} : servedCss.css;
 			}
 			let css;
+			let map;
 			try {
-				const validateDevCss = command === "serve" ? (await loadCssOutput()).pruneStaticCss : void 0;
+				const cssOutput = command === "serve" ? await loadCssOutput() : void 0;
+				const validateDevCss = cssOutput?.pruneStaticCss;
 				const first = prebuilt;
 				prebuilt = void 0;
 				css = await (first ?? generate());
 				if (validateDevCss) css = validateDevCss(css, session, { prune: false });
+				if (devSourcemap && atomOrigins?.size) map = cssOutput?.cssSourceMap?.(css, atomOrigins);
 			} catch (error) {
 				throw asError(error, `failed to generate ${VIRTUAL_CSS_ID}`);
 			}
 			if (command === "serve" && generationAtStart === changeGeneration) servedCss = {
 				generation: generationAtStart,
-				css
+				css,
+				map
 			};
 			if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
-			return css;
+			return map ? {
+				code: css,
+				map
+			} : css;
 		},
 		configureServer(devServer) {
 			server = devServer;
@@ -615,49 +816,15 @@ const bamboocssCss = (options) => {
 		},
 		generateBundle: {
 			order: "post",
-			async handler(outputOptions, bundle) {
-				const { containsGeneratedCssAsset, optimizeStaticCssAssets } = await loadCssOutputModule();
-				const environment = this.environment;
+			async handler(outputOptions, bundle, isWrite) {
+				const context = this;
+				await pruneEmittedSheets(context, session, outputOptions, bundle, isWrite, pruneCss, false);
+				const { containsGeneratedCssAsset } = await loadCssOutputModule();
+				const environment = context.environment;
 				const environmentName = environment?.name ?? "default";
 				const replacesGeneratedStylesheet = containsGeneratedCssAsset(bundle);
-				const outputProjection = session.beginOutputProjection(environmentName, outputOptions, bundle, replacesGeneratedStylesheet);
+				const outputProjection = session.beginOutputProjection(environmentName, outputOptions, bundle, false);
 				try {
-					/**
-					* Pruned against what this environment compiled, without waiting for the rest.
-					*
-					* The stylesheet is emitted and finalized by the environment that *imports* it, which
-					* in an SSR app is the client — and the client builds first, before the server
-					* environment has transformed a single module. Waiting for a complete answer therefore
-					* meant never pruning at all in any SSR framework: react-router, Remix, Nuxt, SvelteKit
-					* and Qwik all build the client first, and the client's output is on disk before the
-					* server environment starts. That is most production apps, and the feature was inert in
-					* every one of them — silently, since a build with nothing to prune looks identical.
-					*
-					* The reason for waiting was real: a class only the server graph reaches is not in this
-					* environment's reachability set, so pruning here removes rules the server-rendered
-					* markup still names. What makes it safe to prune anyway is that the mistake is
-					* *detectable* rather than silent — `buildEnd` in `plugin.ts` intersects every later
-					* environment's compiled classes against `prunedClasses` and fails the build naming
-					* them. A styled component that only ever renders on the server is the shape that
-					* trips it, and `pruneCss: false` is the answer when it does.
-					*
-					* So the trade is deliberate: a loud build failure in the rare case, in exchange for
-					* the feature working at all in the common one. It is the same reasoning as the
-					* unimported-`virtual:bamboo.css` check — a class with no rule behind it must never
-					* leave the build quietly.
-					*/
-					const pending = remainingEnvironments(session);
-					if (pending.length) _bamboocss_logger.logger.debug("vite", `Pruning against the ${JSON.stringify(environment?.name ?? "default")} environment with ${(0, _bamboocss_shared.truncateList)(pending, {
-						unit: "environment",
-						separator: ", "
-					})} still to compile. A class only those reach fails the build rather than shipping without its rule.`);
-					const { sheets } = optimizeStaticCssAssets(bundle, session, {
-						environment: environmentName,
-						prune: pruneCss,
-						requiredClasses: outputProjection.requiredClasses,
-						sourcemap: environment?.config?.build?.sourcemap
-					});
-					if (sheets && !pruneCss) _bamboocss_logger.logger.info("vite", "Reachability pruning is off (`pruneCss: false`). The full extracted stylesheet ships.");
 					if (!outputProjection.cssLoaded) return;
 					if (!session.transformedFiles.size) return;
 					/**
@@ -759,6 +926,64 @@ const shouldTransform = (id) => {
 * Returns `null` when the module is still a raw SFC and must be left to the framework plugin.
 * Astro frontmatter is `---`, not `<script>`, so a tag check alone would parse the template.
 */
+/** The module specifiers that reach bamboo — the `styled-system` paths and any `importMap` — per context. */
+const entrypointNeedles = /* @__PURE__ */ new WeakMap();
+/**
+* Whether a module's text names a bamboo entrypoint at all.
+*
+* A textual test on purpose: it runs before the module is parsed, on modules outside the
+* extraction inventory, to decide whether parsing is worth it. The outdir's own name is among
+* the needles, so a relative import of the generated `styled-system` counts too.
+*/
+const namesEntrypoint = (ctx, code) => {
+	let needles = entrypointNeedles.get(ctx);
+	if (!needles) {
+		const outdirName = ctx.imports.outdir.split("/").filter(Boolean).at(-1);
+		needles = [...new Set([outdirName ?? "", ...Object.values(ctx.imports.value).flat()].filter((needle) => needle.length > 0))];
+		entrypointNeedles.set(ctx, needles);
+	}
+	return needles.some((needle) => code.includes(needle));
+};
+/** A module specifier in an import, export-from, dynamic import or require. */
+const MODULE_SPECIFIER = /\b(?:from|import|require)\s*\(?\s*['"]([^'"]+)['"]/g;
+/** How a relative specifier may name a file, in the order the bundler tries them. */
+const SPECIFIER_SUFFIXES = [
+	"",
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	"/index.ts",
+	"/index.tsx",
+	"/index.js"
+];
+/**
+* Whether a module imports a module the shared project holds.
+*
+* Answered from project membership alone — no parse, no disk, no round trip to the compiler —
+* which is what makes it affordable to ask of every module outside the extraction inventory.
+* A relative specifier is tried against the file names a bundler would; a bare one against
+* where the parser last resolved that package to, since a package the project holds a source
+* of is one an included file imports a recipe from.
+*/
+const importsProjectModule = (ctx, filePath, code) => {
+	const directory = (0, node_path.dirname)(filePath);
+	for (const match of code.matchAll(MODULE_SPECIFIER)) {
+		const specifier = match[1];
+		if (specifier.startsWith(".") || specifier.startsWith("/")) {
+			const base = specifier.startsWith("/") ? specifier : (0, node_path.resolve)(directory, specifier);
+			for (const suffix of SPECIFIER_SUFFIXES) if (ctx.project.hasSourceFile(base + suffix)) return true;
+			continue;
+		}
+		const target = ctx.project.bareSpecifierTarget(specifier);
+		if (target && ctx.project.hasSourceFile(target)) return true;
+	}
+	return false;
+};
 const compilerParsePath = (id, code) => {
 	const [filePath, query = ""] = id.split("?");
 	if (!filePath) return null;
@@ -837,11 +1062,12 @@ const formatSkipped = (id, skipped) => {
 * therefore fold in the post plugin, after the framework has extracted them.
 */
 const bamboocss = (options = {}) => {
-	const { configPath, cwd, reportSkipped = false, reportSummary = true, maxRecipeStates, pruneCss = true } = options;
+	const { configPath, cwd, reportSkipped = false, reportSummary = true, maxRecipeStates, pruneCss = true, splitCss = true } = options;
 	(0, _bamboocss_node_static_compiler.markStaticCompilerActive)();
 	if (maxRecipeStates !== void 0 && (!Number.isSafeInteger(maxRecipeStates) || maxRecipeStates < 1)) throw new Error("bamboocss: `maxRecipeStates` must be a positive safe integer.");
 	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.");
 	const staticSession = createStaticCompilationSession();
+	staticSession.splitCss = splitCss;
 	/**
 	* One Builder, one resolved config, one context and one ts-morph project for the run.
 	*
@@ -1271,6 +1497,42 @@ const bamboocss = (options = {}) => {
 		staticSession.prunedClasses.clear();
 		for (const slots of liveOutputSlotsByEnvironment.values()) for (const slot of slots.values()) for (const className of slot.prunedClasses ?? []) staticSession.prunedClasses.add(className);
 	};
+	/**
+	* Prune the sheets the run wrote whole, now that every environment has contributed.
+	*
+	* Reached from the write hook of whichever environment completes the run, which is the first
+	* point at which the union of every environment's reachability exists and every reference to
+	* the sheet is on disk. A run that never completes — an environment declared and never built
+	* — leaves the sheets whole, and says so as the process exits.
+	*/
+	const finalizeDeferredSheetsIfComplete = async (candidate, bundle, sourcemap) => {
+		if (!staticSession.deferredSheets.length) return;
+		if (remainingEnvironments(staticSession, candidate).length) return;
+		const sheets = staticSession.deferredSheets.splice(0);
+		const { finalizeDeferredSheets } = await loadCssOutputModule();
+		const committed = staticSession.prunedClasses;
+		staticSession.prunedClasses = /* @__PURE__ */ new Set();
+		let finalized;
+		let lost;
+		try {
+			finalized = finalizeDeferredSheets(sheets, staticSession, {
+				prune: pruneCss,
+				requiredClasses: currentRequiredClasses(),
+				outputs: staticSession.writtenOutputs,
+				bundle,
+				sourcemap
+			});
+		} finally {
+			lost = staticSession.prunedClasses;
+			staticSession.prunedClasses = committed;
+		}
+		for (const sheet of finalized) for (const slot of liveOutputSlotsByEnvironment.get(sheet.environment)?.values() ?? []) slot.prunedClasses = new Set(lost);
+		rebuildLivePrunedClasses();
+		for (const sheet of finalized) {
+			if (!sheet.renamed) continue;
+			_bamboocss_logger.logger.info("vite", `Pruned ${sheet.originalFileName} against every environment once the last had written, which restored a rule the earlier prune removed: ${sheet.before} → ${sheet.after} bytes, now ${sheet.renamed}.`);
+		}
+	};
 	const observeEnvironmentBuildStart = (environment) => {
 		const serial = (nextBuildSerialByEnvironment.get(environment) ?? 0) + 1;
 		nextBuildSerialByEnvironment.set(environment, serial);
@@ -1390,6 +1652,8 @@ const bamboocss = (options = {}) => {
 		rebuildStaticTransformContributions();
 		rebuildLivePrunedClasses();
 	};
+	staticSession.finalizeDeferred = ({ environment, bundle, sourcemap }) => finalizeDeferredSheetsIfComplete(environment, bundle, sourcemap);
+	staticSession.classNamesOf = (environment, moduleId) => transformStateByEnvironment.get(environment)?.transformArtifactsByModule.get(moduleId)?.classNames;
 	staticSession.beginOutputProjection = (environment, outputOptions, bundle, replacesGeneratedStylesheet) => {
 		const generation = preparedGenerations.get(environment);
 		if (!generation || transformStateByEnvironment.get(environment) !== generation.state) {
@@ -1412,9 +1676,13 @@ const bamboocss = (options = {}) => {
 			restore() {
 				if (restored) return;
 				restored = true;
+				const previous = outputStageByBundle.get(bundle) ?? outputStageByOptions.get(outputOptions);
 				const stage = replacesGeneratedStylesheet ? {
 					cssDigest: bambooCssDigest(bundle),
-					prunedClasses: new Set(staticSession.prunedClasses)
+					prunedClasses: new Set([...previous?.prunedClasses ?? [], ...staticSession.prunedClasses])
+				} : previous ? {
+					cssDigest: bambooCssDigest(bundle),
+					prunedClasses: new Set(previous.prunedClasses ?? [])
 				} : {};
 				outputStageByBundle.set(bundle, stage);
 				outputStageByOptions.set(outputOptions, stage);
@@ -1756,6 +2024,7 @@ const bamboocss = (options = {}) => {
 	let styleCompiler;
 	let command = "build";
 	let defaultEmitAssets = true;
+	let exitWarningInstalled = false;
 	/**
 	* Expand semantic leaf reads through the Project's exact resolution paths.
 	*
@@ -1998,6 +2267,16 @@ const bamboocss = (options = {}) => {
 			command = config.command;
 			host.setCommand(config.command);
 			defaultEmitAssets = config.build?.emitAssets ?? (!config.build?.ssr || config.build?.ssrEmitAssets === true);
+			if (config.command === "build" && !exitWarningInstalled) {
+				exitWarningInstalled = true;
+				process.once("beforeExit", () => {
+					if (!staticSession.deferredSheets.length) return;
+					_bamboocss_logger.logger.warn("vite", `The stylesheet was pruned against an incomplete run: ${(0, _bamboocss_shared.truncateList)(remainingEnvironments(staticSession), {
+						unit: "environment",
+						separator: ", "
+					})} never completed, so a rule only those reach was never restored. Build every declared environment, or set \`bamboocss({ pruneCss: false })\` to ship the full extracted stylesheet.`);
+				});
+			}
 			const plugins = config.plugins;
 			if (plugins) {
 				for (const finalizer of [outputWriteObserver, memoryOutputCommitter]) {
@@ -2182,11 +2461,11 @@ const bamboocss = (options = {}) => {
 				rebuildStaticTransformContributions(environment, state);
 				const survivors = allSurvivors(states);
 				if (survivors.length) throw createSurvivorError(survivors);
-				const lost = currentWillEmitCss ? [] : [...staticSession.usedClasses].filter((className) => staticSession.prunedClasses.has(require_class_name.bare(className)));
+				const lost = currentWillEmitCss || staticSession.deferredSheets.length ? [] : [...staticSession.usedClasses].filter((className) => staticSession.prunedClasses.has(require_class_name.bare(className)));
 				if (lost.length) 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 — the client, which builds first — so it is pruned against what that environment compiled. These classes are reached only from here, so no rule for them survived.\n\nThat usually means a styled component which renders only on the server. Either give the client a path to it, or set \`bamboocss({ pruneCss: false })\` to ship the whole extracted stylesheet.`);
+				})}\n\nThe stylesheet was pruned before this environment compiled. A run that announces its environments — \`builder\` in the Vite config, which every framework building more than one sets — holds pruning back until the last one has written, so this is a run that built environments one at a time without saying so, or a rebuild of this environment alone after the sheet was finalized. These classes are reached only from here, so no rule for them survived.\n\nConfigure \`builder\` so the run announces its environments, rebuild every environment together, or set \`bamboocss({ pruneCss: false })\` to ship the whole extracted stylesheet.`);
 				const remaining = remainingEnvironments(staticSession, environment);
 				if (typeof this.getModuleInfo === "function" && !remaining.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.`);
@@ -2231,6 +2510,10 @@ const bamboocss = (options = {}) => {
 		if (!ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return null;
 		const [filePath] = id.split("?");
 		if (isGeneratedOutput(filePath, ctx)) return null;
+		if (!(ctx.project.hasSourceFile(filePath) && ctx.project.getSourceFile(filePath)?.getFullText() === code) && !namesEntrypoint(ctx, code) && !importsProjectModule(ctx, filePath, code)) {
+			_bamboocss_logger.logger.debug("vite:transform", `Skipped ${filePath}: ${host.isSourceFile(filePath) ? "rewritten before bamboo" : "outside `include`"}, and it reaches nothing bamboo`);
+			return null;
+		}
 		const requestedParsePath = compilerParsePath(id, code);
 		if (requestedParsePath === null) return null;
 		const state = environmentState(this);
@@ -2393,9 +2676,17 @@ const bamboocss = (options = {}) => {
 		writeBundle: {
 			order: "pre",
 			sequential: true,
-			handler(outputOptions, bundle) {
+			async handler(outputOptions, bundle) {
+				const environment = environmentName(this);
+				const outputDir = outputOptions.dir ?? (outputOptions.file ? (0, node_path.dirname)(outputOptions.file) : void 0);
+				if (outputDir) staticSession.writtenOutputs.push({
+					environment,
+					dir: (0, node_path.resolve)(outputDir),
+					files: Object.values(bundle).map((output) => output.fileName)
+				});
 				const identity = outputIdentityByBundle.get(bundle) ?? outputIdentityByOptions.get(outputOptions);
-				if (identity?.environment === environmentName(this)) publishPreparedOutput(identity.environment, identity.outputToken, identity.outputSlot, true);
+				if (identity?.environment === environment) publishPreparedOutput(identity.environment, identity.outputToken, identity.outputSlot, true);
+				await finalizeDeferredSheetsIfComplete();
 			}
 		}
 	};
@@ -2419,6 +2710,10 @@ const bamboocss = (options = {}) => {
 			session: staticSession,
 			pruneCss
 		}),
+		bamboocssCssEarly({
+			session: staticSession,
+			pruneCss
+		}),
 		compiler,
 		compilerSfc
 	];

package/dist/index.d.cts

@@ -62,6 +62,17 @@ interface BambooVitePluginOptions {
    * @default true
    */
   pruneCss?: boolean;
+  /**
+   * Give each lazily loaded chunk a stylesheet of the utilities only it uses, and keep the
+   * rest in the entry sheet. Builds only, and only where Vite's own `build.cssCodeSplit` is on.
+   *
+   * An atom two chunks use stays in the entry sheet, so nothing is ever downloaded twice; a
+   * route that is the only user of a style downloads that style with the route. Precedence
+   * does not depend on which sheet a rule is in, since it lives in the cascade sublayers.
+   *
+   * @default true
+   */
+  splitCss?: boolean;
 }
 /**
  * Vite integration for Bamboo CSS.

package/dist/index.d.mts

@@ -64,6 +64,17 @@ interface BambooVitePluginOptions {
    * @default true
    */
   pruneCss?: boolean;
+  /**
+   * Give each lazily loaded chunk a stylesheet of the utilities only it uses, and keep the
+   * rest in the entry sheet. Builds only, and only where Vite's own `build.cssCodeSplit` is on.
+   *
+   * An atom two chunks use stays in the entry sheet, so nothing is ever downloaded twice; a
+   * route that is the only user of a style downloads that style with the route. Precedence
+   * does not depend on which sheet a rule is in, since it lives in the cascade sublayers.
+   *
+   * @default true
+   */
+  splitCss?: boolean;
 }
 /**
  * Vite integration for Bamboo CSS.