praxis-kit 3.1.1 → 4.0.0

package/dist/chunk-TJRHF6MS.js

@@ -0,0 +1,2777 @@
+// ../../lib/adapter-utils/src/define-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
+}
+
+// ../../lib/adapter-utils/src/invariant.ts
+function panic(message) {
+  throw new Error(message);
+}
+function invariant(condition, message) {
+  if (!condition) panic(message);
+}
+
+// ../../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";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+
+// ../../lib/primitive/src/merge/constants.ts
+var EVENT_HANDLER_RE = /^on[A-Z]/;
+
+// ../../lib/primitive/src/merge/predicates.ts
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isPlainObject(value) {
+  if (!isObject(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// ../../lib/primitive/src/utils/assert-never.ts
+function assertNever(value) {
+  throw new Error(`Unexpected value: ${String(value)}`);
+}
+
+// ../../lib/primitive/src/utils/iterate.ts
+function find(iterable, callback) {
+  for (const value of iterable) {
+    const result = callback(value);
+    if (result != null) {
+      return result;
+    }
+  }
+  return null;
+}
+function some(iterable, predicate) {
+  for (const value of iterable) {
+    if (predicate(value)) return true;
+  }
+  return false;
+}
+function every(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (!predicate(value, index++)) {
+      return false;
+    }
+  }
+  return true;
+}
+function* filter(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (predicate(value, index++)) {
+      yield value;
+    }
+  }
+}
+function* map(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    yield callback(value, index++);
+  }
+}
+function forEach(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    callback(value, index++);
+  }
+}
+function reduce(iterable, initial, callback) {
+  let accumulator = initial;
+  let index = 0;
+  for (const value of iterable) {
+    accumulator = callback(accumulator, value, index++);
+  }
+  return accumulator;
+}
+function collect(iterable, callback) {
+  const result = {};
+  let index = 0;
+  for (const value of iterable) {
+    const entry = callback(value, index++);
+    if (entry === null) {
+      return null;
+    }
+    result[entry[0]] = entry[1];
+  }
+  return result;
+}
+function findLast(value, callback) {
+  for (let index = value.length - 1; index >= 0; index--) {
+    const result = callback(value[index], index);
+    if (result != null) {
+      return result;
+    }
+  }
+  return null;
+}
+function* items(collection) {
+  for (let i = 0; i < collection.length; i++) {
+    const item = collection.item(i);
+    if (item !== null) {
+      yield item;
+    }
+  }
+}
+function nodeList(list) {
+  return {
+    *[Symbol.iterator]() {
+      for (let i = 0; i < list.length; i++) {
+        const node = list.item(i);
+        if (node !== null) {
+          yield node;
+        }
+      }
+    }
+  };
+}
+function mapEntries(m) {
+  return m.entries();
+}
+function set(s) {
+  return s.values();
+}
+function hasOwn(object, key) {
+  return Object.hasOwn(object, key);
+}
+function* entries(object) {
+  for (const key in object) {
+    if (!hasOwn(object, key)) continue;
+    yield [key, object[key]];
+  }
+}
+function* keys(object) {
+  for (const [key] of entries(object)) {
+    yield key;
+  }
+}
+function* values(object) {
+  for (const [, value] of entries(object)) {
+    yield value;
+  }
+}
+function mapValues(object, callback) {
+  const result = {};
+  for (const [key, value] of entries(object)) {
+    result[key] = callback(value, key);
+  }
+  return result;
+}
+function forEachEntry(object, callback) {
+  for (const [key, value] of entries(object)) {
+    callback(key, value);
+  }
+}
+function forEachKey(object, callback) {
+  for (const key of keys(object)) {
+    callback(key);
+  }
+}
+function forEachValue(object, callback) {
+  for (const value of values(object)) {
+    callback(value);
+  }
+}
+function forEachSet(s, callback) {
+  for (const value of s) {
+    callback(value);
+  }
+}
+var iterate = Object.freeze({
+  entries,
+  filter,
+  find,
+  findLast,
+  forEach,
+  forEachEntry,
+  forEachKey,
+  forEachSet,
+  forEachValue,
+  items,
+  keys,
+  map,
+  mapEntries,
+  mapValues,
+  nodeList,
+  reduce,
+  collect,
+  set,
+  some,
+  every,
+  values
+});
+
+// ../../lib/primitive/src/utils/merge-refs.ts
+function mergeRefsCore(...refs) {
+  const active = refs.filter((r) => r != null);
+  if (active.length === 0) return null;
+  if (active.length === 1) return active[0];
+  return (value) => {
+    iterate.forEach(active, (ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else {
+        ref.current = value;
+      }
+    });
+  };
+}
+
+// ../../lib/primitive/src/constants/aria/global-aria-attributes.ts
+var GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "aria-atomic",
+  "aria-busy",
+  "aria-controls",
+  "aria-current",
+  "aria-describedby",
+  "aria-details",
+  "aria-disabled",
+  "aria-errormessage",
+  "aria-flowto",
+  "aria-hidden",
+  "aria-keyshortcuts",
+  "aria-label",
+  "aria-labelledby",
+  "aria-live",
+  "aria-owns",
+  "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",
+  // 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",
+  // 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",
+  "navigation",
+  "complementary",
+  "contentinfo",
+  "banner"
+];
+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",
+    /* @__PURE__ */ new Set([
+      "application",
+      "combobox",
+      "grid",
+      "group",
+      "listbox",
+      "menu",
+      "menubar",
+      "radiogroup",
+      "spinbutton",
+      "tablist",
+      "toolbar",
+      "textbox",
+      "tree",
+      "treegrid"
+    ])
+  ],
+  ["aria-autocomplete", /* @__PURE__ */ new Set(["combobox", "searchbox", "textbox"])],
+  [
+    "aria-checked",
+    /* @__PURE__ */ new Set(["checkbox", "menuitemcheckbox", "option", "radio", "switch", "treeitem"])
+  ],
+  ["aria-colcount", /* @__PURE__ */ new Set(["grid", "table", "treegrid"])],
+  ["aria-colindex", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "row", "rowheader"])],
+  ["aria-colspan", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "rowheader"])],
+  [
+    "aria-expanded",
+    /* @__PURE__ */ new Set([
+      "button",
+      "combobox",
+      "gridcell",
+      "listbox",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "row",
+      "rowheader",
+      "tab",
+      "treeitem"
+    ])
+  ],
+  [
+    "aria-haspopup",
+    /* @__PURE__ */ new Set([
+      "button",
+      "combobox",
+      "gridcell",
+      "listbox",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "tab",
+      "treeitem"
+    ])
+  ],
+  ["aria-level", /* @__PURE__ */ new Set(["heading", "listitem", "row", "treeitem"])],
+  ["aria-modal", /* @__PURE__ */ new Set(["alertdialog", "dialog"])],
+  ["aria-multiline", /* @__PURE__ */ new Set(["textbox"])],
+  ["aria-multiselectable", /* @__PURE__ */ new Set(["grid", "listbox", "tablist", "tree", "treegrid"])],
+  [
+    "aria-orientation",
+    /* @__PURE__ */ new Set(["scrollbar", "select", "separator", "slider", "tablist", "toolbar", "tree"])
+  ],
+  ["aria-placeholder", /* @__PURE__ */ new Set(["searchbox", "textbox"])],
+  [
+    "aria-posinset",
+    /* @__PURE__ */ new Set([
+      "article",
+      "listitem",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "option",
+      "radio",
+      "row",
+      "tab"
+    ])
+  ],
+  ["aria-pressed", /* @__PURE__ */ new Set(["button"])],
+  [
+    "aria-readonly",
+    /* @__PURE__ */ new Set([
+      "combobox",
+      "grid",
+      "gridcell",
+      "listbox",
+      "radiogroup",
+      "slider",
+      "spinbutton",
+      "textbox",
+      "tree",
+      "treegrid"
+    ])
+  ],
+  [
+    "aria-required",
+    /* @__PURE__ */ new Set([
+      "combobox",
+      "gridcell",
+      "listbox",
+      "radiogroup",
+      "spinbutton",
+      "textbox",
+      "tree",
+      "treegrid"
+    ])
+  ],
+  ["aria-rowcount", /* @__PURE__ */ new Set(["grid", "table", "treegrid"])],
+  ["aria-rowindex", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "row", "rowheader"])],
+  ["aria-rowspan", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "rowheader"])],
+  [
+    "aria-selected",
+    /* @__PURE__ */ new Set(["columnheader", "gridcell", "option", "row", "rowheader", "tab", "treeitem"])
+  ],
+  [
+    "aria-setsize",
+    /* @__PURE__ */ new Set([
+      "article",
+      "listitem",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "option",
+      "radio",
+      "row",
+      "tab"
+    ])
+  ],
+  ["aria-sort", /* @__PURE__ */ new Set(["columnheader", "rowheader"])],
+  [
+    "aria-valuemax",
+    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
+  ],
+  [
+    "aria-valuemin",
+    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
+  ],
+  [
+    "aria-valuenow",
+    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
+  ],
+  [
+    "aria-valuetext",
+    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
+  ]
+]);
+
+// ../../lib/primitive/src/constants/primitive/slot-name.ts
+var SLOT_NAME = "Slot";
+
+// ../../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);
+}
+function isAriaAttributeValidForRole(attr, role) {
+  const allowedRoles = ROLE_RESTRICTED_ATTRIBUTES.get(attr);
+  if (isUndefined(allowedRoles)) return true;
+  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]);
+}
+function isStandaloneTag(tag) {
+  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
+  return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[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;
+}
+
+// ../../lib/primitive/src/guards/children/component-id.ts
+var COMPONENT_ID = /* @__PURE__ */ Symbol.for("praxis.component-id");
+var COMPONENT_DEFAULT_TAG = /* @__PURE__ */ Symbol.for("praxis.component-default-tag");
+
+// ../../lib/primitive/src/guards/children/is-tag.ts
+function getAsProp(child) {
+  if (!isObject(child) || !("props" in child)) return void 0;
+  const props = child.props;
+  if (!isObject(props)) return void 0;
+  const as = props.as;
+  return isString(as) && as !== "" ? as : void 0;
+}
+function getTag(child) {
+  if (!isObject(child) || !("type" in child)) return void 0;
+  const t = child.type;
+  if (isString(t)) return t;
+  if (typeof t === "function" || isObject(t)) {
+    const defaultTag = t[COMPONENT_DEFAULT_TAG];
+    if (!isString(defaultTag)) return void 0;
+    return getAsProp(child) ?? defaultTag;
+  }
+  return void 0;
+}
+function isTag(...args) {
+  if (isString(args[0])) {
+    const set3 = new Set(args);
+    return (child2) => {
+      const tag2 = getTag(child2);
+      return tag2 !== void 0 && set3.has(tag2);
+    };
+  }
+  const [child, ...tags] = args;
+  const set2 = new Set(tags);
+  const tag = getTag(child);
+  return tag !== void 0 && set2.has(tag);
+}
+
+// ../../lib/contract/src/aria/aria-role-policy.ts
+function getImplicitRole(tag, props) {
+  if (tag in IMPLICIT_ROLE_RECORD) return IMPLICIT_ROLE_RECORD[tag];
+  if (tag === "input") return getInputImplicitRole(props?.type);
+  if (tag === "img") return props?.alt === "" ? "none" : "img";
+  if (tag === "section" || tag === "form") {
+    return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
+  }
+  return void 0;
+}
+
+// ../../lib/contract/src/strict/invariant-base.ts
+var InvariantBase = class {
+  diagnostics;
+  constructor(diagnostics) {
+    this.diagnostics = diagnostics;
+  }
+  get active() {
+    return this.diagnostics.active;
+  }
+  violate(input) {
+    this.diagnostics.error(input);
+  }
+  // Always caps at warn — never throws. ARIA 'warning' violations route here
+  // so they surface even in strict='throw' mode without aborting a render.
+  warn(input) {
+    this.diagnostics.warn(input);
+  }
+  invariant(condition, input) {
+    if (!condition) this.violate(input);
+  }
+};
+
+// ../../lib/diagnostics/src/category.ts
+var DiagnosticCategory = /* @__PURE__ */ ((DiagnosticCategory2) => {
+  DiagnosticCategory2[DiagnosticCategory2["Contract"] = 0] = "Contract";
+  DiagnosticCategory2[DiagnosticCategory2["HTML"] = 1] = "HTML";
+  DiagnosticCategory2[DiagnosticCategory2["ARIA"] = 2] = "ARIA";
+  DiagnosticCategory2[DiagnosticCategory2["Composition"] = 3] = "Composition";
+  DiagnosticCategory2[DiagnosticCategory2["Rendering"] = 4] = "Rendering";
+  DiagnosticCategory2[DiagnosticCategory2["Accessibility"] = 5] = "Accessibility";
+  DiagnosticCategory2[DiagnosticCategory2["Performance"] = 6] = "Performance";
+  DiagnosticCategory2[DiagnosticCategory2["Internal"] = 7] = "Internal";
+  DiagnosticCategory2[DiagnosticCategory2["Deprecation"] = 8] = "Deprecation";
+  DiagnosticCategory2[DiagnosticCategory2["Lint"] = 9] = "Lint";
+  return DiagnosticCategory2;
+})(DiagnosticCategory || {});
+
+// ../../lib/diagnostics/src/error.ts
+var PraxisError = class extends Error {
+  diagnostic;
+  constructor(diagnostic) {
+    super(diagnostic.message);
+    this.name = "PraxisError";
+    this.diagnostic = diagnostic;
+  }
+};
+
+// ../../lib/diagnostics/src/severity.ts
+var Severity = /* @__PURE__ */ ((Severity2) => {
+  Severity2[Severity2["Debug"] = 0] = "Debug";
+  Severity2[Severity2["Info"] = 1] = "Info";
+  Severity2[Severity2["Warning"] = 2] = "Warning";
+  Severity2[Severity2["Error"] = 3] = "Error";
+  Severity2[Severity2["Fatal"] = 4] = "Fatal";
+  return Severity2;
+})(Severity || {});
+
+// ../../lib/diagnostics/src/policy.ts
+var DefaultPolicy = class {
+  reportThreshold;
+  throwThreshold;
+  constructor({
+    reportThreshold = 1 /* Info */,
+    throwThreshold = 4 /* Fatal */
+  } = {}) {
+    this.reportThreshold = reportThreshold;
+    this.throwThreshold = throwThreshold;
+  }
+  resolve(diagnostic) {
+    if (diagnostic.severity >= this.throwThreshold) return 2 /* Throw */;
+    if (diagnostic.severity >= this.reportThreshold) return 1 /* Report */;
+    return 0 /* Ignore */;
+  }
+};
+
+// ../../lib/diagnostics/src/diagnostics.ts
+var Diagnostics = class {
+  reporter;
+  policy;
+  // Pre-computed at construction time: true if Warning-level diagnostics are not ignored.
+  active;
+  constructor(reporter, policy = new DefaultPolicy()) {
+    this.reporter = reporter;
+    this.policy = policy;
+    this.active = policy.resolve({ severity: 2 /* Warning */ }) !== 0 /* Ignore */;
+  }
+  report(diagnostic) {
+    const enforcement = this.policy.resolve(diagnostic);
+    if (enforcement === 0 /* Ignore */) return diagnostic;
+    if (enforcement === 2 /* Throw */) throw new PraxisError(diagnostic);
+    this.reporter.report(diagnostic);
+    return diagnostic;
+  }
+  warn(input) {
+    return this.report({ ...input, severity: 2 /* Warning */ });
+  }
+  error(input) {
+    return this.report({ ...input, severity: 3 /* Error */ });
+  }
+  info(input) {
+    return this.report({ ...input, severity: 1 /* Info */ });
+  }
+};
+
+// ../../lib/diagnostics/src/formatter.ts
+function formatDiagnostic(diagnostic) {
+  const level = Severity[diagnostic.severity];
+  const category = DiagnosticCategory[diagnostic.category];
+  const prefix = category !== void 0 ? `[${category}] ` : "";
+  return `${level} ${diagnostic.code}: ${prefix}${diagnostic.message}`;
+}
+
+// ../../lib/diagnostics/src/console-reporter.ts
+var ConsoleReporter = class {
+  report(diagnostic) {
+    const message = formatDiagnostic(diagnostic);
+    switch (diagnostic.severity) {
+      case 0 /* Debug */:
+        console.debug(message);
+        break;
+      case 1 /* Info */:
+        console.info(message);
+        break;
+      case 2 /* Warning */:
+        console.warn(message);
+        break;
+      case 3 /* Error */:
+      case 4 /* Fatal */:
+        console.error(message);
+        break;
+    }
+  }
+};
+
+// ../../lib/diagnostics/src/null-reporter.ts
+var nullReporter = {
+  report() {
+  }
+};
+
+// ../../lib/diagnostics/src/presets.ts
+var ignoreAllPolicy = {
+  resolve(_) {
+    return 0 /* Ignore */;
+  }
+};
+var warnOnlyReporter = {
+  report(diagnostic) {
+    console.warn(formatDiagnostic(diagnostic));
+  }
+};
+var silentDiagnostics = new Diagnostics(nullReporter, ignoreAllPolicy);
+var warnDiagnostics = new Diagnostics(
+  warnOnlyReporter,
+  new DefaultPolicy({ reportThreshold: 2 /* Warning */, throwThreshold: 4 /* Fatal */ })
+);
+var throwDiagnostics = new Diagnostics(
+  new ConsoleReporter(),
+  new DefaultPolicy({ reportThreshold: 2 /* Warning */, throwThreshold: 3 /* Error */ })
+);
+
+// ../../lib/contract/src/diagnostics/aria.ts
+var AriaDiagnostics = {
+  /** Generic bridge for violations produced by external AriaRule functions. */
+  fromViolation(v) {
+    return {
+      code: "ARIA2002" /* AriaViolation */,
+      category: 2 /* ARIA */,
+      message: v.message
+    };
+  },
+  attributeInvalid(key, role) {
+    return {
+      code: "ARIA2003" /* AriaAttributeInvalid */,
+      category: 2 /* ARIA */,
+      message: `"${key}" is not valid on role="${role}". It will be removed.`,
+      rationale: "Invalid ARIA attributes are ignored by assistive technology and may trigger accessibility-tree warnings in browser devtools.",
+      suggestions: [
+        {
+          title: "Remove the attribute",
+          description: `"${key}" is not in the allowed attribute set for role="${role}".`
+        }
+      ]
+    };
+  },
+  missingLiveRegion(role, impliedLive) {
+    return {
+      code: "ARIA2004" /* AriaMissingLiveRegion */,
+      category: 2 /* ARIA */,
+      message: `role="${role}" implies aria-live="${impliedLive}" but it is missing. It has been injected.`,
+      rationale: "Live-region roles announce dynamic content changes to screen readers. Without aria-live the politeness level is unspecified and announcements may be silent.",
+      suggestions: [
+        {
+          title: `Add aria-live="${impliedLive}"`,
+          description: `role="${role}" conventionally implies aria-live="${impliedLive}".`,
+          fix: `aria-live="${impliedLive}"`
+        }
+      ]
+    };
+  },
+  missingAtomic(role) {
+    return {
+      code: "ARIA2005" /* AriaMissingAtomic */,
+      category: 2 /* ARIA */,
+      message: `role="${role}" is a live region. Consider setting aria-atomic="true" if the full region should be announced as a unit, or aria-atomic="false" if only changed nodes should be read.`,
+      rationale: "aria-atomic controls whether assistive technology announces the entire live region or only the changed nodes. Omitting it leaves the behaviour browser-defined."
+    };
+  },
+  relevantInvalidTokens(invalid) {
+    const quoted = invalid.map((t) => `"${t}"`).join(", ");
+    return {
+      code: "ARIA2006" /* AriaRelevantInvalidToken */,
+      category: 2 /* ARIA */,
+      message: `aria-relevant contains invalid token(s): ${quoted}. Valid tokens are: additions, removals, text, all.`,
+      rationale: "aria-relevant accepts a space-separated list of change types. Unrecognised tokens are silently ignored by assistive technology, making the attribute ineffective.",
+      suggestions: [
+        {
+          title: "Use only valid tokens",
+          description: "Valid values are: additions, removals, text, all (or a space-separated combination)."
+        }
+      ]
+    };
+  },
+  relevantSuperseded() {
+    return {
+      code: "ARIA2007" /* AriaRelevantSuperseded */,
+      category: 2 /* ARIA */,
+      message: 'aria-relevant includes "all" alongside other tokens. "all" supersedes additions, removals, and text \u2014 use aria-relevant="all" alone.',
+      rationale: '"all" is equivalent to "additions removals text". Combining it with other tokens is redundant and may confuse readers of the markup.',
+      suggestions: [
+        {
+          title: 'Use aria-relevant="all"',
+          fix: 'aria-relevant="all"'
+        }
+      ]
+    };
+  },
+  missingAccessibleName(tag) {
+    return {
+      code: "ARIA2009" /* AriaMissingAccessibleName */,
+      category: 2 /* ARIA */,
+      message: `<${tag}> has no accessible name. Add aria-label or aria-labelledby.`,
+      rationale: "Elements with a landmark or interactive role must have an accessible name so that assistive technology can identify them when presenting the page outline.",
+      suggestions: [
+        {
+          title: "Add aria-label",
+          description: `Add aria-label="\u2026" directly to the <${tag}> element.`
+        },
+        {
+          title: "Add aria-labelledby",
+          description: "Point aria-labelledby at the id of an existing heading or label element."
+        }
+      ]
+    };
+  },
+  attributeOnPresentational(attr, tag) {
+    return {
+      code: "ARIA2010" /* AriaAttributeOnPresentational */,
+      category: 2 /* ARIA */,
+      message: `"${attr}" is not allowed on a presentational <${tag}>. Presentational elements are invisible to assistive technology.`,
+      rationale: 'role="none" and role="presentation" (including <img alt="">) remove an element from the accessibility tree. ARIA attributes on such elements are ignored by assistive technology.',
+      suggestions: [
+        {
+          title: "Remove the attribute",
+          description: `"${attr}" has no effect when the element has role="none" or role="presentation".`
+        }
+      ]
+    };
+  },
+  ariaHiddenOnFocusable(tag) {
+    return {
+      code: "ARIA2011" /* AriaHiddenOnFocusable */,
+      category: 2 /* ARIA */,
+      message: `aria-hidden="true" must not be used on focusable <${tag}> elements. Screen reader users who navigate by keyboard will encounter the element but receive no information about it.`,
+      rationale: 'aria-hidden removes an element from the accessibility tree while leaving it keyboard-reachable. This creates a "ghost" \u2014 a focusable element assistive technology cannot describe.',
+      suggestions: [
+        {
+          title: "Remove aria-hidden",
+          description: "If the element should be hidden from all users, use the HTML hidden attribute or CSS display:none instead."
+        },
+        {
+          title: "Make the element non-focusable",
+          description: 'If the element is intentionally decorative, add tabindex="-1" and disable it so it is not reachable by keyboard.'
+        }
+      ]
+    };
+  },
+  invalidAttributeValue(attr, value, expected) {
+    const got = value === null ? "null" : value === void 0 ? "undefined" : typeof value === "string" ? `"${value}"` : String(value);
+    return {
+      code: "ARIA2013" /* AriaInvalidAttributeValue */,
+      category: 2 /* ARIA */,
+      message: `"${attr}" has an invalid value (${got}). Expected: ${expected}.`,
+      rationale: "ARIA attributes with invalid values are silently ignored by assistive technology, making the markup semantically inert.",
+      suggestions: [
+        {
+          title: `Use a valid value for ${attr}`,
+          description: `Valid values are: ${expected}.`
+        }
+      ]
+    };
+  },
+  redundantAriaLevel(tag, level) {
+    return {
+      code: "ARIA2014" /* AriaRedundantLevelAttribute */,
+      category: 2 /* ARIA */,
+      message: `aria-level="${level}" is redundant on <${tag}>: the element already has an implicit heading level of ${level}. Remove the attribute.`,
+      rationale: 'Restating the implicit aria-level adds noise without semantic value. Use aria-level only to override the native heading level (e.g. aria-level="3" on <h2>).',
+      suggestions: [
+        {
+          title: "Remove aria-level",
+          description: `<${tag}> already implies aria-level="${level}".`
+        }
+      ]
+    };
+  },
+  requiredProperty(attr, role) {
+    return {
+      code: "ARIA2012" /* AriaRequiredProperty */,
+      category: 2 /* ARIA */,
+      message: `"${attr}" is required for role="${role}" but is missing.`,
+      rationale: `WAI-ARIA 1.2 specifies required states and properties for certain roles. Without "${attr}", assistive technology cannot correctly communicate the element's state to users.`,
+      suggestions: [
+        {
+          title: `Add ${attr}`,
+          description: `role="${role}" requires "${attr}" to be present.`
+        }
+      ]
+    };
+  },
+  invalidRole(role, tag) {
+    return {
+      code: "ARIA2008" /* AriaInvalidRole */,
+      category: 2 /* ARIA */,
+      message: `Invalid role "${role ?? ""}" on <${tag}>.`,
+      rationale: "An unrecognised or misapplied ARIA role is ignored by assistive technology and may degrade the accessibility of the element."
+    };
+  }
+};
+
+// ../../lib/contract/src/diagnostics/contract.ts
+var ContractDiagnostics = {
+  unexpectedChild(typeName, index, context) {
+    return {
+      code: "COMP1004" /* UnexpectedChild */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: unexpected child "${typeName}" at index ${index}.`
+    };
+  },
+  ambiguousChild(typeName, index, ruleNames, context) {
+    const quoted = ruleNames.map((n) => `"${n}"`).join(" and ");
+    return {
+      code: "COMP1005" /* AmbiguousChild */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: child "${typeName}" at index ${index} matches multiple child rules: ${quoted}.`
+    };
+  },
+  cardinalityMin(ruleName, min, context) {
+    return {
+      code: "COMP1006" /* CardinalityMin */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: "${ruleName}" requires at least ${min}.`
+    };
+  },
+  cardinalityMax(ruleName, max, context) {
+    return {
+      code: "COMP1007" /* CardinalityMax */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: "${ruleName}" allows at most ${max}.`
+    };
+  },
+  positionViolation(ruleName, position, index, context) {
+    return {
+      code: "COMP1008" /* PositionViolation */,
+      category: 0 /* Contract */,
+      component: context,
+      message: `${context}: "${ruleName}" must be ${position}, got index ${index}`
+    };
+  },
+  unknownVariantDim(component, label, dim) {
+    return {
+      code: "COMP1010" /* ContractUnknownVariantDim */,
+      category: 0 /* Contract */,
+      message: `${component}: ${label} references unknown variant "${dim}".`
+    };
+  },
+  unknownVariantValue(component, label, dim, value, valid) {
+    return {
+      code: "COMP1011" /* ContractUnknownVariantValue */,
+      category: 0 /* Contract */,
+      message: `${component}: ${label} sets "${dim}" to unknown value "${value}" (valid: ${valid.join(", ")}).`
+    };
+  },
+  unknownRecipeKey(component, key) {
+    return {
+      code: "COMP1012" /* ContractUnknownRecipeKey */,
+      category: 0 /* Contract */,
+      message: `${component} Unknown recipeKey "${key}" \u2014 no preset with that name exists.`
+    };
+  },
+  invalidVariantValue(component, key, value) {
+    return {
+      code: "COMP1013" /* ContractInvalidVariantValue */,
+      category: 0 /* Contract */,
+      message: `${component} Variant "${key}=${value}" is not a defined value for the "${key}" dimension.`
+    };
+  },
+  allowedAsViolation(tag, allowedAs, component) {
+    const allowed = allowedAs.map((t) => `"${String(t)}"`).join(", ");
+    return {
+      code: "COMP1009" /* AllowedAsViolation */,
+      category: 0 /* Contract */,
+      component,
+      message: `<${component}>: "as" prop received "${tag}" but only [${allowed}] are allowed.`
+    };
+  }
+};
+
+// ../../lib/contract/src/diagnostics/html.ts
+var HtmlDiagnostics = {
+  emptyRole(tag) {
+    return {
+      code: "HTML3002" /* HtmlEmptyRole */,
+      category: 1 /* HTML */,
+      message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`
+    };
+  },
+  implicitRoleRedundant(tag, implicitRole) {
+    return {
+      code: "HTML3003" /* HtmlImplicitRoleRedundant */,
+      category: 1 /* HTML */,
+      message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
+    };
+  },
+  implicitRoleOverride(tag, implicitRole, role) {
+    return {
+      code: "HTML3004" /* HtmlImplicitRoleOverride */,
+      category: 1 /* HTML */,
+      message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
+    };
+  },
+  standaloneRegionOverride(tag, implicitRole) {
+    return {
+      code: "HTML3005" /* HtmlStandaloneRegionOverride */,
+      category: 1 /* HTML */,
+      message: `<${tag}> is a self-contained element with implicit role="${implicitRole}". Assigning role="region" has been removed.`
+    };
+  },
+  landmarkRoleOverride(tag, implicitRole, role) {
+    return {
+      code: "HTML3006" /* HtmlLandmarkRoleOverride */,
+      category: 1 /* HTML */,
+      message: `<${tag}> has a fixed landmark role="${implicitRole}". role="${role}" overrides it and confuses assistive technology. The override has been removed.`
+    };
+  },
+  invalidChild(child, parent, allowed) {
+    return {
+      code: "HTML3007" /* HtmlInvalidChild */,
+      category: 1 /* HTML */,
+      message: `<${child}> is not a valid direct child of <${parent}>. Allowed: ${allowed}.`
+    };
+  }
+};
+
+// ../../lib/contract/src/diagnostics/slot.ts
+var SlotDiagnostics = {
+  exclusive(name) {
+    return {
+      code: "SLOT1001" /* SlotExclusive */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: "as" and "asChild" are mutually exclusive`
+    };
+  },
+  singleChildRequired(name, elementTerm) {
+    return {
+      code: "SLOT1002" /* SlotSingleChild */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: asChild requires a ${elementTerm} child`
+    };
+  },
+  singleChildExceeded(name, elementTerm, count) {
+    return {
+      code: "SLOT1002" /* SlotSingleChild */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: asChild requires exactly one ${elementTerm} child, got ${count}`
+    };
+  },
+  discardedChildren(name, elementTerm, count) {
+    const suffix = count === 1 ? "" : "ren";
+    return {
+      code: "SLOT1003" /* SlotDiscardedChildren */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: asChild discarded ${count} non-element child${suffix} \u2014 only ${elementTerm}s are valid asChild children.`
+    };
+  },
+  renderFnRequired(name, received) {
+    return {
+      code: "SLOT1004" /* SlotRenderFn */,
+      category: 0 /* Contract */,
+      component: name,
+      message: `${name}: asChild requires a render function as children, got ${received}`
+    };
+  }
+};
+
+// ../../lib/contract/src/aria/polymorphic-validator.ts
+var VALID = [{ valid: true }];
+function isIntrinsicTag(tag) {
+  return isString(tag);
+}
+function omitProp(obj, key) {
+  const { [key]: _, ...rest } = obj;
+  return rest;
+}
+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(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: d.message,
+            diagnostic: d,
+            tag,
+            role: "",
+            attribute: void 0,
+            severity: "warning",
+            phase: "evaluate"
+          }
+        ]
+      }
+    };
+  }
+  static #deriveContext(tag, props) {
+    if (!isIntrinsicTag(tag)) return { proceed: false, result: { props, violations: [] } };
+    const implicitRole = getImplicitRole(tag, props);
+    const hasRole2 = implicitRole != null || isString(props.role) && props.role.length > 0;
+    if (!hasRole2) return { proceed: false, result: { props, violations: [] } };
+    const normalized = _AriaPolicyEngine.#normalizeEmptyRole(tag, props);
+    if (normalized.normalized) return { proceed: false, result: normalized.result };
+    const effectiveRole = props.role ?? implicitRole;
+    return {
+      proceed: true,
+      tag,
+      implicitRole,
+      effectiveRole,
+      context: { tag, props, implicitRole, effectiveRole }
+    };
+  }
+  static #runRules(rules, context) {
+    const violations = [];
+    const fixes = [];
+    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) {
+    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);
+    if (!derived.proceed) return derived.result;
+    const { tag: narrowedTag, implicitRole, context } = derived;
+    const { violations, fixes } = _AriaPolicyEngine.#runRules(
+      _AriaPolicyEngine.#getRules(context),
+      context
+    );
+    const next = _AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, props, fixes);
+    return { props: next, violations };
+  }
+  static #evaluateWithRules(tag, props, extraRules) {
+    const derived = _AriaPolicyEngine.#deriveContext(tag, props);
+    if (!derived.proceed) return derived.result;
+    const { tag: narrowedTag, implicitRole, context } = derived;
+    const { violations, fixes } = _AriaPolicyEngine.#runRules(
+      [..._AriaPolicyEngine.#getRules(context), ...extraRules],
+      context
+    );
+    const next = _AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, props, fixes);
+    return { props: next, violations };
+  }
+  report(violations) {
+    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
+  // so cache hits survive re-renders that only change non-aria props.
+  // Note: #extraRules are NOT included in the key — each engine instance has its own Map,
+  // so two engines with different rules never share cache entries. If caching ever becomes
+  // static/shared, rule identity would need to be folded into the key.
+  static #createPlanKey(tag, props) {
+    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 = [];
+    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 = {};
+    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) {
+    const hasRemovals = removals.size > 0;
+    const hasUpdates = Object.keys(updates).length > 0;
+    if (!hasRemovals && !hasUpdates) return props;
+    const next = {};
+    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 (!isNull(key)) {
+      const cached = this.#planCache.get(key);
+      if (cached !== void 0) {
+        this.#planCache.delete(key);
+        this.#planCache.set(key, cached);
+        if (cached.violations.length > 0) this.report(cached.violations);
+        return {
+          props: _AriaPolicyEngine.#applyPlan(props, cached.removals, cached.updates),
+          violations: cached.violations
+        };
+      }
+    }
+    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 (!isNull(key)) {
+      const { removals, updates } = _AriaPolicyEngine.#computePlan(
+        props,
+        result.props
+      );
+      const plan = { removals, updates, violations: result.violations };
+      this.#planCache.set(key, plan);
+      if (this.#planCache.size > _AriaPolicyEngine.#MAX_CACHE) {
+        const lru = this.#planCache.keys().next().value;
+        if (lru !== void 0) this.#planCache.delete(lru);
+      }
+    }
+    return result;
+  }
+  static #hasRole(props) {
+    return isString(props.role) && props.role.length > 0;
+  }
+  static #applyFixes(tag, implicitRole, props, fixes) {
+    if (fixes.length === 0) return props;
+    const sorted = [...fixes].sort((a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity));
+    let next = props;
+    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 = {
+    kind: "removeRole",
+    apply: ({ props }) => {
+      if (!("role" in props)) return { applied: false, next: props };
+      return { applied: true, next: omitProp(props, "role"), previous: props };
+    }
+  };
+  static #makeRemoveAttributeFix(attr) {
+    const cached = _AriaPolicyEngine.#removeAttributeFixCache.get(attr);
+    if (cached) return cached;
+    const fix = {
+      kind: `removeAttribute:${attr}`,
+      apply: ({ props }) => {
+        if (!(attr in props)) return { applied: false, next: props };
+        return { applied: true, next: omitProp(props, attr), previous: props };
+      }
+    };
+    _AriaPolicyEngine.#removeAttributeFixCache.set(attr, fix);
+    return fix;
+  }
+  // Snapshot diagnostic model: all rules evaluate against the same (tag, props, implicitRole) snapshot.
+  static #pipeline = [
+    _AriaPolicyEngine.#checkInvalidRoleOverride,
+    _AriaPolicyEngine.#checkRedundantRole,
+    _AriaPolicyEngine.#checkStandaloneRegion,
+    _AriaPolicyEngine.#checkAriaAttributeValues,
+    _AriaPolicyEngine.#checkInvalidAriaAttributes,
+    _AriaPolicyEngine.#checkRequiredAriaProperties,
+    _AriaPolicyEngine.#checkNameRequiredRoles,
+    _AriaPolicyEngine.#checkRedundantAriaLevel,
+    _AriaPolicyEngine.#checkMissingLiveRegion,
+    _AriaPolicyEngine.#checkMissingAtomic,
+    _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,
+    props,
+    implicitRole
+  }) {
+    const role = props.role;
+    if (!implicitRole || !role || role === implicitRole) return VALID;
+    if (isStrongImplicitRole(tag) && role === "region") {
+      return [
+        {
+          valid: false,
+          fixable: true,
+          severity: "error",
+          fix: _AriaPolicyEngine.#removeRole,
+          diagnostic: HtmlDiagnostics.implicitRoleOverride(tag, implicitRole, role)
+        }
+      ];
+    }
+    return VALID;
+  }
+  static #checkRedundantRole({ tag, props, implicitRole }) {
+    const role = props.role;
+    if (!implicitRole || !role || role !== implicitRole) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: "warning",
+        fix: _AriaPolicyEngine.#removeRole,
+        diagnostic: HtmlDiagnostics.implicitRoleRedundant(tag, implicitRole)
+      }
+    ];
+  }
+  static #checkStandaloneRegion({ tag, props, implicitRole }) {
+    const role = props.role;
+    if (role !== "region") return VALID;
+    if (!isStandaloneTag(tag)) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: "error",
+        fix: _AriaPolicyEngine.#removeRole,
+        diagnostic: HtmlDiagnostics.standaloneRegionOverride(tag, implicitRole ?? tag)
+      }
+    ];
+  }
+  static #checkInvalidAriaAttributes({
+    tag,
+    props,
+    effectiveRole
+  }) {
+    if (effectiveRole === "none" || effectiveRole === "presentation") return VALID;
+    const results = [];
+    iterate.forEachEntry(props, (key) => {
+      if (!key.startsWith("aria-")) return;
+      if (isGlobalAriaAttribute(key)) return;
+      if (isAriaAttributeValidForRole(key, effectiveRole)) return;
+      results.push({
+        valid: false,
+        severity: "warning",
+        fixable: true,
+        attribute: key,
+        diagnostic: AriaDiagnostics.attributeInvalid(key, effectiveRole ?? tag),
+        fix: _AriaPolicyEngine.#makeRemoveAttributeFix(key)
+      });
+    });
+    return results;
+  }
+  // ─── ARIA attribute value validation ──────────────────────────────────────
+  // Accepted value shapes for typed ARIA attributes.
+  // Attributes not in this map are unconstrained (arbitrary string values permitted).
+  static #ARIA_VALUE_TYPES = /* @__PURE__ */ new Map([
+    // Boolean (true | false)
+    ["aria-atomic", { kind: "boolean" }],
+    ["aria-busy", { kind: "boolean" }],
+    ["aria-disabled", { kind: "boolean" }],
+    ["aria-expanded", { kind: "boolean" }],
+    ["aria-hidden", { kind: "boolean" }],
+    ["aria-modal", { kind: "boolean" }],
+    ["aria-multiline", { kind: "boolean" }],
+    ["aria-multiselectable", { kind: "boolean" }],
+    ["aria-readonly", { kind: "boolean" }],
+    ["aria-required", { kind: "boolean" }],
+    ["aria-selected", { kind: "boolean" }],
+    // Tristate (true | false | mixed)
+    ["aria-checked", { kind: "tristate" }],
+    ["aria-pressed", { kind: "tristate" }],
+    // Numeric (any finite number)
+    ["aria-valuenow", { kind: "number" }],
+    ["aria-valuemin", { kind: "number" }],
+    ["aria-valuemax", { kind: "number" }],
+    // Integer with optional range
+    ["aria-level", { kind: "integer", min: 1, max: 6 }],
+    ["aria-posinset", { kind: "integer", min: 1 }],
+    ["aria-setsize", { kind: "integer", min: -1 }],
+    ["aria-rowcount", { kind: "integer", min: -1 }],
+    ["aria-colcount", { kind: "integer", min: -1 }],
+    ["aria-rowindex", { kind: "integer", min: 1 }],
+    ["aria-colindex", { kind: "integer", min: 1 }],
+    ["aria-rowspan", { kind: "integer", min: 0 }],
+    ["aria-colspan", { kind: "integer", min: 0 }],
+    // Enum (specific allowed tokens)
+    ["aria-autocomplete", { kind: "enum", values: /* @__PURE__ */ new Set(["inline", "list", "both", "none"]) }],
+    [
+      "aria-current",
+      {
+        kind: "enum",
+        values: /* @__PURE__ */ new Set(["page", "step", "location", "date", "time", "true", "false"])
+      }
+    ],
+    [
+      "aria-haspopup",
+      {
+        kind: "enum",
+        values: /* @__PURE__ */ new Set(["false", "true", "menu", "listbox", "tree", "grid", "dialog"])
+      }
+    ],
+    ["aria-invalid", { kind: "enum", values: /* @__PURE__ */ new Set(["grammar", "false", "spelling", "true"]) }],
+    ["aria-live", { kind: "enum", values: /* @__PURE__ */ new Set(["assertive", "off", "polite"]) }],
+    [
+      "aria-orientation",
+      { kind: "enum", values: /* @__PURE__ */ new Set(["horizontal", "vertical", "undefined"]) }
+    ],
+    ["aria-sort", { kind: "enum", values: /* @__PURE__ */ new Set(["ascending", "descending", "none", "other"]) }]
+  ]);
+  static #isValidAriaValue(value, type) {
+    switch (type.kind) {
+      case "boolean":
+        return value === "true" || value === "false" || value === true || value === false;
+      case "tristate":
+        return value === "true" || value === "false" || value === "mixed" || value === true || value === false;
+      case "number": {
+        if (typeof value === "number") return Number.isFinite(value);
+        if (typeof value !== "string") return false;
+        const n = parseFloat(value);
+        return Number.isFinite(n);
+      }
+      case "integer": {
+        const n = typeof value === "number" ? value : typeof value === "string" ? parseInt(value, 10) : NaN;
+        if (!Number.isFinite(n) || !Number.isInteger(n)) return false;
+        if (type.min !== void 0 && n < type.min) return false;
+        if (type.max !== void 0 && n > type.max) return false;
+        return true;
+      }
+      case "enum":
+        return typeof value === "string" && type.values.has(value);
+    }
+  }
+  static #describeExpected(type) {
+    switch (type.kind) {
+      case "boolean":
+        return '"true" or "false"';
+      case "tristate":
+        return '"true", "false", or "mixed"';
+      case "number":
+        return "a finite number";
+      case "integer": {
+        const parts = ["an integer"];
+        if (type.min !== void 0 && type.max !== void 0)
+          parts.push(`between ${type.min} and ${type.max}`);
+        else if (type.min !== void 0) parts.push(`\u2265 ${type.min}`);
+        else if (type.max !== void 0) parts.push(`\u2264 ${type.max}`);
+        return parts.join(" ");
+      }
+      case "enum":
+        return [...type.values].map((v) => `"${v}"`).join(", ");
+    }
+  }
+  static #checkAriaAttributeValues({ props, effectiveRole }) {
+    if (effectiveRole === "none" || effectiveRole === "presentation") return VALID;
+    const results = [];
+    iterate.forEachEntry(props, (key, value) => {
+      if (!key.startsWith("aria-")) return;
+      const type = _AriaPolicyEngine.#ARIA_VALUE_TYPES.get(key);
+      if (type == null) return;
+      if (_AriaPolicyEngine.#isValidAriaValue(value, type)) return;
+      results.push({
+        valid: false,
+        fixable: true,
+        severity: "warning",
+        attribute: key,
+        diagnostic: AriaDiagnostics.invalidAttributeValue(
+          key,
+          value,
+          _AriaPolicyEngine.#describeExpected(type)
+        ),
+        fix: _AriaPolicyEngine.#makeRemoveAttributeFix(key)
+      });
+    });
+    return results;
+  }
+  // ─── Heading implicit level ────────────────────────────────────────────────
+  static #HEADING_IMPLICIT_LEVELS = /* @__PURE__ */ new Map([
+    ["h1", 1],
+    ["h2", 2],
+    ["h3", 3],
+    ["h4", 4],
+    ["h5", 5],
+    ["h6", 6]
+  ]);
+  static #checkRedundantAriaLevel({
+    tag,
+    props,
+    effectiveRole
+  }) {
+    if (effectiveRole === "none" || effectiveRole === "presentation") return VALID;
+    const implicitLevel = _AriaPolicyEngine.#HEADING_IMPLICIT_LEVELS.get(tag);
+    if (implicitLevel == null) return VALID;
+    const raw = props["aria-level"];
+    if (raw == null) return VALID;
+    const n = typeof raw === "number" ? raw : typeof raw === "string" ? parseInt(raw, 10) : NaN;
+    if (!Number.isFinite(n) || n !== implicitLevel) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: "warning",
+        attribute: "aria-level",
+        diagnostic: AriaDiagnostics.redundantAriaLevel(tag, implicitLevel),
+        fix: _AriaPolicyEngine.#makeRemoveAttributeFix("aria-level")
+      }
+    ];
+  }
+  // ─── Name-required roles ───────────────────────────────────────────────────
+  // Roles that always require an accessible name per WAI-ARIA APG.
+  // Dialog and landmark names are enforced via contracts (ariaContract) rather than
+  // the built-in pipeline so consumers can opt in; img is built in because role=img
+  // on any element (including bare <img>) is definitionally useless without a name.
+  static #NAME_REQUIRED_ROLES = /* @__PURE__ */ new Set(["img"]);
+  static #checkNameRequiredRoles({
+    tag,
+    props,
+    effectiveRole
+  }) {
+    if (!effectiveRole || !_AriaPolicyEngine.#NAME_REQUIRED_ROLES.has(effectiveRole)) return VALID;
+    if ("aria-label" in props || "aria-labelledby" in props) return VALID;
+    if (tag === "img" && typeof props.alt === "string" && props.alt.length > 0) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: false,
+        severity: "warning",
+        diagnostic: AriaDiagnostics.missingAccessibleName(tag)
+      }
+    ];
+  }
+  // WAI-ARIA 1.2 required states and properties, keyed by role.
+  // Source: https://www.w3.org/TR/wai-aria-1.2/#requiredState
+  static #REQUIRED_PROPERTIES = /* @__PURE__ */ new Map([
+    ["combobox", ["aria-expanded"]],
+    ["option", ["aria-selected"]],
+    ["slider", ["aria-valuenow"]],
+    ["scrollbar", ["aria-controls", "aria-valuenow"]],
+    ["spinbutton", ["aria-valuenow"]]
+  ]);
+  static #checkRequiredAriaProperties({
+    props,
+    effectiveRole
+  }) {
+    if (!effectiveRole) return VALID;
+    const required = _AriaPolicyEngine.#REQUIRED_PROPERTIES.get(effectiveRole);
+    if (required == null) return VALID;
+    const results = [];
+    iterate.forEach(required, (attr) => {
+      if (attr in props) return;
+      results.push({
+        valid: false,
+        fixable: false,
+        severity: "warning",
+        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: false,
+        severity: "error",
+        attribute: "aria-hidden",
+        diagnostic: AriaDiagnostics.ariaHiddenOnFocusable(tag)
+      }
+    ];
+  }
+  // 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 = [];
+    iterate.forEachEntry(props, (key) => {
+      if (!key.startsWith("aria-")) return;
+      if (key === "aria-hidden") return;
+      results.push({
+        valid: false,
+        fixable: true,
+        severity: "warning",
+        attribute: key,
+        diagnostic: AriaDiagnostics.attributeOnPresentational(key, tag),
+        fix: _AriaPolicyEngine.#makeRemoveAttributeFix(key)
+      });
+    });
+    return results;
+  }
+  // WAI-ARIA live region roles and their implied aria-live politeness values.
+  static #LIVE_REGION_ROLES = /* @__PURE__ */ new Map([
+    ["alert", "assertive"],
+    ["status", "polite"],
+    ["log", "polite"],
+    ["timer", "off"]
+  ]);
+  static #checkMissingLiveRegion({ effectiveRole, props }) {
+    if (!effectiveRole) return VALID;
+    const impliedLive = _AriaPolicyEngine.#LIVE_REGION_ROLES.get(effectiveRole);
+    if (!impliedLive) return VALID;
+    if ("aria-live" in props) return VALID;
+    const injectLive = {
+      kind: `injectLive:${effectiveRole}`,
+      apply: (ctx) => ({
+        applied: true,
+        next: { ...ctx.props, "aria-live": impliedLive },
+        previous: ctx.props
+      })
+    };
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: "warning",
+        fix: injectLive,
+        diagnostic: AriaDiagnostics.missingLiveRegion(effectiveRole, impliedLive)
+      }
+    ];
+  }
+  static #checkMissingAtomic({ effectiveRole, props }) {
+    if (!effectiveRole || !_AriaPolicyEngine.#LIVE_REGION_ROLES.has(effectiveRole)) return VALID;
+    if ("aria-atomic" in props) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: false,
+        severity: "warning",
+        diagnostic: AriaDiagnostics.missingAtomic(effectiveRole)
+      }
+    ];
+  }
+  static #VALID_RELEVANT_TOKENS = /* @__PURE__ */ new Set(["additions", "removals", "text", "all"]);
+  // Custom fix rules passed via `options.rules` must be pure functions of (tag, props) — the cache
+  // replays stored fixes against new prop objects, so fixes that close over external state will
+  // produce inconsistent results on cache hits.
+  static #normalizeRelevantAllFix = {
+    kind: "normalizeRelevantAll",
+    apply: ({ props: p }) => ({
+      applied: true,
+      next: { ...p, "aria-relevant": "all" },
+      previous: p
+    })
+  };
+  static #checkInvalidAriaRelevant({ props }) {
+    const relevant = props["aria-relevant"];
+    if (relevant === void 0) return VALID;
+    if (typeof relevant !== "string") return VALID;
+    const tokens = relevant.trim().split(/\s+/);
+    const invalid = tokens.filter((t) => !_AriaPolicyEngine.#VALID_RELEVANT_TOKENS.has(t));
+    if (invalid.length > 0) {
+      return [
+        {
+          valid: false,
+          fixable: true,
+          severity: "warning",
+          attribute: "aria-relevant",
+          diagnostic: AriaDiagnostics.relevantInvalidTokens(invalid),
+          fix: _AriaPolicyEngine.#makeRemoveAttributeFix("aria-relevant")
+        }
+      ];
+    }
+    if (tokens.includes("all") && tokens.length > 1) {
+      return [
+        {
+          valid: false,
+          fixable: true,
+          severity: "warning",
+          attribute: "aria-relevant",
+          diagnostic: AriaDiagnostics.relevantSuperseded(),
+          fix: _AriaPolicyEngine.#normalizeRelevantAllFix
+        }
+      ];
+    }
+    return VALID;
+  }
+};
+
+// ../../lib/contract/src/children/get-type-name.ts
+function getTypeName(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const primitive = typeof value;
+  if (primitive !== "object") {
+    return primitive;
+  }
+  const name = value.constructor?.name;
+  return typeof name === "string" && name !== "Object" ? name : "object";
+}
+
+// ../../lib/contract/src/children/normalize-child-rule.ts
+function normalizeCardinality(input, impliesSingleton) {
+  const min = input?.min ?? 0;
+  const max = input?.max ?? (impliesSingleton ? 1 : Infinity);
+  if (min === 0 && max === Infinity) {
+    return { kind: "unbounded" };
+  }
+  if (min > max) {
+    throw new RangeError(`normalizeChildRule: min (${min}) cannot exceed max (${max})`);
+  }
+  return {
+    kind: "bounded",
+    min,
+    max
+  };
+}
+function normalizeChildRule(rule) {
+  const position = rule.position ?? "any";
+  const impliesSingleton = position === "first" || position === "last";
+  return {
+    ...rule,
+    position,
+    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;
+}
+function buildPartialIndex(rules) {
+  const typeIndex = /* @__PURE__ */ new Map();
+  const duplicateTypes = /* @__PURE__ */ new Set();
+  const untypedIndices = [];
+  iterate.forEach(rules, (rule, ri) => {
+    const t = rule.type;
+    if (t === void 0) {
+      untypedIndices.push(ri);
+    } else if (typeIndex.has(t)) {
+      duplicateTypes.add(t);
+    } else {
+      typeIndex.set(t, ri);
+    }
+  });
+  if (duplicateTypes.size > 0) {
+    iterate.forEachSet(duplicateTypes, (t) => {
+      typeIndex.delete(t);
+    });
+    iterate.forEach(rules, (rule, ri) => {
+      if (duplicateTypes.has(rule.type)) untypedIndices.push(ri);
+    });
+  }
+  return { typeIndex, untypedIndices };
+}
+var RuleMatcher = class {
+  #rules;
+  #typeIndex;
+  #untypedIndices;
+  constructor(rules) {
+    this.#rules = rules;
+    const { typeIndex, untypedIndices } = buildPartialIndex(rules);
+    this.#typeIndex = typeIndex;
+    this.#untypedIndices = untypedIndices;
+  }
+  match(children) {
+    const forward = /* @__PURE__ */ new Map();
+    const reverse = /* @__PURE__ */ new Map();
+    const unexpectedIndices = /* @__PURE__ */ new Set();
+    const ambiguousIndices = /* @__PURE__ */ new Set();
+    iterate.forEach(this.#rules, (_, ri) => {
+      reverse.set(ri, /* @__PURE__ */ new Set());
+    });
+    iterate.forEach(children, (child, ci) => {
+      const t = getChildType(child);
+      if (t !== void 0) {
+        const ri = this.#typeIndex.get(t);
+        if (ri !== void 0) {
+          let childEntry = forward.get(ci);
+          if (!childEntry) {
+            childEntry = /* @__PURE__ */ new Set();
+            forward.set(ci, childEntry);
+          }
+          childEntry.add(ri);
+          reverse.get(ri).add(ci);
+        }
+      }
+      iterate.forEach(this.#untypedIndices, (ri) => {
+        if (!this.#rules[ri].match(child)) return;
+        let childEntry = forward.get(ci);
+        if (!childEntry) {
+          childEntry = /* @__PURE__ */ new Set();
+          forward.set(ci, childEntry);
+        }
+        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 };
+  }
+};
+
+// ../../lib/contract/src/children/rule-validator.ts
+var RuleValidator = class _RuleValidator extends InvariantBase {
+  #context;
+  constructor(context, diagnostics) {
+    super(diagnostics);
+    this.#context = context;
+  }
+  validate(rules, matrix, childCount) {
+    const firstIndex = 0;
+    const lastIndex = childCount - 1;
+    iterate.forEach(rules, (rule, ri) => {
+      const matches = matrix.childToRules.reverse.get(ri);
+      const matchCount = matches.size;
+      this.#validateCardinality(rule, matchCount);
+      if (matchCount === 0) return;
+      this.#validatePositions(rule, matches, firstIndex, lastIndex);
+    });
+  }
+  #validateCardinality(rule, matchCount) {
+    const { cardinality, name } = rule;
+    if (cardinality.kind !== "bounded") {
+      return;
+    }
+    const { min, max } = cardinality;
+    if (matchCount < min) {
+      this.violate(ContractDiagnostics.cardinalityMin(name, min, this.#context));
+      return;
+    }
+    if (matchCount > max) {
+      this.violate(ContractDiagnostics.cardinalityMax(name, max, this.#context));
+    }
+  }
+  #validatePositions(rule, matches, firstIndex, lastIndex) {
+    const { name, position } = rule;
+    iterate.forEachSet(matches, (index) => {
+      if (_RuleValidator.#isValidPosition(index, position, firstIndex, lastIndex)) {
+        return;
+      }
+      this.violate(ContractDiagnostics.positionViolation(name, position, index, this.#context));
+    });
+  }
+  static #isValidPosition(matchIndex, position, firstIndex, lastIndex) {
+    switch (position) {
+      case "first":
+        return matchIndex === firstIndex;
+      case "last":
+        return matchIndex === lastIndex;
+      case "any":
+        return true;
+      default:
+        return assertNever(position);
+    }
+  }
+};
+
+// ../../lib/contract/src/children/children-evaluator.ts
+var ChildrenEvaluator = class extends InvariantBase {
+  #context;
+  #rules;
+  #ruleNames;
+  #matcher;
+  #ruleValidator;
+  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, diagnostics);
+  }
+  evaluate(children) {
+    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 violating = [...unexpectedIndices, ...ambiguousIndices].sort((a, b) => a - b);
+    iterate.forEach(violating, (ci) => {
+      const typeName = getTypeName(children[ci]);
+      if (unexpectedIndices.has(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}`);
+        this.violate(ContractDiagnostics.ambiguousChild(typeName, ci, names, this.#context));
+      }
+    });
+  }
+};
+
+// ../../lib/contract/src/props/get-disabled-props.ts
+var disabledProps = ({
+  disabled,
+  "aria-disabled": ariaDisabled,
+  "data-disabled": dataDisabled
+}) => {
+  if (!disabled) return {};
+  return {
+    ...ariaDisabled === void 0 && { "aria-disabled": "true" },
+    ...dataDisabled === void 0 && { "data-disabled": "" }
+  };
+};
+
+// ../../lib/contract/src/props/get-invalid-props.ts
+var invalidProps = ({
+  invalid,
+  "aria-invalid": ariaInvalid,
+  "data-invalid": dataInvalid
+}) => {
+  if (!invalid) return {};
+  return {
+    ...ariaInvalid === void 0 && { "aria-invalid": "true" },
+    ...dataInvalid === void 0 && { "data-invalid": "" }
+  };
+};
+
+// ../../lib/contract/src/props/get-readonly-props.ts
+var readonlyProps = ({
+  readOnly,
+  "aria-readonly": ariaReadonly,
+  "data-readonly": dataReadonly
+}) => {
+  if (!readOnly) return {};
+  return {
+    ...ariaReadonly === void 0 && {
+      "aria-readonly": "true"
+    },
+    ...dataReadonly === void 0 && {
+      "data-readonly": ""
+    }
+  };
+};
+
+// ../core/src/html/aria-rules.ts
+var LANDMARK_TAG_SET = /* @__PURE__ */ new Set(["article", "aside", "footer", "header", "main", "nav"]);
+var removeLandmarkRoleOverride = {
+  kind: "removeRole",
+  apply: ({ props }) => {
+    if (!("role" in props)) return { applied: false, next: props };
+    const { role: _r, ...rest } = props;
+    return { applied: true, next: rest, previous: props };
+  }
+};
+function landmarkRoleRule({ tag, props, implicitRole }) {
+  if (!LANDMARK_TAG_SET.has(tag) || !implicitRole) return [];
+  const role = props.role;
+  if (!role || role === implicitRole) return [];
+  return [
+    {
+      valid: false,
+      fixable: true,
+      severity: "error",
+      fix: removeLandmarkRoleOverride,
+      diagnostic: HtmlDiagnostics.landmarkRoleOverride(tag, implicitRole, role)
+    }
+  ];
+}
+function requireAccessibleName({ tag, props }) {
+  if ("aria-label" in props || "aria-labelledby" in props) return [];
+  return [
+    {
+      valid: false,
+      fixable: false,
+      severity: "warning",
+      diagnostic: AriaDiagnostics.missingAccessibleName(tag)
+    }
+  ];
+}
+var NAMED_LANDMARK_TAGS = /* @__PURE__ */ new Set(["nav", "aside"]);
+function landmarkNameAdvisory(ctx) {
+  if (!ctx.implicitRole || !NAMED_LANDMARK_TAGS.has(ctx.tag)) return [];
+  return requireAccessibleName(ctx);
+}
+
+// ../core/src/html/contracts.ts
+function isOpenContent(...blockedTags) {
+  const set2 = new Set(blockedTags);
+  return (child) => isObject(child) && "type" in child && (!isString(child.type) || !set2.has(child.type));
+}
+var METADATA_TAGS = ["script", "template"];
+var metadataMatch = isTag(...METADATA_TAGS);
+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 { diagnostics: warnDiagnostics, children };
+}
+function ariaContract(aria) {
+  return { diagnostics: warnDiagnostics, 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, landmarkNameAdvisory]);
+var dialogContract = ariaContract([requireAccessibleName]);
+var menuContract = ariaContract([requireAccessibleName]);
+var menubarContract = ariaContract([requireAccessibleName]);
+var treeContract = ariaContract([requireAccessibleName]);
+var gridContract = ariaContract([requireAccessibleName]);
+var listboxContract = ariaContract([requireAccessibleName]);
+var tablistContract = ariaContract([requireAccessibleName]);
+var radiogroupContract = ariaContract([requireAccessibleName]);
+var CONTRACT_GROUPS = [
+  [VOID_TAGS, voidContract],
+  [TEXT_ONLY_TAGS, textOnlyContract],
+  [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,
+  dialog: dialogContract,
+  head: headContract,
+  html: htmlContract
+};
+
+// ../core/src/html/evaluators.ts
+var htmlDiagnostics = warnDiagnostics;
+function buildEvaluatorMap() {
+  const map2 = /* @__PURE__ */ new Map();
+  iterate.forEachEntry(htmlContracts, (tag, { children }) => {
+    if (children?.length) {
+      map2.set(tag, new ChildrenEvaluator(children, htmlDiagnostics, `<${tag}>`));
+    }
+  });
+  return map2;
+}
+var HTML_EVALUATORS = buildEvaluatorMap();
+function getHtmlChildrenEvaluator(tag) {
+  return typeof tag === "string" ? HTML_EVALUATORS.get(tag) : void 0;
+}
+
+// ../core/src/html/prop-normalizers.ts
+var HTML_FORM_NORMALIZERS = /* @__PURE__ */ new Map([
+  ["button", [disabledProps]],
+  ["input", [disabledProps, readonlyProps, invalidProps]],
+  ["select", [disabledProps]],
+  ["textarea", [disabledProps, readonlyProps]],
+  ["fieldset", [disabledProps]],
+  ["optgroup", [disabledProps]]
+]);
+function getHtmlPropNormalizers(tag) {
+  return typeof tag === "string" ? HTML_FORM_NORMALIZERS.get(tag) : void 0;
+}
+
+// ../../lib/styling/src/variant-pass/compile-variant-lookup.ts
+function buildPrecomputedKey(props) {
+  return Object.entries(props).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}:${v}`).join("|");
+}
+
+// ../../lib/styling/src/variant-pass/variant-pass.ts
+function createVariantPass(activeProps, config) {
+  return {
+    name: "variant",
+    execute() {
+      const preset = typeof activeProps["preset"] === "string" ? activeProps["preset"] : void 0;
+      const presetDefaults = preset !== void 0 && config.presets?.[preset] !== void 0 ? config.presets[preset] : {};
+      const resolved = {
+        ...config.defaults,
+        ...presetDefaults,
+        ...activeProps
+      };
+      const classes = [];
+      iterate.forEachEntry(config.variants, (key, valueMap) => {
+        const active = resolved[key];
+        if (typeof active === "string") {
+          const cls = valueMap[active];
+          if (cls !== void 0) classes.push(cls);
+        }
+      });
+      return { context: { classes } };
+    }
+  };
+}
+
+// ../core/src/resolver/resolver.ts
+function enforceAllowedAs(tag, allowedAs, diagnostics, displayName) {
+  if (allowedAs.includes(tag)) return;
+  if (!diagnostics) return;
+  const component = displayName ?? String(tag);
+  diagnostics.error(ContractDiagnostics.allowedAsViolation(String(tag), allowedAs, component));
+}
+
+// ../../lib/adapter-utils/src/apply-prop-normalizers.ts
+function applyPropNormalizers(tag, props, additional) {
+  const normalizers = [...getHtmlPropNormalizers(tag) ?? [], ...additional ?? []];
+  if (normalizers.length === 0) return props;
+  return normalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), props);
+}
+
+// ../../lib/adapter-utils/src/build-engines.ts
+function buildEngines(diagnostics, childRules, context) {
+  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, diagnostics, context) } : {};
+}
+
+// ../../lib/adapter-utils/src/resolve-adapter-common-options.ts
+function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics) {
+  return {
+    name: options.name ?? defaultName,
+    diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
+  };
+}
+
+// ../../lib/adapter-utils/src/slot-validator.ts
+var SlotValidator = class extends InvariantBase {
+  #name;
+  #elementTerm;
+  constructor(name, diagnostics, elementTerm) {
+    super(diagnostics);
+    this.#name = name;
+    this.#elementTerm = elementTerm;
+  }
+  assertExclusive() {
+    this.violate(SlotDiagnostics.exclusive(this.#name));
+  }
+  warnDiscardedChildren(count) {
+    this.warn(SlotDiagnostics.discardedChildren(this.#name, this.#elementTerm, count));
+  }
+  assertSingleChild(count) {
+    this.violate(
+      count === 0 ? SlotDiagnostics.singleChildRequired(this.#name, this.#elementTerm) : SlotDiagnostics.singleChildExceeded(this.#name, this.#elementTerm, count)
+    );
+  }
+};
+
+// ../../lib/adapter-utils/src/slot/policies.ts
+import { clsx } from "clsx";
+function chainHandlers(childHandler, slotHandler) {
+  return (...args) => {
+    childHandler(...args);
+    const event = args[0];
+    if (!(typeof event === "object" && event !== null && "defaultPrevented" in event && event.defaultPrevented)) {
+      slotHandler(...args);
+    }
+  };
+}
+function mergeClassNames(slot, child) {
+  return clsx(slot, child);
+}
+function mergeStyles(slot, child) {
+  if (!isPlainObject(slot) || !isPlainObject(child)) return child;
+  return { ...slot, ...child };
+}
+var policyHandlers = {
+  chain: (slotVal, childVal) => chainHandlers(childVal, slotVal),
+  concat: (slotVal, childVal) => mergeClassNames(slotVal, childVal),
+  "shallow-merge": (slotVal, childVal) => mergeStyles(slotVal, childVal),
+  "child-wins": (_slotVal, childVal) => childVal
+};
+
+// ../../lib/adapter-utils/src/slot/merge-slot-props.ts
+function mergeSlotProps(slotProps, childProps) {
+  const merged = { ...slotProps };
+  iterate.forEachKey(childProps, (key) => {
+    if (!Object.hasOwn(childProps, key)) return;
+    merged[key] = applyMergePolicy(key, slotProps[key], childProps[key]);
+  });
+  return merged;
+}
+function classifyProp(key, slotVal, childVal) {
+  if (EVENT_HANDLER_RE.test(key) && isFunction(slotVal) && isFunction(childVal)) return "chain";
+  if (key === "className") return "concat";
+  if (key === "style") return "shallow-merge";
+  return "child-wins";
+}
+function applyMergePolicy(key, slotVal, childVal) {
+  return policyHandlers[classifyProp(key, slotVal, childVal)](slotVal, childVal);
+}
+
+// ../../lib/adapter-utils/src/build-definition.ts
+function buildDefinition(name, tag) {
+  return {
+    identity: {
+      id: name,
+      name,
+      tag
+    },
+    capabilities: {},
+    metadata: {},
+    diagnostics: []
+  };
+}
+
+// ../../lib/adapter-utils/src/build-variant-config.ts
+function flattenClassName(cls) {
+  return Array.isArray(cls) ? cls.join(" ") : cls;
+}
+function mapVariantRecord(source, mapper) {
+  return iterate.mapValues(
+    source,
+    (inner) => iterate.mapValues(inner, mapper)
+  );
+}
+function buildVariantConfig(variants, presets, defaults, compounds) {
+  return {
+    variants: mapVariantRecord(variants ?? {}, flattenClassName),
+    ...presets !== void 0 && Object.keys(presets).length > 0 && { presets },
+    ...defaults !== void 0 && Object.keys(defaults).length > 0 && { defaults },
+    ...compounds !== void 0 && compounds.length > 0 && {
+      compounds
+    }
+  };
+}
+
+// ../../runtime/core/src/apply-attributes.ts
+function applyAttributes(nodeId, incoming, decoration, removedKeys) {
+  const existing = decoration[nodeId] ?? {};
+  const next = { ...existing.attributes };
+  if (removedKeys !== void 0) {
+    iterate.forEachSet(removedKeys, (key) => {
+      delete next[key];
+    });
+  }
+  Object.assign(next, incoming);
+  const { attributes: _dropped, ...rest } = existing;
+  const nextDecoration = Object.keys(next).length > 0 ? { ...rest, attributes: next } : rest;
+  return { ...decoration, [nodeId]: nextDecoration };
+}
+
+// ../../runtime/core/src/get-active-props.ts
+function getActiveProps(nodeId, decoration) {
+  const dec = decoration[nodeId];
+  return { ...dec?.attributes ?? {}, ...dec?.variants ?? {} };
+}
+
+// ../../runtime/core/src/render-component.ts
+function renderComponent(definition, tree, render, backend) {
+  return backend.render({ definition, tree, render });
+}
+
+// ../../runtime/core/src/build-tree-context.ts
+function buildNode(input, slotAssignments, seenIds, diagnostics) {
+  if (seenIds.has(input.id)) {
+    diagnostics.push({
+      code: "duplicate-node-id",
+      message: `Duplicate node id "${input.id}"`,
+      severity: "error"
+    });
+  } else {
+    seenIds.add(input.id);
+  }
+  if (input.slot !== void 0) {
+    slotAssignments.set(input.id, input.slot);
+  }
+  const children = Object.freeze(
+    (input.children ?? []).map((child) => buildNode(child, slotAssignments, seenIds, diagnostics))
+  );
+  if (input.kind === "native") {
+    return Object.freeze({ kind: "native", id: input.id, tag: input.tag, children });
+  }
+  return Object.freeze({ kind: "component", id: input.id, children });
+}
+function buildTreeContext(root) {
+  const slotAssignments = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const rootNode = buildNode(root, slotAssignments, /* @__PURE__ */ new Set(), diagnostics);
+  return Object.freeze({ root: rootNode, slotAssignments, diagnostics });
+}
+
+// ../../runtime/core/src/build-render-context.ts
+function buildRenderContext(decoration = {}) {
+  return { decoration: new Map(Object.entries(decoration)) };
+}
+
+// ../../lib/adapter-utils/src/resolve-compounds.ts
+function matchesCompound(active, compound) {
+  const { class: _, ...conditions } = compound;
+  return Object.entries(conditions).every(([key, expected]) => {
+    const actual = active[key];
+    return Array.isArray(expected) ? expected.includes(actual) : actual === expected;
+  });
+}
+function resolveCompounds(active, compounds) {
+  if (!compounds?.length) return [];
+  const out = [];
+  iterate.forEach(compounds, (compound) => {
+    if (matchesCompound(active, compound)) {
+      out.push(flattenClassName(compound.class));
+    }
+  });
+  return out;
+}
+
+// ../../lib/adapter-utils/src/resolve-classes.ts
+function resolveClasses(decoration, variantConfig, variantDefaults, recipe, compounds, variantLookup) {
+  const active = getActiveProps("root", decoration);
+  if (variantLookup !== void 0 && recipe === void 0) {
+    const activeVariants = {};
+    iterate.forEachKey(variantConfig.variants, (key) => {
+      const value = active[key];
+      if (typeof value === "string") activeVariants[key] = value;
+    });
+    const lookupKey = buildPrecomputedKey(activeVariants);
+    const precomputedValue = variantLookup[lookupKey];
+    if (precomputedValue !== void 0) {
+      return {
+        variantClasses: precomputedValue !== "" ? [precomputedValue] : [],
+        compoundClasses: []
+      };
+    }
+  }
+  const passInput = recipe !== void 0 ? { ...active, preset: recipe } : active;
+  const { context } = createVariantPass(passInput, variantConfig).execute({ classes: [] });
+  const variantClasses = context.classes;
+  const presetOverrides = recipe !== void 0 ? variantConfig.presets?.[recipe] ?? {} : {};
+  const resolvedValues = {
+    ...variantDefaults,
+    ...presetOverrides,
+    ...active
+  };
+  const compoundClasses = resolveCompounds(resolvedValues, compounds);
+  return { variantClasses, compoundClasses };
+}
+
+// ../../lib/adapter-utils/src/build-pipeline.ts
+function buildStylePipeline(variants, presets, defaults, compounds, variantLookup) {
+  if (variants === void 0 && compounds === void 0 && presets === void 0 && variantLookup === void 0) {
+    return void 0;
+  }
+  const variantConfig = buildVariantConfig(variants, presets, defaults, compounds);
+  return {
+    execute(decoration, recipe) {
+      return resolveClasses(decoration, variantConfig, defaults, recipe, compounds, variantLookup);
+    }
+  };
+}
+
+// ../../lib/adapter-utils/src/join-classes.ts
+function joinClasses(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+
+// ../../lib/adapter-utils/src/decoration-utils.ts
+function withAttributes(dec, attributes) {
+  const { attributes: _a, ...rest } = dec;
+  return attributes !== void 0 ? { ...rest, attributes } : rest;
+}
+
+// ../../lib/adapter-utils/src/apply-aria.ts
+function applyAria(decoration, tag, ariaEngine) {
+  if (ariaEngine === void 0) return decoration;
+  const dec = decoration["root"];
+  if (dec?.attributes === void 0) return decoration;
+  const result = ariaEngine.validate(tag, dec.attributes);
+  const cleaned = result.props;
+  return {
+    ...decoration,
+    root: withAttributes(dec, Object.keys(cleaned).length > 0 ? cleaned : void 0)
+  };
+}
+
+// ../../lib/adapter-utils/src/apply-filter-props.ts
+function applyFilterProps(decoration, filterFn, variantKeys) {
+  if (filterFn === void 0) return decoration;
+  const dec = decoration["root"];
+  if (dec?.attributes === void 0) return decoration;
+  const kept = Object.fromEntries(
+    Object.entries(dec.attributes).filter(([k]) => !filterFn(k, variantKeys))
+  );
+  return {
+    ...decoration,
+    root: withAttributes(dec, Object.keys(kept).length > 0 ? kept : void 0)
+  };
+}
+
+// ../../lib/adapter-utils/src/apply-ref.ts
+function applyRef(decoration, ref) {
+  if (ref == null) return decoration;
+  const existing = decoration["root"] ?? {};
+  return { ...decoration, root: { ...existing, ref } };
+}
+
+// ../../adapters/react/src/shared/merge-refs.ts
+function mergeRefs(...refs) {
+  return mergeRefsCore(...refs);
+}
+
+// ../../adapters/react/src/shared/slot/Slottable.tsx
+import { Fragment } from "react";
+import { jsx } from "react/jsx-runtime";
+function Slottable({ children }) {
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+
+// ../../adapters/react/src/shared/slot/clone.ts
+import { cloneElement } from "react";
+function cloneWithProps(child, props, ref) {
+  return cloneElement(child, ref !== null ? { ...props, ref } : props);
+}
+
+// ../../adapters/react/src/shared/slot/applySlot.ts
+import { isValidElement as isValidElement3 } from "react";
+
+// ../../adapters/react/src/shared/slot/extractSlottable.ts
+import { createElement, Fragment as Fragment2, isValidElement as isValidElement2 } from "react";
+
+// ../../adapters/react/src/shared/slot/predicates.ts
+import { isValidElement } from "react";
+function isSlottableElement(value) {
+  return isValidElement(value) && value.type === Slottable;
+}
+
+// ../../adapters/react/src/shared/slot/extractSlottable.ts
+function extractSlottable(children) {
+  const childrenArray = Array.isArray(children) ? children : [children];
+  const slottables = childrenArray.filter(isSlottableElement);
+  invariant(slottables.length <= 1, "Slot: multiple Slottable children are not allowed");
+  if (slottables.length === 0) {
+    return null;
+  }
+  const [slottable] = slottables;
+  invariant(slottable, "Missing Slottable element");
+  const child = slottable.props.children;
+  invariant(
+    child !== null && child !== void 0,
+    "Slottable expects exactly one React element child, received null"
+  );
+  invariant(
+    typeof child !== "string" && typeof child !== "number",
+    "Slottable expects exactly one React element child, received text content"
+  );
+  invariant(isValidElement2(child), "Slottable expects exactly one React element child");
+  invariant(child.type !== Fragment2, "Slottable child cannot be a Fragment");
+  const index = childrenArray.indexOf(slottable);
+  return {
+    child,
+    // Fragment wrapper: Slot owns no DOM node; ref composition happens only on the merge target.
+    rebuild(merged) {
+      const out = childrenArray.map((node, i) => i === index ? merged : node);
+      return createElement(Fragment2, null, ...out);
+    }
+  };
+}
+
+// ../../adapters/react/src/shared/slot/applySlot.ts
+function applySlot(children, slotProps, ref, cloneSlotChild) {
+  const extraction = extractSlottable(children);
+  if (extraction) {
+    const merged = cloneSlotChild({ child: extraction.child, slotProps, ref });
+    return extraction.rebuild(merged);
+  }
+  invariant(isValidElement3(children), "Slot: child must be a valid React element");
+  return cloneSlotChild({ child: children, slotProps, ref });
+}
+
+// ../../adapters/react/src/shared/slot/make-render-as-child.ts
+import { isValidElement as isValidElement4 } from "react";
+function makeRenderAsChild(cloneSlotChild) {
+  return function renderAsChild(children, className, ref) {
+    if (!isValidElement4(children)) throw new Error("asChild requires a React element child");
+    const slotProps = className ? { className } : {};
+    return cloneSlotChild({ child: children, slotProps, ref: ref ?? null });
+  };
+}
+
+// ../../adapters/react/src/shared/apply-display-name.ts
+function applyDisplayName(component, name) {
+  const displayName = name ?? "PolymorphicComponent";
+  Object.assign(component, {
+    displayName,
+    [COMPONENT_ID]: /* @__PURE__ */ Symbol.for(`praxis.component.${displayName}`)
+  });
+}
+
+// ../../adapters/react/src/backend/extract-decoration.ts
+function isStyleValue(v) {
+  return isString(v) || isNumber(v);
+}
+function isAttributeValue(v) {
+  return isString(v) || isNumber(v) || typeof v === "boolean";
+}
+function assignIfNotEmpty(target, key, value) {
+  if (Object.keys(value).length > 0) {
+    target[key] = value;
+  }
+}
+function extractStyles(value, styles) {
+  if (!isObject(value)) return false;
+  iterate.forEachEntry(value, (k, v) => {
+    if (isStyleValue(v)) {
+      styles[k] = v;
+    }
+  });
+  return true;
+}
+function extractListener(key, value, listeners) {
+  if (!key.startsWith("on") || !isFunction(value)) {
+    return false;
+  }
+  listeners[key] = value;
+  return true;
+}
+function extractAttributeOrVariant(key, value, attributes, variants, variantKeys) {
+  if (variantKeys?.has(key)) {
+    variants[key] = value;
+  } else {
+    attributes[key] = value;
+  }
+}
+function extractDecoration(props, variantKeys) {
+  const attributes = {};
+  const styles = {};
+  const listeners = {};
+  const variants = {};
+  const dec = {};
+  iterate.forEachEntry(props, (key, value) => {
+    if (key === "children" || key === "slot" || key === "ref") return;
+    if (key === "style" && extractStyles(value, styles)) return;
+    if (extractListener(key, value, listeners)) return;
+    if (isAttributeValue(value)) {
+      extractAttributeOrVariant(key, value, attributes, variants, variantKeys);
+    }
+  });
+  assignIfNotEmpty(dec, "attributes", attributes);
+  assignIfNotEmpty(dec, "styles", styles);
+  assignIfNotEmpty(dec, "listeners", listeners);
+  assignIfNotEmpty(dec, "variants", variants);
+  const ref = props.ref;
+  if (ref !== void 0) {
+    dec.ref = ref;
+  }
+  return dec;
+}
+
+// ../../adapters/react/src/current/helpers/render-normally.ts
+import { cloneElement as cloneElement2 } from "react";
+
+// ../../adapters/react/src/backend/react-backend.ts
+import React from "react";
+
+// ../../adapters/react/src/backend/build-props.ts
+function buildPropsFromDecoration(id, decoration) {
+  return {
+    key: id,
+    ...decoration?.attributes,
+    ...decoration?.styles !== void 0 ? { style: decoration.styles } : {},
+    ...decoration?.listeners,
+    ...decoration?.ref !== void 0 ? { ref: decoration.ref } : {}
+  };
+}
+
+// ../../adapters/react/src/backend/react-backend.ts
+function renderNode(node, render) {
+  const children = node.children.map((child) => renderNode(child, render));
+  if (node.kind === "component") {
+    return React.createElement(React.Fragment, { key: node.id }, ...children);
+  }
+  const decoration = render.decoration.get(node.id);
+  const props = buildPropsFromDecoration(node.id, decoration);
+  return React.createElement(node.tag, props, ...children);
+}
+var reactBackend = {
+  render(context) {
+    return renderNode(context.tree.root, context.render);
+  }
+};
+
+// ../../adapters/react/src/current/helpers/render-normally.ts
+function renderNormally(definition, tag, decoration, children) {
+  const treeCtx = buildTreeContext({ kind: "native", tag, id: "root", children: [] });
+  const rendered = renderComponent(
+    definition,
+    treeCtx,
+    buildRenderContext(decoration),
+    reactBackend
+  );
+  return children === void 0 ? rendered : cloneElement2(rendered, {}, children);
+}
+
+// ../../adapters/react/src/current/helpers/render-with-callback.ts
+function renderWithCallback(render, domProps, className, ref) {
+  const props = { ...domProps };
+  if (className) props.className = className;
+  if (ref !== void 0) props.ref = ref;
+  return render(props);
+}
+
+export {
+  isFunction,
+  isPlainObject,
+  SLOT_NAME,
+  COMPONENT_DEFAULT_TAG,
+  AriaPolicyEngine,
+  getHtmlChildrenEvaluator,
+  enforceAllowedAs,
+  applyPropNormalizers,
+  defineContractComponent,
+  buildEngines,
+  resolveAdapterCommonOptions,
+  SlotValidator,
+  mergeSlotProps,
+  buildDefinition,
+  flattenClassName,
+  applyAttributes,
+  buildStylePipeline,
+  joinClasses,
+  applyAria,
+  applyFilterProps,
+  applyRef,
+  mergeRefs,
+  applyDisplayName,
+  cloneWithProps,
+  Slottable,
+  applySlot,
+  makeRenderAsChild,
+  extractDecoration,
+  renderNormally,
+  renderWithCallback
+};