praxis-kit 4.0.0 → 4.0.3

package/dist/tailwind/index.js

@@ -184,118 +184,6 @@ var iterate = Object.freeze({
   values
 });
 
-// ../../lib/diagnostics/src/category.ts
-var DiagnosticCategory = /* @__PURE__ */ ((DiagnosticCategory2) => {
-  DiagnosticCategory2[DiagnosticCategory2["Contract"] = 0] = "Contract";
-  DiagnosticCategory2[DiagnosticCategory2["HTML"] = 1] = "HTML";
-  DiagnosticCategory2[DiagnosticCategory2["ARIA"] = 2] = "ARIA";
-  DiagnosticCategory2[DiagnosticCategory2["Composition"] = 3] = "Composition";
-  DiagnosticCategory2[DiagnosticCategory2["Rendering"] = 4] = "Rendering";
-  DiagnosticCategory2[DiagnosticCategory2["Accessibility"] = 5] = "Accessibility";
-  DiagnosticCategory2[DiagnosticCategory2["Performance"] = 6] = "Performance";
-  DiagnosticCategory2[DiagnosticCategory2["Internal"] = 7] = "Internal";
-  DiagnosticCategory2[DiagnosticCategory2["Deprecation"] = 8] = "Deprecation";
-  DiagnosticCategory2[DiagnosticCategory2["Lint"] = 9] = "Lint";
-  return DiagnosticCategory2;
-})(DiagnosticCategory || {});
-
-// ../../lib/diagnostics/src/error.ts
-var PraxisError = class extends Error {
-  diagnostic;
-  constructor(diagnostic) {
-    super(diagnostic.message);
-    this.name = "PraxisError";
-    this.diagnostic = diagnostic;
-  }
-};
-
-// ../../lib/diagnostics/src/severity.ts
-var Severity = /* @__PURE__ */ ((Severity2) => {
-  Severity2[Severity2["Debug"] = 0] = "Debug";
-  Severity2[Severity2["Info"] = 1] = "Info";
-  Severity2[Severity2["Warning"] = 2] = "Warning";
-  Severity2[Severity2["Error"] = 3] = "Error";
-  Severity2[Severity2["Fatal"] = 4] = "Fatal";
-  return Severity2;
-})(Severity || {});
-
-// ../../lib/diagnostics/src/policy.ts
-var DefaultPolicy = class {
-  reportThreshold;
-  throwThreshold;
-  constructor({
-    reportThreshold = 1 /* Info */,
-    throwThreshold = 4 /* Fatal */
-  } = {}) {
-    this.reportThreshold = reportThreshold;
-    this.throwThreshold = throwThreshold;
-  }
-  resolve(diagnostic) {
-    if (diagnostic.severity >= this.throwThreshold) return 2 /* Throw */;
-    if (diagnostic.severity >= this.reportThreshold) return 1 /* Report */;
-    return 0 /* Ignore */;
-  }
-};
-
-// ../../lib/diagnostics/src/diagnostics.ts
-var Diagnostics = class {
-  reporter;
-  policy;
-  // Pre-computed at construction time: true if Warning-level diagnostics are not ignored.
-  active;
-  constructor(reporter, policy = new DefaultPolicy()) {
-    this.reporter = reporter;
-    this.policy = policy;
-    this.active = policy.resolve({ severity: 2 /* Warning */ }) !== 0 /* Ignore */;
-  }
-  report(diagnostic) {
-    const enforcement = this.policy.resolve(diagnostic);
-    if (enforcement === 0 /* Ignore */) return diagnostic;
-    if (enforcement === 2 /* Throw */) throw new PraxisError(diagnostic);
-    this.reporter.report(diagnostic);
-    return diagnostic;
-  }
-  warn(input) {
-    return this.report({ ...input, severity: 2 /* Warning */ });
-  }
-  error(input) {
-    return this.report({ ...input, severity: 3 /* Error */ });
-  }
-  info(input) {
-    return this.report({ ...input, severity: 1 /* Info */ });
-  }
-};
-
-// ../../lib/diagnostics/src/formatter.ts
-function formatDiagnostic(diagnostic) {
-  const level = Severity[diagnostic.severity];
-  const category = DiagnosticCategory[diagnostic.category];
-  const prefix = category !== void 0 ? `[${category}] ` : "";
-  return `${level} ${diagnostic.code}: ${prefix}${diagnostic.message}`;
-}
-
-// ../../lib/diagnostics/src/console-reporter.ts
-var ConsoleReporter = class {
-  report(diagnostic) {
-    const message = formatDiagnostic(diagnostic);
-    switch (diagnostic.severity) {
-      case 0 /* Debug */:
-        console.debug(message);
-        break;
-      case 1 /* Info */:
-        console.info(message);
-        break;
-      case 2 /* Warning */:
-        console.warn(message);
-        break;
-      case 3 /* Error */:
-      case 4 /* Fatal */:
-        console.error(message);
-        break;
-    }
-  }
-};
-
 // ../../node_modules/.pnpm/class-variance-authority@0.7.1/node_modules/class-variance-authority/dist/index.mjs
 import { clsx as clsx2 } from "clsx";
 var falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
@@ -649,26 +537,30 @@ var LayoutState = class {
   }
 };
 
+// ../../lib/tailwind/src/create-tailwind-pipeline.ts
+import { ConsoleReporter, Diagnostics, DefaultPolicy, Severity } from "../_shared/diagnostics.js";
+
 // ../../lib/tailwind/src/diagnostics.ts
+import { DiagnosticCategory, DiagnosticCode } from "../_shared/diagnostics.js";
 var TailwindDiagnostics = {
   multipleDisplayProps(active) {
     return {
-      code: "CSS6001" /* TailwindMultipleDisplayProps */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode.TailwindMultipleDisplayProps,
+      category: DiagnosticCategory.Contract,
       message: `[createTailwindPipeline] Multiple display props set (${active.join(", ")}); "${active[0]}" takes precedence.`
     };
   },
   reservedLayoutLiteral(reserved) {
     return {
-      code: "CSS6002" /* TailwindReservedLayoutLiteral */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode.TailwindReservedLayoutLiteral,
+      category: DiagnosticCategory.Contract,
       message: `[createTailwindPipeline] Reserved display class(es) ${reserved.map((r) => `"${r}"`).join(", ")} found in resolved classes. The display mode is controlled by the display props (flex, inline-flex, grid, block, hidden, etc.), not by class strings.`
     };
   },
   deadVariantClass(dim, value, mode, classStr) {
     return {
-      code: "CSS6003" /* TailwindDeadVariantClass */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode.TailwindDeadVariantClass,
+      category: DiagnosticCategory.Contract,
       message: `[createTailwindPipeline] Variant "${dim}=${value}" contributes only classes stripped under layout mode "${mode}" ("${classStr}") \u2014 it produces nothing in this mode.`
     };
   }
@@ -678,7 +570,7 @@ var TailwindDiagnostics = {
 var DEV = process.env.NODE_ENV !== "production";
 var devDiagnostics = new Diagnostics(
   new ConsoleReporter(),
-  new DefaultPolicy({ reportThreshold: 2 /* Warning */, throwThreshold: 4 /* Fatal */ })
+  new DefaultPolicy({ reportThreshold: Severity.Warning, throwThreshold: Severity.Fatal })
 );
 var classifier = new ClassClassifier();
 var evaluator = new DependencyEvaluator(defaultDependencyRules);

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

@@ -1,8 +1,144 @@
 import { Plugin } from 'vite';
-import { Cardinality, ChildRulePosition, Severity } from '@praxis-kit/core';
-import { DiagnosticInput } from '@praxis-kit/diagnostics';
+import { Except, Simplify } from 'type-fest';
 import ts from 'typescript';
 
+type StringMap<T = unknown> = Record<string, T>;
+type AnyRecord = StringMap<unknown>;
+
+declare enum DiagnosticCategory {
+    Contract = 0,
+    HTML = 1,
+    ARIA = 2,
+    Composition = 3,
+    Rendering = 4,
+    Accessibility = 5,
+    Performance = 6,
+    Internal = 7,
+    Deprecation = 8,
+    Lint = 9
+}
+
+declare enum DiagnosticCode {
+    MissingRequiredChild = "COMP1001",
+    InvalidParent = "COMP1002",
+    InvalidChild = "COMP1003",
+    UnexpectedChild = "COMP1004",
+    AmbiguousChild = "COMP1005",
+    CardinalityMin = "COMP1006",
+    CardinalityMax = "COMP1007",
+    PositionViolation = "COMP1008",
+    AllowedAsViolation = "COMP1009",
+    SlotExclusive = "SLOT1001",
+    SlotSingleChild = "SLOT1002",
+    SlotDiscardedChildren = "SLOT1003",
+    SlotRenderFn = "SLOT1004",
+    MissingAriaRelationship = "ARIA2001",
+    AriaViolation = "ARIA2002",
+    AriaAttributeInvalid = "ARIA2003",
+    AriaMissingLiveRegion = "ARIA2004",
+    AriaMissingAtomic = "ARIA2005",
+    AriaRelevantInvalidToken = "ARIA2006",
+    AriaRelevantSuperseded = "ARIA2007",
+    AriaInvalidRole = "ARIA2008",
+    AriaMissingAccessibleName = "ARIA2009",
+    AriaAttributeOnPresentational = "ARIA2010",
+    AriaHiddenOnFocusable = "ARIA2011",
+    AriaRequiredProperty = "ARIA2012",
+    AriaInvalidAttributeValue = "ARIA2013",
+    AriaRedundantLevelAttribute = "ARIA2014",
+    InvalidHeadingHierarchy = "HTML3001",
+    HtmlEmptyRole = "HTML3002",
+    HtmlImplicitRoleRedundant = "HTML3003",
+    HtmlImplicitRoleOverride = "HTML3004",
+    HtmlStandaloneRegionOverride = "HTML3005",
+    HtmlLandmarkRoleOverride = "HTML3006",
+    HtmlInvalidChild = "HTML3007",
+    InvalidRenderingTarget = "RENDER4001",
+    LintDeadCompoundKey = "LINT5001",
+    LintDeadCompoundValue = "LINT5002",
+    LintDeadCompoundNonLiteral = "LINT5003",
+    LintMissingStrict = "LINT5004",
+    LintInvalidDefaultKey = "LINT5005",
+    LintInvalidDefaultValue = "LINT5006",
+    LintInvalidDefaultNonLiteral = "LINT5007",
+    LintNegativeMin = "LINT5008",
+    LintNegativeMax = "LINT5009",
+    LintMaxLessThanMin = "LINT5010",
+    LintZeroMax = "LINT5011",
+    LintMultipleFirst = "LINT5012",
+    LintMultipleLast = "LINT5013",
+    LintMinSumExceedsCapacity = "LINT5014",
+    LintCardinalityViolation = "LINT5015",
+    LintAriaTagOverride = "LINT5016",
+    ContractUnknownVariantDim = "COMP1010",
+    ContractUnknownVariantValue = "COMP1011",
+    ContractUnknownRecipeKey = "COMP1012",
+    ContractInvalidVariantValue = "COMP1013",
+    TailwindMultipleDisplayProps = "CSS6001",
+    TailwindReservedLayoutLiteral = "CSS6002",
+    TailwindDeadVariantClass = "CSS6003",
+    PluginInvalidShape = "PLUGIN7001",
+    PluginPipelineReturnType = "PLUGIN7002",
+    InternalError = "INTERNAL9000"
+}
+
+interface SourcePosition {
+    line: number;
+    col: number;
+}
+interface SourceLocation {
+    file: string;
+    start: SourcePosition;
+    end?: SourcePosition;
+}
+
+declare enum Severity$1 {
+    Debug = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3,
+    Fatal = 4
+}
+
+interface DiagnosticSuggestion {
+    title: string;
+    description?: string;
+    fix?: string;
+}
+
+type Context = AnyRecord;
+type Metadata = AnyRecord;
+interface Diagnostic$1 {
+    code: DiagnosticCode;
+    severity: Severity$1;
+    category: DiagnosticCategory;
+    message: string;
+    rationale?: string;
+    component?: string;
+    contract?: string;
+    location?: SourceLocation;
+    suggestions?: DiagnosticSuggestion[];
+    context?: Context;
+    metadata?: Metadata;
+}
+
+type DiagnosticInput = Except<Diagnostic$1, 'severity'>;
+
+type MinMax = {
+    min: number;
+    max: number;
+};
+/** Unboundedness is encoded in the type, not a sentinel value, enabling exhaustive switches. */
+type Cardinality = Simplify<{
+    kind: 'bounded';
+} & MinMax> | {
+    kind: 'unbounded';
+};
+
+type ChildRulePosition = 'first' | 'last' | 'any';
+
+type Severity = 'error' | 'warning' | (string & {});
+
 /**
  * One enforcement.children rule whose cardinality is statically extractable
  * from the factory call AST. The `Cardinality` discriminated union matches the

package/dist/vue/index.d.ts

@@ -1,9 +1,238 @@
-import { ElementType, VariantMap, RecipeMap, EmptyRecord, ClassPluginFactory, AnyRecord, FactoryOptions, PolymorphicGenerics, DefaultOf, PropsOf, VariantProps, VariantsOf, ClassName, RecipeOf, ExtractPluginProps } from '@praxis-kit/core';
-export { AnyFactoryOptions, ElementType, EmptyRecord, PolymorphicGenerics } from '@praxis-kit/core';
+import { RequireAtLeastOne, Simplify, ReadonlyDeep } from 'type-fest';
+import { Diagnostics, DiagnosticInput } from '../_shared/diagnostics.js';
 import * as vue from 'vue';
 import { AllowedComponentProps } from 'vue';
-import { Simplify } from 'type-fest';
-export { defineContractComponent } from '@praxis-kit/adapter-utils';
+
+type StringMap<T = unknown> = Record<string, T>;
+type AnyRecord = StringMap<unknown>;
+
+type IntrinsicTag = keyof HTMLElementTagNameMap;
+
+type ElementType = IntrinsicTag | (string & {});
+
+declare const KNOWN_ARIA_ROLES: readonly ["alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem"];
+type KnownAriaRole = (typeof KNOWN_ARIA_ROLES)[number];
+
+type Booleanish = boolean | 'true' | 'false';
+type ClassName = string | string[];
+type EmptyRecord = Record<never, never>;
+type NonEmptyArray<T> = [T, ...T[]];
+type Numberish = number | `${number}`;
+type Primitive = string | number | boolean;
+type AriaRole = KnownAriaRole | (string & {});
+type IntrinsicProps = AnyRecord & {
+    role?: AriaRole;
+};
+type TagMap = Partial<Record<IntrinsicTag | (string & {}), ClassName>>;
+
+type MinMax = {
+    min: number;
+    max: number;
+};
+type CardinalityInput = Partial<MinMax>;
+
+type ChildRuleMatch<T, U extends T = T> = (child: T) => child is U;
+
+type ChildRulePosition = 'first' | 'last' | 'any';
+
+type ChildRuleInput<T = unknown, U extends T = T> = {
+    name: string;
+    match: ChildRuleMatch<T, U>;
+    cardinality?: CardinalityInput;
+    position?: ChildRulePosition;
+    /**
+     * Optional component-type reference for O(1) dispatch index.
+     * When provided for every rule, the matcher reads child.type instead of
+     * calling every match function on every child (O(n×m) → O(n+m)).
+     */
+    type?: unknown;
+};
+
+type ValidResult = {
+    valid: true;
+};
+
+type RequireAtLeastOneIfNotEmpty<T> = keyof T extends never ? EmptyRecord : RequireAtLeastOne<T>;
+type CompoundVariantConditionValue<V extends VariantMap, K extends keyof V> = VariantKey<V, K> | NonEmptyArray<VariantKey<V, K>>;
+type CompoundVariantConditions<V extends VariantMap> = Simplify<{
+    [K in keyof V]: CompoundVariantConditionValue<V, K>;
+}>;
+type CompoundVariantRequiredConditions<V extends VariantMap> = RequireAtLeastOneIfNotEmpty<CompoundVariantConditions<V>>;
+type CompoundVariantBase<V extends VariantMap> = keyof V extends never ? EmptyRecord : CompoundVariantRequiredConditions<V>;
+type CompoundVariant<V extends VariantMap> = CompoundVariantBase<V> & {
+    class: VariantValue;
+};
+
+interface CVACompounds<V extends VariantMap> {
+    compoundVariants?: readonly CompoundVariant<V>[];
+}
+
+interface CVADefaults<V extends VariantMap> {
+    defaultVariants?: DefaultVariants<V>;
+}
+
+interface CVAVariants<V extends VariantMap> {
+    variants?: V;
+}
+
+type StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T;
+type VariantValue = string | string[];
+type VariantStates<K extends string = string> = Record<K, VariantValue>;
+type VariantMap<V extends string = string, K extends string = string> = Record<V, VariantStates<K>>;
+type VariantKey<V extends VariantMap, K extends keyof V> = StringToBoolean<keyof V[K] & string>;
+/**
+ * A partial selection of variant states authored at factory definition time.
+ *
+ * Uses `keyof V[K]` directly (not `VariantKey`) so TypeScript can eagerly
+ * resolve the union at constraint-check time without deferred conditional types.
+ */
+type VariantSelection<V extends VariantMap> = {
+    [K in keyof V]?: keyof V[K];
+};
+/** The full optional prop surface exposed to callers for a given variant map. */
+type VariantProps<V extends VariantMap> = {
+    [K in keyof V]?: VariantKey<V, K>;
+};
+type NormalizedVariantValue<K extends string> = string extends K ? Primitive : K extends 'true' | 'false' ? Booleanish : K extends `${number}` ? Numberish : K;
+type DefaultVariants<V extends VariantMap> = {
+    [K in keyof V]?: NormalizedVariantValue<keyof V[K] & string>;
+};
+/**
+ * A static, immutable map of named presets to partial variant selections.
+ *
+ * Presets are named bundles of variant props that callers activate by key,
+ * avoiding the need to repeat variant combinations at each call site.
+ */
+type RecipeMap<V extends VariantMap = VariantMap> = Readonly<Record<string, VariantSelection<V>>>;
+type RecipeTarget<TVariants extends VariantMap = VariantMap> = VariantSelection<TVariants>;
+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;
+    preset: TPreset;
+    allowed: TAllowed;
+}
+type VariantsOf<T extends PolymorphicGenerics> = T['variants'];
+type RecipeOf<T extends PolymorphicGenerics> = T['preset'];
+type DefaultOf<T extends PolymorphicGenerics> = T['default'];
+type PropsOf<T extends PolymorphicGenerics> = T['props'];
+
+interface BaseClassOptions {
+    baseClassName?: ClassName;
+}
+
+type ClassPipelineFn = (tag: unknown, props: AnyRecord, className?: ClassName, recipe?: string) => string;
+
+interface RecipeOptions<TVariants extends VariantMap = VariantMap> {
+    recipeMap?: Record<string, RecipeTarget<TVariants>>;
+}
+
+interface TagMapOptions {
+    tagMap?: TagMap;
+}
+
+type CompositionOptions<TVariants extends VariantMap = VariantMap> = Simplify<TagMapOptions & RecipeOptions<TVariants>>;
+
+type CVASystemOptions<TVariants extends VariantMap = VariantMap> = Simplify<CVAVariants<TVariants> & CVADefaults<TVariants> & CVACompounds<TVariants>>;
+
+type StyleOptions<TVariants extends VariantMap = VariantMap> = Simplify<BaseClassOptions & CVASystemOptions<TVariants>>;
+
+type ClassPipelineOptions<TVariants extends VariantMap = VariantMap> = Simplify<StyleOptions<TVariants> & CompositionOptions<TVariants>>;
+
+type OwnedPropKeys = ReadonlySet<string>;
+
+type ClassPlugin<TProps extends AnyRecord = EmptyRecord> = Readonly<{
+    pipeline: ClassPipelineFn;
+    ownedKeys?: OwnedPropKeys;
+    readonly _pluginProps?: TProps;
+}>;
+
+type ClassPluginFactory<TProps extends AnyRecord = EmptyRecord> = <V extends VariantMap>(options: ClassPipelineOptions<V>, diagnostics: Diagnostics) => ClassPlugin<TProps>;
+type ExtractPluginProps<TPlugin extends ClassPluginFactory<AnyRecord> | undefined> = TPlugin extends ClassPluginFactory<infer T> ? string extends keyof T ? EmptyRecord : T : EmptyRecord;
+
+type AriaContext = {
+    readonly tag: IntrinsicTag;
+    readonly implicitRole: AriaRole | undefined;
+    readonly effectiveRole: string | undefined;
+    readonly props: ReadonlyDeep<IntrinsicProps>;
+};
+
+type RemoveAttributeFixKind = `removeAttribute:${string}`;
+type InjectLiveFixKind = `injectLive:${string}`;
+type FixKind = 'removeRole' | 'setRole' | 'normalizeRelevantAll' | RemoveAttributeFixKind | InjectLiveFixKind;
+
+type AriaFixResult = {
+    applied: false;
+    next: ReadonlyDeep<IntrinsicProps>;
+} | {
+    applied: true;
+    next: ReadonlyDeep<IntrinsicProps>;
+    previous: ReadonlyDeep<IntrinsicProps>;
+};
+type AriaFix = {
+    readonly kind: FixKind;
+    readonly priority?: number;
+    readonly source?: string;
+    readonly apply: (context: AriaContext) => AriaFixResult;
+};
+
+type Severity = 'error' | 'warning' | (string & {});
+
+type AriaInvalidBase<M extends string = string> = {
+    valid: false;
+    severity: Severity;
+    message?: M;
+    attribute?: string;
+    diagnostic?: DiagnosticInput;
+};
+type AriaInvalidWithFix<M extends string = string> = AriaInvalidBase<M> & {
+    fixable: true;
+    fix: AriaFix;
+};
+type AriaInvalidWithoutFix<M extends string = string> = AriaInvalidBase<M> & {
+    fixable: false;
+};
+type AriaInvalidResult<M extends string = string> = AriaInvalidWithFix<M> | AriaInvalidWithoutFix<M>;
+type AriaResult = ValidResult | AriaInvalidResult;
+
+type AriaRule<C extends AriaContext = AriaContext> = (context: C) => readonly AriaResult[];
+
+type PropNormalizer = (props: Readonly<AnyRecord & IntrinsicProps>) => Partial<AnyRecord & IntrinsicProps>;
+
+type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
+    readonly diagnostics?: Diagnostics;
+    readonly aria?: readonly AriaRule[];
+    readonly children?: readonly ChildRuleInput[];
+    readonly props?: readonly PropNormalizer[];
+    /** Restricts the `as` prop to this set of tags. Violations route through diagnostics. */
+    readonly allowedAs?: readonly TAllowed[];
+};
+
+type StylingOptions<V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends RecipeMap<V> = Readonly<EmptyRecord>, TPlugin extends ClassPluginFactory<AnyRecord> | undefined = ClassPluginFactory<AnyRecord> | undefined> = {
+    readonly base?: ClassName;
+    readonly variants?: V;
+    readonly defaults?: Partial<DefaultVariants<V>>;
+    readonly compounds?: readonly CompoundVariant<V>[];
+    readonly presets?: TPreset;
+    readonly tags?: Readonly<TagMap>;
+    readonly plugin?: TPlugin;
+    readonly precomputedClasses?: Readonly<Record<string, string>>;
+};
+
+type NormalizeFn<Props extends AnyRecord = AnyRecord> = {
+    normalize(props: Readonly<Props & IntrinsicProps>): Props & IntrinsicProps;
+}['normalize'];
+type AnyFactoryOptions = FactoryOptions<ElementType, AnyRecord, VariantMap, RecipeMap<VariantMap>, ClassPluginFactory<AnyRecord> | undefined>;
+type FactoryOptions<TDefault extends ElementType = ElementType, Props extends AnyRecord = EmptyRecord, V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends RecipeMap<V> = Readonly<EmptyRecord>, TPlugin extends ClassPluginFactory<AnyRecord> | undefined = ClassPluginFactory<AnyRecord> | undefined, TAllowed extends ElementType = ElementType> = {
+    readonly tag?: TDefault;
+    readonly name?: string;
+    readonly defaults?: Partial<NoInfer<Props>>;
+    readonly normalize?: NormalizeFn<NoInfer<Props>>;
+    readonly styling?: StylingOptions<V, TPreset, TPlugin>;
+    readonly enforcement?: EnforcementOptions<TAllowed>;
+};
+
+declare function defineContractComponent<O extends FactoryOptions>(options: O): <R>(factory: (options: O) => R) => R;
 
 type SlottableProps = {
     children?: unknown;
@@ -66,4 +295,4 @@ type PolymorphicComponent<G extends PolymorphicGenerics> = {
 
 declare function createContractComponent<TDefault extends ElementType, Props extends UnknownProps = EmptyRecord, Variants extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends RecipeMap<Variants> = Readonly<EmptyRecord>, TPlugin extends ClassPluginFactory<AnyRecord> | undefined = ClassPluginFactory<AnyRecord> | undefined>(options: VueFactoryOptions<TDefault, Props, Variants, TPreset, TPlugin>): PolymorphicComponent<PolymorphicGenerics<TDefault, Props & ExtractPluginProps<TPlugin>, Variants, TPreset>>;
 
-export { type PolymorphicComponent, type PolymorphicProps, type PolymorphicWithAsChild, Slottable, type SlottableProps, type VueFactoryOptions, createContractComponent };
+export { type AnyFactoryOptions, type ElementType, type EmptyRecord, type PolymorphicComponent, type PolymorphicGenerics, type PolymorphicProps, type PolymorphicWithAsChild, Slottable, type SlottableProps, type VueFactoryOptions, createContractComponent, defineContractComponent };