praxis-kit 2.0.2 → 3.0.0

package/dist/svelte/index.d.ts

@@ -117,9 +117,9 @@ type VariantSelection<V extends VariantMap> = {
  * Presets are named bundles of variant props that callers activate by key,
  * avoiding the need to repeat variant combinations at each call site.
  */
-type PresetMap<V extends VariantMap = VariantMap> = Readonly<Record<string, VariantSelection<V>>>;
+type RecipeMap<V extends VariantMap = VariantMap> = Readonly<Record<string, VariantSelection<V>>>;
 
-interface PolymorphicGenerics<TDefault extends ElementType = ElementType, Props extends AnyRecord = AnyRecord, Variants extends Readonly<VariantMap> = Readonly<VariantMap>, TPreset extends PresetMap<Variants> = Readonly<EmptyRecord>, TAllowed extends ElementType = ElementType> {
+interface PolymorphicGenerics<TDefault extends ElementType = ElementType, Props extends AnyRecord = AnyRecord, Variants extends Readonly<VariantMap> = Readonly<VariantMap>, TPreset extends RecipeMap<Variants> = Readonly<EmptyRecord>, TAllowed extends ElementType = ElementType> {
     default: TDefault;
     props: Props;
     variants: Variants;
@@ -127,23 +127,23 @@ interface PolymorphicGenerics<TDefault extends ElementType = ElementType, Props
     allowed: TAllowed;
 }
 
-type PresetTarget<TVariants extends VariantMap = VariantMap> = VariantSelection<TVariants>;
+type RecipeTarget<TVariants extends VariantMap = VariantMap> = VariantSelection<TVariants>;
 
 interface BaseClassOptions {
     baseClassName?: ClassName;
 }
 
-type ClassPipelineFn = (tag: unknown, props: AnyRecord, className?: ClassName, variantKey?: string) => string;
+type ClassPipelineFn = (tag: unknown, props: AnyRecord, className?: ClassName, recipe?: string) => string;
 
-interface PresetOptions<TVariants extends VariantMap = VariantMap> {
-    presetMap?: Record<string, PresetTarget<TVariants>>;
+interface RecipeOptions<TVariants extends VariantMap = VariantMap> {
+    recipeMap?: Record<string, RecipeTarget<TVariants>>;
 }
 
 interface TagMapOptions {
     tagMap?: TagMap;
 }
 
-type CompositionOptions<TVariants extends VariantMap = VariantMap> = Simplify<TagMapOptions & PresetOptions<TVariants>>;
+type CompositionOptions<TVariants extends VariantMap = VariantMap> = Simplify<TagMapOptions & RecipeOptions<TVariants>>;
 
 type CVASystemOptions<TVariants extends VariantMap = VariantMap> = Simplify<CVAVariants<TVariants> & CVADefaults<TVariants> & CVACompounds<TVariants>>;
 
@@ -218,7 +218,7 @@ type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
     readonly allowedAs?: readonly TAllowed[];
 };
 
-type StylingOptions<V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord> = {
+type StylingOptions<V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends RecipeMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord> = {
     readonly base?: ClassName;
     readonly variants?: V;
     readonly defaults?: Partial<DefaultVariants<V>>;
@@ -232,8 +232,8 @@ type StylingOptions<V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPre
 type NormalizeFn<Props extends AnyRecord = AnyRecord> = {
     normalize(props: Readonly<Props & IntrinsicProps>): Props & IntrinsicProps;
 }['normalize'];
-type AnyFactoryOptions = FactoryOptions<ElementType, AnyRecord, VariantMap, PresetMap<VariantMap>, AnyRecord>;
-type FactoryOptions<TDefault extends ElementType = ElementType, Props extends AnyRecord = EmptyRecord, V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord, TAllowed extends ElementType = ElementType> = {
+type AnyFactoryOptions = FactoryOptions<ElementType, AnyRecord, VariantMap, RecipeMap<VariantMap>, AnyRecord>;
+type FactoryOptions<TDefault extends ElementType = ElementType, Props extends AnyRecord = EmptyRecord, V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends RecipeMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord, TAllowed extends ElementType = ElementType> = {
     readonly tag?: TDefault;
     readonly name?: string;
     readonly defaults?: Partial<NoInfer<Props>>;
@@ -242,12 +242,12 @@ type FactoryOptions<TDefault extends ElementType = ElementType, Props extends An
     readonly enforcement?: EnforcementOptions<TAllowed>;
 };
 
-type ResolvedFactoryOptions<TDefault extends ElementType = ElementType, Props extends AnyRecord = EmptyRecord, V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<V> = Readonly<EmptyRecord>> = {
+type ResolvedFactoryOptions<TDefault extends ElementType = ElementType, Props extends AnyRecord = EmptyRecord, V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends RecipeMap<V> = Readonly<EmptyRecord>> = {
     readonly defaultTag: TDefault;
     readonly baseClassName?: ClassName;
     readonly defaultProps?: Partial<Props>;
     readonly tagMap?: Readonly<TagMap>;
-    readonly presetMap?: TPreset;
+    readonly recipeMap?: TPreset;
     readonly variants?: V;
     readonly defaultVariants?: Partial<DefaultVariants<V>>;
     readonly compoundVariants?: readonly CompoundVariant<V>[];
@@ -266,7 +266,7 @@ type ResolveAriaFn = <P extends IntrinsicProps>(tag: ElementType, props: P) => {
     props: P;
 };
 
-type ResolveClassNameFn<Props extends AnyRecord, TSlot extends string = never> = (tag: ElementType, props: Props, className?: ClassName, variantKey?: TSlot) => string;
+type ResolveClassNameFn<Props extends AnyRecord, TSlot extends string = never> = (tag: ElementType, props: Props, className?: ClassName, recipe?: TSlot) => string;
 
 type ResolvePropsFn<Props extends AnyRecord> = <P extends Partial<Props>>(props: P) => Simplify<Omit<Props, keyof P> & P>;
 
@@ -277,7 +277,7 @@ type RuntimePluginField<TPlugin extends ClassPlugin | undefined> = TPlugin exten
     readonly hasStyling: true;
 } : EmptyRecord;
 
-type PolymorphicRuntime<TDefault extends ElementType, Props extends AnyRecord, Variants extends VariantMap, TSlot extends string = never, TPreset extends PresetMap<Variants> = Readonly<Record<string, VariantSelection<Variants>>>, TPlugin extends ClassPlugin | undefined = ClassPlugin | undefined> = RuntimePluginField<TPlugin> & {
+type PolymorphicRuntime<TDefault extends ElementType, Props extends AnyRecord, Variants extends VariantMap, TSlot extends string = never, TPreset extends RecipeMap<Variants> = Readonly<Record<string, VariantSelection<Variants>>>, TPlugin extends ClassPlugin | undefined = ClassPlugin | undefined> = RuntimePluginField<TPlugin> & {
     readonly options: Readonly<ResolvedFactoryOptions<TDefault, Props, Variants, TPreset>>;
     readonly resolveTag: ResolveTagFn<TDefault>;
     readonly resolveProps: ResolvePropsFn<Props>;
@@ -299,7 +299,7 @@ declare class ChildrenEvaluator extends StrictBase {
     evaluate(children: unknown[]): void;
 }
 
-declare function createPolymorphic<TDefault extends ElementType, Props extends AnyRecord, Variants extends Readonly<VariantMap>, TPreset extends PresetMap<Variants> = Readonly<EmptyRecord>>(options?: FactoryOptions<TDefault, Props, Variants, TPreset>): PolymorphicRuntime<TDefault, Props, Variants, Extract<keyof TPreset, string>, TPreset>;
+declare function createPolymorphic<TDefault extends ElementType, Props extends AnyRecord, Variants extends Readonly<VariantMap>, TPreset extends RecipeMap<Variants> = Readonly<EmptyRecord>>(options?: FactoryOptions<TDefault, Props, Variants, TPreset>): PolymorphicRuntime<TDefault, Props, Variants, Extract<keyof TPreset, string>, TPreset>;
 
 declare class SlotValidator extends StrictBase {
     #private;
@@ -319,9 +319,11 @@ type BuiltChildrenEvaluator<TOptions extends WithChildRules> = TOptions extends
     childrenEvaluator: ChildrenEvaluator;
 } : EmptyRecord;
 
+declare function defineContractComponent<O extends FactoryOptions>(options: O): <R>(factory: (options: O) => R) => R;
+
 type UnknownProps = Record<string, unknown>;
 
-type SvelteFactoryOptions<TDefault extends ElementType, Props extends UnknownProps, Variants extends Readonly<VariantMap>, TPreset extends PresetMap<Variants> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord> = FactoryOptions<TDefault, Props, Variants, TPreset, TPluginProps> & {
+type SvelteFactoryOptions<TDefault extends ElementType, Props extends UnknownProps, Variants extends Readonly<VariantMap>, TPreset extends RecipeMap<Variants> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord> = FactoryOptions<TDefault, Props, Variants, TPreset, TPluginProps> & {
     /**
      * Return true for any prop key that should be consumed but not forwarded to the DOM.
      * Receives `runtime.options.variantKeys` as a convenience if needed.
@@ -329,7 +331,7 @@ type SvelteFactoryOptions<TDefault extends ElementType, Props extends UnknownPro
     filterProps?: (key: string, variantKeys: ReadonlySet<string>) => boolean;
 };
 
-type TypedRuntime<G extends PolymorphicGenerics> = ReturnType<typeof createPolymorphic<DefaultOf<G>, PropsOf<G>, VariantsOf<G>, PresetOf<G>>>;
+type TypedRuntime<G extends PolymorphicGenerics> = ReturnType<typeof createPolymorphic<DefaultOf<G>, PropsOf<G>, VariantsOf<G>, RecipeOf<G>>>;
 
 type BuiltRuntime<G extends PolymorphicGenerics = PolymorphicGenerics, TOptions extends WithChildRules = WithChildRules> = BuiltChildrenEvaluator<TOptions> & {
     runtime: TypedRuntime<G>;
@@ -337,8 +339,6 @@ type BuiltRuntime<G extends PolymorphicGenerics = PolymorphicGenerics, TOptions
     slotValidator: SlotValidator;
 };
 
-declare function createContractComponent<TDefault extends ElementType, Props extends UnknownProps = EmptyRecord, Variants extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<Variants> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord, TOptions extends WithChildRules = SvelteFactoryOptions<TDefault, Props & TPluginProps, Variants, TPreset>>(options: SvelteFactoryOptions<TDefault, Props, Variants, TPreset, TPluginProps> & TOptions): BuiltRuntime<PolymorphicGenerics<TDefault, Props & TPluginProps, Variants, TPreset>, TOptions>;
-
-declare function defineContractComponent<O extends FactoryOptions>(options: O): <R>(factory: (options: O) => R) => R;
+declare function createContractComponent<TDefault extends ElementType, Props extends UnknownProps = EmptyRecord, Variants extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends RecipeMap<Variants> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord, TOptions extends WithChildRules = SvelteFactoryOptions<TDefault, Props & TPluginProps, Variants, TPreset>>(options: SvelteFactoryOptions<TDefault, Props, Variants, TPreset, TPluginProps> & TOptions): BuiltRuntime<PolymorphicGenerics<TDefault, Props & TPluginProps, Variants, TPreset>, TOptions>;
 
 export { type AnyFactoryOptions, type BuiltRuntime, type ElementType, type EmptyRecord, type FilterPredicate, type PolymorphicGenerics, type SvelteFactoryOptions, type UnknownProps, type WithChildRules, createContractComponent, defineContractComponent };

package/dist/svelte/index.js

@@ -1,4 +1,9 @@
-// ../core/dist/chunk-XFCAUPVZ.js
+// ../../lib/adapter-utils/src/define-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
+}
+
+// ../core/dist/chunk-KKSHJDE7.js
 function makeResolveTag(defaultTag) {
   return function tag(as) {
     return as ?? defaultTag;
@@ -67,7 +72,7 @@ function resolveFactoryOptions(options = {}) {
     ...whenDefined("defaultProps", options.defaults),
     ...whenDefined("baseClassName", styling?.base),
     ...whenDefined("tagMap", styling?.tags),
-    ...whenDefined("presetMap", styling?.presets),
+    ...whenDefined("recipeMap", styling?.presets),
     ...whenDefined("variants", styling?.variants),
     ...whenDefined("defaultVariants", styling?.defaults),
     ...whenDefined("compoundVariants", styling?.compounds),
@@ -108,10 +113,10 @@ function validateFactoryOptions(resolved) {
       }
     }
   };
-  const { presetMap } = resolved;
-  if (presetMap) {
-    for (const presetKey in presetMap) {
-      checkSelection(`preset "${presetKey}"`, presetMap[presetKey]);
+  const { recipeMap } = resolved;
+  if (recipeMap) {
+    for (const recipeKey in recipeMap) {
+      checkSelection(`preset "${recipeKey}"`, recipeMap[recipeKey]);
     }
   }
   if (resolved.defaultVariants) checkSelection("defaults", resolved.defaultVariants);
@@ -147,12 +152,12 @@ function report2(strict, message) {
 function label(name) {
   return name ? `[${name}]` : "[createContractComponent]";
 }
-function validateRenderProps(options, props, presetKey) {
-  const { strict, presetMap, variants, displayName } = options;
+function validateRenderProps(options, props, recipeKey) {
+  const { strict, recipeMap, variants, displayName } = options;
   if (!strict) return;
   const tag = label(displayName);
-  if (presetKey !== void 0 && (!presetMap || !Object.hasOwn(presetMap, presetKey))) {
-    report2(strict, `${tag} Unknown presetKey "${presetKey}" \u2014 no preset with that name exists.`);
+  if (recipeKey !== void 0 && (!recipeMap || !Object.hasOwn(recipeMap, recipeKey))) {
+    report2(strict, `${tag} Unknown recipeKey "${recipeKey}" \u2014 no preset with that name exists.`);
   }
   if (variants) {
     for (const key in variants) {
@@ -190,8 +195,8 @@ function assertPluginShape(result) {
 }
 function guardPipeline(pipeline) {
   if (process.env.NODE_ENV === "production") return pipeline;
-  return function guardedPipeline(tag, props, className, variantKey) {
-    const result = pipeline(tag, props, className, variantKey);
+  return function guardedPipeline(tag, props, className, recipe) {
+    const result = pipeline(tag, props, className, recipe);
     if (typeof result !== "string")
       panic(`[praxis-kit] Plugin pipeline must return a string. Got: ${describe(result)}.`);
     return result;
@@ -216,11 +221,11 @@ function createRuntimeMethods(resolved, classPipeline, engine) {
     resolveProps(props) {
       return mergeProps(resolved.defaultProps, props);
     },
-    resolveClasses(tag, props, className, variantKey) {
+    resolveClasses(tag, props, className, recipe) {
       if (process.env.NODE_ENV !== "production") {
-        validateRenderProps(resolved, props, variantKey);
+        validateRenderProps(resolved, props, recipe);
       }
-      return classPipeline(tag, props, className, variantKey);
+      return classPipeline(tag, props, className, recipe);
     },
     resolveAria(tag, props) {
       if (!engine) return { props };
@@ -566,7 +571,7 @@ function isStandaloneTag(tag) {
   return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
 }
 
-// ../core/dist/chunk-VU44HAB7.js
+// ../core/dist/chunk-BNVYTMYV.js
 var IMPLICIT_ROLE_RECORD2 = {
   article: "article",
   aside: "complementary",
@@ -1501,7 +1506,7 @@ function getHtmlPropNormalizers(tag) {
   return typeof tag === "string" ? HTML_FORM_NORMALIZERS.get(tag) : void 0;
 }
 
-// ../core/dist/chunk-EHCOMLJ4.js
+// ../core/dist/chunk-3T4EM5FG.js
 var falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
 var cx = clsx;
 var cva = (base, config) => (props) => {
@@ -1578,18 +1583,18 @@ var StaticClassResolver = class {
 };
 var VariantClassResolver = class _VariantClassResolver {
   #cvaFn;
-  #presetMap;
+  #recipeMap;
   #variantKeys;
   #precomputedClasses;
   #cache = /* @__PURE__ */ new Map();
-  constructor(cvaFn, presetMap, variantKeys, precomputedClasses) {
+  constructor(cvaFn, recipeMap, variantKeys, precomputedClasses) {
     this.#cvaFn = cvaFn ?? null;
-    this.#presetMap = Object.freeze(presetMap ?? {});
+    this.#recipeMap = Object.freeze(recipeMap ?? {});
     this.#variantKeys = variantKeys ?? null;
     this.#precomputedClasses = precomputedClasses ?? null;
   }
-  resolve({ props, variantKey }) {
-    const normalizedKey = variantKey ?? "__none__";
+  resolve({ props, recipe }) {
+    const normalizedKey = recipe ?? "__none__";
     const cacheKey = this.#createCacheKey(props, normalizedKey);
     if (this.#precomputedClasses !== null) {
       const precomputed = this.#precomputedClasses[cacheKey];
@@ -1601,7 +1606,7 @@ var VariantClassResolver = class _VariantClassResolver {
       this.#cache.set(cacheKey, cached);
       return cached;
     }
-    const result = this.#compute(props, variantKey);
+    const result = this.#compute(props, recipe);
     this.#cache.set(cacheKey, result);
     if (this.#cache.size > 1e3) {
       const lru = this.#cache.keys().next().value;
@@ -1609,10 +1614,10 @@ var VariantClassResolver = class _VariantClassResolver {
     }
     return result;
   }
-  #compute(props, variantKey) {
+  #compute(props, recipe) {
     if (!this.#cvaFn) return "";
-    if (!variantKey) return this.#cvaFn(props);
-    const preset = this.#presetMap[variantKey];
+    if (!recipe) return this.#cvaFn(props);
+    const preset = this.#recipeMap[recipe];
     if (!preset) return this.#cvaFn(props);
     return this.#cvaFn({ ...preset, ...props });
   }
@@ -1620,15 +1625,15 @@ var VariantClassResolver = class _VariantClassResolver {
   // props (className, id, etc.) produce identical CVA output and must not fragment the cache.
   // Iterating #variantKeys directly (fixed Set insertion order) avoids Object.keys + filter + sort.
   // String is built incrementally to avoid a parts[] array allocation on every render.
-  #createCacheKey(props, variantKey) {
+  #createCacheKey(props, recipe) {
     if (this.#variantKeys !== null) {
-      let key2 = variantKey;
+      let key2 = recipe;
       for (const k of this.#variantKeys) {
         if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
       }
       return key2;
     }
-    let key = variantKey;
+    let key = recipe;
     for (const k of Object.keys(props).sort()) {
       key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
     }
@@ -1653,13 +1658,13 @@ function createClassPipeline(resolved) {
   const staticResolver = new StaticClassResolver(baseClass, resolved.tagMap);
   const variantResolver = new VariantClassResolver(
     cvaFn,
-    resolved.presetMap,
+    resolved.recipeMap,
     variantKeys,
     resolved.precomputedClasses
   );
-  return function resolveClasses(tag, props, className, variantKey) {
-    const staticClasses = staticResolver.resolve(tag, variantKey !== void 0);
-    const variantClasses = variantResolver.resolve({ props, variantKey });
+  return function resolveClasses(tag, props, className, recipe) {
+    const staticClasses = staticResolver.resolve(tag, recipe !== void 0);
+    const variantClasses = variantResolver.resolve({ props, recipe });
     if (!className)
       return staticClasses && variantClasses ? `${staticClasses} ${variantClasses}` : staticClasses || variantClasses;
     return cn(staticClasses, variantClasses, className);
@@ -1759,11 +1764,6 @@ function createContractComponent(options) {
     options
   );
 }
-
-// ../../adapters/svelte/src/define-contract-component.ts
-function defineContractComponent(options) {
-  return (factory) => factory(options);
-}
 export {
   createContractComponent,
   defineContractComponent

package/dist/tailwind/index.js

@@ -98,18 +98,18 @@ var StaticClassResolver = class {
 // ../../lib/styling/src/variant-class-resolver.ts
 var VariantClassResolver = class _VariantClassResolver {
   #cvaFn;
-  #presetMap;
+  #recipeMap;
   #variantKeys;
   #precomputedClasses;
   #cache = /* @__PURE__ */ new Map();
-  constructor(cvaFn, presetMap, variantKeys, precomputedClasses) {
+  constructor(cvaFn, recipeMap, variantKeys, precomputedClasses) {
     this.#cvaFn = cvaFn ?? null;
-    this.#presetMap = Object.freeze(presetMap ?? {});
+    this.#recipeMap = Object.freeze(recipeMap ?? {});
     this.#variantKeys = variantKeys ?? null;
     this.#precomputedClasses = precomputedClasses ?? null;
   }
-  resolve({ props, variantKey }) {
-    const normalizedKey = variantKey ?? "__none__";
+  resolve({ props, recipe }) {
+    const normalizedKey = recipe ?? "__none__";
     const cacheKey = this.#createCacheKey(props, normalizedKey);
     if (this.#precomputedClasses !== null) {
       const precomputed = this.#precomputedClasses[cacheKey];
@@ -121,7 +121,7 @@ var VariantClassResolver = class _VariantClassResolver {
       this.#cache.set(cacheKey, cached);
       return cached;
     }
-    const result = this.#compute(props, variantKey);
+    const result = this.#compute(props, recipe);
     this.#cache.set(cacheKey, result);
     if (this.#cache.size > 1e3) {
       const lru = this.#cache.keys().next().value;
@@ -129,10 +129,10 @@ var VariantClassResolver = class _VariantClassResolver {
     }
     return result;
   }
-  #compute(props, variantKey) {
+  #compute(props, recipe) {
     if (!this.#cvaFn) return "";
-    if (!variantKey) return this.#cvaFn(props);
-    const preset = this.#presetMap[variantKey];
+    if (!recipe) return this.#cvaFn(props);
+    const preset = this.#recipeMap[recipe];
     if (!preset) return this.#cvaFn(props);
     return this.#cvaFn({ ...preset, ...props });
   }
@@ -140,15 +140,15 @@ var VariantClassResolver = class _VariantClassResolver {
   // props (className, id, etc.) produce identical CVA output and must not fragment the cache.
   // Iterating #variantKeys directly (fixed Set insertion order) avoids Object.keys + filter + sort.
   // String is built incrementally to avoid a parts[] array allocation on every render.
-  #createCacheKey(props, variantKey) {
+  #createCacheKey(props, recipe) {
     if (this.#variantKeys !== null) {
-      let key2 = variantKey;
+      let key2 = recipe;
       for (const k of this.#variantKeys) {
         if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
       }
       return key2;
     }
-    let key = variantKey;
+    let key = recipe;
     for (const k of Object.keys(props).sort()) {
       key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
     }
@@ -175,13 +175,13 @@ function createClassPipeline(resolved) {
   const staticResolver = new StaticClassResolver(baseClass, resolved.tagMap);
   const variantResolver = new VariantClassResolver(
     cvaFn,
-    resolved.presetMap,
+    resolved.recipeMap,
     variantKeys,
     resolved.precomputedClasses
   );
-  return function resolveClasses(tag, props, className, variantKey) {
-    const staticClasses = staticResolver.resolve(tag, variantKey !== void 0);
-    const variantClasses = variantResolver.resolve({ props, variantKey });
+  return function resolveClasses(tag, props, className, recipe) {
+    const staticClasses = staticResolver.resolve(tag, recipe !== void 0);
+    const variantClasses = variantResolver.resolve({ props, recipe });
     if (!className)
       return staticClasses && variantClasses ? `${staticClasses} ${variantClasses}` : staticClasses || variantClasses;
     return cn(staticClasses, variantClasses, className);
@@ -446,8 +446,8 @@ function compoundDimensions(compounds) {
 function getDefaultVariants(options) {
   return options.defaultVariants;
 }
-function resolveActiveSelection(options, variants, props, variantKey) {
-  const preset = variantKey ? options.presetMap?.[variantKey] : void 0;
+function resolveActiveSelection(options, variants, props, recipe) {
+  const preset = recipe ? options.recipeMap?.[recipe] : void 0;
   const defaults = getDefaultVariants(options);
   const selection = {};
   for (const dim in variants) {
@@ -456,11 +456,11 @@ function resolveActiveSelection(options, variants, props, variantKey) {
   }
   return selection;
 }
-function warnDeadVariants(strict, options, compoundDims, props, variantKey, state) {
+function warnDeadVariants(strict, options, compoundDims, props, recipe, state) {
   if (!strict) return;
   const variants = getVariantConfig(options);
   if (!variants) return;
-  const selection = resolveActiveSelection(options, variants, props, variantKey);
+  const selection = resolveActiveSelection(options, variants, props, recipe);
   for (const dim in selection) {
     if (compoundDims.has(dim)) continue;
     const value = selection[dim];
@@ -482,14 +482,14 @@ function createTailwindPipeline(options, strict) {
   const compoundDims = compoundDimensions(getCompoundVariants(options));
   return {
     ownedKeys: LAYOUT_OWNED_KEYS,
-    pipeline(tag, props, className, variantKey) {
+    pipeline(tag, props, className, recipe) {
       const mode = resolveLayout(props);
-      const raw = pipeline(tag, props, className, variantKey);
+      const raw = pipeline(tag, props, className, recipe);
       const tokens = classifyTokens(raw);
       const state = new LayoutState(mode);
       if (DEV) {
         warnReservedLayoutLiterals(strict, tokens);
-        warnDeadVariants(strict, options, compoundDims, props, variantKey, state);
+        warnDeadVariants(strict, options, compoundDims, props, recipe, state);
       }
       const filtered = tokens.filter((token) => evaluator.evaluate(token, state));
       const built = builder.build(filtered);

package/dist/vite-plugin/index.d.ts

@@ -108,6 +108,74 @@ type DesignTokensOptions = {
  */
 declare function designTokensPlugin(options?: DesignTokensOptions): Plugin;
 
+/**
+ * Compile-time static composition transform.
+ *
+ * For factory calls that have `precomputedClasses` injected (by classExtractPlugin),
+ * replaces static JSX usage sites with direct element creation — bypassing the
+ * runtime render pipeline entirely.
+ *
+ * Example:
+ *   // Source (same file defines Button and uses it)
+ *   const Button = createContractComponent({ tag: 'button', styling: { precomputedClasses: {...} } })
+ *   <Button size="lg">Click</Button>
+ *
+ *   // Output
+ *   const Button = createContractComponent({ ... }) // unchanged — still exported
+ *   <button className="btn btn-lg">Click</button>  // inlined!
+ *
+ * **Eligibility conditions** — a usage site is inlined only when:
+ *   1. The component is defined in the same file or imported from a file already
+ *      transformed by this plugin, with `precomputedClasses` injected
+ *   2. No `as`, `asChild`, `render`, or spread attributes at the usage site
+ *   3. All variant props are static string literals
+ *   4. `className` is absent or a static string literal
+ *   5. The factory config has no top-level `defaults` and no `enforcement`
+ *      (either would require runtime prop normalization that inlining skips)
+ *
+ * The factory call itself is intentionally left in the output so the component
+ * remains exportable for cross-file consumption that falls back to the runtime
+ * path. Dead-code elimination at the bundler level can remove it when no
+ * runtime path remains.
+ *
+ * **Cross-file known limitations:**
+ * - Barrel re-exports are not resolved (import from index.ts re-exporting ./Button)
+ * - Aliased imports are not matched (`export { Btn as Button }` won't be found)
+ * - Dev-mode ordering: definition file may not yet be transformed when consumer runs
+ * All three degrade gracefully to the runtime path — no error, no broken output.
+ */
+
+type StaticComponent = {
+    readonly defaultTag: string;
+    readonly variantKeys: ReadonlySet<string>;
+    readonly precomputedClasses: Readonly<Record<string, string>>;
+};
+/**
+ * Walks the source file and extracts metadata for each same-file factory call
+ * that is eligible for static composition.
+ */
+declare function extractStaticComponents(source: ts.SourceFile, calleeNames: ReadonlySet<string>): Map<string, StaticComponent>;
+/**
+ * Applies the static composition transform to the given source file.
+ *
+ * `importedComponents` contains cross-file metadata resolved by the plugin
+ * registry — components defined in other files that were already transformed.
+ * When empty (dev mode ordering race or barrel re-export), same-file components
+ * still inline normally; cross-file sites fall through to the runtime path.
+ *
+ * Returns null when:
+ * - No eligible factory calls or imported components are present
+ * - No eligible usage sites are found after analysis
+ */
+declare function composeStatically(source: ts.SourceFile, calleeNames: ReadonlySet<string>, importedComponents?: ReadonlyMap<string, StaticComponent>): string | null;
+
+type ImportBinding = {
+    /** The exported name in the source module (the name before `as`, if any). */
+    readonly importedName: string;
+    /** The module specifier string (e.g. `'./Button'`). */
+    readonly specifier: string;
+};
+
 /**
  * Pure analysis entry point. Parses `code` as TypeScript/TSX, extracts
  * enforcement.children constraints from factory calls, and validates JSX usage
@@ -220,49 +288,6 @@ declare function buildPrecomputedClasses(stylingObj: ts.ObjectLiteralExpression)
  */
 declare function injectPrecomputedClasses(source: ts.SourceFile, calleeNames: ReadonlySet<string>): string | null;
 
-/**
- * Compile-time static composition transform.
- *
- * For same-file factory calls that have `precomputedClasses` injected (by
- * classExtractPlugin), replaces static JSX usage sites with direct element
- * creation — bypassing the runtime render pipeline entirely.
- *
- * Example:
- *   // Source (same file defines Button and uses it)
- *   const Button = createContractComponent({ tag: 'button', styling: { precomputedClasses: {...} } })
- *   <Button size="lg">Click</Button>
- *
- *   // Output
- *   const Button = createContractComponent({ ... }) // unchanged — still exported
- *   <button className="btn btn-lg">Click</button>  // inlined!
- *
- * **Eligibility conditions** — a usage site is inlined only when:
- *   1. The component is defined in the same file via a factory call with
- *      `precomputedClasses` (classExtractPlugin must run first in the chain)
- *   2. No `as`, `asChild`, `render`, or spread attributes at the usage site
- *   3. All variant props are static string literals
- *   4. `className` is absent or a static string literal
- *   5. The factory config has no top-level `defaults` and no `enforcement`
- *      (either would require runtime prop normalization that inlining skips)
- *
- * The factory call itself is intentionally left in the output so the component
- * remains exportable for cross-file consumption that falls back to the runtime
- * path. Dead-code elimination at the bundler level can remove it when no
- * runtime path remains.
- *
- * **Deferred:** cross-file inlining (component defined in one module, used in
- * another) requires Vite module-graph traversal and is not yet implemented.
- */
-
-/**
- * Applies the static composition transform to the given source file.
- *
- * Returns null when:
- * - No eligible factory calls are found in the file
- * - No eligible usage sites are found after analysis
- */
-declare function composeStatically(source: ts.SourceFile, calleeNames: ReadonlySet<string>): string | null;
-
 /**
  * Vite plugin that performs static enforcement.children cardinality checks at
  * build time for components created with createContractComponent.
@@ -345,23 +370,24 @@ declare function classExtractPlugin(options?: Pick<PluginOptions, 'calleeNames'>
  */
 declare function slotTransformPlugin(): Plugin;
 /**
- * Vite plugin that replaces same-file polymorphic component usage sites with
- * direct element creation at build time, eliminating the runtime render
- * pipeline for statically-analyzable usages.
+ * Vite plugin that replaces polymorphic component usage sites with direct
+ * element creation at build time, eliminating the runtime render pipeline for
+ * statically-analyzable usages.
  *
  * **Requires classExtractPlugin to run first** so that `precomputedClasses` is
  * present in the factory call before this plugin reads it. Place after
  * `classExtractPlugin` in the plugins array.
  *
  * A usage site is inlined when:
- * - The component is defined in the same file with `precomputedClasses` injected
+ * - The component is defined in the same file or imported from a file already
+ *   transformed by this plugin, with `precomputedClasses` injected
  * - No `as`, `asChild`, `render`, or spread attributes at the site
  * - All variant props are static string literals
  * - `className` is absent or a static string literal
  * - The factory config has no `defaults` or `enforcement`
  *
- * Sites that do not meet all conditions fall through to the normal runtime path
- * unchanged.
+ * Cross-file inlining degrades gracefully when the definition file has not yet
+ * been transformed (dev mode ordering, barrel re-exports, aliased imports).
  *
  * @example
  * // vite.config.ts
@@ -392,4 +418,4 @@ declare function staticCompositionPlugin(options?: Pick<PluginOptions, 'calleeNa
  */
 declare function ssrOptimizePlugin(options?: Pick<PluginOptions, 'calleeNames'>): Plugin[];
 
-export { type ComponentConstraint, type ComponentTokens, type DesignTokenManifest, type DesignTokensOptions, type Diagnostic, type PluginOptions, type StaticBound, analyze, buildManifest, buildPrecomputedClasses, classExtractPlugin, collectFileTokens, composeStatically, compoundPrunePlugin, contractPlugin, designTokensPlugin, injectPrecomputedClasses, pruneDeadCompounds, slotTransformPlugin, ssrOptimizePlugin, staticCompositionPlugin, transformAsChild };
+export { type ComponentConstraint, type ComponentTokens, type DesignTokenManifest, type DesignTokensOptions, type Diagnostic, type ImportBinding, type PluginOptions, type StaticBound, type StaticComponent, analyze, buildManifest, buildPrecomputedClasses, classExtractPlugin, collectFileTokens, composeStatically, compoundPrunePlugin, contractPlugin, designTokensPlugin, extractStaticComponents, injectPrecomputedClasses, pruneDeadCompounds, slotTransformPlugin, ssrOptimizePlugin, staticCompositionPlugin, transformAsChild };