@bamboocss/vite 1.45.2 → 1.45.4

package/dist/index.cjs

@@ -36,6 +36,8 @@ let postcss = require("postcss");
 postcss = __toESM(postcss);
 let postcss_selector_parser = require("postcss-selector-parser");
 postcss_selector_parser = __toESM(postcss_selector_parser);
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
 let node_path = require("node:path");
 let _bamboocss_config_ts_path = require("@bamboocss/config/ts-path");
 let _bamboocss_extractor = require("@bamboocss/extractor");
@@ -3321,6 +3323,141 @@ const bamboocss = (options = {}) => {
 		}
 	};
 	/**
+	* What each cross-file consumer was last handed, and what it last compiled to.
+	*
+	* Editing a shared module re-transforms everything that folded a value out of it, and most of
+	* those re-transforms recompute the bytes they already had: an edit to one export changes the
+	* consumers reading *that* export, not the ones reading something else from the same file.
+	* `foldDependentModules` uses this to tell those two apart.
+	*
+	* Digests, not text. Retaining every consumer's source and compiled output for the life of the
+	* process is the same order of memory as the ts-morph project already holding it; two 44-byte
+	* strings per entry is not, and it does not grow with module size. The set is bounded the way
+	* `dependenciesByFile` is — an entry exists only while a module's fold actually reads another
+	* file, which most modules never do — so a project that folds nothing across a boundary pays
+	* neither the bytes nor the hashing.
+	*
+	* The *input* digest is what makes the output digest safe to act on. The check below re-folds
+	* a consumer from disk, and disk is the right text only if that is what the last transform was
+	* handed: a module built by another plugin's `load`, or one edited in the same save, fails
+	* that comparison and is treated as changed. `path` is the spelling `transform` used, because
+	* ts-morph and the fold both key on it and Windows spells it more than one way.
+	*/
+	const foldSignatures = /* @__PURE__ */ new Map();
+	const digest = (text) => (0, node_crypto.createHash)("sha256").update(text).digest("base64");
+	/**
+	* Consumers this edit cannot move, resolved once per watcher event.
+	*
+	* `hotUpdate` runs once per environment — client and ssr both — and the answer is a property
+	* of the files, not of which environment is asking. Cleared in `watchChange`, which every Vite
+	* in the peer range calls for every file event, before either update hook.
+	*/
+	const unchangedFolds = /* @__PURE__ */ new Map();
+	/**
+	* How many dependents in a row may come back changed before the check gives up for this event.
+	*
+	* The check costs a re-fold — ~0.2 ms per dependent measured on a twenty-consumer fan-out — and
+	* it is paid on the awaited path, before Vite is told anything. That is linear in the number of
+	* consumers and does not bound itself: a shared module with three hundred of them adds ~59 ms to
+	* every edit, including the edits where nothing *can* be suppressed because the change moved the
+	* recipe base and every consumer really did recompile.
+	*
+	* The trade is worth it whenever anything is suppressible. Measured on the same fan-out, a
+	* suppressed consumer saves ~2.3 ms of re-transform for the ~0.23 ms its check costs, so the
+	* check pays for itself at about one consumer in ten. What does not pay is the case where the
+	* answer is going to be "changed" for all of them, and that case announces itself: a run of
+	* consumers that all came back changed. Stopping after eight bounds it. On a three-hundred
+	* consumer fan-out, an edit to the recipe base — where nothing can be suppressed — costs 3.6 ms
+	* here rather than the 59 ms checking every one of them would, stacked onto an edit already
+	* spending 600 ms re-transforming. A single unchanged consumer resets the run, so the same
+	* fan-out editing a value no fold reads still checks all three hundred: 49 ms spent against
+	* 520 ms of re-transform not done, and a 715 ms edit reduced to 183 ms.
+	*
+	* Giving up is always the safe direction — an unchecked dependent is treated as changed, which
+	* is what this path did before any of this existed — so the bound can only cost the
+	* optimisation, never correctness. It costs it where the optimisation was worth least: for the
+	* run to reach eight, the consumers seen so far have to be uniformly changed.
+	*/
+	const CHANGED_RUN_LIMIT = 8;
+	let changedRun = 0;
+	/**
+	* Whether re-folding `dependent` now produces exactly the bytes it produced last time.
+	*
+	* Only the fold can answer that. The consumer's own source has not changed, so whether its
+	* compiled output moves depends entirely on what the edited module resolves to *this* time,
+	* and there is no cheaper way to learn that than to resolve it. Doing it here rather than
+	* waiting for the re-transform is the whole point: the decision is needed before the update is
+	* announced, and for a consumer that turns out to be unchanged this fold *replaces* the
+	* re-transform rather than adding to it.
+	*
+	* Conservative in every failure — no recorded signature, a file that will not read, a parse
+	* 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 = (dependent) => {
+		const memoized = unchangedFolds.get(dependent);
+		if (memoized !== void 0) return memoized;
+		const unchanged = changedRun < CHANGED_RUN_LIMIT && refoldMatchesSignature(dependent);
+		changedRun = unchanged ? 0 : changedRun + 1;
+		unchangedFolds.set(dependent, unchanged);
+		return unchanged;
+	};
+	const refoldMatchesSignature = (dependent) => {
+		const signature = foldSignatures.get(dependent);
+		if (!signature || !ctx || !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 = foldSource({
+				ctx,
+				code,
+				parserResult,
+				filePath: signature.path,
+				runtimeCss,
+				styleCompiler,
+				maxRecipeStates,
+				parseModule: (path) => ctx?.project.parseSourceFile(path),
+				recipeConfigCache,
+				reportSurvivors: false,
+				sourceFile
+			});
+			const unchanged = digest(result.code) === signature.output;
+			/**
+			* Edges re-recorded on the way to suppressing a module, and never on the way to
+			* invalidating one.
+			*
+			* The first is necessary: *which* files a module folds from can move while the bytes it
+			* emits do not — a value now re-exported through a different module, say — and suppressing
+			* the announcement means no transform will run to notice. Leaving the old edges would make
+			* the next edit to the new dependency reach nobody.
+			*
+			* The second would be a bug, and is the reason this is a branch rather than an
+			* unconditional write. `hotUpdate` runs once per environment, client then ssr, against one
+			* shared map. A fold that now yields nothing — an export renamed, a call commented out, any
+			* ordinary mid-edit state — returns `dependencies: []`, so writing it here would retract the
+			* consumer's edge during the *client* pass and leave the *ssr* pass finding an empty set and
+			* returning without invalidating anything: the stale compiled class kept in the SSR cache,
+			* with the client half correctly updated. That is the shape of the bug the self-accepting
+			* fix was about, one environment over. `transform` performs the same retraction, but only
+			* after every environment has already invalidated, which is why it is safe there.
+			*
+			* Confining the write to the unchanged branch removes the hazard rather than sequencing
+			* around it, because a retraction cannot reach that branch: `dependencies` is empty only
+			* when `folded.length === 0`, and a fold that folds nothing returns the module's own source,
+			* which cannot equal an output digest recorded from a pass that replaced a call with a
+			* literal. And where an unchanged verdict *does* narrow the edges, both passes agree anyway
+			* — neither invalidates a module it has just called unchanged.
+			*/
+			if (unchanged) recordFoldDependencies(dependent, result.dependencies);
+			return unchanged;
+		} catch {
+			return false;
+		}
+	};
+	/**
 	* Modules to re-transform because `file` changed, hard-invalidated on the way out.
 	*
 	* Invalidating is the fix. It drops the stale compiled result, which is the defect itself,
@@ -3355,10 +3492,46 @@ const bamboocss = (options = {}) => {
 		const dependents = dependentsByDependency.get(normalizeFsPath(file));
 		if (!dependents?.size) return;
 		const added = [];
-		for (const dependent of dependents) for (const module of graph.getModulesByFile(dependent) ?? []) {
-			if (modules.includes(module) || added.includes(module)) continue;
-			graph.invalidateModule(module);
-			added.push(module);
+		for (const dependent of [...dependents]) {
+			/**
+			* A consumer whose compiled bytes this edit does not move is left entirely alone.
+			*
+			* Announcing one tells the browser to refetch a module it already has verbatim: a round
+			* trip, and behind it — in a framework that re-drives HMR per entry, as react-router does
+			* with `reloadModule` in both its client and its ssr pass — a router revalidation.
+			*
+			* Skipping the *invalidation* follows from the same fact, and is where the cost actually
+			* sits. Vite only soft-invalidates a module that statically imports the changed one, which
+			* keeps its cached transform result and re-serves it for the price of rewriting import
+			* timestamps; hard-invalidating turns that into a full re-transform through every plugin
+			* in the chain. On a fan-out of twenty consumers of one shared module, editing a runtime
+			* value no fold reads took the transforms Bamboo runs for that edit from 22 to 2.
+			*
+			* How much that is worth depends on whether the consumer's import statement *survives* the
+			* fold. When it imports nothing from the module but the value being folded, the binding
+			* goes dead, esbuild drops the statement, and the only edge left is the non-static one
+			* `addWatchFile` created — which Vite hard-invalidates by itself, so declining to here
+			* saves nothing and the re-fold is pure cost. Import one more thing from the same module,
+			* which is the shape a real shared `ui.ts` has, and the statement stays, the consumer is a
+			* static importer, and Bamboo's invalidation is the only reason it re-transforms at all.
+			*
+			* Safe by what "identical" means. The invalidation exists to drop a compiled class string
+			* that no longer matches the source it was compiled from; when recompiling produces the
+			* same string, there is nothing stale to drop. Whichever way the module is reached next —
+			* Vite's own propagation, a later request, or nothing at all — the bytes it yields are the
+			* bytes this fold just computed.
+			*
+			* Nor can it mask an update Vite would have sent by itself. This only ever withholds a
+			* name Bamboo added; `modules` is passed through untouched. A consumer that also *imports*
+			* 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(dependent)) continue;
+			for (const module of graph.getModulesByFile(dependent) ?? []) {
+				if (modules.includes(module) || added.includes(module)) continue;
+				graph.invalidateModule(module);
+				added.push(module);
+			}
 		}
 		if (!added.length) return;
 		/**
@@ -3420,6 +3593,9 @@ const bamboocss = (options = {}) => {
 				recipeConfigCache.clear();
 				dependentsByDependency.clear();
 				dependenciesByFile.clear();
+				foldSignatures.clear();
+				unchangedFolds.clear();
+				changedRun = 0;
 				resetStaticCompilationSession(staticSession);
 			}
 			staticSession.startedEnvironments.add(environment);
@@ -3450,6 +3626,8 @@ const bamboocss = (options = {}) => {
 		* the parser still holds the file.
 		*/
 		watchChange(id, change) {
+			unchangedFolds.clear();
+			changedRun = 0;
 			if (!ctx) return;
 			if (!shouldTransform(id)) return;
 			const [filePath] = id.split("?");
@@ -3458,6 +3636,7 @@ const bamboocss = (options = {}) => {
 			if (change.event === "delete") {
 				ctx.project.removeSourceFile(filePath);
 				recordFoldDependencies(normalizeFsPath(filePath), []);
+				foldSignatures.delete(normalizeFsPath(filePath));
 				return;
 			}
 			ctx.project.reloadSourceFile(filePath);
@@ -3526,6 +3705,7 @@ const bamboocss = (options = {}) => {
 					folded: 0,
 					skipped: new Map([["compile-failed", 1]])
 				});
+				foldSignatures.delete(normalizeFsPath(filePath));
 				addSurvivor({
 					file: filePath,
 					line: 1,
@@ -3558,9 +3738,19 @@ const bamboocss = (options = {}) => {
 			}
 			if (reportSkipped && result.skipped.length) _bamboocss_logger.logger.info("vite:transform", formatSkipped(filePath, result.skipped));
 			for (const dependency of result.dependencies) this.addWatchFile?.(dependency);
-			recordFoldDependencies(normalizeFsPath(filePath), result.dependencies);
+			const dependentKey = normalizeFsPath(filePath);
+			recordFoldDependencies(dependentKey, result.dependencies);
+			if (result.dependencies.length) foldSignatures.set(dependentKey, {
+				input: digest(code),
+				output: digest(result.code),
+				path: filePath
+			});
+			else foldSignatures.delete(dependentKey);
 			const forFile = survivorsByFile.get(filePath);
-			if (command === "serve" && forFile?.length) throw createSurvivorError(forFile);
+			if (command === "serve" && forFile?.length) {
+				foldSignatures.delete(dependentKey);
+				throw createSurvivorError(forFile);
+			}
 			if (!result.folded.length) return null;
 			_bamboocss_logger.logger.debug("vite:transform", `Compiled ${result.folded.length} call(s) in ${filePath}`);
 			return {

package/dist/index.mjs

@@ -6,6 +6,8 @@ import remapping from "@ampproject/remapping";
 import MagicString from "magic-string";
 import postcss from "postcss";
 import selectorParser from "postcss-selector-parser";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
 import { resolveTsPathPattern } from "@bamboocss/config/ts-path";
 import { box, maybeBoxNode } from "@bamboocss/extractor";
@@ -3291,6 +3293,141 @@ const bamboocss = (options = {}) => {
 		}
 	};
 	/**
+	* What each cross-file consumer was last handed, and what it last compiled to.
+	*
+	* Editing a shared module re-transforms everything that folded a value out of it, and most of
+	* those re-transforms recompute the bytes they already had: an edit to one export changes the
+	* consumers reading *that* export, not the ones reading something else from the same file.
+	* `foldDependentModules` uses this to tell those two apart.
+	*
+	* Digests, not text. Retaining every consumer's source and compiled output for the life of the
+	* process is the same order of memory as the ts-morph project already holding it; two 44-byte
+	* strings per entry is not, and it does not grow with module size. The set is bounded the way
+	* `dependenciesByFile` is — an entry exists only while a module's fold actually reads another
+	* file, which most modules never do — so a project that folds nothing across a boundary pays
+	* neither the bytes nor the hashing.
+	*
+	* The *input* digest is what makes the output digest safe to act on. The check below re-folds
+	* a consumer from disk, and disk is the right text only if that is what the last transform was
+	* handed: a module built by another plugin's `load`, or one edited in the same save, fails
+	* that comparison and is treated as changed. `path` is the spelling `transform` used, because
+	* ts-morph and the fold both key on it and Windows spells it more than one way.
+	*/
+	const foldSignatures = /* @__PURE__ */ new Map();
+	const digest = (text) => createHash("sha256").update(text).digest("base64");
+	/**
+	* Consumers this edit cannot move, resolved once per watcher event.
+	*
+	* `hotUpdate` runs once per environment — client and ssr both — and the answer is a property
+	* of the files, not of which environment is asking. Cleared in `watchChange`, which every Vite
+	* in the peer range calls for every file event, before either update hook.
+	*/
+	const unchangedFolds = /* @__PURE__ */ new Map();
+	/**
+	* How many dependents in a row may come back changed before the check gives up for this event.
+	*
+	* The check costs a re-fold — ~0.2 ms per dependent measured on a twenty-consumer fan-out — and
+	* it is paid on the awaited path, before Vite is told anything. That is linear in the number of
+	* consumers and does not bound itself: a shared module with three hundred of them adds ~59 ms to
+	* every edit, including the edits where nothing *can* be suppressed because the change moved the
+	* recipe base and every consumer really did recompile.
+	*
+	* The trade is worth it whenever anything is suppressible. Measured on the same fan-out, a
+	* suppressed consumer saves ~2.3 ms of re-transform for the ~0.23 ms its check costs, so the
+	* check pays for itself at about one consumer in ten. What does not pay is the case where the
+	* answer is going to be "changed" for all of them, and that case announces itself: a run of
+	* consumers that all came back changed. Stopping after eight bounds it. On a three-hundred
+	* consumer fan-out, an edit to the recipe base — where nothing can be suppressed — costs 3.6 ms
+	* here rather than the 59 ms checking every one of them would, stacked onto an edit already
+	* spending 600 ms re-transforming. A single unchanged consumer resets the run, so the same
+	* fan-out editing a value no fold reads still checks all three hundred: 49 ms spent against
+	* 520 ms of re-transform not done, and a 715 ms edit reduced to 183 ms.
+	*
+	* Giving up is always the safe direction — an unchecked dependent is treated as changed, which
+	* is what this path did before any of this existed — so the bound can only cost the
+	* optimisation, never correctness. It costs it where the optimisation was worth least: for the
+	* run to reach eight, the consumers seen so far have to be uniformly changed.
+	*/
+	const CHANGED_RUN_LIMIT = 8;
+	let changedRun = 0;
+	/**
+	* Whether re-folding `dependent` now produces exactly the bytes it produced last time.
+	*
+	* Only the fold can answer that. The consumer's own source has not changed, so whether its
+	* compiled output moves depends entirely on what the edited module resolves to *this* time,
+	* and there is no cheaper way to learn that than to resolve it. Doing it here rather than
+	* waiting for the re-transform is the whole point: the decision is needed before the update is
+	* announced, and for a consumer that turns out to be unchanged this fold *replaces* the
+	* re-transform rather than adding to it.
+	*
+	* Conservative in every failure — no recorded signature, a file that will not read, a parse
+	* 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 = (dependent) => {
+		const memoized = unchangedFolds.get(dependent);
+		if (memoized !== void 0) return memoized;
+		const unchanged = changedRun < CHANGED_RUN_LIMIT && refoldMatchesSignature(dependent);
+		changedRun = unchanged ? 0 : changedRun + 1;
+		unchangedFolds.set(dependent, unchanged);
+		return unchanged;
+	};
+	const refoldMatchesSignature = (dependent) => {
+		const signature = foldSignatures.get(dependent);
+		if (!signature || !ctx || !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 = foldSource({
+				ctx,
+				code,
+				parserResult,
+				filePath: signature.path,
+				runtimeCss,
+				styleCompiler,
+				maxRecipeStates,
+				parseModule: (path) => ctx?.project.parseSourceFile(path),
+				recipeConfigCache,
+				reportSurvivors: false,
+				sourceFile
+			});
+			const unchanged = digest(result.code) === signature.output;
+			/**
+			* Edges re-recorded on the way to suppressing a module, and never on the way to
+			* invalidating one.
+			*
+			* The first is necessary: *which* files a module folds from can move while the bytes it
+			* emits do not — a value now re-exported through a different module, say — and suppressing
+			* the announcement means no transform will run to notice. Leaving the old edges would make
+			* the next edit to the new dependency reach nobody.
+			*
+			* The second would be a bug, and is the reason this is a branch rather than an
+			* unconditional write. `hotUpdate` runs once per environment, client then ssr, against one
+			* shared map. A fold that now yields nothing — an export renamed, a call commented out, any
+			* ordinary mid-edit state — returns `dependencies: []`, so writing it here would retract the
+			* consumer's edge during the *client* pass and leave the *ssr* pass finding an empty set and
+			* returning without invalidating anything: the stale compiled class kept in the SSR cache,
+			* with the client half correctly updated. That is the shape of the bug the self-accepting
+			* fix was about, one environment over. `transform` performs the same retraction, but only
+			* after every environment has already invalidated, which is why it is safe there.
+			*
+			* Confining the write to the unchanged branch removes the hazard rather than sequencing
+			* around it, because a retraction cannot reach that branch: `dependencies` is empty only
+			* when `folded.length === 0`, and a fold that folds nothing returns the module's own source,
+			* which cannot equal an output digest recorded from a pass that replaced a call with a
+			* literal. And where an unchanged verdict *does* narrow the edges, both passes agree anyway
+			* — neither invalidates a module it has just called unchanged.
+			*/
+			if (unchanged) recordFoldDependencies(dependent, result.dependencies);
+			return unchanged;
+		} catch {
+			return false;
+		}
+	};
+	/**
 	* Modules to re-transform because `file` changed, hard-invalidated on the way out.
 	*
 	* Invalidating is the fix. It drops the stale compiled result, which is the defect itself,
@@ -3325,10 +3462,46 @@ const bamboocss = (options = {}) => {
 		const dependents = dependentsByDependency.get(normalizeFsPath(file));
 		if (!dependents?.size) return;
 		const added = [];
-		for (const dependent of dependents) for (const module of graph.getModulesByFile(dependent) ?? []) {
-			if (modules.includes(module) || added.includes(module)) continue;
-			graph.invalidateModule(module);
-			added.push(module);
+		for (const dependent of [...dependents]) {
+			/**
+			* A consumer whose compiled bytes this edit does not move is left entirely alone.
+			*
+			* Announcing one tells the browser to refetch a module it already has verbatim: a round
+			* trip, and behind it — in a framework that re-drives HMR per entry, as react-router does
+			* with `reloadModule` in both its client and its ssr pass — a router revalidation.
+			*
+			* Skipping the *invalidation* follows from the same fact, and is where the cost actually
+			* sits. Vite only soft-invalidates a module that statically imports the changed one, which
+			* keeps its cached transform result and re-serves it for the price of rewriting import
+			* timestamps; hard-invalidating turns that into a full re-transform through every plugin
+			* in the chain. On a fan-out of twenty consumers of one shared module, editing a runtime
+			* value no fold reads took the transforms Bamboo runs for that edit from 22 to 2.
+			*
+			* How much that is worth depends on whether the consumer's import statement *survives* the
+			* fold. When it imports nothing from the module but the value being folded, the binding
+			* goes dead, esbuild drops the statement, and the only edge left is the non-static one
+			* `addWatchFile` created — which Vite hard-invalidates by itself, so declining to here
+			* saves nothing and the re-fold is pure cost. Import one more thing from the same module,
+			* which is the shape a real shared `ui.ts` has, and the statement stays, the consumer is a
+			* static importer, and Bamboo's invalidation is the only reason it re-transforms at all.
+			*
+			* Safe by what "identical" means. The invalidation exists to drop a compiled class string
+			* that no longer matches the source it was compiled from; when recompiling produces the
+			* same string, there is nothing stale to drop. Whichever way the module is reached next —
+			* Vite's own propagation, a later request, or nothing at all — the bytes it yields are the
+			* bytes this fold just computed.
+			*
+			* Nor can it mask an update Vite would have sent by itself. This only ever withholds a
+			* name Bamboo added; `modules` is passed through untouched. A consumer that also *imports*
+			* 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(dependent)) continue;
+			for (const module of graph.getModulesByFile(dependent) ?? []) {
+				if (modules.includes(module) || added.includes(module)) continue;
+				graph.invalidateModule(module);
+				added.push(module);
+			}
 		}
 		if (!added.length) return;
 		/**
@@ -3390,6 +3563,9 @@ const bamboocss = (options = {}) => {
 				recipeConfigCache.clear();
 				dependentsByDependency.clear();
 				dependenciesByFile.clear();
+				foldSignatures.clear();
+				unchangedFolds.clear();
+				changedRun = 0;
 				resetStaticCompilationSession(staticSession);
 			}
 			staticSession.startedEnvironments.add(environment);
@@ -3420,6 +3596,8 @@ const bamboocss = (options = {}) => {
 		* the parser still holds the file.
 		*/
 		watchChange(id, change) {
+			unchangedFolds.clear();
+			changedRun = 0;
 			if (!ctx) return;
 			if (!shouldTransform(id)) return;
 			const [filePath] = id.split("?");
@@ -3428,6 +3606,7 @@ const bamboocss = (options = {}) => {
 			if (change.event === "delete") {
 				ctx.project.removeSourceFile(filePath);
 				recordFoldDependencies(normalizeFsPath(filePath), []);
+				foldSignatures.delete(normalizeFsPath(filePath));
 				return;
 			}
 			ctx.project.reloadSourceFile(filePath);
@@ -3496,6 +3675,7 @@ const bamboocss = (options = {}) => {
 					folded: 0,
 					skipped: new Map([["compile-failed", 1]])
 				});
+				foldSignatures.delete(normalizeFsPath(filePath));
 				addSurvivor({
 					file: filePath,
 					line: 1,
@@ -3528,9 +3708,19 @@ const bamboocss = (options = {}) => {
 			}
 			if (reportSkipped && result.skipped.length) logger.info("vite:transform", formatSkipped(filePath, result.skipped));
 			for (const dependency of result.dependencies) this.addWatchFile?.(dependency);
-			recordFoldDependencies(normalizeFsPath(filePath), result.dependencies);
+			const dependentKey = normalizeFsPath(filePath);
+			recordFoldDependencies(dependentKey, result.dependencies);
+			if (result.dependencies.length) foldSignatures.set(dependentKey, {
+				input: digest(code),
+				output: digest(result.code),
+				path: filePath
+			});
+			else foldSignatures.delete(dependentKey);
 			const forFile = survivorsByFile.get(filePath);
-			if (command === "serve" && forFile?.length) throw createSurvivorError(forFile);
+			if (command === "serve" && forFile?.length) {
+				foldSignatures.delete(dependentKey);
+				throw createSurvivorError(forFile);
+			}
 			if (!result.folded.length) return null;
 			logger.debug("vite:transform", `Compiled ${result.folded.length} call(s) in ${filePath}`);
 			return {

package/package.json

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