praxis-kit 4.0.3 → 4.1.0

package/dist/vue/index.js

@@ -1,18 +1,8 @@
 // ../../adapters/vue/src/create-contract-component.ts
-import { cloneVNode, computed, defineComponent as defineComponent2 } from "vue";
+import { computed, defineComponent as defineComponent2 } from "vue";
 
-// ../../lib/adapter-utils/src/invariant.ts
-function panic(message) {
-  throw new Error(message);
-}
-function invariant(condition, message) {
-  if (!condition) panic(message);
-}
-
-// ../../lib/adapter-utils/src/apply-display-name.ts
-function applyDisplayName(component, name) {
-  Object.assign(component, { displayName: name ?? "PolymorphicComponent" });
-}
+// ../../lib/primitive/src/guards/children/component-id.ts
+var COMPONENT_DEFAULT_TAG = /* @__PURE__ */ Symbol.for("praxis.component-default-tag");
 
 // ../../lib/primitive/src/utils/is-object.ts
 function isObject(value, excludeArrays = false) {
@@ -26,185 +16,66 @@ function isNumber(value) {
   return typeof value === "number";
 }
 
-// ../../lib/primitive/src/merge/predicates.ts
-function isFunction(value) {
-  return typeof value === "function";
+// ../../lib/primitive/src/guards/foundational/is-defined.ts
+function isUndefined(value) {
+  return value === void 0;
 }
 
-// ../../lib/primitive/src/utils/assert-never.ts
-function assertNever(value) {
-  throw new Error(`Unexpected value: ${String(value)}`);
+// ../../lib/primitive/src/guards/foundational/is-null.ts
+function isNull(value) {
+  return value === null;
 }
 
-// ../../lib/primitive/src/utils/iterate.ts
-function find(iterable, callback) {
-  for (const value of iterable) {
-    const result = callback(value);
-    if (result != null) {
-      return result;
-    }
-  }
-  return null;
-}
-function some(iterable, predicate) {
-  for (const value of iterable) {
-    if (predicate(value)) return true;
-  }
-  return false;
-}
-function every(iterable, predicate) {
-  let index = 0;
-  for (const value of iterable) {
-    if (!predicate(value, index++)) {
-      return false;
-    }
-  }
-  return true;
-}
-function* filter(iterable, predicate) {
-  let index = 0;
-  for (const value of iterable) {
-    if (predicate(value, index++)) {
-      yield value;
-    }
-  }
-}
-function* map(iterable, callback) {
-  let index = 0;
-  for (const value of iterable) {
-    yield callback(value, index++);
-  }
-}
-function forEach(iterable, callback) {
-  let index = 0;
-  for (const value of iterable) {
-    callback(value, index++);
-  }
-}
-function reduce(iterable, initial, callback) {
-  let accumulator = initial;
-  let index = 0;
-  for (const value of iterable) {
-    accumulator = callback(accumulator, value, index++);
-  }
-  return accumulator;
-}
-function collect(iterable, callback) {
-  const result = {};
-  let index = 0;
-  for (const value of iterable) {
-    const entry = callback(value, index++);
-    if (entry === null) {
-      return null;
-    }
-    result[entry[0]] = entry[1];
-  }
-  return result;
-}
-function findLast(value, callback) {
-  for (let index = value.length - 1; index >= 0; index--) {
-    const result = callback(value[index], index);
-    if (result != null) {
-      return result;
-    }
-  }
-  return null;
-}
-function* items(collection) {
-  for (let i = 0; i < collection.length; i++) {
-    const item = collection.item(i);
-    if (item !== null) {
-      yield item;
-    }
-  }
-}
-function nodeList(list) {
-  return {
-    *[Symbol.iterator]() {
-      for (let i = 0; i < list.length; i++) {
-        const node = list.item(i);
-        if (node !== null) {
-          yield node;
-        }
-      }
-    }
-  };
-}
-function mapEntries(m) {
-  return m.entries();
-}
-function set(s) {
-  return s.values();
-}
-function hasOwn(object, key) {
-  return Object.hasOwn(object, key);
-}
-function* entries(object) {
-  for (const key in object) {
-    if (!hasOwn(object, key)) continue;
-    yield [key, object[key]];
-  }
-}
-function* keys(object) {
-  for (const [key] of entries(object)) {
-    yield key;
-  }
+// ../../lib/primitive/src/guards/children/is-tag.ts
+function getAsProp(child) {
+  if (!isObject(child) || !("props" in child)) return void 0;
+  const props = child.props;
+  if (!isObject(props)) return void 0;
+  const as = props.as;
+  return isString(as) && as !== "" ? as : void 0;
 }
-function* values(object) {
-  for (const [, value] of entries(object)) {
-    yield value;
+function getTag(child) {
+  if (!isObject(child) || !("type" in child)) return void 0;
+  const t = child.type;
+  if (isString(t)) return t;
+  if (typeof t === "function" || isObject(t)) {
+    const defaultTag = t[COMPONENT_DEFAULT_TAG];
+    if (!isString(defaultTag)) return void 0;
+    return getAsProp(child) ?? defaultTag;
   }
+  return void 0;
 }
-function mapValues(object, callback) {
-  const result = {};
-  for (const [key, value] of entries(object)) {
-    result[key] = callback(value, key);
+function isTag(...args) {
+  if (isString(args[0])) {
+    const set3 = new Set(args);
+    return (child2) => {
+      const tag2 = getTag(child2);
+      return tag2 !== void 0 && set3.has(tag2);
+    };
   }
-  return result;
+  const [child, ...tags] = args;
+  const set2 = new Set(tags);
+  const tag = getTag(child);
+  return tag !== void 0 && set2.has(tag);
 }
-function forEachEntry(object, callback) {
-  for (const [key, value] of entries(object)) {
-    callback(key, value);
-  }
+
+// ../../lib/adapter-utils/src/invariant.ts
+function panic(message) {
+  throw new Error(message);
 }
-function forEachKey(object, callback) {
-  for (const key of keys(object)) {
-    callback(key);
-  }
+function invariant(condition, message) {
+  if (!condition) panic(message);
 }
-function forEachValue(object, callback) {
-  for (const value of values(object)) {
-    callback(value);
-  }
+
+// ../../lib/adapter-utils/src/runtime/apply-display-name.ts
+function applyDisplayName(component, name) {
+  Object.assign(component, { displayName: name ?? "PolymorphicComponent" });
 }
-function forEachSet(s, callback) {
-  for (const value of s) {
-    callback(value);
-  }
+
+// ../../lib/adapter-utils/src/runtime/define-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
 }
-var iterate = Object.freeze({
-  entries,
-  filter,
-  find,
-  findLast,
-  forEach,
-  forEachEntry,
-  forEachKey,
-  forEachSet,
-  forEachValue,
-  items,
-  keys,
-  map,
-  mapEntries,
-  mapValues,
-  nodeList,
-  reduce,
-  collect,
-  set,
-  some,
-  every,
-  values
-});
 
 // ../../lib/primitive/src/constants/aria/global-aria-attributes.ts
 var GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
@@ -228,7 +99,7 @@ var GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
 ]);
 
 // ../../lib/primitive/src/constants/aria/implicit-role-record.ts
-var IMPLICIT_ROLE_RECORD = {
+var IMPLICIT_ROLE_RECORD = Object.freeze({
   // Landmarks
   article: "article",
   aside: "complementary",
@@ -264,8 +135,8 @@ var IMPLICIT_ROLE_RECORD = {
   meter: "meter",
   output: "status",
   progress: "progressbar"
-};
-var INPUT_TYPE_ROLE_MAP = {
+});
+var INPUT_TYPE_ROLE_MAP = Object.freeze({
   checkbox: "checkbox",
   radio: "radio",
   range: "slider",
@@ -279,18 +150,106 @@ var INPUT_TYPE_ROLE_MAP = {
   submit: "button",
   reset: "button",
   image: "button"
-};
-var STRONG_ROLES = [
+});
+var STRONG_ROLES = Object.freeze([
   "main",
   "navigation",
   "complementary",
   "contentinfo",
   "banner"
-];
-var STANDALONE_ROLES = ["article"];
+]);
+var STANDALONE_ROLES = Object.freeze([
+  "article"
+]);
 var STRONG_ROLES_SET = new Set(STRONG_ROLES);
 var STANDALONE_ROLES_SET = new Set(STANDALONE_ROLES);
 
+// ../../lib/primitive/src/constants/aria/known-aria-roles.ts
+var KNOWN_ARIA_ROLES = Object.freeze([
+  "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"
+]);
+var KNOWN_ARIA_ROLES_SET = new Set(KNOWN_ARIA_ROLES);
+
 // ../../lib/primitive/src/constants/aria/role-restricted-attributes.ts
 var ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
   [
@@ -442,16 +401,6 @@ var ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
   ]
 ]);
 
-// ../../lib/primitive/src/guards/foundational/is-defined.ts
-function isUndefined(value) {
-  return value === void 0;
-}
-
-// ../../lib/primitive/src/guards/foundational/is-null.ts
-function isNull(value) {
-  return value === null;
-}
-
 // ../../lib/primitive/src/guards/aria/is-aria-attribute.ts
 function isGlobalAriaAttribute(attr) {
   return GLOBAL_ARIA_ATTRIBUTES.has(attr);
@@ -473,51 +422,20 @@ function isStandaloneTag(tag) {
   return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
 }
 function getInputImplicitRole(type) {
-  if (type == null || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
+  if (!isString(type) || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
   return INPUT_TYPE_ROLE_MAP[type];
 }
 function getConditionalImplicitRole(tag, ariaLabel, ariaLabelledBy) {
-  const isNamed = typeof ariaLabel === "string" || typeof ariaLabelledBy === "string";
+  const isNamed = isString(ariaLabel) || isString(ariaLabelledBy);
   if (!isNamed) return void 0;
   if (tag === "section") return "region";
   if (tag === "form") return "form";
   return void 0;
 }
 
-// ../../lib/primitive/src/guards/children/component-id.ts
-var COMPONENT_DEFAULT_TAG = /* @__PURE__ */ Symbol.for("praxis.component-default-tag");
-
-// ../../lib/primitive/src/guards/children/is-tag.ts
-function getAsProp(child) {
-  if (!isObject(child) || !("props" in child)) return void 0;
-  const props = child.props;
-  if (!isObject(props)) return void 0;
-  const as = props.as;
-  return isString(as) && as !== "" ? as : void 0;
-}
-function getTag(child) {
-  if (!isObject(child) || !("type" in child)) return void 0;
-  const t = child.type;
-  if (isString(t)) return t;
-  if (typeof t === "function" || isObject(t)) {
-    const defaultTag = t[COMPONENT_DEFAULT_TAG];
-    if (!isString(defaultTag)) return void 0;
-    return getAsProp(child) ?? defaultTag;
-  }
-  return void 0;
-}
-function isTag(...args) {
-  if (isString(args[0])) {
-    const set3 = new Set(args);
-    return (child2) => {
-      const tag2 = getTag(child2);
-      return tag2 !== void 0 && set3.has(tag2);
-    };
-  }
-  const [child, ...tags] = args;
-  const set2 = new Set(tags);
-  const tag = getTag(child);
-  return tag !== void 0 && set2.has(tag);
+// ../../lib/primitive/src/guards/aria/is-known-aria-role.ts
+function isKnownAriaRole(value) {
+  return isString(value) && KNOWN_ARIA_ROLES_SET.has(value);
 }
 
 // ../../lib/contract/src/aria/aria-role-policy.ts
@@ -528,7 +446,203 @@ function getImplicitRole(tag, props) {
   if (tag === "section" || tag === "form") {
     return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
   }
-  return void 0;
+  return void 0;
+}
+
+// ../../lib/primitive/src/tag/resolve-tag.ts
+function makeResolveTag(defaultTag) {
+  return function tag(as) {
+    return as ?? defaultTag;
+  };
+}
+
+// ../../lib/primitive/src/utils/assert-never.ts
+function assertNever(value) {
+  throw new Error(`Unexpected value: ${String(value)}`);
+}
+
+// ../../lib/primitive/src/utils/cn.ts
+import { clsx } from "clsx";
+function cn(...inputs) {
+  return clsx(...inputs);
+}
+
+// ../../lib/primitive/src/utils/iterate.ts
+function find(iterable, callback) {
+  for (const value of iterable) {
+    const result = callback(value);
+    if (result != null) {
+      return result;
+    }
+  }
+  return null;
+}
+function some(iterable, predicate) {
+  for (const value of iterable) {
+    if (predicate(value)) return true;
+  }
+  return false;
+}
+function every(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (!predicate(value, index++)) {
+      return false;
+    }
+  }
+  return true;
+}
+function* filter(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (predicate(value, index++)) {
+      yield value;
+    }
+  }
+}
+function* map(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    yield callback(value, index++);
+  }
+}
+function forEach(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    callback(value, index++);
+  }
+}
+function reduce(iterable, initial, callback) {
+  let accumulator = initial;
+  let index = 0;
+  for (const value of iterable) {
+    accumulator = callback(accumulator, value, index++);
+  }
+  return accumulator;
+}
+function collect(iterable, callback) {
+  const result = {};
+  let index = 0;
+  for (const value of iterable) {
+    const entry = callback(value, index++);
+    if (entry === null) {
+      return null;
+    }
+    result[entry[0]] = entry[1];
+  }
+  return result;
+}
+function findLast(value, callback) {
+  for (let index = value.length - 1; index >= 0; index--) {
+    const result = callback(value[index], index);
+    if (result != null) {
+      return result;
+    }
+  }
+  return null;
+}
+function* items(collection) {
+  for (let i = 0; i < collection.length; i++) {
+    const item = collection.item(i);
+    if (item !== null) {
+      yield item;
+    }
+  }
+}
+function nodeList(list) {
+  return {
+    *[Symbol.iterator]() {
+      for (let i = 0; i < list.length; i++) {
+        const node = list.item(i);
+        if (node !== null) {
+          yield node;
+        }
+      }
+    }
+  };
+}
+function mapEntries(m) {
+  return m.entries();
+}
+function set(s) {
+  return s.values();
+}
+function hasOwn(object, key) {
+  return Object.hasOwn(object, key);
+}
+function* entries(object) {
+  for (const key in object) {
+    if (!hasOwn(object, key)) continue;
+    yield [key, object[key]];
+  }
+}
+function* keys(object) {
+  for (const [key] of entries(object)) {
+    yield key;
+  }
+}
+function* values(object) {
+  for (const [, value] of entries(object)) {
+    yield value;
+  }
+}
+function mapValues(object, callback) {
+  const result = {};
+  for (const [key, value] of entries(object)) {
+    result[key] = callback(value, key);
+  }
+  return result;
+}
+function forEachEntry(object, callback) {
+  for (const [key, value] of entries(object)) {
+    callback(key, value);
+  }
+}
+function forEachKey(object, callback) {
+  for (const key of keys(object)) {
+    callback(key);
+  }
+}
+function forEachValue(object, callback) {
+  for (const value of values(object)) {
+    callback(value);
+  }
+}
+function forEachSet(s, callback) {
+  for (const value of s) {
+    callback(value);
+  }
+}
+var iterate = Object.freeze({
+  entries,
+  filter,
+  find,
+  findLast,
+  forEach,
+  forEachEntry,
+  forEachKey,
+  forEachSet,
+  forEachValue,
+  items,
+  keys,
+  map,
+  mapEntries,
+  mapValues,
+  nodeList,
+  reduce,
+  collect,
+  set,
+  some,
+  every,
+  values
+});
+
+// ../../lib/primitive/src/utils/merge-props.ts
+function mergeProps(defaultProps, props) {
+  return {
+    ...defaultProps ?? {},
+    ...props
+  };
 }
 
 // ../../lib/contract/src/strict/invariant-base.ts
@@ -777,18 +891,18 @@ var ContractDiagnostics = {
       message: `${context}: "${ruleName}" must be ${position}, got index ${index}`
     };
   },
-  unknownVariantDim(component, label, dim) {
+  unknownVariantDim(component, label2, dim) {
     return {
       code: DiagnosticCode2.ContractUnknownVariantDim,
       category: DiagnosticCategory2.Contract,
-      message: `${component}: ${label} references unknown variant "${dim}".`
+      message: `${component}: ${label2} references unknown variant "${dim}".`
     };
   },
-  unknownVariantValue(component, label, dim, value, valid) {
+  unknownVariantValue(component, label2, dim, value, valid) {
     return {
       code: DiagnosticCode2.ContractUnknownVariantValue,
       category: DiagnosticCategory2.Contract,
-      message: `${component}: ${label} sets "${dim}" to unknown value "${value}" (valid: ${valid.join(", ")}).`
+      message: `${component}: ${label2} sets "${dim}" to unknown value "${value}" (valid: ${valid.join(", ")}).`
     };
   },
   unknownRecipeKey(component, key) {
@@ -1586,7 +1700,7 @@ function getTypeName(value) {
     return primitive;
   }
   const name = value.constructor?.name;
-  return typeof name === "string" && name !== "Object" ? name : "object";
+  return isString(name) && name !== "Object" ? name : "object";
 }
 
 // ../../lib/contract/src/children/normalize-child-rule.ts
@@ -1880,6 +1994,7 @@ function landmarkNameAdvisory(ctx) {
   if (!ctx.implicitRole || !NAMED_LANDMARK_TAGS.has(ctx.tag)) return [];
   return requireAccessibleName(ctx);
 }
+var HTML_ARIA_RULES = [landmarkRoleRule, landmarkNameAdvisory];
 
 // ../core/src/html/contracts.ts
 import { warnDiagnostics } from "../_shared/diagnostics.js";
@@ -2055,404 +2170,492 @@ function getHtmlPropNormalizers(tag) {
   return typeof tag === "string" ? HTML_FORM_NORMALIZERS.get(tag) : void 0;
 }
 
-// ../../lib/styling/src/variant-pass/compile-variant-lookup.ts
-function buildPrecomputedKey(props) {
-  return Object.entries(props).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}:${v}`).join("|");
-}
-
-// ../../lib/styling/src/variant-pass/variant-pass.ts
-function createVariantPass(activeProps, config) {
-  return {
-    name: "variant",
-    execute() {
-      const preset = typeof activeProps["preset"] === "string" ? activeProps["preset"] : void 0;
-      const presetDefaults = preset !== void 0 && config.presets?.[preset] !== void 0 ? config.presets[preset] : {};
-      const resolved = {
-        ...config.defaults,
-        ...presetDefaults,
-        ...activeProps
-      };
-      const classes = [];
-      iterate.forEachEntry(config.variants, (key, valueMap) => {
-        const active = resolved[key];
-        if (typeof active === "string") {
-          const cls = valueMap[active];
-          if (cls !== void 0) classes.push(cls);
-        }
-      });
-      return { context: { classes } };
+// ../../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;
+var cx = clsx2;
+var cva = (base, config) => (props) => {
+  var _config_compoundVariants;
+  if ((config === null || config === void 0 ? void 0 : config.variants) == null) return cx(base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+  const { variants, defaultVariants } = config;
+  const getVariantClassNames = Object.keys(variants).map((variant) => {
+    const variantProp = props === null || props === void 0 ? void 0 : props[variant];
+    const defaultVariantProp = defaultVariants === null || defaultVariants === void 0 ? void 0 : defaultVariants[variant];
+    if (variantProp === null) return null;
+    const variantKey = falsyToString(variantProp) || falsyToString(defaultVariantProp);
+    return variants[variant][variantKey];
+  });
+  const propsWithoutUndefined = props && Object.entries(props).reduce((acc, param) => {
+    let [key, value] = param;
+    if (value === void 0) {
+      return acc;
     }
-  };
-}
-
-// ../core/src/resolver/resolver.ts
-import { silentDiagnostics } from "../_shared/diagnostics.js";
-function enforceAllowedAs(tag, allowedAs, diagnostics, displayName) {
-  if (allowedAs.includes(tag)) return;
-  if (!diagnostics) return;
-  const component = displayName ?? String(tag);
-  diagnostics.error(ContractDiagnostics.allowedAsViolation(String(tag), allowedAs, component));
-}
-
-// ../../lib/adapter-utils/src/apply-prop-normalizers.ts
-function applyPropNormalizers(tag, props, additional) {
-  const normalizers = [...getHtmlPropNormalizers(tag) ?? [], ...additional ?? []];
-  if (normalizers.length === 0) return props;
-  return normalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), props);
-}
-
-// ../../lib/adapter-utils/src/define-component.ts
-function defineContractComponent(options) {
-  return (factory) => factory(options);
-}
-
-// ../../lib/adapter-utils/src/build-engines.ts
-function buildEngines(diagnostics, childRules, context) {
-  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, diagnostics, context) } : {};
-}
-
-// ../../lib/adapter-utils/src/resolve-adapter-common-options.ts
-import { throwDiagnostics, silentDiagnostics as silentDiagnostics2 } from "../_shared/diagnostics.js";
-function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics) {
-  return {
-    name: options.name ?? defaultName,
-    diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
-  };
-}
+    acc[key] = value;
+    return acc;
+  }, {});
+  const getCompoundVariantClassNames = config === null || config === void 0 ? void 0 : (_config_compoundVariants = config.compoundVariants) === null || _config_compoundVariants === void 0 ? void 0 : _config_compoundVariants.reduce((acc, param) => {
+    let { class: cvClass, className: cvClassName, ...compoundVariantOptions } = param;
+    return Object.entries(compoundVariantOptions).every((param2) => {
+      let [key, value] = param2;
+      return Array.isArray(value) ? value.includes({
+        ...defaultVariants,
+        ...propsWithoutUndefined
+      }[key]) : {
+        ...defaultVariants,
+        ...propsWithoutUndefined
+      }[key] === value;
+    }) ? [
+      ...acc,
+      cvClass,
+      cvClassName
+    ] : acc;
+  }, []);
+  return cx(base, getVariantClassNames, getCompoundVariantClassNames, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+};
 
-// ../../lib/adapter-utils/src/slot-validator.ts
-var SlotValidator = class extends InvariantBase {
-  #name;
-  #elementTerm;
-  constructor(name, diagnostics, elementTerm) {
-    super(diagnostics);
-    this.#name = name;
-    this.#elementTerm = elementTerm;
+// ../../lib/styling/src/cva.ts
+function cva2(base, config) {
+  const fn = cva(base, config);
+  return (props) => cn(fn(props));
+}
+
+// ../../lib/styling/src/static-class-resolver.ts
+var StaticClassResolver = class {
+  #baseClass;
+  #cache = /* @__PURE__ */ new Map();
+  #resolveTag;
+  constructor(baseClass, tagMap) {
+    this.#baseClass = Array.isArray(baseClass) ? baseClass.join(" ") : baseClass;
+    this.#resolveTag = tagMap ? (tag) => {
+      const extra = tagMap[tag];
+      if (!extra) return this.#baseClass;
+      const extraStr = Array.isArray(extra) ? extra.join(" ") : extra;
+      return `${this.#baseClass} ${extraStr}`;
+    } : () => this.#baseClass;
+  }
+  resolve(tag, skipTagMap = false) {
+    if (typeof tag !== "string" || skipTagMap) return this.#baseClass;
+    const cached = this.#cache.get(tag);
+    if (cached !== void 0) {
+      this.#cache.delete(tag);
+      this.#cache.set(tag, cached);
+      return cached;
+    }
+    const result = this.#resolveTag(tag);
+    this.#cache.set(tag, result);
+    if (this.#cache.size > 200) {
+      const lru = this.#cache.keys().next().value;
+      if (lru !== void 0) this.#cache.delete(lru);
+    }
+    return result;
   }
-  assertExclusive() {
-    this.violate(SlotDiagnostics.exclusive(this.#name));
+};
+
+// ../../lib/styling/src/variant-class-resolver.ts
+var VariantClassResolver = class _VariantClassResolver {
+  #cvaFn;
+  #recipeMap;
+  #variantKeys;
+  #precomputedClasses;
+  #cache = /* @__PURE__ */ new Map();
+  constructor(cvaFn, recipeMap, variantKeys, precomputedClasses) {
+    this.#cvaFn = cvaFn ?? null;
+    this.#recipeMap = Object.freeze(recipeMap ?? {});
+    this.#variantKeys = variantKeys ?? null;
+    this.#precomputedClasses = precomputedClasses ?? null;
+  }
+  resolve({ props, recipe }) {
+    const normalizedKey = recipe ?? "__none__";
+    const cacheKey = this.#createCacheKey(props, normalizedKey);
+    if (this.#precomputedClasses !== null) {
+      const precomputed = this.#precomputedClasses[cacheKey];
+      if (precomputed !== void 0) return precomputed;
+    }
+    const cached = this.#cache.get(cacheKey);
+    if (cached !== void 0) {
+      this.#cache.delete(cacheKey);
+      this.#cache.set(cacheKey, cached);
+      return cached;
+    }
+    const result = this.#compute(props, recipe);
+    this.#cache.set(cacheKey, result);
+    if (this.#cache.size > 1e3) {
+      const lru = this.#cache.keys().next().value;
+      if (lru !== void 0) this.#cache.delete(lru);
+    }
+    return result;
   }
-  warnDiscardedChildren(count) {
-    this.warn(SlotDiagnostics.discardedChildren(this.#name, this.#elementTerm, count));
+  #compute(props, recipe) {
+    if (!this.#cvaFn) return "";
+    if (!recipe) return this.#cvaFn(props);
+    const preset = this.#recipeMap[recipe];
+    if (!preset) return this.#cvaFn(props);
+    return this.#cvaFn({ ...preset, ...props });
+  }
+  // When variantKeys is provided, only those keys are included in the cache key — non-variant
+  // 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, recipe) {
+    if (this.#variantKeys !== null) {
+      let key2 = recipe;
+      iterate.forEachSet(this.#variantKeys, (k) => {
+        if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
+      });
+      return key2;
+    }
+    let key = recipe;
+    iterate.forEach(Object.keys(props).sort(), (k) => {
+      key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
+    });
+    return key;
   }
-  assertSingleChild(count) {
-    this.violate(
-      count === 0 ? SlotDiagnostics.singleChildRequired(this.#name, this.#elementTerm) : SlotDiagnostics.singleChildExceeded(this.#name, this.#elementTerm, count)
-    );
+  static #serializeValue(value) {
+    if (value === void 0) return "u";
+    if (value === null) return "n";
+    if (typeof value === "boolean") return `b:${value}`;
+    if (typeof value === "string") return `s:${value}`;
+    return `x:${String(value)}`;
   }
 };
 
-// ../../lib/adapter-utils/src/build-definition.ts
-function buildDefinition(name, tag) {
-  return {
-    identity: {
-      id: name,
-      name,
-      tag
-    },
-    capabilities: {},
-    metadata: {},
-    diagnostics: []
+// ../../lib/styling/src/create-class-pipeline.ts
+function createClassPipeline(resolved) {
+  const baseClass = resolved.baseClassName ?? "";
+  const cvaFn = resolved.variants ? cva2("", {
+    variants: resolved.variants,
+    defaultVariants: resolved.defaultVariants,
+    compoundVariants: resolved.compoundVariants
+  }) : null;
+  const variantKeys = resolved.variants ? new Set(Object.keys(resolved.variants)) : void 0;
+  const staticResolver = new StaticClassResolver(baseClass, resolved.tagMap);
+  const variantResolver = new VariantClassResolver(
+    cvaFn,
+    resolved.recipeMap,
+    variantKeys,
+    resolved.precomputedClasses
+  );
+  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);
   };
 }
 
-// ../../lib/adapter-utils/src/build-variant-config.ts
-function flattenClassName(cls) {
-  return Array.isArray(cls) ? cls.join(" ") : cls;
-}
-function mapVariantRecord(source, mapper) {
-  return iterate.mapValues(
-    source,
-    (inner) => iterate.mapValues(inner, mapper)
-  );
-}
-function buildVariantConfig(variants, presets, defaults, compounds) {
-  return {
-    variants: mapVariantRecord(variants ?? {}, flattenClassName),
-    ...presets !== void 0 && Object.keys(presets).length > 0 && { presets },
-    ...defaults !== void 0 && Object.keys(defaults).length > 0 && { defaults },
-    ...compounds !== void 0 && compounds.length > 0 && {
-      compounds
+// ../../lib/pipeline-kit/src/factory/define-pipeline.ts
+function definePipeline(factory) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return (resolved) => {
+    let pipeline = cache.get(resolved);
+    if (!pipeline) {
+      pipeline = factory(resolved);
+      cache.set(resolved, pipeline);
     }
+    return pipeline;
   };
 }
 
-// ../../runtime/core/src/apply-attributes.ts
-function applyAttributes(nodeId, incoming, decoration, removedKeys) {
-  const existing = decoration[nodeId] ?? {};
-  const next = { ...existing.attributes };
-  if (removedKeys !== void 0) {
-    iterate.forEachSet(removedKeys, (key) => {
-      delete next[key];
-    });
-  }
-  Object.assign(next, incoming);
-  const { attributes: _dropped, ...rest } = existing;
-  const nextDecoration = Object.keys(next).length > 0 ? { ...rest, attributes: next } : rest;
-  return { ...decoration, [nodeId]: nextDecoration };
-}
-
-// ../../runtime/core/src/get-active-props.ts
-function getActiveProps(nodeId, decoration) {
-  const dec = decoration[nodeId];
-  return { ...dec?.attributes ?? {}, ...dec?.variants ?? {} };
+// ../core/src/options/resolve-factory-options.ts
+import { silentDiagnostics } from "../_shared/diagnostics.js";
+var EMPTY_VARIANT_KEYS = /* @__PURE__ */ new Set();
+function composeNormalizers(normalizers, fn) {
+  if (!normalizers?.length) return fn;
+  return ((props) => {
+    const patched = normalizers.reduce(
+      (acc, normalizer) => ({ ...acc, ...normalizer(acc) }),
+      props
+    );
+    return fn ? fn(patched) : patched;
+  });
 }
-
-// ../../runtime/core/src/render-component.ts
-function renderComponent(definition, tree, render, backend) {
-  return backend.render({ definition, tree, render });
+function whenDefined(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function resolveFactoryOptions(options = {}) {
+  const { styling, enforcement } = options;
+  const composedNormalizeFn = composeNormalizers(enforcement?.props, options.normalize);
+  const variantKeys = styling?.variants === void 0 ? EMPTY_VARIANT_KEYS : new Set(Object.keys(styling.variants));
+  return Object.freeze({
+    defaultTag: options.tag ?? "div",
+    diagnostics: enforcement?.diagnostics ?? silentDiagnostics,
+    variantKeys,
+    ...whenDefined("displayName", options.name),
+    ...whenDefined("defaultProps", options.defaults),
+    ...whenDefined("baseClassName", styling?.base),
+    ...whenDefined("tagMap", styling?.tags),
+    ...whenDefined("recipeMap", styling?.presets),
+    ...whenDefined("variants", styling?.variants),
+    ...whenDefined("defaultVariants", styling?.defaults),
+    ...whenDefined("compoundVariants", styling?.compounds),
+    ...whenDefined("normalizeFn", composedNormalizeFn),
+    ...whenDefined("ariaRules", enforcement?.aria),
+    ...whenDefined("childRules", enforcement?.children),
+    ...whenDefined("allowedAs", enforcement?.allowedAs),
+    ...whenDefined("precomputedClasses", styling?.precomputedClasses)
+  });
 }
 
-// ../../runtime/core/src/build-tree-context.ts
-function buildNode(input, slotAssignments, seenIds, diagnostics) {
-  if (seenIds.has(input.id)) {
-    diagnostics.push({
-      code: "duplicate-node-id",
-      message: `Duplicate node id "${input.id}"`,
-      severity: "error"
+// ../core/src/options/validate-factory-options.ts
+function validateFactoryOptions(resolved, diagnostics) {
+  if (!diagnostics.active) return;
+  const name = resolved.displayName ?? "Component";
+  const { variants } = resolved;
+  const checkSelection = (label2, selection) => {
+    iterate.forEachEntry(selection, (dim, value) => {
+      if (value === void 0 || value === null) return;
+      if (!variants || !Object.hasOwn(variants, dim)) {
+        diagnostics.error(ContractDiagnostics.unknownVariantDim(name, label2, dim));
+        return;
+      }
+      const states = variants[dim];
+      const stateKey = String(value);
+      if (!Object.hasOwn(states, stateKey)) {
+        diagnostics.error(
+          ContractDiagnostics.unknownVariantValue(name, label2, dim, stateKey, Object.keys(states))
+        );
+      }
+    });
+  };
+  const { recipeMap } = resolved;
+  if (recipeMap) {
+    iterate.forEachEntry(recipeMap, (recipeKey, selection) => {
+      checkSelection(`preset "${recipeKey}"`, selection);
     });
-  } else {
-    seenIds.add(input.id);
-  }
-  if (input.slot !== void 0) {
-    slotAssignments.set(input.id, input.slot);
-  }
-  const children = Object.freeze(
-    (input.children ?? []).map((child) => buildNode(child, slotAssignments, seenIds, diagnostics))
-  );
-  if (input.kind === "native") {
-    return Object.freeze({ kind: "native", id: input.id, tag: input.tag, children });
   }
-  return Object.freeze({ kind: "component", id: input.id, children });
-}
-function buildTreeContext(root) {
-  const slotAssignments = /* @__PURE__ */ new Map();
-  const diagnostics = [];
-  const rootNode = buildNode(root, slotAssignments, /* @__PURE__ */ new Set(), diagnostics);
-  return Object.freeze({ root: rootNode, slotAssignments, diagnostics });
-}
-
-// ../../runtime/core/src/build-render-context.ts
-function buildRenderContext(decoration = {}) {
-  return { decoration: new Map(Object.entries(decoration)) };
+  if (resolved.defaultVariants) checkSelection("defaults", resolved.defaultVariants);
 }
 
-// ../../lib/adapter-utils/src/resolve-compounds.ts
-function matchesCompound(active, compound) {
-  const { class: _, ...conditions } = compound;
-  return Object.entries(conditions).every(([key, expected]) => {
-    const actual = active[key];
-    return Array.isArray(expected) ? expected.includes(actual) : actual === expected;
-  });
+// ../core/src/options/validate-render-props.ts
+function label(name) {
+  return name ? `[${name}]` : "[createContractComponent]";
 }
-function resolveCompounds(active, compounds) {
-  if (!compounds?.length) return [];
-  const out = [];
-  iterate.forEach(compounds, (compound) => {
-    if (matchesCompound(active, compound)) {
-      out.push(flattenClassName(compound.class));
-    }
-  });
-  return out;
+function validateRenderProps(diagnostics, options, props, recipeKey) {
+  const { recipeMap, variants, displayName } = options;
+  const tag = label(displayName);
+  if (recipeKey !== void 0 && (!recipeMap || !Object.hasOwn(recipeMap, recipeKey))) {
+    diagnostics.error(ContractDiagnostics.unknownRecipeKey(tag, recipeKey));
+  }
+  if (variants) {
+    iterate.forEachKey(variants, (key) => {
+      if (!Object.hasOwn(props, key)) return;
+      const value = props[key];
+      if (value === void 0 || value === null) return;
+      const dim = variants[key];
+      if (dim && !Object.hasOwn(dim, String(value))) {
+        diagnostics.error(ContractDiagnostics.invalidVariantValue(tag, key, String(value)));
+      }
+    });
+  }
 }
 
-// ../../lib/adapter-utils/src/resolve-classes.ts
-function resolveClasses(decoration, variantConfig, variantDefaults, recipe, compounds, variantLookup) {
-  const active = getActiveProps("root", decoration);
-  if (variantLookup !== void 0 && recipe === void 0) {
-    const activeVariants = {};
-    iterate.forEachKey(variantConfig.variants, (key) => {
-      const value = active[key];
-      if (typeof value === "string") activeVariants[key] = value;
-    });
-    const lookupKey = buildPrecomputedKey(activeVariants);
-    const precomputedValue = variantLookup[lookupKey];
-    if (precomputedValue !== void 0) {
-      return {
-        variantClasses: precomputedValue !== "" ? [precomputedValue] : [],
-        compoundClasses: []
-      };
-    }
+// ../core/src/factory/plugin-invariants.ts
+import { throwDiagnostics } from "../_shared/diagnostics.js";
+
+// ../core/src/factory/plugin-diagnostics.ts
+import { DiagnosticCategory as DiagnosticCategory5, DiagnosticCode as DiagnosticCode5 } from "../_shared/diagnostics.js";
+var PluginDiagnostics = {
+  invalidShape(received) {
+    const got = received === null ? "null" : typeof received;
+    return {
+      code: DiagnosticCode5.PluginInvalidShape,
+      category: DiagnosticCategory5.Internal,
+      message: `[praxis-kit] Plugin factory must return an object with a 'pipeline' function. Got: ${got}.`
+    };
+  },
+  pipelineReturnType(received) {
+    const got = received === null ? "null" : Array.isArray(received) ? "array" : typeof received;
+    return {
+      code: DiagnosticCode5.PluginPipelineReturnType,
+      category: DiagnosticCategory5.Internal,
+      message: `[praxis-kit] Plugin pipeline must return a string. Got: ${got}.`
+    };
   }
-  const passInput = recipe !== void 0 ? { ...active, preset: recipe } : active;
-  const { context } = createVariantPass(passInput, variantConfig).execute({ classes: [] });
-  const variantClasses = context.classes;
-  const presetOverrides = recipe !== void 0 ? variantConfig.presets?.[recipe] ?? {} : {};
-  const resolvedValues = {
-    ...variantDefaults,
-    ...presetOverrides,
-    ...active
+};
+
+// ../core/src/factory/plugin-invariants.ts
+function assertPluginShape(result) {
+  if (result === null || typeof result !== "object")
+    throwDiagnostics.error(PluginDiagnostics.invalidShape(result));
+  const plugin = result;
+  if (typeof plugin.pipeline !== "function")
+    throwDiagnostics.error(PluginDiagnostics.invalidShape(result));
+}
+function guardPipeline(pipeline) {
+  if (process.env.NODE_ENV === "production") return pipeline;
+  return function guardedPipeline(tag, props, className, recipe) {
+    const result = pipeline(tag, props, className, recipe);
+    if (typeof result !== "string")
+      throwDiagnostics.error(PluginDiagnostics.pipelineReturnType(result));
+    return result;
   };
-  const compoundClasses = resolveCompounds(resolvedValues, compounds);
-  return { variantClasses, compoundClasses };
 }
 
-// ../../lib/adapter-utils/src/build-pipeline.ts
-function buildStylePipeline(variants, presets, defaults, compounds, variantLookup) {
-  if (variants === void 0 && compounds === void 0 && presets === void 0 && variantLookup === void 0) {
-    return void 0;
+// ../core/src/factory/create-polymorphic2.ts
+var createTagPipeline = (resolved) => makeResolveTag(resolved.defaultTag);
+var createPropsPipeline = (resolved) => (props) => mergeProps(resolved.defaultProps, props);
+var createHtmlPropNormalizersPipeline = () => getHtmlPropNormalizers;
+var createHtmlChildrenEvaluatorPipeline = () => getHtmlChildrenEvaluator;
+var createStylingClassPipeline = (resolved) => createClassPipeline(resolved);
+function resolveAriaRules(resolved) {
+  return [.../* @__PURE__ */ new Set([...HTML_ARIA_RULES, ...resolved.ariaRules ?? []])];
+}
+var createAriaPipeline = (resolved) => {
+  const rules = resolveAriaRules(resolved);
+  const engine = new AriaPolicyEngine(resolved.diagnostics, rules.length ? { rules } : void 0);
+  return (tag, props) => engine.validate(tag, props);
+};
+var memoizedTagPipeline = definePipeline(createTagPipeline);
+var memoizedPropsPipeline = definePipeline(createPropsPipeline);
+var memoizedHtmlPropNormalizersPipeline = definePipeline(createHtmlPropNormalizersPipeline);
+var memoizedHtmlChildrenEvaluatorPipeline = definePipeline(createHtmlChildrenEvaluatorPipeline);
+var memoizedClassPipeline = definePipeline(createStylingClassPipeline);
+var memoizedAriaPipeline = definePipeline(createAriaPipeline);
+function resolveAriaPassthrough(_tag, props) {
+  return { props };
+}
+function resolveClassPlugin(factory, resolved, diagnostics) {
+  if (!factory) return { pluginResult: void 0, classPipeline: memoizedClassPipeline(resolved) };
+  const pluginResult = factory(resolved, diagnostics);
+  assertPluginShape(pluginResult);
+  return { pluginResult, classPipeline: guardPipeline(pluginResult.pipeline) };
+}
+function createPolymorphic2(options = {}) {
+  const baseResolved = resolveFactoryOptions(options);
+  const anyBaseResolved = baseResolved;
+  const resolved = Object.freeze({
+    ...baseResolved,
+    htmlPropNormalizersFn: memoizedHtmlPropNormalizersPipeline(anyBaseResolved),
+    htmlChildrenEvaluatorFn: memoizedHtmlChildrenEvaluatorPipeline(anyBaseResolved)
+  });
+  const anyResolved = resolved;
+  if (process.env.NODE_ENV !== "production") {
+    validateFactoryOptions(resolved, resolved.diagnostics);
   }
-  const variantConfig = buildVariantConfig(variants, presets, defaults, compounds);
-  return {
-    execute(decoration, recipe) {
-      return resolveClasses(decoration, variantConfig, defaults, recipe, compounds, variantLookup);
+  const { pluginResult, classPipeline } = resolveClassPlugin(
+    options.styling?.plugin,
+    anyResolved,
+    resolved.diagnostics
+  );
+  const resolveTag2 = memoizedTagPipeline(anyResolved);
+  const resolveProps = memoizedPropsPipeline(anyResolved);
+  const resolveAriaFn = options.enforcement !== void 0 ? memoizedAriaPipeline(anyResolved) : resolveAriaPassthrough;
+  const methods = {
+    resolveTag: resolveTag2,
+    resolveProps,
+    resolveClasses(tag, props, className, recipe) {
+      if (process.env.NODE_ENV !== "production") {
+        validateRenderProps(resolved.diagnostics, resolved, props, recipe);
+      }
+      return classPipeline(tag, props, className, recipe);
+    },
+    resolveAria(tag, props) {
+      return resolveAriaFn(tag, props);
     }
   };
+  const runtimeObject = pluginResult ? { ...methods, options: resolved, hasStyling: true, classPlugin: pluginResult } : { ...methods, options: resolved };
+  return runtimeObject;
 }
 
-// ../../lib/adapter-utils/src/join-classes.ts
-function joinClasses(...classes) {
-  return classes.filter(Boolean).join(" ");
+// ../core/src/resolver/resolver.ts
+import { silentDiagnostics as silentDiagnostics2 } from "../_shared/diagnostics.js";
+function enforceAllowedAs(tag, allowedAs, diagnostics, displayName) {
+  if (allowedAs.includes(tag)) return;
+  if (!diagnostics) return;
+  const component = displayName ?? String(tag);
+  diagnostics.error(ContractDiagnostics.allowedAsViolation(String(tag), allowedAs, component));
 }
 
-// ../../lib/adapter-utils/src/decoration-utils.ts
-function withAttributes(dec, attributes) {
-  const { attributes: _a, ...rest } = dec;
-  return attributes !== void 0 ? { ...rest, attributes } : rest;
+// ../../lib/adapter-utils/src/runtime/build-core-runtime.ts
+var EMPTY_SET = /* @__PURE__ */ new Set();
+function buildCoreRuntime(normalized) {
+  const runtime = createPolymorphic2(normalized);
+  const ownedKeys = "classPlugin" in runtime ? runtime.classPlugin.ownedKeys ?? EMPTY_SET : EMPTY_SET;
+  return { runtime, ownedKeys };
 }
 
-// ../../lib/adapter-utils/src/apply-aria.ts
-function applyAria(decoration, tag, ariaEngine) {
-  if (ariaEngine === void 0) return decoration;
-  const dec = decoration["root"];
-  if (dec?.attributes === void 0) return decoration;
-  const result = ariaEngine.validate(tag, dec.attributes);
-  const cleaned = result.props;
-  return {
-    ...decoration,
-    root: withAttributes(dec, Object.keys(cleaned).length > 0 ? cleaned : void 0)
-  };
+// ../../lib/adapter-utils/src/runtime/build-engines.ts
+function buildEngines(diagnostics, childRules, context) {
+  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, diagnostics, context) } : {};
 }
 
-// ../../lib/adapter-utils/src/apply-filter-props.ts
-function applyFilterProps(decoration, filterFn, variantKeys) {
-  if (filterFn === void 0) return decoration;
-  const dec = decoration["root"];
-  if (dec?.attributes === void 0) return decoration;
-  const kept = Object.fromEntries(
-    Object.entries(dec.attributes).filter(([k]) => !filterFn(k, variantKeys))
-  );
+// ../../lib/adapter-utils/src/runtime/resolve-adapter-common-options.ts
+import { throwDiagnostics as throwDiagnostics2, silentDiagnostics as silentDiagnostics3 } from "../_shared/diagnostics.js";
+function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics2) {
   return {
-    ...decoration,
-    root: withAttributes(dec, Object.keys(kept).length > 0 ? kept : void 0)
+    name: options.name ?? defaultName,
+    diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
   };
 }
 
-// ../../adapters/vue/src/backend/extract-decoration.ts
-function isStyleValue(v) {
-  return isString(v) || isNumber(v);
-}
-function isAttributeValue(v) {
-  return isString(v) || isNumber(v) || typeof v === "boolean";
-}
-function assignIfNotEmpty(target, key, value) {
-  if (Object.keys(value).length > 0) {
-    target[key] = value;
-  }
-}
-function extractStyles(value, styles) {
-  if (!isObject(value)) return false;
-  iterate.forEachEntry(value, (k, v) => {
-    if (isStyleValue(v)) {
-      styles[k] = v;
-    }
+// ../../lib/adapter-utils/src/props/apply-filter.ts
+function applyFilter(props, filterProps, variantKeys) {
+  const out = {};
+  iterate.forEachEntry(props, (k) => {
+    if (!Object.hasOwn(props, k)) return;
+    if (filterProps(k, variantKeys)) return;
+    out[k] = props[k];
   });
-  return true;
-}
-function extractListener(key, value, listeners) {
-  if (!key.startsWith("on") || !isFunction(value)) {
-    return false;
-  }
-  listeners[key] = value;
-  return true;
+  return out;
 }
-function extractAttributeOrVariant(key, value, attributes, variants, variantKeys) {
-  if (variantKeys?.has(key)) {
-    variants[key] = value;
-  } else {
-    attributes[key] = value;
-  }
-}
-function extractDecoration(props, variantKeys) {
-  const attributes = {};
-  const styles = {};
-  const listeners = {};
-  const variants = {};
-  const dec = {};
-  iterate.forEachEntry(props, (key, value) => {
-    if (key === "children" || key === "slot" || key === "ref") return;
-    if (key === "style" && extractStyles(value, styles)) return;
-    if (extractListener(key, value, listeners)) return;
-    if (isAttributeValue(value)) {
-      extractAttributeOrVariant(key, value, attributes, variants, variantKeys);
-    }
-  });
-  assignIfNotEmpty(dec, "attributes", attributes);
-  assignIfNotEmpty(dec, "styles", styles);
-  assignIfNotEmpty(dec, "listeners", listeners);
-  assignIfNotEmpty(dec, "variants", variants);
-  const ref = props.ref;
-  if (ref !== void 0) {
-    dec.ref = ref;
+
+// ../../lib/adapter-utils/src/props/compose-filter.ts
+function composeFilter(ownedKeys, filterProps) {
+  const defaultFilter = (key, variantKeys) => variantKeys.has(key) || ownedKeys.has(key);
+  if (!filterProps) {
+    return defaultFilter;
   }
-  return dec;
+  return (key, variantKeys) => defaultFilter(key, variantKeys) || filterProps(key, variantKeys);
 }
 
-// ../../adapters/vue/src/helpers/render-normally.ts
-import { h as h2 } from "vue";
-
-// ../../adapters/vue/src/backend/vue-backend.ts
-import { Fragment, h } from "vue";
+// ../../lib/adapter-utils/src/slot/slot-validator.ts
+var SlotValidator = class extends InvariantBase {
+  #name;
+  #elementTerm;
+  constructor(name, diagnostics, elementTerm) {
+    super(diagnostics);
+    this.#name = name;
+    this.#elementTerm = elementTerm;
+  }
+  assertExclusive() {
+    this.violate(SlotDiagnostics.exclusive(this.#name));
+  }
+  warnDiscardedChildren(count) {
+    this.warn(SlotDiagnostics.discardedChildren(this.#name, this.#elementTerm, count));
+  }
+  assertSingleChild(count) {
+    this.violate(
+      count === 0 ? SlotDiagnostics.singleChildRequired(this.#name, this.#elementTerm) : SlotDiagnostics.singleChildExceeded(this.#name, this.#elementTerm, count)
+    );
+  }
+};
 
-// ../../adapters/vue/src/backend/build-props.ts
-function buildPropsFromDecoration(id, decoration) {
+// ../../adapters/vue/src/build-runtime.ts
+function normalizeOptions(options) {
   return {
-    key: id,
-    ...decoration?.attributes,
-    ...decoration?.styles !== void 0 ? { style: decoration.styles } : {},
-    ...decoration?.listeners,
-    ...decoration?.ref !== void 0 ? { ref: decoration.ref } : {}
+    ...options,
+    ...resolveAdapterCommonOptions(options)
   };
 }
-
-// ../../adapters/vue/src/backend/vue-backend.ts
-var MULTI_WORD_EVENT_RE = /^on[A-Z][a-z]+[A-Z]/;
-function normalizeListenerKeys(listeners) {
-  const out = {};
-  for (const k in listeners) {
-    out[MULTI_WORD_EVENT_RE.test(k) ? "on" + k.slice(2).toLowerCase() : k] = listeners[k];
-  }
-  return out;
-}
-function renderNode(node, render, isRoot) {
-  const children = node.children.map((child) => renderNode(child, render, false));
-  if (node.kind === "component") {
-    return h(Fragment, isRoot ? null : { key: node.id }, children);
-  }
-  const decoration = render.decoration.get(node.id);
-  const base = buildPropsFromDecoration(isRoot ? "" : node.id, decoration);
-  const { key: _key, ...rest } = base;
-  const props = {
-    ...isRoot ? {} : { key: node.id },
-    ...rest,
-    ...decoration?.listeners !== void 0 ? normalizeListenerKeys(decoration.listeners) : {}
+function buildRuntime(options) {
+  const normalized = normalizeOptions(options);
+  const { runtime, ownedKeys } = buildCoreRuntime(normalized);
+  const { diagnostics, enforcement, filterProps: userFilter, name } = normalized;
+  const { childrenEvaluator } = buildEngines(diagnostics, enforcement?.children, name);
+  const filterProps = composeFilter(ownedKeys, userFilter);
+  const slotValidator = new SlotValidator(name, diagnostics, "VNode");
+  const built = {
+    runtime,
+    filterProps,
+    slotValidator,
+    ...childrenEvaluator !== void 0 && { childrenEvaluator }
   };
-  return h(node.tag, props, children.length > 0 ? children : void 0);
+  return built;
 }
-var vueBackend = {
-  render(context) {
-    return renderNode(context.tree.root, context.render, true);
-  }
-};
 
-// ../../adapters/vue/src/helpers/render-normally.ts
-function renderNormally(definition, tag, decoration, slots) {
-  const treeCtx = buildTreeContext({ kind: "native", tag, id: "root", children: [] });
-  const rendered = renderComponent(definition, treeCtx, buildRenderContext(decoration), vueBackend);
-  if (slots?.default === void 0) return rendered;
-  const { key: _key, ...props } = rendered.props ?? {};
-  return h2(tag, props, { default: slots.default });
-}
+// ../../adapters/vue/src/render.ts
+import { cloneVNode, h as h3 } from "vue";
 
 // ../../adapters/vue/src/normalize-children.ts
 import { isVNode } from "vue";
@@ -2462,17 +2665,19 @@ function normalizeChildren(slots) {
   return { vnodes, discarded: raw.length - vnodes.length };
 }
 
+// ../../adapters/vue/src/slot/extractSlottable.ts
+import { h as h2, Fragment as Fragment2 } from "vue";
+
 // ../../adapters/vue/src/slot/Slottable.ts
-import { defineComponent, h as h3, Fragment as Fragment2 } from "vue";
+import { defineComponent, h, Fragment } from "vue";
 var Slottable = defineComponent({
   name: "Slottable",
   setup(_, { slots }) {
-    return () => h3(Fragment2, null, slots.default?.());
+    return () => h(Fragment, null, slots.default?.());
   }
 });
 
 // ../../adapters/vue/src/slot/extractSlottable.ts
-import { h as h4, Fragment as Fragment3 } from "vue";
 function isSlottableVNode(vnode) {
   return vnode.type === Slottable;
 }
@@ -2495,127 +2700,123 @@ function extractSlottable(children) {
     child,
     rebuild(merged) {
       const out = children.map((node, i) => i === index ? merged : node);
-      return h4(Fragment3, null, out);
+      return h2(Fragment2, null, out);
     }
   };
 }
 
+// ../../adapters/vue/src/render.ts
+var MULTI_WORD_EVENT_RE = /^on[A-Z][a-z]+[A-Z]/;
+function normalizeListenerKeys(props) {
+  const out = {};
+  for (const k in props) {
+    out[MULTI_WORD_EVENT_RE.test(k) ? "on" + k.slice(2).toLowerCase() : k] = props[k];
+  }
+  return out;
+}
+function isAttributeValue(v) {
+  return isString(v) || isNumber(v) || typeof v === "boolean";
+}
+function pickAttributes(props) {
+  const out = {};
+  for (const k in props) {
+    if (isAttributeValue(props[k])) out[k] = props[k];
+  }
+  return out;
+}
+function prepareRenderState(runtime, attrs, filterProps) {
+  const { as, asChild, class: callerClass, recipe, ...rest } = attrs;
+  const tag = typeof as === "string" ? as : runtime.options.defaultTag;
+  if (runtime.options.allowedAs !== void 0) {
+    enforceAllowedAs(
+      tag,
+      runtime.options.allowedAs,
+      runtime.options.diagnostics,
+      runtime.options.displayName
+    );
+  }
+  const mergedProps = runtime.resolveProps(rest);
+  const htmlNormalizers = runtime.options.htmlPropNormalizersFn?.(tag);
+  const htmlNormalizedProps = htmlNormalizers?.length ? htmlNormalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), mergedProps) : mergedProps;
+  const normalizedProps = runtime.options.normalizeFn ? runtime.options.normalizeFn(htmlNormalizedProps) : htmlNormalizedProps;
+  const className = runtime.resolveClasses(tag, normalizedProps, callerClass, recipe);
+  const filteredProps = applyFilter(normalizedProps, filterProps, runtime.options.variantKeys);
+  return {
+    tag,
+    directives: {
+      ...typeof as === "string" && { as },
+      ...asChild !== void 0 && { asChild }
+    },
+    props: filteredProps,
+    className
+  };
+}
+function buildElementProps(props, className) {
+  const { role, ...rest } = props;
+  return {
+    ...normalizeListenerKeys(rest),
+    class: className,
+    ...isKnownAriaRole(role) && { role }
+  };
+}
+function renderIntrinsic(state, runtime, slots) {
+  const elementProps = buildElementProps(state.props, state.className);
+  const domProps = runtime.resolveAria(state.tag, elementProps).props;
+  return h3(state.tag, domProps, slots.default ? { default: slots.default } : void 0);
+}
+function validateSlotDirectives(directives, validator) {
+  const { as, asChild } = directives;
+  if (!asChild) return false;
+  if (as !== void 0) {
+    validator.assertExclusive();
+    return false;
+  }
+  return true;
+}
+function tryRenderAsChild(state, children, discarded, validator) {
+  if (!validateSlotDirectives(state.directives, validator)) return null;
+  if (discarded > 0) validator.warnDiscardedChildren(discarded);
+  const attrs = { ...pickAttributes(state.props), class: state.className };
+  const slottable = extractSlottable(children);
+  if (slottable) return slottable.rebuild(cloneVNode(slottable.child, attrs));
+  if (children.length === 1 && children[0] !== void 0) {
+    return cloneVNode(children[0], attrs);
+  }
+  validator.assertSingleChild(children.length);
+  return null;
+}
+function render({
+  runtime,
+  state,
+  slots,
+  slotValidator,
+  childrenEvaluator
+}) {
+  const { vnodes: children, discarded } = normalizeChildren(slots);
+  if (process.env.NODE_ENV !== "production") {
+    childrenEvaluator?.evaluate(children);
+  }
+  const slotResult = tryRenderAsChild(state, children, discarded, slotValidator);
+  return slotResult ?? renderIntrinsic(state, runtime, slots);
+}
+
 // ../../adapters/vue/src/create-contract-component.ts
-var EMPTY_SET = /* @__PURE__ */ new Set();
 function createContractComponent(options) {
-  const resolved = resolveAdapterCommonOptions(options);
-  const displayName = resolved.name;
-  const defaultTag = options.tag ?? "div";
-  const definition = buildDefinition(displayName, defaultTag);
-  const variantKeys = new Set(Object.keys(options.styling?.variants ?? {}));
-  const domDefaults = options.defaults;
-  const stylePipeline = buildStylePipeline(
-    options.styling?.variants,
-    options.styling?.presets,
-    options.styling?.defaults ?? {},
-    options.styling?.compounds,
-    void 0
-  );
-  const base = options.styling?.base !== void 0 ? flattenClassName(options.styling.base) : void 0;
-  const filterFn = options.filterProps;
-  const allowedAs = options.enforcement?.allowedAs;
-  const normalizeFn = options.normalize;
-  const enforcementNormalizers = options.enforcement?.props;
-  const classPlugin = options.styling?.plugin !== void 0 ? options.styling.plugin(
-    options.styling,
-    resolved.diagnostics
-  ) : void 0;
-  const pluginKeys = classPlugin?.ownedKeys ?? EMPTY_SET;
-  const { childrenEvaluator: explicitEvaluator } = buildEngines(
-    resolved.diagnostics,
-    options.enforcement?.children,
-    displayName
-  );
-  const ariaEngine = options.enforcement !== void 0 ? new AriaPolicyEngine(resolved.diagnostics) : void 0;
-  const slotValidator = new SlotValidator(displayName, resolved.diagnostics, "VNode");
+  const bundle = buildRuntime(options);
   const Component = defineComponent2({
-    name: displayName,
+    // normalizeOptions always supplies `name`, so displayName is always defined here —
+    // the fallback only satisfies the type, which allows it to be absent in general.
+    name: bundle.runtime.options.displayName ?? "PolymorphicComponent",
     inheritAttrs: false,
     setup(_, { attrs, slots }) {
-      const decorationState = computed(() => {
-        const {
-          as,
-          asChild,
-          class: callerClass,
-          recipe,
-          ...ownProps
-        } = attrs;
-        const tag = typeof as === "string" ? as : defaultTag;
-        if (allowedAs !== void 0)
-          enforceAllowedAs(tag, allowedAs, resolved.diagnostics, displayName);
-        const rawBaseProps = domDefaults !== void 0 ? { ...domDefaults, ...ownProps } : ownProps;
-        const normalizedProps = applyPropNormalizers(tag, rawBaseProps, enforcementNormalizers);
-        const baseProps = normalizeFn !== void 0 ? normalizeFn(normalizedProps) : normalizedProps;
-        const pluginProps = {};
-        const propsForExtraction = pluginKeys.size > 0 ? Object.fromEntries(
-          Object.entries(baseProps).filter(([k]) => {
-            if (pluginKeys.has(k)) {
-              pluginProps[k] = baseProps[k];
-              return false;
-            }
-            return true;
-          })
-        ) : baseProps;
-        const rootDec = extractDecoration(propsForExtraction, variantKeys);
-        const decoration = applyAria(
-          Object.keys(rootDec).length > 0 ? { root: rootDec } : {},
-          tag,
-          ariaEngine
-        );
-        const recipeName = typeof recipe === "string" ? recipe : void 0;
-        const { variantClasses, compoundClasses } = stylePipeline ? stylePipeline.execute(decoration, recipeName) : { variantClasses: [], compoundClasses: [] };
-        const rawClassName = joinClasses(
-          base,
-          ...variantClasses,
-          ...compoundClasses,
-          typeof callerClass === "string" ? callerClass : void 0
-        );
-        const className = classPlugin !== void 0 ? classPlugin.pipeline(tag, pluginProps, rawClassName, recipeName) : rawClassName;
-        let finalDecoration = className ? applyAttributes("root", { className }, decoration, variantKeys) : decoration;
-        finalDecoration = applyFilterProps(finalDecoration, filterFn, variantKeys);
-        return { tag, asChild, as, finalDecoration, className };
-      });
-      return () => {
-        const { tag, asChild, as, finalDecoration, className } = decorationState.value;
-        const { vnodes: children, discarded } = normalizeChildren(slots);
-        if (process.env.NODE_ENV !== "production") {
-          const childEval = explicitEvaluator ?? getHtmlChildrenEvaluator(tag);
-          childEval?.evaluate(children);
-        }
-        if (asChild === true) {
-          if (typeof as === "string") {
-            slotValidator.assertExclusive();
-          } else {
-            if (discarded > 0) slotValidator.warnDiscardedChildren(discarded);
-            const extraction = extractSlottable(children);
-            if (extraction) {
-              return extraction.rebuild(
-                cloneVNode(extraction.child, {
-                  ...finalDecoration["root"]?.attributes,
-                  class: className
-                })
-              );
-            }
-            if (children.length === 1 && children[0] !== void 0) {
-              return cloneVNode(children[0], {
-                ...finalDecoration["root"]?.attributes,
-                class: className
-              });
-            }
-            slotValidator.assertSingleChild(children.length);
-            return null;
-          }
-        }
-        return renderNormally(definition, tag, finalDecoration, slots);
-      };
+      const state = computed(
+        () => prepareRenderState(bundle.runtime, attrs, bundle.filterProps)
+      );
+      return () => render({ ...bundle, state: state.value, slots });
     }
   });
   applyDisplayName(Component, options.name);
+  const defaultTag = bundle.runtime.options.defaultTag;
   if (typeof defaultTag === "string") {
     Object.assign(Component, { [COMPONENT_DEFAULT_TAG]: defaultTag });
   }