@bamboocss/vite 1.46.1 → 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
 	};
@@ -234,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";
@@ -414,7 +416,7 @@ const bamboocssCss = (options) => {
 			session.cssLoaded = true;
 			const generationAtStart = changeGeneration;
 			if (command === "serve" && servedCss?.generation === generationAtStart) {
-				if (this.addWatchFile) for (const file of extractedSourceFiles()) this.addWatchFile(file);
+				if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
 				return servedCss.css;
 			}
 			let css;
@@ -431,7 +433,7 @@ const bamboocssCss = (options) => {
 				generation: generationAtStart,
 				css
 			};
-			if (this.addWatchFile) for (const file of extractedSourceFiles()) this.addWatchFile(file);
+			if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
 			return css;
 		},
 		configureServer(devServer) {
@@ -750,6 +752,8 @@ const bamboocss = (options = {}) => {
 	* 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.
@@ -794,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),
@@ -806,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);
@@ -1284,21 +1290,42 @@ 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");
 			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);
@@ -1327,6 +1354,7 @@ const bamboocss = (options = {}) => {
 				foldMemoByContent.set(memoKey, {
 					result: raw,
 					parserDependencies,
+					valueReads: parserResult.getExportReads?.() ?? [],
 					reportedSurvivors: false
 				});
 			}
@@ -1386,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 = [];
@@ -1424,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)) ?? [];
@@ -1458,6 +1486,7 @@ const bamboocss = (options = {}) => {
 	};
 	let ctx;
 	let foldSourceImpl;
+	let verifyExportReadsImpl;
 	let runtimeCss;
 	let styleCompiler;
 	let command = "build";
@@ -1511,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;
 	};
@@ -1673,6 +1703,7 @@ const bamboocss = (options = {}) => {
 		watchChange(id, change) {
 			foldMemoByContent.clear();
 			resolutionClosureMemo.clear();
+			verifyDigestMemo.clear();
 			for (const state of transformStateByEnvironment.values()) {
 				state.unchangedFolds.clear();
 				state.changedRun = 0;
@@ -1695,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.
@@ -1718,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;
@@ -1744,8 +1836,11 @@ const bamboocss = (options = {}) => {
 			try {
 				const memoKey = command === "serve" ? foldMemoKey(filePath, inputDigest ??= digest(code)) : void 0;
 				const memoized = memoKey ? foldMemoByContent.get(memoKey) : void 0;
-				if (memoized?.reportedSurvivors) result = withResolutionClosure(filePath, memoized.result, memoized.parserDependencies, previousDependencies);
-				else {
+				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) {
@@ -1768,13 +1863,19 @@ const bamboocss = (options = {}) => {
 						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);
 				}
+				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
 	};
@@ -229,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";
@@ -409,7 +411,7 @@ const bamboocssCss = (options) => {
 			session.cssLoaded = true;
 			const generationAtStart = changeGeneration;
 			if (command === "serve" && servedCss?.generation === generationAtStart) {
-				if (this.addWatchFile) for (const file of extractedSourceFiles()) this.addWatchFile(file);
+				if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
 				return servedCss.css;
 			}
 			let css;
@@ -426,7 +428,7 @@ const bamboocssCss = (options) => {
 				generation: generationAtStart,
 				css
 			};
-			if (this.addWatchFile) for (const file of extractedSourceFiles()) this.addWatchFile(file);
+			if (this.addWatchFile) for (const file of session.extractedFiles) this.addWatchFile(file);
 			return css;
 		},
 		configureServer(devServer) {
@@ -745,6 +747,8 @@ const bamboocss = (options = {}) => {
 	* 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.
@@ -789,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),
@@ -801,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);
@@ -1279,21 +1285,42 @@ 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");
 			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);
@@ -1322,6 +1349,7 @@ const bamboocss = (options = {}) => {
 				foldMemoByContent.set(memoKey, {
 					result: raw,
 					parserDependencies,
+					valueReads: parserResult.getExportReads?.() ?? [],
 					reportedSurvivors: false
 				});
 			}
@@ -1381,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 = [];
@@ -1419,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)) ?? [];
@@ -1453,6 +1481,7 @@ const bamboocss = (options = {}) => {
 	};
 	let ctx;
 	let foldSourceImpl;
+	let verifyExportReadsImpl;
 	let runtimeCss;
 	let styleCompiler;
 	let command = "build";
@@ -1506,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;
 	};
@@ -1668,6 +1698,7 @@ const bamboocss = (options = {}) => {
 		watchChange(id, change) {
 			foldMemoByContent.clear();
 			resolutionClosureMemo.clear();
+			verifyDigestMemo.clear();
 			for (const state of transformStateByEnvironment.values()) {
 				state.unchangedFolds.clear();
 				state.changedRun = 0;
@@ -1690,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.
@@ -1713,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;
@@ -1739,8 +1831,11 @@ const bamboocss = (options = {}) => {
 			try {
 				const memoKey = command === "serve" ? foldMemoKey(filePath, inputDigest ??= digest(code)) : void 0;
 				const memoized = memoKey ? foldMemoByContent.get(memoKey) : void 0;
-				if (memoized?.reportedSurvivors) result = withResolutionClosure(filePath, memoized.result, memoized.parserDependencies, previousDependencies);
-				else {
+				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) {
@@ -1763,13 +1858,19 @@ const bamboocss = (options = {}) => {
 						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);
 				}
+				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.1",
+  "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.1",
-    "@bamboocss/core": "1.46.1",
-    "@bamboocss/node": "1.46.1",
-    "@bamboocss/shared": "1.46.1",
-    "@bamboocss/extractor": "1.46.1",
-    "@bamboocss/types": "1.46.1",
-    "@bamboocss/logger": "1.46.1"
+    "@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.1"
+    "@bamboocss/fixture": "1.46.2"
   },
   "peerDependencies": {
     "vite": ">=5"