praxis-kit 2.0.2 → 3.0.0

package/dist/vite-plugin/index.js

@@ -332,11 +332,13 @@ function processVariableStatement(node, calleeNames, out) {
       }
     }
     if (rules.length === 0 && !hasAriaRules && !defaultTag) continue;
-    const totalMin = rules.reduce((s, r) => s + cardinalityMin(r.cardinality), 0);
-    const totalMax = rules.reduce(
-      (s, r) => s === Infinity ? Infinity : s + cardinalityMax(r.cardinality),
-      0
-    );
+    let totalMin = 0;
+    let totalMax = 0;
+    for (const rule of rules) {
+      totalMin += cardinalityMin(rule.cardinality);
+      const max = cardinalityMax(rule.cardinality);
+      totalMax = totalMax === Infinity || max === Infinity ? Infinity : totalMax + max;
+    }
     const componentName = ts3.isIdentifier(decl.name) ? decl.name.text : void 0;
     if (!componentName) continue;
     out.push({
@@ -367,7 +369,13 @@ function collectFileDeclarations(source, calleeNames) {
       if (!ts3.isStringLiteral(spec)) return;
       const namedBindings = node.importClause?.namedBindings;
       if (!namedBindings || !ts3.isNamedImports(namedBindings)) return;
-      for (const el of namedBindings.elements) importSpecifiers.set(el.name.text, spec.text);
+      const specifier = spec.text;
+      for (const el of namedBindings.elements) {
+        if (el.isTypeOnly) continue;
+        const localName = el.name.text;
+        const importedName = el.propertyName?.text ?? localName;
+        importSpecifiers.set(localName, { importedName, specifier });
+      }
     }
   });
   return { constraints, importSpecifiers };
@@ -512,23 +520,24 @@ function analyzeJsxSites(source, constraints, severity) {
       const opening = node.openingElement;
       tagName = ts5.isIdentifier(opening.tagName) ? opening.tagName.text : void 0;
       attributes = opening.attributes;
-      count = countStaticChildren(node);
+      count = countJsxChildren(node.children);
     } else if (ts5.isJsxSelfClosingElement(node)) {
       tagName = ts5.isIdentifier(node.tagName) ? node.tagName.text : void 0;
       attributes = node.attributes;
-      count = 0;
+      count = ZERO;
     }
     if (!tagName) return;
     let pos;
     const getPos = () => pos ??= source.getLineAndCharacterOfPosition(node.getStart(source));
     if (count !== void 0) {
       const c = byName.get(tagName);
-      if (c && (count < c.totalMin || count > c.totalMax)) {
+      if (c && (count.max < c.totalMin || count.min > c.totalMax)) {
         const { line, character } = getPos();
         const { totalMin, totalMax, name } = c;
         const rangeText = totalMax === Infinity ? `at least ${totalMin}` : totalMin === totalMax ? `exactly ${totalMin}` : `${totalMin}\u2013${totalMax}`;
+        const receivedText = count.min === count.max ? `${count.min}` : `${count.min}\u2013${count.max}`;
         diagnostics.push({
-          message: `<${name}> expects ${rangeText} ${totalMax === 1 && totalMin === 1 ? "child" : "children"} but received ${count}.`,
+          message: `<${name}> expects ${rangeText} ${totalMax === 1 && totalMin === 1 ? "child" : "children"} but received ${receivedText}.`,
           line: line + 1,
           col: character + 1,
           severity
@@ -567,17 +576,71 @@ function analyzeJsxSites(source, constraints, severity) {
   });
   return { diagnostics, usages };
 }
-function countStaticChildren(node) {
-  let count = 0;
-  for (const child of node.children) {
-    if (ts5.isJsxExpression(child)) return void 0;
-    if (ts5.isJsxText(child)) {
-      if (child.text.trim().length > 0) count++;
+var ZERO = { min: 0, max: 0 };
+var ONE = { min: 1, max: 1 };
+function countExpression(node) {
+  if (node.kind === ts5.SyntaxKind.NullKeyword) return ZERO;
+  if (node.kind === ts5.SyntaxKind.FalseKeyword) return ZERO;
+  if (ts5.isIdentifier(node) && node.text === "undefined") return ZERO;
+  if (ts5.isParenthesizedExpression(node)) return countExpression(node.expression);
+  if (ts5.isJsxElement(node) || ts5.isJsxSelfClosingElement(node)) return ONE;
+  if (ts5.isJsxFragment(node)) return countJsxChildren(node.children);
+  if (ts5.isArrayLiteralExpression(node)) {
+    let min = 0;
+    let max = 0;
+    for (const el of node.elements) {
+      if (ts5.isSpreadElement(el)) return void 0;
+      const c = countExpression(el);
+      if (!c) return void 0;
+      min += c.min;
+      max += c.max;
+    }
+    return { min, max };
+  }
+  if (ts5.isBinaryExpression(node)) {
+    const op = node.operatorToken.kind;
+    if (op === ts5.SyntaxKind.AmpersandAmpersandToken) {
+      const right = countExpression(node.right);
+      if (!right) return void 0;
+      return { min: 0, max: right.max };
+    }
+    if (op === ts5.SyntaxKind.BarBarToken || op === ts5.SyntaxKind.QuestionQuestionToken) {
+      const left = countExpression(node.left);
+      const right = countExpression(node.right);
+      if (!left || !right) return void 0;
+      return { min: Math.min(left.min, right.min), max: Math.max(left.max, right.max) };
+    }
+  }
+  if (ts5.isConditionalExpression(node)) {
+    const whenTrue = countExpression(node.whenTrue);
+    const whenFalse = countExpression(node.whenFalse);
+    if (!whenTrue || !whenFalse) return void 0;
+    return {
+      min: Math.min(whenTrue.min, whenFalse.min),
+      max: Math.max(whenTrue.max, whenFalse.max)
+    };
+  }
+  return void 0;
+}
+function countJsxChildren(children) {
+  let min = 0;
+  let max = 0;
+  for (const child of children) {
+    let c;
+    if (ts5.isJsxExpression(child)) {
+      c = child.expression === void 0 ? ZERO : countExpression(child.expression);
+    } else if (ts5.isJsxText(child)) {
+      c = child.text.trim().length > 0 ? ONE : ZERO;
+    } else if (ts5.isJsxFragment(child)) {
+      c = countJsxChildren(child.children);
     } else {
-      count++;
+      c = ONE;
     }
+    if (!c) return void 0;
+    min += c.min;
+    max += c.max;
   }
-  return count;
+  return { min, max };
 }
 function diagnoseUsages(source, constraints, severity) {
   if (constraints.length === 0) return [];
@@ -589,21 +652,22 @@ function diagnoseUsages(source, constraints, severity) {
     if (ts5.isJsxElement(node)) {
       const openTag = node.openingElement;
       tagName = ts5.isIdentifier(openTag.tagName) ? openTag.tagName.text : void 0;
-      count = countStaticChildren(node);
+      count = countJsxChildren(node.children);
     } else if (ts5.isJsxSelfClosingElement(node)) {
       tagName = ts5.isIdentifier(node.tagName) ? node.tagName.text : void 0;
-      count = 0;
+      count = ZERO;
     }
     if (!tagName) return;
     const constraint = byName.get(tagName);
     if (!constraint) return;
     if (count === void 0) return;
     const { totalMin, totalMax, name } = constraint;
-    if (count < totalMin || count > totalMax) {
+    if (count.max < totalMin || count.min > totalMax) {
       const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
       const rangeText = totalMax === Infinity ? `at least ${totalMin}` : totalMin === totalMax ? `exactly ${totalMin}` : `${totalMin}\u2013${totalMax}`;
+      const receivedText = count.min === count.max ? `${count.min}` : `${count.min}\u2013${count.max}`;
       diagnostics.push({
-        message: `<${name}> expects ${rangeText} ${totalMax === 1 && totalMin === 1 ? "child" : "children"} but received ${count}.`,
+        message: `<${name}> expects ${rangeText} ${totalMax === 1 && totalMin === 1 ? "child" : "children"} but received ${receivedText}.`,
         line: line + 1,
         col: character + 1,
         severity
@@ -650,12 +714,13 @@ var ConstraintRegistry = class {
         const constraint = this.resolveConstraint(fileId, usage.tagName);
         if (!constraint) continue;
         const { totalMin, totalMax, name } = constraint;
-        if (usage.count >= totalMin && usage.count <= totalMax) continue;
+        if (usage.count.max >= totalMin && usage.count.min <= totalMax) continue;
         const rangeText = totalMax === Infinity ? `at least ${totalMin}` : totalMin === totalMax ? `exactly ${totalMin}` : `${totalMin}\u2013${totalMax}`;
         const childWord = totalMax === 1 && totalMin === 1 ? "child" : "children";
+        const receivedText = usage.count.min === usage.count.max ? `${usage.count.min}` : `${usage.count.min}\u2013${usage.count.max}`;
         result.push({
           fileId,
-          message: `<${name}> expects ${rangeText} ${childWord} but received ${usage.count}.`,
+          message: `<${name}> expects ${rangeText} ${childWord} but received ${receivedText}.`,
           line: usage.line,
           col: usage.col,
           severity
@@ -1042,8 +1107,9 @@ function createStaticCompositionTransformer(factory, components, onInlined) {
     return (sourceFile) => ts7.visitEachChild(sourceFile, visit, context);
   };
 }
-function composeStatically(source, calleeNames) {
-  const components = extractStaticComponents(source, calleeNames);
+function composeStatically(source, calleeNames, importedComponents = /* @__PURE__ */ new Map()) {
+  const sameFile = extractStaticComponents(source, calleeNames);
+  const components = importedComponents.size > 0 ? new Map([...importedComponents, ...sameFile]) : sameFile;
   if (components.size === 0) return null;
   const componentNames = new Set(components.keys());
   let hasEligibleTag = false;
@@ -1074,6 +1140,27 @@ function composeStatically(source, calleeNames) {
   return output;
 }
 
+// ../vite-plugin/src/imports.ts
+import ts8 from "typescript";
+function extractImportSpecifiers(source) {
+  const result = /* @__PURE__ */ new Map();
+  walk(source, (node) => {
+    if (!ts8.isImportDeclaration(node)) return;
+    const moduleSpecifier = node.moduleSpecifier;
+    if (!ts8.isStringLiteral(moduleSpecifier)) return;
+    const specifier = moduleSpecifier.text;
+    const namedBindings = node.importClause?.namedBindings;
+    if (!namedBindings || !ts8.isNamedImports(namedBindings)) return;
+    for (const element of namedBindings.elements) {
+      if (element.isTypeOnly) continue;
+      const localName = element.name.text;
+      const importedName = element.propertyName?.text ?? localName;
+      result.set(localName, { importedName, specifier });
+    }
+  });
+  return result;
+}
+
 // ../vite-plugin/src/analyze.ts
 function analyze(code, filename, options) {
   const ext = filename.split(".").pop() ?? "";
@@ -1088,14 +1175,14 @@ function analyze(code, filename, options) {
 // ../vite-plugin/src/design-tokens.ts
 import { writeFileSync } from "fs";
 import { resolve } from "path";
-import ts8 from "typescript";
+import ts9 from "typescript";
 function collectStringValues(node, out) {
   if (!node) return;
-  if (ts8.isStringLiteral(node)) {
+  if (ts9.isStringLiteral(node)) {
     if (node.text.trim()) out.push(node.text);
     return;
   }
-  if (ts8.isArrayLiteralExpression(node)) {
+  if (ts9.isArrayLiteralExpression(node)) {
     for (const elem of node.elements) collectStringValues(elem, out);
   }
 }
@@ -1108,11 +1195,11 @@ function extractStylingTokens(stylingObj) {
   const variantsObj = asObject(getProperty(stylingObj, "variants"));
   if (variantsObj) {
     for (const dimProp of variantsObj.properties) {
-      if (!ts8.isPropertyAssignment(dimProp)) continue;
+      if (!ts9.isPropertyAssignment(dimProp)) continue;
       const valuesObj = asObject(dimProp.initializer);
       if (!valuesObj) continue;
       for (const vp of valuesObj.properties) {
-        if (!ts8.isPropertyAssignment(vp)) continue;
+        if (!ts9.isPropertyAssignment(vp)) continue;
         collectStringValues(vp.initializer, variantClasses);
       }
     }
@@ -1128,7 +1215,7 @@ function extractStylingTokens(stylingObj) {
   const tagsObj = asObject(getProperty(stylingObj, "tags"));
   if (tagsObj) {
     for (const tp of tagsObj.properties) {
-      if (!ts8.isPropertyAssignment(tp)) continue;
+      if (!ts9.isPropertyAssignment(tp)) continue;
       collectStringValues(tp.initializer, tagClasses);
     }
   }
@@ -1136,17 +1223,17 @@ function extractStylingTokens(stylingObj) {
 }
 function collectFileTokens(source, calleeNames) {
   const result = /* @__PURE__ */ new Map();
-  ts8.forEachChild(source, (stmt) => {
-    if (!ts8.isVariableStatement(stmt)) return;
+  ts9.forEachChild(source, (stmt) => {
+    if (!ts9.isVariableStatement(stmt)) return;
     for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !ts8.isCallExpression(decl.initializer)) continue;
+      if (!decl.initializer || !ts9.isCallExpression(decl.initializer)) continue;
       if (!isFactoryCall(decl.initializer, calleeNames)) continue;
       const arg = firstObjectArg(decl.initializer);
       if (!arg) continue;
       const stylingNode = getProperty(arg, "styling");
       const stylingObj = asObject(stylingNode);
       if (!stylingObj) continue;
-      const name = ts8.isIdentifier(decl.name) ? decl.name.text : void 0;
+      const name = ts9.isIdentifier(decl.name) ? decl.name.text : void 0;
       if (!name) continue;
       result.set(name, extractStylingTokens(stylingObj));
     }
@@ -1235,10 +1322,10 @@ function contractPlugin(options) {
       );
       if (importedTagsInUse.size > 0) {
         const resolvedImports = /* @__PURE__ */ new Map();
-        for (const [name, specifier] of importSpecifiers) {
-          if (!importedTagsInUse.has(name)) continue;
+        for (const [localName, { specifier }] of importSpecifiers) {
+          if (!importedTagsInUse.has(localName)) continue;
           const resolved = await this.resolve(specifier, id);
-          if (resolved) resolvedImports.set(name, resolved.id);
+          if (resolved) resolvedImports.set(localName, resolved.id);
         }
         registry.registerImports(id, resolvedImports);
         for (const usage of allUsages) {
@@ -1297,12 +1384,29 @@ function slotTransformPlugin() {
 }
 function staticCompositionPlugin(options) {
   const calleeNames = new Set(options?.calleeNames ?? DEFAULT_CALLEE_NAMES);
+  const registry = /* @__PURE__ */ new Map();
   return {
     name: "praxis-kit:static-compose",
-    transform(code, id) {
+    buildStart() {
+      registry.clear();
+    },
+    async transform(code, id) {
       const ext = id.split(".").pop() ?? "";
       if (!JSX_EXTS.has(ext)) return null;
-      const result = composeStatically(parseSource(id, code), calleeNames);
+      const source = parseSource(id, code);
+      const sameFile = extractStaticComponents(source, calleeNames);
+      if (sameFile.size > 0) registry.set(id, sameFile);
+      const importedComponents = /* @__PURE__ */ new Map();
+      const importSpecifiers = extractImportSpecifiers(source);
+      for (const [localName, { importedName, specifier }] of importSpecifiers) {
+        const resolved = await this.resolve(specifier, id);
+        if (!resolved) continue;
+        const entry = registry.get(resolved.id);
+        if (!entry) continue;
+        const component = entry.get(importedName);
+        if (component) importedComponents.set(localName, component);
+      }
+      const result = composeStatically(source, calleeNames, importedComponents);
       return result !== null ? { code: result } : null;
     }
   };
@@ -1320,6 +1424,7 @@ export {
   compoundPrunePlugin,
   contractPlugin,
   designTokensPlugin,
+  extractStaticComponents,
   injectPrecomputedClasses,
   pruneDeadCompounds,
   slotTransformPlugin,

package/dist/vue/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,25 +127,25 @@ interface PolymorphicGenerics<TDefault extends ElementType = ElementType, Props
     allowed: TAllowed;
 }
 type VariantsOf<T extends PolymorphicGenerics> = T['variants'];
-type PresetOf<T extends PolymorphicGenerics> = T['preset'];
+type RecipeOf<T extends PolymorphicGenerics> = T['preset'];
 
-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>>;
 
@@ -220,7 +220,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>>;
@@ -234,8 +234,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>>;
@@ -247,9 +247,11 @@ type FactoryOptions<TDefault extends ElementType = ElementType, Props extends An
 type DefaultOf<T extends PolymorphicGenerics> = T['default'];
 type PropsOf<T extends PolymorphicGenerics> = T['props'];
 
+declare function defineContractComponent<O extends FactoryOptions>(options: O): <R>(factory: (options: O) => R) => R;
+
 type UnknownProps = Record<string, unknown>;
 
-type VueFactoryOptions<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 VueFactoryOptions<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. Variant keys are always stripped automatically.
@@ -271,7 +273,7 @@ declare const Slottable: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNod
 type ControlProps<G extends PolymorphicGenerics, TAs extends ElementType> = PropsOf<G> & VariantProps<VariantsOf<G>> & {
     as?: TAs;
     class?: ClassName;
-    variantKey?: keyof PresetOf<G>;
+    recipe?: keyof RecipeOf<G>;
 };
 /**
  * Props for the normal (non-slot) render path. `asChild` is absent or `false`.
@@ -306,8 +308,6 @@ type PolymorphicComponent<G extends PolymorphicGenerics> = {
     displayName?: string;
 };
 
-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>(options: VueFactoryOptions<TDefault, Props, Variants, TPreset, TPluginProps>): PolymorphicComponent<PolymorphicGenerics<TDefault, Props & TPluginProps, Variants, TPreset>>;
-
-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>(options: VueFactoryOptions<TDefault, Props, Variants, TPreset, TPluginProps>): PolymorphicComponent<PolymorphicGenerics<TDefault, Props & TPluginProps, Variants, TPreset>>;
 
 export { type AnyFactoryOptions, type ElementType, type EmptyRecord, type PolymorphicComponent, type PolymorphicGenerics, type PolymorphicProps, type PolymorphicWithAsChild, Slottable, type SlottableProps, type VueFactoryOptions, createContractComponent, defineContractComponent };

package/dist/vue/index.js

@@ -20,7 +20,12 @@ function applyFilter(props, filterProps, variantKeys) {
   return out;
 }
 
-// ../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;
@@ -89,7 +94,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),
@@ -130,10 +135,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);
@@ -169,12 +174,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) {
@@ -212,8 +217,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;
@@ -238,11 +243,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 };
@@ -591,7 +596,7 @@ function isKnownAriaRole(value) {
   return isString(value) && KNOWN_ARIA_ROLES_SET.has(value);
 }
 
-// ../core/dist/chunk-VU44HAB7.js
+// ../core/dist/chunk-BNVYTMYV.js
 var IMPLICIT_ROLE_RECORD2 = {
   article: "article",
   aside: "complementary",
@@ -1526,7 +1531,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) => {
@@ -1603,18 +1608,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];
@@ -1626,7 +1631,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;
@@ -1634,10 +1639,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 });
   }
@@ -1645,15 +1650,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])}`;
     }
@@ -1678,13 +1683,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);
@@ -1850,7 +1855,7 @@ function buildDirectives(as, asChild) {
   };
 }
 function resolveRenderState(runtime, attrs, filterProps) {
-  const { as, asChild, class: className, variantKey, ...rest } = attrs;
+  const { as, asChild, class: className, recipe, ...rest } = attrs;
   const tag = runtime.resolveTag(as);
   const mergedProps = runtime.resolveProps(rest);
   const baseProps = runtime.options.normalizeFn ? runtime.options.normalizeFn(mergedProps) : mergedProps;
@@ -1860,7 +1865,7 @@ function resolveRenderState(runtime, attrs, filterProps) {
     tag,
     normalizedProps,
     typeof className === "string" ? className : void 0,
-    typeof variantKey === "string" ? variantKey : void 0
+    typeof recipe === "string" ? recipe : void 0
   );
   const filteredProps = applyFilter(normalizedProps, filterProps, runtime.options.variantKeys);
   return {
@@ -1959,11 +1964,6 @@ function createContractComponent(options) {
   }
   return Component;
 }
-
-// ../../adapters/vue/src/define-contract-component.ts
-function defineContractComponent(options) {
-  return (factory) => factory(options);
-}
 export {
   Slottable,
   createContractComponent,