@tenphi/tasty 0.0.0-snapshot.fdb16ea → 0.0.0-snapshot.fde6cf3

package/dist/{config-B23gZrfP.js → config-Bd2vOF0Z.js}

@@ -2561,8 +2561,8 @@ function resetStyleChunks() {
 * unused is one property load and one branch.
 */
 const GTKEY$1 = "__tasty_prop_handlers__";
-const globalStore$1 = globalThis;
-const propHandlerRegistry = globalStore$1[GTKEY$1] ?? (globalStore$1[GTKEY$1] = {
+const globalStore$2 = globalThis;
+const propHandlerRegistry = globalStore$2[GTKEY$1] ?? (globalStore$2[GTKEY$1] = {
 	apply: null,
 	list: []
 });
@@ -3186,7 +3186,14 @@ function resetStyleBatch() {
 * Automatically infers CSS @property types from custom property values.
 * Supports deferred resolution for var() reference chains of arbitrary depth.
 */
-const CUSTOM_PROP_DECL = /^\s*(--[a-z0-9_-]+)\s*:\s*(.+?)\s*$/i;
+/**
+* One `--name: value` declaration, with the surrounding whitespace dropped.
+*
+* The value is anchored on `\S` at both ends so no two quantifiers can claim
+* the same character. A lazy `(.+?)\s*$` is quadratic on a value of nothing
+* but spaces — every split point gets tried (CodeQL `js/polynomial-redos`).
+*/
+const CUSTOM_PROP_DECL = /^\s*(--[a-z0-9_-]+)\s*:\s*(\S|\S.*\S)\s*$/i;
 const SINGLE_VAR_REF = /^var\((--[a-z0-9_-]+)\)$/i;
 var PropertyTypeResolver = class {
 	/** propName → the prop it depends on */
@@ -5030,6 +5037,8 @@ var SheetManager = class {
 		if (!registry) {
 			const metrics = this.config.devMode ? {
 				hits: 0,
+				precompiledHits: 0,
+				precompiledUniqueHits: 0,
 				misses: 0,
 				bulkCleanups: 0,
 				totalInsertions: 0,
@@ -5054,10 +5063,9 @@ var SheetManager = class {
 				injectedFunctions: /* @__PURE__ */ new Map(),
 				globalRules: /* @__PURE__ */ new Map(),
 				propertyTypeResolver: new PropertyTypeResolver(),
-				usageMap: /* @__PURE__ */ new Map(),
+				unusedSince: /* @__PURE__ */ new Map(),
+				localKeyframes: /* @__PURE__ */ new Map(),
 				touchCount: 0,
-				touchTick: -1,
-				touchedTick: /* @__PURE__ */ new Set(),
 				serverClassSyncIndex: 0,
 				rscStylesScanned: false,
 				injectionMode: this.detectInjectionMode(root)
@@ -5492,7 +5500,14 @@ var SheetManager = class {
 				this.deleteRule(registry, ruleInfo);
 				registry.rules.delete(className);
 				registry.pinCounts.delete(className);
-				registry.usageMap.delete(className);
+				registry.unusedSince.delete(className);
+				for (const [key, entry] of registry.localKeyframes) {
+					if (!entry.owners.delete(className)) continue;
+					if (entry.owners.size === 0) {
+						entry.dispose();
+						registry.localKeyframes.delete(key);
+					}
+				}
 				deleted.add(className);
 				cleanedUpCount++;
 			}
@@ -5519,25 +5534,31 @@ var SheetManager = class {
 		return registry.sheets.reduce((total, sheet) => total + sheet.ruleCount - sheet.holes.length, 0);
 	}
 	/**
-	* Get CSS text from all sheets (for SSR)
+	* The CSS of one managed sheet, or `null` when it holds none this can read —
+	* an empty style element, or a sheet the engine refuses to hand over.
 	*/
-	getCSSText(registry) {
-		const cssChunks = [];
-		for (const sheetInfo of registry.sheets) try {
-			if (sheetInfo.constructableSheet) {
-				const rules = Array.from(sheetInfo.constructableSheet.cssRules);
-				cssChunks.push(rules.map((rule) => rule.cssText).join("\n"));
-			} else if (sheetInfo.sheet) {
+	readSheetCSS(sheetInfo) {
+		try {
+			if (sheetInfo.constructableSheet) return Array.from(sheetInfo.constructableSheet.cssRules).map((rule) => rule.cssText).join("\n");
+			if (sheetInfo.sheet) {
 				const styleElement = sheetInfo.sheet;
-				if (styleElement.textContent) cssChunks.push(styleElement.textContent);
-				else if (styleElement.sheet) {
-					const rules = Array.from(styleElement.sheet.cssRules);
-					cssChunks.push(rules.map((rule) => rule.cssText).join("\n"));
-				}
+				if (styleElement.textContent) return styleElement.textContent;
+				if (styleElement.sheet) return Array.from(styleElement.sheet.cssRules).map((rule) => rule.cssText).join("\n");
 			}
 		} catch (error) {
 			console.warn("[Tasty] Failed to read CSS from sheet:", error);
 		}
+		return null;
+	}
+	/**
+	* Get CSS text from all sheets (for SSR)
+	*/
+	getCSSText(registry) {
+		const cssChunks = [];
+		for (const sheetInfo of registry.sheets) {
+			const css = this.readSheetCSS(sheetInfo);
+			if (css !== null) cssChunks.push(css);
+		}
 		return cssChunks.join("\n");
 	}
 	/**
@@ -5554,16 +5575,21 @@ var SheetManager = class {
 	* Reset cache performance metrics
 	*/
 	resetMetrics(registry) {
-		if (registry.metrics) registry.metrics = {
-			hits: 0,
-			misses: 0,
-			bulkCleanups: 0,
-			totalInsertions: 0,
-			totalUnused: 0,
-			stylesCleanedUp: 0,
-			cleanupHistory: [],
-			startTime: Date.now()
-		};
+		if (registry.metrics) {
+			registry.metrics = {
+				hits: 0,
+				precompiledHits: 0,
+				precompiledUniqueHits: 0,
+				misses: 0,
+				bulkCleanups: 0,
+				totalInsertions: 0,
+				totalUnused: 0,
+				stylesCleanedUp: 0,
+				cleanupHistory: [],
+				startTime: Date.now()
+			};
+			registry.precompiledUsedClasses = void 0;
+		}
 	}
 	/**
 	* Convert keyframes steps to CSS string.
@@ -5849,6 +5875,49 @@ var SheetManager = class {
 	/**
 	* Get the raw CSS content
 	*/
+	/**
+	* The CSS this injector owns in `root`, one entry per sheet, in the order the
+	* engine applies them.
+	*
+	* `getCSSText()` walks the managed sheets only, and raw CSS has its own —
+	* which sits before, after, or *between* them depending on how it got there:
+	* prepended to `adoptedStyleSheets`, or wherever in `<head>` the first raw
+	* injection happened to land, with every managed sheet opened afterwards
+	* following it. Reporting a fixed order would describe the opposite winner
+	* from the live page whenever two rules of equal specificity meet, so the raw
+	* sheet is spliced in at the position the DOM actually gives it.
+	*/
+	getOwnedCSSInOrder(registry, root) {
+		const raw = this.getRawCSSText(root);
+		const rawElement = this.isAdoptedMode(root) ? null : this.rawStyleElements.get(root);
+		let rawIndex = raw && !rawElement ? 0 : -1;
+		const chunks = [];
+		for (const sheetInfo of registry.sheets) {
+			const css = this.readSheetCSS(sheetInfo);
+			if (css === null) continue;
+			if (rawIndex < 0 && rawElement && sheetInfo.sheet && rawElement.compareDocumentPosition(sheetInfo.sheet) & Node.DOCUMENT_POSITION_FOLLOWING) rawIndex = chunks.length;
+			chunks.push(css);
+		}
+		if (!raw) return chunks;
+		chunks.splice(rawIndex < 0 ? chunks.length : rawIndex, 0, raw);
+		return chunks;
+	}
+	/**
+	* Top-level rules in the raw sheet.
+	*
+	* Read from the sheet the engine parsed, not from the text: a raw block is
+	* one string but any number of rules, and one rule — `@keyframes`, `@media` —
+	* can contain any number of blocks, so counting braces answers neither
+	* question.
+	*/
+	getRawRuleCount(root) {
+		const sheet = this.isAdoptedMode(root) ? this.rawConstructableSheets.get(root) : this.rawStyleElements.get(root)?.sheet;
+		try {
+			return sheet?.cssRules.length ?? 0;
+		} catch {
+			return 0;
+		}
+	}
 	getRawCSSText(root) {
 		if (this.isAdoptedMode(root)) {
 			const blocksMap = this.rawCSSBlocks.get(root);
@@ -5970,6 +6039,11 @@ function formatCounterStyleRule(name, descriptors) {
 }
 //#endregion
 //#region src/injector/injector.ts
+/**
+* How long a class is left alone after it was last known to be wanted.
+* Long enough that a render cannot plausibly still be waiting to commit one.
+*/
+const DEFAULT_GC_GRACE = 1e4;
 /** Dispose handle handed back for injections that took no pin. */
 const noop = () => {};
 /**
@@ -6035,16 +6109,48 @@ var StyleInjector = class {
 	sheetManager;
 	config;
 	globalRuleCounter = 0;
-	/** Cancels the scheduled GC, whatever scheduled it. Null when none is pending. */
+	/** Cancels the scheduled sweep, whichever timer scheduled it. */
 	cancelPendingGC = null;
 	namePrefix;
 	classRegex;
 	rscClassRegex;
+	precompiledRevision = -1;
 	/** @internal — exposed for debug utilities only */
 	get _sheetManager() {
 		return this.sheetManager;
 	}
 	/**
+	* Seed deduplication metadata for rules supplied by an immutable external
+	* stylesheet. This records no owned sheet entries and performs no CSS work.
+	* @internal
+	*/
+	registerPrecompiledDependencies(dependencies, revision) {
+		if (typeof document === "undefined" || this.precompiledRevision === revision) return;
+		const registry = this.sheetManager.getRegistry(document);
+		for (const item of dependencies.properties) if (!registry.injectedProperties.has(item.name)) registry.injectedProperties.set(item.name, item.definition);
+		for (const hash of dependencies.fontFaces) registry.injectedFontFaces.add(hash);
+		for (const item of dependencies.counterStyles) if (!registry.injectedCounterStyles.has(item.name)) registry.injectedCounterStyles.set(item.name, true);
+		for (const name of dependencies.functions) if (!registry.injectedFunctions.has(name)) registry.injectedFunctions.set(name, true);
+		for (const item of dependencies.keyframes) {
+			if (!registry.keyframesCache.has(item.contentKey)) registry.keyframesCache.set(item.contentKey, {
+				name: item.name,
+				refCount: Number.POSITIVE_INFINITY,
+				info: {
+					name: item.name,
+					ruleIndex: -2,
+					sheetIndex: -2
+				}
+			});
+			if (!registry.keyframesNameToContent.has(item.name)) registry.keyframesNameToContent.set(item.name, item.contentKey);
+			if (!registry.localKeyframes.has(item.name)) registry.localKeyframes.set(item.name, {
+				name: item.name,
+				dispose: () => {},
+				owners: /* @__PURE__ */ new Set()
+			});
+		}
+		this.precompiledRevision = revision;
+	}
+	/**
 	* Whether sheet writes should be queued instead of applied immediately.
 	*
 	* Only ever true on the client: SSR collects CSS as text and the RSC path
@@ -6124,6 +6230,28 @@ var StyleInjector = class {
 		return false;
 	}
 	/**
+	* Resolve an already-owned or server-hydrated class before its declarations
+	* are rendered. A miss does not reserve a class or mutate the rule cache.
+	* @internal
+	*/
+	prepareClassName(cacheKey, options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		const mapped = registry.cacheKeyToClassName.get(cacheKey);
+		if (mapped) {
+			const info = registry.rules.get(mapped);
+			if (info && !(info.ruleIndex === -1 && info.sheetIndex === -1)) return {
+				className: mapped,
+				isExisting: true
+			};
+		}
+		const className = this.generateClassName(cacheKey);
+		return {
+			className,
+			isExisting: this.tryHydratedHit(registry, cacheKey, className)
+		};
+	}
+	/**
 	* Allocate a className for a cacheKey without injecting styles yet.
 	* This allows separating className allocation (render phase) from style injection (insertion phase).
 	*/
@@ -6171,11 +6299,14 @@ var StyleInjector = class {
 			dispose: () => {}
 		};
 		const cacheKey = options?.cacheKey;
+		const preparedClassName = options?.preparedClassName;
 		let className;
-		if (cacheKey && registry.cacheKeyToClassName.has(cacheKey)) {
+		if (preparedClassName) className = preparedClassName;
+		else if (cacheKey && registry.cacheKeyToClassName.has(cacheKey)) {
 			className = registry.cacheKeyToClassName.get(cacheKey);
 			const existingRuleInfo = registry.rules.get(className);
 			if (existingRuleInfo.ruleIndex === -3) {
+				registry.unusedSince.delete(className);
 				if (pin) registry.pinCounts.set(className, (registry.pinCounts.get(className) || 0) + 1);
 				if (registry.metrics) registry.metrics.hits++;
 				return {
@@ -6184,6 +6315,7 @@ var StyleInjector = class {
 				};
 			}
 			if (!(existingRuleInfo.ruleIndex === -1 && existingRuleInfo.sheetIndex === -1)) {
+				registry.unusedSince.delete(className);
 				if (pin) {
 					const pins = registry.pinCounts.get(className) || 0;
 					registry.pinCounts.set(className, pins + 1);
@@ -6263,7 +6395,7 @@ var StyleInjector = class {
 			});
 			if (cacheKey) registry.cacheKeyToClassName.set(cacheKey, className);
 			if (pin) registry.pinCounts.set(className, 1);
-			this.markUsage(registry, className);
+			registry.unusedSince.set(className, Date.now());
 			const queued = enqueueStyleWrite(() => {
 				if (applySheetWrite()) return;
 				registry.rules.set(className, {
@@ -6280,7 +6412,6 @@ var StyleInjector = class {
 						registry.rules.delete(className);
 						if (cacheKey) registry.cacheKeyToClassName.delete(cacheKey);
 						registry.pinCounts.set(className, 0);
-						registry.usageMap.delete(className);
 						return;
 					}
 					this.unpin(className, registry);
@@ -6292,7 +6423,7 @@ var StyleInjector = class {
 			dispose: () => {}
 		};
 		if (pin) registry.pinCounts.set(className, 1);
-		this.markUsage(registry, className);
+		registry.unusedSince.set(className, Date.now());
 		return {
 			className,
 			dispose: pin ? () => this.unpin(className, registry) : noop
@@ -6375,6 +6506,63 @@ var StyleInjector = class {
 		return this.sheetManager.getRawCSSText(root);
 	}
 	/**
+	* Take a reference on local `@keyframes`, under the deterministic names the
+	* caller resolved.
+	*
+	* One reference per distinct set of steps, shared by every class that ends up
+	* animating it, so a repeat render takes nothing further. Ownership is
+	* assigned by `ownKeyframes()` once the rules exist to be inspected.
+	*/
+	holdKeyframes(steps, names, options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		const keys = /* @__PURE__ */ new Map();
+		for (const [authored, definition] of Object.entries(steps)) {
+			const resolved = names.get(authored) ?? authored;
+			let entry = registry.localKeyframes.get(resolved);
+			if (!entry) {
+				const injected = this.keyframes(definition, {
+					name: resolved,
+					root,
+					distinctByName: true
+				});
+				entry = {
+					name: injected.toString(),
+					dispose: injected.dispose,
+					owners: /* @__PURE__ */ new Set()
+				};
+				registry.localKeyframes.set(resolved, entry);
+			}
+			keys.set(authored, resolved);
+		}
+		return keys;
+	}
+	/**
+	* Record that `className` animates these keyframes, so the reference is
+	* released when the last such class is collected.
+	*
+	* Only classes whose rules actually reference the animation should be here:
+	* a class that merely rendered alongside one would otherwise keep the
+	* keyframes alive for as long as it lives.
+	*/
+	ownKeyframes(key, className, options) {
+		this.sheetManager.getRegistry(options?.root || document).localKeyframes.get(key)?.owners.add(className);
+	}
+	/** Record a chunk lookup served by an immutable external stylesheet. */
+	recordPrecompiledHit(className, options) {
+		if (!this.config.devMode) return;
+		const registry = this.sheetManager.getRegistry(options?.root || document);
+		if (registry.metrics) {
+			registry.metrics.hits++;
+			registry.metrics.precompiledHits++;
+			const used = registry.precompiledUsedClasses ??= /* @__PURE__ */ new Set();
+			if (!used.has(className)) {
+				used.add(className);
+				registry.metrics.precompiledUniqueHits++;
+			}
+		}
+	}
+	/**
 	* Pin an already-injected cacheKey and return the handle that releases it.
 	* For callers that skipped the pipeline on a cache hit but still need the
 	* class held. Returns null if the cacheKey is not found.
@@ -6393,19 +6581,6 @@ var StyleInjector = class {
 		};
 	}
 	/**
-	* Seed the LRU stamp for a newly injected class.
-	*
-	* Without it a class injected during a render but not yet touched would carry
-	* no timestamp at all and sort as the oldest candidate, so `gc()` could evict
-	* the very rule the current render just wrote.
-	*/
-	markUsage(registry, className) {
-		const now = Date.now();
-		const entry = registry.usageMap.get(className);
-		if (entry) entry.lastTouchedAt = now;
-		else registry.usageMap.set(className, { lastTouchedAt: now });
-	}
-	/**
 	* Release one pin on a className. At zero pins the class is not deleted — it
 	* stays cached and collectible, and `gc()` decides when it actually goes.
 	*/
@@ -6643,13 +6818,14 @@ var StyleInjector = class {
 	keyframes(steps, nameOrOptions) {
 		const isStringName = typeof nameOrOptions === "string";
 		const providedName = isStringName ? nameOrOptions : nameOrOptions?.name;
+		const distinctByName = isStringName ? false : nameOrOptions?.distinctByName ?? false;
 		const root = isStringName ? document : nameOrOptions?.root || document;
 		const registry = this.sheetManager.getRegistry(root);
 		if (Object.keys(steps).length === 0) return {
 			toString: () => "",
 			dispose: () => {}
 		};
-		const contentHash = JSON.stringify(steps);
+		const contentHash = distinctByName && providedName ? `${providedName}\u0000${JSON.stringify(steps)}` : JSON.stringify(steps);
 		const existing = registry.keyframesCache.get(contentHash);
 		if (existing) {
 			existing.refCount++;
@@ -6666,7 +6842,7 @@ var StyleInjector = class {
 				actualName = providedName;
 				registry.keyframesNameToContent.set(providedName, contentHash);
 			}
-		} else actualName = makeKeyframeName(this.namePrefix, String(registry.keyframesCounter++));
+		} else actualName = makeKeyframeName(this.namePrefix, hashString(contentHash));
 		const applyWrite = () => {
 			const result = this.sheetManager.insertKeyframes(registry, steps, actualName, root);
 			if (!result) return false;
@@ -6741,45 +6917,31 @@ var StyleInjector = class {
 		}
 	}
 	/**
-	* Record a render-time usage hit for one or more classNames.
-	* Handles space-separated multi-chunk classNames.
-	* When the global touch counter reaches `touchInterval`, schedules a GC
-	* via `requestIdleCallback`.
-	* No-op on the server.
+	* Count a render, and schedule a collection pass every `touchInterval` of
+	* them. Nothing else: what a class is worth keeping is decided by the sweep's
+	* own DOM scan, so rendering does not track usage at all.
+	*
+	* @deprecated The class name is ignored — pass anything, or stop calling it.
+	* Collection no longer records per-class usage, and scheduling does not need
+	* to know which class was rendered. A class handed back by `inject()` is
+	* marked wanted there, which is what reuse actually goes through.
 	*/
-	touch(className, options) {
+	touch(_className, options) {
 		if (typeof document === "undefined") return;
 		if (!this.config.gc) return;
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const now = Date.now();
-		if (registry.touchTick !== now) {
-			registry.touchTick = now;
-			registry.touchedTick.clear();
-		} else if (registry.touchedTick.has(className)) return;
-		registry.touchedTick.add(className);
-		const parts = className.indexOf(" ") === -1 ? [className] : className.split(" ");
-		for (const cls of parts) {
-			if (!this.classRegex.test(cls)) continue;
-			if (!registry.rules.has(cls)) continue;
-			const entry = registry.usageMap.get(cls);
-			if (entry) entry.lastTouchedAt = now;
-			else registry.usageMap.set(cls, { lastTouchedAt: now });
-			registry.touchCount++;
-		}
-		const touchInterval = this.config.gc.touchInterval ?? 1e3;
-		if (registry.touchCount >= touchInterval) {
+		const registry = this.sheetManager.getRegistry(options?.root || document);
+		if (++registry.touchCount >= (this.config.gc.touchInterval ?? 1e3)) {
 			registry.touchCount = 0;
 			this.scheduleGC();
 		}
 	}
 	/**
-	* Schedule a GC via `requestIdleCallback`, falling back to a timeout.
-	* Runs GC on all active roots. Avoids double-scheduling.
+	* Schedule a GC in idle time. Runs GC on all active roots, and avoids
+	* double-scheduling.
 	*
-	* The fallback is deliberately asynchronous: `touch()` runs during React's
-	* render phase, when a class is already injected but its element has not been
-	* committed yet, and a GC there would judge it unused.
+	* Idle only. Without `requestIdleCallback` nothing is collected
+	* automatically: running the sweep inline here would put it inside the render
+	* that touched the class, and collection is never urgent enough for that.
 	*/
 	scheduleGC() {
 		if (this.cancelPendingGC) return;
@@ -6791,9 +6953,6 @@ var StyleInjector = class {
 		if (typeof requestIdleCallback !== "undefined") {
 			const handle = requestIdleCallback(() => runGC());
 			this.cancelPendingGC = () => cancelIdleCallback(handle);
-		} else {
-			const handle = setTimeout(runGC, 0);
-			this.cancelPendingGC = () => clearTimeout(handle);
 		}
 	}
 	/**
@@ -6805,19 +6964,43 @@ var StyleInjector = class {
 	* "unused" means. Entries carry their last `touch()` so callers can drop the
 	* oldest first; a class that was never touched sorts as oldest.
 	*/
+	/**
+	* Everything the injector holds falls into one of five bands, and only the
+	* last of them is ever deleted:
+	*
+	* 1. rendered — some element carries the class right now
+	* 2. not ours — queued for a batched write, pre-allocated, or server-rendered
+	* 3. hot — nothing carries it, but that was noticed less than `grace` ago
+	* 4. cached — cold, but within `capacity` when ordered by when it went cold
+	* 5. the rest
+	*
+	* This returns bands 4 and 5 together, most recently cold first; `gc()` draws
+	* the capacity line through them. Band 3 is what makes collection safe
+	* without a commit signal: a render can resolve a class and commit it a
+	* little later, and during that gap nothing on the page carries it.
+	*/
 	collectUnused(registry, root) {
+		const now = Date.now();
+		const grace = this.config.gc?.grace ?? DEFAULT_GC_GRACE;
 		const liveClasses = /* @__PURE__ */ new Set();
 		for (const el of root.querySelectorAll("[class]")) for (const token of el.classList) if (this.classRegex.test(token)) liveClasses.add(token);
 		const unused = [];
 		for (const [className, ruleInfo] of registry.rules) {
 			if (ruleInfo.sheetIndex < 0) continue;
-			if (liveClasses.has(className)) continue;
+			if (liveClasses.has(className)) {
+				registry.unusedSince.delete(className);
+				continue;
+			}
 			if ((registry.pinCounts.get(className) ?? 0) > 0) continue;
-			unused.push({
-				className,
-				lastTouchedAt: registry.usageMap.get(className)?.lastTouchedAt ?? 0
-			});
+			let since = registry.unusedSince.get(className);
+			if (since === void 0) {
+				since = now;
+				registry.unusedSince.set(className, now);
+			}
+			if (now - since < grace) continue;
+			unused.push(className);
 		}
+		unused.sort((a, b) => (registry.unusedSince.get(b) ?? 0) - (registry.unusedSince.get(a) ?? 0));
 		return unused;
 	}
 	/**
@@ -6829,7 +7012,7 @@ var StyleInjector = class {
 		if (typeof document === "undefined") return [];
 		const root = options?.root || document;
 		const registry = this.sheetManager.getRegistry(root);
-		return this.collectUnused(registry, root).map((entry) => entry.className);
+		return this.collectUnused(registry, root);
 	}
 	/**
 	* Synchronous garbage collection.
@@ -6849,17 +7032,15 @@ var StyleInjector = class {
 		this.cancelPendingGC?.();
 		this.cancelPendingGC = null;
 		const root = options?.root || document;
-		const force = options?.force ?? false;
+		const force = options?.force;
 		const registry = this.sheetManager.getRegistry(root);
 		const capacity = this.config.gc?.capacity ?? 1e3;
 		if (!force && registry.rules.size <= capacity) return 0;
 		const unused = this.collectUnused(registry, root);
 		let doomed;
-		if (force) doomed = unused.map((entry) => entry.className);
-		else if (unused.length > capacity) {
-			unused.sort((a, b) => a.lastTouchedAt - b.lastTouchedAt);
-			doomed = unused.slice(0, unused.length - capacity).map((entry) => entry.className);
-		} else return 0;
+		if (force) doomed = unused;
+		else if (unused.length > capacity) doomed = unused.slice(capacity);
+		else return 0;
 		if (doomed.length === 0) return 0;
 		return this.sheetManager.deleteClasses(registry, doomed);
 	}
@@ -6877,6 +7058,131 @@ var StyleInjector = class {
 	}
 };
 //#endregion
+//#region src/precompile/runtime.ts
+const STORE_KEY = Symbol.for("@tenphi/tasty/precompiled/v1");
+const globalStore$1 = globalThis;
+const store = globalStore$1[STORE_KEY] ??= {
+	manifests: null,
+	chunks: null,
+	dependencies: null,
+	buildCount: 0,
+	active: false,
+	validatedRevision: -1,
+	validate: null,
+	revision: 0,
+	warnings: null
+};
+const EMPTY_DEPENDENCIES = Object.freeze({
+	properties: Object.freeze([]),
+	keyframes: Object.freeze([]),
+	fontFaces: Object.freeze([]),
+	counterStyles: Object.freeze([]),
+	functions: Object.freeze([]),
+	rscKeys: Object.freeze([])
+});
+function getPrecompileStore() {
+	return store;
+}
+function warnPrecompileOnce(key, message) {
+	if (!isDevEnv()) return;
+	const warnings = store.warnings ??= /* @__PURE__ */ new Set();
+	if (warnings.has(key)) return;
+	warnings.add(key);
+	console.warn(message);
+}
+/** Shared single-read gate for the unregistered render hot path. */
+const precompileRuntimeState = store;
+/** @internal Keep catalog recording on the isolated compiler path. */
+function beginPrecompileBuild() {
+	store.buildCount = (store.buildCount ?? 0) + 1;
+	store.active = true;
+}
+/** @internal Balance beginPrecompileBuild(), including failed catalog cases. */
+function endPrecompileBuild() {
+	store.buildCount--;
+	if (store.buildCount === 0 && store.chunks === null) store.active = false;
+}
+function findPrecompiledChunk(lookupKey, namePrefix) {
+	store.validate?.();
+	const chunk = store.chunks?.get(lookupKey);
+	if (!chunk) return null;
+	if (chunk.namePrefix !== namePrefix) {
+		warnPrecompileOnce(`prefix:${chunk.manifestId}:${namePrefix}`, `[Tasty] Ignoring precompiled styles "${chunk.manifestId}": generated with namePrefix "${chunk.namePrefix}", but the runtime uses "${namePrefix}".`);
+		return null;
+	}
+	return chunk;
+}
+function getPrecompiledRevision() {
+	return store.revision;
+}
+function getRegisteredPrecompiledDependencies(namePrefix) {
+	store.validate?.();
+	return store.dependencies?.get(namePrefix) ?? EMPTY_DEPENDENCIES;
+}
+/** @internal Metadata used by tastyDebug without reading or parsing CSSOM. */
+function getRegisteredPrecompiledStats(namePrefix) {
+	const classNames = /* @__PURE__ */ new Set();
+	let manifestCount = 0;
+	let cssSize = 0;
+	let ruleCount = 0;
+	for (const manifest of store.manifests?.values() ?? []) {
+		if (manifest.namePrefix !== namePrefix) continue;
+		manifestCount++;
+		cssSize += manifest.stats.cssSize;
+		ruleCount += manifest.stats.ruleCount;
+		for (const chunk of manifest.chunks) classNames.add(chunk.className);
+	}
+	return {
+		manifestCount,
+		classNames: [...classNames],
+		cssSize,
+		ruleCount
+	};
+}
+function applyRegisteredDependenciesToInjector(injector, namePrefix) {
+	if (!store.manifests) return;
+	injector.registerPrecompiledDependencies(getRegisteredPrecompiledDependencies(namePrefix), store.revision);
+}
+function applyRegisteredDependenciesToRSC(cache, namePrefix) {
+	if (cache.precompiledRevision === store.revision) return;
+	for (const key of cache.precompiledEmittedKeys) cache.emittedKeys.delete(key);
+	for (const [key, name] of cache.precompiledGeneratedNames) if (cache.generatedNames.get(key) === name) cache.generatedNames.delete(key);
+	cache.precompiledEmittedKeys.clear();
+	cache.precompiledGeneratedNames.clear();
+	if (!store.manifests) {
+		cache.precompiledRevision = store.revision;
+		return;
+	}
+	const dependencies = getRegisteredPrecompiledDependencies(namePrefix);
+	for (const key of dependencies.rscKeys) {
+		cache.emittedKeys.add(key);
+		cache.precompiledEmittedKeys.add(key);
+	}
+	for (const item of dependencies.keyframes) for (const key of item.rscKeys) {
+		cache.emittedKeys.add(key);
+		cache.generatedNames.set(key, item.name);
+		cache.precompiledEmittedKeys.add(key);
+		cache.precompiledGeneratedNames.set(key, item.name);
+	}
+	for (const item of dependencies.counterStyles) for (const key of item.rscKeys) {
+		cache.emittedKeys.add(key);
+		cache.generatedNames.set(key, item.name);
+		cache.precompiledEmittedKeys.add(key);
+		cache.precompiledGeneratedNames.set(key, item.name);
+	}
+	cache.precompiledRevision = store.revision;
+}
+/** @internal Test-only reset; resetConfig() calls this to isolate suites. */
+function resetPrecompiledStyles() {
+	store.manifests = null;
+	store.chunks = null;
+	store.dependencies = null;
+	store.buildCount = 0;
+	store.active = false;
+	store.revision++;
+	store.warnings?.clear();
+}
+//#endregion
 //#region src/states/index.ts
 /**
 * Advanced State Mapping - Predefined States Management
@@ -11595,6 +11901,36 @@ function warnOnce(key, message) {
 	}
 }
 let stylesGenerated = false;
+/**
+* What the host passed to `configure()`, for the settings whose live registry
+* is not a faithful record of it. Accumulated across every `configure()` call.
+*
+* - Handlers and props middleware: `configure()` applies them into the handler
+*   registry and then strips them from the stored config, and that registry is
+*   populated lazily as styles are encountered — so neither is a stable record
+*   of what the host asked for.
+* - Declarative `@function` definitions: with `polyfills.functions` enabled,
+*   `configure()` compiles each into a parse-function closure and deliberately
+*   leaves `getGlobalFunctions()` empty, so the definition body survives
+*   nowhere a fingerprint can read it.
+*
+* A precompiled catalog needs exactly that record: replacing a built-in handler
+* or rewriting a function body changes what an already-compiled chunk should
+* contain without changing its lookup key.
+*/
+const configuredOverrides = {
+	handlers: [],
+	propHandlers: [],
+	functions: []
+};
+/** @internal */
+function getConfiguredOverrides() {
+	return {
+		handlers: configuredOverrides.handlers,
+		propHandlers: configuredOverrides.propHandlers,
+		functions: configuredOverrides.functions
+	};
+}
 let currentConfig = null;
 let globalKeyframes = null;
 let globalFontFace = null;
@@ -11745,7 +12081,7 @@ function createDefaultConfig(isTest) {
 function markStylesGenerated() {
 	if (stylesGenerated) return;
 	stylesGenerated = true;
-	if (typeof document !== "undefined" && document.querySelector("style[data-tasty-ssr]")) {
+	if (typeof document !== "undefined" && document.querySelector("[data-tasty-ssr]")) {
 		warnOnce("ssr-globals-skip", "[Tasty] SSR styles detected — skipping client-side global CSS injection to avoid duplicates.");
 		return;
 	}
@@ -12217,17 +12553,26 @@ function configure(config = {}) {
 		parser.setFunctions(finalFuncs);
 		Object.assign(currentFuncs, parseFuncs);
 	}
-	if (Object.keys(functionDefs).length > 0) if (isFunctionsPolyfillEnabled()) for (const [name, definition] of Object.entries(functionDefs)) registerFunctionPolyfill(name, definition);
-	else setGlobalFunction(functionDefs);
+	if (Object.keys(functionDefs).length > 0) {
+		for (const entry of Object.entries(functionDefs)) configuredOverrides.functions.push(entry);
+		if (isFunctionsPolyfillEnabled()) for (const [name, definition] of Object.entries(functionDefs)) registerFunctionPolyfill(name, definition);
+		else setGlobalFunction(functionDefs);
+	}
 	if (Object.keys(mergedKeyframes).length > 0) setGlobalKeyframes(mergedKeyframes);
 	if (Object.keys(mergedProperties).length > 0) setGlobalProperties(mergedProperties);
 	if (Object.keys(mergedFontFaces).length > 0) setGlobalFontFace(mergedFontFaces);
 	if (Object.keys(mergedCounterStyles).length > 0) setGlobalCounterStyle(mergedCounterStyles);
-	if (Object.keys(mergedHandlers).length > 0) for (const [name, definition] of Object.entries(mergedHandlers)) registerHandler(normalizeHandlerDefinition(name, definition), {
-		key: name,
-		source: handlerSources.get(name)
-	});
-	if (Object.keys(mergedPropHandlers).length > 0) for (const [name, definition] of Object.entries(mergedPropHandlers)) registerPropHandler(name, definition, { source: propHandlerSources.get(name) });
+	if (Object.keys(mergedHandlers).length > 0) for (const [name, definition] of Object.entries(mergedHandlers)) {
+		configuredOverrides.handlers.push([name, definition]);
+		registerHandler(normalizeHandlerDefinition(name, definition), {
+			key: name,
+			source: handlerSources.get(name)
+		});
+	}
+	if (Object.keys(mergedPropHandlers).length > 0) for (const [name, definition] of Object.entries(mergedPropHandlers)) {
+		configuredOverrides.propHandlers.push([name, definition]);
+		registerPropHandler(name, definition, { source: propHandlerSources.get(name) });
+	}
 	if (mergedBaseStyleProps.length > 0) registerBaseStyleProps(mergedBaseStyleProps);
 	if (Object.keys(mergedReplaceTokens).length > 0) {
 		const processedTokens = {};
@@ -12304,14 +12649,18 @@ function resetConfig() {
 	resetHandlers();
 	resetStyleChunks();
 	resetPropHandlers();
+	configuredOverrides.handlers.length = 0;
+	configuredOverrides.propHandlers.length = 0;
+	configuredOverrides.functions.length = 0;
 	resetBaseStyleProps();
 	clearPipelineCache();
+	resetPrecompiledStyles();
 	emittedWarnings.clear();
 	resetStyleWarnings();
 	const storage = typeof window !== "undefined" ? window : globalThis;
 	delete storage[GLOBAL_INJECTOR_KEY];
 }
 //#endregion
-export { SheetManager as $, StyleParser as $t, FLOW_STYLES as A, STYLE_TO_CHUNK as At, createStateParserContext as B, getGlobalParseFunctions as Bt, BASE_STYLES as C, APPEARANCE_CHUNK_STYLES as Ct, COLOR_STYLES as D, FONT_CHUNK_STYLES as Dt, BLOCK_STYLES as E, DISPLAY_CHUNK_STYLES as Et, hasPipelineCacheEntry as F, registerFunctionPolyfill as Ft, StyleInjector as G, parseStyle as Gt, extractPredefinedStateRefs as H, getGlobalPredefinedTokens as Ht, isSelector as I, registerLocalFunctionPolyfills as It, hasLocalCounterStyle as J, okhstPlugin as Jt, extractLocalCounterStyle as K, stringifyStyles as Kt, renderStyles as L, CUSTOM_UNITS as Lt, OUTER_STYLES as M, formatFunctionRule as Mt, POSITION_STYLES as N, hasLocalFunctions as Nt, CONTAINER_STYLES as O, LAYOUT_CHUNK_STYLES as Ot, TEXT_STYLES as P, parseFunctionName as Pt, hasLocalFontFace as Q, isDevEnv as Qt, parseStateKey as R, DIRECTIONS as Rt, baseStylePropsRegistry as S, propHandlerRegistry as St, BLOCK_OUTER_STYLES as T, DIMENSION_CHUNK_STYLES as Tt, getGlobalPredefinedStates as U, normalizeColorTokenValue as Ut, extractLocalPredefinedStates as V, getGlobalParser as Vt, setGlobalPredefinedStates as W, parseColor as Wt, fontFaceContentHash as X, okhslPlugin as Xt, extractLocalFontFace as Y, okhslFunction as Yt, formatFontFaceRule as Z, createColorFunc as Zt, isFunctionsPolyfillEnabled as _, hashString as _t, getGlobalCounterStyles as a, hslToRgbValues as an, closeBatchWindow as at, resetConfig as b, hasLocalProperties as bt, getGlobalInjector as c, openBatchWindow as ct, getGlobalStyles as d, DEFAULT_ZERO_NAME_PREFIX as dt, Lru as en, STYLE_HANDLER_MAP as et, getNamePrefix as f, makeClassName as ft, isConfigLocked as g, validateNamePrefix as gt, hasStylesGenerated as h, tastyClassRegex as ht, getGlobalConfigTokens as i, hexToRgb as in, PropertyTypeResolver as it, INNER_STYLES as j, extractLocalFunctions as jt, DIMENSION_STYLES as k, POSITION_CHUNK_STYLES as kt, getGlobalKeyframes as l, resetStyleBatch as lt, hasGlobalRecipes as m, makeKeyframeName as mt, getConfig as n, getNamedColorHex as nn, styleHandlers as nt, getGlobalFontFaces as o, strToRgb as on, flushStyles as ot, hasGlobalKeyframes as p, makeCounterStyleName as pt, formatCounterStyleRule as q, okhstFunction as qt, getEffectiveProperties as r, getRgbValuesFromRgbaString as rn, createStyle as rt, getGlobalFunctions as s, normalizeDslName as sn, hasPendingStyleWrites as st, configure as t, overrideColorAlpha as tn, defineHandler as tt, getGlobalRecipes as u, DEFAULT_NAME_PREFIX as ut, isTestEnvironment as v, extractLocalProperties as vt, BLOCK_INNER_STYLES as w, CHUNK_NAMES as wt, generateTypographyTokens as x, parsePropertyToken as xt, markStylesGenerated as y, getEffectiveDefinition as yt, camelToKebab as z, filterMods as zt };
+export { getRegisteredPrecompiledDependencies as $, getGlobalParseFunctions as $t, DIMENSION_STYLES as A, extractLocalProperties as At, camelToKebab as B, FONT_CHUNK_STYLES as Bt, baseStylePropsRegistry as C, DEFAULT_ZERO_NAME_PREFIX as Ct, BLOCK_STYLES as D, tastyClassRegex as Dt, BLOCK_OUTER_STYLES as E, makeKeyframeName as Et, TEXT_STYLES as F, propHandlerRegistry as Ft, setGlobalPredefinedStates as G, formatFunctionRule as Gt, extractLocalPredefinedStates as H, POSITION_CHUNK_STYLES as Ht, hasPipelineCacheEntry as I, APPEARANCE_CHUNK_STYLES as It, beginPrecompileBuild as J, registerFunctionPolyfill as Jt, applyRegisteredDependenciesToInjector as K, hasLocalFunctions as Kt, isSelector as L, CHUNK_NAMES as Lt, INNER_STYLES as M, hasLocalProperties as Mt, OUTER_STYLES as N, normalizePropertyDefinition as Nt, COLOR_STYLES as O, validateNamePrefix as Ot, POSITION_STYLES as P, parsePropertyToken as Pt, getPrecompiledRevision as Q, filterMods as Qt, renderStyles as R, DIMENSION_CHUNK_STYLES as Rt, generateTypographyTokens as S, DEFAULT_NAME_PREFIX as St, BLOCK_INNER_STYLES as T, makeCounterStyleName as Tt, extractPredefinedStateRefs as U, STYLE_TO_CHUNK as Ut, createStateParserContext as V, LAYOUT_CHUNK_STYLES as Vt, getGlobalPredefinedStates as W, extractLocalFunctions as Wt, findPrecompiledChunk as X, CUSTOM_UNITS as Xt, endPrecompileBuild as Y, registerLocalFunctionPolyfills as Yt, getPrecompileStore as Z, DIRECTIONS as Zt, isConfigLocked as _, hexToRgb as _n, closeBatchWindow as _t, getGlobalConfigTokens as a, stringifyStyles as an, formatCounterStyleRule as at, markStylesGenerated as b, normalizeDslName as bn, openBatchWindow as bt, getGlobalFunctions as c, okhslFunction as cn, fontFaceContentHash as ct, getGlobalRecipes as d, isDevEnv as dn, SheetManager as dt, getGlobalParser as en, getRegisteredPrecompiledStats as et, getGlobalStyles as f, StyleParser as fn, STYLE_HANDLER_MAP as ft, hasStylesGenerated as g, getRgbValuesFromRgbaString as gn, PropertyTypeResolver as gt, hasGlobalRecipes as h, getNamedColorHex as hn, createStyle as ht, getEffectiveProperties as i, parseStyle as in, extractLocalCounterStyle as it, FLOW_STYLES as j, getEffectiveDefinition as jt, CONTAINER_STYLES as k, hashString as kt, getGlobalInjector as l, okhslPlugin as ln, formatFontFaceRule as lt, hasGlobalKeyframes as m, overrideColorAlpha as mn, styleHandlers as mt, getConfig as n, normalizeColorTokenValue as nn, warnPrecompileOnce as nt, getGlobalCounterStyles as o, okhstFunction as on, hasLocalCounterStyle as ot, getNamePrefix as p, Lru as pn, defineHandler as pt, applyRegisteredDependenciesToRSC as q, parseFunctionName as qt, getConfiguredOverrides as r, parseColor as rn, StyleInjector as rt, getGlobalFontFaces as s, okhstPlugin as sn, extractLocalFontFace as st, configure as t, getGlobalPredefinedTokens as tn, precompileRuntimeState as tt, getGlobalKeyframes as u, createColorFunc as un, hasLocalFontFace as ut, isFunctionsPolyfillEnabled as v, hslToRgbValues as vn, flushStyles as vt, BASE_STYLES as w, makeClassName as wt, resetConfig as x, resetStyleBatch as xt, isTestEnvironment as y, strToRgb as yn, hasPendingStyleWrites as yt, parseStateKey as z, DISPLAY_CHUNK_STYLES as zt };
 
-//# sourceMappingURL=config-B23gZrfP.js.map
+//# sourceMappingURL=config-Bd2vOF0Z.js.map