@tenphi/tasty 0.0.0-snapshot.4d272f6 → 0.0.0-snapshot.4e9dfa4

package/dist/{config-CtJeETqW.js → config-BaxtQMS3.js}

@@ -57,6 +57,7 @@ function canonicalFuncName(lowered) {
 //#endregion
 //#region src/parser/lru.ts
 var Lru = class {
+	limit;
 	map = /* @__PURE__ */ new Map();
 	head = null;
 	tail = null;
@@ -1374,6 +1375,93 @@ function isDevEnv() {
 	return nodeEnv !== "test" && nodeEnv !== "production";
 }
 //#endregion
+//#region src/utils/name-prefix.ts
+/**
+* Name prefix utilities for generated identifiers.
+*
+* Tasty generates three kinds of identifiers from content hashes:
+* - class names (used in DOM `class` attribute)
+* - keyframe names (used in CSS `animation`)
+* - counter-style names (used in CSS `list-style-type`)
+*
+* All three derive from a single configurable prefix so that an app
+* can namespace every identifier under one string. Discriminator letters
+* (`k`, `c`) keep the three kinds visually distinct in devtools — they
+* are not required for correctness (CSS keeps these in separate
+* namespaces), only for readability.
+*
+* The runtime / SSR / RSC paths must agree on the prefix; otherwise the
+* client-side hash for a given style will not match the server-rendered
+* class and hydration breaks. The zero-runtime build path uses a
+* different default (`'ts'`) so its classes can't collide with runtime
+* (`'t'`) classes when both are loaded on the same page.
+*/
+/** Default prefix used by the runtime / SSR / RSC paths. */
+const DEFAULT_NAME_PREFIX = "t";
+/** Default prefix used by the zero-runtime (`tastyStatic`) build path. */
+const DEFAULT_ZERO_NAME_PREFIX = "ts";
+/**
+* Allowed shape: starts with a letter or underscore, then letters/
+* digits/underscore/hyphen. Length capped at 32 to keep generated
+* names sane. Matches the CSS identifier rules for the common case
+* while keeping the surface conservative.
+*/
+const NAME_PREFIX_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_-]{0,31}$/;
+/**
+* Validate a `namePrefix` value.
+* Throws a TypeError with a descriptive message on invalid input so
+* misconfiguration fails loudly at `configure()` time rather than
+* surfacing later as broken hydration.
+*/
+function validateNamePrefix(prefix) {
+	if (typeof prefix !== "string") throw new TypeError(`[Tasty] namePrefix must be a string, got ${typeof prefix}.`);
+	if (!NAME_PREFIX_PATTERN.test(prefix)) throw new TypeError(`[Tasty] namePrefix "${prefix}" is invalid. It must start with a letter (a-z, A-Z) or "_", contain only letters, digits, "_" or "-", and be 1-32 characters long. Examples: "t", "ts", "myapp-", "_foo".`);
+}
+/**
+* Build a class name: `${prefix}${hash}`.
+* The hash is appended verbatim — supply a separator inside the prefix
+* itself if you want one (e.g. `'myapp-'`).
+*/
+function makeClassName(prefix, hash) {
+	return `${prefix}${hash}`;
+}
+/**
+* Build a keyframe name: `${prefix}k${suffix}`.
+* The `k` discriminator keeps keyframe names visually distinct from
+* class names sharing the same prefix. `suffix` is typically a content
+* hash but may be a counter for ad-hoc allocation.
+*/
+function makeKeyframeName(prefix, suffix) {
+	return `${prefix}k${suffix}`;
+}
+/**
+* Build a counter-style name: `${prefix}c${suffix}`.
+* The `c` discriminator keeps counter-style names visually distinct
+* from class names sharing the same prefix.
+*/
+function makeCounterStyleName(prefix, suffix) {
+	return `${prefix}c${suffix}`;
+}
+/** Escape a string for safe inclusion in a regex literal. */
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Regex matching any tasty class for the given prefix.
+* Used by the runtime GC's DOM scan and class-allocation bookkeeping.
+*/
+function tastyClassRegex(prefix) {
+	return new RegExp(`^${escapeRegex(prefix)}[a-z0-9]+$`);
+}
+/**
+* Global regex extracting tasty class names from RSC-inlined CSS.
+* Looks for the doubled-specificity pattern `.cls.cls` that
+* `formatRules()` always emits, which makes extraction reliable.
+*/
+function rscClassRegexGlobal(prefix) {
+	return new RegExp(`\\.(${escapeRegex(prefix)}[a-z0-9]+)\\.\\1`, "g");
+}
+//#endregion
 //#region src/parser/types.ts
 let Bucket = /* @__PURE__ */ function(Bucket) {
 	Bucket[Bucket["Color"] = 0] = "Color";
@@ -1439,7 +1527,7 @@ function resolveUntilStable(value, opts, recurse, maxIterations = 10) {
 function classify(raw, opts, recurse) {
 	const token = raw.trim();
 	if (!token) return {
-		bucket: Bucket.Mod,
+		bucket: 2,
 		processed: ""
 	};
 	{
@@ -1461,31 +1549,31 @@ function classify(raw, opts, recurse) {
 		if (depth !== 0) {
 			console.warn("tasty: skipped invalid function token with unmatched parentheses:", token);
 			return {
-				bucket: Bucket.Mod,
+				bucket: 2,
 				processed: ""
 			};
 		}
 	}
 	if (token.startsWith("\"") && token.endsWith("\"") || token.startsWith("'") && token.endsWith("'")) return {
-		bucket: Bucket.Value,
+		bucket: 1,
 		processed: token
 	};
 	if (token.startsWith("$$")) {
 		const name = token.slice(2);
 		if (/^[a-z_][a-z0-9-_]*$/i.test(name)) return {
-			bucket: Bucket.Value,
+			bucket: 1,
 			processed: `--${name}`
 		};
 	}
 	if (token.startsWith("##")) {
 		const name = token.slice(2);
 		if (/^[a-z_][a-z0-9-_]*$/i.test(name)) return {
-			bucket: Bucket.Value,
+			bucket: 1,
 			processed: `--${name}-color`
 		};
 	}
 	if (token === "#current") return {
-		bucket: Bucket.Color,
+		bucket: 0,
 		processed: "currentcolor"
 	};
 	const currentAlphaMatch = token.match(/^#current\.(\$[a-z_][a-z0-9-_]*|[0-9]+)$/i);
@@ -1496,7 +1584,7 @@ function classify(raw, opts, recurse) {
 		else if (rawAlpha === "0") percentage = "0%";
 		else percentage = `${parseFloat("." + rawAlpha) * 100}%`;
 		return {
-			bucket: Bucket.Color,
+			bucket: 0,
 			processed: `color-mix(in oklab, currentcolor ${percentage}, transparent)`
 		};
 	}
@@ -1569,7 +1657,7 @@ function classify(raw, opts, recurse) {
 							const constructed = `${normalizedFunc}(${hasModernAlpha || hasLegacyAlpha ? normalizeArgs(hasModernAlpha ? args.slice(0, slashIdx).trim() : args.slice(0, lastTopLevelComma).trim()) : normalizeArgs(args)} / ${alpha})`;
 							if (!COLOR_FUNCS.has(normalizedFunc) && opts.funcs && normalizedFunc in opts.funcs) return classify(constructed, opts, recurse);
 							return {
-								bucket: Bucket.Color,
+								bucket: 0,
 								processed: constructed
 							};
 						}
@@ -1580,11 +1668,11 @@ function classify(raw, opts, recurse) {
 		}
 	}
 	if (token.match(/^var\(--([a-z0-9-]+)-color\)$/)) return {
-		bucket: Bucket.Color,
+		bucket: 0,
 		processed: token
 	};
 	if (token.startsWith("url(")) return {
-		bucket: Bucket.Value,
+		bucket: 1,
 		processed: token
 	};
 	if (token[0] === "$") {
@@ -1593,7 +1681,7 @@ function classify(raw, opts, recurse) {
 			const name = identMatch[1];
 			const processed = `var(--${name})`;
 			return {
-				bucket: name.endsWith("-color") ? Bucket.Color : Bucket.Value,
+				bucket: name.endsWith("-color") ? 0 : 1,
 				processed
 			};
 		}
@@ -1607,17 +1695,17 @@ function classify(raw, opts, recurse) {
 			else if (rawAlpha === "0") alpha = "0";
 			else alpha = `.${rawAlpha}`;
 			return {
-				bucket: Bucket.Color,
+				bucket: 0,
 				processed: `${getColorSpaceFunc()}(var(--${base}-color-${getColorSpaceSuffix()}) / ${alpha})`
 			};
 		}
 		const name = token.slice(1);
 		if (RE_HEX.test(name)) return {
-			bucket: Bucket.Color,
+			bucket: 0,
 			processed: `var(--${name}-color, #${name})`
 		};
 		return {
-			bucket: Bucket.Color,
+			bucket: 0,
 			processed: `var(--${name}-color)`
 		};
 	}
@@ -1628,7 +1716,7 @@ function classify(raw, opts, recurse) {
 		if (COLOR_FUNCS.has(fname)) {
 			const argProcessed = recurse(inner).output.replace(/,\s+/g, ",");
 			return {
-				bucket: Bucket.Color,
+				bucket: 0,
 				processed: `${canonicalFuncName(fname)}(${argProcessed})`
 			};
 		}
@@ -1641,7 +1729,7 @@ function classify(raw, opts, recurse) {
 		}
 		const argProcessed = recurse(inner).output;
 		return {
-			bucket: Bucket.Value,
+			bucket: 1,
 			processed: `${canonicalFuncName(fname)}(${argProcessed})`
 		};
 	}
@@ -1649,10 +1737,9 @@ function classify(raw, opts, recurse) {
 		const colorMatch = token.slice(1, -1).match(/^#([a-z0-9-]+)\s*,\s*(.*)$/i);
 		if (colorMatch) {
 			const [, name, fallback] = colorMatch;
-			const processedFallback = recurse(fallback).output;
 			return {
-				bucket: Bucket.Color,
-				processed: `var(--${name}-color, ${processedFallback})`
+				bucket: 0,
+				processed: `var(--${name}-color, ${recurse(fallback).output})`
 			};
 		}
 	}
@@ -1662,18 +1749,15 @@ function classify(raw, opts, recurse) {
 			const [, name, fallback] = match;
 			const processedFallback = recurse(fallback).output;
 			return {
-				bucket: name.endsWith("-color") ? Bucket.Color : Bucket.Value,
+				bucket: name.endsWith("-color") ? 0 : 1,
 				processed: `var(--${name}, ${processedFallback})`
 			};
 		}
 	}
-	if (token[0] === "(" && token[token.length - 1] === ")") {
-		const innerProcessed = recurse(token.slice(1, -1)).output;
-		return {
-			bucket: Bucket.Value,
-			processed: `calc(${innerProcessed})`
-		};
-	}
+	if (token[0] === "(" && token[token.length - 1] === ")") return {
+		bucket: 1,
+		processed: `calc(${recurse(token.slice(1, -1)).output})`
+	};
 	const um = token.match(RE_UNIT_NUM);
 	if (um) {
 		const unit = um[1];
@@ -1683,47 +1767,43 @@ function classify(raw, opts, recurse) {
 			const rawMatch = handler.match(RE_RAW_UNIT);
 			if (rawMatch) {
 				const [, baseNum, cssUnit] = rawMatch;
-				const resolved = resolveUntilStable(`${numericPart * parseFloat(baseNum)}${cssUnit}`, opts, recurse);
 				return {
-					bucket: Bucket.Value,
-					processed: resolved
+					bucket: 1,
+					processed: resolveUntilStable(`${numericPart * parseFloat(baseNum)}${cssUnit}`, opts, recurse)
 				};
 			}
 			const base = handler;
 			if (numericPart === 1) return {
-				bucket: Bucket.Value,
+				bucket: 1,
 				processed: base
 			};
 			return {
-				bucket: Bucket.Value,
+				bucket: 1,
 				processed: `calc(${numericPart} * ${base})`
 			};
-		} else {
-			const inner = handler(numericPart);
-			return {
-				bucket: Bucket.Value,
-				processed: inner
-			};
-		}
+		} else return {
+			bucket: 1,
+			processed: handler(numericPart)
+		};
 	}
 	if (/^[+-]?(?:\d*\.\d+|\d+)[a-z%]+$/.test(token)) return {
-		bucket: Bucket.Value,
+		bucket: 1,
 		processed: token
 	};
 	if (RE_NUMBER.test(token)) return {
-		bucket: Bucket.Value,
+		bucket: 1,
 		processed: token
 	};
 	if (VALUE_KEYWORDS.has(token)) return {
-		bucket: Bucket.Value,
+		bucket: 1,
 		processed: token
 	};
 	if (token === "transparent" || token === "currentcolor") return {
-		bucket: Bucket.Color,
+		bucket: 0,
 		processed: token
 	};
 	return {
-		bucket: Bucket.Mod,
+		bucket: 2,
 		processed: token
 	};
 }
@@ -1796,6 +1876,7 @@ function scan(src, cb) {
 //#endregion
 //#region src/parser/parser.ts
 var StyleParser = class {
+	opts;
 	cache;
 	constructor(opts = {}) {
 		this.opts = opts;
@@ -1823,13 +1904,13 @@ var StyleParser = class {
 				return;
 			}
 			switch (bucket) {
-				case Bucket.Color:
+				case 0:
 					currentPart.colors.push(processed);
 					break;
-				case Bucket.Value:
+				case 1:
 					currentPart.values.push(processed);
 					break;
-				case Bucket.Mod:
+				case 2:
 					currentPart.mods.push(processed);
 					break;
 			}
@@ -3242,10 +3323,13 @@ function resolveFontFamily(font, fontFamily) {
 /**
 * Handles typography preset and individual font properties.
 *
-* Preset syntax uses `/` to separate name from modifier:
+* Preset syntax uses `/` to separate the name from one or more
+* space-separated modifiers:
 * - `preset="h1"` — name only
 * - `preset="h2 / strong"` — name + modifier
+* - `preset="h2 / strong italic"` — name + multiple modifiers
 * - `preset="bold"` — modifier-only shorthand (name defaults to `inherit`)
+* - `preset="bold italic"` — modifier-only shorthand with multiple modifiers
 *
 * When `preset` is defined, it sets up CSS custom properties for typography.
 * Individual font props can be used with or without `preset`:
@@ -3265,14 +3349,17 @@ function presetStyle({ preset, fontSize, lineHeight, textTransform, letterSpacin
 		const { parts } = parseStyle(preset === true ? "" : String(preset)).groups[0] ?? { parts: [] };
 		const namePart = parts[0];
 		const modPart = parts[1];
+		const nameTokens = namePart?.all ?? [];
+		const isModOnly = nameTokens.length > 0 && nameTokens.every((t) => PRESET_MODIFIERS.has(t));
 		const nameToken = namePart?.mods[0] ?? namePart?.values[0] ?? "";
-		const isModOnly = PRESET_MODIFIERS.has(nameToken);
 		const name = isModOnly ? "inherit" : nameToken || "inherit";
-		const modifier = isModOnly ? nameToken : modPart?.mods[0] ?? "";
-		const isStrong = modifier === "strong" || modifier === "bold";
-		const isItalic = modifier === "italic";
-		const isIcon = modifier === "icon";
-		const isTight = modifier === "tight";
+		const modTokens = isModOnly ? nameTokens : modPart?.all ?? [];
+		const activeMods = /* @__PURE__ */ new Set();
+		for (const tok of modTokens) if (PRESET_MODIFIERS.has(tok)) activeMods.add(tok);
+		const isStrong = activeMods.has("strong") || activeMods.has("bold");
+		const isItalic = activeMods.has("italic");
+		const isIcon = activeMods.has("icon");
+		const isTight = activeMods.has("tight");
 		if (fontSize == null) setCSSValue(styles, "font-size", name, { cssOnly: true });
 		if (lineHeight == null) setCSSValue(styles, "line-height", name, { cssOnly: true });
 		if (letterSpacing == null) setCSSValue(styles, "letter-spacing", name, { cssOnly: true });
@@ -4137,7 +4224,7 @@ var SheetManager = class {
 								}
 							}
 							if (!anyInserted) {}
-						} else console.warn("[tasty] Browser rejected CSS rule:", fullRule, e);
+						} else if (!(fullRule.startsWith("@property ") && !this.engineSupportsAtProperty(registry, styleSheet))) console.warn("[tasty] Browser rejected CSS rule:", fullRule, e);
 					}
 				} else if (styleElement) {
 					const atomicRuleIndex = this.findAvailableRuleIndex(targetSheet);
@@ -4289,6 +4376,37 @@ var SheetManager = class {
 		return sheet.ruleCount;
 	}
 	/**
+	* Probe whether the underlying CSS engine supports `@property` at-rules.
+	* Result is cached per registry on `registry.atPropertySupported`.
+	*
+	* The probe inserts and immediately deletes a minimal known-valid rule
+	* (`@property --__tasty_probe__ { syntax: "*"; inherits: true; }`).
+	* Engines that lack `@property` support (jsdom, happy-dom) reject any
+	* `@property` rule including this one, so a probe failure is a reliable
+	* signal that further `@property` rejections are environmental noise and
+	* not user-authored bugs.
+	*
+	* The probe is intentionally a separate operation from the user's failing
+	* insertion: we don't want to leak `--__tasty_probe__` into the sheet, so
+	* on success we delete the probe rule immediately, leaving `ruleCount`
+	* and `cssRules.length` unchanged.
+	*/
+	engineSupportsAtProperty(registry, styleSheet) {
+		if (registry.atPropertySupported !== void 0) return registry.atPropertySupported;
+		const probeRule = "@property --__tasty_probe__ { syntax: \"*\"; inherits: true; }";
+		try {
+			const probeIdx = styleSheet.cssRules.length;
+			styleSheet.insertRule(probeRule, probeIdx);
+			try {
+				styleSheet.deleteRule(probeIdx);
+			} catch {}
+			registry.atPropertySupported = true;
+		} catch {
+			registry.atPropertySupported = false;
+		}
+		return registry.atPropertySupported;
+	}
+	/**
 	* Force cleanup of unused styles
 	*/
 	forceCleanup(registry) {
@@ -4809,18 +4927,10 @@ function formatCounterStyleRule(name, descriptors) {
 //#endregion
 //#region src/injector/injector.ts
 /**
-* Generate a deterministic class name from a cache key using content hash.
-* The same cache key always produces the same class name across environments.
-*/
-function generateClassName(cacheKey) {
-	return `t${hashString(cacheKey)}`;
-}
-const RSC_CLASS_RE = /\.(t[a-z0-9]+)\.\1/g;
-/**
 * Extract class names from `<style data-tasty-rsc>` tags.
 * The doubled-specificity pattern `.tXXX.tXXX` makes extraction reliable.
 */
-function extractRSCClassNames() {
+function extractRSCClassNames(rscClassRegex) {
 	if (typeof document === "undefined") return [];
 	const styles = document.querySelectorAll("style[data-tasty-rsc]");
 	if (styles.length === 0) return [];
@@ -4829,8 +4939,8 @@ function extractRSCClassNames() {
 		const text = style.textContent;
 		if (!text) continue;
 		let match;
-		RSC_CLASS_RE.lastIndex = 0;
-		while ((match = RSC_CLASS_RE.exec(text)) !== null) classSet.add(match[1]);
+		rscClassRegex.lastIndex = 0;
+		while ((match = rscClassRegex.exec(text)) !== null) classSet.add(match[1]);
 	}
 	return Array.from(classSet);
 }
@@ -4844,7 +4954,7 @@ function extractRSCClassNames() {
 * Called inside `inject()` / `allocateClassName()` to pick up
 * class names rendered on the server (including during SPA navigation).
 */
-function syncServerClasses(registry) {
+function syncServerClasses(registry, rscClassRegex) {
 	if (typeof window === "undefined") return;
 	const classes = window.__TASTY__;
 	if (classes && classes.length > registry.serverClassSyncIndex) {
@@ -4853,7 +4963,7 @@ function syncServerClasses(registry) {
 	}
 	if (!registry.rscStylesScanned) {
 		registry.rscStylesScanned = true;
-		for (const cls of extractRSCClassNames()) registerHydratedClass(registry, cls);
+		for (const cls of extractRSCClassNames(rscClassRegex)) registerHydratedClass(registry, cls);
 	}
 }
 function registerHydratedClass(registry, className) {
@@ -4865,25 +4975,40 @@ function registerHydratedClass(registry, className) {
 	});
 	registry.refCounts.set(className, 0);
 }
-var StyleInjector = class StyleInjector {
+var StyleInjector = class {
 	sheetManager;
 	config;
 	globalRuleCounter = 0;
 	pendingGCHandle = null;
+	namePrefix;
+	classRegex;
+	rscClassRegex;
 	/** @internal — exposed for debug utilities only */
 	get _sheetManager() {
 		return this.sheetManager;
 	}
 	constructor(config = {}) {
+		if (config.namePrefix !== void 0) validateNamePrefix(config.namePrefix);
 		this.config = config;
 		this.sheetManager = new SheetManager(config);
+		this.namePrefix = config.namePrefix ?? "t";
+		this.classRegex = tastyClassRegex(this.namePrefix);
+		this.rscClassRegex = rscClassRegexGlobal(this.namePrefix);
+	}
+	/**
+	* Generate a deterministic class name from a cache key using content hash.
+	* The same cache key always produces the same class name across environments
+	* with the same `namePrefix`.
+	*/
+	generateClassName(cacheKey) {
+		return makeClassName(this.namePrefix, hashString(cacheKey));
 	}
 	/**
 	* Check if `className` was hydrated from server-rendered styles and,
 	* if so, wire the cacheKey mapping. Returns true on hit.
 	*/
 	tryHydratedHit(registry, cacheKey, className) {
-		syncServerClasses(registry);
+		syncServerClasses(registry, this.rscClassRegex);
 		const rule = registry.rules.get(className);
 		if (rule && rule.ruleIndex === -2 && rule.sheetIndex === -2) {
 			registry.cacheKeyToClassName.set(cacheKey, className);
@@ -4902,7 +5027,7 @@ var StyleInjector = class StyleInjector {
 			className: registry.cacheKeyToClassName.get(cacheKey),
 			isNewAllocation: false
 		};
-		const className = generateClassName(cacheKey);
+		const className = this.generateClassName(cacheKey);
 		if (this.tryHydratedHit(registry, cacheKey, className)) return {
 			className,
 			isNewAllocation: false
@@ -4954,7 +5079,7 @@ var StyleInjector = class StyleInjector {
 				};
 			}
 		} else if (cacheKey) {
-			className = generateClassName(cacheKey);
+			className = this.generateClassName(cacheKey);
 			if (this.tryHydratedHit(registry, cacheKey, className)) {
 				registry.refCounts.set(className, (registry.refCounts.get(className) || 0) + 1);
 				if (registry.metrics) registry.metrics.hits++;
@@ -4963,7 +5088,10 @@ var StyleInjector = class StyleInjector {
 					dispose: () => this.dispose(className, registry)
 				};
 			}
-		} else className = `t${hashString(rules.map((r) => `${r.selector}\0${r.declarations}`).join("\n"))}`;
+		} else {
+			const parts = rules.map((r) => `${r.selector}\0${r.declarations}`);
+			className = makeClassName(this.namePrefix, hashString(parts.join("\n")));
+		}
 		const rulesToInsert = rules.map((rule) => {
 			let newSelector = rule.selector;
 			if (rule.needsClassName) {
@@ -5181,8 +5309,23 @@ var StyleInjector = class StyleInjector {
 		}
 		const cssName = effectiveResult.cssName;
 		const definition = effectiveResult.definition;
-		const normalizedDef = normalizePropertyDefinition(definition);
-		if (registry.injectedProperties.get(cssName) !== void 0) return;
+		this.insertPropertyRule(registry, root, cssName, definition, name);
+		if (effectiveResult.isColor) {
+			const companionCssName = `${cssName}-${getColorSpaceSuffix()}`;
+			const companionDefinition = {
+				syntax: getComponentPropertySyntax(),
+				inherits: definition.inherits,
+				initialValue: colorInitialValueToComponents(definition.initialValue)
+			};
+			this.insertPropertyRule(registry, root, companionCssName, companionDefinition, `${name}:components`);
+		}
+	}
+	/**
+	* Build and insert a single `@property` rule into the given registry.
+	* No-op if the property was already injected.
+	*/
+	insertPropertyRule(registry, root, cssName, definition, cacheKey) {
+		if (registry.injectedProperties.has(cssName)) return;
 		const parts = [];
 		if (definition.syntax != null) {
 			let syntax = String(definition.syntax).trim();
@@ -5202,8 +5345,8 @@ var StyleInjector = class StyleInjector {
 			selector: `@property ${cssName}`,
 			declarations
 		};
-		if (!this.sheetManager.insertGlobalRule(registry, [rule], `property:${name}`, root)) return;
-		registry.injectedProperties.set(cssName, normalizedDef);
+		registry.injectedProperties.set(cssName, normalizePropertyDefinition(definition));
+		this.sheetManager.insertGlobalRule(registry, [rule], `property:${cacheKey}`, root);
 	}
 	/**
 	* Check whether a given @property name was already injected by this injector.
@@ -5283,12 +5426,12 @@ var StyleInjector = class StyleInjector {
 		let actualName;
 		if (providedName) {
 			const existingContentForName = registry.keyframesNameToContent.get(providedName);
-			if (existingContentForName && existingContentForName !== contentHash) actualName = `${providedName}-k${registry.keyframesCounter++}`;
+			if (existingContentForName && existingContentForName !== contentHash) actualName = `${providedName}-${makeKeyframeName(this.namePrefix, String(registry.keyframesCounter++))}`;
 			else {
 				actualName = providedName;
 				registry.keyframesNameToContent.set(providedName, contentHash);
 			}
-		} else actualName = `k${registry.keyframesCounter++}`;
+		} else actualName = makeKeyframeName(this.namePrefix, String(registry.keyframesCounter++));
 		const result = this.sheetManager.insertKeyframes(registry, steps, actualName, root);
 		if (!result) return {
 			toString: () => "",
@@ -5337,7 +5480,6 @@ var StyleInjector = class StyleInjector {
 			}
 		}
 	}
-	static TASTY_CLASS_RE = /^t[a-z0-9]+$/;
 	/**
 	* Record a render-time usage hit for one or more classNames.
 	* Handles space-separated multi-chunk classNames.
@@ -5353,7 +5495,7 @@ var StyleInjector = class StyleInjector {
 		const now = Date.now();
 		const parts = className.indexOf(" ") === -1 ? [className] : className.split(" ");
 		for (const cls of parts) {
-			if (!StyleInjector.TASTY_CLASS_RE.test(cls)) continue;
+			if (!this.classRegex.test(cls)) continue;
 			if (!registry.rules.has(cls)) continue;
 			const entry = registry.usageMap.get(cls);
 			if (entry) entry.lastTouchedAt = now;
@@ -5406,7 +5548,7 @@ var StyleInjector = class StyleInjector {
 			if (registry.usageMap.size - activeCount <= capacity) return 0;
 		}
 		const liveClasses = /* @__PURE__ */ new Set();
-		for (const el of root.querySelectorAll("[class]")) for (const token of el.classList) if (StyleInjector.TASTY_CLASS_RE.test(token)) liveClasses.add(token);
+		for (const el of root.querySelectorAll("[class]")) for (const token of el.classList) if (this.classRegex.test(token)) liveClasses.add(token);
 		let swept = 0;
 		if (force) for (const [className] of registry.usageMap) {
 			if (liveClasses.has(className)) continue;
@@ -6089,6 +6231,7 @@ function simplifyAnd(children) {
 	terms = sortTerms(terms);
 	terms = applyAbsorptionAnd(terms);
 	terms = applyConsensusAnd(terms);
+	terms = pruneContradictedOrBranches(terms);
 	if (terms.length === 0) return trueCondition();
 	if (terms.length === 1) return terms[0];
 	return {
@@ -6375,11 +6518,14 @@ function hasContainerStyleConflict(terms) {
 */
 function buildImpliedNegationCheck(terms) {
 	const positiveValues = /* @__PURE__ */ new Map();
+	const negatedBooleanAttrs = /* @__PURE__ */ new Set();
 	for (const term of terms) {
-		if (term.kind !== "state" || term.negated) continue;
-		if (term.type === "container" && term.subtype === "style") {
-			if (term.propertyValue !== void 0) positiveValues.set(`c:${term.containerName || "_"}:${term.property}`, term.propertyValue);
-		} else if (term.type === "modifier" && term.value !== void 0) positiveValues.set(`m:${term.attribute}`, term.value);
+		if (term.kind !== "state") continue;
+		if (!term.negated) {
+			if (term.type === "container" && term.subtype === "style") {
+				if (term.propertyValue !== void 0) positiveValues.set(`c:${term.containerName || "_"}:${term.property}`, term.propertyValue);
+			} else if (term.type === "modifier" && term.value !== void 0) positiveValues.set(`m:${term.attribute}`, term.value);
+		} else if (term.type === "modifier" && term.value === void 0) negatedBooleanAttrs.add(term.attribute);
 	}
 	return (term) => {
 		if (term.kind !== "state" || !term.negated) return false;
@@ -6389,6 +6535,7 @@ function buildImpliedNegationCheck(terms) {
 			return pos !== void 0 && term.propertyValue !== pos;
 		}
 		if (term.type === "modifier" && term.value !== void 0) {
+			if (negatedBooleanAttrs.has(term.attribute)) return true;
 			const pos = positiveValues.get(`m:${term.attribute}`);
 			return pos !== void 0 && term.value !== pos;
 		}
@@ -6736,437 +6883,97 @@ function tryResolvePair(aChildren, bChildren) {
 	if (common.length === 1) return common[0];
 	return or(...common);
 }
-//#endregion
-//#region src/pipeline/exclusive.ts
 /**
-* Build exclusive conditions for a list of parsed style entries.
+* For each OR child of an AND, prune branches that are impossible
+* given the other AND siblings.
 *
-* The entries should be ordered by priority (highest priority first).
-*
-* For each entry, we compute:
-*   exclusiveCondition = condition & !prior[0] & !prior[1] & ...
-*
-* This ensures exactly one condition matches at any time.
-*
-* Example:
-*   Input (ordered highest to lowest priority):
-*     A: value1 (priority 2)
-*     B: value2 (priority 1)
-*     C: value3 (priority 0)
-*
-*   Output:
-*     A: A
-*     B: B & !A
-*     C: C & !A & !B
+* Example: A & OR(!A & X, Y) → A & Y
 *
-* @param entries Parsed style entries ordered by priority (highest first)
-* @returns Entries with exclusive conditions, filtered to remove impossible ones
+* This catches dead OR branches left by exclusive negation (Stage 2b)
+* where `NOT(combined)` introduces branches contradicting flat siblings.
 */
-function buildExclusiveConditions(entries) {
+function pruneContradictedOrBranches(terms) {
+	if (!terms.some((t) => t.kind === "compound" && t.operator === "OR")) return terms;
+	let changed = false;
 	const result = [];
-	const priorConditions = [];
-	for (const entry of entries) {
-		let exclusive = entry.condition;
-		for (const prior of priorConditions) if (prior.kind !== "true") exclusive = and(exclusive, not(prior));
-		const simplified = simplifyCondition(exclusive);
-		if (simplified.kind === "false") continue;
-		result.push({
-			...entry,
-			exclusiveCondition: simplified
-		});
-		if (entry.condition.kind !== "true") priorConditions.push(entry.condition);
-	}
-	return result;
-}
-/**
-* Parse style entries from a value mapping object.
-*
-* @param styleKey The style key (e.g., 'padding')
-* @param valueMap The value mapping { '': '2x', 'compact': '1x', '@media(w < 768px)': '0.5x' }
-* @param parseCondition Function to parse state keys into conditions
-* @returns Parsed entries ordered by priority (highest first)
-*/
-function parseStyleEntries(styleKey, valueMap, parseCondition) {
-	const entries = [];
-	Object.keys(valueMap).forEach((stateKey, index) => {
-		const value = valueMap[stateKey];
-		const condition = stateKey === "" ? trueCondition() : parseCondition(stateKey);
-		entries.push({
-			styleKey,
-			stateKey,
-			value,
-			condition,
-			priority: index
-		});
-	});
-	entries.reverse();
-	return entries;
-}
-/**
-* Merge parsed entries that share the same value.
-*
-* When multiple **non-default** state keys map to the same value, their
-* conditions can be combined with OR and treated as a single entry.
-* This must happen **before** exclusive expansion and OR branch splitting
-* to avoid combinatorial explosion and duplicate CSS output.
-*
-* Default (TRUE) entries are **never** merged with non-default entries.
-* Merging `TRUE | X` collapses to `TRUE`, destroying the non-default
-* condition's participation in exclusive building. That causes
-* intermediate-priority states to lose their `:not(X)` negation,
-* breaking mutual exclusivity when X and an intermediate state are
-* both active. Stage 6 `mergeByValue` handles combining rules with
-* identical CSS output after exclusive conditions are correctly built.
-*
-* Example: `{ '@dark': 'red', '@dark & @hc': 'red' }` merges into a
-* single entry with condition `@dark | (@dark & @hc)` = `@dark`.
-*
-* Entries are ordered highest-priority-first. The merged entry keeps the
-* highest priority of the group.
-*/
-function mergeEntriesByValue(entries) {
-	if (entries.length <= 1) return entries;
-	const groups = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const valueKey = serializeValue(entry.value);
-		const group = groups.get(valueKey);
-		if (group) {
-			group.entries.push(entry);
-			group.maxPriority = Math.max(group.maxPriority, entry.priority);
-		} else groups.set(valueKey, {
-			entries: [entry],
-			maxPriority: entry.priority
-		});
-	}
-	if (groups.size === entries.length) return entries;
-	const merged = [];
-	for (const [, group] of groups) {
-		if (group.entries.length === 1) {
-			merged.push(group.entries[0]);
+	for (let i = 0; i < terms.length; i++) {
+		const term = terms[i];
+		if (term.kind !== "compound" || term.operator !== "OR") {
+			result.push(term);
 			continue;
 		}
-		const defaultEntries = group.entries.filter((e) => e.condition.kind === "true");
-		const nonDefaultEntries = group.entries.filter((e) => e.condition.kind !== "true");
-		for (const entry of defaultEntries) merged.push(entry);
-		if (nonDefaultEntries.length === 1) merged.push(nonDefaultEntries[0]);
-		else if (nonDefaultEntries.length >= 2) {
-			const combinedCondition = simplifyCondition(or(...nonDefaultEntries.map((e) => e.condition)));
-			const combinedStateKey = nonDefaultEntries.map((e) => e.stateKey).join(" | ");
-			merged.push({
-				styleKey: nonDefaultEntries[0].styleKey,
-				stateKey: combinedStateKey,
-				value: nonDefaultEntries[0].value,
-				condition: combinedCondition,
-				priority: group.maxPriority
+		const siblings = [...terms.slice(0, i), ...terms.slice(i + 1)];
+		const surviving = [];
+		for (const branch of term.children) if (simplifyInner({
+			kind: "compound",
+			operator: "AND",
+			children: [branch, ...siblings]
+		}).kind !== "false") surviving.push(branch);
+		if (surviving.length === term.children.length) result.push(term);
+		else if (surviving.length === 0) return [falseCondition()];
+		else {
+			changed = true;
+			if (surviving.length === 1) result.push(surviving[0]);
+			else result.push({
+				kind: "compound",
+				operator: "OR",
+				children: surviving
 			});
 		}
 	}
-	merged.sort((a, b) => b.priority - a.priority);
-	return merged;
-}
-function serializeValue(value) {
-	if (value === null || value === void 0) return "null";
-	if (typeof value === "string" || typeof value === "number") return String(value);
-	return JSON.stringify(value);
+	if (!changed) return terms;
+	const flattened = [];
+	for (const term of result) if (term.kind === "compound" && term.operator === "AND") flattened.push(...term.children);
+	else flattened.push(term);
+	return flattened;
 }
+//#endregion
+//#region src/pipeline/materialize-contradictions.ts
 /**
-* Eliminate redundant state dimensions from a value map.
-*
-* When a value map contains compound AND state keys (e.g. `@dark & @hc`),
-* checks whether any state atom is a "don't-care" variable — i.e. the
-* value is the same whether that atom is present or absent. Redundant
-* atoms are removed from all keys and duplicate entries are collapsed.
-*
-* This runs **before** condition parsing so that downstream stages
-* (`mergeEntriesByValue`, `buildExclusiveConditions`, materialization)
-* never see the irrelevant dimension, producing simpler, smaller CSS.
-*
-* Only pure top-level AND combinations are eligible. Keys that contain
-* `|`, `^`, or `,` at the top level are treated as opaque single atoms.
-*
-* @example
-*   { '': A, '@dark': B, '@hc': A, '@dark & @hc': B }
-*   // @hc is redundant → { '': A, '@dark': B }
+* Generic deduplication by a key extraction function.
+* Preserves insertion order, keeping the first occurrence of each key.
 */
-function extractCompoundStates(valueMap) {
-	const keys = Object.keys(valueMap);
-	if (keys.length < 3 || !keys.some((k) => k.includes("&"))) return valueMap;
-	const entries = keys.map((key) => {
-		return {
-			atoms: splitTopLevelAnd(key) ?? [key],
-			value: valueMap[key]
-		};
-	});
-	const allAtoms = /* @__PURE__ */ new Set();
-	for (const e of entries) for (const a of e.atoms) allAtoms.add(a);
-	const redundant = /* @__PURE__ */ new Set();
-	for (const atom of allAtoms) if (isAtomRedundant(entries, atom)) redundant.add(atom);
-	if (redundant.size === 0) return valueMap;
-	const newMap = {};
-	for (const e of entries) {
-		const newKey = e.atoms.filter((a) => !redundant.has(a)).join(" & ");
-		if (!(newKey in newMap)) newMap[newKey] = e.value;
+function dedupeByKey(items, getKey) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const item of items) {
+		const key = getKey(item);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(item);
+		}
 	}
-	return newMap;
+	return result;
+}
+function dedupeMediaConditions(conditions) {
+	return dedupeByKey(conditions, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
+}
+function dedupeContainerConditions(conditions) {
+	return dedupeByKey(conditions, (c) => `${c.name ?? ""}|${c.condition}|${c.negated}`);
+}
+function dedupeSupportsConditions(conditions) {
+	return dedupeByKey(conditions, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
 }
 /**
-* Split a state key by top-level `&` operators.
-*
-* Returns `null` if the key contains `|`, `^`, or `,` at the top level
-* (making it ineligible for atom-level extraction).
-* Returns `[]` for the empty string (default key).
+* Check if supports conditions contain contradictions
+* e.g., @supports(display: grid) AND NOT @supports(display: grid)
 */
-function splitTopLevelAnd(key) {
-	if (key === "") return [];
-	const parts = [];
-	let depth = 0;
-	let current = "";
-	for (const ch of key) {
-		if (ch === "(" || ch === "[") depth++;
-		else if (ch === ")" || ch === "]") depth--;
-		if (depth === 0) {
-			if (ch === "&") {
-				const trimmed = current.trim();
-				if (trimmed) parts.push(trimmed);
-				current = "";
-				continue;
-			}
-			if (ch === "|" || ch === "^" || ch === ",") return null;
-		}
-		current += ch;
+function hasSupportsContradiction(conditions) {
+	const conditionMap = /* @__PURE__ */ new Map();
+	for (const cond of conditions) {
+		const key = `${cond.subtype}|${cond.condition}`;
+		const existing = conditionMap.get(key);
+		if (existing !== void 0 && existing !== !cond.negated) return true;
+		conditionMap.set(key, !cond.negated);
 	}
-	const trimmed = current.trim();
-	if (trimmed) parts.push(trimmed);
-	return parts;
+	return false;
 }
 /**
-* An atom is redundant when every entry that contains it has a matching
-* partner (same remaining atoms, atom absent) with the same value.
-*/
-function isAtomRedundant(entries, atom) {
-	const withAtom = entries.filter((e) => e.atoms.includes(atom));
-	if (withAtom.length === 0) return false;
-	for (const wa of withAtom) {
-		const remaining = wa.atoms.filter((a) => a !== atom);
-		const pair = entries.find((e) => !e.atoms.includes(atom) && e.atoms.length === remaining.length && remaining.every((r) => e.atoms.includes(r)));
-		if (!pair) return false;
-		if (serializeValue(wa.value) !== serializeValue(pair.value)) return false;
-	}
-	return true;
-}
-/**
-* Check if a value is a style value mapping (object with state keys)
-*/
-function isValueMapping(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
-}
-/**
-* Expand OR conditions in parsed entries into multiple exclusive entries.
-*
-* For an entry with condition `A | B | C`, this creates 3 entries:
-*   - condition: A
-*   - condition: B & !A
-*   - condition: C & !A & !B
-*
-* This ensures OR branches are mutually exclusive BEFORE the main
-* exclusive condition building pass.
-*
-* @param entries Parsed entries (may contain OR conditions)
-* @returns Expanded entries with OR branches made exclusive
-*/
-function expandOrConditions(entries) {
-	const result = [];
-	for (const entry of entries) {
-		const expanded = expandSingleEntry(entry);
-		result.push(...expanded);
-	}
-	return result;
-}
-/**
-* Expand a single entry's OR condition into multiple exclusive entries.
-*
-* Note: branches are NOT sorted by at-rule context here (unlike the
-* `expandExclusiveOrs` pass below). User-authored ORs in state keys aren't
-* the product of De Morgan negation, so each branch is expected to render
-* independently in its own scope and at-rule sort isn't load-bearing.
-* The post-build pass needs the sort because it has to preserve at-rule
-* wrapping across branches that came from negating a compound at-rule.
-*/
-function expandSingleEntry(entry) {
-	const orBranches = collectOrBranches(entry.condition);
-	if (orBranches.length <= 1) return [entry];
-	const result = [];
-	const priorBranches = [];
-	for (let i = 0; i < orBranches.length; i++) {
-		const branch = orBranches[i];
-		let exclusiveBranch = branch;
-		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
-		const simplified = simplifyCondition(exclusiveBranch);
-		if (simplified.kind === "false") {
-			priorBranches.push(branch);
-			continue;
-		}
-		result.push({
-			...entry,
-			stateKey: `${entry.stateKey}[${i}]`,
-			condition: simplified
-		});
-		priorBranches.push(branch);
-	}
-	return result;
-}
-/**
-* Collect top-level OR branches from a condition.
-*
-* For `A | B | C`, returns [A, B, C]
-* For `A & B`, returns [A & B] (single branch)
-* For `A | (B & C)`, returns [A, B & C]
-*/
-function collectOrBranches(condition) {
-	if (condition.kind === "true" || condition.kind === "false") return [condition];
-	if (isCompoundCondition(condition) && condition.operator === "OR") {
-		const branches = [];
-		for (const child of condition.children) branches.push(...collectOrBranches(child));
-		return branches;
-	}
-	return [condition];
-}
-/**
-* Expand OR conditions in exclusive entries AFTER buildExclusiveConditions.
-*
-* This handles ORs that arise from De Morgan expansion during negation:
-*   !(A & B) = !A | !B
-*
-* These ORs need to be made exclusive to avoid overlapping CSS rules:
-*   !A | !B  →  !A | (A & !B)
-*
-* This is logically equivalent but ensures each branch has proper context.
-*
-* Example:
-*   Input: { "": V1, "@supports(...) & :has()": V2 }
-*   V2's exclusive = @supports & :has
-*   V1's exclusive = !(@supports & :has) = !@supports | !:has
-*
-*   Without this fix: V1 gets two rules:
-*     - @supports (not ...) → V1  ✓
-*     - :not(:has()) → V1  ✗ (missing @supports context!)
-*
-*   With this fix: V1 gets two exclusive rules:
-*     - @supports (not ...) → V1  ✓
-*     - @supports (...) { :not(:has()) } → V1  ✓ (proper context!)
-*/
-function expandExclusiveOrs(entries) {
-	const result = [];
-	for (const entry of entries) {
-		const expanded = expandExclusiveConditionOrs(entry);
-		result.push(...expanded);
-	}
-	return result;
-}
-/**
-* Check if a condition involves at-rules (media, container, supports, starting)
-*/
-function hasAtRuleContext(node) {
-	if (node.kind === "true" || node.kind === "false") return false;
-	if (node.kind === "state") return node.type === "media" || node.type === "container" || node.type === "supports" || node.type === "starting";
-	if (node.kind === "compound") return node.children.some(hasAtRuleContext);
-	return false;
-}
-/**
-* Sort OR branches to prioritize at-rule conditions first.
-*
-* This is critical for correct CSS generation. For `!A | !B` where A is at-rule
-* and B is modifier, we want:
-*   - Branch 0: !A (at-rule negation - covers "no @supports/media" case)
-*   - Branch 1: A & !B (modifier negation with at-rule context)
-*
-* If we process in wrong order (!B first), we'd get:
-*   - Branch 0: !B (modifier negation WITHOUT at-rule context - WRONG!)
-*   - Branch 1: B & !A (at-rule negation with modifier - incomplete coverage)
-*/
-function sortOrBranchesForExpansion(branches) {
-	return [...branches].sort((a, b) => {
-		const aHasAtRule = hasAtRuleContext(a);
-		const bHasAtRule = hasAtRuleContext(b);
-		if (aHasAtRule && !bHasAtRule) return -1;
-		if (!aHasAtRule && bHasAtRule) return 1;
-		return 0;
-	});
-}
-/**
-* Expand ORs in a single entry's exclusive condition
-*/
-function expandExclusiveConditionOrs(entry) {
-	let orBranches = collectOrBranches(entry.exclusiveCondition);
-	if (orBranches.length <= 1) return [entry];
-	orBranches = sortOrBranchesForExpansion(orBranches);
-	const result = [];
-	const priorBranches = [];
-	for (let i = 0; i < orBranches.length; i++) {
-		const branch = orBranches[i];
-		let exclusiveBranch = branch;
-		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
-		const simplified = simplifyCondition(exclusiveBranch);
-		if (simplified.kind === "false") {
-			priorBranches.push(branch);
-			continue;
-		}
-		result.push({
-			...entry,
-			stateKey: `${entry.stateKey}[or:${i}]`,
-			exclusiveCondition: simplified
-		});
-		priorBranches.push(branch);
-	}
-	return result;
-}
-//#endregion
-//#region src/pipeline/materialize-contradictions.ts
-/**
-* Generic deduplication by a key extraction function.
-* Preserves insertion order, keeping the first occurrence of each key.
-*/
-function dedupeByKey(items, getKey) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const item of items) {
-		const key = getKey(item);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(item);
-		}
-	}
-	return result;
-}
-function dedupeMediaConditions(conditions) {
-	return dedupeByKey(conditions, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
-}
-function dedupeContainerConditions(conditions) {
-	return dedupeByKey(conditions, (c) => `${c.name ?? ""}|${c.condition}|${c.negated}`);
-}
-function dedupeSupportsConditions(conditions) {
-	return dedupeByKey(conditions, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
-}
-/**
-* Check if supports conditions contain contradictions
-* e.g., @supports(display: grid) AND NOT @supports(display: grid)
-*/
-function hasSupportsContradiction(conditions) {
-	const conditionMap = /* @__PURE__ */ new Map();
-	for (const cond of conditions) {
-		const key = `${cond.subtype}|${cond.condition}`;
-		const existing = conditionMap.get(key);
-		if (existing !== void 0 && existing !== !cond.negated) return true;
-		conditionMap.set(key, !cond.negated);
-	}
-	return false;
-}
-/**
-* Check if a set of media conditions contains contradictions
-* e.g., (prefers-color-scheme: light) AND NOT (prefers-color-scheme: light)
-* or (width >= 900px) AND (width < 600px)
-*
-* Uses parsed media conditions for efficient analysis without regex parsing.
+* Check if a set of media conditions contains contradictions
+* e.g., (prefers-color-scheme: light) AND NOT (prefers-color-scheme: light)
+* or (width >= 900px) AND (width < 600px)
+*
+* Uses parsed media conditions for efficient analysis without regex parsing.
 */
 function hasMediaContradiction(conditions) {
 	const featureConditions = /* @__PURE__ */ new Map();
@@ -7777,7 +7584,9 @@ function dedupeSelectorConditions(conditions) {
 	if (facts.negatedBooleanAttrs.size === 0 && facts.positiveExactValuesByAttr.size === 0) return result;
 	return result.filter((c) => {
 		if (!("attribute" in c)) return true;
-		return !isSubsumedNegatedModifier(c, facts);
+		if (isSubsumedNegatedModifier(c, facts)) return false;
+		if (!c.negated && c.value === void 0 && facts.positiveExactValuesByAttr.has(c.attribute)) return false;
+		return true;
 	});
 }
 /**
@@ -8100,6 +7909,12 @@ function makeOrBranchesExclusive(children) {
 * Check if OR branches produce different at-rule contexts when
 * materialized. If so, the Cartesian product in andToCSS will
 * create overlapping CSS variants that need exclusive expansion.
+*
+* Exported so Stage 2a (`expandOrConditions` in `exclusive.ts`) can
+* reuse the same heuristic and skip OR expansion when every branch
+* lives in the same at-rule/root/parent/own context — pure-selector
+* ORs are better collapsed into `:is(...)` at materialization time
+* than expanded into mutually-exclusive `A | (B & !A) | …` cascades.
 */
 function branchesProduceDifferentContexts(branches) {
 	const contextKeys = /* @__PURE__ */ new Set();
@@ -8117,161 +7932,634 @@ function branchesProduceDifferentContexts(branches) {
 * After deduplication, variants that differ only in their base
 * modifier/pseudo conditions are merged into :is() groups.
 *
-* Note: OR exclusivity is handled at the pipeline level (expandOrConditions),
-* so here we just collect all variants. Any remaining ORs in the condition
-* tree (e.g., from De Morgan expansion) are handled as simple alternatives.
+* Note: OR exclusivity is handled at the pipeline level (expandOrConditions),
+* so here we just collect all variants. Any remaining ORs in the condition
+* tree (e.g., from De Morgan expansion) are handled as simple alternatives.
+*/
+function orToCSS(children) {
+	const allVariants = [];
+	for (const child of children) {
+		const childCSS = conditionToCSSInner(child);
+		if (childCSS.isImpossible) continue;
+		allVariants.push(...childCSS.variants);
+	}
+	if (allVariants.length === 0) return {
+		variants: [],
+		isImpossible: true
+	};
+	return {
+		variants: dedupeVariants(allVariants),
+		isImpossible: false
+	};
+}
+/**
+* Find keys present in ALL condition arrays.
+*/
+function findCommonKeys(conditionSets, getKey) {
+	if (conditionSets.length === 0) return /* @__PURE__ */ new Set();
+	const common = new Set(conditionSets[0].map(getKey));
+	for (let i = 1; i < conditionSets.length; i++) {
+		const keys = new Set(conditionSets[i].map(getKey));
+		for (const key of common) if (!keys.has(key)) common.delete(key);
+	}
+	return common;
+}
+/**
+* Merge OR variants that share the same "context" (at-rules, root, parent,
+* own, starting) into a single variant with a SelectorGroup.
+*
+* Variants with no modifier/pseudo conditions are kept separate (they match
+* unconditionally and can't be expressed inside :is()).
+*/
+function mergeVariantsIntoSelectorGroups(variants) {
+	if (variants.length <= 1) return variants;
+	const groups = /* @__PURE__ */ new Map();
+	for (const v of variants) {
+		const key = getVariantContextKey(v);
+		const group = groups.get(key);
+		if (group) group.push(v);
+		else groups.set(key, [v]);
+	}
+	const result = [];
+	for (const group of groups.values()) {
+		if (group.length === 1) {
+			result.push(group[0]);
+			continue;
+		}
+		const withSelectors = [];
+		const withoutSelectors = [];
+		for (const v of group) if (v.modifierConditions.length === 0 && v.pseudoConditions.length === 0) withoutSelectors.push(v);
+		else withSelectors.push(v);
+		result.push(...withoutSelectors);
+		if (withSelectors.length <= 1) {
+			result.push(...withSelectors);
+			continue;
+		}
+		result.push(factorAndGroup(withSelectors));
+	}
+	return result;
+}
+/**
+* Factor common modifier/pseudo conditions out of variants and create
+* a single variant with a SelectorGroup for the remaining (differing)
+* conditions.
+*
+* Precondition: all variants must share the same context key (identical
+* at-rules, root/parent/own/selector groups, startingStyle).
+*/
+function factorAndGroup(variants) {
+	{
+		const key0 = getVariantContextKey(variants[0]);
+		for (let i = 1; i < variants.length; i++) {
+			const keyI = getVariantContextKey(variants[i]);
+			if (keyI !== key0) throw new Error(`factorAndGroup: context key mismatch at index ${i}.\n  expected: ${key0}\n  got:      ${keyI}`);
+		}
+	}
+	const commonModKeys = findCommonKeys(variants.map((v) => v.modifierConditions), getModifierKey);
+	const commonPseudoKeys = findCommonKeys(variants.map((v) => v.pseudoConditions), getPseudoKey);
+	const commonModifiers = variants[0].modifierConditions.filter((m) => commonModKeys.has(getModifierKey(m)));
+	const commonPseudos = variants[0].pseudoConditions.filter((p) => commonPseudoKeys.has(getPseudoKey(p)));
+	const branches = [];
+	let hasEmptyBranch = false;
+	for (const v of variants) {
+		const branch = [];
+		for (const mod of v.modifierConditions) if (!commonModKeys.has(getModifierKey(mod))) branch.push(mod);
+		for (const pseudo of v.pseudoConditions) if (!commonPseudoKeys.has(getPseudoKey(pseudo))) branch.push(pseudo);
+		if (branch.length > 0) branches.push(branch);
+		else hasEmptyBranch = true;
+	}
+	if (hasEmptyBranch) return {
+		...variants[0],
+		modifierConditions: commonModifiers,
+		pseudoConditions: commonPseudos
+	};
+	const factoredGroups = tryFactorIntoDimensions(branches);
+	if (factoredGroups) return {
+		modifierConditions: commonModifiers,
+		pseudoConditions: commonPseudos,
+		selectorGroups: [...variants[0].selectorGroups, ...factoredGroups],
+		ownGroups: [...variants[0].ownGroups],
+		mediaConditions: [...variants[0].mediaConditions],
+		containerConditions: [...variants[0].containerConditions],
+		supportsConditions: [...variants[0].supportsConditions],
+		rootGroups: [...variants[0].rootGroups],
+		parentGroups: [...variants[0].parentGroups],
+		startingStyle: variants[0].startingStyle
+	};
+	return {
+		modifierConditions: commonModifiers,
+		pseudoConditions: commonPseudos,
+		selectorGroups: [...variants[0].selectorGroups, {
+			branches,
+			negated: false
+		}],
+		ownGroups: [...variants[0].ownGroups],
+		mediaConditions: [...variants[0].mediaConditions],
+		containerConditions: [...variants[0].containerConditions],
+		supportsConditions: [...variants[0].supportsConditions],
+		rootGroups: [...variants[0].rootGroups],
+		parentGroups: [...variants[0].parentGroups],
+		startingStyle: variants[0].startingStyle
+	};
+}
+/**
+* Detect when branches form a complete Cartesian product of independent
+* modifier attribute dimensions and return one SelectorGroup per dimension.
+*
+* Example: 4 branches for 2 attributes × 2 values each →
+*   :is(A1, A2):is(B1, B2)  instead of  :is(A1B1, A1B2, A2B1, A2B2)
+*/
+function tryFactorIntoDimensions(branches) {
+	if (branches.length < 4) return null;
+	const dimensions = /* @__PURE__ */ new Map();
+	for (const branch of branches) for (const cond of branch) {
+		if (!("attribute" in cond)) return null;
+		if (!dimensions.has(cond.attribute)) dimensions.set(cond.attribute, /* @__PURE__ */ new Map());
+		dimensions.get(cond.attribute).set(getModifierKey(cond), cond);
+	}
+	if (dimensions.size < 2) return null;
+	for (const branch of branches) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const cond of branch) {
+			const attr = cond.attribute;
+			if (seen.has(attr)) return null;
+			seen.add(attr);
+		}
+		if (seen.size !== dimensions.size) return null;
+	}
+	let expectedCount = 1;
+	for (const vals of dimensions.values()) expectedCount *= vals.size;
+	if (branches.length !== expectedCount) return null;
+	return [...dimensions.values()].map((vals) => ({
+		branches: [...vals.values()].map((cond) => [cond]),
+		negated: false
+	}));
+}
+/**
+* Build at-rules array from a variant
+*/
+function buildAtRulesFromVariant(variant) {
+	const atRules = [];
+	if (variant.mediaConditions.length > 0) {
+		const conditionParts = variant.mediaConditions.map((c) => {
+			if (c.subtype === "type") return c.negated ? `not ${c.condition}` : c.condition;
+			else return c.negated ? `(not ${c.condition})` : c.condition;
+		});
+		atRules.push(`@media ${conditionParts.sort().join(" and ")}`);
+	}
+	if (variant.containerConditions.length > 0) {
+		const byName = /* @__PURE__ */ new Map();
+		for (const cond of variant.containerConditions) {
+			const group = byName.get(cond.name) || [];
+			group.push(cond);
+			byName.set(cond.name, group);
+		}
+		for (const [name, conditions] of byName) {
+			const conditionParts = conditions.map((c) => c.negated ? `(not ${c.condition})` : c.condition);
+			const namePrefix = name ? `${name} ` : "";
+			atRules.push(`@container ${namePrefix}${conditionParts.join(" and ")}`);
+		}
+	}
+	if (variant.supportsConditions.length > 0) {
+		const conditionParts = variant.supportsConditions.map((c) => {
+			if (c.subtype === "selector") {
+				const selectorCond = `selector(${c.condition})`;
+				return c.negated ? `(not ${selectorCond})` : selectorCond;
+			} else {
+				const featureCond = `(${c.condition})`;
+				return c.negated ? `(not ${featureCond})` : featureCond;
+			}
+		});
+		atRules.push(`@supports ${conditionParts.join(" and ")}`);
+	}
+	return atRules;
+}
+//#endregion
+//#region src/pipeline/exclusive.ts
+/**
+* Build exclusive conditions for a list of parsed style entries.
+*
+* The entries should be ordered by priority (highest priority first).
+*
+* For each entry, we compute:
+*   exclusiveCondition = condition & !prior[0] & !prior[1] & ...
+*
+* This ensures exactly one condition matches at any time.
+*
+* Example:
+*   Input (ordered highest to lowest priority):
+*     A: value1 (priority 2)
+*     B: value2 (priority 1)
+*     C: value3 (priority 0)
+*
+*   Output:
+*     A: A
+*     B: B & !A
+*     C: C & !A & !B
+*
+* @param entries Parsed style entries ordered by priority (highest first)
+* @returns Entries with exclusive conditions, filtered to remove impossible ones
+*/
+function buildExclusiveConditions(entries) {
+	const result = [];
+	const priorConditions = [];
+	for (const entry of entries) {
+		let exclusive = entry.condition;
+		for (const prior of priorConditions) if (prior.kind !== "true") exclusive = and(exclusive, not(prior));
+		const simplified = simplifyCondition(exclusive);
+		if (simplified.kind === "false") continue;
+		result.push({
+			...entry,
+			exclusiveCondition: simplified
+		});
+		if (entry.condition.kind !== "true") priorConditions.push(entry.condition);
+	}
+	return result;
+}
+/**
+* Parse style entries from a value mapping object.
+*
+* @param styleKey The style key (e.g., 'padding')
+* @param valueMap The value mapping { '': '2x', 'compact': '1x', '@media(w < 768px)': '0.5x' }
+* @param parseCondition Function to parse state keys into conditions
+* @returns Parsed entries ordered by priority (highest first)
+*/
+function parseStyleEntries(styleKey, valueMap, parseCondition) {
+	const entries = [];
+	Object.keys(valueMap).forEach((stateKey, index) => {
+		const value = valueMap[stateKey];
+		const condition = stateKey === "" ? trueCondition() : parseCondition(stateKey);
+		entries.push({
+			styleKey,
+			stateKey,
+			value,
+			condition,
+			priority: index
+		});
+	});
+	entries.reverse();
+	return entries;
+}
+/**
+* Merge parsed entries that share the same value.
+*
+* When multiple **non-default** state keys map to the same value, their
+* conditions can be combined with OR and treated as a single entry.
+* This must happen **before** exclusive expansion and OR branch splitting
+* to avoid combinatorial explosion and duplicate CSS output.
+*
+* **Merging must preserve the authored cascade.** Merging two same-value
+* entries with priorities `p_h > p_l` lifts the lower-priority entry up
+* to `p_h` and changes the "blocker" for intermediate-priority entries
+* from `!C_h` to `!(C_h | C_l) = !C_h & !C_l`. The added `!C_l`
+* constraint can incorrectly block an intermediate entry that should
+* have won.
+*
+* Two same-value entries with conditions `C_h` (higher priority) and
+* `C_l` (lower priority) are safe to merge iff for every entry
+* `e_m` strictly between them in priority with a different value,
+*
+*     simplify(C_m & C_l & !C_h) = FALSE
+*
+* i.e. there is no scenario where the intermediate state could have
+* matched (`C_m`), the lower-priority same-value entry would also have
+* matched (`C_l`), and the higher-priority entry would not (`!C_h`).
+* In such scenarios the intermediate is supposed to win; the merge
+* would block it by introducing `!C_l`.
+*
+* Example (UNSAFE — must not merge):
+* `{ hovered: 'red', pressed: 'blue', disabled: 'red' }`.
+* C_h = disabled, C_l = hovered, C_m = pressed. `pressed & hovered &
+* !disabled` is satisfiable (three independent modifiers), so the
+* intermediate `pressed` would lose to a merged red rule when both
+* `pressed` and `hovered` are active — breaking the cascade
+* `disabled > pressed > hovered`.
+*
+* Example (SAFE — still merges):
+* `{ '': light, '@dark': dark, '@hc': hc, '@dark & @hc': dark }`.
+* C_h = `@dark & @hc`, C_l = `@dark`, C_m = `@hc`.
+* `@hc & @dark & !(@dark & @hc) = @hc & @dark & (!@dark | !@hc)`
+* simplifies to FALSE, so merging the two darks into one `@dark` rule
+* at the higher priority does not affect the `@hc` rule.
+*
+* Default (TRUE) entries are never merged with non-default entries.
+* Merging `TRUE | X` collapses to `TRUE`, destroying the non-default
+* condition's participation in exclusive building. Stage 6
+* `mergeByValue` handles combining rules with identical CSS output
+* after exclusive conditions are correctly built.
+*
+* The merged entry keeps the highest priority of the merged entries.
+*/
+function mergeEntriesByValue(entries) {
+	if (entries.length <= 1) return entries;
+	const merged = [];
+	for (const entry of entries) {
+		if (entry.condition.kind === "true") {
+			merged.push(entry);
+			continue;
+		}
+		const valueKey = serializeValue(entry.value);
+		let mergeIdx = -1;
+		for (let j = merged.length - 1; j >= 0; j--) {
+			const prev = merged[j];
+			if (prev.condition.kind === "true") continue;
+			if (serializeValue(prev.value) !== valueKey) continue;
+			let safe = true;
+			for (let k = j + 1; k < merged.length; k++) {
+				const inter = merged[k];
+				if (inter.condition.kind === "true") continue;
+				if (serializeValue(inter.value) === valueKey) continue;
+				if (simplifyCondition(and(inter.condition, entry.condition, not(prev.condition))).kind !== "false") {
+					safe = false;
+					break;
+				}
+			}
+			if (safe) {
+				mergeIdx = j;
+				break;
+			}
+		}
+		if (mergeIdx >= 0) {
+			const prev = merged[mergeIdx];
+			const newCondition = simplifyCondition(or(prev.condition, entry.condition));
+			merged[mergeIdx] = {
+				styleKey: prev.styleKey,
+				stateKey: `${prev.stateKey} | ${entry.stateKey}`,
+				value: prev.value,
+				condition: newCondition,
+				priority: Math.max(prev.priority, entry.priority)
+			};
+		} else merged.push(entry);
+	}
+	return merged;
+}
+function serializeValue(value) {
+	if (value === null || value === void 0) return "null";
+	if (typeof value === "string" || typeof value === "number") return String(value);
+	return JSON.stringify(value);
+}
+/**
+* Eliminate redundant state dimensions from a value map.
+*
+* When a value map contains compound AND state keys (e.g. `@dark & @hc`),
+* checks whether any state atom is a "don't-care" variable — i.e. the
+* value is the same whether that atom is present or absent. Redundant
+* atoms are removed from all keys and duplicate entries are collapsed.
+*
+* This runs **before** condition parsing so that downstream stages
+* (`mergeEntriesByValue`, `buildExclusiveConditions`, materialization)
+* never see the irrelevant dimension, producing simpler, smaller CSS.
+*
+* Only pure top-level AND combinations are eligible. Keys that contain
+* `|`, `^`, or `,` at the top level are treated as opaque single atoms.
+*
+* @example
+*   { '': A, '@dark': B, '@hc': A, '@dark & @hc': B }
+*   // @hc is redundant → { '': A, '@dark': B }
+*/
+function extractCompoundStates(valueMap) {
+	const keys = Object.keys(valueMap);
+	if (keys.length < 3 || !keys.some((k) => k.includes("&"))) return valueMap;
+	const entries = keys.map((key) => {
+		return {
+			atoms: splitTopLevelAnd(key) ?? [key],
+			value: valueMap[key]
+		};
+	});
+	const allAtoms = /* @__PURE__ */ new Set();
+	for (const e of entries) for (const a of e.atoms) allAtoms.add(a);
+	const redundant = /* @__PURE__ */ new Set();
+	for (const atom of allAtoms) if (isAtomRedundant(entries, atom)) redundant.add(atom);
+	if (redundant.size === 0) return valueMap;
+	const newMap = {};
+	for (const e of entries) {
+		const newKey = e.atoms.filter((a) => !redundant.has(a)).join(" & ");
+		if (!(newKey in newMap)) newMap[newKey] = e.value;
+	}
+	return newMap;
+}
+/**
+* Split a state key by top-level `&` operators.
+*
+* Returns `null` if the key contains `|`, `^`, or `,` at the top level
+* (making it ineligible for atom-level extraction).
+* Returns `[]` for the empty string (default key).
+*/
+function splitTopLevelAnd(key) {
+	if (key === "") return [];
+	const parts = [];
+	let depth = 0;
+	let current = "";
+	for (const ch of key) {
+		if (ch === "(" || ch === "[") depth++;
+		else if (ch === ")" || ch === "]") depth--;
+		if (depth === 0) {
+			if (ch === "&") {
+				const trimmed = current.trim();
+				if (trimmed) parts.push(trimmed);
+				current = "";
+				continue;
+			}
+			if (ch === "|" || ch === "^" || ch === ",") return null;
+		}
+		current += ch;
+	}
+	const trimmed = current.trim();
+	if (trimmed) parts.push(trimmed);
+	return parts;
+}
+/**
+* An atom is redundant when every entry that contains it has a matching
+* partner (same remaining atoms, atom absent) with the same value.
+*/
+function isAtomRedundant(entries, atom) {
+	const withAtom = entries.filter((e) => e.atoms.includes(atom));
+	if (withAtom.length === 0) return false;
+	for (const wa of withAtom) {
+		const remaining = wa.atoms.filter((a) => a !== atom);
+		const pair = entries.find((e) => !e.atoms.includes(atom) && e.atoms.length === remaining.length && remaining.every((r) => e.atoms.includes(r)));
+		if (!pair) return false;
+		if (serializeValue(wa.value) !== serializeValue(pair.value)) return false;
+	}
+	return true;
+}
+/**
+* Check if a value is a style value mapping (object with state keys)
+*/
+function isValueMapping(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+/**
+* Expand OR conditions in parsed entries into multiple exclusive entries.
+*
+* For an entry with condition `A | B | C`, this creates 3 entries:
+*   - condition: A
+*   - condition: B & !A
+*   - condition: C & !A & !B
+*
+* This ensures OR branches are mutually exclusive BEFORE the main
+* exclusive condition building pass.
+*
+* @param entries Parsed entries (may contain OR conditions)
+* @returns Expanded entries with OR branches made exclusive
+*/
+function expandOrConditions(entries) {
+	const result = [];
+	for (const entry of entries) {
+		const expanded = expandSingleEntry(entry);
+		result.push(...expanded);
+	}
+	return result;
+}
+/**
+* Expand a single entry's OR condition into multiple exclusive entries.
+*
+* Note: branches are NOT sorted by at-rule context here (unlike the
+* `expandExclusiveOrs` pass below). User-authored ORs in state keys aren't
+* the product of De Morgan negation, so each branch is expected to render
+* independently in its own scope and at-rule sort isn't load-bearing.
+* The post-build pass needs the sort because it has to preserve at-rule
+* wrapping across branches that came from negating a compound at-rule.
+*
+* Skip optimisation: when every branch renders into the same at-rule /
+* root / parent / own context (see "Key Design Decision #2" in
+* `docs/pipeline.md`), forcing mutual exclusivity here produces dead
+* `B & !A`-style branches that materialization later folds back into
+* `:is(A, B)`. Bail out and let `materialize.ts` collapse the OR via
+* `mergeVariantsIntoSelectorGroups`. Cross-entry exclusivity is still
+* enforced by `buildExclusiveConditions`; the post-build `expandExclusiveOrs`
+* pass still handles De Morgan ORs whose branches actually differ in
+* context.
 */
-function orToCSS(children) {
-	const allVariants = [];
-	for (const child of children) {
-		const childCSS = conditionToCSSInner(child);
-		if (childCSS.isImpossible) continue;
-		allVariants.push(...childCSS.variants);
+function expandSingleEntry(entry) {
+	const orBranches = collectOrBranches(entry.condition);
+	if (orBranches.length <= 1) return [entry];
+	if (!branchesProduceDifferentContexts(orBranches)) return [entry];
+	const result = [];
+	const priorBranches = [];
+	for (let i = 0; i < orBranches.length; i++) {
+		const branch = orBranches[i];
+		let exclusiveBranch = branch;
+		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
+		const simplified = simplifyCondition(exclusiveBranch);
+		if (simplified.kind === "false") {
+			priorBranches.push(branch);
+			continue;
+		}
+		result.push({
+			...entry,
+			stateKey: `${entry.stateKey}[${i}]`,
+			condition: simplified
+		});
+		priorBranches.push(branch);
 	}
-	if (allVariants.length === 0) return {
-		variants: [],
-		isImpossible: true
-	};
-	return {
-		variants: dedupeVariants(allVariants),
-		isImpossible: false
-	};
+	return result;
 }
 /**
-* Find keys present in ALL condition arrays.
+* Collect top-level OR branches from a condition.
+*
+* For `A | B | C`, returns [A, B, C]
+* For `A & B`, returns [A & B] (single branch)
+* For `A | (B & C)`, returns [A, B & C]
 */
-function findCommonKeys(conditionSets, getKey) {
-	if (conditionSets.length === 0) return /* @__PURE__ */ new Set();
-	const common = new Set(conditionSets[0].map(getKey));
-	for (let i = 1; i < conditionSets.length; i++) {
-		const keys = new Set(conditionSets[i].map(getKey));
-		for (const key of common) if (!keys.has(key)) common.delete(key);
+function collectOrBranches(condition) {
+	if (condition.kind === "true" || condition.kind === "false") return [condition];
+	if (isCompoundCondition(condition) && condition.operator === "OR") {
+		const branches = [];
+		for (const child of condition.children) branches.push(...collectOrBranches(child));
+		return branches;
 	}
-	return common;
+	return [condition];
 }
 /**
-* Merge OR variants that share the same "context" (at-rules, root, parent,
-* own, starting) into a single variant with a SelectorGroup.
+* Expand OR conditions in exclusive entries AFTER buildExclusiveConditions.
 *
-* Variants with no modifier/pseudo conditions are kept separate (they match
-* unconditionally and can't be expressed inside :is()).
+* This handles ORs that arise from De Morgan expansion during negation:
+*   !(A & B) = !A | !B
+*
+* These ORs need to be made exclusive to avoid overlapping CSS rules:
+*   !A | !B  →  !A | (A & !B)
+*
+* This is logically equivalent but ensures each branch has proper context.
+*
+* Example:
+*   Input: { "": V1, "@supports(...) & :has()": V2 }
+*   V2's exclusive = @supports & :has
+*   V1's exclusive = !(@supports & :has) = !@supports | !:has
+*
+*   Without this fix: V1 gets two rules:
+*     - @supports (not ...) → V1  ✓
+*     - :not(:has()) → V1  ✗ (missing @supports context!)
+*
+*   With this fix: V1 gets two exclusive rules:
+*     - @supports (not ...) → V1  ✓
+*     - @supports (...) { :not(:has()) } → V1  ✓ (proper context!)
 */
-function mergeVariantsIntoSelectorGroups(variants) {
-	if (variants.length <= 1) return variants;
-	const groups = /* @__PURE__ */ new Map();
-	for (const v of variants) {
-		const key = getVariantContextKey(v);
-		const group = groups.get(key);
-		if (group) group.push(v);
-		else groups.set(key, [v]);
-	}
+function expandExclusiveOrs(entries) {
 	const result = [];
-	for (const group of groups.values()) {
-		if (group.length === 1) {
-			result.push(group[0]);
-			continue;
-		}
-		const withSelectors = [];
-		const withoutSelectors = [];
-		for (const v of group) if (v.modifierConditions.length === 0 && v.pseudoConditions.length === 0) withoutSelectors.push(v);
-		else withSelectors.push(v);
-		result.push(...withoutSelectors);
-		if (withSelectors.length <= 1) {
-			result.push(...withSelectors);
-			continue;
-		}
-		result.push(factorAndGroup(withSelectors));
+	for (const entry of entries) {
+		const expanded = expandExclusiveConditionOrs(entry);
+		result.push(...expanded);
 	}
 	return result;
 }
 /**
-* Factor common modifier/pseudo conditions out of variants and create
-* a single variant with a SelectorGroup for the remaining (differing)
-* conditions.
+* Check if a condition involves at-rules (media, container, supports, starting)
+*/
+function hasAtRuleContext(node) {
+	if (node.kind === "true" || node.kind === "false") return false;
+	if (node.kind === "state") return node.type === "media" || node.type === "container" || node.type === "supports" || node.type === "starting";
+	if (node.kind === "compound") return node.children.some(hasAtRuleContext);
+	return false;
+}
+/**
+* Sort OR branches to prioritize at-rule conditions first.
 *
-* Precondition: all variants must share the same context key (identical
-* at-rules, root/parent/own/selector groups, startingStyle).
+* This is critical for correct CSS generation. For `!A | !B` where A is at-rule
+* and B is modifier, we want:
+*   - Branch 0: !A (at-rule negation - covers "no @supports/media" case)
+*   - Branch 1: A & !B (modifier negation with at-rule context)
+*
+* If we process in wrong order (!B first), we'd get:
+*   - Branch 0: !B (modifier negation WITHOUT at-rule context - WRONG!)
+*   - Branch 1: B & !A (at-rule negation with modifier - incomplete coverage)
 */
-function factorAndGroup(variants) {
-	{
-		const key0 = getVariantContextKey(variants[0]);
-		for (let i = 1; i < variants.length; i++) {
-			const keyI = getVariantContextKey(variants[i]);
-			if (keyI !== key0) throw new Error(`factorAndGroup: context key mismatch at index ${i}.\n  expected: ${key0}\n  got:      ${keyI}`);
-		}
-	}
-	const commonModKeys = findCommonKeys(variants.map((v) => v.modifierConditions), getModifierKey);
-	const commonPseudoKeys = findCommonKeys(variants.map((v) => v.pseudoConditions), getPseudoKey);
-	const commonModifiers = variants[0].modifierConditions.filter((m) => commonModKeys.has(getModifierKey(m)));
-	const commonPseudos = variants[0].pseudoConditions.filter((p) => commonPseudoKeys.has(getPseudoKey(p)));
-	const branches = [];
-	let hasEmptyBranch = false;
-	for (const v of variants) {
-		const branch = [];
-		for (const mod of v.modifierConditions) if (!commonModKeys.has(getModifierKey(mod))) branch.push(mod);
-		for (const pseudo of v.pseudoConditions) if (!commonPseudoKeys.has(getPseudoKey(pseudo))) branch.push(pseudo);
-		if (branch.length > 0) branches.push(branch);
-		else hasEmptyBranch = true;
-	}
-	if (hasEmptyBranch) return {
-		...variants[0],
-		modifierConditions: commonModifiers,
-		pseudoConditions: commonPseudos
-	};
-	return {
-		modifierConditions: commonModifiers,
-		pseudoConditions: commonPseudos,
-		selectorGroups: [...variants[0].selectorGroups, {
-			branches,
-			negated: false
-		}],
-		ownGroups: [...variants[0].ownGroups],
-		mediaConditions: [...variants[0].mediaConditions],
-		containerConditions: [...variants[0].containerConditions],
-		supportsConditions: [...variants[0].supportsConditions],
-		rootGroups: [...variants[0].rootGroups],
-		parentGroups: [...variants[0].parentGroups],
-		startingStyle: variants[0].startingStyle
-	};
+function sortOrBranchesForExpansion(branches) {
+	return [...branches].sort((a, b) => {
+		const aHasAtRule = hasAtRuleContext(a);
+		const bHasAtRule = hasAtRuleContext(b);
+		if (aHasAtRule && !bHasAtRule) return -1;
+		if (!aHasAtRule && bHasAtRule) return 1;
+		return 0;
+	});
 }
 /**
-* Build at-rules array from a variant
+* Expand ORs in a single entry's exclusive condition
 */
-function buildAtRulesFromVariant(variant) {
-	const atRules = [];
-	if (variant.mediaConditions.length > 0) {
-		const conditionParts = variant.mediaConditions.map((c) => {
-			if (c.subtype === "type") return c.negated ? `not ${c.condition}` : c.condition;
-			else return c.negated ? `(not ${c.condition})` : c.condition;
-		});
-		atRules.push(`@media ${conditionParts.join(" and ")}`);
-	}
-	if (variant.containerConditions.length > 0) {
-		const byName = /* @__PURE__ */ new Map();
-		for (const cond of variant.containerConditions) {
-			const group = byName.get(cond.name) || [];
-			group.push(cond);
-			byName.set(cond.name, group);
-		}
-		for (const [name, conditions] of byName) {
-			const conditionParts = conditions.map((c) => c.negated ? `(not ${c.condition})` : c.condition);
-			const namePrefix = name ? `${name} ` : "";
-			atRules.push(`@container ${namePrefix}${conditionParts.join(" and ")}`);
+function expandExclusiveConditionOrs(entry) {
+	let orBranches = collectOrBranches(entry.exclusiveCondition);
+	if (orBranches.length <= 1) return [entry];
+	if (!branchesProduceDifferentContexts(orBranches)) return [entry];
+	orBranches = sortOrBranchesForExpansion(orBranches);
+	const result = [];
+	const priorBranches = [];
+	for (let i = 0; i < orBranches.length; i++) {
+		const branch = orBranches[i];
+		let exclusiveBranch = branch;
+		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
+		const simplified = simplifyCondition(exclusiveBranch);
+		if (simplified.kind === "false") {
+			priorBranches.push(branch);
+			continue;
 		}
-	}
-	if (variant.supportsConditions.length > 0) {
-		const conditionParts = variant.supportsConditions.map((c) => {
-			if (c.subtype === "selector") {
-				const selectorCond = `selector(${c.condition})`;
-				return c.negated ? `(not ${selectorCond})` : selectorCond;
-			} else {
-				const featureCond = `(${c.condition})`;
-				return c.negated ? `(not ${featureCond})` : featureCond;
-			}
+		result.push({
+			...entry,
+			stateKey: `${entry.stateKey}[or:${i}]`,
+			exclusiveCondition: simplified
 		});
-		atRules.push(`@supports ${conditionParts.join(" and ")}`);
+		priorBranches.push(branch);
 	}
-	return atRules;
+	return result;
 }
 //#endregion
 //#region src/utils/case-converter.ts
@@ -8338,6 +8626,15 @@ function emitWarning(code, message) {
 const MAX_XOR_CHAIN_LENGTH = 4;
 const parseCache = new Lru(5e3);
 /**
+* Chrome-internal pseudo-classes (e.g. `:-internal-autofill-selected`,
+* `:-internal-autofill-previewed`) cannot be targeted from user CSS and
+* may invalidate the surrounding rule in Safari even when wrapped in
+* forgiving `:is(...)`. The regex matches both bare uses and references
+* inside enhanced pseudo arguments like `:is(:-webkit-autofill,
+* :-internal-autofill-selected)`.
+*/
+const INTERNAL_PSEUDO_PATTERN = /:-internal-[a-z0-9-]+/g;
+/**
 * Pattern for tokenizing state notation.
 * Matches: operators, parentheses, @-prefixed states, value mods, boolean mods,
 * pseudo-classes, class selectors, and attribute selectors.
@@ -8755,6 +9052,14 @@ function parseStateKey(stateKey, options = {}) {
 	const cacheKey = trimmed + "\0" + (options.isSubElement ? "1" : "0") + "\0" + localStatesKey;
 	const cached = parseCache.get(cacheKey);
 	if (cached) return cached;
+	if (isDevEnv()) {
+		INTERNAL_PSEUDO_PATTERN.lastIndex = 0;
+		const internalMatches = trimmed.match(INTERNAL_PSEUDO_PATTERN);
+		if (internalMatches && internalMatches.length > 0) {
+			const unique = Array.from(new Set(internalMatches));
+			emitWarning("INTERNAL_PSEUDO_USED", `State key "${trimmed}" references internal pseudo-class${unique.length > 1 ? "es" : ""} ${unique.map((p) => `\`${p}\``).join(", ")}. These are unmatchable from user CSS and can invalidate the surrounding rule in Safari (even inside \`:is(...)\`). Use \`:-webkit-autofill | :autofill\` instead for autofill states.`);
+		}
+	}
 	const result = new Parser(tokenize(trimmed), options).parse();
 	parseCache.set(cacheKey, result);
 	return result;
@@ -8824,7 +9129,15 @@ function runPipeline(styles, parserContext) {
 function processStyles(styles, selectorSuffix, parserContext, allRules) {
 	const keys = Object.keys(styles);
 	const selectorKeys = keys.filter((key) => isSelector(key));
-	const styleKeys = keys.filter((key) => !isSelector(key) && !key.startsWith("@"));
+	const styleKeys = [];
+	for (const key of keys) {
+		if (isSelector(key) || key.startsWith("@")) continue;
+		if (key.startsWith(":")) {
+			emitWarning("INVALID_TOP_LEVEL_PSEUDO_KEY", `Style key "${key}" starts with ':' which is not a valid Tasty style key. Use "&${key}" for nested-selector form, or move the state into a value map (e.g. \`{ color: { '${key}': value } }\`). The key has been ignored.`);
+			continue;
+		}
+		styleKeys.push(key);
+	}
 	processNestedSelectors(styles, selectorKeys, selectorSuffix, parserContext, allRules);
 	processHandlerQueue(buildHandlerQueue(styleKeys, styles), selectorSuffix, parserContext, allRules);
 }
@@ -9106,14 +9419,15 @@ function validatePattern(pattern) {
 * processSinglePattern('>Body>Row>', 'Cell')
 * // → '> [data-element="Body"] > [data-element="Row"] > [data-element="Cell"]'
 *
-* processSinglePattern('::before', 'Before')
-* // → '::before' (no key injection for pseudo on root)
+* processSinglePattern('&::before', 'Before')
+* // → '::before' (& attaches pseudo directly to root, no key injection)
 *
 * processSinglePattern('>@:hover', 'Item')
 * // → '> [data-element="Item"]:hover'
 */
 function processSinglePattern(pattern, key) {
-	const normalized = pattern.replace(/^&/, "").trim();
+	const startsWithAmpersand = pattern.startsWith("&");
+	const normalized = (startsWithAmpersand ? pattern.slice(1) : pattern).trim();
 	if (!normalized) return ` [data-element="${key}"]`;
 	const startsWithPseudo = /^::?[a-z]/.test(normalized);
 	let result = transformPattern(normalized);
@@ -9123,8 +9437,8 @@ function processSinglePattern(pattern, key) {
 		if (!startsWithPseudo && !result.startsWith(" ")) result = " " + result;
 		return result;
 	}
-	if (shouldInjectKey(normalized)) result = result + ` [data-element="${key}"]`;
-	if (!startsWithPseudo && !result.startsWith(" ")) result = " " + result;
+	if (shouldInjectKey(normalized, key)) result = result + ` [data-element="${key}"]`;
+	if (!startsWithAmpersand && !result.startsWith(" ")) result = " " + result;
 	return result;
 }
 /**
@@ -9262,22 +9576,28 @@ function transformPattern(pattern) {
 * | Attribute ([type]) | No | `'[type="text"]'` | `[type="text"]` |
 *
 * @param pattern - The normalized pattern (after stripping &)
+* @param key - The sub-element key being styled. If the trailing element name
+*              equals this key, it acts as an explicit placeholder for the key
+*              (same role as `@`) and no auto-injection happens.
 * @returns true if key should be injected, false otherwise
 *
 * @example
-* shouldInjectKey('>')           // → true (trailing combinator)
-* shouldInjectKey('>Body>Row')   // → true (ends with element)
-* shouldInjectKey('h1')          // → false (ends with tag)
-* shouldInjectKey('*')           // → false (universal selector)
-* shouldInjectKey('::before')    // → false (ends with pseudo)
-* shouldInjectKey('.active')     // → false (ends with class)
-* shouldInjectKey('a:hover')     // → false (ends with pseudo)
-* shouldInjectKey('button.primary') // → false (ends with class)
-*/
-function shouldInjectKey(pattern) {
+* shouldInjectKey('>', 'Key')            // → true (trailing combinator)
+* shouldInjectKey('>Body>Row', 'Key')    // → true (ends with different element)
+* shouldInjectKey('>Body>Key', 'Key')    // → false (trailing name === key)
+* shouldInjectKey('Key', 'Key')          // → false (sole element === key)
+* shouldInjectKey('h1', 'Key')           // → false (ends with tag)
+* shouldInjectKey('*', 'Key')            // → false (universal selector)
+* shouldInjectKey('::before', 'Key')     // → false (ends with pseudo)
+* shouldInjectKey('.active', 'Key')      // → false (ends with class)
+* shouldInjectKey('a:hover', 'Key')      // → false (ends with pseudo)
+* shouldInjectKey('button.primary', 'Key') // → false (ends with class)
+*/
+function shouldInjectKey(pattern, key) {
 	const trimmed = pattern.trim();
 	if (/[>+~]$/.test(trimmed)) return true;
-	if (/(?:^|[\s>+~\]:])[A-Z][a-zA-Z0-9]*$/.test(trimmed)) return true;
+	const trailingElement = trimmed.match(/(?:^|[\s>+~\]:])([A-Z][a-zA-Z0-9]*)$/);
+	if (trailingElement) return trailingElement[1] !== key;
 	return false;
 }
 /**
@@ -9683,7 +10003,10 @@ function isTestEnvironment() {
 		const g = global;
 		if (g.vi || g.jest || g.expect || g.describe || g.it) return true;
 	}
-	if (typeof window !== "undefined" && window.navigator?.userAgent?.includes("jsdom")) return true;
+	if (typeof window !== "undefined") {
+		const ua = window.navigator?.userAgent;
+		if (ua?.includes("jsdom") || ua?.includes("HappyDOM")) return true;
+	}
 	if (typeof globalThis !== "undefined") {
 		const gt = globalThis;
 		if (gt.vitest || gt.mocha) return true;
@@ -9697,7 +10020,8 @@ function createDefaultConfig(isTest) {
 	return {
 		maxRulesPerSheet: 8192,
 		forceTextInjection: isTest ?? false,
-		devMode: isDevEnv()
+		devMode: isDevEnv(),
+		namePrefix: "t"
 	};
 }
 /**
@@ -9939,6 +10263,7 @@ function configure(config = {}) {
 		warnOnce("configure-after-styles", "[Tasty] Cannot call configure() after styles have been generated.\nConfiguration must be done before the first render. The configuration will be ignored.");
 		return;
 	}
+	if (config.namePrefix !== void 0) validateNamePrefix(config.namePrefix);
 	let mergedStates = {};
 	let mergedUnits = {};
 	let mergedFuncs = {};
@@ -10090,6 +10415,17 @@ function getConfig() {
 	return currentConfig;
 }
 /**
+* Get the configured prefix used for every generated identifier
+* (class names, keyframe names, counter-style names).
+*
+* Falls back to the default prefix (`'t'`) when `configure()` has not
+* been called yet — this matches the auto-configuration behavior used
+* by the rest of the system.
+*/
+function getNamePrefix() {
+	return currentConfig?.namePrefix ?? "t";
+}
+/**
 * Get the global injector instance.
 * Auto-configures with defaults if not already configured.
 */
@@ -10123,6 +10459,6 @@ function resetConfig() {
 	delete storage[GLOBAL_INJECTOR_KEY];
 }
 //#endregion
-export { parseStyle as $, extractLocalCounterStyle as A, deprecationWarning as B, camelToKebab as C, Lru as Ct, getGlobalPredefinedStates as D, extractPredefinedStateRefs as E, formatFontFaceRule as F, DIRECTIONS as G, createStyle as H, hasLocalFontFace as I, getGlobalFuncs as J, customFunc as K, SheetManager as L, hasLocalCounterStyle as M, extractLocalFontFace as N, setGlobalPredefinedStates as O, fontFaceContentHash as P, parseColor as Q, STYLE_HANDLER_MAP as R, parseStateKey as S, strToRgb as St, extractLocalPredefinedStates as T, PropertyTypeResolver as U, warn as V, CUSTOM_UNITS as W, getGlobalPredefinedTokens as X, getGlobalParser as Y, normalizeColorTokenValue as Z, resetConfig as _, getComponentPropertySyntax as _t, getGlobalCounterStyle as a, StyleParser as at, isSelector as b, hexToRgb as bt, getGlobalKeyframes as c, hashString as ct, hasGlobalKeyframes as d, hasLocalProperties as dt, resetGlobalPredefinedTokens as et, hasGlobalRecipes as f, parsePropertyToken as ft, markStylesGenerated as g, getColorSpaceSuffix as gt, isTestEnvironment as h, getColorSpaceFunc as ht, getGlobalConfigTokens as i, okhslPlugin as it, formatCounterStyleRule as j, StyleInjector as k, getGlobalRecipes as l, extractLocalProperties as lt, isConfigLocked as m, getColorSpaceComponents as mt, getConfig as n, stringifyStyles as nt, getGlobalFontFace as o, Bucket as ot, hasStylesGenerated as p, colorInitialValueToComponents as pt, filterMods as q, getEffectiveProperties as r, okhslFunc as rt, getGlobalInjector as s, isDevEnv as st, configure as t, setGlobalPredefinedTokens as tt, getGlobalStyles as u, getEffectiveDefinition as ut, generateTypographyTokens as v, getNamedColorHex as vt, createStateParserContext as w, renderStyles as x, hslToRgbValues as xt, hasPipelineCacheEntry as y, getRgbValuesFromRgbaString as yt, styleHandlers as z };
+export { parseColor as $, StyleInjector as A, strToRgb as At, styleHandlers as B, parseStateKey as C, getColorSpaceFunc as Ct, extractPredefinedStateRefs as D, getRgbValuesFromRgbaString as Dt, extractLocalPredefinedStates as E, getNamedColorHex as Et, fontFaceContentHash as F, CUSTOM_UNITS as G, warn as H, formatFontFaceRule as I, filterMods as J, DIRECTIONS as K, hasLocalFontFace as L, formatCounterStyleRule as M, hasLocalCounterStyle as N, getGlobalPredefinedStates as O, hexToRgb as Ot, extractLocalFontFace as P, normalizeColorTokenValue as Q, SheetManager as R, renderStyles as S, getColorSpaceComponents as St, createStateParserContext as T, getComponentPropertySyntax as Tt, createStyle as U, deprecationWarning as V, PropertyTypeResolver as W, getGlobalParser as X, getGlobalFuncs as Y, getGlobalPredefinedTokens as Z, markStylesGenerated as _, extractLocalProperties as _t, getGlobalCounterStyle as a, okhslPlugin as at, hasPipelineCacheEntry as b, parsePropertyToken as bt, getGlobalKeyframes as c, DEFAULT_NAME_PREFIX as ct, getNamePrefix as d, makeCounterStyleName as dt, parseStyle as et, hasGlobalKeyframes as f, makeKeyframeName as ft, isTestEnvironment as g, hashString as gt, isConfigLocked as h, isDevEnv as ht, getGlobalConfigTokens as i, okhslFunc as it, extractLocalCounterStyle as j, Lru as jt, setGlobalPredefinedStates as k, hslToRgbValues as kt, getGlobalRecipes as l, DEFAULT_ZERO_NAME_PREFIX as lt, hasStylesGenerated as m, validateNamePrefix as mt, getConfig as n, setGlobalPredefinedTokens as nt, getGlobalFontFace as o, StyleParser as ot, hasGlobalRecipes as p, tastyClassRegex as pt, customFunc as q, getEffectiveProperties as r, stringifyStyles as rt, getGlobalInjector as s, Bucket as st, configure as t, resetGlobalPredefinedTokens as tt, getGlobalStyles as u, makeClassName as ut, resetConfig as v, getEffectiveDefinition as vt, camelToKebab as w, getColorSpaceSuffix as wt, isSelector as x, colorInitialValueToComponents as xt, generateTypographyTokens as y, hasLocalProperties as yt, STYLE_HANDLER_MAP as z };
 
-//# sourceMappingURL=config-CtJeETqW.js.map
+//# sourceMappingURL=config-BaxtQMS3.js.map