@tenphi/tasty 0.0.0-snapshot.167ce4e → 0.0.0-snapshot.17c4f74

package/dist/{config-raGoEeGs.js → config-BBiyxMCe.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";
@@ -1788,6 +1876,7 @@ function scan(src, cb) {
 //#endregion
 //#region src/parser/parser.ts
 var StyleParser = class {
+	opts;
 	cache;
 	constructor(opts = {}) {
 		this.opts = opts;
@@ -3234,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`:
@@ -3257,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 });
@@ -4129,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);
@@ -4281,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) {
@@ -4801,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 [];
@@ -4821,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);
 }
@@ -4836,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) {
@@ -4845,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) {
@@ -4857,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);
@@ -4894,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
@@ -4946,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++;
@@ -4955,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) {
@@ -5173,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();
@@ -5194,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.
@@ -5275,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: () => "",
@@ -5329,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.
@@ -5345,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;
@@ -5398,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;
@@ -6055,9 +6205,13 @@ function simplifyInner(node) {
 		return node;
 	}
 	if (node.kind === "compound") {
+		const key = getConditionUniqueId(node);
+		const cached = simplifyCache.get(key);
+		if (cached) return cached;
 		const simplifiedChildren = node.children.map((c) => simplifyInner(c));
-		if (node.operator === "AND") return simplifyAnd(simplifiedChildren);
-		else return simplifyOr(simplifiedChildren);
+		const result = node.operator === "AND" ? simplifyAnd(simplifiedChildren) : simplifyOr(simplifiedChildren);
+		simplifyCache.set(key, result);
+		return result;
 	}
 	return node;
 }
@@ -6075,13 +6229,23 @@ function simplifyAnd(children) {
 	if (hasRangeContradiction(terms)) return falseCondition();
 	if (hasAttributeConflict(terms)) return falseCondition();
 	if (hasContainerStyleConflict(terms)) return falseCondition();
-	terms = removeImpliedNegations(terms);
-	terms = deduplicateTerms(terms);
-	terms = mergeRanges(terms);
-	terms = sortTerms(terms);
-	terms = applyAbsorptionAnd(terms);
-	terms = applyConsensusAnd(terms);
-	terms = pruneContradictedOrBranches(terms);
+	const MAX_SIMPLIFY_PASSES = 4;
+	for (let pass = 0; pass < MAX_SIMPLIFY_PASSES; pass++) {
+		const lengthBefore = terms.length;
+		const keyBefore = simplifyTermsKey(terms);
+		terms = removeImpliedNegations(terms);
+		terms = deduplicateTerms(terms);
+		terms = mergeRanges(terms);
+		terms = sortTerms(terms);
+		terms = applyAbsorptionAnd(terms);
+		terms = applyConsensusAnd(terms);
+		terms = pruneContradictedOrBranches(terms);
+		if (terms.length === 0) break;
+		if (terms.length === 1) break;
+		if (hasContradiction(terms)) return falseCondition();
+		if (hasAttributeConflict(terms)) return falseCondition();
+		if (terms.length === lengthBefore && simplifyTermsKey(terms) === keyBefore) break;
+	}
 	if (terms.length === 0) return trueCondition();
 	if (terms.length === 1) return terms[0];
 	return {
@@ -6396,6 +6560,13 @@ function removeImpliedNegations(terms) {
 	const isImplied = buildImpliedNegationCheck(terms);
 	return terms.filter((t) => !isImplied(t));
 }
+/**
+* Build a stable, order-insensitive key for a list of AND terms.
+* Used to detect fixpoint convergence in `simplifyAnd`.
+*/
+function simplifyTermsKey(terms) {
+	return terms.map((t) => getConditionUniqueId(t)).sort().join("&");
+}
 function deduplicateTerms(terms) {
 	const seen = /* @__PURE__ */ new Set();
 	const result = [];
@@ -6778,1061 +6949,677 @@ function pruneContradictedOrBranches(terms) {
 	return flattened;
 }
 //#endregion
-//#region src/pipeline/exclusive.ts
+//#region src/pipeline/materialize-contradictions.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
+* Generic deduplication by a key extraction function.
+* Preserves insertion order, keeping the first occurrence of each key.
 */
-function buildExclusiveConditions(entries) {
+function dedupeByKey(items, getKey) {
+	const seen = /* @__PURE__ */ new Set();
 	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);
+	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}`);
+}
 /**
-* 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)
+* Check if supports conditions contain contradictions
+* e.g., @supports(display: grid) AND NOT @supports(display: grid)
 */
-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;
+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;
 }
 /**
-* 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.
+* 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)
 *
-* Example: `{ '@dark': 'red', '@dark & @hc': 'red' }` merges into a
-* single entry with condition `@dark | (@dark & @hc)` = `@dark`.
+* Uses parsed media conditions for efficient analysis without regex parsing.
+*/
+function hasMediaContradiction(conditions) {
+	const featureConditions = /* @__PURE__ */ new Map();
+	const typeConditions = /* @__PURE__ */ new Map();
+	const dimensionConditions = /* @__PURE__ */ new Map();
+	const dimensionsByDim = /* @__PURE__ */ new Map();
+	for (const cond of conditions) if (cond.subtype === "type") {
+		const key = cond.mediaType || "all";
+		const existing = typeConditions.get(key);
+		if (existing !== void 0 && existing !== !cond.negated) return true;
+		typeConditions.set(key, !cond.negated);
+	} else if (cond.subtype === "feature") {
+		const key = cond.condition;
+		const existing = featureConditions.get(key);
+		if (existing !== void 0 && existing !== !cond.negated) return true;
+		featureConditions.set(key, !cond.negated);
+	} else if (cond.subtype === "dimension") {
+		const condKey = cond.condition;
+		const existing = dimensionConditions.get(condKey);
+		if (existing !== void 0 && existing !== !cond.negated) return true;
+		dimensionConditions.set(condKey, !cond.negated);
+		if (!cond.negated) {
+			const dim = cond.dimension || "width";
+			let bounds = dimensionsByDim.get(dim);
+			if (!bounds) {
+				bounds = {
+					lowerBound: null,
+					upperBound: null
+				};
+				dimensionsByDim.set(dim, bounds);
+			}
+			if (cond.lowerBound?.valueNumeric != null) {
+				const value = cond.lowerBound.valueNumeric;
+				if (bounds.lowerBound === null || value > bounds.lowerBound) bounds.lowerBound = value;
+			}
+			if (cond.upperBound?.valueNumeric != null) {
+				const value = cond.upperBound.valueNumeric;
+				if (bounds.upperBound === null || value < bounds.upperBound) bounds.upperBound = value;
+			}
+			if (bounds.lowerBound !== null && bounds.upperBound !== null && bounds.lowerBound >= bounds.upperBound) return true;
+		}
+	}
+	return false;
+}
+/**
+* Check if container conditions contain contradictions in style queries
+* e.g., style(--variant: danger) and style(--variant: success) together
+* Same property with different values = always false
 *
-* Entries are ordered highest-priority-first. The merged entry keeps the
-* highest priority of the group.
+* Uses parsed container conditions for efficient analysis without regex parsing.
 */
-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
+function hasContainerStyleContradiction(conditions) {
+	const styleQueries = /* @__PURE__ */ new Map();
+	for (const cond of conditions) {
+		if (cond.subtype !== "style" || !cond.property) continue;
+		const property = cond.property;
+		const value = cond.propertyValue;
+		if (!styleQueries.has(property)) styleQueries.set(property, {
+			hasExistence: false,
+			values: /* @__PURE__ */ new Set(),
+			hasNegatedExistence: false
 		});
+		const entry = styleQueries.get(property);
+		if (cond.negated) {
+			if (value === void 0) entry.hasNegatedExistence = true;
+		} else if (value === void 0) entry.hasExistence = true;
+		else entry.values.add(value);
 	}
-	if (groups.size === entries.length) return entries;
-	const merged = [];
-	for (const [, group] of groups) {
-		if (group.entries.length === 1) {
-			merged.push(group.entries[0]);
-			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
-			});
-		}
+	for (const [, entry] of styleQueries) {
+		if (entry.hasExistence && entry.hasNegatedExistence) return true;
+		if (entry.values.size > 1) return true;
+		if (entry.hasNegatedExistence && entry.values.size > 0) return true;
 	}
-	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);
+	return false;
 }
+//#endregion
+//#region src/pipeline/materialize.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.
+* CSS Materialization
 *
-* @example
-*   { '': A, '@dark': B, '@hc': A, '@dark & @hc': B }
-*   // @hc is redundant → { '': A, '@dark': B }
+* Converts condition trees into CSS selectors and at-rules.
+* This is the final stage that produces actual CSS output.
 */
-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;
+const conditionCache = new Lru(3e3);
+/**
+* Convert a condition tree to CSS components
+*/
+function conditionToCSS(node) {
+	const key = getConditionUniqueId(node);
+	const cached = conditionCache.get(key);
+	if (cached) return cached;
+	const result = conditionToCSSInner(node);
+	conditionCache.set(key, result);
+	return result;
+}
+function emptyVariant() {
+	return {
+		modifierConditions: [],
+		pseudoConditions: [],
+		selectorGroups: [],
+		ownGroups: [],
+		mediaConditions: [],
+		containerConditions: [],
+		supportsConditions: [],
+		rootGroups: [],
+		parentGroups: [],
+		startingStyle: false
+	};
+}
+function conditionToCSSInner(node) {
+	if (node.kind === "true") return {
+		variants: [emptyVariant()],
+		isImpossible: false
+	};
+	if (node.kind === "false") return {
+		variants: [],
+		isImpossible: true
+	};
+	if (node.kind === "state") return stateToCSS(node);
+	if (node.kind === "compound") if (node.operator === "AND") return andToCSS(node.children);
+	else return orToCSS(node.children);
+	return {
+		variants: [emptyVariant()],
+		isImpossible: false
+	};
 }
 /**
-* 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).
+* Convert a state condition to CSS
 */
-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;
+function stateToCSS(state) {
+	switch (state.type) {
+		case "media": return {
+			variants: mediaToParsed(state).map((mediaCond) => {
+				const v = emptyVariant();
+				v.mediaConditions.push(mediaCond);
+				return v;
+			}),
+			isImpossible: false
+		};
+		case "root": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "rootGroups");
+		case "parent": return parentConditionToVariants(state.innerCondition, state.negated ?? false, state.direct);
+		case "own": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "ownGroups");
+		case "modifier": {
+			const v = emptyVariant();
+			v.modifierConditions.push(modifierToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "pseudo": {
+			const v = emptyVariant();
+			v.pseudoConditions.push(pseudoToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "container": {
+			const v = emptyVariant();
+			v.containerConditions.push(containerToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "supports": {
+			const v = emptyVariant();
+			v.supportsConditions.push(supportsToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "starting": {
+			const v = emptyVariant();
+			v.startingStyle = !state.negated;
+			return {
+				variants: [v],
+				isImpossible: false
+			};
 		}
-		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.
+* Convert modifier condition to parsed structure
 */
-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;
+function modifierToParsed(state) {
+	return {
+		attribute: state.attribute,
+		value: state.value,
+		operator: state.operator,
+		negated: state.negated ?? false
+	};
 }
 /**
-* Check if a value is a style value mapping (object with state keys)
+* Convert parsed modifier to CSS selector string (for final output)
 */
-function isValueMapping(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+function modifierToCSS(mod) {
+	let selector;
+	if (mod.value !== void 0) {
+		const op = mod.operator || "=";
+		selector = `[${mod.attribute}${op}"${mod.value}"]`;
+	} else selector = `[${mod.attribute}]`;
+	if (mod.negated) return `:not(${selector})`;
+	return selector;
 }
 /**
-* 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
+* Convert pseudo condition to parsed structure
 */
-function expandOrConditions(entries) {
-	const result = [];
-	for (const entry of entries) {
-		const expanded = expandSingleEntry(entry);
-		result.push(...expanded);
-	}
-	return result;
+function pseudoToParsed(state) {
+	return {
+		pseudo: state.pseudo,
+		negated: state.negated ?? false
+	};
 }
 /**
-* Expand a single entry's OR condition into multiple exclusive entries.
+* Convert parsed pseudo to CSS selector string (for final output).
 *
-* 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.
+* :not() is normalized to negated :is() at parse time, so pseudo.pseudo
+* never starts with ':not(' here. When negated:
+* - :is(X) → :not(X)     (unwrap :is)
+* - :where(X) → :not(X)  (unwrap :where)
+* - :has(X) → :not(:has(X))
+* - other → :not(other)
+*
+* When not negated, single-argument :is()/:where() is unwrapped when the
+* inner content is a simple compound selector that can safely append to
+* the base selector (this happens after double-negation of :not()).
 */
-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);
+function pseudoToCSS(pseudo) {
+	const p = pseudo.pseudo;
+	if (pseudo.negated) {
+		if (p.startsWith(":is(") || p.startsWith(":where(")) return `:not(${p.slice(p.indexOf("(") + 1, -1)})`;
+		return `:not(${p})`;
 	}
-	return result;
+	if ((p.startsWith(":is(") || p.startsWith(":where(")) && !p.includes(",")) {
+		const inner = p.slice(p.indexOf("(") + 1, -1);
+		const ch = inner[0];
+		if ((ch === ":" || ch === "." || ch === "[" || ch === "#") && !/\s/.test(inner)) return inner;
+	}
+	return p;
 }
 /**
-* 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]
+* Convert media condition to parsed structure(s)
+* Returns an array because negated ranges produce OR branches (two separate conditions)
 */
-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];
+function mediaToParsed(state) {
+	if (state.subtype === "type") {
+		const mediaType = state.mediaType || "all";
+		return [{
+			subtype: "type",
+			negated: state.negated ?? false,
+			condition: mediaType,
+			mediaType: state.mediaType
+		}];
+	} else if (state.subtype === "feature") {
+		let condition;
+		if (state.featureValue) condition = `(${state.feature}: ${state.featureValue})`;
+		else condition = `(${state.feature})`;
+		return [{
+			subtype: "feature",
+			negated: state.negated ?? false,
+			condition,
+			feature: state.feature,
+			featureValue: state.featureValue
+		}];
+	} else return dimensionToMediaParsed(state.dimension || "width", state.lowerBound, state.upperBound, state.negated ?? false);
 }
 /**
-* 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!)
+* Convert dimension bounds to parsed media condition(s)
+* Uses CSS Media Queries Level 4 `not (condition)` syntax for negation.
 */
-function expandExclusiveOrs(entries) {
-	const result = [];
-	for (const entry of entries) {
-		const expanded = expandExclusiveConditionOrs(entry);
-		result.push(...expanded);
-	}
-	return result;
+function dimensionToMediaParsed(dimension, lowerBound, upperBound, negated) {
+	let condition;
+	if (lowerBound && upperBound) {
+		const lowerOp = lowerBound.inclusive ? "<=" : "<";
+		const upperOp = upperBound.inclusive ? "<=" : "<";
+		condition = `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;
+	} else if (upperBound) condition = `(${dimension} ${upperBound.inclusive ? "<=" : "<"} ${upperBound.value})`;
+	else if (lowerBound) condition = `(${dimension} ${lowerBound.inclusive ? ">=" : ">"} ${lowerBound.value})`;
+	else condition = `(${dimension})`;
+	return [{
+		subtype: "dimension",
+		negated: negated ?? false,
+		condition,
+		dimension,
+		lowerBound,
+		upperBound
+	}];
 }
 /**
-* Check if a condition involves at-rules (media, container, supports, starting)
+* Convert container condition to parsed structure
+* This enables structured analysis for contradiction detection and condition combining
 */
-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;
+function containerToParsed(state) {
+	let condition;
+	if (state.subtype === "style") if (state.propertyValue) condition = `style(--${state.property}: ${state.propertyValue})`;
+	else condition = `style(--${state.property})`;
+	else if (state.subtype === "raw") condition = state.rawCondition;
+	else condition = dimensionToContainerCondition(state.dimension || "width", state.lowerBound, state.upperBound);
+	return {
+		name: state.containerName,
+		condition,
+		negated: state.negated ?? false,
+		subtype: state.subtype,
+		property: state.property,
+		propertyValue: state.propertyValue
+	};
 }
 /**
-* 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)
+* Convert dimension bounds to container query condition (single string)
+* Container queries support "not (condition)", so no need to invert manually
 */
-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;
-	});
+function dimensionToContainerCondition(dimension, lowerBound, upperBound) {
+	if (lowerBound && upperBound) {
+		const lowerOp = lowerBound.inclusive ? "<=" : "<";
+		const upperOp = upperBound.inclusive ? "<=" : "<";
+		return `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;
+	} else if (upperBound) return `(${dimension} ${upperBound.inclusive ? "<=" : "<"} ${upperBound.value})`;
+	else if (lowerBound) return `(${dimension} ${lowerBound.inclusive ? ">=" : ">"} ${lowerBound.value})`;
+	return "(width)";
 }
 /**
-* Expand ORs in a single entry's exclusive condition
+* Convert supports condition to parsed structure
 */
-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;
+function supportsToParsed(state) {
+	return {
+		subtype: state.subtype,
+		condition: state.condition,
+		negated: state.negated ?? false
+	};
 }
-//#endregion
-//#region src/pipeline/materialize-contradictions.ts
 /**
-* Generic deduplication by a key extraction function.
-* Preserves insertion order, keeping the first occurrence of each key.
+* Collect all modifier and pseudo conditions from a variant as a flat array.
 */
-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}`);
+function collectSelectorConditions(variant) {
+	return [...variant.modifierConditions, ...variant.pseudoConditions];
 }
 /**
-* Check if supports conditions contain contradictions
-* e.g., @supports(display: grid) AND NOT @supports(display: grid)
+* Convert an inner condition tree into a single SelectorVariant with
+* one SelectorGroup whose branches represent the inner OR alternatives.
+* Shared by @root() and @own().
+*
+* Both positive and negated cases produce one variant with one group.
+* Negation simply sets the `negated` flag, which swaps :is() for :not()
+* in the final CSS output — no De Morgan transformation is needed.
+*
+* This mirrors parentConditionToVariants: OR branches are kept inside
+* a single group and rendered as comma-separated arguments in
+* :is()/:not(), e.g. :root:is([a], [b]) or [el]:not([a], [b]).
 */
-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);
+function innerConditionToVariants(innerCondition, negated, target) {
+	const innerCSS = conditionToCSS(innerCondition);
+	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
+		variants: [],
+		isImpossible: true
+	};
+	const branches = [];
+	for (const innerVariant of innerCSS.variants) {
+		const conditions = collectSelectorConditions(innerVariant);
+		if (conditions.length > 0) branches.push(conditions);
 	}
-	return false;
+	if (branches.length === 0) return {
+		variants: [emptyVariant()],
+		isImpossible: false
+	};
+	const v = emptyVariant();
+	v[target].push({
+		branches,
+		negated
+	});
+	return {
+		variants: [v],
+		isImpossible: 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)
+* Convert a @parent() inner condition into a single SelectorVariant with
+* one ParentGroup whose branches represent the inner OR alternatives.
 *
-* Uses parsed media conditions for efficient analysis without regex parsing.
+* Both positive and negated cases produce one variant with one group.
+* Negation simply sets the `negated` flag, which swaps :is() for :not()
+* in the final CSS output — no structural transformation is needed.
 */
-function hasMediaContradiction(conditions) {
-	const featureConditions = /* @__PURE__ */ new Map();
-	const typeConditions = /* @__PURE__ */ new Map();
-	const dimensionConditions = /* @__PURE__ */ new Map();
-	const dimensionsByDim = /* @__PURE__ */ new Map();
-	for (const cond of conditions) if (cond.subtype === "type") {
-		const key = cond.mediaType || "all";
-		const existing = typeConditions.get(key);
-		if (existing !== void 0 && existing !== !cond.negated) return true;
-		typeConditions.set(key, !cond.negated);
-	} else if (cond.subtype === "feature") {
-		const key = cond.condition;
-		const existing = featureConditions.get(key);
-		if (existing !== void 0 && existing !== !cond.negated) return true;
-		featureConditions.set(key, !cond.negated);
-	} else if (cond.subtype === "dimension") {
-		const condKey = cond.condition;
-		const existing = dimensionConditions.get(condKey);
-		if (existing !== void 0 && existing !== !cond.negated) return true;
-		dimensionConditions.set(condKey, !cond.negated);
-		if (!cond.negated) {
-			const dim = cond.dimension || "width";
-			let bounds = dimensionsByDim.get(dim);
-			if (!bounds) {
-				bounds = {
-					lowerBound: null,
-					upperBound: null
-				};
-				dimensionsByDim.set(dim, bounds);
-			}
-			if (cond.lowerBound?.valueNumeric != null) {
-				const value = cond.lowerBound.valueNumeric;
-				if (bounds.lowerBound === null || value > bounds.lowerBound) bounds.lowerBound = value;
-			}
-			if (cond.upperBound?.valueNumeric != null) {
-				const value = cond.upperBound.valueNumeric;
-				if (bounds.upperBound === null || value < bounds.upperBound) bounds.upperBound = value;
-			}
-			if (bounds.lowerBound !== null && bounds.upperBound !== null && bounds.lowerBound >= bounds.upperBound) return true;
-		}
-	}
-	return false;
-}
-/**
-* Check if container conditions contain contradictions in style queries
-* e.g., style(--variant: danger) and style(--variant: success) together
-* Same property with different values = always false
-*
-* Uses parsed container conditions for efficient analysis without regex parsing.
-*/
-function hasContainerStyleContradiction(conditions) {
-	const styleQueries = /* @__PURE__ */ new Map();
-	for (const cond of conditions) {
-		if (cond.subtype !== "style" || !cond.property) continue;
-		const property = cond.property;
-		const value = cond.propertyValue;
-		if (!styleQueries.has(property)) styleQueries.set(property, {
-			hasExistence: false,
-			values: /* @__PURE__ */ new Set(),
-			hasNegatedExistence: false
-		});
-		const entry = styleQueries.get(property);
-		if (cond.negated) {
-			if (value === void 0) entry.hasNegatedExistence = true;
-		} else if (value === void 0) entry.hasExistence = true;
-		else entry.values.add(value);
-	}
-	for (const [, entry] of styleQueries) {
-		if (entry.hasExistence && entry.hasNegatedExistence) return true;
-		if (entry.values.size > 1) return true;
-		if (entry.hasNegatedExistence && entry.values.size > 0) return true;
-	}
-	return false;
-}
-//#endregion
-//#region src/pipeline/materialize.ts
-/**
-* CSS Materialization
-*
-* Converts condition trees into CSS selectors and at-rules.
-* This is the final stage that produces actual CSS output.
-*/
-const conditionCache = new Lru(3e3);
-/**
-* Convert a condition tree to CSS components
-*/
-function conditionToCSS(node) {
-	const key = getConditionUniqueId(node);
-	const cached = conditionCache.get(key);
-	if (cached) return cached;
-	const result = conditionToCSSInner(node);
-	conditionCache.set(key, result);
-	return result;
-}
-function emptyVariant() {
-	return {
-		modifierConditions: [],
-		pseudoConditions: [],
-		selectorGroups: [],
-		ownGroups: [],
-		mediaConditions: [],
-		containerConditions: [],
-		supportsConditions: [],
-		rootGroups: [],
-		parentGroups: [],
-		startingStyle: false
+function parentConditionToVariants(innerCondition, negated, direct) {
+	const innerCSS = conditionToCSS(innerCondition);
+	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
+		variants: [],
+		isImpossible: true
 	};
-}
-function conditionToCSSInner(node) {
-	if (node.kind === "true") return {
+	const branches = [];
+	for (const innerVariant of innerCSS.variants) {
+		const conditions = collectSelectorConditions(innerVariant);
+		if (conditions.length > 0) branches.push(conditions);
+	}
+	if (branches.length === 0) return {
 		variants: [emptyVariant()],
 		isImpossible: false
 	};
-	if (node.kind === "false") return {
-		variants: [],
-		isImpossible: true
-	};
-	if (node.kind === "state") return stateToCSS(node);
-	if (node.kind === "compound") if (node.operator === "AND") return andToCSS(node.children);
-	else return orToCSS(node.children);
+	const v = emptyVariant();
+	v.parentGroups.push({
+		branches,
+		direct,
+		negated
+	});
 	return {
-		variants: [emptyVariant()],
+		variants: [v],
 		isImpossible: false
 	};
 }
 /**
-* Convert a state condition to CSS
+* Sort key for canonical condition output within selectors.
+*
+* Priority order:
+* 0: Boolean attribute selectors ([data-hovered])
+* 1: Value attribute selectors ([data-size="small"])
+* 2: Negated boolean attributes (:not([data-disabled]))
+* 3: Negated value attributes (:not([data-size="small"]))
+* 4: Pseudo-classes (:hover, :focus)
+* 5: Negated pseudo-classes (:not(:disabled))
+*
+* Secondary sort: alphabetical by attribute name / pseudo string.
 */
-function stateToCSS(state) {
-	switch (state.type) {
-		case "media": return {
-			variants: mediaToParsed(state).map((mediaCond) => {
-				const v = emptyVariant();
-				v.mediaConditions.push(mediaCond);
-				return v;
-			}),
-			isImpossible: false
-		};
-		case "root": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "rootGroups");
-		case "parent": return parentConditionToVariants(state.innerCondition, state.negated ?? false, state.direct);
-		case "own": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "ownGroups");
-		case "modifier": {
-			const v = emptyVariant();
-			v.modifierConditions.push(modifierToParsed(state));
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
-		case "pseudo": {
-			const v = emptyVariant();
-			v.pseudoConditions.push(pseudoToParsed(state));
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
-		case "container": {
-			const v = emptyVariant();
-			v.containerConditions.push(containerToParsed(state));
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
-		case "supports": {
-			const v = emptyVariant();
-			v.supportsConditions.push(supportsToParsed(state));
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
-		case "starting": {
-			const v = emptyVariant();
-			v.startingStyle = !state.negated;
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
+function conditionSortKey(cond) {
+	if ("attribute" in cond) {
+		const hasValue = cond.value !== void 0 ? 1 : 0;
+		return `${(cond.negated ? 2 : 0) + hasValue}|${cond.attribute}|${cond.value ?? ""}`;
 	}
+	return `${cond.negated ? 5 : 4}|${cond.pseudo}`;
+}
+function sortConditions(conditions) {
+	return conditions.toSorted((a, b) => conditionSortKey(a).localeCompare(conditionSortKey(b)));
+}
+function branchToCSS(branch) {
+	let parts = "";
+	for (const cond of sortConditions(branch)) parts += selectorConditionToCSS(cond);
+	return parts;
 }
 /**
-* Convert modifier condition to parsed structure
+* Wrap serialized selector arguments in :is() or :not().
+* Arguments are sorted for canonical output.
 */
-function modifierToParsed(state) {
-	return {
-		attribute: state.attribute,
-		value: state.value,
-		operator: state.operator,
-		negated: state.negated ?? false
-	};
+function wrapInIsOrNot(args, negated) {
+	return `${negated ? ":not" : ":is"}(${args.sort().join(", ")})`;
 }
 /**
-* Convert parsed modifier to CSS selector string (for final output)
+* Convert a selector group to a CSS selector fragment.
+*
+* Single-branch groups are unwrapped (no :is() wrapper).
+* Multi-branch groups use :is() or :not().
+* Negation swaps :is() for :not().
 */
-function modifierToCSS(mod) {
-	let selector;
-	if (mod.value !== void 0) {
-		const op = mod.operator || "=";
-		selector = `[${mod.attribute}${op}"${mod.value}"]`;
-	} else selector = `[${mod.attribute}]`;
-	if (mod.negated) return `:not(${selector})`;
-	return selector;
+function selectorGroupToCSS(group) {
+	if (group.branches.length === 0) return "";
+	if (group.branches.length === 1) {
+		const parts = branchToCSS(group.branches[0]);
+		if (group.negated) return `:not(${parts})`;
+		return parts;
+	}
+	return wrapInIsOrNot(group.branches.map(branchToCSS), group.negated);
 }
 /**
-* Convert pseudo condition to parsed structure
+* Collect facts about modifier conditions for subsumption analysis.
+* Tracks negated boolean attrs (:not([attr])) and positive exact values ([attr="X"]).
 */
-function pseudoToParsed(state) {
+function collectSubsumptionFacts(modifiers) {
+	const negatedBooleanAttrs = /* @__PURE__ */ new Set();
+	const positiveExactValuesByAttr = /* @__PURE__ */ new Map();
+	for (const mod of modifiers) {
+		if (mod.negated && mod.value === void 0) negatedBooleanAttrs.add(mod.attribute);
+		if (!mod.negated && mod.value !== void 0 && (mod.operator ?? "=") === "=") {
+			let vals = positiveExactValuesByAttr.get(mod.attribute);
+			if (!vals) {
+				vals = /* @__PURE__ */ new Set();
+				positiveExactValuesByAttr.set(mod.attribute, vals);
+			}
+			vals.add(mod.value);
+		}
+	}
 	return {
-		pseudo: state.pseudo,
-		negated: state.negated ?? false
+		negatedBooleanAttrs,
+		positiveExactValuesByAttr
 	};
 }
 /**
-* Convert parsed pseudo to CSS selector string (for final output).
-*
-* :not() is normalized to negated :is() at parse time, so pseudo.pseudo
-* never starts with ':not(' here. When negated:
-* - :is(X) → :not(X)     (unwrap :is)
-* - :where(X) → :not(X)  (unwrap :where)
-* - :has(X) → :not(:has(X))
-* - other → :not(other)
+* Check if a negated-value modifier is subsumed by stronger facts:
+* - :not([attr]) subsumes :not([attr="val"])
+* - [attr="X"] implies :not([attr="Y"]) is redundant (single exact value)
 *
-* When not negated, single-argument :is()/:where() is unwrapped when the
-* inner content is a simple compound selector that can safely append to
-* the base selector (this happens after double-negation of :not()).
+* Only applies to exact-match (=) operators; substring operators don't
+* imply exclusivity between values.
 */
-function pseudoToCSS(pseudo) {
-	const p = pseudo.pseudo;
-	if (pseudo.negated) {
-		if (p.startsWith(":is(") || p.startsWith(":where(")) return `:not(${p.slice(p.indexOf("(") + 1, -1)})`;
-		return `:not(${p})`;
+function isSubsumedNegatedModifier(mod, facts) {
+	if (!mod.negated || mod.value === void 0) return false;
+	if (facts.negatedBooleanAttrs.has(mod.attribute)) return true;
+	if ((mod.operator ?? "=") === "=") {
+		const posVals = facts.positiveExactValuesByAttr.get(mod.attribute);
+		if (posVals && posVals.size === 1 && !posVals.has(mod.value)) return true;
 	}
-	if ((p.startsWith(":is(") || p.startsWith(":where(")) && !p.includes(",")) {
-		const inner = p.slice(p.indexOf("(") + 1, -1);
-		const ch = inner[0];
-		if ((ch === ":" || ch === "." || ch === "[" || ch === "#") && !/\s/.test(inner)) return inner;
+	return false;
+}
+/**
+* Remove redundant single-condition groups that are subsumed by stronger
+* groups on the same attribute. O(n) — only inspects single-branch,
+* single-condition groups.
+*/
+function optimizeGroups(groups) {
+	if (groups.length <= 1) return groups;
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const g of groups) {
+		const key = getSelectorGroupKey(g);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(g);
+		}
 	}
-	return p;
+	if (result.length <= 1) return result;
+	const effectiveModifiers = [];
+	for (const g of result) {
+		if (g.branches.length !== 1 || g.branches[0].length !== 1) continue;
+		const cond = g.branches[0][0];
+		if (!("attribute" in cond)) continue;
+		effectiveModifiers.push({
+			...cond,
+			negated: g.negated !== cond.negated
+		});
+	}
+	const facts = collectSubsumptionFacts(effectiveModifiers);
+	if (facts.negatedBooleanAttrs.size === 0 && facts.positiveExactValuesByAttr.size === 0) return result;
+	return result.filter((g) => {
+		if (g.branches.length !== 1 || g.branches[0].length !== 1) return true;
+		const cond = g.branches[0][0];
+		if (!("attribute" in cond) || !g.negated || cond.negated || cond.value === void 0) return true;
+		return !isSubsumedNegatedModifier({
+			...cond,
+			negated: true
+		}, facts);
+	});
 }
 /**
-* Convert media condition to parsed structure(s)
-* Returns an array because negated ranges produce OR branches (two separate conditions)
+* Convert root groups to CSS selector prefix (for final output)
 */
-function mediaToParsed(state) {
-	if (state.subtype === "type") {
-		const mediaType = state.mediaType || "all";
-		return [{
-			subtype: "type",
-			negated: state.negated ?? false,
-			condition: mediaType,
-			mediaType: state.mediaType
-		}];
-	} else if (state.subtype === "feature") {
-		let condition;
-		if (state.featureValue) condition = `(${state.feature}: ${state.featureValue})`;
-		else condition = `(${state.feature})`;
-		return [{
-			subtype: "feature",
-			negated: state.negated ?? false,
-			condition,
-			feature: state.feature,
-			featureValue: state.featureValue
-		}];
-	} else return dimensionToMediaParsed(state.dimension || "width", state.lowerBound, state.upperBound, state.negated ?? false);
+function rootGroupsToCSS(groups) {
+	if (groups.length === 0) return void 0;
+	const optimized = optimizeGroups(groups);
+	if (optimized.length === 0) return void 0;
+	let prefix = ":root";
+	for (const group of optimized) prefix += selectorGroupToCSS(group);
+	return prefix;
 }
 /**
-* Convert dimension bounds to parsed media condition(s)
-* Uses CSS Media Queries Level 4 `not (condition)` syntax for negation.
+* Convert parent groups to CSS selector fragments (for final output).
+* Each group produces its own :is()/:not() wrapper with a combinator
+* suffix (` *` or ` > *`) appended to each branch.
 */
-function dimensionToMediaParsed(dimension, lowerBound, upperBound, negated) {
-	let condition;
-	if (lowerBound && upperBound) {
-		const lowerOp = lowerBound.inclusive ? "<=" : "<";
-		const upperOp = upperBound.inclusive ? "<=" : "<";
-		condition = `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;
-	} else if (upperBound) condition = `(${dimension} ${upperBound.inclusive ? "<=" : "<"} ${upperBound.value})`;
-	else if (lowerBound) condition = `(${dimension} ${lowerBound.inclusive ? ">=" : ">"} ${lowerBound.value})`;
-	else condition = `(${dimension})`;
-	return [{
-		subtype: "dimension",
-		negated: negated ?? false,
-		condition,
-		dimension,
-		lowerBound,
-		upperBound
-	}];
+function parentGroupsToCSS(groups) {
+	let result = "";
+	for (const group of groups) {
+		const combinator = group.direct ? " > *" : " *";
+		const args = group.branches.map((branch) => branchToCSS(branch) + combinator);
+		result += wrapInIsOrNot(args, group.negated);
+	}
+	return result;
 }
 /**
-* Convert container condition to parsed structure
-* This enables structured analysis for contradiction detection and condition combining
+* Convert a modifier or pseudo condition to a CSS selector fragment
 */
-function containerToParsed(state) {
-	let condition;
-	if (state.subtype === "style") if (state.propertyValue) condition = `style(--${state.property}: ${state.propertyValue})`;
-	else condition = `style(--${state.property})`;
-	else if (state.subtype === "raw") condition = state.rawCondition;
-	else condition = dimensionToContainerCondition(state.dimension || "width", state.lowerBound, state.upperBound);
-	return {
-		name: state.containerName,
-		condition,
-		negated: state.negated ?? false,
-		subtype: state.subtype,
-		property: state.property,
-		propertyValue: state.propertyValue
-	};
+function selectorConditionToCSS(cond) {
+	if ("attribute" in cond) return modifierToCSS(cond);
+	return pseudoToCSS(cond);
 }
 /**
-* Convert dimension bounds to container query condition (single string)
-* Container queries support "not (condition)", so no need to invert manually
+* Get unique key for a modifier condition
 */
-function dimensionToContainerCondition(dimension, lowerBound, upperBound) {
-	if (lowerBound && upperBound) {
-		const lowerOp = lowerBound.inclusive ? "<=" : "<";
-		const upperOp = upperBound.inclusive ? "<=" : "<";
-		return `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;
-	} else if (upperBound) return `(${dimension} ${upperBound.inclusive ? "<=" : "<"} ${upperBound.value})`;
-	else if (lowerBound) return `(${dimension} ${lowerBound.inclusive ? ">=" : ">"} ${lowerBound.value})`;
-	return "(width)";
+function getModifierKey(mod) {
+	const base = mod.value ? `${mod.attribute}${mod.operator || "="}${mod.value}` : mod.attribute;
+	return mod.negated ? `!${base}` : base;
 }
 /**
-* Convert supports condition to parsed structure
+* Get unique key for a pseudo condition
 */
-function supportsToParsed(state) {
-	return {
-		subtype: state.subtype,
-		condition: state.condition,
-		negated: state.negated ?? false
-	};
+function getPseudoKey(pseudo) {
+	return pseudo.negated ? `!${pseudo.pseudo}` : pseudo.pseudo;
 }
 /**
-* Collect all modifier and pseudo conditions from a variant as a flat array.
+* Get unique key for any selector condition (modifier or pseudo)
 */
-function collectSelectorConditions(variant) {
-	return [...variant.modifierConditions, ...variant.pseudoConditions];
+function getSelectorConditionKey(cond) {
+	return "attribute" in cond ? `mod:${getModifierKey(cond)}` : `pseudo:${getPseudoKey(cond)}`;
 }
 /**
-* Convert an inner condition tree into a single SelectorVariant with
-* one SelectorGroup whose branches represent the inner OR alternatives.
-* Shared by @root() and @own().
-*
-* Both positive and negated cases produce one variant with one group.
-* Negation simply sets the `negated` flag, which swaps :is() for :not()
-* in the final CSS output — no De Morgan transformation is needed.
-*
-* This mirrors parentConditionToVariants: OR branches are kept inside
-* a single group and rendered as comma-separated arguments in
-* :is()/:not(), e.g. :root:is([a], [b]) or [el]:not([a], [b]).
+* Deduplicate selector conditions (modifiers or pseudos).
+* Shared by root, parent, and own conditions.
 */
-function innerConditionToVariants(innerCondition, negated, target) {
-	const innerCSS = conditionToCSS(innerCondition);
-	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
-		variants: [],
-		isImpossible: true
-	};
-	const branches = [];
-	for (const innerVariant of innerCSS.variants) {
-		const conditions = collectSelectorConditions(innerVariant);
-		if (conditions.length > 0) branches.push(conditions);
+function dedupeSelectorConditions(conditions) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const c of conditions) {
+		const key = getSelectorConditionKey(c);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(c);
+		}
 	}
-	if (branches.length === 0) return {
-		variants: [emptyVariant()],
-		isImpossible: false
-	};
-	const v = emptyVariant();
-	v[target].push({
-		branches,
-		negated
+	const facts = collectSubsumptionFacts(result.filter((c) => "attribute" in c));
+	if (facts.negatedBooleanAttrs.size === 0 && facts.positiveExactValuesByAttr.size === 0) return result;
+	return result.filter((c) => {
+		if (!("attribute" in c)) return true;
+		if (isSubsumedNegatedModifier(c, facts)) return false;
+		if (!c.negated && c.value === void 0 && facts.positiveExactValuesByAttr.has(c.attribute)) return false;
+		return true;
 	});
-	return {
-		variants: [v],
-		isImpossible: false
-	};
 }
 /**
-* Convert a @parent() inner condition into a single SelectorVariant with
-* one ParentGroup whose branches represent the inner OR alternatives.
-*
-* Both positive and negated cases produce one variant with one group.
-* Negation simply sets the `negated` flag, which swaps :is() for :not()
-* in the final CSS output — no structural transformation is needed.
+* Check for modifier contradiction: same attribute with opposite negation
 */
-function parentConditionToVariants(innerCondition, negated, direct) {
-	const innerCSS = conditionToCSS(innerCondition);
-	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
-		variants: [],
-		isImpossible: true
-	};
-	const branches = [];
-	for (const innerVariant of innerCSS.variants) {
-		const conditions = collectSelectorConditions(innerVariant);
-		if (conditions.length > 0) branches.push(conditions);
-	}
-	if (branches.length === 0) return {
-		variants: [emptyVariant()],
-		isImpossible: false
-	};
-	const v = emptyVariant();
-	v.parentGroups.push({
-		branches,
-		direct,
-		negated
-	});
-	return {
-		variants: [v],
-		isImpossible: false
-	};
-}
-/**
-* Sort key for canonical condition output within selectors.
-*
-* Priority order:
-* 0: Boolean attribute selectors ([data-hovered])
-* 1: Value attribute selectors ([data-size="small"])
-* 2: Negated boolean attributes (:not([data-disabled]))
-* 3: Negated value attributes (:not([data-size="small"]))
-* 4: Pseudo-classes (:hover, :focus)
-* 5: Negated pseudo-classes (:not(:disabled))
-*
-* Secondary sort: alphabetical by attribute name / pseudo string.
-*/
-function conditionSortKey(cond) {
-	if ("attribute" in cond) {
-		const hasValue = cond.value !== void 0 ? 1 : 0;
-		return `${(cond.negated ? 2 : 0) + hasValue}|${cond.attribute}|${cond.value ?? ""}`;
-	}
-	return `${cond.negated ? 5 : 4}|${cond.pseudo}`;
-}
-function sortConditions(conditions) {
-	return conditions.toSorted((a, b) => conditionSortKey(a).localeCompare(conditionSortKey(b)));
-}
-function branchToCSS(branch) {
-	let parts = "";
-	for (const cond of sortConditions(branch)) parts += selectorConditionToCSS(cond);
-	return parts;
-}
-/**
-* Wrap serialized selector arguments in :is() or :not().
-* Arguments are sorted for canonical output.
-*/
-function wrapInIsOrNot(args, negated) {
-	return `${negated ? ":not" : ":is"}(${args.sort().join(", ")})`;
-}
-/**
-* Convert a selector group to a CSS selector fragment.
-*
-* Single-branch groups are unwrapped (no :is() wrapper).
-* Multi-branch groups use :is() or :not().
-* Negation swaps :is() for :not().
-*/
-function selectorGroupToCSS(group) {
-	if (group.branches.length === 0) return "";
-	if (group.branches.length === 1) {
-		const parts = branchToCSS(group.branches[0]);
-		if (group.negated) return `:not(${parts})`;
-		return parts;
-	}
-	return wrapInIsOrNot(group.branches.map(branchToCSS), group.negated);
-}
-/**
-* Collect facts about modifier conditions for subsumption analysis.
-* Tracks negated boolean attrs (:not([attr])) and positive exact values ([attr="X"]).
-*/
-function collectSubsumptionFacts(modifiers) {
-	const negatedBooleanAttrs = /* @__PURE__ */ new Set();
-	const positiveExactValuesByAttr = /* @__PURE__ */ new Map();
-	for (const mod of modifiers) {
-		if (mod.negated && mod.value === void 0) negatedBooleanAttrs.add(mod.attribute);
-		if (!mod.negated && mod.value !== void 0 && (mod.operator ?? "=") === "=") {
-			let vals = positiveExactValuesByAttr.get(mod.attribute);
-			if (!vals) {
-				vals = /* @__PURE__ */ new Set();
-				positiveExactValuesByAttr.set(mod.attribute, vals);
-			}
-			vals.add(mod.value);
-		}
-	}
-	return {
-		negatedBooleanAttrs,
-		positiveExactValuesByAttr
-	};
-}
-/**
-* Check if a negated-value modifier is subsumed by stronger facts:
-* - :not([attr]) subsumes :not([attr="val"])
-* - [attr="X"] implies :not([attr="Y"]) is redundant (single exact value)
-*
-* Only applies to exact-match (=) operators; substring operators don't
-* imply exclusivity between values.
-*/
-function isSubsumedNegatedModifier(mod, facts) {
-	if (!mod.negated || mod.value === void 0) return false;
-	if (facts.negatedBooleanAttrs.has(mod.attribute)) return true;
-	if ((mod.operator ?? "=") === "=") {
-		const posVals = facts.positiveExactValuesByAttr.get(mod.attribute);
-		if (posVals && posVals.size === 1 && !posVals.has(mod.value)) return true;
-	}
-	return false;
-}
-/**
-* Remove redundant single-condition groups that are subsumed by stronger
-* groups on the same attribute. O(n) — only inspects single-branch,
-* single-condition groups.
-*/
-function optimizeGroups(groups) {
-	if (groups.length <= 1) return groups;
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const g of groups) {
-		const key = getSelectorGroupKey(g);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(g);
-		}
-	}
-	if (result.length <= 1) return result;
-	const effectiveModifiers = [];
-	for (const g of result) {
-		if (g.branches.length !== 1 || g.branches[0].length !== 1) continue;
-		const cond = g.branches[0][0];
-		if (!("attribute" in cond)) continue;
-		effectiveModifiers.push({
-			...cond,
-			negated: g.negated !== cond.negated
-		});
-	}
-	const facts = collectSubsumptionFacts(effectiveModifiers);
-	if (facts.negatedBooleanAttrs.size === 0 && facts.positiveExactValuesByAttr.size === 0) return result;
-	return result.filter((g) => {
-		if (g.branches.length !== 1 || g.branches[0].length !== 1) return true;
-		const cond = g.branches[0][0];
-		if (!("attribute" in cond) || !g.negated || cond.negated || cond.value === void 0) return true;
-		return !isSubsumedNegatedModifier({
-			...cond,
-			negated: true
-		}, facts);
-	});
-}
-/**
-* Convert root groups to CSS selector prefix (for final output)
-*/
-function rootGroupsToCSS(groups) {
-	if (groups.length === 0) return void 0;
-	const optimized = optimizeGroups(groups);
-	if (optimized.length === 0) return void 0;
-	let prefix = ":root";
-	for (const group of optimized) prefix += selectorGroupToCSS(group);
-	return prefix;
-}
-/**
-* Convert parent groups to CSS selector fragments (for final output).
-* Each group produces its own :is()/:not() wrapper with a combinator
-* suffix (` *` or ` > *`) appended to each branch.
-*/
-function parentGroupsToCSS(groups) {
-	let result = "";
-	for (const group of groups) {
-		const combinator = group.direct ? " > *" : " *";
-		const args = group.branches.map((branch) => branchToCSS(branch) + combinator);
-		result += wrapInIsOrNot(args, group.negated);
-	}
-	return result;
-}
-/**
-* Convert a modifier or pseudo condition to a CSS selector fragment
-*/
-function selectorConditionToCSS(cond) {
-	if ("attribute" in cond) return modifierToCSS(cond);
-	return pseudoToCSS(cond);
-}
-/**
-* Get unique key for a modifier condition
-*/
-function getModifierKey(mod) {
-	const base = mod.value ? `${mod.attribute}${mod.operator || "="}${mod.value}` : mod.attribute;
-	return mod.negated ? `!${base}` : base;
-}
-/**
-* Get unique key for a pseudo condition
-*/
-function getPseudoKey(pseudo) {
-	return pseudo.negated ? `!${pseudo.pseudo}` : pseudo.pseudo;
-}
-/**
-* Get unique key for any selector condition (modifier or pseudo)
-*/
-function getSelectorConditionKey(cond) {
-	return "attribute" in cond ? `mod:${getModifierKey(cond)}` : `pseudo:${getPseudoKey(cond)}`;
-}
-/**
-* Deduplicate selector conditions (modifiers or pseudos).
-* Shared by root, parent, and own conditions.
-*/
-function dedupeSelectorConditions(conditions) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const c of conditions) {
-		const key = getSelectorConditionKey(c);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(c);
-		}
-	}
-	const facts = collectSubsumptionFacts(result.filter((c) => "attribute" in c));
-	if (facts.negatedBooleanAttrs.size === 0 && facts.positiveExactValuesByAttr.size === 0) return result;
-	return result.filter((c) => {
-		if (!("attribute" in c)) return true;
-		if (isSubsumedNegatedModifier(c, facts)) return false;
-		if (!c.negated && c.value === void 0 && facts.positiveExactValuesByAttr.has(c.attribute)) return false;
-		return true;
-	});
-}
-/**
-* Check for modifier contradiction: same attribute with opposite negation
-*/
-function hasModifierContradiction(conditions) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const mod of conditions) {
-		const baseKey = mod.value ? `${mod.attribute}${mod.operator || "="}${mod.value}` : mod.attribute;
-		const existing = byKey.get(baseKey);
-		if (existing !== void 0 && existing !== !mod.negated) return true;
-		byKey.set(baseKey, !mod.negated);
+function hasModifierContradiction(conditions) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const mod of conditions) {
+		const baseKey = mod.value ? `${mod.attribute}${mod.operator || "="}${mod.value}` : mod.attribute;
+		const existing = byKey.get(baseKey);
+		if (existing !== void 0 && existing !== !mod.negated) return true;
+		byKey.set(baseKey, !mod.negated);
 	}
 	return false;
 }
@@ -8039,328 +7826,827 @@ function getParentGroupKey(g) {
 /**
 * Deduplicate variants
 *
-* Removes:
-* 1. Exact duplicates (same key)
-* 2. Superset variants (more restrictive selectors that are redundant)
+* Removes:
+* 1. Exact duplicates (same key)
+* 2. Superset variants (more restrictive selectors that are redundant)
+*/
+function dedupeVariants(variants) {
+	if (variants.length <= 1) return variants;
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const v of variants) {
+		const key = getVariantKey(v);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(v);
+		}
+	}
+	if (result.length <= 1) return result;
+	result.sort((a, b) => variantConditionCount(a) - variantConditionCount(b));
+	const filtered = [];
+	for (const candidate of result) {
+		let isRedundant = false;
+		for (const kept of filtered) if (isVariantSuperset(candidate, kept)) {
+			isRedundant = true;
+			break;
+		}
+		if (!isRedundant) filtered.push(candidate);
+	}
+	return filtered;
+}
+/**
+* Combine AND conditions into CSS
+*
+* AND of conditions means cartesian product of variants:
+* (A1 | A2) & (B1 | B2) = A1&B1 | A1&B2 | A2&B1 | A2&B2
+*
+* Variants that result in contradictions (e.g., conflicting media rules)
+* are filtered out.
+*/
+function andToCSS(children) {
+	const exclusiveChildren = makeOrBranchesExclusive(children);
+	let currentVariants = [emptyVariant()];
+	for (const child of exclusiveChildren) {
+		const childCSS = conditionToCSSInner(child);
+		if (childCSS.isImpossible || childCSS.variants.length === 0) return {
+			variants: [],
+			isImpossible: true
+		};
+		const newVariants = [];
+		for (const current of currentVariants) for (const childVariant of childCSS.variants) {
+			const merged = mergeVariants(current, childVariant);
+			if (merged !== null) newVariants.push(merged);
+		}
+		if (newVariants.length === 0) return {
+			variants: [],
+			isImpossible: true
+		};
+		currentVariants = dedupeVariants(newVariants);
+	}
+	return {
+		variants: currentVariants,
+		isImpossible: false
+	};
+}
+/**
+* Make OR branches within AND children mutually exclusive.
+*
+* For an AND child that is OR(A, B), transforms it to OR(A, B & !A)
+* so that when andToCSS does a Cartesian product, the resulting
+* CSS variants don't overlap.
+*
+* Only transforms OR children whose branches actually produce
+* different at-rule contexts when materialized. This avoids
+* breaking cases where contradiction detection in the Cartesian
+* product naturally handles deduplication.
+*/
+function makeOrBranchesExclusive(children) {
+	return children.map((child) => {
+		if (!isCompoundCondition(child) || child.operator !== "OR") return child;
+		if (child.children.length <= 1) return child;
+		if (!branchesProduceDifferentContexts(child.children)) return child;
+		const exclusiveBranches = [];
+		const priorBranches = [];
+		for (const branch of child.children) {
+			if (priorBranches.length === 0) exclusiveBranches.push(branch);
+			else {
+				let exclusive = branch;
+				for (const prior of priorBranches) exclusive = and(exclusive, not(prior));
+				const simplified = simplifyCondition(exclusive);
+				if (simplified.kind !== "false") exclusiveBranches.push(simplified);
+			}
+			priorBranches.push(branch);
+		}
+		if (exclusiveBranches.length === 0) return child;
+		if (exclusiveBranches.length === 1) return exclusiveBranches[0];
+		return {
+			kind: "compound",
+			operator: "OR",
+			children: exclusiveBranches
+		};
+	});
+}
+/**
+* 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();
+	for (const branch of branches) {
+		const css = conditionToCSSInner(branch);
+		if (css.isImpossible) continue;
+		for (const v of css.variants) contextKeys.add(getVariantContextKey(v));
+	}
+	return contextKeys.size > 1;
+}
+/**
+* Combine OR conditions into CSS
+*
+* OR in CSS means multiple selector variants (DNF).
+* 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.
+*/
+/**
+* Serialize a single negated own-element selector leaf (modifier or pseudo)
+* to its *positive* selector string, for use inside a combined `:not(...)`.
+*
+* Returns `null` when the node is not a negated, own-element selector leaf
+* (e.g. positive, or a media/container/parent/root/own/supports/starting
+* wrapper, or a compound), which means it cannot participate in De Morgan
+* recombination.
+*/
+function negatedSelectorLeafToPositiveSelector(node) {
+	if (node.kind !== "state" || !node.negated) return null;
+	if (node.type === "modifier") return modifierToCSS({
+		attribute: node.attribute,
+		value: node.value,
+		operator: node.operator,
+		negated: false
+	});
+	if (node.type === "pseudo") {
+		const p = node.pseudo;
+		if ((p.startsWith(":is(") || p.startsWith(":where(")) && !p.includes(",")) {
+			const inner = p.slice(p.indexOf("(") + 1, -1);
+			if (!/\s/.test(inner)) return inner;
+			return `:is(${inner})`;
+		}
+		return p;
+	}
+	return null;
+}
+/**
+* De Morgan recombination for an OR whose every branch is a negated
+* own-element selector leaf:
+*
+*   OR(¬a, ¬b, ¬c)  ≡  ¬(a ∧ b ∧ c)  →  single `:not(a b c)`
+*
+* This keeps the catch-all/default exclusive condition (which has no
+* positive terms to prune against) from exploding into a Cartesian product
+* of OR branches at `andToCSS`. Returns `null` when recombination does not
+* apply, so genuine unions (e.g. `:hover | :focus`) fall through to the
+* normal per-branch materialization.
+*/
+function tryRecombineNegatedSelectorOr(children) {
+	if (children.length < 2) return null;
+	const positiveSelectors = [];
+	for (const child of children) {
+		const sel = negatedSelectorLeafToPositiveSelector(child);
+		if (sel === null) return null;
+		positiveSelectors.push(sel);
+	}
+	positiveSelectors.sort();
+	const compound = positiveSelectors.join("");
+	const v = emptyVariant();
+	v.pseudoConditions.push({
+		pseudo: `:is(${compound})`,
+		negated: true
+	});
+	return {
+		variants: [v],
+		isImpossible: false
+	};
+}
+function orToCSS(children) {
+	const recombined = tryRecombineNegatedSelectorOr(children);
+	if (recombined !== null) return recombined;
+	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") continue;
+			if (entry.condition.kind !== "true" && simplifyCondition(and(entry.condition, prior)).kind === "false") continue;
+			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 dedupeVariants(variants) {
-	if (variants.length <= 1) return variants;
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const v of variants) {
-		const key = getVariantKey(v);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(v);
+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;
 		}
-	}
-	if (result.length <= 1) return result;
-	result.sort((a, b) => variantConditionCount(a) - variantConditionCount(b));
-	const filtered = [];
-	for (const candidate of result) {
-		let isRedundant = false;
-		for (const kept of filtered) if (isVariantSuperset(candidate, kept)) {
-			isRedundant = true;
-			break;
+		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 (!isRedundant) filtered.push(candidate);
+		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 filtered;
+	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);
 }
 /**
-* Combine AND conditions into CSS
+* Eliminate redundant state dimensions from a value map.
 *
-* AND of conditions means cartesian product of variants:
-* (A1 | A2) & (B1 | B2) = A1&B1 | A1&B2 | A2&B1 | A2&B2
+* 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.
 *
-* Variants that result in contradictions (e.g., conflicting media rules)
-* are filtered out.
+* 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 andToCSS(children) {
-	const exclusiveChildren = makeOrBranchesExclusive(children);
-	let currentVariants = [emptyVariant()];
-	for (const child of exclusiveChildren) {
-		const childCSS = conditionToCSSInner(child);
-		if (childCSS.isImpossible || childCSS.variants.length === 0) return {
-			variants: [],
-			isImpossible: true
-		};
-		const newVariants = [];
-		for (const current of currentVariants) for (const childVariant of childCSS.variants) {
-			const merged = mergeVariants(current, childVariant);
-			if (merged !== null) newVariants.push(merged);
-		}
-		if (newVariants.length === 0) return {
-			variants: [],
-			isImpossible: true
+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]
 		};
-		currentVariants = dedupeVariants(newVariants);
+	});
+	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 {
-		variants: currentVariants,
-		isImpossible: false
-	};
+	return newMap;
 }
 /**
-* Make OR branches within AND children mutually exclusive.
-*
-* For an AND child that is OR(A, B), transforms it to OR(A, B & !A)
-* so that when andToCSS does a Cartesian product, the resulting
-* CSS variants don't overlap.
+* Split a state key by top-level `&` operators.
 *
-* Only transforms OR children whose branches actually produce
-* different at-rule contexts when materialized. This avoids
-* breaking cases where contradiction detection in the Cartesian
-* product naturally handles deduplication.
+* 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 makeOrBranchesExclusive(children) {
-	return children.map((child) => {
-		if (!isCompoundCondition(child) || child.operator !== "OR") return child;
-		if (child.children.length <= 1) return child;
-		if (!branchesProduceDifferentContexts(child.children)) return child;
-		const exclusiveBranches = [];
-		const priorBranches = [];
-		for (const branch of child.children) {
-			if (priorBranches.length === 0) exclusiveBranches.push(branch);
-			else {
-				let exclusive = branch;
-				for (const prior of priorBranches) exclusive = and(exclusive, not(prior));
-				const simplified = simplifyCondition(exclusive);
-				if (simplified.kind !== "false") exclusiveBranches.push(simplified);
+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;
 			}
-			priorBranches.push(branch);
+			if (ch === "|" || ch === "^" || ch === ",") return null;
 		}
-		if (exclusiveBranches.length === 0) return child;
-		if (exclusiveBranches.length === 1) return exclusiveBranches[0];
-		return {
-			kind: "compound",
-			operator: "OR",
-			children: exclusiveBranches
-		};
-	});
+		current += ch;
+	}
+	const trimmed = current.trim();
+	if (trimmed) parts.push(trimmed);
+	return parts;
 }
 /**
-* 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.
+* An atom is redundant when every entry that contains it has a matching
+* partner (same remaining atoms, atom absent) with the same value.
 */
-function branchesProduceDifferentContexts(branches) {
-	const contextKeys = /* @__PURE__ */ new Set();
-	for (const branch of branches) {
-		const css = conditionToCSSInner(branch);
-		if (css.isImpossible) continue;
-		for (const v of css.variants) contextKeys.add(getVariantContextKey(v));
+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 contextKeys.size > 1;
+	return true;
 }
 /**
-* Combine OR conditions into CSS
+* 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.
 *
-* OR in CSS means multiple selector variants (DNF).
-* After deduplication, variants that differ only in their base
-* modifier/pseudo conditions are merged into :is() groups.
+* For an entry with condition `A | B | C`, this creates 3 entries:
+*   - condition: A
+*   - condition: B & !A
+*   - condition: C & !A & !B
 *
-* 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.
+* 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 orToCSS(children) {
-	const allVariants = [];
-	for (const child of children) {
-		const childCSS = conditionToCSSInner(child);
-		if (childCSS.isImpossible) continue;
-		allVariants.push(...childCSS.variants);
+function expandOrConditions(entries) {
+	const result = [];
+	for (const entry of entries) {
+		const expanded = expandSingleEntry(entry);
+		result.push(...expanded);
 	}
-	if (allVariants.length === 0) return {
-		variants: [],
-		isImpossible: true
-	};
-	return {
-		variants: dedupeVariants(allVariants),
-		isImpossible: false
-	};
+	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 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);
+	}
+	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.
-*
-* Precondition: all variants must share the same context key (identical
-* at-rules, root/parent/own/selector groups, startingStyle).
+* Check if a condition involves at-rules (media, container, supports, starting)
 */
-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
-	};
+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;
 }
 /**
-* Detect when branches form a complete Cartesian product of independent
-* modifier attribute dimensions and return one SelectorGroup per dimension.
+* Sort OR branches to prioritize at-rule conditions first.
 *
-* Example: 4 branches for 2 attributes × 2 values each →
-*   :is(A1, A2):is(B1, B2)  instead of  :is(A1B1, A1B2, A2B1, A2B2)
+* 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 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
-	}));
+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.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 ")}`);
+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
@@ -8427,6 +8713,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.
@@ -8619,7 +8914,15 @@ var Parser = class {
 			return createPseudoCondition(value, false, value);
 		}
 		if (value.startsWith(".")) return createPseudoCondition(value, false, value);
-		if (value.startsWith("[")) return createPseudoCondition(value, false, value);
+		if (value.startsWith("[")) {
+			const attrMatch = /^\[\s*([a-zA-Z_][\w-]*)\s*(?:(=|\^=|\$=|\*=)\s*(?:"([^"]*)"|'([^']*)'|([^\]\s]+)))?\s*\]$/.exec(value);
+			if (attrMatch) {
+				const [, attribute, operator, dq, sq, bare] = attrMatch;
+				if (operator === void 0) return createModifierCondition(attribute, void 0, "=", false, value);
+				return createModifierCondition(attribute, dq ?? sq ?? bare, operator, false, value);
+			}
+			return createPseudoCondition(value, false, value);
+		}
 		if (value.includes("=")) return this.parseValueModifier(value);
 		return this.parseBooleanModifier(value);
 	}
@@ -8844,6 +9147,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;
@@ -8913,7 +9224,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);
 }
@@ -9796,7 +10115,8 @@ function createDefaultConfig(isTest) {
 	return {
 		maxRulesPerSheet: 8192,
 		forceTextInjection: isTest ?? false,
-		devMode: isDevEnv()
+		devMode: isDevEnv(),
+		namePrefix: "t"
 	};
 }
 /**
@@ -10038,6 +10358,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 = {};
@@ -10189,6 +10510,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.
 */
@@ -10222,6 +10554,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-raGoEeGs.js.map
+//# sourceMappingURL=config-BBiyxMCe.js.map