praxis-kit 6.2.3 → 6.6.0

package/dist/lit/index.js

@@ -25,6 +25,9 @@ function isNull(value) {
 function isNonNull(value) {
   return value != null;
 }
+function isNullish(value) {
+  return isNull(value) || value === void 0;
+}
 
 // ../../lib/primitive/src/utils/type-guards.ts
 function isObject(value, excludeArrays = false) {
@@ -526,20 +529,29 @@ function isAriaAttributeValidForRole(attr, role) {
 }
 
 // ../../lib/primitive/src/guards/aria/is-aria-role.ts
+function lookupImplicitRole(tag) {
+  return IMPLICIT_ROLE_RECORD[tag];
+}
 function isStrongImplicitRole(tag) {
-  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
-  return STRONG_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+  const role = lookupImplicitRole(tag);
+  return !isNullish(role) && STRONG_ROLES_SET.has(role);
 }
-function isStandaloneTag(tag) {
-  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
-  return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+function hasStandaloneRole(tag) {
+  const role = lookupImplicitRole(tag);
+  return !isNullish(role) && STANDALONE_ROLES_SET.has(role);
 }
-function getInputImplicitRole(type) {
-  if (!isString(type) || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
-  return INPUT_TYPE_ROLE_MAP[type];
+var LIST_ELIGIBLE_INPUT_TYPES = /* @__PURE__ */ new Set(["text", "search", "tel", "url", "email"]);
+function getInputImplicitRole(type, list) {
+  if (!isString(type)) return void 0;
+  const role = INPUT_TYPE_ROLE_MAP[type];
+  if (!role) return void 0;
+  if (!isNullish(list) && LIST_ELIGIBLE_INPUT_TYPES.has(type)) {
+    return "combobox";
+  }
+  return role;
 }
 function getConditionalImplicitRole(tag, ariaLabel, ariaLabelledBy) {
-  const isNamed = isString(ariaLabel) || isString(ariaLabelledBy);
+  const isNamed = isString(ariaLabel) && ariaLabel.trim().length > 0 || isString(ariaLabelledBy) && ariaLabelledBy.trim().length > 0;
   if (!isNamed) return void 0;
   if (tag === "section") return "region";
   if (tag === "form") return "form";
@@ -585,7 +597,7 @@ function isTag(...args) {
 // ../../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 === "input") return getInputImplicitRole(props?.type, props?.list);
   if (tag === "img") return props?.alt === "" ? "none" : "img";
   if (tag === "section" || tag === "form") {
     return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
@@ -868,7 +880,11 @@ var ATTRIBUTE_IGNORED_CODES = {
   max: DiagnosticCode3.HtmlInputMaxIgnoredForType,
   step: DiagnosticCode3.HtmlInputStepIgnoredForType,
   accept: DiagnosticCode3.HtmlInputAcceptIgnoredForType,
-  capture: DiagnosticCode3.HtmlInputCaptureIgnoredForType
+  capture: DiagnosticCode3.HtmlInputCaptureIgnoredForType,
+  size: DiagnosticCode3.HtmlInputSizeIgnoredForType,
+  alt: DiagnosticCode3.HtmlInputAltIgnoredForType,
+  height: DiagnosticCode3.HtmlInputHeightIgnoredForType,
+  width: DiagnosticCode3.HtmlInputWidthIgnoredForType
 };
 var HtmlDiagnostics = {
   emptyRole(tag) {
@@ -1056,8 +1072,132 @@ var InvariantBase = class {
   }
 };
 
-// ../../lib/contract/src/aria/polymorphic-validator.ts
+// ../../lib/contract/src/aria/spec/roles/required-properties.ts
+var REQUIRED_ARIA_PROPERTIES = {
+  combobox: ["aria-expanded"],
+  option: ["aria-selected"],
+  slider: ["aria-valuenow"],
+  scrollbar: ["aria-controls", "aria-valuenow"],
+  spinbutton: ["aria-valuenow"]
+};
+
+// ../../lib/contract/src/aria/spec/roles/name-required.ts
+var NAME_REQUIRED_ROLES = /* @__PURE__ */ new Set(["img"]);
+
+// ../../lib/contract/src/aria/spec/validators/required-properties-validator.ts
 var NO_VIOLATIONS = [{ valid: true }];
+function requiredAttributeByRole(roles, attribute) {
+  return Object.fromEntries([...roles].map((role) => [role, [attribute]]));
+}
+function checkRequiredAttributes(requirement, { props, effectiveRole }) {
+  if (!effectiveRole) return NO_VIOLATIONS;
+  const requiredAttributes = requirement.attributesByRole[effectiveRole];
+  if (!requiredAttributes) return NO_VIOLATIONS;
+  const results = [];
+  for (const attribute of requiredAttributes) {
+    if (attribute in props) continue;
+    results.push({
+      valid: false,
+      fixable: false,
+      severity: "warning",
+      attribute,
+      diagnostic: requirement.diagnosticFor(attribute, effectiveRole)
+    });
+  }
+  return results;
+}
+
+// ../../lib/contract/src/aria/spec/roles/live-region.ts
+var LIVE_REGION_ROLES = /* @__PURE__ */ new Map([
+  ["alert", "assertive"],
+  ["status", "polite"],
+  ["log", "polite"],
+  ["timer", "off"]
+]);
+var ATOMIC_REQUIREMENTS = requiredAttributeByRole(LIVE_REGION_ROLES.keys(), "aria-atomic");
+
+// ../../lib/contract/src/aria/spec/attributes/aria-value-types.ts
+var 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"]) }]
+]);
+
+// ../../lib/contract/src/aria/spec/attributes/aria-relevant-tokens.ts
+var VALID_RELEVANT_TOKENS = /* @__PURE__ */ new Set([
+  "additions",
+  "removals",
+  "text",
+  "all"
+]);
+
+// ../../lib/contract/src/aria/spec/elements/heading-implicit-levels.ts
+var HEADING_IMPLICIT_LEVELS = /* @__PURE__ */ new Map([
+  ["h1", 1],
+  ["h2", 2],
+  ["h3", 3],
+  ["h4", 4],
+  ["h5", 5],
+  ["h6", 6]
+]);
+
+// ../../lib/contract/src/aria/spec/elements/interactive-tags.ts
+var INTERACTIVE_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "button",
+  "input",
+  "select",
+  "textarea"
+]);
+
+// ../../lib/contract/src/aria/polymorphic-validator.ts
+var NO_VIOLATIONS2 = [{ valid: true }];
 function isIntrinsicTag(tag) {
   return isString(tag);
 }
@@ -1100,7 +1240,6 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     if (!isIntrinsicTag(tag)) return { proceed: false, result: { props, violations: [] } };
     const implicitRole = getImplicitRole(tag, props);
     const hasRole = isNonNull(implicitRole) || isString(props.role) && props.role.length > 0;
-    if (!hasRole) return { proceed: false, result: { props, violations: [] } };
     const normalized = _AriaPolicyEngine.#normalizeEmptyRole(tag, props);
     const workingProps = normalized.normalized ? normalized.result.props : props;
     const preExistingViolations = normalized.normalized ? normalized.result.violations : [];
@@ -1110,6 +1249,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
       tag,
       implicitRole,
       effectiveRole,
+      hasRole,
       props: workingProps,
       preExistingViolations,
       context: { tag, props: workingProps, implicitRole, effectiveRole }
@@ -1119,6 +1259,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     const violations = [];
     const fixes = [];
     iterate.forEach(rules, (rule) => {
+      if (isNonNull(rule.tags) && !rule.tags.includes(context.tag)) return;
       iterate.forEach(rule(context), (result) => {
         if (result.valid) return;
         const {
@@ -1144,7 +1285,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     return { violations, fixes };
   }
   static #getRules(context) {
-    if (_AriaPolicyEngine.#hasRole(context.props) || isNonNull(context.effectiveRole) && _AriaPolicyEngine.#LIVE_REGION_ROLES.has(context.effectiveRole)) {
+    if (_AriaPolicyEngine.#hasRole(context.props) || isNonNull(context.effectiveRole) && LIVE_REGION_ROLES.has(context.effectiveRole)) {
       return _AriaPolicyEngine.#pipeline;
     }
     return _AriaPolicyEngine.#implicitOnlyRules;
@@ -1152,6 +1293,8 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
   static evaluate(tag, props) {
     const derived = _AriaPolicyEngine.#deriveContext(tag, props);
     if (!derived.proceed) return derived.result;
+    if (!derived.hasRole)
+      return { props: derived.props, violations: [...derived.preExistingViolations] };
     const {
       tag: narrowedTag,
       implicitRole,
@@ -1176,10 +1319,8 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
       props: workingProps,
       preExistingViolations
     } = derived;
-    const { violations, fixes } = _AriaPolicyEngine.#runRules(
-      [..._AriaPolicyEngine.#getRules(context), ...extraRules],
-      context
-    );
+    const rules = derived.hasRole ? [..._AriaPolicyEngine.#getRules(context), ...extraRules] : extraRules;
+    const { violations, fixes } = _AriaPolicyEngine.#runRules(rules, context);
     const next = _AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, workingProps, fixes);
     return { props: next, violations: [...preExistingViolations, ...violations] };
   }
@@ -1346,7 +1487,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     implicitRole
   }) {
     const role = props.role;
-    if (!implicitRole || !role || role === implicitRole) return NO_VIOLATIONS;
+    if (!implicitRole || !role || role === implicitRole) return NO_VIOLATIONS2;
     if (isStrongImplicitRole(tag) && role === "region") {
       const diagnostic = HtmlDiagnostics.implicitRoleOverride(tag, implicitRole, role);
       return [
@@ -1359,11 +1500,11 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
         }
       ];
     }
-    return NO_VIOLATIONS;
+    return NO_VIOLATIONS2;
   }
   static #checkRedundantRole({ tag, props, implicitRole }) {
     const role = props.role;
-    if (!implicitRole || !role || role !== implicitRole) return NO_VIOLATIONS;
+    if (!implicitRole || !role || role !== implicitRole) return NO_VIOLATIONS2;
     const diagnostic = HtmlDiagnostics.implicitRoleRedundant(tag, implicitRole);
     return [
       {
@@ -1377,8 +1518,8 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
   }
   static #checkStandaloneRegion({ tag, props, implicitRole }) {
     const role = props.role;
-    if (role !== "region") return NO_VIOLATIONS;
-    if (!isStandaloneTag(tag)) return NO_VIOLATIONS;
+    if (role !== "region") return NO_VIOLATIONS2;
+    if (!hasStandaloneRole(tag)) return NO_VIOLATIONS2;
     const diagnostic = HtmlDiagnostics.standaloneRegionOverride(tag, implicitRole ?? tag);
     return [
       {
@@ -1395,7 +1536,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     props,
     effectiveRole
   }) {
-    if (effectiveRole === "none" || effectiveRole === "presentation") return NO_VIOLATIONS;
+    if (effectiveRole === "none" || effectiveRole === "presentation") return NO_VIOLATIONS2;
     const results = [];
     iterate.forEachEntry(props, (key) => {
       if (!key.startsWith("aria-")) return;
@@ -1413,62 +1554,6 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     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":
@@ -1513,11 +1598,11 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     }
   }
   static #checkAriaAttributeValues({ props, effectiveRole }) {
-    if (effectiveRole === "none" || effectiveRole === "presentation") return NO_VIOLATIONS;
+    if (effectiveRole === "none" || effectiveRole === "presentation") return NO_VIOLATIONS2;
     const results = [];
     iterate.forEachEntry(props, (key, value) => {
       if (!key.startsWith("aria-")) return;
-      const type = _AriaPolicyEngine.#ARIA_VALUE_TYPES.get(key);
+      const type = ARIA_VALUE_TYPES.get(key);
       if (!isNonNull(type)) return;
       if (_AriaPolicyEngine.#isValidAriaValue(value, type)) return;
       results.push({
@@ -1536,26 +1621,18 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     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 NO_VIOLATIONS;
-    const implicitLevel = _AriaPolicyEngine.#HEADING_IMPLICIT_LEVELS.get(tag);
-    if (!isNonNull(implicitLevel)) return NO_VIOLATIONS;
+    if (effectiveRole === "none" || effectiveRole === "presentation") return NO_VIOLATIONS2;
+    const implicitLevel = HEADING_IMPLICIT_LEVELS.get(tag);
+    if (!isNonNull(implicitLevel)) return NO_VIOLATIONS2;
     const raw = props["aria-level"];
-    if (!isNonNull(raw)) return NO_VIOLATIONS;
+    if (!isNonNull(raw)) return NO_VIOLATIONS2;
     const n = typeof raw === "number" ? raw : typeof raw === "string" ? parseInt(raw, 10) : NaN;
-    if (!Number.isFinite(n) || n !== implicitLevel) return NO_VIOLATIONS;
+    if (!Number.isFinite(n) || n !== implicitLevel) return NO_VIOLATIONS2;
     return [
       {
         valid: false,
@@ -1568,20 +1645,14 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     ];
   }
   // ─── 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 NO_VIOLATIONS;
-    if ("aria-label" in props || "aria-labelledby" in props) return NO_VIOLATIONS;
-    if (tag === "img" && typeof props.alt === "string" && props.alt.length > 0) return NO_VIOLATIONS;
+    if (!effectiveRole || !NAME_REQUIRED_ROLES.has(effectiveRole)) return NO_VIOLATIONS2;
+    if ("aria-label" in props || "aria-labelledby" in props) return NO_VIOLATIONS2;
+    if (tag === "img" && typeof props.alt === "string" && props.alt.length > 0) return NO_VIOLATIONS2;
     return [
       {
         valid: false,
@@ -1591,51 +1662,21 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
       }
     ];
   }
-  // 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 NO_VIOLATIONS;
-    const required = _AriaPolicyEngine.#REQUIRED_PROPERTIES.get(effectiveRole);
-    if (!isNonNull(required)) return NO_VIOLATIONS;
-    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;
+  static #requiredAriaPropertiesRule = {
+    attributesByRole: REQUIRED_ARIA_PROPERTIES,
+    diagnosticFor: (attribute, role) => AriaDiagnostics.requiredProperty(attribute, role)
+  };
+  static #checkRequiredAriaProperties(context) {
+    return checkRequiredAttributes(_AriaPolicyEngine.#requiredAriaPropertiesRule, context);
   }
-  // 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 NO_VIOLATIONS;
-    const isInteractive = _AriaPolicyEngine.#INTERACTIVE_TAGS.has(tag);
+    if (props["aria-hidden"] !== "true" && props["aria-hidden"] !== true) return NO_VIOLATIONS2;
+    const isInteractive = 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 NO_VIOLATIONS;
+      if (!Number.isFinite(n) || n < 0) return NO_VIOLATIONS2;
     }
     return [
       {
@@ -1654,7 +1695,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     props,
     effectiveRole
   }) {
-    if (effectiveRole !== "none" && effectiveRole !== "presentation") return NO_VIOLATIONS;
+    if (effectiveRole !== "none" && effectiveRole !== "presentation") return NO_VIOLATIONS2;
     const results = [];
     iterate.forEachEntry(props, (key) => {
       if (!key.startsWith("aria-")) return;
@@ -1670,18 +1711,11 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     });
     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 NO_VIOLATIONS;
-    const impliedLive = _AriaPolicyEngine.#LIVE_REGION_ROLES.get(effectiveRole);
-    if (!impliedLive) return NO_VIOLATIONS;
-    if ("aria-live" in props) return NO_VIOLATIONS;
+    if (!effectiveRole) return NO_VIOLATIONS2;
+    const impliedLive = LIVE_REGION_ROLES.get(effectiveRole);
+    if (!impliedLive) return NO_VIOLATIONS2;
+    if ("aria-live" in props) return NO_VIOLATIONS2;
     const injectLive = {
       kind: `injectLive:${effectiveRole}`,
       apply: (ctx) => ({
@@ -1700,20 +1734,13 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
       }
     ];
   }
-  static #checkMissingAtomic({ effectiveRole, props }) {
-    if (!effectiveRole || !_AriaPolicyEngine.#LIVE_REGION_ROLES.has(effectiveRole))
-      return NO_VIOLATIONS;
-    if ("aria-atomic" in props) return NO_VIOLATIONS;
-    return [
-      {
-        valid: false,
-        fixable: false,
-        severity: "warning",
-        diagnostic: AriaDiagnostics.missingAtomic(effectiveRole)
-      }
-    ];
+  static #missingAtomicRule = {
+    attributesByRole: ATOMIC_REQUIREMENTS,
+    diagnosticFor: (_attribute, role) => AriaDiagnostics.missingAtomic(role)
+  };
+  static #checkMissingAtomic(context) {
+    return checkRequiredAttributes(_AriaPolicyEngine.#missingAtomicRule, context);
   }
-  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.
@@ -1727,10 +1754,10 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
   };
   static #checkInvalidAriaRelevant({ props }) {
     const relevant = props["aria-relevant"];
-    if (relevant === void 0) return NO_VIOLATIONS;
-    if (typeof relevant !== "string") return NO_VIOLATIONS;
+    if (relevant === void 0) return NO_VIOLATIONS2;
+    if (typeof relevant !== "string") return NO_VIOLATIONS2;
     const tokens = relevant.trim().split(/\s+/);
-    const invalid = tokens.filter((t) => !_AriaPolicyEngine.#VALID_RELEVANT_TOKENS.has(t));
+    const invalid = tokens.filter((t) => !VALID_RELEVANT_TOKENS.has(t));
     if (invalid.length > 0) {
       return [
         {
@@ -1755,7 +1782,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
         }
       ];
     }
-    return NO_VIOLATIONS;
+    return NO_VIOLATIONS2;
   }
 };
 
@@ -2075,7 +2102,59 @@ var readonlyProps = ({
 // ../core/src/html/evaluators.ts
 import { warnDiagnostics as warnDiagnostics2 } from "../_shared/diagnostics.js";
 
-// ../core/src/html/input-rules.ts
+// ../core/src/html/spec/vocabulary/input.ts
+var TEXT_INPUT_TYPES = ["text", "search", "url", "tel", "email", "password"];
+var NUMERIC_INPUT_TYPES = [
+  "number",
+  "range",
+  "date",
+  "month",
+  "week",
+  "time",
+  "datetime-local"
+];
+var HTML_INPUT_TYPES = /* @__PURE__ */ new Set([
+  ...TEXT_INPUT_TYPES,
+  ...NUMERIC_INPUT_TYPES,
+  "checkbox",
+  "radio",
+  "file",
+  "color",
+  "hidden",
+  "button",
+  "submit",
+  "reset",
+  "image"
+]);
+
+// ../core/src/html/spec/attributes/input.ts
+var INPUT_ATTRIBUTE_TYPE_POLICIES = [
+  { attribute: "checked", allowedTypes: ["checkbox", "radio"] },
+  { attribute: "multiple", allowedTypes: ["email", "file"] },
+  { attribute: "maxLength", allowedTypes: TEXT_INPUT_TYPES },
+  { attribute: "minLength", allowedTypes: TEXT_INPUT_TYPES },
+  { attribute: "pattern", allowedTypes: TEXT_INPUT_TYPES },
+  { attribute: "min", allowedTypes: NUMERIC_INPUT_TYPES },
+  { attribute: "max", allowedTypes: NUMERIC_INPUT_TYPES },
+  { attribute: "step", allowedTypes: NUMERIC_INPUT_TYPES },
+  { attribute: "accept", allowedTypes: ["file"] },
+  { attribute: "capture", allowedTypes: ["file"] },
+  { attribute: "size", allowedTypes: TEXT_INPUT_TYPES },
+  { attribute: "alt", allowedTypes: ["image"] },
+  { attribute: "height", allowedTypes: ["image"] },
+  { attribute: "width", allowedTypes: ["image"] }
+];
+
+// ../core/src/html/spec/constraints/input.ts
+var REQUIRED_READONLY_CONFLICT = {
+  props: ["required", "readOnly"],
+  diagnostic: () => InputAccessibilityDiagnostics.requiredReadOnlyConflict()
+};
+var INPUT_MUTUALLY_EXCLUSIVE_POLICIES = [
+  REQUIRED_READONLY_CONFLICT
+];
+
+// ../core/src/html/spec/validators/attribute-type-validator.ts
 var DEFAULT_INPUT_TYPE = "text";
 function omit(props, key) {
   const next = { ...props };
@@ -2091,7 +2170,10 @@ function removeAttributeFix(attribute) {
     }
   };
 }
-function inputAttributeRequiresType(attribute, allowedTypes) {
+function createInputAttributeTypeRule({
+  attribute,
+  allowedTypes
+}) {
   const rule = ({ tag, props }) => {
     if (tag !== "input" || !(attribute in props)) return [];
     const type = typeof props.type === "string" ? props.type : DEFAULT_INPUT_TYPE;
@@ -2107,31 +2189,30 @@ function inputAttributeRequiresType(attribute, allowedTypes) {
       }
     ];
   };
-  return Object.assign(rule, { readsProps: ["type", attribute] });
+  return Object.assign(rule, { readsProps: ["type", attribute], tags: ["input"] });
+}
+
+// ../core/src/html/spec/validators/mutually-exclusive-validator.ts
+function createMutuallyExclusiveRule({
+  props: conflictingProps,
+  diagnostic: createDiagnostic
+}) {
+  const [first, second] = conflictingProps;
+  const rule = ({ tag, props }) => {
+    if (tag !== "input" || !props[first] || !props[second]) return [];
+    const diagnostic = createDiagnostic();
+    return [{ valid: false, fixable: false, severity: diagnostic.severity, diagnostic }];
+  };
+  return Object.assign(rule, { readsProps: conflictingProps, tags: ["input"] });
+}
+
+// ../core/src/html/input-rules.ts
+var policyByAttribute = Object.fromEntries(
+  INPUT_ATTRIBUTE_TYPE_POLICIES.map((policy) => [policy.attribute, policy])
+);
+function policyFor(attribute) {
+  return policyByAttribute[attribute];
 }
-var TEXT_INPUT_TYPES = ["text", "search", "url", "tel", "email", "password"];
-var NUMERIC_INPUT_TYPES = [
-  "number",
-  "range",
-  "date",
-  "month",
-  "week",
-  "time",
-  "datetime-local"
-];
-var HTML_INPUT_TYPES = /* @__PURE__ */ new Set([
-  ...TEXT_INPUT_TYPES,
-  ...NUMERIC_INPUT_TYPES,
-  "checkbox",
-  "radio",
-  "file",
-  "color",
-  "hidden",
-  "button",
-  "submit",
-  "reset",
-  "image"
-]);
 var supportedInputTypeRule = Object.assign(
   ({ tag, props }) => {
     if (tag !== "input" || typeof props.type !== "string") return [];
@@ -2147,30 +2228,22 @@ var supportedInputTypeRule = Object.assign(
       }
     ];
   },
-  { readsProps: ["type"] }
-);
-var checkedRequiresCheckableTypeRule = inputAttributeRequiresType("checked", [
-  "checkbox",
-  "radio"
-]);
-var multipleRequiresSupportedTypeRule = inputAttributeRequiresType("multiple", [
-  "email",
-  "file"
-]);
-var maxLengthRequiresTextTypeRule = inputAttributeRequiresType(
-  "maxLength",
-  TEXT_INPUT_TYPES
-);
-var minLengthRequiresTextTypeRule = inputAttributeRequiresType(
-  "minLength",
-  TEXT_INPUT_TYPES
+  { readsProps: ["type"], tags: ["input"] }
 );
-var patternRequiresTextTypeRule = inputAttributeRequiresType("pattern", TEXT_INPUT_TYPES);
-var minRequiresNumericTypeRule = inputAttributeRequiresType("min", NUMERIC_INPUT_TYPES);
-var maxRequiresNumericTypeRule = inputAttributeRequiresType("max", NUMERIC_INPUT_TYPES);
-var stepRequiresNumericTypeRule = inputAttributeRequiresType("step", NUMERIC_INPUT_TYPES);
-var acceptRequiresFileTypeRule = inputAttributeRequiresType("accept", ["file"]);
-var captureRequiresFileTypeRule = inputAttributeRequiresType("capture", ["file"]);
+var checkedRequiresCheckableTypeRule = createInputAttributeTypeRule(policyFor("checked"));
+var multipleRequiresSupportedTypeRule = createInputAttributeTypeRule(policyFor("multiple"));
+var maxLengthRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("maxLength"));
+var minLengthRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("minLength"));
+var patternRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("pattern"));
+var minRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("min"));
+var maxRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("max"));
+var stepRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("step"));
+var acceptRequiresFileTypeRule = createInputAttributeTypeRule(policyFor("accept"));
+var captureRequiresFileTypeRule = createInputAttributeTypeRule(policyFor("capture"));
+var sizeRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("size"));
+var altRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("alt"));
+var heightRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("height"));
+var widthRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("width"));
 var inputAccessibleNameRule = Object.assign(
   ({ tag, props }) => {
     if (tag !== "input" || props.type === "hidden") return [];
@@ -2179,7 +2252,10 @@ var inputAccessibleNameRule = Object.assign(
     const diagnostic = hasPlaceholder ? InputAccessibilityDiagnostics.placeholderIsNotLabel() : InputAccessibilityDiagnostics.missingAccessibleName();
     return [{ valid: false, fixable: false, severity: diagnostic.severity, diagnostic }];
   },
-  { readsProps: ["type", "aria-label", "aria-labelledby", "placeholder"] }
+  {
+    readsProps: ["type", "aria-label", "aria-labelledby", "placeholder"],
+    tags: ["input"]
+  }
 );
 var PASSWORD_AUTOCOMPLETE_VALUES = ["current-password", "new-password"];
 var passwordAutocompleteRule = Object.assign(
@@ -2191,16 +2267,9 @@ var passwordAutocompleteRule = Object.assign(
     const diagnostic = InputAccessibilityDiagnostics.passwordMissingAutocomplete();
     return [{ valid: false, fixable: false, severity: diagnostic.severity, diagnostic }];
   },
-  { readsProps: ["type", "autoComplete"] }
-);
-var requiredReadOnlyConflictRule = Object.assign(
-  ({ tag, props }) => {
-    if (tag !== "input" || !props.required || !props.readOnly) return [];
-    const diagnostic = InputAccessibilityDiagnostics.requiredReadOnlyConflict();
-    return [{ valid: false, fixable: false, severity: diagnostic.severity, diagnostic }];
-  },
-  { readsProps: ["required", "readOnly"] }
+  { readsProps: ["type", "autoComplete"], tags: ["input"] }
 );
+var requiredReadOnlyConflictRule = createMutuallyExclusiveRule(REQUIRED_READONLY_CONFLICT);
 var INPUT_RULES = [
   supportedInputTypeRule,
   checkedRequiresCheckableTypeRule,
@@ -2213,11 +2282,132 @@ var INPUT_RULES = [
   stepRequiresNumericTypeRule,
   acceptRequiresFileTypeRule,
   captureRequiresFileTypeRule,
+  sizeRequiresTextTypeRule,
+  altRequiresImageTypeRule,
+  heightRequiresImageTypeRule,
+  widthRequiresImageTypeRule,
   inputAccessibleNameRule,
   passwordAutocompleteRule,
   requiredReadOnlyConflictRule
 ];
 
+// ../core/src/html/spec/types.ts
+function definePropRolePolicy(prop, map2, fallback) {
+  return { kind: "byProp", prop, map: map2, fallback };
+}
+function resolveAllowedRoles(spec, props) {
+  const policy = spec.allowedRoles;
+  if (!policy) return void 0;
+  switch (policy.kind) {
+    case "fixed":
+      return policy.roles;
+    case "byProp": {
+      const value = typeof props[policy.prop] === "string" ? props[policy.prop] : policy.fallback;
+      return policy.map[value];
+    }
+    case "dynamic":
+      return policy.resolve({ props });
+  }
+}
+
+// ../core/src/html/spec/roles/input.ts
+var ALLOWED_INPUT_ROLES = {
+  checkbox: ["menuitemcheckbox", "option", "switch", "button"],
+  radio: ["menuitemradio"],
+  range: [],
+  number: [],
+  search: ["combobox"],
+  text: ["combobox", "searchbox", "spinbutton"],
+  email: ["combobox"],
+  tel: ["combobox"],
+  url: ["combobox"],
+  button: [
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  submit: [
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  reset: [
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  image: [
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  hidden: []
+};
+
+// ../core/src/html/spec/elements/input.ts
+var inputElementSpec = {
+  tag: "input",
+  allowedRoles: definePropRolePolicy("type", ALLOWED_INPUT_ROLES, "text"),
+  attributes: INPUT_ATTRIBUTE_TYPE_POLICIES,
+  mutuallyExclusive: INPUT_MUTUALLY_EXCLUSIVE_POLICIES
+};
+
+// ../core/src/html/spec/roles/img.ts
+var IMG_NAMED_ROLES = [
+  "button",
+  "checkbox",
+  "link",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "progressbar",
+  "scrollbar",
+  "separator",
+  "slider",
+  "switch",
+  "tab",
+  "treeitem"
+];
+
+// ../core/src/html/spec/elements/img.ts
+var imgElementSpec = {
+  tag: "img",
+  allowedRoles: {
+    kind: "dynamic",
+    resolve: ({ props }) => props.alt === "" ? [] : IMG_NAMED_ROLES
+  }
+};
+
+// ../core/src/html/spec/roles/table.ts
+var ALLOWED_TABLE_ROLES = ["grid", "treegrid"];
+
+// ../core/src/html/spec/elements/table.ts
+var tableElementSpec = {
+  tag: "table",
+  allowedRoles: { kind: "fixed", roles: ALLOWED_TABLE_ROLES }
+};
+
 // ../core/src/html/role-restrictions.ts
 var ALLOWED_ROLES = {
   article: ["application", "document", "feed", "main", "none", "presentation", "region"],
@@ -2290,86 +2480,17 @@ var ALLOWED_ROLES = {
     "tab",
     "treeitem"
   ],
-  table: ["grid", "treegrid"],
   dialog: ["alertdialog"],
   fieldset: ["none", "presentation", "radiogroup"]
 };
-var IMG_NAMED_ROLES = [
-  "button",
-  "checkbox",
-  "link",
-  "menuitem",
-  "menuitemcheckbox",
-  "menuitemradio",
-  "option",
-  "progressbar",
-  "scrollbar",
-  "separator",
-  "slider",
-  "switch",
-  "tab",
-  "treeitem"
-];
-var ALLOWED_INPUT_ROLES = {
-  checkbox: ["menuitemcheckbox", "option", "switch", "button"],
-  radio: ["menuitemradio"],
-  range: [],
-  number: [],
-  search: ["combobox"],
-  text: ["combobox", "searchbox", "spinbutton"],
-  email: ["combobox"],
-  tel: ["combobox"],
-  url: ["combobox"],
-  button: [
-    "link",
-    "menuitem",
-    "menuitemcheckbox",
-    "menuitemradio",
-    "option",
-    "radio",
-    "switch",
-    "tab"
-  ],
-  submit: [
-    "link",
-    "menuitem",
-    "menuitemcheckbox",
-    "menuitemradio",
-    "option",
-    "radio",
-    "switch",
-    "tab"
-  ],
-  reset: [
-    "link",
-    "menuitem",
-    "menuitemcheckbox",
-    "menuitemradio",
-    "option",
-    "radio",
-    "switch",
-    "tab"
-  ],
-  image: [
-    "link",
-    "menuitem",
-    "menuitemcheckbox",
-    "menuitemradio",
-    "option",
-    "radio",
-    "switch",
-    "tab"
-  ],
-  hidden: []
+var ELEMENT_SPECS = {
+  input: inputElementSpec,
+  img: imgElementSpec,
+  table: tableElementSpec
 };
 function getAllowedRoles(tag, props) {
-  if (tag === "input") {
-    const type = typeof props.type === "string" ? props.type : "text";
-    return ALLOWED_INPUT_ROLES[type];
-  }
-  if (tag === "img") {
-    return props.alt === "" ? [] : IMG_NAMED_ROLES;
-  }
+  const spec = ELEMENT_SPECS[tag];
+  if (spec) return resolveAllowedRoles(spec, props);
   return ALLOWED_ROLES[tag];
 }
 var removeRoleFix = {
@@ -2410,21 +2531,24 @@ var removeLandmarkRoleOverride = {
     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 [];
-  const diagnostic = HtmlDiagnostics.landmarkRoleOverride(tag, implicitRole, role);
-  return [
-    {
-      valid: false,
-      fixable: true,
-      severity: diagnostic.severity,
-      fix: removeLandmarkRoleOverride,
-      diagnostic
-    }
-  ];
-}
+var landmarkRoleRule = Object.assign(
+  ({ tag, props, implicitRole }) => {
+    if (!LANDMARK_TAG_SET.has(tag) || !implicitRole) return [];
+    const role = props.role;
+    if (!role || role === implicitRole) return [];
+    const diagnostic = HtmlDiagnostics.landmarkRoleOverride(tag, implicitRole, role);
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: diagnostic.severity,
+        fix: removeLandmarkRoleOverride,
+        diagnostic
+      }
+    ];
+  },
+  { tags: [...LANDMARK_TAG_SET] }
+);
 function requireAccessibleName({ tag, props }) {
   if ("aria-label" in props || "aria-labelledby" in props) return [];
   return [
@@ -2437,10 +2561,13 @@ function requireAccessibleName({ tag, props }) {
   ];
 }
 var NAMED_LANDMARK_TAGS = /* @__PURE__ */ new Set(["nav", "aside"]);
-function landmarkNameAdvisory(ctx) {
-  if (!ctx.implicitRole || !NAMED_LANDMARK_TAGS.has(ctx.tag)) return [];
-  return requireAccessibleName(ctx);
-}
+var landmarkNameAdvisory = Object.assign(
+  (ctx) => {
+    if (!ctx.implicitRole || !NAMED_LANDMARK_TAGS.has(ctx.tag)) return [];
+    return requireAccessibleName(ctx);
+  },
+  { tags: [...NAMED_LANDMARK_TAGS] }
+);
 var HTML_ARIA_RULES = [
   landmarkRoleRule,
   landmarkNameAdvisory,
@@ -2541,6 +2668,62 @@ var figureContract = contract([
 ]);
 var detailsContract = firstChildContract("summary", "summary");
 var fieldsetContract = firstChildContract("legend", "legend");
+var objectContract = contract([
+  { name: "param", match: isTag("param") },
+  { name: "content", match: isOpenContent("param") }
+]);
+var INTERACTIVE_CONTENT_TAGS = ["a", "button", "input", "select", "textarea", "label"];
+var buttonContract = closedContract([
+  { name: "content", match: isOpenContent(...INTERACTIVE_CONTENT_TAGS) }
+]);
+var anchorContract = closedContract([
+  { name: "content", match: isOpenContent(...INTERACTIVE_CONTENT_TAGS) }
+]);
+var LABELABLE_TAGS = [
+  "button",
+  "input",
+  "meter",
+  "output",
+  "progress",
+  "select",
+  "textarea"
+];
+var labelContract = contract([
+  { name: "control", match: isTag(...LABELABLE_TAGS), cardinality: { max: 1 } }
+]);
+var P_BLOCKED_TAGS = [
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "details",
+  "dialog",
+  "div",
+  "dl",
+  "fieldset",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hr",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "ul"
+];
+var pContract = closedContract([
+  { name: "content", match: isOpenContent(...P_BLOCKED_TAGS) }
+]);
 var mediaContract = contract([
   { name: "source", match: isTag("source") },
   { name: "track", match: isTag("track") },
@@ -2595,6 +2778,11 @@ var htmlContracts = {
   details: detailsContract,
   fieldset: fieldsetContract,
   dialog: dialogContract,
+  object: objectContract,
+  button: buttonContract,
+  a: anchorContract,
+  label: labelContract,
+  p: pContract,
   head: headContract,
   html: htmlContract
 };
@@ -2821,6 +3009,11 @@ function composeNormalizers(normalizers, fn) {
 function whenDefined(key, value) {
   return value === void 0 ? {} : { [key]: value };
 }
+function mergeAriaRules(aria, rules) {
+  if (!aria?.length) return rules;
+  if (!rules?.length) return aria;
+  return [...aria, ...rules];
+}
 function resolveFactoryOptions(options = {}) {
   const { styling, enforcement } = options;
   const composedNormalizeFn = composeNormalizers(enforcement?.props, options.normalize);
@@ -2841,7 +3034,7 @@ function resolveFactoryOptions(options = {}) {
     ...whenDefined("defaultVariants", styling?.defaults),
     ...whenDefined("compoundVariants", styling?.compounds),
     ...whenDefined("normalizeFn", composedNormalizeFn),
-    ...whenDefined("ariaRules", enforcement?.aria),
+    ...whenDefined("ariaRules", mergeAriaRules(enforcement?.aria, enforcement?.rules)),
     ...whenDefined("childRules", enforcement?.children),
     ...whenDefined("exclusiveChildren", enforcement?.exclusiveChildren),
     ...whenDefined("allowText", enforcement?.allowText),