@animus-ui/system 0.1.9 → 0.1.12

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-EpwTL9Sa.js

@@ -0,0 +1,228 @@
+import { isUnitlessProperty } from "@animus-ui/properties";
+//#region src/runtime/is-dev.ts
+/**
+* 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 {
+		if (typeof process !== "undefined" && typeof process.env === "undefined") return true;
+		return process.env.NODE_ENV !== "production";
+	} catch {
+		return false;
+	}
+})();
+//#endregion
+//#region src/runtime/witness.ts
+const WITNESS_CAP = 5e3;
+function recordWitness(component, prop, value, outcome) {
+	if (!IS_DEV) return;
+	const g = globalThis;
+	const buf = g.__ANIMUS_WITNESS__ ??= [];
+	buf.push({
+		component,
+		prop,
+		value: String(value),
+		outcome
+	});
+	if (buf.length > 5e3) buf.splice(0, buf.length - WITNESS_CAP);
+}
+//#endregion
+//#region src/runtime/resolveClasses.ts
+/**
+* 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") {
+		if (cssProperties.some(isUnitlessProperty)) return String(value);
+		return `${value}px`;
+	}
+	return String(value);
+}
+/**
+* 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);
+}
+function isValidTransformResult(result) {
+	return typeof result === "string" || typeof result === "number" && Number.isFinite(result);
+}
+/**
+* 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";
+	if (Array.isArray(result)) return "array";
+	if (typeof result === "number") return "non-finite-number";
+	return typeof result;
+}
+function resolveEntry(value, dc) {
+	const key = String(value);
+	const scaleResolved = dc.scaleValues?.[key];
+	if (scaleResolved != null) {
+		const transformed = dc.transform ? dc.transform(scaleResolved) : scaleResolved;
+		if (dc.transform && !isValidTransformResult(transformed)) return { shape: describeResultShape(transformed) };
+		return String(transformed);
+	}
+	const transformed = dc.transform ? dc.transform(value) : value;
+	if (dc.transform && !isValidTransformResult(transformed)) return { shape: describeResultShape(transformed) };
+	if (typeof transformed !== "number") return String(transformed);
+	return applyUnitFallback(transformed, dc.properties && dc.properties.length > 0 ? dc.properties : dc.property ? [dc.property] : []);
+}
+const warnedDrops = /* @__PURE__ */ new Set();
+function warnDroppedValue(baseClassName, propName, serializedValue) {
+	if (IS_DEV) {
+		const dedupeKey = `${baseClassName}|${propName}`;
+		if (warnedDrops.has(dedupeKey)) return;
+		warnedDrops.add(dedupeKey);
+		console.warn(`[animus:drop] ${baseClassName}: value ${serializedValue} on prop '${propName}' matched no static class and no dynamic slot — it will not render. If this prop should accept runtime values, ensure its dynamic config is emitted.`);
+	}
+}
+/**
+* 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;
+	for (const [prop, vc] of Object.entries(config.variants)) {
+		const value = props[prop] ?? vc.default;
+		if (value != null) {
+			const isDefault = !(prop in props) && vc.default != null;
+			classes.push(`${baseClassName}--${prop}-${isDefault ? "default" : value}`);
+			recordWitness(baseClassName, prop, value, "static");
+		}
+	}
+}
+function applyCompoundClasses(classes, props, config) {
+	if (!config.compounds) return;
+	for (const compound of config.compounds) {
+		let match = true;
+		for (const [prop, expected] of Object.entries(compound.conditions)) {
+			const current = props[prop] ?? config.variants?.[prop]?.default;
+			if (Array.isArray(expected) ? !expected.includes(current) : current !== expected) {
+				match = false;
+				break;
+			}
+		}
+		if (match) classes.push(compound.className);
+	}
+}
+function applyStateClasses(classes, baseClassName, props, config, activeStates) {
+	if (!config.states) return;
+	for (const state of config.states) if (props[state]) {
+		classes.push(`${baseClassName}--${state}`);
+		activeStates.push(state);
+		recordWitness(baseClassName, state, "true", "static");
+	}
+}
+const warnedInvalidResults = /* @__PURE__ */ new Set();
+function warnInvalidTransformResult(baseClassName, propName, shape) {
+	if (IS_DEV) {
+		const dedupeKey = `${baseClassName}|${propName}`;
+		if (warnedInvalidResults.has(dedupeKey)) return;
+		warnedInvalidResults.add(dedupeKey);
+		console.warn(`[animus:drop] ${baseClassName}: transform for prop '${propName}' returned ${shape} — expected string or finite number; value dropped`);
+	}
+}
+/**
+* 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 = [];
+	if (typeof propValue === "object" && propValue !== null && !Array.isArray(propValue)) for (const [bp, bpVal] of Object.entries(propValue)) {
+		if (bpVal == null) continue;
+		const resolved = resolveEntry(bpVal, dc);
+		if (typeof resolved !== "string") return resolved;
+		staged.push(bp === "_" ? [
+			dc.slotClass,
+			dc.varName,
+			resolved
+		] : [
+			`${dc.slotClass}-${bp}`,
+			`${dc.varName}-${bp}`,
+			resolved
+		]);
+	}
+	else {
+		const resolved = resolveEntry(propValue, dc);
+		if (typeof resolved !== "string") return resolved;
+		staged.push([
+			dc.slotClass,
+			dc.varName,
+			resolved
+		]);
+	}
+	for (const [slotClass, varName, resolved] of staged) {
+		classes.push(slotClass);
+		dynStyle[varName] = resolved;
+	}
+	return null;
+}
+function resolveClasses(baseClassName, props, config, systemPropMap, dynamicPropConfig) {
+	const classes = [baseClassName];
+	let dynStyle;
+	applyVariantClasses(classes, baseClassName, props, config);
+	applyCompoundClasses(classes, props, config);
+	const activeStates = [];
+	applyStateClasses(classes, baseClassName, props, config, activeStates);
+	const systemPropNames = config.systemPropNames || [];
+	if (systemPropNames.length > 0) {
+		const { customPropMap, customDynamicConfig } = config;
+		for (const propName of systemPropNames) {
+			if (!(propName in props)) continue;
+			const propValue = props[propName];
+			if (propValue == null) continue;
+			const key = serializeValueKey(propValue);
+			const cls = customPropMap?.[propName]?.[key] ?? systemPropMap?.[propName]?.[key];
+			if (cls) {
+				classes.push(cls);
+				recordWitness(baseClassName, propName, key, "static");
+			} else {
+				const dc = customDynamicConfig?.[propName] ?? dynamicPropConfig?.[propName];
+				if (dc) {
+					const staged = dynStyle ?? {};
+					const invalid = applyDynamicProp(classes, staged, propValue, dc);
+					if (invalid === null) {
+						dynStyle = staged;
+						recordWitness(baseClassName, propName, key, "dynamic");
+					} else {
+						warnInvalidTransformResult(baseClassName, propName, invalid.shape);
+						recordWitness(baseClassName, propName, key, "drop");
+					}
+				} else {
+					warnDroppedValue(baseClassName, propName, key);
+					recordWitness(baseClassName, propName, key, "drop");
+				}
+			}
+		}
+	}
+	return {
+		classes,
+		dynamicStyle: dynStyle,
+		activeStates
+	};
+}
+//#endregion
+//#region src/runtime/createClassResolver.ts
+function serializeDynamicStyle(style) {
+	return Object.entries(style).map(([property, value]) => `${property}: ${value}`).join("; ");
+}
+function createClassResolver(className, config, systemPropMap, dynamicPropConfig) {
+	const resolveAttributes = (props) => {
+		const { classes, dynamicStyle } = resolveClasses(className, props || {}, config, systemPropMap, dynamicPropConfig);
+		const attributes = { class: classes.join(" ") };
+		if (dynamicStyle && Object.keys(dynamicStyle).length > 0) attributes.style = serializeDynamicStyle(dynamicStyle);
+		return attributes;
+	};
+	const resolver = (props) => resolveClasses(className, props || {}, config, systemPropMap, dynamicPropConfig).classes.join(" ");
+	return Object.assign(resolver, { attrs: resolveAttributes });
+}
+//#endregion
+export { resolveClasses as n, createClassResolver as t };

package/dist/createComposedFamily-C4NovMcd.js

@@ -0,0 +1,115 @@
+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
+/**
+* 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) => {
+		for (const ref of refs) if (typeof ref === "function") ref(node);
+		else if (ref) ref.current = node;
+	};
+}
+/**
+* `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)) {
+		if (key === "className") continue;
+		if (!(key.startsWith("data-") || key.startsWith("aria-")) && filterProps.has(key)) continue;
+		domProps[key] = value;
+	}
+}
+/**
+* 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);
+	if (!isValidElement(child)) throw new Error(`${className}: asChild requires a single React element as children`);
+	const childRef = child.ref;
+	const mergedClassName = [classes.join(" "), child.props.className].filter(Boolean).join(" ");
+	const mergedStyle = dynamicStyle || props.style || child.props.style ? {
+		...props.style,
+		...child.props.style,
+		...dynamicStyle
+	} : void 0;
+	const parentProps = {};
+	forwardProps(props, filterProps, parentProps);
+	delete parentProps.children;
+	delete parentProps.style;
+	delete parentProps.ref;
+	return cloneElement(child, {
+		...parentProps,
+		...child.props,
+		ref: composeRefs(ref, childRef),
+		className: mergedClassName,
+		...mergedStyle ? { style: mergedStyle } : {}
+	});
+}
+function renderElement(element, filterProps, props, ref, classes, dynamicStyle) {
+	const target = props.as || element;
+	const domProps = {
+		ref,
+		className: classes.join(" ")
+	};
+	forwardProps(props, filterProps, domProps);
+	if (dynamicStyle) domProps.style = props.style ? {
+		...props.style,
+		...dynamicStyle
+	} : dynamicStyle;
+	return createElement(target, domProps);
+}
+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 = /* @__PURE__ */ new Set([
+		"as",
+		"asChild",
+		...variantProps,
+		...stateProps,
+		...systemPropNames
+	]);
+	const Component = forwardRef((props, ref) => {
+		const { classes, dynamicStyle } = resolveClasses(className, props, config, systemPropMap, dynamicPropConfig);
+		if (props.className) classes.push(props.className);
+		return props.asChild ? renderAsChild(className, filterProps, props, ref, classes, dynamicStyle) : renderElement(element, filterProps, props, ref, classes, dynamicStyle);
+	});
+	Component.displayName = className;
+	const variantDefaults = {};
+	if (config.variants) {
+		for (const [prop, vc] of Object.entries(config.variants)) if (vc.default != null) variantDefaults[prop] = vc.default;
+	}
+	return Object.assign(Component, {
+		variantDefaults: Object.freeze(variantDefaults),
+		extend: () => {
+			throw new Error(`Cannot extend extracted component "${className}" at runtime. Extensions must be authored in source code using the builder API (e.g. import the original component and call .extend() there) so the extraction pipeline can resolve them at build time.`);
+		}
+	});
+}
+//#endregion
+//#region src/runtime/createComposedFamily.ts
+/**
+* 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");
+	const { name } = config;
+	const result = {};
+	for (const [slotName, SourceComponent] of Object.entries(slots)) {
+		const Wrapper = forwardRef((props, ref) => createElement(SourceComponent, {
+			...props,
+			ref
+		}, props.children));
+		Wrapper.displayName = `${name}.${slotName}`;
+		result[slotName] = Wrapper;
+	}
+	return result;
+}
+//#endregion
+export { createComponent as n, createComposedFamily as t };

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-DHdmBc64.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

@@ -4,9 +4,9 @@ export { compose } from './compose';
 export type { KeyframeFrameMap, KeyframeRef, Keyframes } from './keyframes';
 export { asset, ASSET_PLACEHOLDER_PREFIX, type AssetRef } from './asset.js';
 export { createComponent } from './runtime';
-export { createClassResolver } from './runtime/createClassResolver';
+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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"}