praxis-kit 3.1.1 → 4.0.0

package/dist/lit/index.js

@@ -1,58 +1,17 @@
 // ../../adapters/lit/src/create-contract-component.ts
 import { LitElement, html } from "lit";
 
-// ../../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];
-  }
-  return out;
-}
-
-// ../../lib/adapter-utils/src/define-component.ts
-function defineContractComponent(options) {
-  return (factory) => factory(options);
-}
-
-// ../core/dist/chunk-KKSHJDE7.js
+// ../../lib/primitive/src/tag/resolve-tag.ts
 function makeResolveTag(defaultTag) {
   return function tag(as) {
     return as ?? defaultTag;
   };
 }
-function assertNever(value) {
-  throw new Error(`Unexpected value: ${String(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 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 cn(...inputs) {
-  return clsx(...inputs);
-}
-function mergeProps(defaultProps, props) {
-  return {
-    ...defaultProps ?? {},
-    ...props
-  };
-}
-function isNull(value) {
-  return value === null;
-}
-function isObject(value) {
-  return !isNull(value) && typeof value === "object";
+
+// ../../lib/primitive/src/utils/is-object.ts
+function isObject(value, excludeArrays = false) {
+  if (value === null || typeof value !== "object") return false;
+  return excludeArrays ? !Array.isArray(value) : true;
 }
 function isString(value) {
   return typeof value === "string";
@@ -60,308 +19,197 @@ function isString(value) {
 function isNumber(value) {
   return typeof value === "number";
 }
-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;
-  });
+
+// ../../lib/primitive/src/utils/assert-never.ts
+function assertNever(value) {
+  throw new Error(`Unexpected value: ${String(value)}`);
 }
-function whenDefined(key, value) {
-  return value === void 0 ? {} : { [key]: value };
+
+// ../../lib/primitive/src/utils/cn.ts
+import { clsx } from "clsx";
+function cn(...inputs) {
+  return clsx(...inputs);
 }
-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)
-  });
+
+// ../../lib/primitive/src/utils/iterate.ts
+function find(iterable, callback) {
+  for (const value of iterable) {
+    const result = callback(value);
+    if (result != null) {
+      return result;
+    }
+  }
+  return null;
 }
-function report(strict, message) {
-  if (strict === false) return;
-  const mode = strict === true ? "throw" : strict;
-  if (mode === "throw") throw new Error(message);
-  console.warn(message);
+function some(iterable, predicate) {
+  for (const value of iterable) {
+    if (predicate(value)) return true;
+  }
+  return false;
 }
-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(", ")}).`
-        );
-      }
+function every(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (!predicate(value, index++)) {
+      return false;
     }
-  };
-  const { recipeMap } = resolved;
-  if (recipeMap) {
-    for (const recipeKey in recipeMap) {
-      checkSelection(`preset "${recipeKey}"`, recipeMap[recipeKey]);
+  }
+  return true;
+}
+function* filter(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (predicate(value, index++)) {
+      yield value;
     }
   }
-  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);
+function* map(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    yield callback(value, index++);
+  }
+}
+function forEach(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    callback(value, index++);
+  }
+}
+function reduce(iterable, initial, callback) {
+  let accumulator = initial;
+  let index = 0;
+  for (const value of iterable) {
+    accumulator = callback(accumulator, value, index++);
+  }
+  return accumulator;
+}
+function collect(iterable, callback) {
+  const result = {};
+  let index = 0;
+  for (const value of iterable) {
+    const entry = callback(value, index++);
+    if (entry === null) {
+      return null;
     }
-    return;
+    result[entry[0]] = entry[1];
   }
-  if (warned.has(message)) return;
-  warned.add(message);
-  console.warn(message);
+  return result;
 }
-function label(name) {
-  return name ? `[${name}]` : "[createContractComponent]";
+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 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.`);
+function* items(collection) {
+  for (let i = 0; i < collection.length; i++) {
+    const item = collection.item(i);
+    if (item !== null) {
+      yield item;
+    }
   }
-  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 nodeList(list) {
+  return {
+    *[Symbol.iterator]() {
+      for (let i = 0; i < list.length; i++) {
+        const node = list.item(i);
+        if (node !== null) {
+          yield node;
+        }
       }
     }
+  };
+}
+function mapEntries(m) {
+  return m.entries();
+}
+function set(s) {
+  return s.values();
+}
+function hasOwn(object, key) {
+  return Object.hasOwn(object, key);
+}
+function* entries(object) {
+  for (const key in object) {
+    if (!hasOwn(object, key)) continue;
+    yield [key, object[key]];
   }
 }
-function panic(message) {
-  throw new Error(message);
+function* keys(object) {
+  for (const [key] of entries(object)) {
+    yield key;
+  }
 }
-function describe(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  return typeof value;
+function* values(object) {
+  for (const [, value] of entries(object)) {
+    yield 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 mapValues(object, callback) {
+  const result = {};
+  for (const [key, value] of entries(object)) {
+    result[key] = callback(value, key);
+  }
+  return result;
 }
-function guardPipeline(pipeline) {
-  if (process.env.NODE_ENV === "production") return pipeline;
-  return function guardedPipeline(tag, props, className, recipe) {
-    const result = pipeline(tag, props, className, recipe);
-    if (typeof result !== "string")
-      panic(`[praxis-kit] Plugin pipeline must return a string. Got: ${describe(result)}.`);
-    return result;
-  };
+function forEachEntry(object, callback) {
+  for (const [key, value] of entries(object)) {
+    callback(key, 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 forEachKey(object, callback) {
+  for (const key of keys(object)) {
+    callback(key);
   }
-  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);
-      }
-      return classPipeline(tag, props, className, recipe);
-    },
-    resolveAria(tag, props) {
-      if (!engine) return { props };
-      const result = engine.validate(tag, props);
-      return { props: result.props };
-    }
-  };
+function forEachValue(object, callback) {
+  for (const value of values(object)) {
+    callback(value);
+  }
 }
-function createRuntimeObject(methods, resolved, pluginResult) {
-  return pluginResult ? { ...methods, options: resolved, hasStyling: true, classPlugin: pluginResult } : { ...methods, options: resolved };
+function forEachSet(s, callback) {
+  for (const value of s) {
+    callback(value);
+  }
 }
-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 iterate = Object.freeze({
+  entries,
+  filter,
+  find,
+  findLast,
+  forEach,
+  forEachEntry,
+  forEachKey,
+  forEachSet,
+  forEachValue,
+  items,
+  keys,
+  map,
+  mapEntries,
+  mapValues,
+  nodeList,
+  reduce,
+  collect,
+  set,
+  some,
+  every,
+  values
+});
+
+// ../../lib/primitive/src/utils/merge-props.ts
+function mergeProps(defaultProps, props) {
+  return {
+    ...defaultProps ?? {},
+    ...props
+  };
 }
-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",
@@ -381,29 +229,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",
@@ -415,6 +293,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",
@@ -564,9 +444,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);
 }
@@ -576,6 +465,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]);
@@ -584,116 +475,509 @@ function isStandaloneTag(tag) {
   if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
   return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
 }
-
-// ../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 getInputImplicitRole(type) {
+  if (type == null || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
+  return INPUT_TYPE_ROLE_MAP[type];
+}
+function getConditionalImplicitRole(tag, ariaLabel, ariaLabelledBy) {
+  const isNamed = typeof ariaLabel === "string" || typeof ariaLabelledBy === "string";
+  if (!isNamed) return void 0;
+  if (tag === "section") return "region";
+  if (tag === "form") return "form";
   return void 0;
 }
-var COMPONENT_DEFAULT_TAG = /* @__PURE__ */ Symbol.for("praxis.component-default-tag");
-function getAsProp(child) {
-  if (!isObject(child) || !("props" in child)) return void 0;
-  const props = child.props;
-  if (!isObject(props)) return void 0;
-  const as = props.as;
-  return isString(as) && as !== "" ? as : void 0;
+
+// ../../lib/adapter-utils/src/apply-filter.ts
+function applyFilter(props, filterProps, variantKeys) {
+  const out = {};
+  iterate.forEachEntry(props, (k) => {
+    if (!Object.hasOwn(props, k)) return;
+    if (filterProps(k, variantKeys)) return;
+    out[k] = props[k];
+  });
+  return out;
 }
-function getTag(child) {
-  if (!isObject(child) || !("type" in child)) return void 0;
-  const t = child.type;
-  if (isString(t)) return t;
-  if (typeof t === "function" || isObject(t)) {
-    const defaultTag = t[COMPONENT_DEFAULT_TAG];
-    if (!isString(defaultTag)) return void 0;
-    return getAsProp(child) ?? defaultTag;
+
+// ../../lib/contract/src/aria/aria-role-policy.ts
+function getImplicitRole(tag, props) {
+  if (tag in IMPLICIT_ROLE_RECORD) return IMPLICIT_ROLE_RECORD[tag];
+  if (tag === "input") return getInputImplicitRole(props?.type);
+  if (tag === "img") return props?.alt === "" ? "none" : "img";
+  if (tag === "section" || tag === "form") {
+    return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
   }
   return void 0;
 }
-function isTag(...args) {
-  if (isString(args[0])) {
-    const set2 = new Set(args);
-    return (child2) => {
-      const tag2 = getTag(child2);
-      return tag2 !== void 0 && set2.has(tag2);
-    };
+
+// ../../lib/contract/src/strict/invariant-base.ts
+var InvariantBase = class {
+  diagnostics;
+  constructor(diagnostics) {
+    this.diagnostics = diagnostics;
   }
-  const [child, ...tags] = args;
-  const set = 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);
+  get active() {
+    return this.diagnostics.active;
+  }
+  violate(input) {
+    this.diagnostics.error(input);
   }
-  // Always caps at console.warn — never throws. ARIA 'warning' violations route here
+  // 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 isNull2(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, label2, dim) {
+    return {
+      code: "COMP1010" /* ContractUnknownVariantDim */,
+      category: 0 /* Contract */,
+      message: `${component}: ${label2} references unknown variant "${dim}".`
+    };
+  },
+  unknownVariantValue(component, label2, dim, value, valid) {
+    return {
+      code: "COMP1011" /* ContractUnknownVariantValue */,
+      category: 0 /* Contract */,
+      message: `${component}: ${label2} 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/aria/polymorphic-validator.ts
 var VALID = [{ valid: true }];
 function isIntrinsicTag(tag) {
   return isString(tag);
@@ -702,26 +986,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,
@@ -734,10 +1020,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 hasRole = implicitRole != null || isString(props.role) && props.role.length > 0;
+    if (!hasRole) 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;
@@ -752,25 +1037,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);
@@ -795,10 +1091,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
@@ -810,27 +1107,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) {
@@ -838,15 +1134,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 (!isNull2(key)) {
+    if (!isNull(key)) {
       const cached = this.#planCache.get(key);
       if (cached !== void 0) {
         this.#planCache.delete(key);
@@ -860,7 +1156,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 (!isNull2(key)) {
+    if (!isNull(key)) {
       const { removals, updates } = _AriaPolicyEngine.#computePlan(
         props,
         result.props
@@ -881,12 +1177,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 = {
@@ -914,10 +1210,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,
@@ -933,7 +1245,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)
         }
       ];
     }
@@ -947,45 +1259,302 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
         valid: false,
         fixable: true,
         severity: "warning",
-        fix: _AriaPolicyEngine.#removeRole,
-        message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
+        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)
       }
     ];
   }
-  static #checkStandaloneRegion({ tag, props, implicitRole }) {
-    const role = props.role;
-    if (role !== "region") return VALID;
-    if (!isStandaloneTag(tag)) return VALID;
+  // 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",
+        attribute: attr,
+        diagnostic: AriaDiagnostics.requiredProperty(attr, effectiveRole)
+      });
+    });
+    return results;
+  }
+  // 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.
@@ -1014,7 +1583,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)
       }
     ];
   }
@@ -1026,7 +1595,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)
       }
     ];
   }
@@ -1055,7 +1624,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")
         }
       ];
@@ -1067,7 +1636,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
         }
       ];
@@ -1075,6 +1644,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";
@@ -1085,39 +1656,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);
@@ -1142,6 +1682,8 @@ function normalizeChildRule(rule) {
     cardinality: normalizeCardinality(rule.cardinality, impliesSingleton)
   };
 }
+
+// ../../lib/contract/src/children/rules-matcher.ts
 function getChildType(child) {
   if (!isObject(child) || !("type" in child)) return void 0;
   return child.type;
@@ -1150,8 +1692,8 @@ 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)) {
@@ -1159,12 +1701,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 };
 }
@@ -1183,10 +1727,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);
@@ -1200,8 +1744,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();
@@ -1209,33 +1753,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;
@@ -1244,21 +1790,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) {
@@ -1273,48 +1819,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,
@@ -1326,6 +1874,8 @@ var disabledProps = ({
     ...dataDisabled === void 0 && { "data-disabled": "" }
   };
 };
+
+// ../../lib/contract/src/props/get-invalid-props.ts
 var invalidProps = ({
   invalid,
   "aria-invalid": ariaInvalid,
@@ -1337,6 +1887,8 @@ var invalidProps = ({
     ...dataInvalid === void 0 && { "data-invalid": "" }
   };
 };
+
+// ../../lib/contract/src/props/get-readonly-props.ts
 var readonlyProps = ({
   readOnly,
   "aria-readonly": ariaReadonly,
@@ -1352,6 +1904,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",
@@ -1371,154 +1925,29 @@ 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 isOpenContent(...blockedTags) {
-  const set = new Set(blockedTags);
-  return (child) => isObject(child) && "type" in child && (!isString(child.type) || !set.has(child.type));
-}
-var METADATA_TAGS = ["script", "template"];
-var metadataMatch = isTag(...METADATA_TAGS);
-function metadata(name = "metadata") {
-  return { name, match: metadataMatch };
-}
-function firstOptional(name, tag) {
-  return { name, match: isTag(tag), cardinality: { max: 1 }, position: "first" };
-}
-function contract(children) {
-  return { strict: "warn", children };
-}
-function ariaContract(aria) {
-  return { strict: "warn", aria };
-}
-function firstChildContract(name, tag) {
-  return contract([firstOptional(name, tag), { name: "content", match: isOpenContent(tag) }]);
-}
-var VOID_TAGS = [
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-];
-var TEXT_ONLY_TAGS = ["option", "script", "style", "textarea", "title"];
-var LANDMARK_TAGS = ["article", "aside", "footer", "header", "main", "nav"];
-var listContract = contract([{ name: "list-item", match: isTag("li", ...METADATA_TAGS) }]);
-var tableContract = contract([
-  firstOptional("caption", "caption"),
-  { name: "colgroup", match: isTag("colgroup") },
-  { name: "thead", match: isTag("thead"), cardinality: { max: 1 } },
-  { name: "tbody", match: isTag("tbody") },
-  { name: "tfoot", match: isTag("tfoot"), cardinality: { max: 1 } },
-  { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
-]);
-var tableBodyContract = contract([
-  { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
-]);
-var tableRowContract = contract([
-  { name: "table-cell", match: isTag("td", "th", ...METADATA_TAGS) }
-]);
-var colgroupContract = contract([{ name: "column", match: isTag("col", "template") }]);
-var dlContract = contract([
-  { name: "term", match: isTag("dt") },
-  { name: "description", match: isTag("dd") },
-  { name: "group", match: isTag("div") },
-  metadata()
-]);
-var selectContract = contract([
-  { name: "option", match: isTag("option", "optgroup", "hr", ...METADATA_TAGS) }
-]);
-var optgroupContract = contract([
-  { name: "option", match: isTag("option", ...METADATA_TAGS) }
-]);
-var datalistContract = contract([
-  { name: "option", match: isTag("option", ...METADATA_TAGS) }
-]);
-var pictureContract = contract([
-  { name: "source", match: isTag("source", ...METADATA_TAGS) },
-  { name: "image", match: isTag("img"), cardinality: { min: 1, max: 1 }, position: "last" }
-]);
-var figureContract = contract([
-  { name: "caption", match: isTag("figcaption"), cardinality: { max: 1 } },
-  { name: "content", match: isOpenContent("figcaption") }
-]);
-var detailsContract = firstChildContract("summary", "summary");
-var fieldsetContract = firstChildContract("legend", "legend");
-var mediaContract = contract([
-  { name: "source", match: isTag("source") },
-  { name: "track", match: isTag("track") },
-  metadata(),
-  { name: "content", match: isOpenContent("source", "track", ...METADATA_TAGS) }
-]);
-var headContract = contract([
-  {
-    name: "metadata",
-    match: isTag("base", "link", "meta", "noscript", "script", "style", "template", "title")
-  }
-]);
-var htmlContract = contract([
-  { name: "head", match: isTag("head"), cardinality: { min: 1, max: 1 }, position: "first" },
-  { name: "body", match: isTag("body"), cardinality: { min: 1, max: 1 } }
-]);
-var voidContract = contract([]);
-var textOnlyContract = contract([
-  {
-    name: "text",
-    match: (child) => isString(child) || isNumber(child)
-  }
-]);
-var landmarkContract = ariaContract([landmarkRoleRule]);
-var CONTRACT_GROUPS = [
-  [VOID_TAGS, voidContract],
-  [TEXT_ONLY_TAGS, textOnlyContract],
-  [LANDMARK_TAGS, landmarkContract],
-  [["ul", "ol", "menu"], listContract],
-  [["audio", "video"], mediaContract],
-  [["thead", "tbody", "tfoot"], tableBodyContract]
-];
-function contractMap(groups) {
-  return Object.fromEntries(
-    groups.flatMap(([tags, enforcement]) => tags.map((tag) => [tag, enforcement]))
-  );
-}
-var htmlContracts = {
-  ...contractMap(CONTRACT_GROUPS),
-  table: tableContract,
-  tr: tableRowContract,
-  colgroup: colgroupContract,
-  dl: dlContract,
-  select: selectContract,
-  optgroup: optgroupContract,
-  datalist: datalistContract,
-  picture: pictureContract,
-  figure: figureContract,
-  details: detailsContract,
-  fieldset: fieldsetContract,
-  head: headContract,
-  html: htmlContract
-};
-function buildEvaluatorMap() {
-  const map = /* @__PURE__ */ new Map();
-  for (const [tag, { children }] of Object.entries(htmlContracts)) {
-    if (children?.length) {
-      map.set(tag, new ChildrenEvaluator(children, "warn", `<${tag}>`));
+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)
     }
-  }
-  return map;
+  ];
+}
+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);
 }
-var HTML_EVALUATORS = buildEvaluatorMap();
+var HTML_ARIA_RULES = [landmarkRoleRule, landmarkNameAdvisory];
+
+// ../core/src/html/prop-normalizers.ts
 var HTML_FORM_NORMALIZERS = /* @__PURE__ */ new Map([
   ["button", [disabledProps]],
   ["input", [disabledProps, readonlyProps, invalidProps]],
@@ -1531,9 +1960,10 @@ function getHtmlPropNormalizers(tag) {
   return typeof tag === "string" ? HTML_FORM_NORMALIZERS.get(tag) : void 0;
 }
 
-// ../core/dist/chunk-3T4EM5FG.js
+// ../../node_modules/.pnpm/class-variance-authority@0.7.1/node_modules/class-variance-authority/dist/index.mjs
+import { clsx as clsx2 } from "clsx";
 var falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
-var cx = clsx;
+var cx = clsx2;
 var cva = (base, config) => (props) => {
   var _config_compoundVariants;
   if ((config === null || config === void 0 ? void 0 : config.variants) == null) return cx(base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
@@ -1572,10 +2002,14 @@ var cva = (base, config) => (props) => {
   }, []);
   return cx(base, getVariantClassNames, getCompoundVariantClassNames, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
 };
+
+// ../../lib/styling/src/cva.ts
 function cva2(base, config) {
   const fn = cva(base, config);
   return (props) => cn(fn(props));
 }
+
+// ../../lib/styling/src/static-class-resolver.ts
 var StaticClassResolver = class {
   #baseClass;
   #cache = /* @__PURE__ */ new Map();
@@ -1606,6 +2040,8 @@ var StaticClassResolver = class {
     return result;
   }
 };
+
+// ../../lib/styling/src/variant-class-resolver.ts
 var VariantClassResolver = class _VariantClassResolver {
   #cvaFn;
   #recipeMap;
@@ -1653,15 +2089,15 @@ var VariantClassResolver = class _VariantClassResolver {
   #createCacheKey(props, recipe) {
     if (this.#variantKeys !== null) {
       let key2 = recipe;
-      for (const k of this.#variantKeys) {
+      iterate.forEachSet(this.#variantKeys, (k) => {
         if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
-      }
+      });
       return key2;
     }
     let key = recipe;
-    for (const k of Object.keys(props).sort()) {
+    iterate.forEach(Object.keys(props).sort(), (k) => {
       key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
-    }
+    });
     return key;
   }
   static #serializeValue(value) {
@@ -1672,6 +2108,8 @@ var VariantClassResolver = class _VariantClassResolver {
     return `x:${String(value)}`;
   }
 };
+
+// ../../lib/styling/src/create-class-pipeline.ts
 function createClassPipeline(resolved) {
   const baseClass = resolved.baseClassName ?? "";
   const cvaFn = resolved.variants ? cva2("", {
@@ -1696,7 +2134,203 @@ function createClassPipeline(resolved) {
   };
 }
 
-// ../core/dist/index.js
+// ../core/src/options/resolve-factory-options.ts
+var EMPTY_VARIANT_KEYS = /* @__PURE__ */ new Set();
+function composeNormalizers(normalizers, fn) {
+  if (!normalizers?.length) return fn;
+  return ((props) => {
+    const patched = normalizers.reduce(
+      (acc, normalizer) => ({ ...acc, ...normalizer(acc) }),
+      props
+    );
+    return fn ? fn(patched) : patched;
+  });
+}
+function whenDefined(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function resolveFactoryOptions(options = {}) {
+  const { styling, enforcement } = options;
+  const composedNormalizeFn = composeNormalizers(enforcement?.props, options.normalize);
+  const variantKeys = styling?.variants === void 0 ? EMPTY_VARIANT_KEYS : new Set(Object.keys(styling.variants));
+  return Object.freeze({
+    defaultTag: options.tag ?? "div",
+    diagnostics: enforcement?.diagnostics ?? silentDiagnostics,
+    variantKeys,
+    ...whenDefined("displayName", options.name),
+    ...whenDefined("defaultProps", options.defaults),
+    ...whenDefined("baseClassName", styling?.base),
+    ...whenDefined("tagMap", styling?.tags),
+    ...whenDefined("recipeMap", styling?.presets),
+    ...whenDefined("variants", styling?.variants),
+    ...whenDefined("defaultVariants", styling?.defaults),
+    ...whenDefined("compoundVariants", styling?.compounds),
+    ...whenDefined("normalizeFn", composedNormalizeFn),
+    ...whenDefined("ariaRules", enforcement?.aria),
+    ...whenDefined("childRules", enforcement?.children),
+    ...whenDefined("allowedAs", enforcement?.allowedAs),
+    ...whenDefined("precomputedClasses", styling?.precomputedClasses)
+  });
+}
+
+// ../core/src/options/validate-factory-options.ts
+function validateFactoryOptions(resolved, diagnostics) {
+  if (!diagnostics.active) return;
+  const name = resolved.displayName ?? "Component";
+  const { variants } = resolved;
+  const checkSelection = (label2, selection) => {
+    iterate.forEachEntry(selection, (dim, value) => {
+      if (value === void 0 || value === null) return;
+      if (!variants || !Object.hasOwn(variants, dim)) {
+        diagnostics.error(ContractDiagnostics.unknownVariantDim(name, label2, dim));
+        return;
+      }
+      const states = variants[dim];
+      const stateKey = String(value);
+      if (!Object.hasOwn(states, stateKey)) {
+        diagnostics.error(
+          ContractDiagnostics.unknownVariantValue(name, label2, dim, stateKey, Object.keys(states))
+        );
+      }
+    });
+  };
+  const { recipeMap } = resolved;
+  if (recipeMap) {
+    iterate.forEachEntry(recipeMap, (recipeKey, selection) => {
+      checkSelection(`preset "${recipeKey}"`, selection);
+    });
+  }
+  if (resolved.defaultVariants) checkSelection("defaults", resolved.defaultVariants);
+}
+
+// ../core/src/options/validate-render-props.ts
+function label(name) {
+  return name ? `[${name}]` : "[createContractComponent]";
+}
+function validateRenderProps(diagnostics, options, props, recipeKey) {
+  const { recipeMap, variants, displayName } = options;
+  const tag = label(displayName);
+  if (recipeKey !== void 0 && (!recipeMap || !Object.hasOwn(recipeMap, recipeKey))) {
+    diagnostics.error(ContractDiagnostics.unknownRecipeKey(tag, recipeKey));
+  }
+  if (variants) {
+    iterate.forEachKey(variants, (key) => {
+      if (!Object.hasOwn(props, key)) return;
+      const value = props[key];
+      if (value === void 0 || value === null) return;
+      const dim = variants[key];
+      if (dim && !Object.hasOwn(dim, String(value))) {
+        diagnostics.error(ContractDiagnostics.invalidVariantValue(tag, key, String(value)));
+      }
+    });
+  }
+}
+
+// ../core/src/factory/plugin-diagnostics.ts
+var PluginDiagnostics = {
+  invalidShape(received) {
+    const got = received === null ? "null" : typeof received;
+    return {
+      code: "PLUGIN7001" /* PluginInvalidShape */,
+      category: 7 /* Internal */,
+      message: `[praxis-kit] Plugin factory must return an object with a 'pipeline' function. Got: ${got}.`
+    };
+  },
+  pipelineReturnType(received) {
+    const got = received === null ? "null" : Array.isArray(received) ? "array" : typeof received;
+    return {
+      code: "PLUGIN7002" /* PluginPipelineReturnType */,
+      category: 7 /* Internal */,
+      message: `[praxis-kit] Plugin pipeline must return a string. Got: ${got}.`
+    };
+  }
+};
+
+// ../core/src/factory/plugin-invariants.ts
+function assertPluginShape(result) {
+  if (result === null || typeof result !== "object")
+    throwDiagnostics.error(PluginDiagnostics.invalidShape(result));
+  const plugin = result;
+  if (typeof plugin.pipeline !== "function")
+    throwDiagnostics.error(PluginDiagnostics.invalidShape(result));
+}
+function guardPipeline(pipeline) {
+  if (process.env.NODE_ENV === "production") return pipeline;
+  return function guardedPipeline(tag, props, className, recipe) {
+    const result = pipeline(tag, props, className, recipe);
+    if (typeof result !== "string")
+      throwDiagnostics.error(PluginDiagnostics.pipelineReturnType(result));
+    return result;
+  };
+}
+
+// ../core/src/factory/create-polymorphic.ts
+var NOOP_CLASS_PIPELINE = (_tag, _props, className) => Array.isArray(className) ? className.join(" ") : className ?? "";
+function resolveClassPipeline(options, resolved, diagnostics, 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 };
+  }
+  const pluginResult = factory(resolved, diagnostics);
+  assertPluginShape(pluginResult);
+  const classPipeline = guardPipeline(pluginResult.pipeline);
+  return { pluginResult, classPipeline };
+}
+function createRuntimeMethods(resolved, classPipeline, engine, renderDiagnostics) {
+  return {
+    resolveTag: makeResolveTag(resolved.defaultTag),
+    resolveProps(props) {
+      return mergeProps(resolved.defaultProps, props);
+    },
+    resolveClasses(tag, props, className, recipe) {
+      if (process.env.NODE_ENV !== "production") {
+        validateRenderProps(renderDiagnostics, resolved, props, recipe);
+      }
+      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, resolved.diagnostics);
+  }
+  const { pluginResult, classPipeline } = resolveClassPipeline(
+    options,
+    resolved,
+    resolved.diagnostics,
+    capabilities
+  );
+  const allAriaRules = [
+    .../* @__PURE__ */ new Set([...capabilities?.htmlAriaRules ?? [], ...resolved.ariaRules ?? []])
+  ];
+  const engine = options.enforcement !== void 0 && capabilities?.AriaEngine ? new capabilities.AriaEngine(
+    resolved.diagnostics,
+    allAriaRules.length ? { rules: allAriaRules } : void 0
+  ) : null;
+  const methods = createRuntimeMethods(resolved, classPipeline, engine, resolved.diagnostics);
+  return createRuntimeObject(
+    methods,
+    resolved,
+    pluginResult
+  );
+}
+
+// ../core/src/factory/create-polymorphic-full.ts
 var FULL_CAPABILITIES = {
   createClassPipeline,
   AriaEngine: AriaPolicyEngine,
@@ -1707,6 +2341,11 @@ function createPolymorphic2(options = {}) {
   return createPolymorphic(options, FULL_CAPABILITIES);
 }
 
+// ../../lib/adapter-utils/src/define-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
+}
+
 // ../../lib/adapter-utils/src/build-core-runtime.ts
 var EMPTY_SET = /* @__PURE__ */ new Set();
 function buildCoreRuntime(normalized) {
@@ -1716,8 +2355,8 @@ function buildCoreRuntime(normalized) {
 }
 
 // ../../lib/adapter-utils/src/build-engines.ts
-function buildEngines(strict, childRules, context) {
-  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, strict, context) } : {};
+function buildEngines(diagnostics, childRules, context) {
+  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, diagnostics, context) } : {};
 }
 
 // ../../lib/adapter-utils/src/compose-filter.ts
@@ -1730,10 +2369,10 @@ function composeFilter(ownedKeys, filterProps) {
 }
 
 // ../../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
   };
 }
 
@@ -1741,7 +2380,7 @@ function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponen
 function normalizeOptions(options) {
   return {
     ...options,
-    ...resolveAdapterCommonOptions(options, "PolymorphicElement", false)
+    ...resolveAdapterCommonOptions(options, "PolymorphicElement", silentDiagnostics)
   };
 }
 function buildRuntime(options) {
@@ -1749,7 +2388,7 @@ function buildRuntime(options) {
   const normalized = normalizeOptions(options);
   const { runtime, ownedKeys } = buildCoreRuntime(normalized);
   const { childrenEvaluator } = buildEngines(
-    normalized.strict,
+    normalized.diagnostics,
     enforcement?.children,
     normalized.name
   );
@@ -1771,16 +2410,14 @@ function escapeAttr(value) {
 }
 function buildAttrString(attributes) {
   const parts = [];
-  for (const key in attributes) {
-    if (!Object.hasOwn(attributes, key)) continue;
-    const value = attributes[key];
-    if (value === false || value === null || value === void 0) continue;
+  iterate.forEachEntry(attributes, (key, value) => {
+    if (value === false || value === null || value === void 0) return;
     if (value === true) {
       parts.push(key);
     } else {
       parts.push(`${key}="${escapeAttr(String(value))}"`);
     }
-  }
+  });
   return parts.length > 0 ? " " + parts.join(" ") : "";
 }
 function renderToString(component, props = {}, innerHTML = "") {
@@ -1858,19 +2495,19 @@ function resolveHostState(bundle, props) {
 }
 function applyHostState(host, state, prevPipelineAttrs, incomingProps) {
   host.className = state.className;
-  for (const key of prevPipelineAttrs) {
+  iterate.forEachSet(prevPipelineAttrs, (key) => {
     if (!Object.hasOwn(state.attributes, key)) {
       host.removeAttribute(key);
     }
-  }
+  });
   prevPipelineAttrs.clear();
-  for (const key in incomingProps) {
-    if (!Object.hasOwn(incomingProps, key)) continue;
-    if (!key.startsWith("aria-") && key !== "role") continue;
+  iterate.forEachKey(incomingProps, (key) => {
+    if (!Object.hasOwn(incomingProps, key)) return;
+    if (!key.startsWith("aria-") && key !== "role") return;
     if (!Object.hasOwn(state.attributes, key)) host.removeAttribute(key);
-  }
-  for (const key in state.attributes) {
-    if (!Object.hasOwn(state.attributes, key)) continue;
+  });
+  iterate.forEachKey(state.attributes, (key) => {
+    if (!Object.hasOwn(state.attributes, key)) return;
     const value = state.attributes[key];
     if (value === void 0 || value === null || value === false) {
       host.removeAttribute(key);
@@ -1881,7 +2518,7 @@ function applyHostState(host, state, prevPipelineAttrs, incomingProps) {
       host.setAttribute(key, String(value));
       prevPipelineAttrs.add(key);
     }
-  }
+  });
 }
 function createContractComponent(options) {
   const bundle = buildRuntime(options);
@@ -1902,12 +2539,12 @@ function createContractComponent(options) {
     // attribute so _applyPraxis can read it without a circular class→pipeline→class loop.
     praxisClass: { type: String, attribute: "praxis-class" }
   };
-  for (const key of variantKeys) {
+  iterate.forEach(variantKeys, (key) => {
     staticProps[key] = { type: String, attribute: key };
-  }
-  for (const key of pluginKeys) {
+  });
+  iterate.forEach(pluginKeys, (key) => {
     staticProps[key] = { type: String, attribute: key };
-  }
+  });
   class PolymorphicLitElement extends LitElement {
     // Tracks keys set by the pipeline last render so stale attrs are removed.
     _pipelineAttrs = /* @__PURE__ */ new Set();
@@ -1949,16 +2586,16 @@ function createContractComponent(options) {
     _applyPraxis() {
       const self = this._self;
       const props = {};
-      for (const attr of Array.from(this.attributes)) {
+      iterate.forEach(iterate.items(this.attributes), (attr) => {
         if (attr.name !== "class") props[attr.name] = attr.value;
-      }
+      });
       props["as"] = self.as;
       props["recipe"] = self.recipe;
       props["className"] = self.praxisClass;
-      for (const key of variantKeys) {
+      iterate.forEach(variantKeys, (key) => {
         const val = self[key];
         if (val != null) props[key] = val;
-      }
+      });
       applyHostState(this, resolveHostState(looseBundle, props), this._pipelineAttrs, props);
     }
     render() {