praxis-kit 4.0.3 → 4.1.0

package/dist/preact/index.js

@@ -1,7 +1,5 @@
-// ../../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) {
@@ -15,6 +13,16 @@ function isNumber(value) {
   return typeof value === "number";
 }
 
+// ../../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/merge/constants.ts
 var EVENT_HANDLER_RE = /^on[A-Z]/;
 
@@ -28,195 +36,58 @@ function isPlainObject(value) {
   return proto === Object.prototype || proto === null;
 }
 
-// ../../lib/primitive/src/utils/assert-never.ts
-function assertNever(value) {
-  throw new Error(`Unexpected value: ${String(value)}`);
-}
-
-// ../../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;
-  }
+// ../../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 mapValues(object, callback) {
-  const result = {};
-  for (const [key, value] of entries(object)) {
-    result[key] = callback(value, key);
+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 result;
+  return void 0;
 }
-function forEachEntry(object, callback) {
-  for (const [key, value] of entries(object)) {
-    callback(key, value);
+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);
 }
-function forEachKey(object, callback) {
-  for (const key of keys(object)) {
-    callback(key);
-  }
+
+// ../../adapters/preact/src/create-contract-component.ts
+import { forwardRef as forwardRef2 } from "preact/compat";
+
+// ../../lib/adapter-utils/src/invariant.ts
+function panic(message) {
+  throw new Error(message);
 }
-function forEachValue(object, callback) {
-  for (const value of values(object)) {
-    callback(value);
-  }
+function invariant(condition, message) {
+  if (!condition) panic(message);
 }
-function forEachSet(s, callback) {
-  for (const value of s) {
-    callback(value);
-  }
+
+// ../../lib/adapter-utils/src/runtime/apply-display-name.ts
+function applyDisplayName(component, name) {
+  Object.assign(component, { displayName: name ?? "PolymorphicComponent" });
 }
-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-refs.ts
-function mergeRefsCore(...refs) {
-  const active = refs.filter((r) => r != null);
-  if (active.length === 0) return null;
-  if (active.length === 1) return active[0];
-  return (value) => {
-    iterate.forEach(active, (ref) => {
-      if (typeof ref === "function") {
-        ref(value);
-      } else {
-        ref.current = value;
-      }
-    });
-  };
+// ../../lib/adapter-utils/src/runtime/define-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
 }
 
 // ../../lib/primitive/src/constants/aria/global-aria-attributes.ts
@@ -241,7 +112,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",
@@ -277,8 +148,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",
@@ -292,18 +163,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([
   [
@@ -455,16 +414,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);
@@ -476,6 +425,9 @@ function isAriaAttributeValidForRole(attr, role) {
   return allowedRoles.has(role);
 }
 
+// ../../lib/primitive/src/constants/primitive/slot-name.ts
+var SLOT_NAME = "Slot";
+
 // ../../lib/primitive/src/guards/aria/is-aria-role.ts
 function isStrongImplicitRole(tag) {
   if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
@@ -486,62 +438,243 @@ 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;
+// ../../lib/primitive/src/guards/aria/is-known-aria-role.ts
+function isKnownAriaRole(value) {
+  return isString(value) && KNOWN_ARIA_ROLES_SET.has(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;
+
+// ../../lib/contract/src/aria/aria-role-policy.ts
+function getImplicitRole(tag, props) {
+  if (tag in IMPLICIT_ROLE_RECORD) return IMPLICIT_ROLE_RECORD[tag];
+  if (tag === "input") return getInputImplicitRole(props?.type);
+  if (tag === "img") return props?.alt === "" ? "none" : "img";
+  if (tag === "section" || tag === "form") {
+    return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
   }
   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);
-    };
+
+// ../../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;
+    }
   }
-  const [child, ...tags] = args;
-  const set2 = new Set(tags);
-  const tag = getTag(child);
-  return tag !== void 0 && set2.has(tag);
+  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-refs.ts
+function mergeRefsCore(...refs) {
+  const active = refs.filter((r) => r != null);
+  if (active.length === 0) return null;
+  if (active.length === 1) return active[0];
+  return (value) => {
+    iterate.forEach(active, (ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else {
+        ref.current = value;
+      }
+    });
+  };
 }
 
-// ../../lib/contract/src/aria/aria-role-policy.ts
-function getImplicitRole(tag, props) {
-  if (tag in IMPLICIT_ROLE_RECORD) return IMPLICIT_ROLE_RECORD[tag];
-  if (tag === "input") return getInputImplicitRole(props?.type);
-  if (tag === "img") return props?.alt === "" ? "none" : "img";
-  if (tag === "section" || tag === "form") {
-    return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
-  }
-  return void 0;
+// ../../lib/primitive/src/utils/merge-props.ts
+function mergeProps(defaultProps, props) {
+  return {
+    ...defaultProps ?? {},
+    ...props
+  };
 }
 
 // ../../lib/contract/src/strict/invariant-base.ts
@@ -790,18 +923,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) {
@@ -1599,7 +1732,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
@@ -1893,6 +2026,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";
@@ -2068,38 +2202,396 @@ 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("|");
-}
+// ../../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;
+    }
+    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/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);
-        }
+// ../../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;
+  }
+};
+
+// ../../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;
+  }
+  #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 { context: { classes } };
+      return key2;
+    }
+    let key = recipe;
+    iterate.forEach(Object.keys(props).sort(), (k) => {
+      key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
+    });
+    return key;
+  }
+  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/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/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;
   };
 }
 
-// ../core/src/resolver/resolver.ts
+// ../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;
+  });
+}
+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)
+  });
+}
+
+// ../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);
+    });
+  }
+  if (resolved.defaultVariants) checkSelection("defaults", resolved.defaultVariants);
+}
+
+// ../core/src/options/validate-render-props.ts
+function label(name) {
+  return name ? `[${name}]` : "[createContractComponent]";
+}
+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)));
+      }
+    });
+  }
+}
+
+// ../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}.`
+    };
+  }
+};
+
+// ../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;
+  };
+}
+
+// ../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 { 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;
+}
+
+// ../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;
@@ -2107,33 +2599,49 @@ function enforceAllowedAs(tag, allowedAs, diagnostics, displayName) {
   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/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/build-engines.ts
+// ../../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/resolve-adapter-common-options.ts
-import { throwDiagnostics, silentDiagnostics as silentDiagnostics2 } from "../_shared/diagnostics.js";
-function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics) {
+// ../../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 {
     name: options.name ?? defaultName,
     diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
   };
 }
 
-// ../../lib/adapter-utils/src/slot-validator.ts
+// ../../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 out;
+}
+
+// ../../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 (key, variantKeys) => defaultFilter(key, variantKeys) || filterProps(key, variantKeys);
+}
+
+// ../../lib/adapter-utils/src/slot/slot-validator.ts
 var SlotValidator = class extends InvariantBase {
   #name;
   #elementTerm;
@@ -2156,18 +2664,18 @@ var SlotValidator = class extends InvariantBase {
 };
 
 // ../../lib/adapter-utils/src/slot/policies.ts
-import { clsx } from "clsx";
+import { clsx as clsx3 } from "clsx";
 function chainHandlers(childHandler, slotHandler) {
   return (...args) => {
     childHandler(...args);
     const event = args[0];
-    if (!(typeof event === "object" && event !== null && "defaultPrevented" in event && event.defaultPrevented)) {
+    if (!(isObject(event) && "defaultPrevented" in event && event.defaultPrevented)) {
       slotHandler(...args);
     }
   };
 }
 function mergeClassNames(slot, child) {
-  return clsx(slot, child);
+  return clsx3(slot, child);
 }
 function mergeStyles(slot, child) {
   if (!isPlainObject(slot) || !isPlainObject(child)) return child;
@@ -2199,449 +2707,261 @@ function applyMergePolicy(key, slotVal, childVal) {
   return policyHandlers[classifyProp(key, slotVal, childVal)](slotVal, childVal);
 }
 
-// ../../lib/adapter-utils/src/build-definition.ts
-function buildDefinition(name, tag) {
-  return {
-    identity: {
-      id: name,
-      name,
-      tag
-    },
-    capabilities: {},
-    metadata: {},
-    diagnostics: []
-  };
-}
+// ../../adapters/preact/src/render.tsx
+import { h as h2 } from "preact";
 
-// ../../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
-    }
-  };
-}
+// ../../adapters/preact/src/slot/Slot.tsx
+import { forwardRef } from "preact/compat";
 
-// ../../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 };
-}
+// ../../adapters/preact/src/slot/applySlot.ts
+import { isValidElement as isValidElement3 } from "preact";
 
-// ../../runtime/core/src/get-active-props.ts
-function getActiveProps(nodeId, decoration) {
-  const dec = decoration[nodeId];
-  return { ...dec?.attributes ?? {}, ...dec?.variants ?? {} };
-}
+// ../../adapters/preact/src/slot/extractSlottable.ts
+import { h, Fragment as Fragment2, isValidElement as isValidElement2 } from "preact";
 
-// ../../runtime/core/src/render-component.ts
-function renderComponent(definition, tree, render, backend) {
-  return backend.render({ definition, tree, render });
-}
+// ../../adapters/preact/src/slot/predicates.ts
+import { isValidElement } from "preact";
 
-// ../../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"
-    });
-  } 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))
+// ../../adapters/preact/src/slot/Slottable.tsx
+import { Fragment } from "preact";
+import { jsx } from "preact/jsx-runtime";
+function Slottable({ children }) {
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+
+// ../../adapters/preact/src/slot/predicates.ts
+function isSlottableElement(value) {
+  return isValidElement(value) && value.type === Slottable;
+}
+
+// ../../adapters/preact/src/slot/extractSlottable.ts
+function extractSlottable(children) {
+  const childrenArray = Array.isArray(children) ? children : [children];
+  const slottables = childrenArray.filter(isSlottableElement);
+  invariant(slottables.length <= 1, "Slot: multiple Slottable children are not allowed");
+  if (slottables.length === 0) return null;
+  const [slottable] = slottables;
+  invariant(slottable, "Missing Slottable element");
+  const child = slottable.props.children;
+  invariant(
+    child !== null && child !== void 0,
+    "Slottable expects exactly one Preact element child, received null"
   );
-  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)) };
-}
-
-// ../../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;
-  });
-}
-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;
-}
-
-// ../../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: []
-      };
+  invariant(
+    typeof child !== "string" && typeof child !== "number",
+    "Slottable expects exactly one Preact element child, received text content"
+  );
+  invariant(isValidElement2(child), "Slottable expects exactly one Preact element child");
+  invariant(child.type !== Fragment2, "Slottable child cannot be a Fragment");
+  const index = childrenArray.indexOf(slottable);
+  return {
+    child,
+    rebuild(merged) {
+      const out = childrenArray.map((node, i) => i === index ? merged : node);
+      return h(Fragment2, null, ...out);
     }
-  }
-  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
   };
-  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;
+// ../../adapters/preact/src/slot/applySlot.ts
+function applySlot(children, slotProps, ref, cloneSlotChild2) {
+  const extraction = extractSlottable(children);
+  if (extraction) {
+    const merged = cloneSlotChild2({ child: extraction.child, slotProps, ref });
+    return extraction.rebuild(merged);
   }
-  const variantConfig = buildVariantConfig(variants, presets, defaults, compounds);
-  return {
-    execute(decoration, recipe) {
-      return resolveClasses(decoration, variantConfig, defaults, recipe, compounds, variantLookup);
-    }
-  };
+  invariant(isValidElement3(children), "Slot: child must be a valid Preact element");
+  return cloneSlotChild2({ child: children, slotProps, ref });
 }
 
-// ../../lib/adapter-utils/src/join-classes.ts
-function joinClasses(...classes) {
-  return classes.filter(Boolean).join(" ");
-}
+// ../../adapters/preact/src/slot/cloneSlotChild.ts
+import { cloneElement, Fragment as Fragment3 } from "preact";
 
-// ../../lib/adapter-utils/src/decoration-utils.ts
-function withAttributes(dec, attributes) {
-  const { attributes: _a, ...rest } = dec;
-  return attributes !== void 0 ? { ...rest, attributes } : rest;
+// ../../adapters/preact/src/slot/composeRefs.ts
+function mergeRefs(...refs) {
+  return mergeRefsCore(...refs);
 }
-
-// ../../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)
-  };
+function getChildRef(child) {
+  const ref = child.ref;
+  return ref ?? null;
 }
 
-// ../../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))
-  );
-  return {
-    ...decoration,
-    root: withAttributes(dec, Object.keys(kept).length > 0 ? kept : void 0)
-  };
+// ../../adapters/preact/src/slot/cloneSlotChild.ts
+function cloneSlotChild({ child, slotProps, ref }) {
+  const childProps = child.props;
+  const isFragment = child.type === Fragment3;
+  const childRef = isFragment ? null : getChildRef(child);
+  const mergedRef = isFragment ? null : mergeRefs(ref, childRef);
+  const merged = mergeSlotProps(slotProps, childProps);
+  return cloneElement(child, mergedRef !== null ? { ...merged, ref: mergedRef } : merged);
 }
 
-// ../../lib/adapter-utils/src/apply-ref.ts
-function applyRef(decoration, ref) {
-  if (ref == null) return decoration;
-  const existing = decoration["root"] ?? {};
-  return { ...decoration, root: { ...existing, ref } };
+// ../../adapters/preact/src/slot/Slot.tsx
+var Slot = forwardRef(function Slot2({ children, ...slotProps }, ref) {
+  return applySlot(children, slotProps, ref ?? null, cloneSlotChild);
+});
+Object.assign(Slot, { displayName: SLOT_NAME });
+
+// ../../adapters/preact/src/render.tsx
+function buildRenderState(tag, directives, props, className, children) {
+  const state = { tag, directives, props, className };
+  if (children !== void 0) state.children = children;
+  return state;
+}
+function prepareRenderState(runtime, props, filterProps) {
+  const { as, asChild, children, className, recipe, ...rest } = props;
+  const tag = runtime.resolveTag(as);
+  if (runtime.options.allowedAs !== void 0 && as !== 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 resolvedClass = runtime.resolveClasses(tag, normalizedProps, className, recipe);
+  const filteredProps = applyFilter(normalizedProps, filterProps, runtime.options.variantKeys);
+  const directives = {
+    ...as !== void 0 && { as },
+    ...asChild !== void 0 && { asChild }
+  };
+  return buildRenderState(tag, directives, filteredProps, resolvedClass, children);
 }
-
-// ../../adapters/preact/src/create-contract-component.ts
-import { forwardRef } from "preact/compat";
-
-// ../../adapters/preact/src/backend/extract-decoration.ts
-function isStyleValue(v) {
-  return isString(v) || isNumber(v);
+function warnDiscardedChildren(originalChildren, normalizedChildren, validator) {
+  if (!Array.isArray(originalChildren)) return;
+  const discarded = originalChildren.length - normalizedChildren.length;
+  if (discarded > 0) validator.warnDiscardedChildren(discarded);
 }
-function isAttributeValue(v) {
-  return isString(v) || isNumber(v) || typeof v === "boolean";
+function isSingleElementArray(arr) {
+  return arr.length === 1;
 }
-function assignIfNotEmpty(target, key, value) {
-  if (Object.keys(value).length > 0) {
-    target[key] = value;
+function resolveSlotChildren(children, normalized, validator) {
+  warnDiscardedChildren(children, normalized, validator);
+  if (isSingleElementArray(normalized)) {
+    return normalized[0];
   }
+  if (normalized.length > 1 && normalized.some(isSlottableElement)) {
+    return normalized;
+  }
+  validator.assertSingleChild(normalized.length);
+  return null;
 }
-function extractStyles(value, styles) {
-  if (!isObject(value)) return false;
-  iterate.forEachEntry(value, (k, v) => {
-    if (isStyleValue(v)) {
-      styles[k] = v;
-    }
-  });
-  return true;
-}
-function extractListener(key, value, listeners) {
-  if (!key.startsWith("on") || !isFunction(value)) {
+function validateSlotDirectives(directives, validator) {
+  const { as, asChild } = directives;
+  if (!asChild) return false;
+  if (as !== void 0) {
+    validator.assertExclusive();
     return false;
   }
-  listeners[key] = value;
   return true;
 }
-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);
-    }
+function resolveSlotRender(state, getNormalized, validator) {
+  if (!validateSlotDirectives(state.directives, validator)) return null;
+  const child = resolveSlotChildren(state.children, getNormalized(), validator);
+  if (child === null) return null;
+  return { child };
+}
+function renderResolvedSlot(slotComponent, state, slotRender, ref) {
+  return h2(slotComponent, {
+    ...state.props,
+    className: state.className,
+    ref,
+    children: slotRender.child
   });
-  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;
-  }
-  return dec;
 }
-
-// ../../adapters/preact/src/helpers/render-normally.ts
-import { cloneElement } from "preact";
-
-// ../../adapters/preact/src/backend/preact-backend.ts
-import { Fragment, h } from "preact";
-
-// ../../adapters/preact/src/backend/build-props.ts
-function buildPropsFromDecoration(id, decoration) {
+function tryRenderAsChild(state, ref, slotComponent, getNormalized, validator) {
+  const slotRender = resolveSlotRender(state, getNormalized, validator);
+  if (slotRender === null) return null;
+  return renderResolvedSlot(slotComponent, state, slotRender, ref);
+}
+function buildElementProps(props, className, ref, children) {
+  const { role, ...rest } = props;
   return {
-    key: id,
-    ...decoration?.attributes,
-    ...decoration?.styles !== void 0 ? { style: decoration.styles } : {},
-    ...decoration?.listeners,
-    ...decoration?.ref !== void 0 ? { ref: decoration.ref } : {}
+    ...rest,
+    className,
+    ref,
+    ...children !== void 0 && { children },
+    ...isKnownAriaRole(role) && { role }
   };
 }
-
-// ../../adapters/preact/src/backend/preact-backend.ts
-function renderNode(node, render) {
-  const children = node.children.map((child) => renderNode(child, render));
-  if (node.kind === "component") {
-    return h(Fragment, { key: node.id }, ...children);
-  }
-  const decoration = render.decoration.get(node.id);
-  const props = buildPropsFromDecoration(node.id, decoration);
-  return h(node.tag, props, ...children);
-}
-var preactBackend = {
-  render(context) {
-    return renderNode(context.tree.root, context.render);
-  }
-};
-
-// ../../adapters/preact/src/helpers/render-normally.ts
-function renderNormally(definition, tag, decoration, children) {
-  const treeCtx = buildTreeContext({ kind: "native", tag, id: "root", children: [] });
-  const rendered = renderComponent(
-    definition,
-    treeCtx,
-    buildRenderContext(decoration),
-    preactBackend
+function renderIntrinsic(state, ref, runtime) {
+  const elementProps = buildElementProps(state.props, state.className, ref, state.children);
+  const domProps = typeof state.tag === "string" ? runtime.resolveAria(state.tag, elementProps).props : elementProps;
+  return h2(state.tag, domProps);
+}
+function render({
+  runtime,
+  props,
+  ref,
+  slotComponent,
+  normalizeChildren: normalizeChildren2,
+  filterProps,
+  slotValidator,
+  childrenEvaluator
+}) {
+  const state = prepareRenderState(runtime, props, filterProps);
+  let normalizedChildren;
+  const getNormalizedChildren = () => normalizedChildren ??= normalizeChildren2(state.children);
+  if (process.env.NODE_ENV !== "production") {
+    childrenEvaluator?.evaluate(getNormalizedChildren());
+    runtime.options.htmlChildrenEvaluatorFn?.(state.tag)?.evaluate(getNormalizedChildren());
+  }
+  const slotResult = tryRenderAsChild(
+    state,
+    ref,
+    slotComponent,
+    getNormalizedChildren,
+    slotValidator
   );
-  return children === void 0 ? rendered : cloneElement(rendered, {}, children);
-}
-
-// ../../adapters/preact/src/helpers/make-render-as-child.ts
-import { isValidElement } from "preact";
-function makeRenderAsChild(cloneSlotChild2) {
-  return function renderAsChild(children, className, ref) {
-    if (!isValidElement(children)) throw new Error("asChild requires a Preact element child");
-    const slotProps = className ? { className } : {};
-    return cloneSlotChild2({ child: children, slotProps, ref: ref ?? null });
-  };
+  return slotResult ?? renderIntrinsic(state, ref, runtime);
 }
 
 // ../../adapters/preact/src/normalize-children.ts
-import { isValidElement as isValidElement2 } from "preact";
+import { isValidElement as isValidElement4 } from "preact";
 function normalizeChildren(children) {
-  if (isValidElement2(children)) return [children];
-  if (Array.isArray(children)) return children.filter(isValidElement2);
+  if (isValidElement4(children)) return [children];
+  if (Array.isArray(children)) return children.filter(isValidElement4);
   return [];
 }
 
-// ../../adapters/preact/src/slot/cloneSlotChild.ts
-import { cloneElement as cloneElement2, Fragment as Fragment2 } from "preact";
-
-// ../../adapters/preact/src/slot/composeRefs.ts
-function mergeRefs(...refs) {
-  return mergeRefsCore(...refs);
-}
-function getChildRef(child) {
-  const ref = child.ref;
-  return ref ?? null;
-}
-
-// ../../adapters/preact/src/slot/cloneSlotChild.ts
-function cloneSlotChild({ child, slotProps, ref }) {
-  const childProps = child.props;
-  const isFragment = child.type === Fragment2;
-  const childRef = isFragment ? null : getChildRef(child);
-  const mergedRef = isFragment ? null : mergeRefs(ref, childRef);
-  const merged = mergeSlotProps(slotProps, childProps);
-  return cloneElement2(child, mergedRef !== null ? { ...merged, ref: mergedRef } : merged);
+// ../../adapters/preact/src/build-runtime.ts
+function normalizeOptions(options) {
+  return {
+    ...options,
+    ...resolveAdapterCommonOptions(options),
+    slotComponent: options.slotComponent ?? Slot
+  };
 }
-
-// ../../adapters/preact/src/slot/Slottable.tsx
-import { Fragment as Fragment3 } from "preact";
-import { jsx } from "preact/jsx-runtime";
-function Slottable({ children }) {
-  return /* @__PURE__ */ jsx(Fragment3, { children });
+function buildRuntime(options) {
+  const normalized = normalizeOptions(options);
+  const { runtime, ownedKeys } = buildCoreRuntime(normalized);
+  const { diagnostics, enforcement, filterProps: userFilter, name, slotComponent } = normalized;
+  const { childrenEvaluator } = buildEngines(diagnostics, enforcement?.children, name);
+  const filterProps = composeFilter(ownedKeys, userFilter);
+  const slotValidator = new SlotValidator(name, diagnostics, "Preact element");
+  const built = {
+    runtime,
+    filterProps,
+    slotValidator,
+    slotComponent,
+    normalizeChildren,
+    ...childrenEvaluator !== void 0 && { childrenEvaluator }
+  };
+  return built;
 }
 
 // ../../adapters/preact/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, "Preact element");
-  const renderAsChild = makeRenderAsChild(cloneSlotChild);
-  const Component = forwardRef(function Component2(props, ref) {
-    const {
-      as,
-      asChild,
-      children,
-      className: callerClassName,
-      recipe,
-      ...ownProps
-    } = props;
-    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
-    );
-    if (process.env.NODE_ENV !== "production") {
-      const childEval = explicitEvaluator ?? getHtmlChildrenEvaluator(tag);
-      childEval?.evaluate(normalizeChildren(children));
-    }
-    const recipeName = typeof recipe === "string" ? recipe : void 0;
-    const { variantClasses, compoundClasses } = stylePipeline ? stylePipeline.execute(decoration, recipeName) : { variantClasses: [], compoundClasses: [] };
-    const rawClassName = joinClasses(base, ...variantClasses, ...compoundClasses, callerClassName);
-    const className = classPlugin !== void 0 ? classPlugin.pipeline(tag, pluginProps, rawClassName, recipeName) : rawClassName;
-    if (asChild === true) {
-      if (typeof as === "string") {
-        slotValidator.assertExclusive();
-      } else {
-        return renderAsChild(children, className, ref ?? null);
-      }
-    }
-    let finalDecoration = className ? applyAttributes("root", { className }, decoration, variantKeys) : decoration;
-    finalDecoration = applyFilterProps(finalDecoration, filterFn, variantKeys);
-    finalDecoration = applyRef(finalDecoration, ref ?? null);
-    return renderNormally(definition, tag, finalDecoration, children);
+  const bundle = buildRuntime(options);
+  const Component = forwardRef2(function Component2(props, ref) {
+    return render({ ...bundle, props, ref: ref ?? null });
   });
   applyDisplayName(Component, options.name);
+  const defaultTag = bundle.runtime.options.defaultTag;
   if (typeof defaultTag === "string") {
     Object.assign(Component, { [COMPONENT_DEFAULT_TAG]: defaultTag });
   }