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

package/dist/{core-B1tyn69d.js → core-ClInK6YG.js}

@@ -1,7 +1,8 @@
-import { Bt as getGlobalParseFunctions, G as StyleInjector, Gt as parseStyle, It as registerLocalFunctionPolyfills, J as hasLocalCounterStyle, K as extractLocalCounterStyle, Mt as formatFunctionRule, Nt as hasLocalFunctions, Pt as parseFunctionName, Q as hasLocalFontFace, Qt as isDevEnv, Ut as normalizeColorTokenValue, Vt as getGlobalParser, X as fontFaceContentHash, Y as extractLocalFontFace, Z as formatFontFaceRule, _ as isFunctionsPolyfillEnabled, _t as hashString, bt as hasLocalProperties, c as getGlobalInjector, en as Lru, et as STYLE_HANDLER_MAP, f as getNamePrefix, ft as makeClassName, ht as tastyClassRegex, it as PropertyTypeResolver, jt as extractLocalFunctions, l as getGlobalKeyframes, n as getConfig, p as hasGlobalKeyframes, q as formatCounterStyleRule, rt as createStyle, sn as normalizeDslName, tn as overrideColorAlpha, v as isTestEnvironment, vt as extractLocalProperties, wt as CHUNK_NAMES, xt as parsePropertyToken, y as markStylesGenerated, z as camelToKebab } from "./config-B23gZrfP.js";
-import { a as mergeKeyframes, c as generateChunkCacheKey, i as hasLocalKeyframes, l as categorizeStyleKeys, n as extractLocalKeyframes, o as replaceAnimationNames, r as filterUsedKeyframes, s as renderStylesForChunk, t as extractAnimationNamesFromStyles } from "./keyframes-Dxdx3KOo.js";
-import { n as formatPropertyCSS, r as getRegisteredSSRCollector, t as formatRules } from "./format-rules-BCTWVvcS.js";
-import { t as resolveRecipes } from "./resolve-recipes-BuOvSEa2.js";
+import { $t as getGlobalParseFunctions, At as extractLocalProperties, B as camelToKebab, Dt as tastyClassRegex, Gt as formatFunctionRule, K as applyRegisteredDependenciesToInjector, Kt as hasLocalFunctions, Lt as CHUNK_NAMES, Mt as hasLocalProperties, Nt as normalizePropertyDefinition, Pt as parsePropertyToken, Wt as extractLocalFunctions, X as findPrecompiledChunk, Yt as registerLocalFunctionPolyfills, at as formatCounterStyleRule, b as markStylesGenerated, bn as normalizeDslName, ct as fontFaceContentHash, dn as isDevEnv, en as getGlobalParser, et as getRegisteredPrecompiledStats, ft as STYLE_HANDLER_MAP, gt as PropertyTypeResolver, ht as createStyle, in as parseStyle, it as extractLocalCounterStyle, jt as getEffectiveDefinition, kt as hashString, l as getGlobalInjector, lt as formatFontFaceRule, m as hasGlobalKeyframes, mn as overrideColorAlpha, n as getConfig, nn as normalizeColorTokenValue, ot as hasLocalCounterStyle, p as getNamePrefix, pn as Lru, q as applyRegisteredDependenciesToRSC, qt as parseFunctionName, rt as StyleInjector, st as extractLocalFontFace, tt as precompileRuntimeState, u as getGlobalKeyframes, ut as hasLocalFontFace, v as isFunctionsPolyfillEnabled, vt as flushStyles, wt as makeClassName, y as isTestEnvironment } from "./config-Bd2vOF0Z.js";
+import { a as mergeKeyframes, c as resolveKeyframesNames, d as categorizeStyleKeys, i as hasLocalKeyframes, l as renderStylesForChunk, n as extractLocalKeyframes, o as referencesAnimation, r as filterUsedKeyframes, s as replaceAnimationNames, t as extractAnimationNamesFromStyles, u as generateChunkCacheKey } from "./keyframes-BjfNVhaB.js";
+import { t as getRegisteredSSRCollector } from "./ssr-collector-ref-COs_ioWl.js";
+import { r as formatPropertyCSS, t as formatRules } from "./format-rules-CGhgoVLR.js";
+import { t as resolveRecipes } from "./resolve-recipes-B2Sf36AH.js";
 import { cache } from "react";
 //#region src/utils/function-color.ts
 const RE_FUNC_NAME = /^([a-z][a-z0-9-]*)\s*\(/i;
@@ -245,6 +246,21 @@ function getCSSTextForNode(node, options) {
 	return getGlobalInjector().getCSSTextForClasses(classSet, options);
 }
 /**
+* Take a reference on local `@keyframes` under the deterministic names the
+* caller resolved, and report which entry holds each. Pair with
+* `ownKeyframes()` once the rules exist to inspect.
+*/
+function holdKeyframes(steps, names, options) {
+	return getGlobalInjector().holdKeyframes(steps, names, options);
+}
+/**
+* Record that a class animates these keyframes, so the reference is released
+* when the last such class is collected.
+*/
+function ownKeyframes(key, className, options) {
+	getGlobalInjector().ownKeyframes(key, className, options);
+}
+/**
 * Remove every injected rule that is neither in the DOM nor held by an
 * outstanding `inject()` handle. Equivalent to `gc({ force: true })`.
 */
@@ -252,9 +268,12 @@ function cleanup(root) {
 	return getGlobalInjector().cleanup(root);
 }
 /**
-* Record a render-time usage hit for one or more classNames.
-* Used internally by computeStyles and tasty() to track usage for GC.
-* When the global touch counter reaches `touchInterval`, schedules GC.
+* Count a render, so that a collection pass is scheduled every
+* `gc.touchInterval` of them. Used internally by computeStyles and tasty().
+*
+* @deprecated The class name is ignored — collection asks the DOM what is
+* rendered rather than recording usage per class. The argument is kept so
+* existing calls still compile.
 */
 function touch(className, options) {
 	if (!getConfig().gc) return;
@@ -314,8 +333,15 @@ const getRSCCache = cache(() => ({
 	internalsEmitted: false,
 	pendingCSS: [],
 	keyToIndex: /* @__PURE__ */ new Map(),
-	generatedNames: /* @__PURE__ */ new Map()
+	generatedNames: /* @__PURE__ */ new Map(),
+	precompiledRevision: -1,
+	precompiledEmittedKeys: /* @__PURE__ */ new Set(),
+	precompiledGeneratedNames: /* @__PURE__ */ new Map()
 }));
+function prepareRSCCache(cache) {
+	applyRegisteredDependenciesToRSC(cache, getNamePrefix());
+	return cache;
+}
 function rscAllocateClassName(rscCache, cacheKey) {
 	const existing = rscCache.cacheKeyToClassName.get(cacheKey);
 	if (existing) return {
@@ -375,7 +401,7 @@ function getStyleTarget() {
 	};
 	if (typeof document === "undefined") return {
 		mode: "rsc",
-		cache: getRSCCache()
+		cache: prepareRSCCache(getRSCCache())
 	};
 	return { mode: "client" };
 }
@@ -399,12 +425,13 @@ function scanAndEmitAutoProperties(rules, styles, emit) {
 		if (!rule.declarations) continue;
 		resolver.scanDeclarations(rule.declarations, (name) => registered.has(name), (name, syntax, initialValue) => {
 			registered.add(name);
-			const css = formatPropertyCSS(name, {
+			const definition = {
 				syntax,
 				inherits: true,
 				initialValue
-			});
-			if (css) emit(name, css);
+			};
+			const css = formatPropertyCSS(name, definition);
+			if (css) emit(name, css, definition);
 		});
 	}
 }
@@ -416,9 +443,14 @@ function scanAndEmitAutoProperties(rules, styles, emit) {
 * @param collector - SSR collector to emit @property CSS into
 * @param styles - Original styles object (used to skip explicit @property)
 */
-function collectAutoInferredProperties(rules, collector, styles) {
-	scanAndEmitAutoProperties(rules, styles, (name, css) => {
-		collector.collectProperty(`__auto:${name}`, css);
+function collectAutoInferredProperties(rules, collector, styles, source = "component") {
+	scanAndEmitAutoProperties(rules, styles, (name, css, definition) => {
+		collector.collectProperty(`__auto:${name}`, css, {
+			source,
+			cssName: name,
+			normalizedDefinition: normalizePropertyDefinition(definition),
+			rscKey: `__auto:${name}`
+		});
 	});
 }
 /**
@@ -519,6 +551,17 @@ function hasKeys(obj) {
 * This enables tasty() components to work as React Server Components.
 */
 const EMPTY_RESULT = { className: "" };
+function keyframeLookupSignature(names) {
+	if (!names || names.size === 0) return "";
+	return [...names].map(([authored, resolved]) => `${authored}=${resolved}`).sort().join(",");
+}
+function precompiledLookupKey(baseKey, signature) {
+	return signature ? `${baseKey}\0pkf:${signature}` : baseKey;
+}
+function lookupPrecompiledChunk(baseKey, signature, root) {
+	if (root && !(typeof document !== "undefined" && root === document)) return null;
+	return findPrecompiledChunk(precompiledLookupKey(baseKey, signature), getNamePrefix());
+}
 /**
 * Mark internals as emitted for this RSC request.
 *
@@ -544,8 +587,10 @@ function collectInternalsRSC(rscCache) {
 function collectAncillaryRSC(rscCache, styles) {
 	const parts = [];
 	const usedKf = getUsedKeyframes(styles);
-	if (usedKf) for (const [name, steps] of Object.entries(usedKf)) {
-		const key = `__kf:${name}:${JSON.stringify(steps)}`;
+	const rscKeyframeNames = usedKf ? resolveKeyframesNames(usedKf) : null;
+	if (usedKf && rscKeyframeNames) for (const [authored, steps] of Object.entries(usedKf)) {
+		const name = rscKeyframeNames.get(authored);
+		const key = `__kf:${name}`;
 		if (!rscCache.emittedKeys.has(key)) {
 			rscCache.emittedKeys.add(key);
 			parts.push(formatKeyframesCSS(name, steps));
@@ -601,24 +646,33 @@ function collectAncillaryRSC(rscCache, styles) {
 * Process all chunks in RSC mode: render CSS to strings, allocate classNames,
 * and return combined { className, css }.
 */
-function computeStylesRSC(styles, chunkMap, stableStyles) {
-	const rscCache = getRSCCache();
+function computeStylesRSC(styles, chunkMap, stableStyles, precompiledEnabled = false) {
+	const rscCache = prepareRSCCache(getRSCCache());
 	const cssParts = [];
 	const classNames = [];
+	const rscUsedKf = getUsedKeyframes(styles);
+	const rscKeyframeNames = rscUsedKf ? resolveKeyframesNames(rscUsedKf) : null;
+	const lookupSignature = precompiledEnabled ? keyframeLookupSignature(rscKeyframeNames) : "";
 	const pendingCSS = flushPendingCSS(rscCache);
 	if (pendingCSS) cssParts.push(pendingCSS);
 	const internalsCSS = collectInternalsRSC(rscCache);
 	if (internalsCSS) cssParts.push(internalsCSS);
 	for (const [chunkName, chunkStyleKeys] of chunkMap) {
 		if (chunkStyleKeys.length === 0) continue;
-		const { className, isNew } = rscAllocateClassName(rscCache, generateChunkCacheKey(styles, chunkName, chunkStyleKeys, stableStyles));
+		const baseKey = generateChunkCacheKey(styles, chunkName, chunkStyleKeys, stableStyles);
+		const precompiled = precompiledEnabled ? lookupPrecompiledChunk(baseKey, lookupSignature) : null;
+		if (precompiled) {
+			classNames.push(precompiled.className);
+			continue;
+		}
+		const renderResult = renderStylesForChunk(styles, chunkName, chunkStyleKeys);
+		if (renderResult.rules.length === 0) continue;
+		const { rules, cacheKey } = applyKeyframeNames(renderResult.rules, baseKey, rscKeyframeNames);
+		const { className, isNew } = rscAllocateClassName(rscCache, cacheKey);
 		classNames.push(className);
 		if (isNew) {
-			const renderResult = renderStylesForChunk(styles, chunkName, chunkStyleKeys);
-			if (renderResult.rules.length > 0) {
-				const css = formatRules(renderResult.rules, className);
-				if (css) cssParts.push(css);
-			}
+			const css = formatRules(rules, className);
+			if (css) cssParts.push(css);
 		}
 	}
 	const ancillaryCSS = collectAncillaryRSC(rscCache, styles);
@@ -645,23 +699,26 @@ function getUsedKeyframes(styles) {
 /**
 * Process a chunk on the SSR path: allocate via collector, render, collect CSS.
 */
-function processChunkSSR(collector, styles, chunkName, styleKeys, stableStyles) {
+function processChunkSSR(collector, styles, chunkName, styleKeys, stableStyles, keyframeNames) {
 	if (styleKeys.length === 0) return null;
-	const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys, stableStyles);
+	const baseKey = generateChunkCacheKey(styles, chunkName, styleKeys, stableStyles);
+	const renderResult = renderStylesForChunk(styles, chunkName, styleKeys);
+	if (renderResult.rules.length === 0) return null;
+	const { animations, rules, cacheKey } = applyKeyframeNames(renderResult.rules, baseKey, keyframeNames);
 	const { className, isNewAllocation } = collector.allocateClassName(cacheKey);
 	if (isNewAllocation) {
-		const renderResult = renderStylesForChunk(styles, chunkName, styleKeys);
-		if (renderResult.rules.length > 0) {
-			collector.collectChunk(cacheKey, className, renderResult.rules);
-			return {
-				name: chunkName,
-				styleKeys,
-				cacheKey,
-				renderResult,
-				className
-			};
-		}
-		return null;
+		collector.collectChunk(cacheKey, className, rules);
+		return {
+			name: chunkName,
+			styleKeys,
+			cacheKey,
+			renderResult: {
+				...renderResult,
+				rules
+			},
+			className,
+			animations
+		};
 	}
 	return {
 		name: chunkName,
@@ -671,58 +728,126 @@ function processChunkSSR(collector, styles, chunkName, styleKeys, stableStyles)
 		className
 	};
 }
-/**
-* Process a chunk on the client: render, allocate className, and inject
-* CSS synchronously. The injector's cache makes this idempotent.
-*/
-function processChunkSync(styles, chunkName, styleKeys, stableStyles, root) {
+/** Catalog-aware SSR path, kept off the unregistered runtime hot path. */
+function processChunkSSRPrecompiled(collector, styles, chunkName, styleKeys, stableStyles, keyframeNames, lookupSignature = "", precompiledEnabled = false) {
 	if (styleKeys.length === 0) return null;
-	const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys, stableStyles);
-	const renderResult = renderStylesForChunk(styles, chunkName, styleKeys, cacheKey);
+	const baseKey = generateChunkCacheKey(styles, chunkName, styleKeys, stableStyles);
+	if (precompiledEnabled && !collector.isPrecompileRecording()) {
+		const precompiled = lookupPrecompiledChunk(baseKey, lookupSignature);
+		if (precompiled) return {
+			name: chunkName,
+			styleKeys,
+			cacheKey: baseKey,
+			renderResult: { rules: [] },
+			className: precompiled.className,
+			animations: [...precompiled.animations]
+		};
+	}
+	const renderResult = renderStylesForChunk(styles, chunkName, styleKeys);
 	if (renderResult.rules.length === 0) return null;
-	const { className } = inject(renderResult.rules, {
-		cacheKey,
-		root,
-		pin: false
-	});
+	const { animations, rules, cacheKey } = applyKeyframeNames(renderResult.rules, baseKey, keyframeNames);
+	const { className, isNewAllocation } = collector.allocateClassName(cacheKey);
+	if (collector.isPrecompileRecording()) collector.recordPrecompiledChunk(precompiledLookupKey(baseKey, lookupSignature), className, animations);
+	if (isNewAllocation) {
+		collector.collectChunk(cacheKey, className, rules);
+		return {
+			name: chunkName,
+			styleKeys,
+			cacheKey,
+			renderResult: {
+				...renderResult,
+				rules
+			},
+			className,
+			animations
+		};
+	}
 	return {
 		name: chunkName,
 		styleKeys,
 		cacheKey,
-		renderResult,
+		renderResult: { rules: [] },
 		className
 	};
 }
 /**
-* Inject keyframes synchronously and return a name replacement map.
-* On the client, keyframes are injected into the DOM.
+* Point a chunk's rules at the resolved keyframe names, and fold those names
+* into its cache key.
+*
+* Both halves matter, and both have to happen before the rules are written
+* anywhere: the declarations have to name the animation that will exist, and
+* the key has to distinguish two components that authored the same shorthand
+* over different definitions. Shared by the client and the server so they
+* cannot disagree about either.
 */
-function injectKeyframesSync(usedKeyframes, root) {
-	let nameMap = null;
-	for (const [name, steps] of Object.entries(usedKeyframes)) {
-		const injectedName = keyframes(steps, {
-			name,
-			root
-		}).toString();
-		if (injectedName !== name) {
-			if (!nameMap) nameMap = /* @__PURE__ */ new Map();
-			nameMap.set(name, injectedName);
-		}
-	}
-	return nameMap;
+function applyKeyframeNames(ruleset, baseKey, keyframeNames) {
+	if (!keyframeNames || keyframeNames.size === 0) return {
+		animations: [],
+		rules: ruleset,
+		cacheKey: baseKey
+	};
+	const animations = [...keyframeNames.keys()].filter((authored) => ruleset.some((rule) => referencesAnimation(rule.declarations, authored)));
+	if (animations.length === 0) return {
+		animations,
+		rules: ruleset,
+		cacheKey: baseKey
+	};
+	return {
+		animations,
+		rules: ruleset.map((rule) => ({
+			...rule,
+			declarations: replaceAnimationNames(rule.declarations, keyframeNames)
+		})),
+		cacheKey: `${baseKey}\u0000kf:${animations.map((authored) => `${authored}=${keyframeNames.get(authored)}`).sort().join(",")}`
+	};
 }
 /**
-* Inject chunk rules synchronously, replacing animation names if needed.
+* Process a chunk on the client: render, allocate className, and inject
+* CSS synchronously. The injector's cache makes this idempotent.
 */
-function injectChunkRulesSync(chunks, nameMap, root) {
-	for (const chunk of chunks) if (chunk.renderResult.rules.length > 0) inject(nameMap ? chunk.renderResult.rules.map((rule) => ({
-		...rule,
-		declarations: replaceAnimationNames(rule.declarations, nameMap)
-	})) : chunk.renderResult.rules, {
-		cacheKey: chunk.cacheKey,
+function processChunkSync(styles, chunkName, styleKeys, stableStyles, root, keyframeNames, lookupSignature = "", clientInjector, precompiledEnabled = false) {
+	if (styleKeys.length === 0) return null;
+	const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys, stableStyles);
+	const precompiled = precompiledEnabled ? lookupPrecompiledChunk(cacheKey, lookupSignature, root) : null;
+	if (precompiled) {
+		clientInjector?.recordPrecompiledHit(precompiled.className, { root });
+		return {
+			name: chunkName,
+			styleKeys,
+			cacheKey,
+			renderResult: { rules: [] },
+			className: precompiled.className,
+			animations: [...precompiled.animations]
+		};
+	}
+	const prepared = clientInjector?.prepareClassName(cacheKey, { root });
+	if (prepared?.isExisting) return {
+		name: chunkName,
+		styleKeys,
+		cacheKey,
+		renderResult: { rules: [] },
+		className: prepared.className
+	};
+	const renderResult = renderStylesForChunk(styles, chunkName, styleKeys, cacheKey);
+	if (renderResult.rules.length === 0) return null;
+	const { animations, rules, cacheKey: injectKey } = applyKeyframeNames(renderResult.rules, cacheKey, keyframeNames);
+	const { className } = (clientInjector ?? getGlobalInjector()).inject(rules, {
+		cacheKey: injectKey,
 		root,
-		pin: false
+		pin: false,
+		preparedClassName: injectKey === cacheKey ? prepared?.className : void 0
 	});
+	return {
+		name: chunkName,
+		styleKeys,
+		cacheKey: injectKey,
+		renderResult: {
+			...renderResult,
+			rules
+		},
+		className,
+		animations
+	};
 }
 /**
 * Inject all ancillary rules (properties, font-faces, counter-styles) synchronously.
@@ -756,15 +881,30 @@ function injectAncillarySync(styles, root) {
 */
 function collectAncillarySSR(collector, styles, chunks) {
 	const usedKf = getUsedKeyframes(styles);
-	if (usedKf) for (const [name, steps] of Object.entries(usedKf)) {
-		const css = formatKeyframesCSS(name, steps);
-		collector.collectKeyframes(name, css);
+	if (usedKf) {
+		const names = resolveKeyframesNames(usedKf);
+		for (const [authored, steps] of Object.entries(usedKf)) {
+			const name = names.get(authored);
+			collector.collectKeyframes(name, formatKeyframesCSS(name, steps), {
+				source: "component",
+				contentKey: `${name}\0${JSON.stringify(steps)}`,
+				rscKeys: [`__kf:${name}`]
+			});
+		}
 	}
 	if (hasLocalProperties(styles)) {
 		const localProperties = extractLocalProperties(styles);
 		if (localProperties) for (const [token, definition] of Object.entries(localProperties)) {
 			const css = formatPropertyCSS(token, definition);
-			if (css) collector.collectProperty(token, css);
+			if (css) {
+				const effective = getEffectiveDefinition(token, definition);
+				collector.collectProperty(token, css, {
+					source: "component",
+					cssName: effective.isValid ? effective.cssName : void 0,
+					normalizedDefinition: effective.isValid ? normalizePropertyDefinition(effective.definition) : void 0,
+					rscKey: `__prop:${token}`
+				});
+			}
 		}
 	}
 	if (hasLocalFontFace(styles)) {
@@ -774,7 +914,7 @@ function collectAncillarySSR(collector, styles, chunks) {
 			for (const desc of descriptors) {
 				const hash = fontFaceContentHash(family, desc);
 				const css = formatFontFaceRule(family, desc);
-				collector.collectFontFace(hash, css);
+				collector.collectFontFace(hash, css, { source: "component" });
 			}
 		}
 	}
@@ -782,14 +922,17 @@ function collectAncillarySSR(collector, styles, chunks) {
 		const localCounterStyle = extractLocalCounterStyle(styles);
 		if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) {
 			const css = formatCounterStyleRule(name, descriptors);
-			collector.collectCounterStyle(name, css);
+			collector.collectCounterStyle(name, css, {
+				source: "component",
+				rscKeys: [`__cs:${name}:${JSON.stringify(descriptors)}`]
+			});
 		}
 	}
 	if (!isFunctionsPolyfillEnabled() && hasLocalFunctions(styles)) {
 		const localFunctions = extractLocalFunctions(styles);
 		if (localFunctions) for (const [name, definition] of Object.entries(localFunctions)) {
 			const css = formatFunctionRule(name, definition);
-			collector.collectFunction(parseFunctionName(name), css);
+			collector.collectFunction(parseFunctionName(name), css, { source: "component" });
 		}
 	}
 	if (getConfig().autoPropertyTypes !== false) {
@@ -818,26 +961,44 @@ function computeStyles(styles, options) {
 	const stableStyles = options?.stableStyles === true && resolved === styles;
 	if (isFunctionsPolyfillEnabled() && hasLocalFunctions(resolved)) registerLocalFunctionPolyfills(resolved);
 	const chunkMap = categorizeStyleKeys(resolved);
+	const precompiledEnabled = precompileRuntimeState.active === true;
 	const collector = options?.ssrCollector !== void 0 ? options.ssrCollector : getRegisteredSSRCollector();
 	const chunks = [];
 	if (collector) {
+		if (precompiledEnabled) collector.applyRegisteredPrecompiledDependencies();
 		collector.collectInternals();
-		for (const [chunkName, chunkStyleKeys] of chunkMap) {
-			const chunk = processChunkSSR(collector, resolved, chunkName, chunkStyleKeys, stableStyles);
+		const ssrKf = getUsedKeyframes(resolved);
+		const ssrKeyframeNames = ssrKf ? resolveKeyframesNames(ssrKf) : null;
+		if (precompiledEnabled) {
+			const lookupSignature = keyframeLookupSignature(ssrKeyframeNames);
+			for (const [chunkName, chunkStyleKeys] of chunkMap) {
+				const chunk = processChunkSSRPrecompiled(collector, resolved, chunkName, chunkStyleKeys, stableStyles, ssrKeyframeNames, lookupSignature, precompiledEnabled);
+				if (chunk) chunks.push(chunk);
+			}
+		} else for (const [chunkName, chunkStyleKeys] of chunkMap) {
+			const chunk = processChunkSSR(collector, resolved, chunkName, chunkStyleKeys, stableStyles, ssrKeyframeNames);
 			if (chunk) chunks.push(chunk);
 		}
 		collectAncillarySSR(collector, resolved, chunks);
-	} else if (typeof document === "undefined") return computeStylesRSC(resolved, chunkMap, stableStyles);
+	} else if (typeof document === "undefined") return computeStylesRSC(resolved, chunkMap, stableStyles, precompiledEnabled);
 	else {
 		const root = options?.root;
+		const clientInjector = getGlobalInjector();
+		if (precompiledEnabled && (!root || typeof ShadowRoot === "undefined" || !(root instanceof ShadowRoot))) applyRegisteredDependenciesToInjector(clientInjector, getNamePrefix());
+		markStylesGenerated();
 		injectAncillarySync(resolved, root);
 		const usedKf = getUsedKeyframes(resolved);
-		const nameMap = usedKf ? injectKeyframesSync(usedKf, root) : null;
+		const keyframeNames = usedKf ? resolveKeyframesNames(usedKf) : null;
+		const lookupSignature = precompiledEnabled ? keyframeLookupSignature(keyframeNames) : "";
+		const keyframeKeys = usedKf && keyframeNames ? holdKeyframes(usedKf, keyframeNames, { root }) : null;
 		for (const [chunkName, chunkStyleKeys] of chunkMap) {
-			const chunk = processChunkSync(resolved, chunkName, chunkStyleKeys, stableStyles, root);
+			const chunk = processChunkSync(resolved, chunkName, chunkStyleKeys, stableStyles, root, keyframeNames, lookupSignature, clientInjector, precompiledEnabled);
 			if (chunk) chunks.push(chunk);
 		}
-		if (nameMap) injectChunkRulesSync(chunks, nameMap, root);
+		if (keyframeKeys) for (const chunk of chunks) for (const authored of chunk.animations ?? []) {
+			const key = keyframeKeys.get(authored);
+			if (key) ownKeyframes(key, chunk.className, { root });
+		}
 		for (const chunk of chunks) touch(chunk.className, { root });
 	}
 	if (chunks.length === 0) return EMPTY_RESULT;
@@ -1118,7 +1279,17 @@ function countRules(css) {
 function sortTastyClasses(classes) {
 	return Array.from(classes).sort((a, b) => a.localeCompare(b));
 }
+/**
+* The registry for `root`, with every queued write landed first.
+*
+* Every injector read API is a flush point, and the reads below reach past
+* those APIs straight into the registry and the sheet manager. Without this
+* they would report a batch window's contents as absent — a rule that is
+* enqueued but not yet in a sheet is missing from `globalRules`, from the
+* sheets, and from anything counting either.
+*/
 function getRegistry(root = document) {
+	flushStyles();
 	return injector.instance._sheetManager?.getRegistry(root);
 }
 function findDomTastyClasses(root = document) {
@@ -1134,6 +1305,17 @@ function findDomTastyClasses(root = document) {
 	return sortTastyClasses(classes);
 }
 /**
+* Everything this injector holds in `root`, in the order the engine applies it,
+* with the sources kept byte-for-byte — trimming would report a total smaller
+* than one of its own parts whenever raw CSS has edge whitespace.
+*/
+function getAllCSS(root = document) {
+	const registry = getRegistry(root);
+	const sheetManager = injector.instance._sheetManager;
+	if (!registry || !sheetManager) return "";
+	return sheetManager.getOwnedCSSInOrder(registry, root).join("\n");
+}
+/**
 * Injected classes that no element carries and nobody pinned — the exact set
 * `gc({ force: true })` would delete.
 *
@@ -1144,6 +1326,22 @@ function findDomTastyClasses(root = document) {
 function getUnusedClasses(root = document) {
 	return sortTastyClasses(injector.instance.getUnusedClasses({ root }));
 }
+/** Every class this injector holds CSS for in `root`. */
+function getOwnedClasses(root = document) {
+	const registry = getRegistry(root);
+	if (!registry) return [];
+	const owned = [];
+	for (const [className, info] of registry.rules) if (info.sheetIndex >= 0) owned.push(className);
+	return sortTastyClasses(owned);
+}
+function getPrecompiledDebugStats(root) {
+	return typeof ShadowRoot !== "undefined" && root instanceof ShadowRoot ? {
+		manifestCount: 0,
+		classNames: [],
+		cssSize: 0,
+		ruleCount: 0
+	} : getRegisteredPrecompiledStats(getNamePrefix());
+}
 function prettifyCSS(css) {
 	if (!css || !css.trim()) return "";
 	const out = [];
@@ -1238,6 +1436,18 @@ function buildChunkBreakdown(root = document) {
 		totalClasses
 	};
 }
+/**
+* Every prefix `registry.globalRules` is keyed by. Anything missing here is a
+* rule the summary would hold but never count, which is how the totals stopped
+* adding up the first time.
+*/
+const GLOBAL_RULE_PREFIXES = {
+	global: "global:",
+	property: "property:",
+	fontFace: "fontface:",
+	counterStyle: "counterstyle:",
+	function: "function:"
+};
 function getGlobalTypeCSS(type, root = document) {
 	const registry = getRegistry(root);
 	if (!registry) return {
@@ -1247,6 +1457,15 @@ function getGlobalTypeCSS(type, root = document) {
 	};
 	const chunks = [];
 	let rc = 0;
+	if (type === "raw") {
+		const css = injector.instance.getRawCSSText({ root });
+		const sheetManager = injector.instance._sheetManager;
+		return {
+			css: prettifyCSS(css),
+			ruleCount: sheetManager?.getRawRuleCount(root) ?? 0,
+			size: css.length
+		};
+	}
 	if (type === "keyframes") for (const [, entry] of registry.keyframesCache) {
 		const info = entry.info;
 		const sheetInfo = registry.sheets[info.sheetIndex];
@@ -1264,7 +1483,7 @@ function getGlobalTypeCSS(type, root = document) {
 		}
 	}
 	else {
-		const prefix = type === "global" ? "global:" : type === "raw" ? "raw:" : "property:";
+		const prefix = GLOBAL_RULE_PREFIXES[type];
 		for (const [key, ri] of registry.globalRules) {
 			if (!key.startsWith(prefix)) continue;
 			const sheetInfo = registry.sheets[ri.sheetIndex];
@@ -1354,7 +1573,7 @@ const tastyDebug = {
 				if (!raw) console.warn("[Tasty] source CSS not available. Falling back to live CSSOM.");
 				css = injector.instance.getCSSTextForClasses(target, { root });
 			}
-		} else if (typeof target === "string") if (target === "all") css = injector.instance.getCSSText({ root });
+		} else if (typeof target === "string") if (target === "all") css = getAllCSS(root);
 		else if (target === "global") {
 			css = getGlobalTypeCSS("global", root).css;
 			return css;
@@ -1430,38 +1649,79 @@ const tastyDebug = {
 		const { root = document, raw = false } = opts || {};
 		const activeClasses = findDomTastyClasses(root);
 		const unusedClasses = getUnusedClasses(root);
-		const totalStyledClasses = [...activeClasses, ...unusedClasses];
+		const ownedClasses = getOwnedClasses(root);
+		const precompiled = getPrecompiledDebugStats(root);
+		const precompiledClasses = sortTastyClasses(precompiled.classNames);
+		const precompiledSet = new Set(precompiledClasses);
+		const runtimeActiveClasses = activeClasses.filter((className) => !precompiledSet.has(className));
+		const precompiledActiveClasses = activeClasses.filter((className) => precompiledSet.has(className));
+		const activeSet = new Set(activeClasses);
+		const precompiledInactiveClasses = precompiledClasses.filter((className) => !activeSet.has(className));
+		const precompiledUsedClasses = sortTastyClasses(getRegistry(root)?.precompiledUsedClasses ?? []);
+		const totalStyledClasses = sortTastyClasses(new Set([
+			...activeClasses,
+			...ownedClasses,
+			...precompiledClasses
+		]));
+		const unusedSet = new Set(unusedClasses);
+		const hotClasses = ownedClasses.filter((className) => !activeSet.has(className) && !unusedSet.has(className));
+		const hotCSS = injector.instance.getCSSTextForClasses(hotClasses, { root });
 		const activeCSS = injector.instance.getCSSTextForClasses(activeClasses, { root });
 		const unusedCSS = injector.instance.getCSSTextForClasses(unusedClasses, { root });
-		const allCSS = injector.instance.getCSSText({ root });
+		const allCSS = getAllCSS(root);
 		const activeRuleCount = countRules(activeCSS);
 		const unusedRuleCount = countRules(unusedCSS);
 		const globalData = getGlobalTypeCSS("global", root);
 		const rawData = getGlobalTypeCSS("raw", root);
 		const kfData = getGlobalTypeCSS("keyframes", root);
 		const propData = getGlobalTypeCSS("property", root);
-		const totalRuleCount = activeRuleCount + unusedRuleCount + globalData.ruleCount + rawData.ruleCount + kfData.ruleCount + propData.ruleCount;
+		const atRuleData = [
+			"fontFace",
+			"counterStyle",
+			"function"
+		].reduce((all, type) => {
+			const data = getGlobalTypeCSS(type, root);
+			return {
+				css: data.css ? `${all.css}\n${data.css}`.trim() : all.css,
+				ruleCount: all.ruleCount + data.ruleCount,
+				size: all.size + data.size
+			};
+		}, {
+			css: "",
+			ruleCount: 0,
+			size: 0
+		});
+		const totalRuleCountWithPrecompiled = activeRuleCount + unusedRuleCount + countRules(hotCSS) + globalData.ruleCount + atRuleData.ruleCount + rawData.ruleCount + kfData.ruleCount + propData.ruleCount + precompiled.ruleCount;
 		const metrics = injector.instance.getMetrics({ root });
 		const defs = getDefs(root);
 		const chunkBreakdown = buildChunkBreakdown(root);
 		const summary = {
 			activeClasses,
+			runtimeActiveClasses,
+			precompiledActiveClasses,
+			precompiledInactiveClasses,
+			precompiledUsedClasses,
 			unusedClasses,
+			hotClasses,
 			totalStyledClasses,
+			precompiledClasses,
+			precompiledManifestCount: precompiled.manifestCount,
 			activeCSSSize: activeCSS.length,
 			unusedCSSSize: unusedCSS.length,
-			globalCSSSize: globalData.size,
+			globalCSSSize: globalData.size + atRuleData.size,
 			rawCSSSize: rawData.size,
 			keyframesCSSSize: kfData.size,
 			propertyCSSSize: propData.size,
-			totalCSSSize: allCSS.length,
+			precompiledCSSSize: precompiled.cssSize,
+			totalCSSSize: allCSS.length + precompiled.cssSize,
 			activeRuleCount,
 			unusedRuleCount,
-			globalRuleCount: globalData.ruleCount,
+			globalRuleCount: globalData.ruleCount + atRuleData.ruleCount,
 			rawRuleCount: rawData.ruleCount,
 			keyframesRuleCount: kfData.ruleCount,
 			propertyRuleCount: propData.ruleCount,
-			totalRuleCount,
+			precompiledRuleCount: precompiled.ruleCount,
+			totalRuleCount: totalRuleCountWithPrecompiled,
 			metrics,
 			definedProperties: defs.properties,
 			definedKeyframes: defs.keyframes,
@@ -1469,17 +1729,20 @@ const tastyDebug = {
 		};
 		if (!raw) {
 			console.group("Tasty Summary");
-			console.log(`Active:   ${activeClasses.length} classes, ${activeRuleCount} rules, ${fmtSize(activeCSS.length)}`);
-			console.log(`Unused:   ${unusedClasses.length} classes, ${unusedRuleCount} rules, ${fmtSize(unusedCSS.length)}`);
-			console.log(`Global:   ${globalData.ruleCount} rules, ${fmtSize(globalData.size)}`);
+			console.log(`Active:   ${activeClasses.length} classes (${runtimeActiveClasses.length} runtime, ${precompiledActiveClasses.length} precompiled), ${activeRuleCount} runtime rules, ${fmtSize(activeCSS.length)} runtime CSS`);
+			console.log(`Unused:   ${unusedClasses.length} runtime classes, ${unusedRuleCount} rules, ${fmtSize(unusedCSS.length)}`);
+			if (hotClasses.length) console.log(`Held:     ${hotClasses.length} classes, ${countRules(hotCSS)} rules, ${fmtSize(hotCSS.length)} (not rendered, not yet collectable)`);
+			console.log(`Global:   ${globalData.ruleCount + atRuleData.ruleCount} rules, ${fmtSize(globalData.size + atRuleData.size)}`);
 			if (rawData.ruleCount) console.log(`Raw:      ${rawData.ruleCount} rules, ${fmtSize(rawData.size)}`);
 			if (kfData.ruleCount) console.log(`Keyframes: ${kfData.ruleCount} rules, ${fmtSize(kfData.size)}`);
 			if (propData.ruleCount) console.log(`@property: ${propData.ruleCount} rules, ${fmtSize(propData.size)}`);
-			console.log(`Total:    ${totalStyledClasses.length} classes, ${totalRuleCount} rules, ${fmtSize(allCSS.length)}`);
+			if (precompiled.manifestCount) console.log(`Precompiled: ${precompiledActiveClasses.length} active, ${precompiledInactiveClasses.length} inactive, ${precompiledUsedClasses.length}/${precompiledClasses.length} used since reset; ${precompiled.ruleCount} rules, ${fmtSize(precompiled.cssSize)} (${precompiled.manifestCount} ${precompiled.manifestCount === 1 ? "manifest" : "manifests"})`);
+			console.log(`Total:    ${totalStyledClasses.length} classes, ${totalRuleCountWithPrecompiled} rules, ${fmtSize(allCSS.length + precompiled.cssSize)}`);
 			if (metrics) {
 				const total = metrics.hits + metrics.misses;
 				const rate = total > 0 ? (metrics.hits / total * 100).toFixed(1) : 0;
-				console.log(`Cache:    ${rate}% hit rate (${total} lookups)`);
+				const runtimeHits = metrics.hits - metrics.precompiledHits;
+				console.log(`Lookups:  ${total} (${metrics.precompiledHits} precompiled across ${metrics.precompiledUniqueHits} classes, ${runtimeHits} runtime cache hits, ${metrics.misses} generated; ${rate}% reused)`);
 			}
 			if (chunkBreakdown.totalChunkTypes > 0) {
 				console.groupCollapsed(`Chunks (${chunkBreakdown.totalChunkTypes} types, ${chunkBreakdown.totalClasses} classes)`);
@@ -1514,21 +1777,37 @@ const tastyDebug = {
 		const active = findDomTastyClasses(root);
 		const unused = getUnusedClasses(root);
 		const metrics = injector.instance.getMetrics({ root });
+		const precompiled = getPrecompiledDebugStats(root);
+		const precompiledSet = new Set(precompiled.classNames);
+		const runtimeActive = active.filter((className) => !precompiledSet.has(className));
+		const precompiledActive = active.filter((className) => precompiledSet.has(className));
+		const activeSet = new Set(active);
+		const precompiledInactive = sortTastyClasses(precompiled.classNames.filter((className) => !activeSet.has(className)));
+		const precompiledUsed = sortTastyClasses(getRegistry(root)?.precompiledUsedClasses ?? []);
 		const status = {
 			classes: {
 				active,
 				unused,
-				all: [...active, ...unused]
+				all: sortTastyClasses(new Set([
+					...active,
+					...getOwnedClasses(root),
+					...precompiled.classNames
+				])),
+				runtimeActive,
+				precompiledActive,
+				precompiledInactive,
+				precompiledUsed
 			},
 			metrics
 		};
 		if (!raw) {
 			console.group("Cache");
-			console.log(`Active: ${active.length}, Unused: ${unused.length}`);
+			console.log(`Active: ${active.length} (${runtimeActive.length} runtime, ${precompiledActive.length} precompiled), Unused: ${unused.length} runtime, Inactive precompiled: ${precompiledInactive.length}`);
 			if (metrics) {
 				const total = metrics.hits + metrics.misses;
 				const rate = total > 0 ? (metrics.hits / total * 100).toFixed(1) : 0;
-				console.log(`Hits: ${metrics.hits}, Misses: ${metrics.misses}, Rate: ${rate}%`);
+				const runtimeHits = metrics.hits - metrics.precompiledHits;
+				console.log(`Precompiled: ${metrics.precompiledHits} hits across ${metrics.precompiledUniqueHits} classes, Runtime cache: ${runtimeHits} hits, Generated: ${metrics.misses}, Reuse: ${rate}%`);
 			}
 			console.groupEnd();
 		}
@@ -1568,6 +1847,6 @@ function getPageCSS(root = document) {
 }
 if (typeof window !== "undefined" && isDevEnv()) tastyDebug.install();
 //#endregion
-export { property as A, getRawCSSText as C, injector as D, injectRawCSS as E, ChunkSheetRegistry as M, chunkSheetRegistry as N, isPropertyDefined as O, resolveFunctionColor as P, getCSSTextForNode as S, injectGlobal as T, destroy as _, color as a, gc as b, hasKeys as c, collectAutoInferredPropertiesRSC as d, getStyleTarget as f, createInjector as g, counterStyle as h, _modAttrs as i, touch as j, keyframes as k, formatKeyframesCSS as l, cleanup as m, processTokens as n, filterBaseProps as o, pushRSCCSS as p, dotize as r, computeStyles as s, tastyDebug as t, collectAutoInferredProperties as u, fontFace as v, inject as w, getCSSText as x, func as y };
+export { keyframes as A, getRawCSSText as C, injectRawCSS as D, injectGlobal as E, chunkSheetRegistry as F, resolveFunctionColor as I, property as M, touch as N, injector as O, ChunkSheetRegistry as P, getCSSTextForNode as S, inject as T, destroy as _, color as a, gc as b, hasKeys as c, collectAutoInferredPropertiesRSC as d, getStyleTarget as f, createInjector as g, counterStyle as h, _modAttrs as i, ownKeyframes as j, isPropertyDefined as k, formatKeyframesCSS as l, cleanup as m, processTokens as n, filterBaseProps as o, pushRSCCSS as p, dotize as r, computeStyles as s, tastyDebug as t, collectAutoInferredProperties as u, fontFace as v, holdKeyframes as w, getCSSText as x, func as y };
 
-//# sourceMappingURL=core-B1tyn69d.js.map
+//# sourceMappingURL=core-ClInK6YG.js.map