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

package/dist/{core-DWrUWxog.js → core-DGm0CFHP.js}

@@ -1,7 +1,8 @@
-import { $ as hasLocalKeyframes, B as camelToKebab, Bt as hasLocalFunctions, Dt as hasLocalProperties, J as formatCounterStyleRule, Jt as getGlobalParser, K as StyleInjector, Ot as parsePropertyToken, Q as filterUsedKeyframes, Qt as parseStyle, Rt as extractLocalFunctions, St as tastyClassRegex, Tt as extractLocalProperties, Ut as registerLocalFunctionPolyfills, Vt as parseFunctionName, X as extractAnimationNamesFromStyles, Xt as normalizeColorTokenValue, Y as hasLocalCounterStyle, Z as extractLocalKeyframes, an as isDevEnv, at as hasLocalFontFace, b as markStylesGenerated, c as getGlobalInjector, cn as overrideColorAlpha, dt as PropertyTypeResolver, et as mergeKeyframes, f as getNamePrefix, it as formatFontFaceRule, jt as CHUNK_NAMES, l as getGlobalKeyframes, m as hasGlobalKeyframes, mn as normalizeDslName, n as getConfig, nt as extractLocalFontFace, q as extractLocalCounterStyle, qt as getGlobalParseFunctions, rt as fontFaceContentHash, sn as Lru, st as STYLE_HANDLER_MAP, tt as replaceAnimationNames, ut as createStyle, v as isFunctionsPolyfillEnabled, wt as hashString, y as isTestEnvironment, yt as makeClassName, zt as formatFunctionRule } from "./config-B97n_EIv.js";
-import { n as generateChunkCacheKey, r as categorizeStyleKeys, t as renderStylesForChunk } from "./renderChunk-COXABoQz.js";
-import { n as formatPropertyCSS, r as getRegisteredSSRCollector, t as formatRules } from "./format-rules-Wb7dJOoL.js";
-import { t as resolveRecipes } from "./resolve-recipes-BnrUEjWV.js";
+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, ot as flushStyles, 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-B3gPdCqd.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-DE-OE76F.js";
+import { t as getRegisteredSSRCollector } from "./ssr-collector-ref-COs_ioWl.js";
+import { n as formatPropertyCSS, t as formatRules } from "./format-rules-XRw9u7d4.js";
+import { t as resolveRecipes } from "./resolve-recipes-H9NqOQuP.js";
 import { cache } from "react";
 //#region src/utils/function-color.ts
 const RE_FUNC_NAME = /^([a-z][a-z0-9-]*)\s*\(/i;
@@ -245,59 +246,39 @@ function getCSSTextForNode(node, options) {
 	return getGlobalInjector().getCSSTextForClasses(classSet, options);
 }
 /**
-* The class name a cache key resolves to, and whether its CSS is described
-* already. Pure — safe during render.
+* 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 resolveChunk(cacheKey) {
-	return getGlobalInjector().resolveChunk(cacheKey);
-}
-/** Whether this class has already been described, so its CSS need not be re-rendered. */
-function hasRecipe(className) {
-	return getGlobalInjector().hasRecipe(className);
+function holdKeyframes(steps, names, options) {
+	return getGlobalInjector().holdKeyframes(steps, names, options);
 }
 /**
-* Record the CSS a class name stands for without writing it to a sheet, so the
-* commit that mounts it can insert it — and put it back if it was collected.
+* Record that a class animates these keyframes, so the reference is released
+* when the last such class is collected.
 */
-function defineRecipe(className, recipe) {
-	const injector = getGlobalInjector();
-	markStylesGenerated();
-	injector.defineRecipe(className, recipe);
+function ownKeyframes(key, className, options) {
+	getGlobalInjector().ownKeyframes(key, className, options);
 }
 /**
-* Take up styles on commit: insert whatever is missing from the sheet and count
-* one more mounted holder. Call from `useInsertionEffect`, and pair with
-* `releaseStyles` in its cleanup.
-*
-* `className` may hold several space-separated chunk classes; they are acquired
-* together, so one component pays one effect.
-*/
-function acquireStyles(className, options) {
-	const injector = getGlobalInjector();
-	markStylesGenerated();
-	injector.acquire(className, options);
-}
-/**
-* Give up styles on unmount. At zero holders the classes become collectible,
-* but nothing is deleted here — see `gc()`.
-*/
-function releaseStyles(className, options) {
-	getGlobalInjector().release(className, options);
-}
-/**
-* Remove every injected rule that no mounted component holds and no `inject()`
-* handle pins. Equivalent to `gc({ force: true })`.
+* Remove every injected rule that is neither in the DOM nor held by an
+* outstanding `inject()` handle. Equivalent to `gc({ force: true })`.
 */
 function cleanup(root) {
 	return getGlobalInjector().cleanup(root);
 }
 /**
-* @deprecated No longer does anything. Collection follows React commits —
-* styled components acquire their classes in `useInsertionEffect` and release
-* them on unmount — so there is no usage counter left to feed. Kept so existing
-* imports keep working; remove the call.
+* 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) {}
+function touch(className, options) {
+	if (!getConfig().gc) return;
+	getGlobalInjector().touch(className, options);
+}
 /**
 * Synchronous garbage collection of unused styles — those no element carries
 * and no `inject()` handle references. Evicts the oldest ones once they exceed
@@ -582,8 +563,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));
@@ -643,20 +626,23 @@ function computeStylesRSC(styles, chunkMap, stableStyles) {
 	const rscCache = getRSCCache();
 	const cssParts = [];
 	const classNames = [];
+	const rscUsedKf = getUsedKeyframes(styles);
+	const rscKeyframeNames = rscUsedKf ? resolveKeyframesNames(rscUsedKf) : null;
 	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 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);
@@ -683,117 +669,92 @@ 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;
-	}
-	return {
-		name: chunkName,
-		styleKeys,
-		cacheKey,
-		renderResult: { rules: [] },
-		className
-	};
-}
-/**
-* Process a chunk on the client: render, resolve the className, and — unless
-* the caller manages the class through a commit — inject it now.
-*/
-function processChunkSync(styles, chunkName, styleKeys, stableStyles, root, managed) {
-	if (styleKeys.length === 0) return null;
-	const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys, stableStyles);
-	if (managed) {
-		const { name: className, described } = resolveChunk(cacheKey);
-		if (described) return {
-			name: chunkName,
-			styleKeys,
-			cacheKey,
-			renderResult: { rules: [] },
-			className
-		};
-		const renderResult = renderStylesForChunk(styles, chunkName, styleKeys, cacheKey);
-		if (renderResult.rules.length === 0) return null;
+		collector.collectChunk(cacheKey, className, rules);
 		return {
 			name: chunkName,
 			styleKeys,
 			cacheKey,
-			renderResult,
-			className
+			renderResult: {
+				...renderResult,
+				rules
+			},
+			className,
+			animations
 		};
 	}
-	const renderResult = renderStylesForChunk(styles, chunkName, styleKeys, cacheKey);
-	if (renderResult.rules.length === 0) return null;
-	const { className } = inject(renderResult.rules, {
-		cacheKey,
-		root
-	});
 	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.
-*/
-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;
-}
-/**
-* Record what each freshly described chunk class stands for, so the commit that
-* mounts it can insert the rules — and so a later commit can put them back if
-* they were collected in between.
+* 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 recordChunkRecipes(chunks, usedKeyframes) {
-	for (const chunk of chunks) {
-		if (chunk.renderResult.rules.length === 0) continue;
-		defineRecipe(chunk.className, {
-			rules: chunk.renderResult.rules,
-			cacheKey: chunk.cacheKey,
-			keyframes: usedKeyframes ?? void 0
-		});
-	}
+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) {
+	if (styleKeys.length === 0) return null;
+	const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys, stableStyles);
+	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 } = inject(rules, {
+		cacheKey: injectKey,
 		root,
 		pin: false
 	});
+	return {
+		name: chunkName,
+		styleKeys,
+		cacheKey: injectKey,
+		renderResult: {
+			...renderResult,
+			rules
+		},
+		className,
+		animations
+	};
 }
 /**
 * Inject all ancillary rules (properties, font-faces, counter-styles) synchronously.
@@ -827,9 +788,12 @@ 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));
+		}
 	}
 	if (hasLocalProperties(styles)) {
 		const localProperties = extractLocalProperties(styles);
@@ -893,24 +857,29 @@ function computeStyles(styles, options) {
 	const chunks = [];
 	if (collector) {
 		collector.collectInternals();
+		const ssrKf = getUsedKeyframes(resolved);
+		const ssrKeyframeNames = ssrKf ? resolveKeyframesNames(ssrKf) : null;
 		for (const [chunkName, chunkStyleKeys] of chunkMap) {
-			const chunk = processChunkSSR(collector, resolved, chunkName, chunkStyleKeys, stableStyles);
+			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 {
 		const root = options?.root;
-		const managed = options?.managed;
 		injectAncillarySync(resolved, root);
 		const usedKf = getUsedKeyframes(resolved);
-		const nameMap = usedKf && !managed ? injectKeyframesSync(usedKf, root) : null;
+		const keyframeNames = usedKf ? resolveKeyframesNames(usedKf) : null;
+		const keyframeKeys = usedKf && keyframeNames ? holdKeyframes(usedKf, keyframeNames, { root }) : null;
 		for (const [chunkName, chunkStyleKeys] of chunkMap) {
-			const chunk = processChunkSync(resolved, chunkName, chunkStyleKeys, stableStyles, root, managed);
+			const chunk = processChunkSync(resolved, chunkName, chunkStyleKeys, stableStyles, root, keyframeNames);
 			if (chunk) chunks.push(chunk);
 		}
-		if (managed) recordChunkRecipes(chunks, usedKf);
-		else 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;
 	if (chunks.length === 1) return { className: chunks[0].className };
@@ -1190,10 +1159,41 @@ function countRules(css) {
 function sortTastyClasses(classes) {
 	return Array.from(classes).sort((a, b) => a.localeCompare(b));
 }
-function getRegistry(root = document) {
+/**
+* The root these helpers read, or `null` where there is no DOM.
+*
+* `document` used to be a default parameter value, and a default is evaluated
+* at the call site — so every read below threw a bare `ReferenceError` under
+* Node, taking out five of the eight public methods. A debug utility must not
+* be able to fail an SSR render because a call was left in, so the DOM-less
+* case reports an empty result and says why.
+*/
+function defaultRoot() {
+	return typeof document === "undefined" ? null : document;
+}
+let warnedNoDom = false;
+/** Say once why the numbers are empty. Silent under `{ raw: true }`. */
+function warnNoDom(raw) {
+	if (raw || warnedNoDom) return;
+	warnedNoDom = true;
+	console.warn("[Tasty] tastyDebug reads the DOM and this environment has none, so the result is empty. During SSR, read the ServerStyleCollector instead.");
+}
+/**
+* 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 = defaultRoot()) {
+	if (!root) return void 0;
+	flushStyles();
 	return injector.instance._sheetManager?.getRegistry(root);
 }
-function findDomTastyClasses(root = document) {
+function findDomTastyClasses(root = defaultRoot()) {
+	if (!root) return [];
 	const classes = /* @__PURE__ */ new Set();
 	const elements = root.querySelectorAll?.("[class]") || [];
 	const classRegex = tastyClassRegex(getNamePrefix());
@@ -1206,6 +1206,29 @@ 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 = defaultRoot()) {
+	const registry = getRegistry(root);
+	const sheetManager = injector.instance._sheetManager;
+	if (!root || !registry || !sheetManager) return "";
+	return sheetManager.getOwnedCSSInOrder(registry, root).join("\n");
+}
+/**
+* The injector's own readers fall back to `document` when `root` is omitted, so
+* they have to be reached with a real root or not at all.
+*/
+function cssTextForClasses(classNames, root) {
+	if (!root) return "";
+	return injector.instance.getCSSTextForClasses(classNames, { root });
+}
+function getInjectorMetrics(root) {
+	if (!root) return null;
+	return injector.instance.getMetrics({ root });
+}
+/**
 * Injected classes that no element carries and nobody pinned — the exact set
 * `gc({ force: true })` would delete.
 *
@@ -1213,9 +1236,18 @@ function findDomTastyClasses(root = document) {
 * drifted apart once before, when this file still read "unused" off the pin
 * counts the render path had stopped maintaining.
 */
-function getUnusedClasses(root = document) {
+function getUnusedClasses(root = defaultRoot()) {
+	if (!root) return [];
 	return sortTastyClasses(injector.instance.getUnusedClasses({ root }));
 }
+/** Every class this injector holds CSS for in `root`. */
+function getOwnedClasses(root = defaultRoot()) {
+	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 prettifyCSS(css) {
 	if (!css || !css.trim()) return "";
 	const out = [];
@@ -1276,15 +1308,15 @@ function extractChunkName(cacheKey) {
 	}
 	return null;
 }
-function getChunkForClass(className, root = document) {
+function getChunkForClass(className, root = defaultRoot()) {
 	const registry = getRegistry(root);
 	if (!registry) return null;
 	for (const [key, cn] of registry.cacheKeyToClassName) if (cn === className) return extractChunkName(key);
 	return null;
 }
-function buildChunkBreakdown(root = document) {
+function buildChunkBreakdown(root = defaultRoot()) {
 	const registry = getRegistry(root);
-	if (!registry) return {
+	if (!root || !registry) return {
 		byChunk: {},
 		totalChunkTypes: 0,
 		totalClasses: 0
@@ -1310,15 +1342,36 @@ function buildChunkBreakdown(root = document) {
 		totalClasses
 	};
 }
-function getGlobalTypeCSS(type, root = document) {
+/**
+* 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 = defaultRoot()) {
 	const registry = getRegistry(root);
-	if (!registry) return {
+	if (!root || !registry) return {
 		css: "",
 		ruleCount: 0,
 		size: 0
 	};
 	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];
@@ -1336,7 +1389,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];
@@ -1365,7 +1418,7 @@ function getGlobalTypeCSS(type, root = document) {
 		size: raw.length
 	};
 }
-function getSourceCssForClasses(classNames, root = document) {
+function getSourceCssForClasses(classNames, root = defaultRoot()) {
 	const registry = getRegistry(root);
 	if (!registry) return null;
 	const chunks = [];
@@ -1379,7 +1432,7 @@ function getSourceCssForClasses(classNames, root = document) {
 	}
 	return found ? chunks.join("\n") : null;
 }
-function getDefs(root = document) {
+function getDefs(root = defaultRoot()) {
 	const registry = getRegistry(root);
 	let properties = [];
 	if (registry?.injectedProperties) properties = Array.from(registry.injectedProperties.keys()).sort();
@@ -1409,7 +1462,11 @@ const CHUNK_ORDER = [
 ];
 const tastyDebug = {
 	css(target, opts) {
-		const { root = document, prettify = true, raw = false, source = false } = opts || {};
+		const { root = defaultRoot(), prettify = true, raw = false, source = false } = opts || {};
+		if (!root) {
+			warnNoDom(raw);
+			return "";
+		}
 		let css = "";
 		const classRegex = tastyClassRegex(getNamePrefix());
 		if (source && typeof target === "string" && classRegex.test(target)) {
@@ -1426,7 +1483,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;
@@ -1455,8 +1512,9 @@ const tastyDebug = {
 		return result;
 	},
 	inspect(target, opts) {
-		const { root = document, raw = false } = opts || {};
-		const element = typeof target === "string" ? root.querySelector?.(target) : target;
+		const { root = defaultRoot(), raw = false } = opts || {};
+		const element = !root ? null : typeof target === "string" ? root.querySelector?.(target) : target;
+		if (!root) warnNoDom(raw);
 		if (!element) {
 			const empty = {
 				element: null,
@@ -1466,7 +1524,7 @@ const tastyDebug = {
 				size: 0,
 				rules: 0
 			};
-			if (!raw) console.warn("[Tasty] debug.inspect: element not found");
+			if (!raw && root) console.warn("[Tasty] debug.inspect: element not found");
 			return empty;
 		}
 		const classList = element.getAttribute("class") || "";
@@ -1476,7 +1534,7 @@ const tastyDebug = {
 			className,
 			chunkName: getChunkForClass(className, root)
 		}));
-		const css = getCSSTextForNode(element, { root });
+		const css = getCSSTextForNode(element, { root: root ?? void 0 });
 		const rules = countRules(css);
 		const result = {
 			element,
@@ -1499,37 +1557,60 @@ const tastyDebug = {
 		return result;
 	},
 	summary(opts) {
-		const { root = document, raw = false } = opts || {};
+		const { root = defaultRoot(), raw = false } = opts || {};
+		if (!root) warnNoDom(raw);
 		const activeClasses = findDomTastyClasses(root);
 		const unusedClasses = getUnusedClasses(root);
-		const totalStyledClasses = [...activeClasses, ...unusedClasses];
-		const activeCSS = injector.instance.getCSSTextForClasses(activeClasses, { root });
-		const unusedCSS = injector.instance.getCSSTextForClasses(unusedClasses, { root });
-		const allCSS = injector.instance.getCSSText({ root });
+		const ownedClasses = getOwnedClasses(root);
+		const totalStyledClasses = sortTastyClasses(new Set([...activeClasses, ...ownedClasses]));
+		const unusedSet = new Set(unusedClasses);
+		const activeSet = new Set(activeClasses);
+		const hotClasses = ownedClasses.filter((className) => !activeSet.has(className) && !unusedSet.has(className));
+		const hotCSS = cssTextForClasses(hotClasses, root);
+		const activeCSS = cssTextForClasses(activeClasses, root);
+		const unusedCSS = cssTextForClasses(unusedClasses, 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 metrics = injector.instance.getMetrics({ root });
+		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 totalRuleCount = activeRuleCount + unusedRuleCount + countRules(hotCSS) + globalData.ruleCount + atRuleData.ruleCount + rawData.ruleCount + kfData.ruleCount + propData.ruleCount;
+		const metrics = getInjectorMetrics(root);
 		const defs = getDefs(root);
 		const chunkBreakdown = buildChunkBreakdown(root);
 		const summary = {
 			activeClasses,
 			unusedClasses,
+			hotClasses,
 			totalStyledClasses,
 			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,
 			activeRuleCount,
 			unusedRuleCount,
-			globalRuleCount: globalData.ruleCount,
+			globalRuleCount: globalData.ruleCount + atRuleData.ruleCount,
 			rawRuleCount: rawData.ruleCount,
 			keyframesRuleCount: kfData.ruleCount,
 			propertyRuleCount: propData.ruleCount,
@@ -1543,7 +1624,8 @@ const tastyDebug = {
 			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)}`);
+			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)}`);
@@ -1568,7 +1650,8 @@ const tastyDebug = {
 		return summary;
 	},
 	chunks(opts) {
-		const { root = document, raw = false } = opts || {};
+		const { root = defaultRoot(), raw = false } = opts || {};
+		if (!root) warnNoDom(raw);
 		const breakdown = buildChunkBreakdown(root);
 		if (!raw) {
 			console.group(`Chunks (${breakdown.totalChunkTypes} types, ${breakdown.totalClasses} classes)`);
@@ -1582,15 +1665,16 @@ const tastyDebug = {
 		return breakdown;
 	},
 	cache(opts) {
-		const { root = document, raw = false } = opts || {};
+		const { root = defaultRoot(), raw = false } = opts || {};
+		if (!root) warnNoDom(raw);
 		const active = findDomTastyClasses(root);
 		const unused = getUnusedClasses(root);
-		const metrics = injector.instance.getMetrics({ root });
+		const metrics = getInjectorMetrics(root);
 		const status = {
 			classes: {
 				active,
 				unused,
-				all: [...active, ...unused]
+				all: sortTastyClasses(new Set([...active, ...getOwnedClasses(root)]))
 			},
 			metrics
 		};
@@ -1607,7 +1691,9 @@ const tastyDebug = {
 		return status;
 	},
 	cleanup(opts) {
-		injector.instance.cleanup(opts?.root);
+		const root = opts?.root ?? defaultRoot();
+		if (!root) return;
+		injector.instance.cleanup(root);
 	},
 	help() {
 		console.log(`tastyDebug API:
@@ -1629,7 +1715,8 @@ Options: { raw: true } suppresses logging, { root: shadowRoot } targets Shadow D
 		}
 	}
 };
-function getPageCSS(root = document) {
+function getPageCSS(root = defaultRoot()) {
+	if (!root) return "";
 	const chunks = [];
 	try {
 		if ("styleSheets" in root) for (const sheet of Array.from(root.styleSheets)) try {
@@ -1640,6 +1727,6 @@ function getPageCSS(root = document) {
 }
 if (typeof window !== "undefined" && isDevEnv()) tastyDebug.install();
 //#endregion
-export { injector as A, getCSSText as C, inject as D, hasRecipe as E, resolveChunk as F, touch as I, ChunkSheetRegistry as L, keyframes as M, property as N, injectGlobal as O, releaseStyles as P, chunkSheetRegistry as R, gc as S, getRawCSSText as T, createInjector as _, color as a, fontFace as b, hasKeys as c, collectAutoInferredPropertiesRSC as d, getStyleTarget as f, counterStyle as g, cleanup as h, _modAttrs as i, isPropertyDefined as j, injectRawCSS as k, formatKeyframesCSS as l, acquireStyles as m, processTokens as n, filterBaseProps as o, pushRSCCSS as p, dotize as r, computeStyles as s, tastyDebug as t, collectAutoInferredProperties as u, defineRecipe as v, getCSSTextForNode as w, func as x, destroy as y, resolveFunctionColor as z };
+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-DWrUWxog.js.map
+//# sourceMappingURL=core-DGm0CFHP.js.map