@tenphi/tasty 0.0.0-snapshot.05e04ff → 0.0.0-snapshot.06c8a41

package/dist/{config-B97n_EIv.js → config-B3gPdCqd.js}

@@ -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 */
@@ -5054,9 +5061,9 @@ var SheetManager = class {
 				injectedFunctions: /* @__PURE__ */ new Map(),
 				globalRules: /* @__PURE__ */ new Map(),
 				propertyTypeResolver: new PropertyTypeResolver(),
-				committed: /* @__PURE__ */ new Map(),
-				keyframeHandles: /* @__PURE__ */ new Map(),
-				candidates: /* @__PURE__ */ new Map(),
+				unusedSince: /* @__PURE__ */ new Map(),
+				localKeyframes: /* @__PURE__ */ new Map(),
+				touchCount: 0,
 				serverClassSyncIndex: 0,
 				rscStylesScanned: false,
 				injectionMode: this.detectInjectionMode(root)
@@ -5489,14 +5496,16 @@ var SheetManager = class {
 				const endIdx = ruleInfo.endRuleIndex ?? ruleInfo.ruleIndex;
 				if (startIdx < 0 || endIdx > maxRuleIndex || startIdx > endIdx) continue;
 				this.deleteRule(registry, ruleInfo);
-				const keyframeHandles = registry.keyframeHandles.get(className);
-				if (keyframeHandles) {
-					for (const dispose of keyframeHandles) dispose();
-					registry.keyframeHandles.delete(className);
-				}
 				registry.rules.delete(className);
 				registry.pinCounts.delete(className);
-				registry.candidates.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++;
 			}
@@ -5523,25 +5532,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");
 	}
 	/**
@@ -5853,6 +5868,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);
@@ -5925,209 +5983,6 @@ function fontFaceContentHash(family, descriptors) {
 	});
 }
 //#endregion
-//#region src/keyframes/index.ts
-const KEYFRAMES_KEY = "@keyframes";
-/**
-* Pattern to extract animation names from CSS animation property values.
-* Animation name is typically the first identifier in the shorthand.
-* Handles: "fadeIn 300ms ease-in", "pulse 1s infinite", etc.
-*
-* CSS animation shorthand order (all optional except name):
-* animation: name | duration | timing | delay | iteration | direction | fill-mode | play-state
-*
-* Animation names must:
-* - Start with a letter, underscore, or hyphen (but not a digit or CSS keyword)
-* - Not be CSS keywords: none, initial, inherit, unset, revert
-*/
-const CSS_KEYWORDS = new Set([
-	"none",
-	"initial",
-	"inherit",
-	"unset",
-	"revert",
-	"auto",
-	"normal",
-	"running",
-	"paused"
-]);
-/**
-* Pattern to match animation name at the start of an animation value.
-* Must start with letter, underscore, or hyphen (not digit).
-*/
-const ANIMATION_NAME_PATTERN = /^([a-zA-Z_-][a-zA-Z0-9_-]*)/;
-/**
-* Check if styles object has local @keyframes definition.
-* Fast path: single property lookup.
-*/
-function hasLocalKeyframes(styles) {
-	return KEYFRAMES_KEY in styles;
-}
-/**
-* Extract local @keyframes from styles object.
-* Returns null if no local keyframes (fast path).
-*/
-function extractLocalKeyframes(styles) {
-	const keyframes = styles[KEYFRAMES_KEY];
-	if (!keyframes || typeof keyframes !== "object") return null;
-	return keyframes;
-}
-/**
-* Merge local and global keyframes.
-* Local keyframes take priority over global.
-* Returns null if no keyframes exist (fast path).
-*/
-function mergeKeyframes(local, global) {
-	if (!local && !global) return null;
-	if (!local) return global;
-	if (!global) return local;
-	return {
-		...global,
-		...local
-	};
-}
-/**
-* Extract animation name from a single animation value.
-* Returns null if no valid name found.
-*
-* Examples:
-* - "fadeIn 300ms ease-in" → "fadeIn"
-* - "1s pulse infinite" → "pulse" (name can be anywhere)
-* - "none" → null (CSS keyword)
-* - "300ms ease-in" → null (no name, just duration/timing)
-*/
-function extractAnimationNameFromValue(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return null;
-	const parts = trimmed.split(/\s+/);
-	for (const part of parts) {
-		if (CSS_KEYWORDS.has(part.toLowerCase())) continue;
-		if (/^-?[\d.]+m?s$/i.test(part)) continue;
-		if (part === "infinite" || /^\d+$/.test(part)) continue;
-		if ([
-			"normal",
-			"reverse",
-			"alternate",
-			"alternate-reverse"
-		].includes(part.toLowerCase())) continue;
-		if ([
-			"forwards",
-			"backwards",
-			"both"
-		].includes(part.toLowerCase())) continue;
-		if (["running", "paused"].includes(part.toLowerCase())) continue;
-		if (/^(ease|linear|ease-in|ease-out|ease-in-out|step-start|step-end)$/i.test(part)) continue;
-		if (/^(cubic-bezier|steps)\(/i.test(part)) continue;
-		const match = ANIMATION_NAME_PATTERN.exec(part);
-		if (match) return match[1];
-	}
-	return null;
-}
-/**
-* Extract all animation names from an animation property value.
-* Handles multiple animations separated by commas.
-*
-* Example: "fadeIn 300ms, slideIn 500ms ease-out" → ["fadeIn", "slideIn"]
-*/
-function extractAnimationNamesFromAnimationValue(value) {
-	const names = [];
-	const animations = value.split(",");
-	for (const animation of animations) {
-		const name = extractAnimationNameFromValue(animation);
-		if (name && !names.includes(name)) names.push(name);
-	}
-	return names;
-}
-/**
-* Extract animation names from a style value (handles mappings and arrays).
-*/
-function extractAnimationNamesFromStyleValue(value, names) {
-	if (typeof value === "string") for (const name of extractAnimationNamesFromAnimationValue(value)) names.add(name);
-	else if (Array.isArray(value)) for (const v of value) extractAnimationNamesFromStyleValue(v, names);
-	else if (value && typeof value === "object") for (const v of Object.values(value)) extractAnimationNamesFromStyleValue(v, names);
-}
-/**
-* Extract all animation names referenced in styles.
-* Scans 'animation' and 'animationName' properties including in state mappings.
-* Returns empty set if no animation properties found (fast path).
-*/
-function extractAnimationNamesFromStyles(styles) {
-	const names = /* @__PURE__ */ new Set();
-	if ("animation" in styles) extractAnimationNamesFromStyleValue(styles.animation, names);
-	if ("animationName" in styles) extractAnimationNamesFromStyleValue(styles.animationName, names);
-	for (const [key, value] of Object.entries(styles)) {
-		if (key === "$" || key === KEYFRAMES_KEY) continue;
-		if ((key.startsWith("&") || key.startsWith(".") || /^[A-Z]/.test(key)) && value && typeof value === "object") {
-			const nestedNames = extractAnimationNamesFromStyles(value);
-			for (const name of nestedNames) names.add(name);
-		}
-	}
-	return names;
-}
-/**
-* Replace animation names in CSS declarations with injected names.
-* Optimized to avoid regex creation - uses simple string replacement.
-*
-* @param declarations CSS declarations string
-* @param nameMap Map from original name to injected name (only contains names that differ)
-* @returns Updated declarations string
-*/
-function replaceAnimationNames(declarations, nameMap) {
-	if (!declarations.includes("animation")) return declarations;
-	const parts = declarations.split(";");
-	let modified = false;
-	for (let i = 0; i < parts.length; i++) {
-		const part = parts[i];
-		const colonIdx = part.indexOf(":");
-		if (colonIdx === -1) continue;
-		const prop = part.slice(0, colonIdx).trim().toLowerCase();
-		if (prop === "animation" || prop === "animation-name") {
-			const prefix = part.slice(0, colonIdx + 1);
-			let value = part.slice(colonIdx + 1);
-			for (const [original, injected] of nameMap) {
-				const newValue = replaceWord(value, original, injected);
-				if (newValue !== value) {
-					value = newValue;
-					modified = true;
-				}
-			}
-			parts[i] = prefix + value;
-		}
-	}
-	return modified ? parts.join(";") : declarations;
-}
-/**
-* Replace a word in a string (word boundary aware, no regex).
-*/
-function replaceWord(str, word, replacement) {
-	let result = str;
-	let idx = 0;
-	while ((idx = result.indexOf(word, idx)) !== -1) {
-		const before = idx === 0 ? " " : result[idx - 1];
-		const after = idx + word.length >= result.length ? " " : result[idx + word.length];
-		const isWordBoundaryBefore = !/[a-zA-Z0-9_-]/.test(before);
-		const isWordBoundaryAfter = !/[a-zA-Z0-9_-]/.test(after);
-		if (isWordBoundaryBefore && isWordBoundaryAfter) {
-			result = result.slice(0, idx) + replacement + result.slice(idx + word.length);
-			idx += replacement.length;
-		} else idx += word.length;
-	}
-	return result;
-}
-/**
-* Filter keyframes to only those that are actually used.
-* Returns null if no keyframes are used (fast path).
-*/
-function filterUsedKeyframes(keyframes, usedNames) {
-	if (!keyframes || usedNames.size === 0) return null;
-	const used = {};
-	let hasAny = false;
-	for (const name of usedNames) if (keyframes[name]) {
-		used[name] = keyframes[name];
-		hasAny = true;
-	}
-	return hasAny ? used : null;
-}
-//#endregion
 //#region src/counter-style/index.ts
 const COUNTER_STYLE_KEY = "@counter-style";
 /**
@@ -6177,6 +6032,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 = () => {};
 /**
@@ -6242,19 +6102,8 @@ var StyleInjector = class {
 	sheetManager;
 	config;
 	globalRuleCounter = 0;
-	/** Cancels the scheduled collection pass, whichever timer scheduled it. */
+	/** Cancels the scheduled sweep, whichever timer scheduled it. */
 	cancelPendingGC = null;
-	/** className -> the CSS it stands for, so a collected class can come back. */
-	recipes = /* @__PURE__ */ new Map();
-	/**
-	* cacheKey -> the class name it resolves to, and whether its CSS has been
-	* described yet. A managed render is then one lookup rather than a hash plus
-	* a second lookup, which matters because it runs for every chunk of every
-	* component on every render.
-	*/
-	classNames = /* @__PURE__ */ new Map();
-	/** Releases since the last scheduled pass. */
-	releaseCount = 0;
 	namePrefix;
 	classRegex;
 	rscClassRegex;
@@ -6394,6 +6243,7 @@ var StyleInjector = class {
 			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 {
@@ -6402,6 +6252,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);
@@ -6481,6 +6332,7 @@ var StyleInjector = class {
 			});
 			if (cacheKey) registry.cacheKeyToClassName.set(cacheKey, className);
 			if (pin) registry.pinCounts.set(className, 1);
+			registry.unusedSince.set(className, Date.now());
 			const queued = enqueueStyleWrite(() => {
 				if (applySheetWrite()) return;
 				registry.rules.set(className, {
@@ -6508,6 +6360,7 @@ var StyleInjector = class {
 			dispose: () => {}
 		};
 		if (pin) registry.pinCounts.set(className, 1);
+		registry.unusedSince.set(className, Date.now());
 		return {
 			className,
 			dispose: pin ? () => this.unpin(className, registry) : noop
@@ -6590,6 +6443,49 @@ 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);
+	}
+	/**
 	* 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.
@@ -6670,7 +6566,7 @@ var StyleInjector = class {
 		const root = options?.root || document;
 		const registry = this.sheetManager.getRegistry(root);
 		const metrics = this.sheetManager.getMetrics(registry);
-		if (metrics && typeof document !== "undefined") metrics.unusedHits = this.collectUnused(registry).length;
+		if (metrics && typeof document !== "undefined") metrics.unusedHits = this.collectUnused(registry, root).length;
 		return metrics;
 	}
 	/**
@@ -6845,13 +6741,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++;
@@ -6943,131 +6840,31 @@ var StyleInjector = class {
 		}
 	}
 	/**
-	* The class name a cache key resolves to. Pure: no allocation, no reservation,
-	* nothing written — safe to call during render, and stable across renders
-	* because the name is a hash of the key.
-	*/
-	/**
-	* The class name a cache key resolves to, and whether its CSS is already
-	* described. Pure: no allocation beyond the memo, nothing written — safe
-	* during render, and stable because the name is a hash of the key.
-	*/
-	resolveChunk(cacheKey) {
-		let entry = this.classNames.get(cacheKey);
-		if (entry === void 0) {
-			entry = {
-				name: this.generateClassName(cacheKey),
-				described: false
-			};
-			this.classNames.set(cacheKey, entry);
-		}
-		return entry;
-	}
-	/** Whether this class has already been described, so its CSS need not be re-rendered. */
-	hasRecipe(className) {
-		return this.recipes.has(className);
-	}
-	/**
-	* Record the CSS a class name stands for without writing it to a sheet.
-	*
-	* Called during render. Nothing is inserted yet: the component that will
-	* carry the class inserts it from here when it commits, so a render that is
-	* discarded leaves no rule behind, and a rule collected between render and
-	* commit comes back.
-	*/
-	defineRecipe(className, recipe) {
-		if (this.recipes.has(className)) return;
-		this.recipes.set(className, recipe);
-		if (recipe.cacheKey) {
-			const entry = this.classNames.get(recipe.cacheKey);
-			if (entry) entry.described = true;
-		}
-	}
-	/**
-	* Take up a class on commit: insert its rules if they are not in the sheet,
-	* and count one more mounted holder.
+	* 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.
 	*
-	* `className` may be several space-separated chunk classes; they are acquired
-	* together, which is what lets a component pay one insertion effect.
-	*/
-	acquire(className, options) {
-		if (!className) return;
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const parts = className.indexOf(" ") === -1 ? [className] : className.split(" ");
-		for (const cls of parts) {
-			const held = registry.committed.get(cls) ?? 0;
-			registry.committed.set(cls, held + 1);
-			registry.candidates.delete(cls);
-			if (held > 0) continue;
-			const existing = registry.rules.get(cls);
-			if (existing && existing.sheetIndex !== -1) continue;
-			const recipe = this.recipes.get(cls);
-			if (!recipe) continue;
-			let rules = recipe.rules;
-			if (recipe.keyframes) {
-				const handles = [];
-				let nameMap = null;
-				for (const [name, steps] of Object.entries(recipe.keyframes)) {
-					const injected = this.keyframes(steps, {
-						name,
-						root
-					});
-					handles.push(injected.dispose);
-					const injectedName = injected.toString();
-					if (injectedName !== name) {
-						if (!nameMap) nameMap = /* @__PURE__ */ new Map();
-						nameMap.set(name, injectedName);
-					}
-				}
-				registry.keyframeHandles.set(cls, handles);
-				if (nameMap) rules = rules.map((rule) => ({
-					...rule,
-					declarations: replaceAnimationNames(rule.declarations, nameMap)
-				}));
-			}
-			this.inject(rules, {
-				root,
-				cacheKey: recipe.cacheKey,
-				pin: false
-			});
-		}
-	}
-	/**
-	* Give up a class on unmount. At zero holders it becomes a candidate, but is
-	* not deleted here: insertion-effect cleanups and setups interleave component
-	* by component, so a sibling mounting the same class must get to say so
-	* first. The scheduled pass re-checks before deleting anything.
+	* @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.
 	*/
-	release(className, options) {
-		if (!className) return;
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const parts = className.indexOf(" ") === -1 ? [className] : className.split(" ");
-		const now = Date.now();
-		for (const cls of parts) {
-			const held = registry.committed.get(cls) ?? 0;
-			if (held <= 1) {
-				registry.committed.delete(cls);
-				registry.candidates.set(cls, now);
-				this.releaseCount++;
-			} else registry.committed.set(cls, held - 1);
-		}
+	touch(_className, options) {
+		if (typeof document === "undefined") return;
 		if (!this.config.gc) return;
-		const releaseInterval = this.config.gc.releaseInterval ?? 1e3;
-		if (this.releaseCount >= releaseInterval) {
-			this.releaseCount = 0;
+		const registry = this.sheetManager.getRegistry(options?.root || document);
+		if (++registry.touchCount >= (this.config.gc.touchInterval ?? 1e3)) {
+			registry.touchCount = 0;
 			this.scheduleGC();
 		}
 	}
 	/**
-	* Schedule a collection pass. Runs on all active roots, and avoids
+	* Schedule a GC in idle time. Runs GC on all active roots, and avoids
 	* double-scheduling.
 	*
-	* Deliberately deferred rather than run inside `release()`: insertion-effect
-	* cleanups and setups interleave component by component, so a class one
-	* component just dropped may be picked straight back up by the next one.
-	* Deleting on the way past would race that; the pass re-checks instead.
+	* 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;
@@ -7079,30 +6876,54 @@ 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);
 		}
 	}
 	/**
-	* The one definition of "unused": a class that mounted components released
-	* and nobody pinned. `gc()` deletes from this set, `getMetrics()` counts it,
-	* and `tastyDebug` reports it — all through here, so the three can never
-	* disagree about what "unused" means.
+	* The one definition of "unused": this injector owns the class's rules, no
+	* element in `root` carries it, and nobody pinned it.
+	*
+	* `gc()` evicts from this set, `getMetrics()` counts it, and `tastyDebug`
+	* reports it — all through here, so the three can never disagree about what
+	* "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
 	*
-	* Only a class that was committed and then released can be here. A class
-	* that was never mounted — a bare `computeStyles()` call, a pinned
-	* `inject()` — is never collectible, because nothing would re-create it.
+	* 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) {
+	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 of registry.candidates.keys()) {
-			if ((registry.committed.get(className) ?? 0) > 0) continue;
+		for (const [className, ruleInfo] of registry.rules) {
+			if (ruleInfo.sheetIndex < 0) continue;
+			if (liveClasses.has(className)) {
+				registry.unusedSince.delete(className);
+				continue;
+			}
 			if ((registry.pinCounts.get(className) ?? 0) > 0) continue;
-			const ruleInfo = registry.rules.get(className);
-			if (!ruleInfo || ruleInfo.sheetIndex < 0) continue;
+			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;
 	}
 	/**
@@ -7112,8 +6933,9 @@ var StyleInjector = class {
 	getUnusedClasses(options) {
 		flushStyles();
 		if (typeof document === "undefined") return [];
-		const registry = this.sheetManager.getRegistry(options?.root || document);
-		return this.collectUnused(registry);
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		return this.collectUnused(registry, root);
 	}
 	/**
 	* Synchronous garbage collection.
@@ -7136,15 +6958,12 @@ var StyleInjector = class {
 		const force = options?.force;
 		const registry = this.sheetManager.getRegistry(root);
 		const capacity = this.config.gc?.capacity ?? 1e3;
-		if (!force && registry.candidates.size <= capacity) return 0;
-		const unused = this.collectUnused(registry);
+		if (!force && registry.rules.size <= capacity) return 0;
+		const unused = this.collectUnused(registry, root);
 		let doomed;
 		if (force) doomed = unused;
-		else if (unused.length > capacity) {
-			const releasedAt = (cls) => registry.candidates.get(cls) ?? 0;
-			unused.sort((a, b) => releasedAt(a) - releasedAt(b));
-			doomed = unused.slice(0, unused.length - capacity);
-		} else return 0;
+		else if (unused.length > capacity) doomed = unused.slice(capacity);
+		else return 0;
 		if (doomed.length === 0) return 0;
 		return this.sheetManager.deleteClasses(registry, doomed);
 	}
@@ -12027,19 +11846,10 @@ function createDefaultConfig(isTest) {
 * This locks the configuration - no further changes allowed.
 * Also injects internal and global properties.
 */
-/**
-* Bumped whenever the global injector is replaced. Caches that hold class names
-* across renders compare it to notice that the injector which knew what those
-* names stand for is gone.
-*/
-let styleEpoch = 0;
-function getStyleEpoch() {
-	return styleEpoch;
-}
 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;
 	}
@@ -12604,9 +12414,8 @@ function resetConfig() {
 	resetStyleWarnings();
 	const storage = typeof window !== "undefined" ? window : globalThis;
 	delete storage[GLOBAL_INJECTOR_KEY];
-	styleEpoch++;
 }
 //#endregion
-export { hasLocalKeyframes as $, stringifyStyles as $t, DIMENSION_STYLES as A, APPEARANCE_CHUNK_STYLES as At, camelToKebab as B, hasLocalFunctions as Bt, baseStylePropsRegistry as C, validateNamePrefix as Ct, BLOCK_STYLES as D, hasLocalProperties as Dt, BLOCK_OUTER_STYLES as E, getEffectiveDefinition as Et, TEXT_STYLES as F, LAYOUT_CHUNK_STYLES as Ft, setGlobalPredefinedStates as G, DIRECTIONS as Gt, extractLocalPredefinedStates as H, registerFunctionPolyfill as Ht, hasPipelineCacheEntry as I, POSITION_CHUNK_STYLES as It, formatCounterStyleRule as J, getGlobalParser as Jt, StyleInjector as K, filterMods as Kt, isSelector as L, STYLE_TO_CHUNK as Lt, INNER_STYLES as M, DIMENSION_CHUNK_STYLES as Mt, OUTER_STYLES as N, DISPLAY_CHUNK_STYLES as Nt, COLOR_STYLES as O, parsePropertyToken as Ot, POSITION_STYLES as P, FONT_CHUNK_STYLES as Pt, filterUsedKeyframes as Q, parseStyle as Qt, renderStyles as R, extractLocalFunctions as Rt, generateTypographyTokens as S, tastyClassRegex as St, BLOCK_INNER_STYLES as T, extractLocalProperties as Tt, extractPredefinedStateRefs as U, registerLocalFunctionPolyfills as Ut, createStateParserContext as V, parseFunctionName as Vt, getGlobalPredefinedStates as W, CUSTOM_UNITS as Wt, extractAnimationNamesFromStyles as X, normalizeColorTokenValue as Xt, hasLocalCounterStyle as Y, getGlobalPredefinedTokens as Yt, extractLocalKeyframes as Z, parseColor as Zt, isConfigLocked as _, DEFAULT_NAME_PREFIX as _t, getGlobalCounterStyles as a, isDevEnv as an, hasLocalFontFace as at, markStylesGenerated as b, makeCounterStyleName as bt, getGlobalInjector as c, overrideColorAlpha as cn, defineHandler as ct, getGlobalStyles as d, hexToRgb as dn, PropertyTypeResolver as dt, okhstFunction as en, mergeKeyframes as et, getNamePrefix as f, hslToRgbValues as fn, closeBatchWindow as ft, hasStylesGenerated as g, resetStyleBatch as gt, hasGlobalRecipes as h, openBatchWindow as ht, getGlobalConfigTokens as i, createColorFunc as in, formatFontFaceRule as it, FLOW_STYLES as j, CHUNK_NAMES as jt, CONTAINER_STYLES as k, propHandlerRegistry as kt, getGlobalKeyframes as l, getNamedColorHex as ln, styleHandlers as lt, hasGlobalKeyframes as m, normalizeDslName as mn, hasPendingStyleWrites as mt, getConfig as n, okhslFunction as nn, extractLocalFontFace as nt, getGlobalFontFaces as o, StyleParser as on, SheetManager as ot, getStyleEpoch as p, strToRgb as pn, flushStyles as pt, extractLocalCounterStyle as q, getGlobalParseFunctions as qt, getEffectiveProperties as r, okhslPlugin as rn, fontFaceContentHash as rt, getGlobalFunctions as s, Lru as sn, STYLE_HANDLER_MAP as st, configure as t, okhstPlugin as tn, replaceAnimationNames as tt, getGlobalRecipes as u, getRgbValuesFromRgbaString as un, createStyle as ut, isFunctionsPolyfillEnabled as v, DEFAULT_ZERO_NAME_PREFIX as vt, BASE_STYLES as w, hashString as wt, resetConfig as x, makeKeyframeName as xt, isTestEnvironment as y, makeClassName as yt, parseStateKey as z, formatFunctionRule as zt };
+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 };
 
-//# sourceMappingURL=config-B97n_EIv.js.map
+//# sourceMappingURL=config-B3gPdCqd.js.map