@animus-ui/system 0.1.11 → 0.1.13

package/dist/conditions.d.ts

@@ -1,147 +1,67 @@
 /**
- * Condition alias registry — maps `_`-prefixed alias keys to at-rule condition
- * strings (`@media` / `@container` / `@supports`). Parallel in shape to the
- * selector alias registry (`selectors.ts`): alias → `{ value, order, kind }`.
- *
- * `order` determines cascade precedence within a layer (aliased conditions emit
- * in registry order, per design D4). `kind` is inferred from the at-rule prefix
- * of `value` (design D3) and drives which at-rule the extractor wraps the block
- * in. Serialized into the manifest as the NEW `conditionAliases` field, leaving
- * `selectorAliases` byte-for-byte unchanged.
- *
- * This module hosts BOTH the runtime registry and the authoring TYPE surface
- * (inc 04): the augmentable `Conditions`/`Selectors` publication, the
- * `ConditionsOf`/`SelectorsOf` extractors, the branded rejection types
- * (`UnknownConditionAlias`/`UnknownAtRule`, plus the cross-registry
- * `ReservedBySelectorRegistry`/`ReservedByConditionRegistry`), and the shallow
- * `RawAtRuleKey` shapes consumed by `ThemedCSSProps`' kind-dispatched arms.
- * `addConditions()` constrains values to `AtRuleValue` at the type level;
- * `inferConditionKind` remains the runtime fail-loud check.
+ * Condition alias registry: `_`-prefixed alias keys → at-rule condition
+ * strings, plus the authoring type surface consumers augment.
  */
-/** The three condition kinds, inferred from the at-rule prefix of the value. */
 export type ConditionKind = 'media' | 'container' | 'supports';
 /**
- * Augmentable registry of registered condition alias keys. Empty by default;
- * a consumer publishes its registrations with:
- *
- * ```ts
- * declare module '@animus-ui/system' {
- *   interface Conditions extends Record<ConditionsOf<typeof ds>, true> {}
- * }
- * ```
- *
- * When this interface is empty (no publication), `ThemedCSSProps` keeps
- * `_`-prefixed block keys permissive — the same graceful degradation the
- * augmentable `Theme` uses (empty theme ⇒ raw CSS values). Once populated, the
- * validating arms engage: unknown `_` keys resolve to `UnknownConditionAlias`.
- *
- * JOINT NAMESPACE (inc-04 F8/F9): condition and selector aliases share the one
- * `_` block-key namespace, so publishing EITHER `Conditions` OR `Selectors`
- * flips BOTH namespaces from permissive to validating (see `KnownUnderscoreKey`
- * in `types/config.ts`, whose gate reads `keyof Conditions | keyof Selectors`).
- *
- * Built-in condition aliases (`BUILT_IN_CONDITIONS`, design D8) are NOT members
- * of this interface — they live in the static `BuiltInConditionAlias` union
- * (`types/config.ts`), mirroring `BuiltInSelectorAlias`. Defaulting members here
- * would make publication permanently non-empty and destroy the degradation
- * contract above (a non-augmenting consumer with custom aliases would flip from
- * permissive to branded-rejection the day built-ins shipped).
+ * Augmentable registry of registered condition alias keys. Empty keeps `_`
+ * block keys permissive; publishing either registry validates both.
  */
 export interface Conditions {
 }
 declare const CONDS_BRAND: unique symbol;
 declare const SELS_BRAND: unique symbol;
 /**
- * Phantom brand carried on `build()`'s system output, threading the accumulated
- * registered condition (`C`) and custom selector (`S`) alias-key unions to the
- * consumer's augmentation site. Type-only — never present at runtime.
+ * Type-only phantom brand on a built system, carrying the registered
+ * condition (`C`) and selector (`S`) alias keys to the augmentation site.
  */
 export interface RegistryBrand<C extends string = never, S extends string = never> {
     readonly [CONDS_BRAND]?: C;
     readonly [SELS_BRAND]?: S;
 }
-/** Extract the registered condition alias keys from a built system. */
 export type ConditionsOf<Sys> = Sys extends RegistryBrand<infer C, string> ? C : never;
-/** Extract the registered custom selector alias keys from a built system. */
 export type SelectorsOf<Sys> = Sys extends RegistryBrand<string, infer S> ? S : never;
 /**
- * Branded rejection for a `_`-prefixed block key that is neither a registered
- * condition alias, a registered selector alias, a built-in selector alias,
- * nor a built-in condition alias.
- * The type name carries the offending key; the `hint` states the remedy. Never
- * a bare `never` arm — `never` produces a misleading "not assignable to
- * 'undefined'" (design D9, measured).
+ * Branded rejection for a `_` block key that no registry owns. Not a bare
+ * `never`: that reports a misleading "not assignable to 'undefined'".
  */
 export interface UnknownConditionAlias<K extends string> {
     readonly __unknownConditionAlias: K;
     readonly hint: `"${K}" is not a registered condition or selector alias. Register it with .addConditions() / .addSelectors(), or use a raw "&…" selector or "@media|@container|@supports (…)" key.`;
 }
-/**
- * Branded rejection for an `@`-prefixed block key that does not match an
- * accepted at-rule shape (`@media …` / `@container …` / `@supports …`). The
- * type name carries the offending key; the `hint` states the remedy.
- */
 export interface UnknownAtRule<K extends string> {
     readonly __unknownAtRule: K;
     readonly hint: `"${K}" is not a valid at-rule block key. At-rule keys must begin with "@media ", "@container ", or "@supports " followed by a parenthesized/feature tail.`;
 }
 /**
- * Branded rejection for an `addConditions()` key already owned by the SELECTOR
- * registry — a built-in (`BuiltInSelectorAlias`) or one registered earlier in
- * the chain. A name resolves through exactly one registry; the runtime throw in
- * `mergeConditions` is this type's fail-loud backstop.
- *
- * The rejecting arm must be a real type, never a bare `never`: in VALUE
- * position a `never` arm makes inference for the whole record fall back to the
- * constraint, dropping BOTH the check and the literal key accumulation — the
- * gate silently becomes a no-op.
- *
- * The static `BuiltInSelectorAlias`/`BuiltInConditionAlias` unions must stay in
- * sync with `BUILT_IN_SELECTORS`/`BUILT_IN_CONDITIONS` (25 and 9 entries today)
- * or this compile-time gate and the construction-time throw disagree.
+ * Rejection for an `addConditions()` key the selector registry owns. Never a
+ * bare `never`: in VALUE position it drops both the check and accumulation.
  */
 export interface ReservedBySelectorRegistry<K extends string> {
     readonly __reservedBySelectorRegistry: K;
     readonly hint: `"${K}" is already a selector alias — condition and selector alias names must be disjoint. Rename this condition alias, or redefine the selector with .addSelectors().`;
 }
-/**
- * Branded rejection for an `addSelectors()` key already owned by the CONDITION
- * registry — a built-in (`BuiltInConditionAlias`) or one registered earlier in
- * the chain. Mirror of `ReservedBySelectorRegistry`; the runtime throw in
- * `addSelectors` is the backstop.
- */
 export interface ReservedByConditionRegistry<K extends string> {
     readonly __reservedByConditionRegistry: K;
     readonly hint: `"${K}" is already a condition alias — condition and selector alias names must be disjoint. Rename this selector alias, or redefine the condition with .addConditions().`;
 }
 /**
- * The alias NAMES carried by a registered union, or `never` once that union has
- * widened to the whole `_` pattern. Registering a non-literal record
- * (`Record<`_${string}`, …>`) widens the phantom `Conds`/`Sels` union to
- * `` `_${string}` ``; a gate that subtracted it verbatim would then match every
- * subsequent key and reject legal aliases with a misleading brand. A widened
- * registration must not poison the opposite-registry gate — it goes quiet and
- * the construction-time throw stays the backstop for the names the type layer
- * can no longer enumerate. Built-ins are subtracted separately and are
- * unaffected.
+ * Alias names, or `never` once the union has widened to the whole `_`
+ * pattern — a widened union would reject every legal alias downstream.
  */
 export type NarrowedAliases<U extends string> = `_${string}` extends U ? never : U;
 /**
- * SHALLOW at-rule key shapes (design D9): prefix + tail only. Deep query-grammar
- * template literals are the repo's one known TS2589 zone (string-embedded
- * unions) and stay out — Rust validates queries for real; the type layer stops
- * at the prefix. The trailing space after each at-rule name is load-bearing: it
- * rejects prefix typos (`@containr …`, `@medi …`) without a closed grammar.
+ * Prefix + tail only: a deep query grammar hits TS2589. The trailing space
+ * is load-bearing — it rejects prefix typos (`@medi …`) without a grammar.
  */
 export type RawAtRuleKey = `@media ${string}` | `@container ${string}` | `@supports ${string}`;
 /**
- * The at-rule VALUE shape `addConditions()` accepts. Same prefix-only principle
- * as `RawAtRuleKey`, minus its trailing space — a value may open its query
+ * No trailing space, unlike `RawAtRuleKey`: a value may open its query
  * immediately (`@media(width>=40em)`).
  */
 export type AtRuleValue = `@media${string}` | `@container${string}` | `@supports${string}`;
 export interface ConditionAlias {
-    /** Full at-rule condition string, e.g. `@media (prefers-reduced-motion: reduce)`. */
+    /** Full at-rule condition string, e.g. `@media print`. */
     value: string;
     /** Sort index for cascade ordering within a layer. */
     order: number;
@@ -150,61 +70,24 @@ export interface ConditionAlias {
 }
 export type ConditionAliasMap = Record<string, ConditionAlias>;
 /**
- * Built-in condition aliases (design D8, increment 06).
- *
- * The Panda-compatible media-feature set: motion, print, orientation, contrast,
- * and OS color-scheme preferences. Every alias is a pure `@media` feature query
- * (`kind: 'media'`). Color-mode aliases (`_dark` / `_light`) are DELIBERATELY
- * excluded — they are selector-kind (`[data-color-mode]`) surface owned by the
- * `system-color-scheme` change, not media features.
- *
- * ORDER BAND (inc-03 full-pass): built-ins occupy a reserved band BELOW the user
- * band — one slot of 10 per alias in table row order, 300–380. The user band
- * starts at 500 (`mergeConditions` floors allocation at 490 → first user alias
- * is 500), so built-ins and user registrations never interleave on collision.
- * This mirrors the selector registry's real layout (built-ins 10–440, users
- * 500+).
- *
- * The static type-level mirror is `BuiltInConditionAlias` in `types/config.ts`
- * (added to `KnownUnderscoreKey`'s VALIDATING branch, exactly like
- * `BuiltInSelectorAlias`). Built-ins are NOT members of the augmentable
- * `Conditions` interface: interface members would make publication permanently
- * non-empty, killing inc-04's graceful-degradation contract. The
- * `types.test-d.tsx` drift positives keep the two in sync.
+ * Media-feature aliases only — color-mode aliases are selector-kind. The
+ * reserved order band (300–380) sits below the user band (500+).
  */
 export declare const BUILT_IN_CONDITIONS: ConditionAliasMap;
 /**
- * Infer the condition kind from an at-rule value's prefix (design D3).
- * Throws (fail-loud, build time) when the value does not begin with a
- * supported at-rule name. The compile-time complement is `addConditions()`'s
- * value constraint (`@media`/`@container`/`@supports`-prefixed template
- * literals); this runtime throw remains the backstop for untyped callers.
+ * Throws on an unsupported prefix — the runtime backstop for untyped
+ * callers, complementing `addConditions()`'s value constraint.
  */
 export declare function inferConditionKind(value: string): ConditionKind;
 /**
- * Merge user-provided condition aliases with a base map.
- *
- * - User aliases override built-ins of the same name, preserving the existing
- *   order (mirrors `mergeSelectors`).
- * - New aliases allocate orders CONTINUING from the highest existing order
- *   (floored at 490, so the first user alias lands at 500) rather than
- *   restarting at 500 each call — chained `.addConditions()` calls must not
- *   collide on order 500.
- * - Fails loud when a condition alias name is already reserved by the SELECTOR
- *   alias registry (`reservedSelectorNames`): the two registries share the `_`
- *   namespace at the call site and their names MUST be disjoint, else a block
- *   key would be ambiguous. The error names the offending alias and both
- *   registries.
+ * Overrides keep the existing order; new aliases continue past the highest
+ * existing order (floor 490) so chained calls never collide on 500.
  */
 export declare function mergeConditions(base: ConditionAliasMap, custom: Record<string, string>, reservedSelectorNames?: ReadonlySet<string>): ConditionAliasMap;
-/** Get the sorted alias keys for deterministic cascade ordering. */
 export declare function getSortedConditionKeys(map: ConditionAliasMap): string[];
 /**
- * Serialize the condition map for the extraction pipeline.
- * Emits `alias → { value, order, kind }` in registry (cascade) order so the
- * JSON is deterministic. Distinct in SHAPE from the selector map (which
- * flattens to `alias → selector`) — the object entry is forward-compatible
- * with a future multi-valued `values: string[]` property (design D3).
+ * Emits `alias → { value, order, kind }` in cascade order so the JSON is
+ * deterministic.
  */
 export declare function serializeConditionMap(map: ConditionAliasMap): Record<string, ConditionAlias>;
 export {};

package/dist/conditions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../src/conditions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../src/conditions.ts"],"names":[],"mappings":"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"}

package/dist/{createClassResolver-BWyEQ5KZ.js → createClassResolver-EpwTL9Sa.js}

@@ -1,48 +1,8 @@
 import { isUnitlessProperty } from "@animus-ui/properties";
 //#region src/runtime/is-dev.ts
 /**
-* The runtime's dev-build signal, shared by every development-only path
-* (drop diagnostic, reachability witness). Several hosts have to be satisfied
-* at once, and they force this exact shape:
-*
-* - **Bundles built through an Animus plugin.** `__ANIMUS_DEV__` is a
-*   build-time define supplied by the Vite plugin's `config` hook and by the
-*   Next plugin's DefinePlugin entry, each keyed on its bundler's own
-*   dev/build signal. It is tested FIRST, and as the CONDITIONAL OF THE
-*   INITIALIZER ITSELF — not as an early return inside the IIFE below. That
-*   distinction is the whole point: define-replacement turns the test into
-*   `typeof false === 'boolean'`, and only in this position does the
-*   production minifier propagate the resulting constant into every `IS_DEV`
-*   reference, so the gated branches and their diagnostic strings leave the
-*   bundle entirely. Hidden inside the IIFE, the same guard collapses to a
-*   variable the minifier keeps, and every diagnostic string ships. Never
-*   "tidy" this ternary into the fallback.
-* - **Browser bundles without the define.** `process.env.NODE_ENV` is a define
-*   token that Vite and Next rewrite to a string literal; `typeof process` is
-*   not rewritten by anything, so guarding the token with it strands every dev
-*   branch in a browser (no `process` global → the conjunction is false in dev
-*   too). The token must therefore be read bare.
-* - **Next under Turbopack.** The Next plugin supplies the define from its
-*   `webpack()` hook, and a Turbopack-active run never calls that hook (the
-*   Turbopack path wires rules and aliases instead), so those builds carry no
-*   token and land on the `process.env.NODE_ENV` fallback below — correct
-*   answer, no elimination.
-* - **QuickJS (the Rust system-loader).** It evaluates the system dist with no
-*   define pass and no `process`, so the `typeof` test is simply false and the
-*   bare read then throws ReferenceError at module scope — caught here, and
-*   not-dev is the correct answer for a loader that only reads config.
-*   `import.meta` is unavailable there (a script-context eval makes it a syntax
-*   error), so it is never used.
-* - **Node (SSR, tests).** Reads the real `process.env.NODE_ENV`.
-*
-* Evaluated once, at module load: in every host the answer is fixed for the
-* lifetime of the bundle.
-*
-* The define is the sanctioned foldable path, and the only one. The try/catch
-* fallback is deliberately NOT foldable — a host that supplies no token keeps
-* its (gated-off, never-executed) diagnostic strings, which is the accepted
-* price of a diagnostic that actually fires in a browser dev build. Restore
-* elimination by supplying the define from a bundler plugin.
+* The define token is tested as the initializer's own conditional, never from
+* inside the fallback: only there can a minifier drop the dev-gated code.
 */
 const IS_DEV = typeof __ANIMUS_DEV__ === "boolean" ? __ANIMUS_DEV__ : (() => {
 	try {
@@ -54,14 +14,6 @@ const IS_DEV = typeof __ANIMUS_DEV__ === "boolean" ? __ANIMUS_DEV__ : (() => {
 })();
 //#endregion
 //#region src/runtime/witness.ts
-/**
-* Dev-mode reachability witness: records every class-resolution outcome into a
-* bounded in-page ring buffer at globalThis.__ANIMUS_WITNESS__. Development
-* only — a production build records nothing and never creates the handle
-* (IS_DEV is false). See is-dev.ts for the define/fold story and which hosts
-* eliminate this code rather than merely gate it off. The handle name is the
-* greppable exclusion token.
-*/
 const WITNESS_CAP = 5e3;
 function recordWitness(component, prop, value, outcome) {
 	if (!IS_DEV) return;
@@ -78,15 +30,8 @@ function recordWitness(component, prop, value, outcome) {
 //#endregion
 //#region src/runtime/resolveClasses.ts
 /**
-* Apply unit fallback to a value for the CSS properties the value lands on.
-* `isUnitlessProperty` owns the spelling question, so either convention works.
-*
-* A mixed property set resolves to unitless: an unsuffixed number on a length
-* property is dropped by the CSS parser, whereas `px` on a unitless property
-* renders and silently changes layout — prefer the drop.
-*
-* An empty property list keeps the unconditional `px` — configs emitted before
-* `property` was carried name no property at all.
+* A mixed property set resolves to unitless: a bare number on a length
+* property is dropped by the parser, `px` on a unitless one shifts layout.
 */
 function applyUnitFallback(value, cssProperties) {
 	if (typeof value === "number") {
@@ -96,29 +41,20 @@ function applyUnitFallback(value, cssProperties) {
 	return String(value);
 }
 /**
-* Serialize a system prop value to a lookup key matching the Rust
-* css_generator's serialize_value_key output format.
+* The key format is fixed by the Rust css generator; a divergence here misses
+* every static class lookup.
 */
 function serializeValueKey(value) {
 	if (typeof value === "number" || typeof value === "string") return String(value);
 	if (typeof value === "object" && value !== null && !Array.isArray(value)) return Object.keys(value).sort().map((k) => `${k}:${value[k]}`).join("|");
 	return String(value);
 }
-/**
-* Validity predicate for transform results (design D5): only strings and
-* finite numbers may reach the stylesheet. The gate applies solely where a
-* configured transform ran — scale hits without a transform are exempt.
-*/
 function isValidTransformResult(result) {
 	return typeof result === "string" || typeof result === "number" && Number.isFinite(result);
 }
 /**
-* Shape descriptor for an invalid transform result, shared by the drop
-* warning and its tests. `null` and arrays are named before `typeof` would
-* fold them into `object`; non-finite numbers get their own name because
-* finite ones are valid. Precondition: callers pass only results that failed
-* `isValidTransformResult` — valid strings/finite numbers are out of domain
-* and would be mislabeled.
+* The domain is results that failed `isValidTransformResult`; a valid string
+* or finite number passed here is mislabeled.
 */
 function describeResultShape(result) {
 	if (result === null) return "null";
@@ -126,11 +62,6 @@ function describeResultShape(result) {
 	if (typeof result === "number") return "non-finite-number";
 	return typeof result;
 }
-/**
-* Resolve one entry through scale lookup → transform → unit fallback,
-* validating the transform result in both the scale-resolved and raw arms.
-* An invalid result yields its shape descriptor instead of a string.
-*/
 function resolveEntry(value, dc) {
 	const key = String(value);
 	const scaleResolved = dc.scaleValues?.[key];
@@ -154,10 +85,8 @@ function warnDroppedValue(baseClassName, propName, serializedValue) {
 	}
 }
 /**
-* Apply variant classes in declaration order, recording a static witness per
-* resolved variant. When a value comes from a defaultVariant fallback (prop not
-* passed), emit --{prop}-default instead of --{prop}-{value} so the compose
-* override rule cannot match, allowing inheritance from the parent to win.
+* A value taken from a variant default emits `--{prop}-default`, not the
+* value, so the compose override rule misses and the parent's value wins.
 */
 function applyVariantClasses(classes, baseClassName, props, config) {
 	if (!config.variants) return;
@@ -170,10 +99,6 @@ function applyVariantClasses(classes, baseClassName, props, config) {
 		}
 	}
 }
-/**
-* Apply compound classes: push each compound's className when every condition
-* matches (against the prop value or its variant default). No witness records.
-*/
 function applyCompoundClasses(classes, props, config) {
 	if (!config.compounds) return;
 	for (const compound of config.compounds) {
@@ -188,10 +113,6 @@ function applyCompoundClasses(classes, props, config) {
 		if (match) classes.push(compound.className);
 	}
 }
-/**
-* Apply state classes and track active states for data-attribute passthrough,
-* recording a static witness per active state.
-*/
 function applyStateClasses(classes, baseClassName, props, config, activeStates) {
 	if (!config.states) return;
 	for (const state of config.states) if (props[state]) {
@@ -210,18 +131,8 @@ function warnInvalidTransformResult(baseClassName, propName, shape) {
 	}
 }
 /**
-* Expand a resolved dynamic prop into slot classes and CSS-variable style
-* entries. Responsive objects expand per breakpoint: the `_` base breakpoint
-* uses the bare slotClass and varName; named breakpoints suffix both
-* (`${slotClass}-${bp}` and `${varName}-${bp}`). Scalar values push the bare
-* slotClass and set varName directly.
-*
-* Two-phase so the drop is atomic: every entry resolves into a staging list
-* before any mutation. One invalid transform result anywhere — the scalar, or
-* any single breakpoint — returns that failure (first offending shape) with
-* `classes` and `dynStyle` untouched. On success the staged entries apply in
-* the pre-existing push order and the function returns `null`; the caller
-* records the witness from the outcome.
+* Resolution is staged so a drop is atomic: one invalid transform result
+* anywhere leaves `classes` and `dynStyle` untouched.
 */
 function applyDynamicProp(classes, dynStyle, propValue, dc) {
 	const staged = [];
@@ -254,10 +165,6 @@ function applyDynamicProp(classes, dynStyle, propValue, dc) {
 	}
 	return null;
 }
-/**
-* Resolve className parts from props, using extracted configuration.
-* This is the shared logic between createComponent and createClassResolver.
-*/
 function resolveClasses(baseClassName, props, config, systemPropMap, dynamicPropConfig) {
 	const classes = [baseClassName];
 	let dynStyle;
@@ -304,14 +211,6 @@ function resolveClasses(baseClassName, props, config, systemPropMap, dynamicProp
 }
 //#endregion
 //#region src/runtime/createClassResolver.ts
-/**
-* createClassResolver — framework-agnostic className resolution.
-*
-* Produced by .asClass() terminal. Same resolution logic as createComponent
-* (variants, states, compounds, system props). The resolver remains callable
-* as a className string function and also exposes framework-neutral attributes
-* for renderers that need dynamic CSS-variable styles.
-*/
 function serializeDynamicStyle(style) {
 	return Object.entries(style).map(([property, value]) => `${property}: ${value}`).join("; ");
 }

package/dist/{createComposedFamily-k5tTujGI.js → createComposedFamily-C4NovMcd.js}

@@ -1,11 +1,10 @@
-import { n as resolveClasses } from "./createClassResolver-BWyEQ5KZ.js";
-import { t as assertRootSlot } from "./assert-root-slot-B73sDJ1Q.js";
+import { n as resolveClasses } from "./createClassResolver-EpwTL9Sa.js";
+import { t as assertRootSlot } from "./assert-root-slot-C3Lp9MNJ.js";
 import { Children, cloneElement, createElement, forwardRef, isValidElement } from "react";
 //#region src/runtime/index.ts
 /**
-* Merge multiple refs (callback or object) into a single callback ref.
-* Creates a new callback on each call — no memoization possible in a
-* hook-free runtime (RSC compatibility). Matches @radix-ui/react-compose-refs.
+* A new callback on every call: the runtime stays hook-free so components
+* work in server components, which rules memoization out.
 */
 function composeRefs(...refs) {
 	return (node) => {
@@ -14,16 +13,8 @@ function composeRefs(...refs) {
 	};
 }
 /**
-* Forward props to the underlying element, filtering out Animus-managed props.
-*
-* data-* and aria-* attributes always pass through to the DOM, even when used
-* as variant/state keys. This enables headless UI interop: the attribute is
-* consumed for styling AND forwarded to the element so external frameworks
-* (Radix, Ark-UI) see it.
-*
-* filterProps covers all Animus props, so unknown props pass through: for DOM
-* elements React handles any unknown-attribute warnings in dev mode, and for
-* component elements all non-filtered props are forwarded to the component.
+* `data-*` and `aria-*` reach the DOM even when they key a variant or state,
+* so headless libraries driving those attributes still see them.
 */
 function forwardProps(props, filterProps, domProps) {
 	for (const [key, value] of Object.entries(props)) {
@@ -33,13 +24,8 @@ function forwardProps(props, filterProps, domProps) {
 	}
 }
 /**
-* asChild render path: don't render our own element — merge the resolved
-* className/ref/style onto the single child element, plus the parent's own
-* forwardable props (event handlers, role, aria-*, data-*, id, tabIndex).
-*
-* Conflict rule is child-wins: the parent's props are spread UNDER the child's
-* own, so a handler or attribute declared on the child replaces the parent's
-* rather than chaining with it.
+* The child wins every conflict: parent props spread under the child's own, so
+* a handler declared on the child replaces the parent's instead of chaining.
 */
 function renderAsChild(className, filterProps, props, ref, classes, dynamicStyle) {
 	const child = Children.only(props.children);
@@ -64,10 +50,6 @@ function renderAsChild(className, filterProps, props, ref, classes, dynamicStyle
 		...mergedStyle ? { style: mergedStyle } : {}
 	});
 }
-/**
-* Normal render path: render our own element (or the `as` override), forwarding
-* filtered props and applying any dynamic CSS-variable style.
-*/
 function renderElement(element, filterProps, props, ref, classes, dynamicStyle) {
 	const target = props.as || element;
 	const domProps = {
@@ -81,26 +63,11 @@ function renderElement(element, filterProps, props, ref, classes, dynamicStyle)
 	} : dynamicStyle;
 	return createElement(target, domProps);
 }
-/**
-* Create a lightweight component that applies extracted CSS class names.
-* Replaces Emotion's styled() for extracted components.
-*
-* The element parameter accepts either an HTML tag string (e.g. 'button') or
-* a React component reference (e.g. NextLink). When a component reference is
-* used, prop forwarding skips the HTML-attribute validity check — all
-* non-filtered props are forwarded to the component.
-*
-* The optional systemPropMap parameter provides the shared prop→value→className
-* lookup table, served as a virtual module by the Vite plugin.
-*
-* The optional dynamicPropConfig parameter provides CSS variable fallback
-* metadata for props with detected dynamic usage.
-*/
 function createComponent(element, className, config, systemPropMap, dynamicPropConfig) {
 	const variantProps = config.variants ? Object.keys(config.variants) : [];
 	const stateProps = config.states || [];
 	const systemPropNames = config.systemPropNames || [];
-	const filterProps = new Set([
+	const filterProps = /* @__PURE__ */ new Set([
 		"as",
 		"asChild",
 		...variantProps,
@@ -127,13 +94,8 @@ function createComponent(element, className, config, systemPropMap, dynamicPropC
 //#endregion
 //#region src/runtime/createComposedFamily.ts
 /**
-* createComposedFamily — extraction-time replacement for compose().
-*
-* The transform emitter replaces `compose({ Root, Body }, { shared, name })`
-* with `createComposedFamily({ Root, Body }, { name })`.
-*
-* RSC-safe: uses only forwardRef and createElement — no createContext,
-* no useContext, no hooks.
+* The extraction emitter rewrites `compose()` calls to this form. It stays
+* hook- and context-free so composed families work in server components.
 */
 function createComposedFamily(slots, config) {
 	assertRootSlot(slots, "createComposedFamily");

package/dist/groups/index.js

@@ -1,4 +1,4 @@
-import { a as borderShorthand, i as gridItemRatio, n as size, o as createScale, r as gridItem } from "../size-CcVEGaen.js";
+import { a as borderShorthand, i as gridItemRatio, n as size, o as createScale, r as gridItem } from "../size-C6jqxiQy.js";
 //#region src/groups/index.ts
 const color = {
 	color: {

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { asset, ASSET_PLACEHOLDER_PREFIX, type AssetRef } from './asset.js';
 export { createComponent } from './runtime';
 export { type ClassResolver, type ClassResolverAttributes, createClassResolver, } from './runtime/createClassResolver';
 export { createComposedFamily } from './runtime/createComposedFamily';
-export type { CreateKeyframesFactory, FontFace, FontFaceSrc, GlobalStyleBlock, GlobalStyleMap, GlobalStylesFactory, LibraryBundle, RegistrySnapshot, SerializedConfig, SystemBuilderStage, SystemInstance, } from './SystemBuilder';
+export type { CreateKeyframesFactory, FontFace, FontFaceSrc, GlobalStyleBlock, GlobalStyleMap, GlobalStylesFactory, KeyframesFrameData, LibraryBundle, RegisterableGlobalStyles, RegisterableKeyframes, RegistrySnapshot, SealedSystemInstance, SerializedConfig, SystemBuilderStage, SystemBundle, SystemInstance, VocabularyCollisionEntry, VocabularyGlobalStyleEntry, VocabularyKeyframesEntry, VocabularyLegacyVerbEntry, VocabularyNameCollision, VocabularyOf, VocabularyRecord, } from './SystemBuilder';
 export { createSystem, SystemBuilder } from './SystemBuilder';
 export { createScale, numericOrStringScale, numericScale, stringScale, } from './scales/createScale';
 export { type AtRuleValue, BUILT_IN_CONDITIONS, type ConditionAlias, type ConditionAliasMap, type ConditionKind, type Conditions, type ConditionsOf, type NarrowedAliases, type RawAtRuleKey, type RegistryBrand, type ReservedByConditionRegistry, type ReservedBySelectorRegistry, type SelectorsOf, type UnknownAtRule, type UnknownConditionAlias, } from './conditions.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}