@bamboocss/vite 1.46.0 → 1.46.2

package/dist/fold-module.cjs

@@ -1,5 +1,6 @@
 const require_chunk = require("./chunk.cjs");
 let _bamboocss_shared = require("@bamboocss/shared");
+let node_crypto = require("node:crypto");
 let node_path = require("node:path");
 let magic_string = require("magic-string");
 magic_string = require_chunk.__toESM(magic_string);
@@ -1007,6 +1008,97 @@ const createRuntimeToken = (ctx) => (path) => tokenValuesFor(ctx).get(path)?.var
 //#endregion
 //#region src/fold.ts
 /**
+* Decide whether an edit to `changedFile` moved anything a dependent's fold actually read.
+*
+* `'unchanged'` means every recorded read of the edited file re-digests to the same value —
+* the dependent's fold inputs did not move, so its output cannot have, and the re-fold can be
+* skipped outright. `'changed'` means a read definitely differs, which is the same verdict
+* the re-fold would reach after doing all the work. `'unknown'` is every other situation —
+* no read names the edited file (the relationship runs through a channel these records do
+* not witness, a barrel hop in a recipe binding walk, say), a digest could not be pinned
+* down on either side — and sends the caller to the full re-fold this replaced.
+*
+* `digestMemo` is the per-event cache: many dependents verify against the same edited file,
+* and each distinct `(kind, file, name)` needs digesting once, not once per dependent.
+*/
+const verifyExportReads = (ctx, parseModule, reads, changedFile, digestMemo) => {
+	const relevant = reads.filter((read) => read.file === changedFile);
+	if (!relevant.length) return {
+		verdict: "unknown",
+		crossings: []
+	};
+	const crossings = /* @__PURE__ */ new Set();
+	for (const read of relevant) {
+		if (read.digest === void 0) return {
+			verdict: "unknown",
+			crossings: []
+		};
+		const key = `${read.kind}\u0000${read.file}\u0000${read.name}`;
+		if (!digestMemo.has(key)) if (read.kind === "value") {
+			const crossed = [];
+			const digest = ctx.project?.digestExportRead?.(read.file, read.name, (path) => crossed.push(path));
+			digestMemo.set(key, {
+				digest,
+				crossings: crossed
+			});
+		} else {
+			const batched = `recipe-file\u0000${read.file}`;
+			if (!digestMemo.has(batched)) {
+				try {
+					const result = parseModule(read.file);
+					if (result) for (const [name, entry] of collectRecipeConfigs(result)) digestMemo.set(`recipe\u0000${read.file}\u0000${name}`, {
+						digest: entry === AMBIGUOUS ? "bamboo:export-missing" : digestRecipeConfig(entry),
+						crossings: []
+					});
+				} catch {}
+				digestMemo.set(batched, {
+					digest: "bamboo:batched",
+					crossings: []
+				});
+			}
+			if (!digestMemo.has(key)) digestMemo.set(key, {
+				digest: digestRecipeReadNow(parseModule, read.file, read.name),
+				crossings: []
+			});
+		}
+		const entry = digestMemo.get(key);
+		if (entry.digest === void 0) return {
+			verdict: "unknown",
+			crossings: []
+		};
+		if (entry.digest !== read.digest) return {
+			verdict: "changed",
+			crossings: []
+		};
+		for (const path of entry.crossings) crossings.add(path);
+	}
+	return {
+		verdict: "unchanged",
+		crossings: [...crossings]
+	};
+};
+const digestRecipeReadNow = (parseModule, file, name) => {
+	try {
+		const result = parseModule(file);
+		if (!result) return "bamboo:module-missing";
+		const entry = collectRecipeConfigs(result).get(name);
+		if (!entry || entry === AMBIGUOUS) return "bamboo:export-missing";
+		return digestRecipeConfig(entry);
+	} catch {
+		return;
+	}
+};
+/** The verification witness for a foreign recipe read: the config bytes, order preserved. */
+const digestRecipeConfig = (entry) => {
+	try {
+		const json = JSON.stringify(entry.config, (_key, value) => value === void 0 ? "bamboo:undefined" : value);
+		if (json === void 0) return void 0;
+		return (0, node_crypto.createHash)("sha256").update(json).digest("base64");
+	} catch {
+		return;
+	}
+};
+/**
 * `cva`/`sva` return a function, so their definitions are compile-time declarations rather
 * than class-producing calls; once their uses are lowered, the factory calls are erased.
 * `token` also resolves to no class, but it does resolve to a literal, so it compiles through
@@ -1480,6 +1572,8 @@ const foldSource = (options) => {
 	const helperModules = /* @__PURE__ */ new Map();
 	/** Declaring modules a fold read, recorded as paths because their nodes do not persist. */
 	const foreignDependencies = /* @__PURE__ */ new Set();
+	/** Foreign recipe configs consumed, digested at read time for later verification. */
+	const exportReads = [];
 	/** Resolutions for this module's own call sites, keyed by the name the call site writes. */
 	const importedRecipes = /* @__PURE__ */ new Map();
 	/**
@@ -1520,6 +1614,12 @@ const foldSource = (options) => {
 			const entry = foreign.configs.get(origin.name);
 			if (!entry || entry === AMBIGUOUS) return void 0;
 			foreignDependencies.add(origin.filePath);
+			exportReads.push({
+				kind: "recipe",
+				file: origin.filePath,
+				name: origin.name,
+				digest: digestRecipeConfig(entry)
+			});
 			helperModules.set(name, foreign.cssSpecifier ? rebaseSpecifier(foreign.cssSpecifier, origin.filePath, consuming.getFilePath()) : void 0);
 			return entry;
 		};
@@ -2092,7 +2192,8 @@ const foldSource = (options) => {
 			map: null,
 			folded,
 			skipped,
-			dependencies: []
+			dependencies: [],
+			exportReads: []
 		};
 	}
 	const rewriteSourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile() ?? recipeDefinitions[0]?.call.getSourceFile();
@@ -2101,7 +2202,8 @@ const foldSource = (options) => {
 		map: null,
 		folded,
 		skipped,
-		dependencies: []
+		dependencies: [],
+		exportReads: []
 	};
 	const dependencyScan = createDependencyScan(rewriteSourceFile);
 	candidates.sort((a, b) => a.start - b.start || b.end - a.end);
@@ -2408,7 +2510,8 @@ const foldSource = (options) => {
 		map: null,
 		folded,
 		skipped,
-		dependencies: []
+		dependencies: [],
+		exportReads: []
 	};
 	return {
 		code: magic.toString(),
@@ -2419,7 +2522,8 @@ const foldSource = (options) => {
 		}),
 		folded,
 		skipped,
-		dependencies: [...dependencyScan.results, ...foreignDependencies]
+		dependencies: [...dependencyScan.results, ...foreignDependencies],
+		exportReads
 	};
 };
 //#endregion
@@ -2485,3 +2589,4 @@ const createStaticStyleSetCompiler = (ctx, runtimeCss, allocateClassString = (cl
 exports.createRuntimeCss = createRuntimeCss;
 exports.createStaticStyleSetCompiler = createStaticStyleSetCompiler;
 exports.foldSource = foldSource;
+exports.verifyExportReads = verifyExportReads;

package/dist/fold-module.mjs

@@ -1,4 +1,5 @@
 import { compact, createCssUncached, createMergeCss, memo, viewTransitionClassName } from "@bamboocss/shared";
+import { createHash } from "node:crypto";
 import { dirname, relative, resolve } from "node:path";
 import MagicString from "magic-string";
 import { resolveTsPathPattern } from "@bamboocss/config/ts-path";
@@ -1005,6 +1006,97 @@ const createRuntimeToken = (ctx) => (path) => tokenValuesFor(ctx).get(path)?.var
 //#endregion
 //#region src/fold.ts
 /**
+* Decide whether an edit to `changedFile` moved anything a dependent's fold actually read.
+*
+* `'unchanged'` means every recorded read of the edited file re-digests to the same value —
+* the dependent's fold inputs did not move, so its output cannot have, and the re-fold can be
+* skipped outright. `'changed'` means a read definitely differs, which is the same verdict
+* the re-fold would reach after doing all the work. `'unknown'` is every other situation —
+* no read names the edited file (the relationship runs through a channel these records do
+* not witness, a barrel hop in a recipe binding walk, say), a digest could not be pinned
+* down on either side — and sends the caller to the full re-fold this replaced.
+*
+* `digestMemo` is the per-event cache: many dependents verify against the same edited file,
+* and each distinct `(kind, file, name)` needs digesting once, not once per dependent.
+*/
+const verifyExportReads = (ctx, parseModule, reads, changedFile, digestMemo) => {
+	const relevant = reads.filter((read) => read.file === changedFile);
+	if (!relevant.length) return {
+		verdict: "unknown",
+		crossings: []
+	};
+	const crossings = /* @__PURE__ */ new Set();
+	for (const read of relevant) {
+		if (read.digest === void 0) return {
+			verdict: "unknown",
+			crossings: []
+		};
+		const key = `${read.kind}\u0000${read.file}\u0000${read.name}`;
+		if (!digestMemo.has(key)) if (read.kind === "value") {
+			const crossed = [];
+			const digest = ctx.project?.digestExportRead?.(read.file, read.name, (path) => crossed.push(path));
+			digestMemo.set(key, {
+				digest,
+				crossings: crossed
+			});
+		} else {
+			const batched = `recipe-file\u0000${read.file}`;
+			if (!digestMemo.has(batched)) {
+				try {
+					const result = parseModule(read.file);
+					if (result) for (const [name, entry] of collectRecipeConfigs(result)) digestMemo.set(`recipe\u0000${read.file}\u0000${name}`, {
+						digest: entry === AMBIGUOUS ? "bamboo:export-missing" : digestRecipeConfig(entry),
+						crossings: []
+					});
+				} catch {}
+				digestMemo.set(batched, {
+					digest: "bamboo:batched",
+					crossings: []
+				});
+			}
+			if (!digestMemo.has(key)) digestMemo.set(key, {
+				digest: digestRecipeReadNow(parseModule, read.file, read.name),
+				crossings: []
+			});
+		}
+		const entry = digestMemo.get(key);
+		if (entry.digest === void 0) return {
+			verdict: "unknown",
+			crossings: []
+		};
+		if (entry.digest !== read.digest) return {
+			verdict: "changed",
+			crossings: []
+		};
+		for (const path of entry.crossings) crossings.add(path);
+	}
+	return {
+		verdict: "unchanged",
+		crossings: [...crossings]
+	};
+};
+const digestRecipeReadNow = (parseModule, file, name) => {
+	try {
+		const result = parseModule(file);
+		if (!result) return "bamboo:module-missing";
+		const entry = collectRecipeConfigs(result).get(name);
+		if (!entry || entry === AMBIGUOUS) return "bamboo:export-missing";
+		return digestRecipeConfig(entry);
+	} catch {
+		return;
+	}
+};
+/** The verification witness for a foreign recipe read: the config bytes, order preserved. */
+const digestRecipeConfig = (entry) => {
+	try {
+		const json = JSON.stringify(entry.config, (_key, value) => value === void 0 ? "bamboo:undefined" : value);
+		if (json === void 0) return void 0;
+		return createHash("sha256").update(json).digest("base64");
+	} catch {
+		return;
+	}
+};
+/**
 * `cva`/`sva` return a function, so their definitions are compile-time declarations rather
 * than class-producing calls; once their uses are lowered, the factory calls are erased.
 * `token` also resolves to no class, but it does resolve to a literal, so it compiles through
@@ -1478,6 +1570,8 @@ const foldSource = (options) => {
 	const helperModules = /* @__PURE__ */ new Map();
 	/** Declaring modules a fold read, recorded as paths because their nodes do not persist. */
 	const foreignDependencies = /* @__PURE__ */ new Set();
+	/** Foreign recipe configs consumed, digested at read time for later verification. */
+	const exportReads = [];
 	/** Resolutions for this module's own call sites, keyed by the name the call site writes. */
 	const importedRecipes = /* @__PURE__ */ new Map();
 	/**
@@ -1518,6 +1612,12 @@ const foldSource = (options) => {
 			const entry = foreign.configs.get(origin.name);
 			if (!entry || entry === AMBIGUOUS) return void 0;
 			foreignDependencies.add(origin.filePath);
+			exportReads.push({
+				kind: "recipe",
+				file: origin.filePath,
+				name: origin.name,
+				digest: digestRecipeConfig(entry)
+			});
 			helperModules.set(name, foreign.cssSpecifier ? rebaseSpecifier(foreign.cssSpecifier, origin.filePath, consuming.getFilePath()) : void 0);
 			return entry;
 		};
@@ -2090,7 +2190,8 @@ const foldSource = (options) => {
 			map: null,
 			folded,
 			skipped,
-			dependencies: []
+			dependencies: [],
+			exportReads: []
 		};
 	}
 	const rewriteSourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile() ?? recipeDefinitions[0]?.call.getSourceFile();
@@ -2099,7 +2200,8 @@ const foldSource = (options) => {
 		map: null,
 		folded,
 		skipped,
-		dependencies: []
+		dependencies: [],
+		exportReads: []
 	};
 	const dependencyScan = createDependencyScan(rewriteSourceFile);
 	candidates.sort((a, b) => a.start - b.start || b.end - a.end);
@@ -2406,7 +2508,8 @@ const foldSource = (options) => {
 		map: null,
 		folded,
 		skipped,
-		dependencies: []
+		dependencies: [],
+		exportReads: []
 	};
 	return {
 		code: magic.toString(),
@@ -2417,7 +2520,8 @@ const foldSource = (options) => {
 		}),
 		folded,
 		skipped,
-		dependencies: [...dependencyScan.results, ...foreignDependencies]
+		dependencies: [...dependencyScan.results, ...foreignDependencies],
+		exportReads
 	};
 };
 //#endregion
@@ -2480,4 +2584,4 @@ const createStaticStyleSetCompiler = (ctx, runtimeCss, allocateClassString = (cl
 	};
 };
 //#endregion
-export { createRuntimeCss, createStaticStyleSetCompiler, foldSource };
+export { createRuntimeCss, createStaticStyleSetCompiler, foldSource, verifyExportReads };

package/dist/index.cjs

@@ -61,6 +61,7 @@ const createLazyCompilerState = (loadContext, loadFold) => createRetryableLazy(a
 	return {
 		context,
 		foldSource: fold.foldSource,
+		verifyExportReads: fold.verifyExportReads,
 		runtimeCss,
 		styleCompiler
 	};
@@ -208,6 +209,23 @@ const bamboocssCss = (options) => {
 	* stylesheet twice over.
 	*/
 	let pending;
+	/**
+	* Which change the current `pending` was generated for, and the validated sheet it produced.
+	*
+	* Every environment loads the virtual stylesheet — a react-router dev server loads it once
+	* for the client graph and once for SSR — and each load used to run a complete extraction
+	* and optimization pass to produce byte-identical CSS. The sheet is a function of the source
+	* files alone, and the watcher below is the single point every event that can reach it
+	* passes through — Vite's own propagation only arrives via the watch edges `load` registers,
+	* over the same extracted files the watcher checks. A monotonic counter bumped there is
+	* therefore enough to know whether a build already reflects the world a load is asking about.
+	*
+	* Dev only. A production build has no dev watcher to advance the counter, so serving the
+	* memo there would hand `vite build --watch` a stale sheet; builds regenerate per load.
+	*/
+	let changeGeneration = 0;
+	let pendingGeneration = -1;
+	let servedCss;
 	const build = async () => {
 		const builder = await ensureBuilder();
 		await builder.setup({
@@ -217,6 +235,7 @@ const bamboocssCss = (options) => {
 		});
 		await builder.emit();
 		builder.extract();
+		await new Promise((settle) => setImmediate(settle));
 		if (builder.context?.config.polyfill) throw new Error("bamboocss: the cascade-layer polyfill is incompatible with compiled atomic styles. The polyfill removes the utility-layer boundary required for safe atom reachability and renaming.");
 		if (builder.context) {
 			session.utilityLayer = builder.context.config.layers?.utilities ?? "utilities";
@@ -245,6 +264,8 @@ const bamboocssCss = (options) => {
 		return css;
 	};
 	const generate = () => {
+		if (command === "serve" && pending && pendingGeneration === changeGeneration) return pending;
+		pendingGeneration = changeGeneration;
 		pending = Promise.resolve(pending).catch(() => void 0).then(build);
 		return pending;
 	};
@@ -393,6 +414,11 @@ const bamboocssCss = (options) => {
 			const query = queryOf(id);
 			if (id.slice(0, id.length - query.length) !== RESOLVED_ID) return null;
 			session.cssLoaded = true;
+			const generationAtStart = changeGeneration;
+			if (command === "serve" && servedCss?.generation === generationAtStart) {
+				if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
+				return servedCss.css;
+			}
 			let css;
 			try {
 				const validateDevCss = command === "serve" ? (await loadCssOutput()).pruneStaticCss : void 0;
@@ -403,7 +429,11 @@ const bamboocssCss = (options) => {
 			} catch (error) {
 				throw asError(error, `failed to generate ${VIRTUAL_CSS_ID}`);
 			}
-			if (this.addWatchFile) for (const file of extractedSourceFiles()) this.addWatchFile(file);
+			if (command === "serve" && generationAtStart === changeGeneration) servedCss = {
+				generation: generationAtStart,
+				css
+			};
+			if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
 			return css;
 		},
 		configureServer(devServer) {
@@ -427,6 +457,7 @@ const bamboocssCss = (options) => {
 				if (!ctx) return;
 				const absoluteFile = ctx.runtime.path.abs(ctx.config.cwd, file);
 				if (!session.extractedFiles.has(absoluteFile)) return;
+				changeGeneration++;
 				prebuilt = void 0;
 				const mod = server?.moduleGraph.getModuleById(RESOLVED_ID);
 				if (!mod) return;
@@ -694,6 +725,45 @@ const bamboocss = (options = {}) => {
 		return /* @__PURE__ */ new Error(`bamboocss: cached transform metadata for ${JSON.stringify(id)} in the ${JSON.stringify(environment)} environment ${problem}.\n\nBamboo cannot safely rebuild from this entry because cached JavaScript may still name CSS classes whose rules would be dropped. Restart Vite to invalidate its in-memory transform cache. If this persists, clear Vite's cache directory and rebuild.`);
 	};
 	const transformStateByEnvironment = /* @__PURE__ */ new Map();
+	/**
+	* One fold per file content per change event, shared across environments and hooks.
+	*
+	* A single edit folds the same bytes repeatedly: `hotUpdate` provisionally re-folds every
+	* dependent once per environment to decide what to invalidate, then `transform` folds the
+	* edited module for the client graph, again for SSR, and once more for each update a
+	* framework re-drives — react-router's server-change trigger calls `reloadModule` per pass.
+	* All of them read the same shared ts-morph project under the same config, so the result is
+	* a function of the bytes alone and the repeats were pure cost: on the app this was measured
+	* on, four transforms of a 46 kB route module per edit, ~10 ms each.
+	*
+	* `watchChange` clears it, which is the exact validity window: entries are correct until a
+	* file event changes what a fold could resolve, and `watchChange` is the one hook Vite calls
+	* for every such event before any update work begins. The per-environment resolution closure
+	* is deliberately not memoized — `withResolutionClosure` is recomputed per consumer against
+	* that environment's own recorded dependencies.
+	*
+	* Keyed by path *and* content digest, not path alone, because one physical file is served
+	* as more than one module shape in the same event — react-router clips a route module down
+	* to its route exports for the client graph while SSR gets the full file — and a last-write
+	* key would make the two shapes evict each other on every pass.
+	*
+	* Dev only, like the verdict memo it sits beside: a build transforms each module once per
+	* environment with no bracketing events, and holding every module's fold for the length of a
+	* build is memory a one-shot pass has no reason to spend.
+	*/
+	const foldMemoByContent = /* @__PURE__ */ new Map();
+	/** Per-event digests of the edited file's read values, shared across every dependent. */
+	const verifyDigestMemo = /* @__PURE__ */ new Map();
+	const foldMemoKey = (filePath, inputDigest) => `${filePath}\0${inputDigest}`;
+	/**
+	* The Project resolution walk `withResolutionClosure` runs, memoized per change event.
+	*
+	* The walk is the dominant per-dependent cost once the fold itself is memoized — it runs
+	* once per dependent per environment with identical inputs, since both environments record
+	* the same fold dependencies for byte-identical source. Same bracketing as the fold memo:
+	* `watchChange` clears it, so no entry outlives the project state it was computed against.
+	*/
+	const resolutionClosureMemo = /* @__PURE__ */ new Map();
 	/** The immutable generation currently occupying each configured output on disk. */
 	const liveOutputSlotsByEnvironment = /* @__PURE__ */ new Map();
 	/** Graphs which passed `buildEnd`, but whose output has not succeeded yet. */
@@ -728,7 +798,8 @@ const bamboocss = (options = {}) => {
 		transformedModulesThisRun: /* @__PURE__ */ new Set(),
 		unchangedFolds: /* @__PURE__ */ new Map(),
 		changedRun: 0,
-		cssLoaded: false
+		cssLoaded: false,
+		exportReadsByModule: /* @__PURE__ */ new Map()
 	});
 	const cloneEnvironmentState = (state) => ({
 		transformArtifactsByModule: new Map(state.transformArtifactsByModule),
@@ -740,7 +811,8 @@ const bamboocss = (options = {}) => {
 		transformedModulesThisRun: new Set(state.transformedModulesThisRun),
 		unchangedFolds: new Map(state.unchangedFolds),
 		changedRun: state.changedRun,
-		cssLoaded: state.cssLoaded
+		cssLoaded: state.cssLoaded,
+		exportReadsByModule: new Map(state.exportReadsByModule)
 	});
 	const environmentState = (context) => {
 		const identity = environmentName(context);
@@ -1218,36 +1290,75 @@ const bamboocss = (options = {}) => {
 	* that returns nothing, a fold that throws — because "changed" is what this path did before,
 	* and a wrong "unchanged" is a stale class string in the browser.
 	*/
-	const foldOutputUnchanged = (state, dependent) => {
+	const foldOutputUnchanged = (state, dependent, changedFile) => {
 		const memoized = state.unchangedFolds.get(dependent);
 		if (memoized !== void 0) return memoized;
-		const unchanged = state.changedRun < CHANGED_RUN_LIMIT && refoldMatchesSignature(state, dependent);
+		const unchanged = state.changedRun < CHANGED_RUN_LIMIT && refoldMatchesSignature(state, dependent, changedFile);
 		state.changedRun = unchanged ? 0 : state.changedRun + 1;
 		state.unchangedFolds.set(dependent, unchanged);
 		return unchanged;
 	};
-	const refoldMatchesSignature = (state, dependent) => {
+	const refoldMatchesSignature = (state, dependent, changedFile) => {
 		const signature = state.foldSignatures.get(dependent);
 		if (!signature || !ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return false;
 		try {
 			const code = (0, node_fs.readFileSync)(signature.path, "utf8");
-			if (digest(code) !== signature.input) return false;
-			const sourceFile = ctx.project.addSourceFile(signature.path, code);
-			const parserResult = ctx.project.parseSourceFile(signature.path);
-			if (!parserResult) return false;
-			const result = withResolutionClosure(signature.path, foldSourceImpl({
-				ctx,
-				code,
-				parserResult,
-				filePath: signature.path,
-				runtimeCss,
-				styleCompiler,
-				maxRecipeStates,
-				parseModule: (path) => ctx?.project.parseSourceFile(path),
-				recipeConfigCache: state.recipeConfigCache,
-				reportSurvivors: false,
-				sourceFile
-			}), parserResult.getDependencies(), state.dependenciesByModule.get(dependent));
+			const inputDigest = digest(code);
+			if (inputDigest !== signature.input) return false;
+			/**
+			* Try to answer from what the fold *read* before re-running it.
+			*
+			* The recorded reads carry the digest of every cross-file value and recipe config this
+			* dependent's fold consumed. When each read of the edited file re-digests identically,
+			* the fold's inputs did not move and its output cannot have — the whole re-fold below
+			* is skipped, which is most of what an edit to a shared module used to cost. Any gap —
+			* no read naming the edited file, an unverifiable digest, the verifier chunk not loaded
+			* — falls through to the full re-fold, which is exactly the previous behavior. A
+			* definite mismatch is equally final in the other direction: the re-fold would only
+			* rediscover the change.
+			*/
+			const reads = state.exportReadsByModule.get(dependent);
+			if (reads?.length && verifyExportReadsImpl) {
+				const { verdict, crossings } = verifyExportReadsImpl(ctx, (path) => ctx?.project.parseSourceFile(path), reads, normalizeFsPath(changedFile), verifyDigestMemo);
+				if (verdict === "unchanged") {
+					recordFoldDependencies(state, dependent, signature.path, [...state.dependenciesByModule.get(dependent) ?? [], ...crossings]);
+					return true;
+				}
+				if (verdict === "changed") return false;
+			}
+			let raw;
+			let parserDependencies;
+			const memoKey = foldMemoKey(signature.path, inputDigest);
+			const memoized = foldMemoByContent.get(memoKey);
+			if (memoized) {
+				raw = memoized.result;
+				parserDependencies = memoized.parserDependencies;
+			} else {
+				const sourceFile = ctx.project.addSourceFile(signature.path, code);
+				const parserResult = ctx.project.parseSourceFile(signature.path);
+				if (!parserResult) return false;
+				raw = foldSourceImpl({
+					ctx,
+					code,
+					parserResult,
+					filePath: signature.path,
+					runtimeCss,
+					styleCompiler,
+					maxRecipeStates,
+					parseModule: (path) => ctx?.project.parseSourceFile(path),
+					recipeConfigCache: state.recipeConfigCache,
+					reportSurvivors: false,
+					sourceFile
+				});
+				parserDependencies = parserResult.getDependencies();
+				foldMemoByContent.set(memoKey, {
+					result: raw,
+					parserDependencies,
+					valueReads: parserResult.getExportReads?.() ?? [],
+					reportedSurvivors: false
+				});
+			}
+			const result = withResolutionClosure(signature.path, raw, parserDependencies, state.dependenciesByModule.get(dependent));
 			const unchanged = digest(result.code) === signature.output;
 			/**
 			* Edges re-recorded exactly on the way to suppressing a module. A changed provisional
@@ -1303,7 +1414,7 @@ const bamboocss = (options = {}) => {
 	* 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 = (state, file, modules, graph) => {
+	const foldDependentModules = (state, file, modules, graph, verify = true) => {
 		const dependents = state.dependentsByDependency.get(normalizeFsPath(file));
 		if (!dependents?.size) return;
 		const added = [];
@@ -1341,7 +1452,7 @@ const bamboocss = (options = {}) => {
 			* the edited module for a runtime value is still reached by `propagateUpdate` exactly as
 			* it would be with no plugin here at all — that direction was never this list's to decide.
 			*/
-			if (foldOutputUnchanged(state, dependent)) continue;
+			if (verify && foldOutputUnchanged(state, dependent, file)) continue;
 			const exact = graph.getModuleById?.(dependent);
 			const dependentFile = state.filesByModule.get(dependent) ?? dependent;
 			const candidates = exact ? [exact] : graph.getModulesByFile(normalizeFsPath(dependentFile)) ?? [];
@@ -1375,6 +1486,7 @@ const bamboocss = (options = {}) => {
 	};
 	let ctx;
 	let foldSourceImpl;
+	let verifyExportReadsImpl;
 	let runtimeCss;
 	let styleCompiler;
 	let command = "build";
@@ -1397,7 +1509,14 @@ const bamboocss = (options = {}) => {
 		const targets = new Set(dependencies);
 		for (const dependency of previousDependencies ?? []) targets.add(dependency);
 		if (!targets.size) return result;
-		for (const dependency of ctx.project.getDependencies(filePath, [...targets])) if (!isGeneratedOutput(dependency, ctx)) dependencies.add(dependency);
+		const targetList = [...targets];
+		const closureKey = command === "serve" ? `${filePath}\0${targetList.slice().sort().join("|")}` : void 0;
+		let reachable = closureKey ? resolutionClosureMemo.get(closureKey) : void 0;
+		if (!reachable) {
+			reachable = ctx.project.getDependencies(filePath, targetList);
+			if (closureKey) resolutionClosureMemo.set(closureKey, reachable);
+		}
+		for (const dependency of reachable) if (!isGeneratedOutput(dependency, ctx)) dependencies.add(dependency);
 		const expanded = [...dependencies];
 		if (expanded.length === result.dependencies.length && expanded.every((dependency, index) => dependency === result.dependencies[index])) return result;
 		return {
@@ -1421,6 +1540,7 @@ const bamboocss = (options = {}) => {
 		const loaded = await loadCompilerState();
 		ctx = loaded.context;
 		foldSourceImpl = loaded.foldSource;
+		verifyExportReadsImpl = loaded.verifyExportReads;
 		runtimeCss = loaded.runtimeCss;
 		styleCompiler = loaded.styleCompiler;
 	};
@@ -1581,6 +1701,9 @@ const bamboocss = (options = {}) => {
 		* the parser still holds the file.
 		*/
 		watchChange(id, change) {
+			foldMemoByContent.clear();
+			resolutionClosureMemo.clear();
+			verifyDigestMemo.clear();
 			for (const state of transformStateByEnvironment.values()) {
 				state.unchangedFolds.clear();
 				state.changedRun = 0;
@@ -1603,6 +1726,52 @@ const bamboocss = (options = {}) => {
 				return;
 			}
 			ctx.project.reloadSourceFile(filePath);
+			/**
+			* Fold the edited file before the browser asks for it.
+			*
+			* The first transform after an edit is the one fold the memo cannot already hold — the
+			* bytes are new — and it sits on the repaint path: the websocket round trip plus the
+			* module refetch land ~15-30ms after this hook, and the fold costs ~5-13ms of that
+			* budget on a route-sized module. Folding one macrotask later, after the update hooks
+			* have run and the broadcast is out, has the memo hot before the request arrives.
+			*
+			* `setImmediate` is the load-bearing part: this hook is awaited before Vite announces
+			* anything, so the work must not run inline. Content-keyed like every memo entry, so a
+			* racing save cannot poison anything — the entry states what these exact bytes fold to,
+			* and a later event's `watchChange` clears the memo before that event's transforms run.
+			* Failures are swallowed here; the real transform runs the same fold and owns the
+			* diagnostics.
+			*/
+			if (command === "serve") setImmediate(() => {
+				if (!ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return;
+				try {
+					const code = (0, node_fs.readFileSync)(filePath, "utf8");
+					const memoKey = foldMemoKey(filePath, digest(code));
+					if (foldMemoByContent.has(memoKey)) return;
+					const sourceFile = ctx.project.addSourceFile(filePath, code);
+					const parserResult = ctx.project.parseSourceFile(filePath);
+					if (!parserResult) return;
+					const folded = foldSourceImpl({
+						ctx,
+						code,
+						parserResult,
+						filePath,
+						runtimeCss,
+						styleCompiler,
+						maxRecipeStates,
+						parseModule: (path) => ctx?.project.parseSourceFile(path),
+						recipeConfigCache: transformStateByEnvironment.get("client")?.recipeConfigCache ?? /* @__PURE__ */ new Map(),
+						reportSurvivors: true,
+						sourceFile
+					});
+					foldMemoByContent.set(memoKey, {
+						result: folded,
+						parserDependencies: parserResult.getDependencies(),
+						valueReads: parserResult.getExportReads?.() ?? [],
+						reportedSurvivors: true
+					});
+				} catch {}
+			});
 		},
 		/**
 		* Re-transform whatever folded a value out of the file that just changed.
@@ -1626,7 +1795,22 @@ const bamboocss = (options = {}) => {
 		hotUpdate({ file, modules }) {
 			const graph = this.environment?.moduleGraph;
 			if (!graph) return;
-			return foldDependentModules(environmentState(this), file, modules, graph);
+			/**
+			* The provisional re-folds exist to spare the *browser*: an announced client module is a
+			* refetch round trip, and behind a framework that re-drives HMR per entry, a router
+			* revalidation — that is what deciding "unchanged" before Vite is told anything buys.
+			*
+			* A server graph has none of that economy. Its modules are re-transformed by this same
+			* process the next time something renders, nothing is announced by invalidating quietly,
+			* and the verification runs on the awaited path *before* the client's update can be
+			* broadcast — on a react-router app, re-folding every SSR consumer of a shared style
+			* module added ~15ms to each edit's repaint for work whose only reader was the next
+			* `.data` revalidation. Invalidate outright there and let the next render pay lazily,
+			* off the repaint path. `verify` stays on when the consumer kind is unknown — a harness
+			* without environment config keeps the conservative shape.
+			*/
+			const consumer = this.environment?.config?.consumer;
+			return foldDependentModules(environmentState(this), file, modules, graph, consumer !== "server");
 		},
 		handleHotUpdate({ file, modules, server }) {
 			const legacy = server;
@@ -1650,27 +1834,48 @@ const bamboocss = (options = {}) => {
 			const previousDependencies = previousSignature && previousSignature.input === (inputDigest ??= digest(code)) ? state.dependenciesByModule.get(id) : void 0;
 			let result;
 			try {
-				const sourceFile = ctx.project.addSourceFile(filePath, code);
-				const parserResult = ctx.project.parseSourceFile(filePath);
-				if (!parserResult) {
-					state.transformArtifactsByModule.delete(id);
-					recordFoldDependencies(state, id, filePath, []);
-					state.foldSignatures.delete(id);
-					return null;
+				const memoKey = command === "serve" ? foldMemoKey(filePath, inputDigest ??= digest(code)) : void 0;
+				const memoized = memoKey ? foldMemoByContent.get(memoKey) : void 0;
+				let valueReads = [];
+				if (memoized?.reportedSurvivors) {
+					valueReads = memoized.valueReads;
+					result = withResolutionClosure(filePath, memoized.result, memoized.parserDependencies, previousDependencies);
+				} else {
+					const sourceFile = ctx.project.addSourceFile(filePath, code);
+					const parserResult = ctx.project.parseSourceFile(filePath);
+					if (!parserResult) {
+						state.transformArtifactsByModule.delete(id);
+						recordFoldDependencies(state, id, filePath, []);
+						state.foldSignatures.delete(id);
+						return null;
+					}
+					const folded = foldSourceImpl({
+						ctx,
+						code,
+						parserResult,
+						filePath,
+						runtimeCss,
+						styleCompiler,
+						maxRecipeStates,
+						parseModule: (path) => ctx?.project.parseSourceFile(path),
+						recipeConfigCache: state.recipeConfigCache,
+						reportSurvivors: true,
+						sourceFile
+					});
+					const parserDependencies = parserResult.getDependencies();
+					valueReads = parserResult.getExportReads?.() ?? [];
+					if (memoKey) foldMemoByContent.set(memoKey, {
+						result: folded,
+						parserDependencies,
+						valueReads,
+						reportedSurvivors: true
+					});
+					result = withResolutionClosure(filePath, folded, parserDependencies, previousDependencies);
 				}
-				result = withResolutionClosure(filePath, foldSourceImpl({
-					ctx,
-					code,
-					parserResult,
-					filePath,
-					runtimeCss,
-					styleCompiler,
-					maxRecipeStates,
-					parseModule: (path) => ctx?.project.parseSourceFile(path),
-					recipeConfigCache: state.recipeConfigCache,
-					reportSurvivors: true,
-					sourceFile
-				}), parserResult.getDependencies(), previousDependencies);
+				state.exportReadsByModule.set(id, [...valueReads.map((read) => ({
+					kind: "value",
+					...read
+				})), ...result.exportReads]);
 			} catch (error) {
 				_bamboocss_logger.logger.caughtError("vite:transform", `Failed to compile ${filePath}`, error);
 				const previousDependencies = [...state.dependenciesByModule.get(id) ?? []];

package/dist/index.mjs

@@ -56,6 +56,7 @@ const createLazyCompilerState = (loadContext, loadFold) => createRetryableLazy(a
 	return {
 		context,
 		foldSource: fold.foldSource,
+		verifyExportReads: fold.verifyExportReads,
 		runtimeCss,
 		styleCompiler
 	};
@@ -203,6 +204,23 @@ const bamboocssCss = (options) => {
 	* stylesheet twice over.
 	*/
 	let pending;
+	/**
+	* Which change the current `pending` was generated for, and the validated sheet it produced.
+	*
+	* Every environment loads the virtual stylesheet — a react-router dev server loads it once
+	* for the client graph and once for SSR — and each load used to run a complete extraction
+	* and optimization pass to produce byte-identical CSS. The sheet is a function of the source
+	* files alone, and the watcher below is the single point every event that can reach it
+	* passes through — Vite's own propagation only arrives via the watch edges `load` registers,
+	* over the same extracted files the watcher checks. A monotonic counter bumped there is
+	* therefore enough to know whether a build already reflects the world a load is asking about.
+	*
+	* Dev only. A production build has no dev watcher to advance the counter, so serving the
+	* memo there would hand `vite build --watch` a stale sheet; builds regenerate per load.
+	*/
+	let changeGeneration = 0;
+	let pendingGeneration = -1;
+	let servedCss;
 	const build = async () => {
 		const builder = await ensureBuilder();
 		await builder.setup({
@@ -212,6 +230,7 @@ const bamboocssCss = (options) => {
 		});
 		await builder.emit();
 		builder.extract();
+		await new Promise((settle) => setImmediate(settle));
 		if (builder.context?.config.polyfill) throw new Error("bamboocss: the cascade-layer polyfill is incompatible with compiled atomic styles. The polyfill removes the utility-layer boundary required for safe atom reachability and renaming.");
 		if (builder.context) {
 			session.utilityLayer = builder.context.config.layers?.utilities ?? "utilities";
@@ -240,6 +259,8 @@ const bamboocssCss = (options) => {
 		return css;
 	};
 	const generate = () => {
+		if (command === "serve" && pending && pendingGeneration === changeGeneration) return pending;
+		pendingGeneration = changeGeneration;
 		pending = Promise.resolve(pending).catch(() => void 0).then(build);
 		return pending;
 	};
@@ -388,6 +409,11 @@ const bamboocssCss = (options) => {
 			const query = queryOf(id);
 			if (id.slice(0, id.length - query.length) !== RESOLVED_ID) return null;
 			session.cssLoaded = true;
+			const generationAtStart = changeGeneration;
+			if (command === "serve" && servedCss?.generation === generationAtStart) {
+				if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
+				return servedCss.css;
+			}
 			let css;
 			try {
 				const validateDevCss = command === "serve" ? (await loadCssOutput()).pruneStaticCss : void 0;
@@ -398,7 +424,11 @@ const bamboocssCss = (options) => {
 			} catch (error) {
 				throw asError(error, `failed to generate ${VIRTUAL_CSS_ID}`);
 			}
-			if (this.addWatchFile) for (const file of extractedSourceFiles()) this.addWatchFile(file);
+			if (command === "serve" && generationAtStart === changeGeneration) servedCss = {
+				generation: generationAtStart,
+				css
+			};
+			if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
 			return css;
 		},
 		configureServer(devServer) {
@@ -422,6 +452,7 @@ const bamboocssCss = (options) => {
 				if (!ctx) return;
 				const absoluteFile = ctx.runtime.path.abs(ctx.config.cwd, file);
 				if (!session.extractedFiles.has(absoluteFile)) return;
+				changeGeneration++;
 				prebuilt = void 0;
 				const mod = server?.moduleGraph.getModuleById(RESOLVED_ID);
 				if (!mod) return;
@@ -689,6 +720,45 @@ const bamboocss = (options = {}) => {
 		return /* @__PURE__ */ new Error(`bamboocss: cached transform metadata for ${JSON.stringify(id)} in the ${JSON.stringify(environment)} environment ${problem}.\n\nBamboo cannot safely rebuild from this entry because cached JavaScript may still name CSS classes whose rules would be dropped. Restart Vite to invalidate its in-memory transform cache. If this persists, clear Vite's cache directory and rebuild.`);
 	};
 	const transformStateByEnvironment = /* @__PURE__ */ new Map();
+	/**
+	* One fold per file content per change event, shared across environments and hooks.
+	*
+	* A single edit folds the same bytes repeatedly: `hotUpdate` provisionally re-folds every
+	* dependent once per environment to decide what to invalidate, then `transform` folds the
+	* edited module for the client graph, again for SSR, and once more for each update a
+	* framework re-drives — react-router's server-change trigger calls `reloadModule` per pass.
+	* All of them read the same shared ts-morph project under the same config, so the result is
+	* a function of the bytes alone and the repeats were pure cost: on the app this was measured
+	* on, four transforms of a 46 kB route module per edit, ~10 ms each.
+	*
+	* `watchChange` clears it, which is the exact validity window: entries are correct until a
+	* file event changes what a fold could resolve, and `watchChange` is the one hook Vite calls
+	* for every such event before any update work begins. The per-environment resolution closure
+	* is deliberately not memoized — `withResolutionClosure` is recomputed per consumer against
+	* that environment's own recorded dependencies.
+	*
+	* Keyed by path *and* content digest, not path alone, because one physical file is served
+	* as more than one module shape in the same event — react-router clips a route module down
+	* to its route exports for the client graph while SSR gets the full file — and a last-write
+	* key would make the two shapes evict each other on every pass.
+	*
+	* Dev only, like the verdict memo it sits beside: a build transforms each module once per
+	* environment with no bracketing events, and holding every module's fold for the length of a
+	* build is memory a one-shot pass has no reason to spend.
+	*/
+	const foldMemoByContent = /* @__PURE__ */ new Map();
+	/** Per-event digests of the edited file's read values, shared across every dependent. */
+	const verifyDigestMemo = /* @__PURE__ */ new Map();
+	const foldMemoKey = (filePath, inputDigest) => `${filePath}\0${inputDigest}`;
+	/**
+	* The Project resolution walk `withResolutionClosure` runs, memoized per change event.
+	*
+	* The walk is the dominant per-dependent cost once the fold itself is memoized — it runs
+	* once per dependent per environment with identical inputs, since both environments record
+	* the same fold dependencies for byte-identical source. Same bracketing as the fold memo:
+	* `watchChange` clears it, so no entry outlives the project state it was computed against.
+	*/
+	const resolutionClosureMemo = /* @__PURE__ */ new Map();
 	/** The immutable generation currently occupying each configured output on disk. */
 	const liveOutputSlotsByEnvironment = /* @__PURE__ */ new Map();
 	/** Graphs which passed `buildEnd`, but whose output has not succeeded yet. */
@@ -723,7 +793,8 @@ const bamboocss = (options = {}) => {
 		transformedModulesThisRun: /* @__PURE__ */ new Set(),
 		unchangedFolds: /* @__PURE__ */ new Map(),
 		changedRun: 0,
-		cssLoaded: false
+		cssLoaded: false,
+		exportReadsByModule: /* @__PURE__ */ new Map()
 	});
 	const cloneEnvironmentState = (state) => ({
 		transformArtifactsByModule: new Map(state.transformArtifactsByModule),
@@ -735,7 +806,8 @@ const bamboocss = (options = {}) => {
 		transformedModulesThisRun: new Set(state.transformedModulesThisRun),
 		unchangedFolds: new Map(state.unchangedFolds),
 		changedRun: state.changedRun,
-		cssLoaded: state.cssLoaded
+		cssLoaded: state.cssLoaded,
+		exportReadsByModule: new Map(state.exportReadsByModule)
 	});
 	const environmentState = (context) => {
 		const identity = environmentName(context);
@@ -1213,36 +1285,75 @@ const bamboocss = (options = {}) => {
 	* that returns nothing, a fold that throws — because "changed" is what this path did before,
 	* and a wrong "unchanged" is a stale class string in the browser.
 	*/
-	const foldOutputUnchanged = (state, dependent) => {
+	const foldOutputUnchanged = (state, dependent, changedFile) => {
 		const memoized = state.unchangedFolds.get(dependent);
 		if (memoized !== void 0) return memoized;
-		const unchanged = state.changedRun < CHANGED_RUN_LIMIT && refoldMatchesSignature(state, dependent);
+		const unchanged = state.changedRun < CHANGED_RUN_LIMIT && refoldMatchesSignature(state, dependent, changedFile);
 		state.changedRun = unchanged ? 0 : state.changedRun + 1;
 		state.unchangedFolds.set(dependent, unchanged);
 		return unchanged;
 	};
-	const refoldMatchesSignature = (state, dependent) => {
+	const refoldMatchesSignature = (state, dependent, changedFile) => {
 		const signature = state.foldSignatures.get(dependent);
 		if (!signature || !ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return false;
 		try {
 			const code = readFileSync(signature.path, "utf8");
-			if (digest(code) !== signature.input) return false;
-			const sourceFile = ctx.project.addSourceFile(signature.path, code);
-			const parserResult = ctx.project.parseSourceFile(signature.path);
-			if (!parserResult) return false;
-			const result = withResolutionClosure(signature.path, foldSourceImpl({
-				ctx,
-				code,
-				parserResult,
-				filePath: signature.path,
-				runtimeCss,
-				styleCompiler,
-				maxRecipeStates,
-				parseModule: (path) => ctx?.project.parseSourceFile(path),
-				recipeConfigCache: state.recipeConfigCache,
-				reportSurvivors: false,
-				sourceFile
-			}), parserResult.getDependencies(), state.dependenciesByModule.get(dependent));
+			const inputDigest = digest(code);
+			if (inputDigest !== signature.input) return false;
+			/**
+			* Try to answer from what the fold *read* before re-running it.
+			*
+			* The recorded reads carry the digest of every cross-file value and recipe config this
+			* dependent's fold consumed. When each read of the edited file re-digests identically,
+			* the fold's inputs did not move and its output cannot have — the whole re-fold below
+			* is skipped, which is most of what an edit to a shared module used to cost. Any gap —
+			* no read naming the edited file, an unverifiable digest, the verifier chunk not loaded
+			* — falls through to the full re-fold, which is exactly the previous behavior. A
+			* definite mismatch is equally final in the other direction: the re-fold would only
+			* rediscover the change.
+			*/
+			const reads = state.exportReadsByModule.get(dependent);
+			if (reads?.length && verifyExportReadsImpl) {
+				const { verdict, crossings } = verifyExportReadsImpl(ctx, (path) => ctx?.project.parseSourceFile(path), reads, normalizeFsPath(changedFile), verifyDigestMemo);
+				if (verdict === "unchanged") {
+					recordFoldDependencies(state, dependent, signature.path, [...state.dependenciesByModule.get(dependent) ?? [], ...crossings]);
+					return true;
+				}
+				if (verdict === "changed") return false;
+			}
+			let raw;
+			let parserDependencies;
+			const memoKey = foldMemoKey(signature.path, inputDigest);
+			const memoized = foldMemoByContent.get(memoKey);
+			if (memoized) {
+				raw = memoized.result;
+				parserDependencies = memoized.parserDependencies;
+			} else {
+				const sourceFile = ctx.project.addSourceFile(signature.path, code);
+				const parserResult = ctx.project.parseSourceFile(signature.path);
+				if (!parserResult) return false;
+				raw = foldSourceImpl({
+					ctx,
+					code,
+					parserResult,
+					filePath: signature.path,
+					runtimeCss,
+					styleCompiler,
+					maxRecipeStates,
+					parseModule: (path) => ctx?.project.parseSourceFile(path),
+					recipeConfigCache: state.recipeConfigCache,
+					reportSurvivors: false,
+					sourceFile
+				});
+				parserDependencies = parserResult.getDependencies();
+				foldMemoByContent.set(memoKey, {
+					result: raw,
+					parserDependencies,
+					valueReads: parserResult.getExportReads?.() ?? [],
+					reportedSurvivors: false
+				});
+			}
+			const result = withResolutionClosure(signature.path, raw, parserDependencies, state.dependenciesByModule.get(dependent));
 			const unchanged = digest(result.code) === signature.output;
 			/**
 			* Edges re-recorded exactly on the way to suppressing a module. A changed provisional
@@ -1298,7 +1409,7 @@ const bamboocss = (options = {}) => {
 	* 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 = (state, file, modules, graph) => {
+	const foldDependentModules = (state, file, modules, graph, verify = true) => {
 		const dependents = state.dependentsByDependency.get(normalizeFsPath(file));
 		if (!dependents?.size) return;
 		const added = [];
@@ -1336,7 +1447,7 @@ const bamboocss = (options = {}) => {
 			* the edited module for a runtime value is still reached by `propagateUpdate` exactly as
 			* it would be with no plugin here at all — that direction was never this list's to decide.
 			*/
-			if (foldOutputUnchanged(state, dependent)) continue;
+			if (verify && foldOutputUnchanged(state, dependent, file)) continue;
 			const exact = graph.getModuleById?.(dependent);
 			const dependentFile = state.filesByModule.get(dependent) ?? dependent;
 			const candidates = exact ? [exact] : graph.getModulesByFile(normalizeFsPath(dependentFile)) ?? [];
@@ -1370,6 +1481,7 @@ const bamboocss = (options = {}) => {
 	};
 	let ctx;
 	let foldSourceImpl;
+	let verifyExportReadsImpl;
 	let runtimeCss;
 	let styleCompiler;
 	let command = "build";
@@ -1392,7 +1504,14 @@ const bamboocss = (options = {}) => {
 		const targets = new Set(dependencies);
 		for (const dependency of previousDependencies ?? []) targets.add(dependency);
 		if (!targets.size) return result;
-		for (const dependency of ctx.project.getDependencies(filePath, [...targets])) if (!isGeneratedOutput(dependency, ctx)) dependencies.add(dependency);
+		const targetList = [...targets];
+		const closureKey = command === "serve" ? `${filePath}\0${targetList.slice().sort().join("|")}` : void 0;
+		let reachable = closureKey ? resolutionClosureMemo.get(closureKey) : void 0;
+		if (!reachable) {
+			reachable = ctx.project.getDependencies(filePath, targetList);
+			if (closureKey) resolutionClosureMemo.set(closureKey, reachable);
+		}
+		for (const dependency of reachable) if (!isGeneratedOutput(dependency, ctx)) dependencies.add(dependency);
 		const expanded = [...dependencies];
 		if (expanded.length === result.dependencies.length && expanded.every((dependency, index) => dependency === result.dependencies[index])) return result;
 		return {
@@ -1416,6 +1535,7 @@ const bamboocss = (options = {}) => {
 		const loaded = await loadCompilerState();
 		ctx = loaded.context;
 		foldSourceImpl = loaded.foldSource;
+		verifyExportReadsImpl = loaded.verifyExportReads;
 		runtimeCss = loaded.runtimeCss;
 		styleCompiler = loaded.styleCompiler;
 	};
@@ -1576,6 +1696,9 @@ const bamboocss = (options = {}) => {
 		* the parser still holds the file.
 		*/
 		watchChange(id, change) {
+			foldMemoByContent.clear();
+			resolutionClosureMemo.clear();
+			verifyDigestMemo.clear();
 			for (const state of transformStateByEnvironment.values()) {
 				state.unchangedFolds.clear();
 				state.changedRun = 0;
@@ -1598,6 +1721,52 @@ const bamboocss = (options = {}) => {
 				return;
 			}
 			ctx.project.reloadSourceFile(filePath);
+			/**
+			* Fold the edited file before the browser asks for it.
+			*
+			* The first transform after an edit is the one fold the memo cannot already hold — the
+			* bytes are new — and it sits on the repaint path: the websocket round trip plus the
+			* module refetch land ~15-30ms after this hook, and the fold costs ~5-13ms of that
+			* budget on a route-sized module. Folding one macrotask later, after the update hooks
+			* have run and the broadcast is out, has the memo hot before the request arrives.
+			*
+			* `setImmediate` is the load-bearing part: this hook is awaited before Vite announces
+			* anything, so the work must not run inline. Content-keyed like every memo entry, so a
+			* racing save cannot poison anything — the entry states what these exact bytes fold to,
+			* and a later event's `watchChange` clears the memo before that event's transforms run.
+			* Failures are swallowed here; the real transform runs the same fold and owns the
+			* diagnostics.
+			*/
+			if (command === "serve") setImmediate(() => {
+				if (!ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return;
+				try {
+					const code = readFileSync(filePath, "utf8");
+					const memoKey = foldMemoKey(filePath, digest(code));
+					if (foldMemoByContent.has(memoKey)) return;
+					const sourceFile = ctx.project.addSourceFile(filePath, code);
+					const parserResult = ctx.project.parseSourceFile(filePath);
+					if (!parserResult) return;
+					const folded = foldSourceImpl({
+						ctx,
+						code,
+						parserResult,
+						filePath,
+						runtimeCss,
+						styleCompiler,
+						maxRecipeStates,
+						parseModule: (path) => ctx?.project.parseSourceFile(path),
+						recipeConfigCache: transformStateByEnvironment.get("client")?.recipeConfigCache ?? /* @__PURE__ */ new Map(),
+						reportSurvivors: true,
+						sourceFile
+					});
+					foldMemoByContent.set(memoKey, {
+						result: folded,
+						parserDependencies: parserResult.getDependencies(),
+						valueReads: parserResult.getExportReads?.() ?? [],
+						reportedSurvivors: true
+					});
+				} catch {}
+			});
 		},
 		/**
 		* Re-transform whatever folded a value out of the file that just changed.
@@ -1621,7 +1790,22 @@ const bamboocss = (options = {}) => {
 		hotUpdate({ file, modules }) {
 			const graph = this.environment?.moduleGraph;
 			if (!graph) return;
-			return foldDependentModules(environmentState(this), file, modules, graph);
+			/**
+			* The provisional re-folds exist to spare the *browser*: an announced client module is a
+			* refetch round trip, and behind a framework that re-drives HMR per entry, a router
+			* revalidation — that is what deciding "unchanged" before Vite is told anything buys.
+			*
+			* A server graph has none of that economy. Its modules are re-transformed by this same
+			* process the next time something renders, nothing is announced by invalidating quietly,
+			* and the verification runs on the awaited path *before* the client's update can be
+			* broadcast — on a react-router app, re-folding every SSR consumer of a shared style
+			* module added ~15ms to each edit's repaint for work whose only reader was the next
+			* `.data` revalidation. Invalidate outright there and let the next render pay lazily,
+			* off the repaint path. `verify` stays on when the consumer kind is unknown — a harness
+			* without environment config keeps the conservative shape.
+			*/
+			const consumer = this.environment?.config?.consumer;
+			return foldDependentModules(environmentState(this), file, modules, graph, consumer !== "server");
 		},
 		handleHotUpdate({ file, modules, server }) {
 			const legacy = server;
@@ -1645,27 +1829,48 @@ const bamboocss = (options = {}) => {
 			const previousDependencies = previousSignature && previousSignature.input === (inputDigest ??= digest(code)) ? state.dependenciesByModule.get(id) : void 0;
 			let result;
 			try {
-				const sourceFile = ctx.project.addSourceFile(filePath, code);
-				const parserResult = ctx.project.parseSourceFile(filePath);
-				if (!parserResult) {
-					state.transformArtifactsByModule.delete(id);
-					recordFoldDependencies(state, id, filePath, []);
-					state.foldSignatures.delete(id);
-					return null;
+				const memoKey = command === "serve" ? foldMemoKey(filePath, inputDigest ??= digest(code)) : void 0;
+				const memoized = memoKey ? foldMemoByContent.get(memoKey) : void 0;
+				let valueReads = [];
+				if (memoized?.reportedSurvivors) {
+					valueReads = memoized.valueReads;
+					result = withResolutionClosure(filePath, memoized.result, memoized.parserDependencies, previousDependencies);
+				} else {
+					const sourceFile = ctx.project.addSourceFile(filePath, code);
+					const parserResult = ctx.project.parseSourceFile(filePath);
+					if (!parserResult) {
+						state.transformArtifactsByModule.delete(id);
+						recordFoldDependencies(state, id, filePath, []);
+						state.foldSignatures.delete(id);
+						return null;
+					}
+					const folded = foldSourceImpl({
+						ctx,
+						code,
+						parserResult,
+						filePath,
+						runtimeCss,
+						styleCompiler,
+						maxRecipeStates,
+						parseModule: (path) => ctx?.project.parseSourceFile(path),
+						recipeConfigCache: state.recipeConfigCache,
+						reportSurvivors: true,
+						sourceFile
+					});
+					const parserDependencies = parserResult.getDependencies();
+					valueReads = parserResult.getExportReads?.() ?? [];
+					if (memoKey) foldMemoByContent.set(memoKey, {
+						result: folded,
+						parserDependencies,
+						valueReads,
+						reportedSurvivors: true
+					});
+					result = withResolutionClosure(filePath, folded, parserDependencies, previousDependencies);
 				}
-				result = withResolutionClosure(filePath, foldSourceImpl({
-					ctx,
-					code,
-					parserResult,
-					filePath,
-					runtimeCss,
-					styleCompiler,
-					maxRecipeStates,
-					parseModule: (path) => ctx?.project.parseSourceFile(path),
-					recipeConfigCache: state.recipeConfigCache,
-					reportSurvivors: true,
-					sourceFile
-				}), parserResult.getDependencies(), previousDependencies);
+				state.exportReadsByModule.set(id, [...valueReads.map((read) => ({
+					kind: "value",
+					...read
+				})), ...result.exportReads]);
 			} catch (error) {
 				logger.caughtError("vite:transform", `Failed to compile ${filePath}`, error);
 				const previousDependencies = [...state.dependenciesByModule.get(id) ?? []];

package/package.json

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