praxis-kit 3.1.0 → 4.0.0

package/dist/preact/index.js

@@ -1,23 +1,18 @@
-// ../../adapters/preact/src/create-contract-component.ts
-import { forwardRef as forwardRef2 } from "preact/compat";
-
-// ../../adapters/preact/src/normalize-children.ts
-import { isValidElement } from "preact";
-function normalizeChildren(children) {
-  if (isValidElement(children)) return [children];
-  if (Array.isArray(children)) return children.filter(isValidElement);
-  return [];
+// ../../lib/adapter-utils/src/apply-display-name.ts
+function applyDisplayName(component, name) {
+  Object.assign(component, { displayName: name ?? "PolymorphicComponent" });
 }
 
-// ../shared/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 isNull(value) {
-  return value === null;
+function isObject(value, excludeArrays = false) {
+  if (value === null || typeof value !== "object") return false;
+  return excludeArrays ? !Array.isArray(value) : true;
 }
-function isObject(value) {
-  return !isNull(value) && typeof value === "object";
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
 }
 
 // ../../lib/primitive/src/merge/constants.ts
@@ -33,372 +28,198 @@ function isPlainObject(value) {
   return proto === Object.prototype || proto === null;
 }
 
-// ../../adapters/preact/src/apply-display-name.ts
-function applyDisplayName(component, name) {
-  Object.assign(component, { displayName: name ?? "PolymorphicComponent" });
+// ../../lib/primitive/src/utils/assert-never.ts
+function assertNever(value) {
+  throw new Error(`Unexpected value: ${String(value)}`);
 }
 
-// ../../lib/adapter-utils/src/apply-filter.ts
-function applyFilter(props, filterProps, variantKeys) {
-  const out = {};
-  for (const k in props) {
-    if (!Object.hasOwn(props, k)) continue;
-    if (filterProps(k, variantKeys)) continue;
-    out[k] = props[k];
+// ../../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 out;
+  return null;
 }
-
-// ../../lib/adapter-utils/src/define-component.ts
-function defineContractComponent(options) {
-  return (factory) => factory(options);
+function some(iterable, predicate) {
+  for (const value of iterable) {
+    if (predicate(value)) return true;
+  }
+  return false;
 }
-
-// ../core/dist/chunk-KKSHJDE7.js
-function makeResolveTag(defaultTag) {
-  return function tag(as) {
-    return as ?? defaultTag;
-  };
+function every(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (!predicate(value, index++)) {
+      return false;
+    }
+  }
+  return true;
 }
-function assertNever(value) {
-  throw new Error(`Unexpected value: ${String(value)}`);
+function* filter(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (predicate(value, index++)) {
+      yield value;
+    }
+  }
 }
-function r(e) {
-  var t, f, n = "";
-  if ("string" == typeof e || "number" == typeof e) n += e;
-  else if ("object" == typeof e) if (Array.isArray(e)) {
-    var o = e.length;
-    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
-  } else for (f in e) e[f] && (n && (n += " "), n += f);
-  return n;
+function* map(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    yield callback(value, index++);
+  }
 }
-function clsx() {
-  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
-  return n;
+function forEach(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    callback(value, index++);
+  }
 }
-function cn(...inputs) {
-  return clsx(...inputs);
+function reduce(iterable, initial, callback) {
+  let accumulator = initial;
+  let index = 0;
+  for (const value of iterable) {
+    accumulator = callback(accumulator, value, index++);
+  }
+  return accumulator;
 }
-function mergeProps(defaultProps, props) {
-  return {
-    ...defaultProps ?? {},
-    ...props
-  };
+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 isNull2(value) {
-  return value === null;
+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 isObject2(value) {
-  return !isNull2(value) && typeof value === "object";
+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 isString(value) {
-  return typeof value === "string";
+function mapEntries(m) {
+  return m.entries();
 }
-function isNumber(value) {
-  return typeof value === "number";
+function set(s) {
+  return s.values();
 }
-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 hasOwn(object, key) {
+  return Object.hasOwn(object, key);
 }
-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",
-    strict: enforcement?.strict ?? false,
-    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)
-  });
+function* entries(object) {
+  for (const key in object) {
+    if (!hasOwn(object, key)) continue;
+    yield [key, object[key]];
+  }
 }
-function report(strict, message) {
-  if (strict === false) return;
-  const mode = strict === true ? "throw" : strict;
-  if (mode === "throw") throw new Error(message);
-  console.warn(message);
-}
-function validateFactoryOptions(resolved) {
-  const { strict } = resolved;
-  if (strict === false) return;
-  const name = resolved.displayName ?? "Component";
-  const { variants } = resolved;
-  const checkSelection = (label2, selection) => {
-    const record = selection;
-    for (const dim in record) {
-      const value = record[dim];
-      if (value === void 0 || value === null) continue;
-      if (!variants || !Object.hasOwn(variants, dim)) {
-        report(strict, `${name}: ${label2} references unknown variant "${dim}".`);
-        continue;
-      }
-      const states = variants[dim];
-      const stateKey = String(value);
-      if (!Object.hasOwn(states, stateKey)) {
-        report(
-          strict,
-          `${name}: ${label2} sets "${dim}" to unknown value "${stateKey}" (valid: ${Object.keys(states).join(", ")}).`
-        );
-      }
-    }
-  };
-  const { recipeMap } = resolved;
-  if (recipeMap) {
-    for (const recipeKey in recipeMap) {
-      checkSelection(`preset "${recipeKey}"`, recipeMap[recipeKey]);
-    }
+function* keys(object) {
+  for (const [key] of entries(object)) {
+    yield key;
   }
-  if (resolved.defaultVariants) checkSelection("defaults", resolved.defaultVariants);
-}
-var warned = /* @__PURE__ */ new Set();
-var pendingAsyncWarns = /* @__PURE__ */ new Set();
-var asyncWarnScheduled = false;
-function flushAsyncWarns() {
-  asyncWarnScheduled = false;
-  const messages = [...pendingAsyncWarns];
-  pendingAsyncWarns.clear();
-  for (const msg of messages) {
-    console.warn(msg);
-  }
-}
-function report2(strict, message) {
-  if (!strict) return;
-  const mode = strict === true ? "throw" : strict;
-  if (mode === "throw") throw new Error(message);
-  if (mode === "async-warn") {
-    if (pendingAsyncWarns.has(message)) return;
-    pendingAsyncWarns.add(message);
-    if (!asyncWarnScheduled) {
-      asyncWarnScheduled = true;
-      queueMicrotask(flushAsyncWarns);
-    }
-    return;
-  }
-  if (warned.has(message)) return;
-  warned.add(message);
-  console.warn(message);
-}
-function label(name) {
-  return name ? `[${name}]` : "[createContractComponent]";
-}
-function validateRenderProps(options, props, recipeKey) {
-  const { strict, recipeMap, variants, displayName } = options;
-  if (!strict) return;
-  const tag = label(displayName);
-  if (recipeKey !== void 0 && (!recipeMap || !Object.hasOwn(recipeMap, recipeKey))) {
-    report2(strict, `${tag} Unknown recipeKey "${recipeKey}" \u2014 no preset with that name exists.`);
-  }
-  if (variants) {
-    for (const key in variants) {
-      if (!Object.hasOwn(props, key)) continue;
-      const value = props[key];
-      if (value === void 0 || value === null) continue;
-      const dim = variants[key];
-      if (dim && !Object.hasOwn(dim, String(value))) {
-        report2(
-          strict,
-          `${tag} Variant "${key}=${String(value)}" is not a defined value for the "${key}" dimension.`
-        );
-      }
-    }
+}
+function* values(object) {
+  for (const [, value] of entries(object)) {
+    yield value;
   }
 }
-function panic(message) {
-  throw new Error(message);
+function mapValues(object, callback) {
+  const result = {};
+  for (const [key, value] of entries(object)) {
+    result[key] = callback(value, key);
+  }
+  return result;
 }
-function describe(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  return typeof value;
+function forEachEntry(object, callback) {
+  for (const [key, value] of entries(object)) {
+    callback(key, value);
+  }
 }
-function assertPluginShape(result) {
-  if (result === null || typeof result !== "object")
-    panic(
-      `[praxis-kit] Plugin factory must return an object with a 'pipeline' function. Got: ${result === null ? "null" : typeof result}.`
-    );
-  const plugin = result;
-  if (typeof plugin.pipeline !== "function")
-    panic(
-      `[praxis-kit] Plugin factory return value is missing a 'pipeline' function. Got pipeline: ${typeof plugin.pipeline}.`
-    );
+function forEachKey(object, callback) {
+  for (const key of keys(object)) {
+    callback(key);
+  }
 }
-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")
-      panic(`[praxis-kit] Plugin pipeline must return a string. Got: ${describe(result)}.`);
-    return result;
-  };
+function forEachValue(object, callback) {
+  for (const value of values(object)) {
+    callback(value);
+  }
 }
-var NOOP_CLASS_PIPELINE = (_tag, _props, className) => Array.isArray(className) ? className.join(" ") : className ?? "";
-function resolveClassPipeline(options, resolved, strict, capabilities) {
-  const factory = options.styling?.plugin;
-  if (!factory) {
-    const createClassPipeline2 = capabilities?.createClassPipeline;
-    const classPipeline2 = createClassPipeline2 ? createClassPipeline2(resolved) : NOOP_CLASS_PIPELINE;
-    return { pluginResult: void 0, classPipeline: classPipeline2 };
+function forEachSet(s, callback) {
+  for (const value of s) {
+    callback(value);
   }
-  const pluginResult = factory(resolved, strict);
-  assertPluginShape(pluginResult);
-  const classPipeline = guardPipeline(pluginResult.pipeline);
-  return { pluginResult, classPipeline };
 }
-function createRuntimeMethods(resolved, classPipeline, engine) {
-  return {
-    resolveTag: makeResolveTag(resolved.defaultTag),
-    resolveProps(props) {
-      return mergeProps(resolved.defaultProps, props);
-    },
-    resolveClasses(tag, props, className, recipe) {
-      if (process.env.NODE_ENV !== "production") {
-        validateRenderProps(resolved, props, recipe);
+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;
       }
-      return classPipeline(tag, props, className, recipe);
-    },
-    resolveAria(tag, props) {
-      if (!engine) return { props };
-      const result = engine.validate(tag, props);
-      return { props: result.props };
-    }
+    });
   };
 }
-function createRuntimeObject(methods, resolved, pluginResult) {
-  return pluginResult ? { ...methods, options: resolved, hasStyling: true, classPlugin: pluginResult } : { ...methods, options: resolved };
-}
-function createPolymorphic(options = {}, capabilities) {
-  const baseResolved = resolveFactoryOptions(options);
-  const resolved = capabilities?.htmlPropNormalizersFn !== void 0 ? Object.freeze({
-    ...baseResolved,
-    htmlPropNormalizersFn: capabilities.htmlPropNormalizersFn
-  }) : baseResolved;
-  if (process.env.NODE_ENV !== "production") validateFactoryOptions(resolved);
-  const { pluginResult, classPipeline } = resolveClassPipeline(
-    options,
-    resolved,
-    resolved.strict,
-    capabilities
-  );
-  const allAriaRules = [
-    .../* @__PURE__ */ new Set([...capabilities?.htmlAriaRules ?? [], ...resolved.ariaRules ?? []])
-  ];
-  const engine = options.enforcement !== void 0 && capabilities?.AriaEngine ? new capabilities.AriaEngine(
-    resolved.strict,
-    allAriaRules.length ? { rules: allAriaRules } : void 0
-  ) : null;
-  const methods = createRuntimeMethods(resolved, classPipeline, engine);
-  return createRuntimeObject(
-    methods,
-    resolved,
-    pluginResult
-  );
-}
-var KNOWN_ARIA_ROLES = [
-  "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/global-aria-attributes.ts
 var GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
   "aria-atomic",
   "aria-busy",
@@ -418,29 +239,59 @@ var GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
   "aria-relevant",
   "aria-roledescription"
 ]);
+
+// ../../lib/primitive/src/constants/aria/implicit-role-record.ts
 var IMPLICIT_ROLE_RECORD = {
+  // Landmarks
   article: "article",
   aside: "complementary",
   footer: "contentinfo",
   header: "banner",
   main: "main",
   nav: "navigation",
-  button: "button",
+  // Interactive
   a: "link",
+  button: "button",
   select: "listbox",
+  textarea: "textbox",
+  // Headings
   h1: "heading",
   h2: "heading",
   h3: "heading",
   h4: "heading",
   h5: "heading",
   h6: "heading",
+  // Lists
   ul: "list",
   ol: "list",
   li: "listitem",
+  // Tables
   table: "table",
   tr: "row",
   td: "cell",
-  th: "columnheader"
+  th: "columnheader",
+  // Structural / semantic
+  dialog: "dialog",
+  fieldset: "group",
+  figure: "figure",
+  meter: "meter",
+  output: "status",
+  progress: "progressbar"
+};
+var INPUT_TYPE_ROLE_MAP = {
+  checkbox: "checkbox",
+  radio: "radio",
+  range: "slider",
+  number: "spinbutton",
+  search: "searchbox",
+  text: "textbox",
+  email: "textbox",
+  tel: "textbox",
+  url: "textbox",
+  button: "button",
+  submit: "button",
+  reset: "button",
+  image: "button"
 };
 var STRONG_ROLES = [
   "main",
@@ -452,6 +303,8 @@ var STRONG_ROLES = [
 var STANDALONE_ROLES = ["article"];
 var STRONG_ROLES_SET = new Set(STRONG_ROLES);
 var STANDALONE_ROLES_SET = new Set(STANDALONE_ROLES);
+
+// ../../lib/primitive/src/constants/aria/role-restricted-attributes.ts
 var ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
   [
     "aria-activedescendant",
@@ -601,9 +454,18 @@ var ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
     /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
   ]
 ]);
+
+// ../../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);
 }
@@ -613,6 +475,8 @@ function isAriaAttributeValidForRole(attr, role) {
   if (isUndefined(role)) return false;
   return allowedRoles.has(role);
 }
+
+// ../../lib/primitive/src/guards/aria/is-aria-role.ts
 function isStrongImplicitRole(tag) {
   if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
   return STRONG_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
@@ -621,53 +485,35 @@ function isStandaloneTag(tag) {
   if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
   return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
 }
-function isKnownAriaRole(value) {
-  return isString(value) && KNOWN_ARIA_ROLES_SET.has(value);
+function getInputImplicitRole(type) {
+  if (type == null || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
+  return INPUT_TYPE_ROLE_MAP[type];
 }
-
-// ../core/dist/chunk-2NJ5XLOA.js
-var IMPLICIT_ROLE_RECORD2 = {
-  article: "article",
-  aside: "complementary",
-  footer: "contentinfo",
-  header: "banner",
-  main: "main",
-  nav: "navigation",
-  button: "button",
-  a: "link",
-  select: "listbox",
-  h1: "heading",
-  h2: "heading",
-  h3: "heading",
-  h4: "heading",
-  h5: "heading",
-  h6: "heading",
-  ul: "list",
-  ol: "list",
-  li: "listitem",
-  table: "table",
-  tr: "row",
-  td: "cell",
-  th: "columnheader"
-};
-function getImplicitRole(tag) {
-  if (tag in IMPLICIT_ROLE_RECORD2) return IMPLICIT_ROLE_RECORD2[tag];
+function getConditionalImplicitRole(tag, ariaLabel, ariaLabelledBy) {
+  const isNamed = typeof ariaLabel === "string" || typeof ariaLabelledBy === "string";
+  if (!isNamed) return void 0;
+  if (tag === "section") return "region";
+  if (tag === "form") return "form";
   return void 0;
 }
-var COMPONENT_DEFAULT_TAG2 = /* @__PURE__ */ Symbol.for("praxis.component-default-tag");
+
+// ../../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 (!isObject2(child) || !("props" in child)) return void 0;
+  if (!isObject(child) || !("props" in child)) return void 0;
   const props = child.props;
-  if (!isObject2(props)) return void 0;
+  if (!isObject(props)) return void 0;
   const as = props.as;
   return isString(as) && as !== "" ? as : void 0;
 }
 function getTag(child) {
-  if (!isObject2(child) || !("type" in child)) return void 0;
+  if (!isObject(child) || !("type" in child)) return void 0;
   const t = child.type;
   if (isString(t)) return t;
-  if (typeof t === "function" || isObject2(t)) {
-    const defaultTag = t[COMPONENT_DEFAULT_TAG2];
+  if (typeof t === "function" || isObject(t)) {
+    const defaultTag = t[COMPONENT_DEFAULT_TAG];
     if (!isString(defaultTag)) return void 0;
     return getAsProp(child) ?? defaultTag;
   }
@@ -675,65 +521,543 @@ function getTag(child) {
 }
 function isTag(...args) {
   if (isString(args[0])) {
-    const set2 = new Set(args);
+    const set3 = new Set(args);
     return (child2) => {
       const tag2 = getTag(child2);
-      return tag2 !== void 0 && set2.has(tag2);
+      return tag2 !== void 0 && set3.has(tag2);
     };
   }
   const [child, ...tags] = args;
-  const set = new Set(tags);
+  const set2 = new Set(tags);
   const tag = getTag(child);
-  return tag !== void 0 && set.has(tag);
-}
-var pendingAsyncWarns2 = /* @__PURE__ */ new Set();
-var asyncWarnScheduled2 = false;
-function flushAsyncWarns2() {
-  asyncWarnScheduled2 = false;
-  const messages = [...pendingAsyncWarns2];
-  pendingAsyncWarns2.clear();
-  for (const msg of messages) {
-    console.warn(msg);
-  }
-}
-function scheduleAsyncWarn(message) {
-  if (pendingAsyncWarns2.has(message)) return;
-  pendingAsyncWarns2.add(message);
-  if (!asyncWarnScheduled2) {
-    asyncWarnScheduled2 = true;
-    queueMicrotask(flushAsyncWarns2);
-  }
-}
-var StrictBase = class {
-  strict;
-  constructor(strict) {
-    this.strict = strict;
-  }
-  violate(message) {
-    if (this.strict === true || this.strict === "throw") {
-      throw new Error(message);
-    }
-    this.warn(message);
+  return tag !== void 0 && set2.has(tag);
+}
+
+// ../../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/contract/src/strict/invariant-base.ts
+var InvariantBase = class {
+  diagnostics;
+  constructor(diagnostics) {
+    this.diagnostics = diagnostics;
   }
-  // Always caps at console.warn — never throws. ARIA 'warning' violations route here
+  get active() {
+    return this.diagnostics.active;
+  }
+  violate(input) {
+    this.diagnostics.error(input);
+  }
+  // Always caps at warn — never throws. ARIA 'warning' violations route here
   // so they surface even in strict='throw' mode without aborting a render.
-  warn(message) {
-    if (!this.strict) return;
-    if (this.strict === "async-warn") {
-      scheduleAsyncWarn(message);
-      return;
-    }
-    console.warn(message);
+  warn(input) {
+    this.diagnostics.warn(input);
   }
-  invariant(condition, message) {
-    if (!condition) {
-      this.violate(message);
-    }
+  invariant(condition, input) {
+    if (!condition) this.violate(input);
   }
 };
-function isNull3(value) {
-  return value === null;
+
+// ../../lib/diagnostics/src/category.ts
+var DiagnosticCategory = /* @__PURE__ */ ((DiagnosticCategory2) => {
+  DiagnosticCategory2[DiagnosticCategory2["Contract"] = 0] = "Contract";
+  DiagnosticCategory2[DiagnosticCategory2["HTML"] = 1] = "HTML";
+  DiagnosticCategory2[DiagnosticCategory2["ARIA"] = 2] = "ARIA";
+  DiagnosticCategory2[DiagnosticCategory2["Composition"] = 3] = "Composition";
+  DiagnosticCategory2[DiagnosticCategory2["Rendering"] = 4] = "Rendering";
+  DiagnosticCategory2[DiagnosticCategory2["Accessibility"] = 5] = "Accessibility";
+  DiagnosticCategory2[DiagnosticCategory2["Performance"] = 6] = "Performance";
+  DiagnosticCategory2[DiagnosticCategory2["Internal"] = 7] = "Internal";
+  DiagnosticCategory2[DiagnosticCategory2["Deprecation"] = 8] = "Deprecation";
+  DiagnosticCategory2[DiagnosticCategory2["Lint"] = 9] = "Lint";
+  return DiagnosticCategory2;
+})(DiagnosticCategory || {});
+
+// ../../lib/diagnostics/src/error.ts
+var PraxisError = class extends Error {
+  diagnostic;
+  constructor(diagnostic) {
+    super(diagnostic.message);
+    this.name = "PraxisError";
+    this.diagnostic = diagnostic;
+  }
+};
+
+// ../../lib/diagnostics/src/severity.ts
+var Severity = /* @__PURE__ */ ((Severity2) => {
+  Severity2[Severity2["Debug"] = 0] = "Debug";
+  Severity2[Severity2["Info"] = 1] = "Info";
+  Severity2[Severity2["Warning"] = 2] = "Warning";
+  Severity2[Severity2["Error"] = 3] = "Error";
+  Severity2[Severity2["Fatal"] = 4] = "Fatal";
+  return Severity2;
+})(Severity || {});
+
+// ../../lib/diagnostics/src/policy.ts
+var DefaultPolicy = class {
+  reportThreshold;
+  throwThreshold;
+  constructor({
+    reportThreshold = 1 /* Info */,
+    throwThreshold = 4 /* Fatal */
+  } = {}) {
+    this.reportThreshold = reportThreshold;
+    this.throwThreshold = throwThreshold;
+  }
+  resolve(diagnostic) {
+    if (diagnostic.severity >= this.throwThreshold) return 2 /* Throw */;
+    if (diagnostic.severity >= this.reportThreshold) return 1 /* Report */;
+    return 0 /* Ignore */;
+  }
+};
+
+// ../../lib/diagnostics/src/diagnostics.ts
+var Diagnostics = class {
+  reporter;
+  policy;
+  // Pre-computed at construction time: true if Warning-level diagnostics are not ignored.
+  active;
+  constructor(reporter, policy = new DefaultPolicy()) {
+    this.reporter = reporter;
+    this.policy = policy;
+    this.active = policy.resolve({ severity: 2 /* Warning */ }) !== 0 /* Ignore */;
+  }
+  report(diagnostic) {
+    const enforcement = this.policy.resolve(diagnostic);
+    if (enforcement === 0 /* Ignore */) return diagnostic;
+    if (enforcement === 2 /* Throw */) throw new PraxisError(diagnostic);
+    this.reporter.report(diagnostic);
+    return diagnostic;
+  }
+  warn(input) {
+    return this.report({ ...input, severity: 2 /* Warning */ });
+  }
+  error(input) {
+    return this.report({ ...input, severity: 3 /* Error */ });
+  }
+  info(input) {
+    return this.report({ ...input, severity: 1 /* Info */ });
+  }
+};
+
+// ../../lib/diagnostics/src/formatter.ts
+function formatDiagnostic(diagnostic) {
+  const level = Severity[diagnostic.severity];
+  const category = DiagnosticCategory[diagnostic.category];
+  const prefix = category !== void 0 ? `[${category}] ` : "";
+  return `${level} ${diagnostic.code}: ${prefix}${diagnostic.message}`;
 }
+
+// ../../lib/diagnostics/src/console-reporter.ts
+var ConsoleReporter = class {
+  report(diagnostic) {
+    const message = formatDiagnostic(diagnostic);
+    switch (diagnostic.severity) {
+      case 0 /* Debug */:
+        console.debug(message);
+        break;
+      case 1 /* Info */:
+        console.info(message);
+        break;
+      case 2 /* Warning */:
+        console.warn(message);
+        break;
+      case 3 /* Error */:
+      case 4 /* Fatal */:
+        console.error(message);
+        break;
+    }
+  }
+};
+
+// ../../lib/diagnostics/src/null-reporter.ts
+var nullReporter = {
+  report() {
+  }
+};
+
+// ../../lib/diagnostics/src/presets.ts
+var ignoreAllPolicy = {
+  resolve(_) {
+    return 0 /* Ignore */;
+  }
+};
+var warnOnlyReporter = {
+  report(diagnostic) {
+    console.warn(formatDiagnostic(diagnostic));
+  }
+};
+var silentDiagnostics = new Diagnostics(nullReporter, ignoreAllPolicy);
+var warnDiagnostics = new Diagnostics(
+  warnOnlyReporter,
+  new DefaultPolicy({ reportThreshold: 2 /* Warning */, throwThreshold: 4 /* Fatal */ })
+);
+var throwDiagnostics = new Diagnostics(
+  new ConsoleReporter(),
+  new DefaultPolicy({ reportThreshold: 2 /* Warning */, throwThreshold: 3 /* Error */ })
+);
+
+// ../../lib/contract/src/diagnostics/aria.ts
+var AriaDiagnostics = {
+  /** Generic bridge for violations produced by external AriaRule functions. */
+  fromViolation(v) {
+    return {
+      code: "ARIA2002" /* AriaViolation */,
+      category: 2 /* ARIA */,
+      message: v.message
+    };
+  },
+  attributeInvalid(key, role) {
+    return {
+      code: "ARIA2003" /* AriaAttributeInvalid */,
+      category: 2 /* ARIA */,
+      message: `"${key}" is not valid on role="${role}". It will be removed.`,
+      rationale: "Invalid ARIA attributes are ignored by assistive technology and may trigger accessibility-tree warnings in browser devtools.",
+      suggestions: [
+        {
+          title: "Remove the attribute",
+          description: `"${key}" is not in the allowed attribute set for role="${role}".`
+        }
+      ]
+    };
+  },
+  missingLiveRegion(role, impliedLive) {
+    return {
+      code: "ARIA2004" /* AriaMissingLiveRegion */,
+      category: 2 /* ARIA */,
+      message: `role="${role}" implies aria-live="${impliedLive}" but it is missing. It has been injected.`,
+      rationale: "Live-region roles announce dynamic content changes to screen readers. Without aria-live the politeness level is unspecified and announcements may be silent.",
+      suggestions: [
+        {
+          title: `Add aria-live="${impliedLive}"`,
+          description: `role="${role}" conventionally implies aria-live="${impliedLive}".`,
+          fix: `aria-live="${impliedLive}"`
+        }
+      ]
+    };
+  },
+  missingAtomic(role) {
+    return {
+      code: "ARIA2005" /* AriaMissingAtomic */,
+      category: 2 /* ARIA */,
+      message: `role="${role}" is a live region. Consider setting aria-atomic="true" if the full region should be announced as a unit, or aria-atomic="false" if only changed nodes should be read.`,
+      rationale: "aria-atomic controls whether assistive technology announces the entire live region or only the changed nodes. Omitting it leaves the behaviour browser-defined."
+    };
+  },
+  relevantInvalidTokens(invalid) {
+    const quoted = invalid.map((t) => `"${t}"`).join(", ");
+    return {
+      code: "ARIA2006" /* AriaRelevantInvalidToken */,
+      category: 2 /* ARIA */,
+      message: `aria-relevant contains invalid token(s): ${quoted}. Valid tokens are: additions, removals, text, all.`,
+      rationale: "aria-relevant accepts a space-separated list of change types. Unrecognised tokens are silently ignored by assistive technology, making the attribute ineffective.",
+      suggestions: [
+        {
+          title: "Use only valid tokens",
+          description: "Valid values are: additions, removals, text, all (or a space-separated combination)."
+        }
+      ]
+    };
+  },
+  relevantSuperseded() {
+    return {
+      code: "ARIA2007" /* AriaRelevantSuperseded */,
+      category: 2 /* ARIA */,
+      message: 'aria-relevant includes "all" alongside other tokens. "all" supersedes additions, removals, and text \u2014 use aria-relevant="all" alone.',
+      rationale: '"all" is equivalent to "additions removals text". Combining it with other tokens is redundant and may confuse readers of the markup.',
+      suggestions: [
+        {
+          title: 'Use aria-relevant="all"',
+          fix: 'aria-relevant="all"'
+        }
+      ]
+    };
+  },
+  missingAccessibleName(tag) {
+    return {
+      code: "ARIA2009" /* AriaMissingAccessibleName */,
+      category: 2 /* ARIA */,
+      message: `<${tag}> has no accessible name. Add aria-label or aria-labelledby.`,
+      rationale: "Elements with a landmark or interactive role must have an accessible name so that assistive technology can identify them when presenting the page outline.",
+      suggestions: [
+        {
+          title: "Add aria-label",
+          description: `Add aria-label="\u2026" directly to the <${tag}> element.`
+        },
+        {
+          title: "Add aria-labelledby",
+          description: "Point aria-labelledby at the id of an existing heading or label element."
+        }
+      ]
+    };
+  },
+  attributeOnPresentational(attr, tag) {
+    return {
+      code: "ARIA2010" /* AriaAttributeOnPresentational */,
+      category: 2 /* ARIA */,
+      message: `"${attr}" is not allowed on a presentational <${tag}>. Presentational elements are invisible to assistive technology.`,
+      rationale: 'role="none" and role="presentation" (including <img alt="">) remove an element from the accessibility tree. ARIA attributes on such elements are ignored by assistive technology.',
+      suggestions: [
+        {
+          title: "Remove the attribute",
+          description: `"${attr}" has no effect when the element has role="none" or role="presentation".`
+        }
+      ]
+    };
+  },
+  ariaHiddenOnFocusable(tag) {
+    return {
+      code: "ARIA2011" /* AriaHiddenOnFocusable */,
+      category: 2 /* ARIA */,
+      message: `aria-hidden="true" must not be used on focusable <${tag}> elements. Screen reader users who navigate by keyboard will encounter the element but receive no information about it.`,
+      rationale: 'aria-hidden removes an element from the accessibility tree while leaving it keyboard-reachable. This creates a "ghost" \u2014 a focusable element assistive technology cannot describe.',
+      suggestions: [
+        {
+          title: "Remove aria-hidden",
+          description: "If the element should be hidden from all users, use the HTML hidden attribute or CSS display:none instead."
+        },
+        {
+          title: "Make the element non-focusable",
+          description: 'If the element is intentionally decorative, add tabindex="-1" and disable it so it is not reachable by keyboard.'
+        }
+      ]
+    };
+  },
+  invalidAttributeValue(attr, value, expected) {
+    const got = value === null ? "null" : value === void 0 ? "undefined" : typeof value === "string" ? `"${value}"` : String(value);
+    return {
+      code: "ARIA2013" /* AriaInvalidAttributeValue */,
+      category: 2 /* ARIA */,
+      message: `"${attr}" has an invalid value (${got}). Expected: ${expected}.`,
+      rationale: "ARIA attributes with invalid values are silently ignored by assistive technology, making the markup semantically inert.",
+      suggestions: [
+        {
+          title: `Use a valid value for ${attr}`,
+          description: `Valid values are: ${expected}.`
+        }
+      ]
+    };
+  },
+  redundantAriaLevel(tag, level) {
+    return {
+      code: "ARIA2014" /* AriaRedundantLevelAttribute */,
+      category: 2 /* ARIA */,
+      message: `aria-level="${level}" is redundant on <${tag}>: the element already has an implicit heading level of ${level}. Remove the attribute.`,
+      rationale: 'Restating the implicit aria-level adds noise without semantic value. Use aria-level only to override the native heading level (e.g. aria-level="3" on <h2>).',
+      suggestions: [
+        {
+          title: "Remove aria-level",
+          description: `<${tag}> already implies aria-level="${level}".`
+        }
+      ]
+    };
+  },
+  requiredProperty(attr, role) {
+    return {
+      code: "ARIA2012" /* AriaRequiredProperty */,
+      category: 2 /* ARIA */,
+      message: `"${attr}" is required for role="${role}" but is missing.`,
+      rationale: `WAI-ARIA 1.2 specifies required states and properties for certain roles. Without "${attr}", assistive technology cannot correctly communicate the element's state to users.`,
+      suggestions: [
+        {
+          title: `Add ${attr}`,
+          description: `role="${role}" requires "${attr}" to be present.`
+        }
+      ]
+    };
+  },
+  invalidRole(role, tag) {
+    return {
+      code: "ARIA2008" /* AriaInvalidRole */,
+      category: 2 /* ARIA */,
+      message: `Invalid role "${role ?? ""}" on <${tag}>.`,
+      rationale: "An unrecognised or misapplied ARIA role is ignored by assistive technology and may degrade the accessibility of the element."
+    };
+  }
+};
+
+// ../../lib/contract/src/diagnostics/contract.ts
+var ContractDiagnostics = {
+  unexpectedChild(typeName, index, context) {
+    return {
+      code: "COMP1004" /* UnexpectedChild */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: unexpected child "${typeName}" at index ${index}.`
+    };
+  },
+  ambiguousChild(typeName, index, ruleNames, context) {
+    const quoted = ruleNames.map((n) => `"${n}"`).join(" and ");
+    return {
+      code: "COMP1005" /* AmbiguousChild */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: child "${typeName}" at index ${index} matches multiple child rules: ${quoted}.`
+    };
+  },
+  cardinalityMin(ruleName, min, context) {
+    return {
+      code: "COMP1006" /* CardinalityMin */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: "${ruleName}" requires at least ${min}.`
+    };
+  },
+  cardinalityMax(ruleName, max, context) {
+    return {
+      code: "COMP1007" /* CardinalityMax */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: "${ruleName}" allows at most ${max}.`
+    };
+  },
+  positionViolation(ruleName, position, index, context) {
+    return {
+      code: "COMP1008" /* PositionViolation */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: "${ruleName}" must be ${position}, got index ${index}`
+    };
+  },
+  unknownVariantDim(component, label, dim) {
+    return {
+      code: "COMP1010" /* ContractUnknownVariantDim */,
+      category: 0 /* Contract */,
+      message: `${component}: ${label} references unknown variant "${dim}".`
+    };
+  },
+  unknownVariantValue(component, label, dim, value, valid) {
+    return {
+      code: "COMP1011" /* ContractUnknownVariantValue */,
+      category: 0 /* Contract */,
+      message: `${component}: ${label} sets "${dim}" to unknown value "${value}" (valid: ${valid.join(", ")}).`
+    };
+  },
+  unknownRecipeKey(component, key) {
+    return {
+      code: "COMP1012" /* ContractUnknownRecipeKey */,
+      category: 0 /* Contract */,
+      message: `${component} Unknown recipeKey "${key}" \u2014 no preset with that name exists.`
+    };
+  },
+  invalidVariantValue(component, key, value) {
+    return {
+      code: "COMP1013" /* ContractInvalidVariantValue */,
+      category: 0 /* Contract */,
+      message: `${component} Variant "${key}=${value}" is not a defined value for the "${key}" dimension.`
+    };
+  },
+  allowedAsViolation(tag, allowedAs, component) {
+    const allowed = allowedAs.map((t) => `"${String(t)}"`).join(", ");
+    return {
+      code: "COMP1009" /* AllowedAsViolation */,
+      category: 0 /* Contract */,
+      component,
+      message: `<${component}>: "as" prop received "${tag}" but only [${allowed}] are allowed.`
+    };
+  }
+};
+
+// ../../lib/contract/src/diagnostics/html.ts
+var HtmlDiagnostics = {
+  emptyRole(tag) {
+    return {
+      code: "HTML3002" /* HtmlEmptyRole */,
+      category: 1 /* HTML */,
+      message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`
+    };
+  },
+  implicitRoleRedundant(tag, implicitRole) {
+    return {
+      code: "HTML3003" /* HtmlImplicitRoleRedundant */,
+      category: 1 /* HTML */,
+      message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
+    };
+  },
+  implicitRoleOverride(tag, implicitRole, role) {
+    return {
+      code: "HTML3004" /* HtmlImplicitRoleOverride */,
+      category: 1 /* HTML */,
+      message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
+    };
+  },
+  standaloneRegionOverride(tag, implicitRole) {
+    return {
+      code: "HTML3005" /* HtmlStandaloneRegionOverride */,
+      category: 1 /* HTML */,
+      message: `<${tag}> is a self-contained element with implicit role="${implicitRole}". Assigning role="region" has been removed.`
+    };
+  },
+  landmarkRoleOverride(tag, implicitRole, role) {
+    return {
+      code: "HTML3006" /* HtmlLandmarkRoleOverride */,
+      category: 1 /* HTML */,
+      message: `<${tag}> has a fixed landmark role="${implicitRole}". role="${role}" overrides it and confuses assistive technology. The override has been removed.`
+    };
+  },
+  invalidChild(child, parent, allowed) {
+    return {
+      code: "HTML3007" /* HtmlInvalidChild */,
+      category: 1 /* HTML */,
+      message: `<${child}> is not a valid direct child of <${parent}>. Allowed: ${allowed}.`
+    };
+  }
+};
+
+// ../../lib/contract/src/diagnostics/slot.ts
+var SlotDiagnostics = {
+  exclusive(name) {
+    return {
+      code: "SLOT1001" /* SlotExclusive */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: "as" and "asChild" are mutually exclusive`
+    };
+  },
+  singleChildRequired(name, elementTerm) {
+    return {
+      code: "SLOT1002" /* SlotSingleChild */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: asChild requires a ${elementTerm} child`
+    };
+  },
+  singleChildExceeded(name, elementTerm, count) {
+    return {
+      code: "SLOT1002" /* SlotSingleChild */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: asChild requires exactly one ${elementTerm} child, got ${count}`
+    };
+  },
+  discardedChildren(name, elementTerm, count) {
+    const suffix = count === 1 ? "" : "ren";
+    return {
+      code: "SLOT1003" /* SlotDiscardedChildren */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: asChild discarded ${count} non-element child${suffix} \u2014 only ${elementTerm}s are valid asChild children.`
+    };
+  },
+  renderFnRequired(name, received) {
+    return {
+      code: "SLOT1004" /* SlotRenderFn */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: asChild requires a render function as children, got ${received}`
+    };
+  }
+};
+
+// ../../lib/contract/src/aria/polymorphic-validator.ts
 var VALID = [{ valid: true }];
 function isIntrinsicTag(tag) {
   return isString(tag);
@@ -742,26 +1066,28 @@ function omitProp(obj, key) {
   const { [key]: _, ...rest } = obj;
   return rest;
 }
-var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
+var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
   #extraRules;
   #planCache = /* @__PURE__ */ new Map();
   static #MAX_CACHE = 100;
   // Memoized AriaFix objects keyed by attribute name — the ARIA attribute set is
   // finite so this Map is bounded and avoids recreating closures on every cache miss.
   static #removeAttributeFixCache = /* @__PURE__ */ new Map();
-  constructor(strict = "warn", options) {
-    super(strict);
+  constructor(diagnostics, options) {
+    super(diagnostics);
     this.#extraRules = options?.rules ?? [];
   }
   static #normalizeEmptyRole(tag, props) {
     if (props.role !== "") return { normalized: false };
+    const d = HtmlDiagnostics.emptyRole(tag);
     return {
       normalized: true,
       result: {
         props: omitProp(props, "role"),
         violations: [
           {
-            message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`,
+            message: d.message,
+            diagnostic: d,
             tag,
             role: "",
             attribute: void 0,
@@ -774,10 +1100,9 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
   }
   static #deriveContext(tag, props) {
     if (!isIntrinsicTag(tag)) return { proceed: false, result: { props, violations: [] } };
-    const implicitRole = getImplicitRole(tag);
-    const hasExplicitLiveRole = !implicitRole && _AriaPolicyEngine.#LIVE_REGION_ROLES.has(props.role ?? "");
-    if (!implicitRole && !hasExplicitLiveRole)
-      return { proceed: false, result: { props, violations: [] } };
+    const implicitRole = getImplicitRole(tag, props);
+    const hasRole2 = implicitRole != null || isString(props.role) && props.role.length > 0;
+    if (!hasRole2) return { proceed: false, result: { props, violations: [] } };
     const normalized = _AriaPolicyEngine.#normalizeEmptyRole(tag, props);
     if (normalized.normalized) return { proceed: false, result: normalized.result };
     const effectiveRole = props.role ?? implicitRole;
@@ -792,25 +1117,36 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
   static #runRules(rules, context) {
     const violations = [];
     const fixes = [];
-    for (const rule of rules) {
-      for (const result of rule(context)) {
-        if (!result.valid) {
-          violations.push({
-            message: result.message ?? `Invalid role "${context.props.role}" on <${context.tag}>`,
-            tag: context.tag,
-            role: context.props.role,
-            attribute: result.attribute,
-            severity: result.severity,
-            phase: "evaluate"
-          });
-          if (result.fixable) fixes.push(result.fix);
-        }
-      }
-    }
+    iterate.forEach(rules, (rule) => {
+      iterate.forEach(rule(context), (result) => {
+        if (result.valid) return;
+        const {
+          tag,
+          props: { role }
+        } = context;
+        const { message, attribute, severity } = result;
+        const resolvedMessage = message ?? result.diagnostic?.message;
+        const fallbackDiag = resolvedMessage == null ? AriaDiagnostics.invalidRole(role, tag) : void 0;
+        violations.push({
+          message: resolvedMessage ?? fallbackDiag.message,
+          tag,
+          role,
+          attribute,
+          severity,
+          phase: "evaluate",
+          ...result.diagnostic != null && { diagnostic: result.diagnostic },
+          ...fallbackDiag != null && { diagnostic: fallbackDiag }
+        });
+        if (result.fixable) fixes.push(result.fix);
+      });
+    });
     return { violations, fixes };
   }
   static #getRules(context) {
-    return _AriaPolicyEngine.#hasRole(context.props) ? _AriaPolicyEngine.#pipeline : [_AriaPolicyEngine.#checkInvalidAriaAttributes];
+    if (_AriaPolicyEngine.#hasRole(context.props) || context.effectiveRole != null && _AriaPolicyEngine.#LIVE_REGION_ROLES.has(context.effectiveRole)) {
+      return _AriaPolicyEngine.#pipeline;
+    }
+    return _AriaPolicyEngine.#implicitOnlyRules;
   }
   static evaluate(tag, props) {
     const derived = _AriaPolicyEngine.#deriveContext(tag, props);
@@ -835,10 +1171,11 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
     return { props: next, violations };
   }
   report(violations) {
-    for (const v of violations) {
-      if (v.severity === "error") this.violate(v.message);
-      else this.warn(v.message);
-    }
+    iterate.forEach(violations, (v) => {
+      const d = v.diagnostic ?? AriaDiagnostics.fromViolation(v);
+      if (v.severity === "error") this.violate(d);
+      else this.warn(d);
+    });
   }
   // Cache key covers only the aria-relevant subset of props (tag + role + aria-* attrs).
   // Non-aria props (className, onClick, etc.) do not affect ARIA decisions and are excluded
@@ -850,27 +1187,26 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
     if (!isIntrinsicTag(tag)) return null;
     const parts = [tag];
     if (typeof props.role === "string") parts.push(`role:${props.role}`);
+    if (tag === "input" && typeof props.type === "string") parts.push(`type:${props.type}`);
+    if (tag === "img") parts.push(`alt:${props.alt === "" ? "empty" : "present"}`);
     const ariaEntries = [];
-    for (const k in props) {
-      if (!Object.hasOwn(props, k) || !k.startsWith("aria-")) continue;
-      const v = props[k];
-      if (!isString(v) && !isNumber(v) && typeof v !== "boolean") continue;
+    iterate.forEachEntry(props, (k, v) => {
+      if (!k.startsWith("aria-")) return;
+      if (!isString(v) && !isNumber(v) && typeof v !== "boolean") return;
       ariaEntries.push(`${k}:${String(v)}`);
-    }
+    });
     if (ariaEntries.length > 0) parts.push(...ariaEntries.sort());
     return parts.join("|");
   }
   static #computePlan(inputProps, resultProps) {
     const removals = /* @__PURE__ */ new Set();
     const updates = {};
-    for (const key in inputProps) {
-      if (Object.hasOwn(inputProps, key) && !(key in resultProps)) removals.add(key);
-    }
-    for (const key in resultProps) {
-      if (!Object.hasOwn(resultProps, key)) continue;
-      const resultVal = resultProps[key];
+    iterate.forEachKey(inputProps, (key) => {
+      if (!(key in resultProps)) removals.add(key);
+    });
+    iterate.forEachEntry(resultProps, (key, resultVal) => {
       if (inputProps[key] !== resultVal) updates[key] = resultVal;
-    }
+    });
     return { removals, updates };
   }
   static #applyPlan(props, removals, updates) {
@@ -878,15 +1214,15 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
     const hasUpdates = Object.keys(updates).length > 0;
     if (!hasRemovals && !hasUpdates) return props;
     const next = {};
-    for (const k in props) {
-      if (Object.hasOwn(props, k) && !removals.has(k)) next[k] = props[k];
-    }
+    iterate.forEachEntry(props, (k, v) => {
+      if (!removals.has(k)) next[k] = v;
+    });
     Object.assign(next, updates);
     return next;
   }
   validate(tag, props) {
     const key = _AriaPolicyEngine.#createPlanKey(tag, props);
-    if (!isNull3(key)) {
+    if (!isNull(key)) {
       const cached = this.#planCache.get(key);
       if (cached !== void 0) {
         this.#planCache.delete(key);
@@ -900,7 +1236,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
     }
     const result = this.#extraRules.length ? _AriaPolicyEngine.#evaluateWithRules(tag, props, this.#extraRules) : _AriaPolicyEngine.evaluate(tag, props);
     if (result.violations.length > 0) this.report(result.violations);
-    if (!isNull3(key)) {
+    if (!isNull(key)) {
       const { removals, updates } = _AriaPolicyEngine.#computePlan(
         props,
         result.props
@@ -921,12 +1257,12 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
     if (fixes.length === 0) return props;
     const sorted = [...fixes].sort((a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity));
     let next = props;
-    for (const { apply } of sorted) {
+    iterate.forEach(sorted, ({ apply }) => {
       const effectiveRole = next.role ?? implicitRole;
       const fixContext = { tag, implicitRole, effectiveRole, props: next };
       const fixResult = apply(fixContext);
       if (fixResult.applied) next = fixResult.next;
-    }
+    });
     return next;
   }
   static #removeRole = {
@@ -954,10 +1290,26 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
     _AriaPolicyEngine.#checkInvalidRoleOverride,
     _AriaPolicyEngine.#checkRedundantRole,
     _AriaPolicyEngine.#checkStandaloneRegion,
+    _AriaPolicyEngine.#checkAriaAttributeValues,
     _AriaPolicyEngine.#checkInvalidAriaAttributes,
+    _AriaPolicyEngine.#checkRequiredAriaProperties,
+    _AriaPolicyEngine.#checkNameRequiredRoles,
+    _AriaPolicyEngine.#checkRedundantAriaLevel,
     _AriaPolicyEngine.#checkMissingLiveRegion,
     _AriaPolicyEngine.#checkMissingAtomic,
-    _AriaPolicyEngine.#checkInvalidAriaRelevant
+    _AriaPolicyEngine.#checkInvalidAriaRelevant,
+    _AriaPolicyEngine.#checkAriaHiddenOnFocusable,
+    _AriaPolicyEngine.#checkPresentationalAriaAttributes
+  ];
+  // Rules for elements with an implicit role but no explicit role (not a live region).
+  static #implicitOnlyRules = [
+    _AriaPolicyEngine.#checkAriaAttributeValues,
+    _AriaPolicyEngine.#checkInvalidAriaAttributes,
+    _AriaPolicyEngine.#checkRequiredAriaProperties,
+    _AriaPolicyEngine.#checkNameRequiredRoles,
+    _AriaPolicyEngine.#checkRedundantAriaLevel,
+    _AriaPolicyEngine.#checkAriaHiddenOnFocusable,
+    _AriaPolicyEngine.#checkPresentationalAriaAttributes
   ];
   static #checkInvalidRoleOverride({
     tag,
@@ -973,7 +1325,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
           fixable: true,
           severity: "error",
           fix: _AriaPolicyEngine.#removeRole,
-          message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
+          diagnostic: HtmlDiagnostics.implicitRoleOverride(tag, implicitRole, role)
         }
       ];
     }
@@ -985,47 +1337,304 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
     return [
       {
         valid: false,
-        fixable: true,
+        fixable: true,
+        severity: "warning",
+        fix: _AriaPolicyEngine.#removeRole,
+        diagnostic: HtmlDiagnostics.implicitRoleRedundant(tag, implicitRole)
+      }
+    ];
+  }
+  static #checkStandaloneRegion({ tag, props, implicitRole }) {
+    const role = props.role;
+    if (role !== "region") return VALID;
+    if (!isStandaloneTag(tag)) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: "error",
+        fix: _AriaPolicyEngine.#removeRole,
+        diagnostic: HtmlDiagnostics.standaloneRegionOverride(tag, implicitRole ?? tag)
+      }
+    ];
+  }
+  static #checkInvalidAriaAttributes({
+    tag,
+    props,
+    effectiveRole
+  }) {
+    if (effectiveRole === "none" || effectiveRole === "presentation") return VALID;
+    const results = [];
+    iterate.forEachEntry(props, (key) => {
+      if (!key.startsWith("aria-")) return;
+      if (isGlobalAriaAttribute(key)) return;
+      if (isAriaAttributeValidForRole(key, effectiveRole)) return;
+      results.push({
+        valid: false,
+        severity: "warning",
+        fixable: true,
+        attribute: key,
+        diagnostic: AriaDiagnostics.attributeInvalid(key, effectiveRole ?? tag),
+        fix: _AriaPolicyEngine.#makeRemoveAttributeFix(key)
+      });
+    });
+    return results;
+  }
+  // ─── ARIA attribute value validation ──────────────────────────────────────
+  // Accepted value shapes for typed ARIA attributes.
+  // Attributes not in this map are unconstrained (arbitrary string values permitted).
+  static #ARIA_VALUE_TYPES = /* @__PURE__ */ new Map([
+    // Boolean (true | false)
+    ["aria-atomic", { kind: "boolean" }],
+    ["aria-busy", { kind: "boolean" }],
+    ["aria-disabled", { kind: "boolean" }],
+    ["aria-expanded", { kind: "boolean" }],
+    ["aria-hidden", { kind: "boolean" }],
+    ["aria-modal", { kind: "boolean" }],
+    ["aria-multiline", { kind: "boolean" }],
+    ["aria-multiselectable", { kind: "boolean" }],
+    ["aria-readonly", { kind: "boolean" }],
+    ["aria-required", { kind: "boolean" }],
+    ["aria-selected", { kind: "boolean" }],
+    // Tristate (true | false | mixed)
+    ["aria-checked", { kind: "tristate" }],
+    ["aria-pressed", { kind: "tristate" }],
+    // Numeric (any finite number)
+    ["aria-valuenow", { kind: "number" }],
+    ["aria-valuemin", { kind: "number" }],
+    ["aria-valuemax", { kind: "number" }],
+    // Integer with optional range
+    ["aria-level", { kind: "integer", min: 1, max: 6 }],
+    ["aria-posinset", { kind: "integer", min: 1 }],
+    ["aria-setsize", { kind: "integer", min: -1 }],
+    ["aria-rowcount", { kind: "integer", min: -1 }],
+    ["aria-colcount", { kind: "integer", min: -1 }],
+    ["aria-rowindex", { kind: "integer", min: 1 }],
+    ["aria-colindex", { kind: "integer", min: 1 }],
+    ["aria-rowspan", { kind: "integer", min: 0 }],
+    ["aria-colspan", { kind: "integer", min: 0 }],
+    // Enum (specific allowed tokens)
+    ["aria-autocomplete", { kind: "enum", values: /* @__PURE__ */ new Set(["inline", "list", "both", "none"]) }],
+    [
+      "aria-current",
+      {
+        kind: "enum",
+        values: /* @__PURE__ */ new Set(["page", "step", "location", "date", "time", "true", "false"])
+      }
+    ],
+    [
+      "aria-haspopup",
+      {
+        kind: "enum",
+        values: /* @__PURE__ */ new Set(["false", "true", "menu", "listbox", "tree", "grid", "dialog"])
+      }
+    ],
+    ["aria-invalid", { kind: "enum", values: /* @__PURE__ */ new Set(["grammar", "false", "spelling", "true"]) }],
+    ["aria-live", { kind: "enum", values: /* @__PURE__ */ new Set(["assertive", "off", "polite"]) }],
+    [
+      "aria-orientation",
+      { kind: "enum", values: /* @__PURE__ */ new Set(["horizontal", "vertical", "undefined"]) }
+    ],
+    ["aria-sort", { kind: "enum", values: /* @__PURE__ */ new Set(["ascending", "descending", "none", "other"]) }]
+  ]);
+  static #isValidAriaValue(value, type) {
+    switch (type.kind) {
+      case "boolean":
+        return value === "true" || value === "false" || value === true || value === false;
+      case "tristate":
+        return value === "true" || value === "false" || value === "mixed" || value === true || value === false;
+      case "number": {
+        if (typeof value === "number") return Number.isFinite(value);
+        if (typeof value !== "string") return false;
+        const n = parseFloat(value);
+        return Number.isFinite(n);
+      }
+      case "integer": {
+        const n = typeof value === "number" ? value : typeof value === "string" ? parseInt(value, 10) : NaN;
+        if (!Number.isFinite(n) || !Number.isInteger(n)) return false;
+        if (type.min !== void 0 && n < type.min) return false;
+        if (type.max !== void 0 && n > type.max) return false;
+        return true;
+      }
+      case "enum":
+        return typeof value === "string" && type.values.has(value);
+    }
+  }
+  static #describeExpected(type) {
+    switch (type.kind) {
+      case "boolean":
+        return '"true" or "false"';
+      case "tristate":
+        return '"true", "false", or "mixed"';
+      case "number":
+        return "a finite number";
+      case "integer": {
+        const parts = ["an integer"];
+        if (type.min !== void 0 && type.max !== void 0)
+          parts.push(`between ${type.min} and ${type.max}`);
+        else if (type.min !== void 0) parts.push(`\u2265 ${type.min}`);
+        else if (type.max !== void 0) parts.push(`\u2264 ${type.max}`);
+        return parts.join(" ");
+      }
+      case "enum":
+        return [...type.values].map((v) => `"${v}"`).join(", ");
+    }
+  }
+  static #checkAriaAttributeValues({ props, effectiveRole }) {
+    if (effectiveRole === "none" || effectiveRole === "presentation") return VALID;
+    const results = [];
+    iterate.forEachEntry(props, (key, value) => {
+      if (!key.startsWith("aria-")) return;
+      const type = _AriaPolicyEngine.#ARIA_VALUE_TYPES.get(key);
+      if (type == null) return;
+      if (_AriaPolicyEngine.#isValidAriaValue(value, type)) return;
+      results.push({
+        valid: false,
+        fixable: true,
+        severity: "warning",
+        attribute: key,
+        diagnostic: AriaDiagnostics.invalidAttributeValue(
+          key,
+          value,
+          _AriaPolicyEngine.#describeExpected(type)
+        ),
+        fix: _AriaPolicyEngine.#makeRemoveAttributeFix(key)
+      });
+    });
+    return results;
+  }
+  // ─── Heading implicit level ────────────────────────────────────────────────
+  static #HEADING_IMPLICIT_LEVELS = /* @__PURE__ */ new Map([
+    ["h1", 1],
+    ["h2", 2],
+    ["h3", 3],
+    ["h4", 4],
+    ["h5", 5],
+    ["h6", 6]
+  ]);
+  static #checkRedundantAriaLevel({
+    tag,
+    props,
+    effectiveRole
+  }) {
+    if (effectiveRole === "none" || effectiveRole === "presentation") return VALID;
+    const implicitLevel = _AriaPolicyEngine.#HEADING_IMPLICIT_LEVELS.get(tag);
+    if (implicitLevel == null) return VALID;
+    const raw = props["aria-level"];
+    if (raw == null) return VALID;
+    const n = typeof raw === "number" ? raw : typeof raw === "string" ? parseInt(raw, 10) : NaN;
+    if (!Number.isFinite(n) || n !== implicitLevel) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: "warning",
+        attribute: "aria-level",
+        diagnostic: AriaDiagnostics.redundantAriaLevel(tag, implicitLevel),
+        fix: _AriaPolicyEngine.#makeRemoveAttributeFix("aria-level")
+      }
+    ];
+  }
+  // ─── Name-required roles ───────────────────────────────────────────────────
+  // Roles that always require an accessible name per WAI-ARIA APG.
+  // Dialog and landmark names are enforced via contracts (ariaContract) rather than
+  // the built-in pipeline so consumers can opt in; img is built in because role=img
+  // on any element (including bare <img>) is definitionally useless without a name.
+  static #NAME_REQUIRED_ROLES = /* @__PURE__ */ new Set(["img"]);
+  static #checkNameRequiredRoles({
+    tag,
+    props,
+    effectiveRole
+  }) {
+    if (!effectiveRole || !_AriaPolicyEngine.#NAME_REQUIRED_ROLES.has(effectiveRole)) return VALID;
+    if ("aria-label" in props || "aria-labelledby" in props) return VALID;
+    if (tag === "img" && typeof props.alt === "string" && props.alt.length > 0) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: false,
+        severity: "warning",
+        diagnostic: AriaDiagnostics.missingAccessibleName(tag)
+      }
+    ];
+  }
+  // WAI-ARIA 1.2 required states and properties, keyed by role.
+  // Source: https://www.w3.org/TR/wai-aria-1.2/#requiredState
+  static #REQUIRED_PROPERTIES = /* @__PURE__ */ new Map([
+    ["combobox", ["aria-expanded"]],
+    ["option", ["aria-selected"]],
+    ["slider", ["aria-valuenow"]],
+    ["scrollbar", ["aria-controls", "aria-valuenow"]],
+    ["spinbutton", ["aria-valuenow"]]
+  ]);
+  static #checkRequiredAriaProperties({
+    props,
+    effectiveRole
+  }) {
+    if (!effectiveRole) return VALID;
+    const required = _AriaPolicyEngine.#REQUIRED_PROPERTIES.get(effectiveRole);
+    if (required == null) return VALID;
+    const results = [];
+    iterate.forEach(required, (attr) => {
+      if (attr in props) return;
+      results.push({
+        valid: false,
+        fixable: false,
         severity: "warning",
-        fix: _AriaPolicyEngine.#removeRole,
-        message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
-      }
-    ];
+        attribute: attr,
+        diagnostic: AriaDiagnostics.requiredProperty(attr, effectiveRole)
+      });
+    });
+    return results;
   }
-  static #checkStandaloneRegion({ tag, props, implicitRole }) {
-    const role = props.role;
-    if (role !== "region") return VALID;
-    if (!isStandaloneTag(tag)) return VALID;
+  // Natively interactive HTML elements — always keyboard-reachable unless explicitly disabled.
+  static #INTERACTIVE_TAGS = /* @__PURE__ */ new Set([
+    "a",
+    "button",
+    "input",
+    "select",
+    "textarea"
+  ]);
+  // WAI-ARIA 1.2 §6.6: aria-hidden="true" must not be placed on focusable elements.
+  static #checkAriaHiddenOnFocusable({ tag, props }) {
+    if (props["aria-hidden"] !== "true" && props["aria-hidden"] !== true) return VALID;
+    const isInteractive = _AriaPolicyEngine.#INTERACTIVE_TAGS.has(tag);
+    if (!isInteractive) {
+      const tabindex = props.tabindex;
+      const n = typeof tabindex === "number" ? tabindex : typeof tabindex === "string" ? parseInt(tabindex, 10) : NaN;
+      if (!Number.isFinite(n) || n < 0) return VALID;
+    }
     return [
       {
         valid: false,
-        fixable: true,
+        fixable: false,
         severity: "error",
-        fix: _AriaPolicyEngine.#removeRole,
-        message: `<${tag}> is a self-contained element with implicit role="${implicitRole}". Assigning role="region" has been removed.`
+        attribute: "aria-hidden",
+        diagnostic: AriaDiagnostics.ariaHiddenOnFocusable(tag)
       }
     ];
   }
-  static #checkInvalidAriaAttributes({
+  // Presentational elements (role=none/presentation, including <img alt="">) are removed
+  // from the accessibility tree — ARIA attributes on them are meaningless and misleading.
+  static #checkPresentationalAriaAttributes({
     tag,
     props,
     effectiveRole
   }) {
+    if (effectiveRole !== "none" && effectiveRole !== "presentation") return VALID;
     const results = [];
-    for (const key in props) {
-      if (!Object.hasOwn(props, key)) continue;
-      if (!key.startsWith("aria-")) continue;
-      if (isGlobalAriaAttribute(key)) continue;
-      if (isAriaAttributeValidForRole(key, effectiveRole)) continue;
+    iterate.forEachEntry(props, (key) => {
+      if (!key.startsWith("aria-")) return;
+      if (key === "aria-hidden") return;
       results.push({
         valid: false,
-        severity: "warning",
         fixable: true,
+        severity: "warning",
         attribute: key,
-        message: `"${key}" is not valid on role="${effectiveRole ?? tag}". It will be removed.`,
+        diagnostic: AriaDiagnostics.attributeOnPresentational(key, tag),
         fix: _AriaPolicyEngine.#makeRemoveAttributeFix(key)
       });
-    }
+    });
     return results;
   }
   // WAI-ARIA live region roles and their implied aria-live politeness values.
@@ -1054,7 +1663,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
         fixable: true,
         severity: "warning",
         fix: injectLive,
-        message: `role="${effectiveRole}" implies aria-live="${impliedLive}" but it is missing. It has been injected.`
+        diagnostic: AriaDiagnostics.missingLiveRegion(effectiveRole, impliedLive)
       }
     ];
   }
@@ -1066,7 +1675,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
         valid: false,
         fixable: false,
         severity: "warning",
-        message: `role="${effectiveRole}" is a live region. Consider setting aria-atomic="true" if the full region should be announced as a unit, or aria-atomic="false" if only changed nodes should be read.`
+        diagnostic: AriaDiagnostics.missingAtomic(effectiveRole)
       }
     ];
   }
@@ -1095,7 +1704,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
           fixable: true,
           severity: "warning",
           attribute: "aria-relevant",
-          message: `aria-relevant contains invalid token(s): ${invalid.map((t) => `"${t}"`).join(", ")}. Valid tokens are: additions, removals, text, all.`,
+          diagnostic: AriaDiagnostics.relevantInvalidTokens(invalid),
           fix: _AriaPolicyEngine.#makeRemoveAttributeFix("aria-relevant")
         }
       ];
@@ -1107,7 +1716,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
           fixable: true,
           severity: "warning",
           attribute: "aria-relevant",
-          message: `aria-relevant includes "all" alongside other tokens. "all" supersedes additions, removals, and text \u2014 use aria-relevant="all" alone.`,
+          diagnostic: AriaDiagnostics.relevantSuperseded(),
           fix: _AriaPolicyEngine.#normalizeRelevantAllFix
         }
       ];
@@ -1115,6 +1724,8 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
     return VALID;
   }
 };
+
+// ../../lib/contract/src/children/get-type-name.ts
 function getTypeName(value) {
   if (value === null) return "null";
   if (value === void 0) return "undefined";
@@ -1125,39 +1736,8 @@ function getTypeName(value) {
   const name = value.constructor?.name;
   return typeof name === "string" && name !== "Object" ? name : "object";
 }
-var MatchValidationErrorBuilder = class {
-  #prefix;
-  constructor(ctx = "") {
-    this.#prefix = ctx ? `${ctx}:
-` : "";
-  }
-  #template(typeName, index, prefix = "", suffix = "") {
-    const leadingStr = prefix ? `${prefix} ` : "";
-    const followingStr = suffix ? ` ${suffix}` : "";
-    return `${leadingStr}child "${typeName}" at index ${index}${followingStr}.`;
-  }
-  unexpectedChild(typeName, index) {
-    return this.#template(typeName, index, "unexpected");
-  }
-  multipleMatches(typeName, index, ruleNames) {
-    const quoted = ruleNames.map((n) => `"${n}"`);
-    return this.#template(
-      typeName,
-      index,
-      "",
-      `matches multiple child rules: ${quoted.join(" and ")}`
-    );
-  }
-  #format(errors) {
-    return this.#prefix + errors.join("\n");
-  }
-  toError(errors) {
-    if (errors.length === 0) {
-      return new Error(this.#prefix + "Unknown validation error.");
-    }
-    return new Error(this.#format(errors));
-  }
-};
+
+// ../../lib/contract/src/children/normalize-child-rule.ts
 function normalizeCardinality(input, impliesSingleton) {
   const min = input?.min ?? 0;
   const max = input?.max ?? (impliesSingleton ? 1 : Infinity);
@@ -1182,16 +1762,18 @@ function normalizeChildRule(rule) {
     cardinality: normalizeCardinality(rule.cardinality, impliesSingleton)
   };
 }
+
+// ../../lib/contract/src/children/rules-matcher.ts
 function getChildType(child) {
-  if (!isObject2(child) || !("type" in child)) return void 0;
+  if (!isObject(child) || !("type" in child)) return void 0;
   return child.type;
 }
 function buildPartialIndex(rules) {
   const typeIndex = /* @__PURE__ */ new Map();
   const duplicateTypes = /* @__PURE__ */ new Set();
   const untypedIndices = [];
-  for (let ri = 0; ri < rules.length; ri++) {
-    const t = rules[ri].type;
+  iterate.forEach(rules, (rule, ri) => {
+    const t = rule.type;
     if (t === void 0) {
       untypedIndices.push(ri);
     } else if (typeIndex.has(t)) {
@@ -1199,12 +1781,14 @@ function buildPartialIndex(rules) {
     } else {
       typeIndex.set(t, ri);
     }
-  }
+  });
   if (duplicateTypes.size > 0) {
-    for (const t of duplicateTypes) typeIndex.delete(t);
-    for (let ri = 0; ri < rules.length; ri++) {
-      if (duplicateTypes.has(rules[ri].type)) untypedIndices.push(ri);
-    }
+    iterate.forEachSet(duplicateTypes, (t) => {
+      typeIndex.delete(t);
+    });
+    iterate.forEach(rules, (rule, ri) => {
+      if (duplicateTypes.has(rule.type)) untypedIndices.push(ri);
+    });
   }
   return { typeIndex, untypedIndices };
 }
@@ -1223,10 +1807,10 @@ var RuleMatcher = class {
     const reverse = /* @__PURE__ */ new Map();
     const unexpectedIndices = /* @__PURE__ */ new Set();
     const ambiguousIndices = /* @__PURE__ */ new Set();
-    for (let ri = 0; ri < this.#rules.length; ri++) {
+    iterate.forEach(this.#rules, (_, ri) => {
       reverse.set(ri, /* @__PURE__ */ new Set());
-    }
-    for (const [ci, child] of children.entries()) {
+    });
+    iterate.forEach(children, (child, ci) => {
       const t = getChildType(child);
       if (t !== void 0) {
         const ri = this.#typeIndex.get(t);
@@ -1240,8 +1824,8 @@ var RuleMatcher = class {
           reverse.get(ri).add(ci);
         }
       }
-      for (const ri of this.#untypedIndices) {
-        if (!this.#rules[ri].match(child)) continue;
+      iterate.forEach(this.#untypedIndices, (ri) => {
+        if (!this.#rules[ri].match(child)) return;
         let childEntry = forward.get(ci);
         if (!childEntry) {
           childEntry = /* @__PURE__ */ new Set();
@@ -1249,33 +1833,35 @@ var RuleMatcher = class {
         }
         childEntry.add(ri);
         reverse.get(ri).add(ci);
-      }
+      });
       const entry = forward.get(ci);
       if (!entry) {
         unexpectedIndices.add(ci);
       } else if (entry.size > 1) {
         ambiguousIndices.add(ci);
       }
-    }
+    });
     return { matrix: { childToRules: { forward, reverse } }, unexpectedIndices, ambiguousIndices };
   }
 };
-var RuleValidator = class _RuleValidator extends StrictBase {
+
+// ../../lib/contract/src/children/rule-validator.ts
+var RuleValidator = class _RuleValidator extends InvariantBase {
   #context;
-  constructor(context, strict) {
-    super(strict);
+  constructor(context, diagnostics) {
+    super(diagnostics);
     this.#context = context;
   }
   validate(rules, matrix, childCount) {
     const firstIndex = 0;
     const lastIndex = childCount - 1;
-    for (const [ri, rule] of rules.entries()) {
+    iterate.forEach(rules, (rule, ri) => {
       const matches = matrix.childToRules.reverse.get(ri);
       const matchCount = matches.size;
       this.#validateCardinality(rule, matchCount);
-      if (matchCount === 0) continue;
+      if (matchCount === 0) return;
       this.#validatePositions(rule, matches, firstIndex, lastIndex);
-    }
+    });
   }
   #validateCardinality(rule, matchCount) {
     const { cardinality, name } = rule;
@@ -1284,21 +1870,21 @@ var RuleValidator = class _RuleValidator extends StrictBase {
     }
     const { min, max } = cardinality;
     if (matchCount < min) {
-      this.violate(`${this.#context}: "${name}" requires at least ${min}.`);
+      this.violate(ContractDiagnostics.cardinalityMin(name, min, this.#context));
       return;
     }
     if (matchCount > max) {
-      this.violate(`${this.#context}: "${name}" allows at most ${max}.`);
+      this.violate(ContractDiagnostics.cardinalityMax(name, max, this.#context));
     }
   }
   #validatePositions(rule, matches, firstIndex, lastIndex) {
     const { name, position } = rule;
-    for (const index of matches) {
+    iterate.forEachSet(matches, (index) => {
       if (_RuleValidator.#isValidPosition(index, position, firstIndex, lastIndex)) {
-        continue;
+        return;
       }
-      this.violate(`${this.#context}: "${name}" must be ${position}, got index ${index}`);
-    }
+      this.violate(ContractDiagnostics.positionViolation(name, position, index, this.#context));
+    });
   }
   static #isValidPosition(matchIndex, position, firstIndex, lastIndex) {
     switch (position) {
@@ -1313,48 +1899,50 @@ var RuleValidator = class _RuleValidator extends StrictBase {
     }
   }
 };
-var ChildrenEvaluator = class extends StrictBase {
+
+// ../../lib/contract/src/children/children-evaluator.ts
+var ChildrenEvaluator = class extends InvariantBase {
+  #context;
   #rules;
   #ruleNames;
   #matcher;
   #ruleValidator;
-  #matchBuilder;
-  constructor(rules, strict = "warn", context = "Component") {
-    super(strict);
-    this.#rules = rules.map((r2) => normalizeChildRule(r2));
-    this.#ruleNames = this.#rules.map((r2) => r2.name);
-    for (const rule of this.#rules) {
+  constructor(rules, diagnostics, context = "Component") {
+    super(diagnostics);
+    this.#context = context;
+    this.#rules = rules.map((r) => normalizeChildRule(r));
+    this.#ruleNames = this.#rules.map((r) => r.name);
+    iterate.forEach(this.#rules, (rule) => {
       const { name, position, cardinality } = rule;
       if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
         throw new RangeError(
           `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
         );
       }
-    }
+    });
     this.#matcher = new RuleMatcher(this.#rules);
-    this.#ruleValidator = new RuleValidator(context, strict);
-    this.#matchBuilder = new MatchValidationErrorBuilder(context);
+    this.#ruleValidator = new RuleValidator(context, diagnostics);
   }
   evaluate(children) {
-    if (!this.strict) return;
+    if (!this.active) return;
     const { matrix, unexpectedIndices, ambiguousIndices } = this.#matcher.match(children);
     this.#ruleValidator.validate(this.#rules, matrix, children.length);
     if (unexpectedIndices.size === 0 && ambiguousIndices.size === 0) return;
-    const errors = [];
     const violating = [...unexpectedIndices, ...ambiguousIndices].sort((a, b) => a - b);
-    for (const ci of violating) {
+    iterate.forEach(violating, (ci) => {
       const typeName = getTypeName(children[ci]);
       if (unexpectedIndices.has(ci)) {
-        errors.push(this.#matchBuilder.unexpectedChild(typeName, ci));
+        this.violate(ContractDiagnostics.unexpectedChild(typeName, ci, this.#context));
       } else {
         const matches = matrix.childToRules.forward.get(ci);
         const names = [...matches].map((ri) => this.#ruleNames[ri] ?? `#${ri}`);
-        errors.push(this.#matchBuilder.multipleMatches(typeName, ci, names));
+        this.violate(ContractDiagnostics.ambiguousChild(typeName, ci, names, this.#context));
       }
-    }
-    this.invariant(errors.length === 0, this.#matchBuilder.toError(errors).message);
+    });
   }
 };
+
+// ../../lib/contract/src/props/get-disabled-props.ts
 var disabledProps = ({
   disabled,
   "aria-disabled": ariaDisabled,
@@ -1366,6 +1954,8 @@ var disabledProps = ({
     ...dataDisabled === void 0 && { "data-disabled": "" }
   };
 };
+
+// ../../lib/contract/src/props/get-invalid-props.ts
 var invalidProps = ({
   invalid,
   "aria-invalid": ariaInvalid,
@@ -1377,6 +1967,8 @@ var invalidProps = ({
     ...dataInvalid === void 0 && { "data-invalid": "" }
   };
 };
+
+// ../../lib/contract/src/props/get-readonly-props.ts
 var readonlyProps = ({
   readOnly,
   "aria-readonly": ariaReadonly,
@@ -1392,6 +1984,8 @@ var readonlyProps = ({
     }
   };
 };
+
+// ../core/src/html/aria-rules.ts
 var LANDMARK_TAG_SET = /* @__PURE__ */ new Set(["article", "aside", "footer", "header", "main", "nav"]);
 var removeLandmarkRoleOverride = {
   kind: "removeRole",
@@ -1411,14 +2005,31 @@ function landmarkRoleRule({ tag, props, implicitRole }) {
       fixable: true,
       severity: "error",
       fix: removeLandmarkRoleOverride,
-      message: `<${tag}> has a fixed landmark role="${implicitRole}". role="${role}" overrides it and confuses assistive technology. The override has been removed.`
+      diagnostic: HtmlDiagnostics.landmarkRoleOverride(tag, implicitRole, role)
     }
   ];
 }
-var HTML_ARIA_RULES = [landmarkRoleRule];
+function requireAccessibleName({ tag, props }) {
+  if ("aria-label" in props || "aria-labelledby" in props) return [];
+  return [
+    {
+      valid: false,
+      fixable: false,
+      severity: "warning",
+      diagnostic: AriaDiagnostics.missingAccessibleName(tag)
+    }
+  ];
+}
+var NAMED_LANDMARK_TAGS = /* @__PURE__ */ new Set(["nav", "aside"]);
+function landmarkNameAdvisory(ctx) {
+  if (!ctx.implicitRole || !NAMED_LANDMARK_TAGS.has(ctx.tag)) return [];
+  return requireAccessibleName(ctx);
+}
+
+// ../core/src/html/contracts.ts
 function isOpenContent(...blockedTags) {
-  const set = new Set(blockedTags);
-  return (child) => isObject2(child) && "type" in child && (!isString(child.type) || !set.has(child.type));
+  const set2 = new Set(blockedTags);
+  return (child) => isObject(child) && "type" in child && (!isString(child.type) || !set2.has(child.type));
 }
 var METADATA_TAGS = ["script", "template"];
 var metadataMatch = isTag(...METADATA_TAGS);
@@ -1429,10 +2040,10 @@ function firstOptional(name, tag) {
   return { name, match: isTag(tag), cardinality: { max: 1 }, position: "first" };
 }
 function contract(children) {
-  return { strict: "warn", children };
+  return { diagnostics: warnDiagnostics, children };
 }
 function ariaContract(aria) {
-  return { strict: "warn", aria };
+  return { diagnostics: warnDiagnostics, aria };
 }
 function firstChildContract(name, tag) {
   return contract([firstOptional(name, tag), { name: "content", match: isOpenContent(tag) }]);
@@ -1519,7 +2130,15 @@ var textOnlyContract = contract([
     match: (child) => isString(child) || isNumber(child)
   }
 ]);
-var landmarkContract = ariaContract([landmarkRoleRule]);
+var landmarkContract = ariaContract([landmarkRoleRule, landmarkNameAdvisory]);
+var dialogContract = ariaContract([requireAccessibleName]);
+var menuContract = ariaContract([requireAccessibleName]);
+var menubarContract = ariaContract([requireAccessibleName]);
+var treeContract = ariaContract([requireAccessibleName]);
+var gridContract = ariaContract([requireAccessibleName]);
+var listboxContract = ariaContract([requireAccessibleName]);
+var tablistContract = ariaContract([requireAccessibleName]);
+var radiogroupContract = ariaContract([requireAccessibleName]);
 var CONTRACT_GROUPS = [
   [VOID_TAGS, voidContract],
   [TEXT_ONLY_TAGS, textOnlyContract],
@@ -1546,19 +2165,28 @@ var htmlContracts = {
   figure: figureContract,
   details: detailsContract,
   fieldset: fieldsetContract,
+  dialog: dialogContract,
   head: headContract,
   html: htmlContract
 };
+
+// ../core/src/html/evaluators.ts
+var htmlDiagnostics = warnDiagnostics;
 function buildEvaluatorMap() {
-  const map = /* @__PURE__ */ new Map();
-  for (const [tag, { children }] of Object.entries(htmlContracts)) {
+  const map2 = /* @__PURE__ */ new Map();
+  iterate.forEachEntry(htmlContracts, (tag, { children }) => {
     if (children?.length) {
-      map.set(tag, new ChildrenEvaluator(children, "warn", `<${tag}>`));
+      map2.set(tag, new ChildrenEvaluator(children, htmlDiagnostics, `<${tag}>`));
     }
-  }
-  return map;
+  });
+  return map2;
 }
 var HTML_EVALUATORS = buildEvaluatorMap();
+function getHtmlChildrenEvaluator(tag) {
+  return typeof tag === "string" ? HTML_EVALUATORS.get(tag) : void 0;
+}
+
+// ../core/src/html/prop-normalizers.ts
 var HTML_FORM_NORMALIZERS = /* @__PURE__ */ new Map([
   ["button", [disabledProps]],
   ["input", [disabledProps, readonlyProps, invalidProps]],
@@ -1571,241 +2199,93 @@ function getHtmlPropNormalizers(tag) {
   return typeof tag === "string" ? HTML_FORM_NORMALIZERS.get(tag) : void 0;
 }
 
-// ../core/dist/chunk-3T4EM5FG.js
-var falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
-var cx = clsx;
-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);
-};
-function cva2(base, config) {
-  const fn = cva(base, config);
-  return (props) => cn(fn(props));
-}
-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;
-  }
-};
-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;
-      for (const k of this.#variantKeys) {
-        if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
-      }
-      return key2;
-    }
-    let key = recipe;
-    for (const k of Object.keys(props).sort()) {
-      key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
+// ../../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 } };
     }
-    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)}`;
-  }
-};
-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);
   };
 }
 
-// ../core/dist/index.js
-var FULL_CAPABILITIES = {
-  createClassPipeline,
-  AriaEngine: AriaPolicyEngine,
-  htmlAriaRules: HTML_ARIA_RULES,
-  htmlPropNormalizersFn: getHtmlPropNormalizers
-};
-function createPolymorphic2(options = {}) {
-  return createPolymorphic(options, FULL_CAPABILITIES);
+// ../core/src/resolver/resolver.ts
+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/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-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/build-engines.ts
-function buildEngines(strict, childRules, context) {
-  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, strict, context) } : {};
+// ../../lib/adapter-utils/src/define-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
 }
 
-// ../../lib/adapter-utils/src/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/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
-function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultStrict = "throw") {
+function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics) {
   return {
     name: options.name ?? defaultName,
-    strict: options.enforcement?.strict ?? defaultStrict
+    diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
   };
 }
 
 // ../../lib/adapter-utils/src/slot-validator.ts
-var SlotValidator = class extends StrictBase {
+var SlotValidator = class extends InvariantBase {
   #name;
   #elementTerm;
-  constructor(name, strict, elementTerm) {
-    super(strict);
+  constructor(name, diagnostics, elementTerm) {
+    super(diagnostics);
     this.#name = name;
     this.#elementTerm = elementTerm;
   }
   assertExclusive() {
-    this.violate(`${this.#name}: "as" and "asChild" are mutually exclusive`);
+    this.violate(SlotDiagnostics.exclusive(this.#name));
   }
   warnDiscardedChildren(count) {
-    const suffix = count === 1 ? "" : "ren";
-    this.warn(
-      `${this.#name}: asChild discarded ${count} non-element child${suffix} \u2014 only ${this.#elementTerm}s are valid asChild children.`
-    );
+    this.warn(SlotDiagnostics.discardedChildren(this.#name, this.#elementTerm, count));
   }
   assertSingleChild(count) {
-    const msg = count === 0 ? `${this.#name}: asChild requires a ${this.#elementTerm} child` : `${this.#name}: asChild requires exactly one ${this.#elementTerm} child, got ${count}`;
-    this.violate(msg);
+    this.violate(
+      count === 0 ? SlotDiagnostics.singleChildRequired(this.#name, this.#elementTerm) : SlotDiagnostics.singleChildExceeded(this.#name, this.#elementTerm, count)
+    );
   }
 };
 
-// ../shared/src/constants/primitive/slot-name.ts
-var SLOT_NAME = "Slot";
-
 // ../../lib/adapter-utils/src/slot/policies.ts
-import { clsx as clsx2 } from "clsx";
+import { clsx } from "clsx";
 function chainHandlers(childHandler, slotHandler) {
   return (...args) => {
     childHandler(...args);
@@ -1816,7 +2296,7 @@ function chainHandlers(childHandler, slotHandler) {
   };
 }
 function mergeClassNames(slot, child) {
-  return clsx2(slot, child);
+  return clsx(slot, child);
 }
 function mergeStyles(slot, child) {
   if (!isPlainObject(slot) || !isPlainObject(child)) return child;
@@ -1832,10 +2312,10 @@ var policyHandlers = {
 // ../../lib/adapter-utils/src/slot/merge-slot-props.ts
 function mergeSlotProps(slotProps, childProps) {
   const merged = { ...slotProps };
-  for (const key in childProps) {
-    if (!Object.hasOwn(childProps, key)) continue;
+  iterate.forEachKey(childProps, (key) => {
+    if (!Object.hasOwn(childProps, key)) return;
     merged[key] = applyMergePolicy(key, slotProps[key], childProps[key]);
-  }
+  });
   return merged;
 }
 function classifyProp(key, slotVal, childVal) {
@@ -1848,270 +2328,451 @@ function applyMergePolicy(key, slotVal, childVal) {
   return policyHandlers[classifyProp(key, slotVal, childVal)](slotVal, childVal);
 }
 
-// ../../adapters/preact/src/slot/Slot.tsx
-import { forwardRef } from "preact/compat";
-
-// ../../adapters/preact/src/slot/applySlot.ts
-import { isValidElement as isValidElement4 } from "preact";
-
-// ../../adapters/preact/src/slot/invariant.ts
-function panic2(message) {
-  throw new Error(message);
-}
-function invariant(condition, message) {
-  if (!condition) panic2(message);
+// ../../lib/adapter-utils/src/build-definition.ts
+function buildDefinition(name, tag) {
+  return {
+    identity: {
+      id: name,
+      name,
+      tag
+    },
+    capabilities: {},
+    metadata: {},
+    diagnostics: []
+  };
 }
 
-// ../../adapters/preact/src/slot/extractSlottable.ts
-import { h, Fragment as Fragment2, isValidElement as isValidElement3 } from "preact";
-
-// ../../adapters/preact/src/slot/predicates.ts
-import { isValidElement as isValidElement2 } from "preact";
-
-// ../../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 isValidElement2(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"
+// ../../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)
   );
-  invariant(
-    typeof child !== "string" && typeof child !== "number",
-    "Slottable expects exactly one Preact element child, received text content"
-  );
-  invariant(isValidElement3(child), "Slottable expects exactly one Preact element child");
-  invariant(child.type !== Fragment2, "Slottable child cannot be a Fragment");
-  const index = childrenArray.indexOf(slottable);
+}
+function buildVariantConfig(variants, presets, defaults, compounds) {
   return {
-    child,
-    rebuild(merged) {
-      const out = childrenArray.map((node, i) => i === index ? merged : node);
-      return h(Fragment2, null, ...out);
+    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/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);
+// ../../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];
+    });
   }
-  invariant(isValidElement4(children), "Slot: child must be a valid Preact element");
-  return cloneSlotChild2({ child: children, slotProps, ref });
+  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/cloneSlotChild.ts
-import { cloneElement, Fragment as Fragment3 } 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/composeRefs.ts
-function mergeRefs(...refs) {
-  const active = refs.filter((r2) => r2 != null);
-  if (active.length === 0) return null;
-  if (active.length === 1) return active[0];
-  return (value) => {
-    for (const ref of active) {
-      if (typeof ref === "function") {
-        ref(value);
-      } else {
-        ref.current = value;
-      }
-    }
-  };
+// ../../runtime/core/src/render-component.ts
+function renderComponent(definition, tree, render, backend) {
+  return backend.render({ definition, tree, render });
 }
-function getChildRef(child) {
-  const ref = child.ref;
-  return ref ?? null;
+
+// ../../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))
+  );
+  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 });
 }
 
-// ../../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);
+// ../../runtime/core/src/build-render-context.ts
+function buildRenderContext(decoration = {}) {
+  return { decoration: new Map(Object.entries(decoration)) };
 }
 
-// ../../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 });
+// ../../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;
+}
 
-// ../../adapters/preact/src/slot/slot-validator.ts
-var SlotValidator2 = class extends SlotValidator {
-  constructor(name, strict) {
-    super(name, strict, "Preact element");
+// ../../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: []
+      };
+    }
   }
-};
+  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 };
+}
 
-// ../../adapters/preact/src/build-runtime.ts
-function normalizeOptions(options) {
+// ../../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;
+  }
+  const variantConfig = buildVariantConfig(variants, presets, defaults, compounds);
   return {
-    ...options,
-    slotComponent: options.slotComponent ?? Slot,
-    ...resolveAdapterCommonOptions(options)
+    execute(decoration, recipe) {
+      return resolveClasses(decoration, variantConfig, defaults, recipe, compounds, variantLookup);
+    }
   };
 }
-function buildRuntime(options) {
-  const normalized = normalizeOptions(options);
-  const { runtime, ownedKeys } = buildCoreRuntime(normalized);
-  const slotValidator = new SlotValidator2(normalized.name, normalized.strict);
-  const { childrenEvaluator } = buildEngines(
-    normalized.strict,
-    normalized.enforcement?.children,
-    normalized.name
-  );
-  const filterProps = composeFilter(ownedKeys, normalized.filterProps);
+
+// ../../lib/adapter-utils/src/join-classes.ts
+function joinClasses(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+
+// ../../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/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 {
-    runtime,
-    slotComponent: normalized.slotComponent,
-    normalizeChildren,
-    slotValidator,
-    filterProps,
-    ...childrenEvaluator !== void 0 && { childrenEvaluator }
+    ...decoration,
+    root: withAttributes(dec, Object.keys(cleaned).length > 0 ? cleaned : void 0)
   };
 }
 
-// ../../adapters/preact/src/render.ts
-import { h as h2 } from "preact";
-function buildDirectives(as, asChild) {
+// ../../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 {
-    ...as !== void 0 && { as },
-    ...asChild !== void 0 && { asChild }
+    ...decoration,
+    root: withAttributes(dec, Object.keys(kept).length > 0 ? kept : void 0)
   };
 }
-function buildRenderState(tag, directives, props, className, children) {
-  const state = { tag, directives, props, className };
-  if (children !== void 0) state.children = children;
-  return state;
-}
-function resolveRenderState(runtime, props, filterProps) {
-  const { as, asChild, children, className, recipe, ...rest } = props;
-  const tag = runtime.resolveTag(as);
-  const mergedProps = runtime.resolveProps(rest);
-  const baseProps = runtime.options.normalizeFn ? runtime.options.normalizeFn(mergedProps) : mergedProps;
-  const htmlNormalizers = runtime.options.htmlPropNormalizersFn?.(tag);
-  const normalizedProps = htmlNormalizers?.length ? htmlNormalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), baseProps) : baseProps;
-  const resolvedClass = runtime.resolveClasses(tag, normalizedProps, className, recipe);
-  const filteredProps = applyFilter(normalizedProps, filterProps, runtime.options.variantKeys);
-  return buildRenderState(tag, buildDirectives(as, asChild), filteredProps, resolvedClass, children);
-}
-function warnDiscardedChildren(originalChildren, normalizedChildren, validator) {
-  if (!Array.isArray(originalChildren)) return;
-  const discarded = originalChildren.length - normalizedChildren.length;
-  if (discarded > 0) validator.warnDiscardedChildren(discarded);
-}
-function isSingleElementArray(arr) {
-  return arr.length === 1;
-}
-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;
+
+// ../../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/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 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 validateSlotDirectives(directives, validator) {
-  const { as, asChild } = directives;
-  if (!asChild) return false;
-  if (as !== void 0) {
-    validator.assertExclusive();
+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)) {
     return false;
   }
+  listeners[key] = value;
   return true;
 }
-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, resolved, ref) {
-  return h2(slotComponent, {
-    ...state.props,
-    className: state.className,
-    ref,
-    children: resolved.child
+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;
+  }
+  return dec;
 }
-function tryRenderAsChild(state, ref, slotComponent, getNormalized, validator) {
-  const resolved = resolveSlotRender(state, getNormalized, validator);
-  if (resolved === null) return null;
-  return renderResolvedSlot(slotComponent, state, resolved, ref);
-}
-function buildElementProps(props, className, ref, children) {
-  const { role, ...rest } = props;
+
+// ../../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) {
   return {
-    ...rest,
-    className,
-    ref,
-    ...children !== void 0 && { children },
-    ...isKnownAriaRole(role) && { role }
+    key: id,
+    ...decoration?.attributes,
+    ...decoration?.styles !== void 0 ? { style: decoration.styles } : {},
+    ...decoration?.listeners,
+    ...decoration?.ref !== void 0 ? { ref: decoration.ref } : {}
+  };
+}
+
+// ../../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
+  );
+  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 });
   };
 }
-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 = resolveRenderState(runtime, props, filterProps);
-  let cached;
-  const once = () => cached ??= normalizeChildren2(state.children);
-  if (process.env.NODE_ENV !== "production") childrenEvaluator?.evaluate(once());
-  const slotResult = tryRenderAsChild(state, ref, slotComponent, once, slotValidator);
-  return slotResult ?? renderIntrinsic(state, ref, runtime);
+
+// ../../adapters/preact/src/normalize-children.ts
+import { isValidElement as isValidElement2 } from "preact";
+function normalizeChildren(children) {
+  if (isValidElement2(children)) return [children];
+  if (Array.isArray(children)) return children.filter(isValidElement2);
+  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/slot/Slottable.tsx
+import { Fragment as Fragment3 } from "preact";
+import { jsx } from "preact/jsx-runtime";
+function Slottable({ children }) {
+  return /* @__PURE__ */ jsx(Fragment3, { children });
 }
 
 // ../../adapters/preact/src/create-contract-component.ts
+var EMPTY_SET = /* @__PURE__ */ new Set();
 function createContractComponent(options) {
-  const bundle = buildRuntime(options);
-  const Component = forwardRef2(function Component2(props, ref) {
-    return render({
-      ...bundle,
-      normalizeChildren,
-      props,
-      ref: ref ?? null
-    });
+  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);
   });
   applyDisplayName(Component, options.name);
-  if (typeof bundle.runtime.options.defaultTag === "string") {
-    Object.assign(Component, { [COMPONENT_DEFAULT_TAG]: bundle.runtime.options.defaultTag });
+  if (typeof defaultTag === "string") {
+    Object.assign(Component, { [COMPONENT_DEFAULT_TAG]: defaultTag });
   }
   return Component;
 }