praxis-kit 6.2.1 → 6.5.0

package/dist/lit/index.js

@@ -858,11 +858,28 @@ var ContractDiagnostics = {
 
 // ../../lib/contract/src/diagnostics/html.ts
 import { DiagnosticCategory as DiagnosticCategory3, DiagnosticCode as DiagnosticCode3 } from "../_shared/diagnostics.js";
+var ATTRIBUTE_IGNORED_CODES = {
+  checked: DiagnosticCode3.HtmlInputCheckedIgnoredForType,
+  multiple: DiagnosticCode3.HtmlInputMultipleIgnoredForType,
+  maxLength: DiagnosticCode3.HtmlInputMaxLengthIgnoredForType,
+  minLength: DiagnosticCode3.HtmlInputMinLengthIgnoredForType,
+  pattern: DiagnosticCode3.HtmlInputPatternIgnoredForType,
+  min: DiagnosticCode3.HtmlInputMinIgnoredForType,
+  max: DiagnosticCode3.HtmlInputMaxIgnoredForType,
+  step: DiagnosticCode3.HtmlInputStepIgnoredForType,
+  accept: DiagnosticCode3.HtmlInputAcceptIgnoredForType,
+  capture: DiagnosticCode3.HtmlInputCaptureIgnoredForType,
+  size: DiagnosticCode3.HtmlInputSizeIgnoredForType,
+  alt: DiagnosticCode3.HtmlInputAltIgnoredForType,
+  height: DiagnosticCode3.HtmlInputHeightIgnoredForType,
+  width: DiagnosticCode3.HtmlInputWidthIgnoredForType
+};
 var HtmlDiagnostics = {
   emptyRole(tag) {
     return {
       code: DiagnosticCode3.HtmlEmptyRole,
       category: DiagnosticCategory3.HTML,
+      severity: "warning",
       message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`
     };
   },
@@ -870,6 +887,7 @@ var HtmlDiagnostics = {
     return {
       code: DiagnosticCode3.HtmlImplicitRoleRedundant,
       category: DiagnosticCategory3.HTML,
+      severity: "warning",
       message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
     };
   },
@@ -877,6 +895,7 @@ var HtmlDiagnostics = {
     return {
       code: DiagnosticCode3.HtmlImplicitRoleOverride,
       category: DiagnosticCategory3.HTML,
+      severity: "error",
       message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
     };
   },
@@ -884,6 +903,7 @@ var HtmlDiagnostics = {
     return {
       code: DiagnosticCode3.HtmlStandaloneRegionOverride,
       category: DiagnosticCategory3.HTML,
+      severity: "error",
       message: `<${tag}> is a self-contained element with implicit role="${implicitRole}". Assigning role="region" has been removed.`
     };
   },
@@ -891,6 +911,7 @@ var HtmlDiagnostics = {
     return {
       code: DiagnosticCode3.HtmlLandmarkRoleOverride,
       category: DiagnosticCategory3.HTML,
+      severity: "error",
       message: `<${tag}> has a fixed landmark role="${implicitRole}". role="${role}" overrides it and confuses assistive technology. The override has been removed.`
     };
   },
@@ -898,8 +919,122 @@ var HtmlDiagnostics = {
     return {
       code: DiagnosticCode3.HtmlInvalidChild,
       category: DiagnosticCategory3.HTML,
+      severity: "error",
       message: `<${child}> is not a valid direct child of <${parent}>. Allowed: ${allowed}.`
     };
+  },
+  roleNotPermitted(tag, role, allowedRoles) {
+    const allowed = allowedRoles.length > 0 ? allowedRoles.map((r) => `"${r}"`).join(", ") : "none \u2014 no explicit role is permitted on this element";
+    return {
+      code: DiagnosticCode3.HtmlRoleNotPermitted,
+      category: DiagnosticCategory3.HTML,
+      severity: "error",
+      message: `role="${role}" is not permitted on <${tag}>. Allowed alternate role(s): ${allowed}.`,
+      rationale: 'The WAI-ARIA "ARIA in HTML" specification restricts which explicit roles a native element may take. A role outside that set is ignored or produces undefined behavior in assistive technology.'
+    };
+  },
+  // Reserved for <input>-specific facts (HTML3101–3199, see codes.ts) — later element families
+  // (button, img, table, ...) get their own reserved block and their own namespace here.
+  input: {
+    unsupportedType(type) {
+      return {
+        code: DiagnosticCode3.HtmlInputUnsupportedType,
+        category: DiagnosticCategory3.HTML,
+        severity: "warning",
+        message: `type="${type}" is not a value defined by the HTML specification. Browsers silently fall back to type="text".`,
+        rationale: 'An unrecognized input type is not invalid markup \u2014 the spec requires the "text" fallback \u2014 but it usually means a typo, since the input keeps working while silently losing the intended type-specific behavior (validation, virtual keyboard, picker UI).',
+        suggestions: [
+          {
+            title: "Check for a typo in the type value",
+            description: `"${type}" does not match any HTML5 input type.`
+          }
+        ]
+      };
+    },
+    // The user-visible problem is that the attribute is ignored — not that it "requires" a type;
+    // that's the rule's internal framing, not what the browser actually does.
+    attributeIgnoredForType(attribute, type, allowedTypes) {
+      const allowed = allowedTypes.map((t) => `"${t}"`).join(", ");
+      const code = ATTRIBUTE_IGNORED_CODES[attribute];
+      if (!code) throw new Error(`No DiagnosticCode registered for input attribute "${attribute}"`);
+      return {
+        code,
+        category: DiagnosticCategory3.HTML,
+        severity: "warning",
+        message: `"${attribute}" is ignored on <input type="${type}">.`,
+        rationale: `"${attribute}" only has an effect when type is one of: ${allowed}. Browsers silently ignore it on other input types.`,
+        suggestions: [
+          {
+            title: `Remove "${attribute}"`,
+            description: `"${attribute}" only affects <input> when type is one of: ${allowed}.`
+          }
+        ]
+      };
+    }
+  }
+};
+
+// ../../lib/contract/src/diagnostics/input-accessibility.ts
+import { DiagnosticCategory as DiagnosticCategory4, DiagnosticCode as DiagnosticCode4 } from "../_shared/diagnostics.js";
+function accessibilityFact(input) {
+  return { category: DiagnosticCategory4.Accessibility, ...input };
+}
+var InputAccessibilityDiagnostics = {
+  missingAccessibleName() {
+    return accessibilityFact({
+      code: DiagnosticCode4.A11yInputMissingAccessibleName,
+      severity: "warning",
+      message: "This input has no accessible name. Add an associated <label>, aria-label, or aria-labelledby.",
+      rationale: "Assistive technology announces a form field by its accessible name; without one, users of screen readers cannot tell what the field is for.",
+      suggestions: [
+        { title: "Add aria-label", description: 'Set aria-label="\u2026" directly on the input.' },
+        {
+          title: "Add an associated <label>",
+          description: 'Wrap the input in a <label>, or point a <label for="\u2026"> at its id.'
+        }
+      ]
+    });
+  },
+  placeholderIsNotLabel() {
+    return accessibilityFact({
+      code: DiagnosticCode4.A11yInputPlaceholderNotLabel,
+      severity: "warning",
+      message: "Placeholder text does not provide an accessible name. Add an associated <label>, aria-label, or aria-labelledby.",
+      rationale: "Placeholder text disappears as users interact with the field and is not treated as the control's accessible name by many assistive technologies.",
+      suggestions: [
+        { title: "Add aria-label", description: 'Set aria-label="\u2026" directly on the input.' },
+        {
+          title: "Add an associated <label>",
+          description: 'Wrap the input in a <label>, or point a <label for="\u2026"> at its id.'
+        }
+      ]
+    });
+  },
+  passwordMissingAutocomplete() {
+    return accessibilityFact({
+      code: DiagnosticCode4.A11yInputPasswordAutocomplete,
+      severity: "warning",
+      message: "Password inputs should specify an autoComplete value.",
+      rationale: "Without an explicit autocomplete hint, password managers and browsers cannot reliably tell a sign-in field apart from a password-creation field.",
+      suggestions: [
+        {
+          title: 'Set autoComplete="current-password"',
+          description: "Use this for sign-in forms."
+        },
+        {
+          title: 'Set autoComplete="new-password"',
+          description: "Use this for sign-up / change-password forms."
+        }
+      ]
+    });
+  },
+  requiredReadOnlyConflict() {
+    return accessibilityFact({
+      code: DiagnosticCode4.A11yInputRequiredReadOnlyConflict,
+      severity: "warning",
+      message: "The required and readOnly attributes are both present. A read-only field cannot satisfy required validation through user interaction.",
+      rationale: "This combination is valid HTML but usually indicates an unintended state. Consider using disabled instead of readOnly, or only applying required when the field is editable."
+    });
   }
 };
 
@@ -925,8 +1060,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);
 }
@@ -958,7 +1217,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
             tag,
             role: "",
             attribute: void 0,
-            severity: "warning",
+            severity: d.severity,
             phase: "evaluate"
           }
         ]
@@ -988,6 +1247,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 {
@@ -1013,7 +1273,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;
@@ -1215,44 +1475,47 @@ 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 [
         {
           valid: false,
           fixable: true,
-          severity: "error",
+          severity: diagnostic.severity,
           fix: _AriaPolicyEngine.#removeRole,
-          diagnostic: HtmlDiagnostics.implicitRoleOverride(tag, implicitRole, role)
+          diagnostic
         }
       ];
     }
-    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 [
       {
         valid: false,
         fixable: true,
-        severity: "warning",
+        severity: diagnostic.severity,
         fix: _AriaPolicyEngine.#removeRole,
-        diagnostic: HtmlDiagnostics.implicitRoleRedundant(tag, implicitRole)
+        diagnostic
       }
     ];
   }
   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 (!isStandaloneTag(tag)) return NO_VIOLATIONS2;
+    const diagnostic = HtmlDiagnostics.standaloneRegionOverride(tag, implicitRole ?? tag);
     return [
       {
         valid: false,
         fixable: true,
-        severity: "error",
+        severity: diagnostic.severity,
         fix: _AriaPolicyEngine.#removeRole,
-        diagnostic: HtmlDiagnostics.standaloneRegionOverride(tag, implicitRole ?? tag)
+        diagnostic
       }
     ];
   }
@@ -1261,7 +1524,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;
@@ -1279,62 +1542,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":
@@ -1379,11 +1586,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({
@@ -1402,26 +1609,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,
@@ -1434,20 +1633,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,
@@ -1457,51 +1650,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 [
       {
@@ -1520,7 +1683,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;
@@ -1536,18 +1699,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) => ({
@@ -1566,20 +1722,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.
@@ -1593,10 +1742,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 [
         {
@@ -1621,7 +1770,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
         }
       ];
     }
-    return NO_VIOLATIONS;
+    return NO_VIOLATIONS2;
   }
 };
 
@@ -1941,6 +2090,425 @@ var readonlyProps = ({
 // ../core/src/html/evaluators.ts
 import { warnDiagnostics as warnDiagnostics2 } from "../_shared/diagnostics.js";
 
+// ../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 };
+  delete next[key];
+  return next;
+}
+function removeAttributeFix(attribute) {
+  return {
+    kind: `removeAttribute:${attribute}`,
+    apply: ({ props }) => {
+      if (!(attribute in props)) return { applied: false, next: props };
+      return { applied: true, next: omit(props, attribute), previous: props };
+    }
+  };
+}
+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;
+    if (allowedTypes.includes(type)) return [];
+    const diagnostic = HtmlDiagnostics.input.attributeIgnoredForType(attribute, type, allowedTypes);
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: diagnostic.severity,
+        fix: removeAttributeFix(attribute),
+        diagnostic
+      }
+    ];
+  };
+  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 supportedInputTypeRule = Object.assign(
+  ({ tag, props }) => {
+    if (tag !== "input" || typeof props.type !== "string") return [];
+    const type = props.type;
+    if (HTML_INPUT_TYPES.has(type)) return [];
+    const diagnostic = HtmlDiagnostics.input.unsupportedType(type);
+    return [
+      {
+        valid: false,
+        fixable: false,
+        severity: diagnostic.severity,
+        diagnostic
+      }
+    ];
+  },
+  { readsProps: ["type"], tags: ["input"] }
+);
+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 [];
+    if ("aria-label" in props || "aria-labelledby" in props) return [];
+    const hasPlaceholder = typeof props.placeholder === "string" && props.placeholder.length > 0;
+    const diagnostic = hasPlaceholder ? InputAccessibilityDiagnostics.placeholderIsNotLabel() : InputAccessibilityDiagnostics.missingAccessibleName();
+    return [{ valid: false, fixable: false, severity: diagnostic.severity, diagnostic }];
+  },
+  {
+    readsProps: ["type", "aria-label", "aria-labelledby", "placeholder"],
+    tags: ["input"]
+  }
+);
+var PASSWORD_AUTOCOMPLETE_VALUES = ["current-password", "new-password"];
+var passwordAutocompleteRule = Object.assign(
+  ({ tag, props }) => {
+    if (tag !== "input" || props.type !== "password") return [];
+    const autoComplete = props.autoComplete;
+    const tokens = typeof autoComplete === "string" ? autoComplete.split(" ") : [];
+    if (PASSWORD_AUTOCOMPLETE_VALUES.some((value) => tokens.includes(value))) return [];
+    const diagnostic = InputAccessibilityDiagnostics.passwordMissingAutocomplete();
+    return [{ valid: false, fixable: false, severity: diagnostic.severity, diagnostic }];
+  },
+  { readsProps: ["type", "autoComplete"], tags: ["input"] }
+);
+var requiredReadOnlyConflictRule = createMutuallyExclusiveRule(REQUIRED_READONLY_CONFLICT);
+var INPUT_RULES = [
+  supportedInputTypeRule,
+  checkedRequiresCheckableTypeRule,
+  multipleRequiresSupportedTypeRule,
+  maxLengthRequiresTextTypeRule,
+  minLengthRequiresTextTypeRule,
+  patternRequiresTextTypeRule,
+  minRequiresNumericTypeRule,
+  maxRequiresNumericTypeRule,
+  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"],
+  aside: ["feed", "none", "presentation", "region", "search"],
+  footer: ["group", "none", "presentation"],
+  header: ["group", "none", "presentation"],
+  main: [],
+  nav: [],
+  a: [
+    "button",
+    "checkbox",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab",
+    "treeitem"
+  ],
+  button: [
+    "checkbox",
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  select: ["menu"],
+  h1: ["tab", "presentation", "none"],
+  h2: ["tab", "presentation", "none"],
+  h3: ["tab", "presentation", "none"],
+  h4: ["tab", "presentation", "none"],
+  h5: ["tab", "presentation", "none"],
+  h6: ["tab", "presentation", "none"],
+  ul: [
+    "directory",
+    "group",
+    "listbox",
+    "menu",
+    "menubar",
+    "radiogroup",
+    "tablist",
+    "toolbar",
+    "tree"
+  ],
+  ol: [
+    "directory",
+    "group",
+    "listbox",
+    "menu",
+    "menubar",
+    "radiogroup",
+    "tablist",
+    "toolbar",
+    "tree"
+  ],
+  li: [
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "none",
+    "presentation",
+    "radio",
+    "separator",
+    "tab",
+    "treeitem"
+  ],
+  dialog: ["alertdialog"],
+  fieldset: ["none", "presentation", "radiogroup"]
+};
+var ELEMENT_SPECS = {
+  input: inputElementSpec,
+  img: imgElementSpec,
+  table: tableElementSpec
+};
+function getAllowedRoles(tag, props) {
+  const spec = ELEMENT_SPECS[tag];
+  if (spec) return resolveAllowedRoles(spec, props);
+  return ALLOWED_ROLES[tag];
+}
+var removeRoleFix = {
+  kind: "removeRole",
+  apply: ({ props }) => {
+    if (!("role" in props)) return { applied: false, next: props };
+    const { role: _role, ...rest } = props;
+    return { applied: true, next: rest, previous: props };
+  }
+};
+var roleNotPermittedRule = Object.assign(
+  ({ tag, props, implicitRole }) => {
+    const role = props.role;
+    if (typeof role !== "string" || role.length === 0 || role === implicitRole) return [];
+    const allowed = getAllowedRoles(tag, props);
+    if (allowed === void 0 || allowed.includes(role)) return [];
+    const diagnostic = HtmlDiagnostics.roleNotPermitted(tag, role, allowed);
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: diagnostic.severity,
+        fix: removeRoleFix,
+        diagnostic
+      }
+    ];
+  },
+  { readsProps: ["role", "type", "alt"] }
+);
+
 // ../core/src/html/aria-rules.ts
 var LANDMARK_TAG_SET = /* @__PURE__ */ new Set(["article", "aside", "footer", "header", "main", "nav"]);
 var removeLandmarkRoleOverride = {
@@ -1951,20 +2519,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 [];
-  return [
-    {
-      valid: false,
-      fixable: true,
-      severity: "error",
-      fix: removeLandmarkRoleOverride,
-      diagnostic: HtmlDiagnostics.landmarkRoleOverride(tag, implicitRole, role)
-    }
-  ];
-}
+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 [
@@ -1977,11 +2549,19 @@ 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 HTML_ARIA_RULES = [landmarkRoleRule, landmarkNameAdvisory];
+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,
+  roleNotPermittedRule,
+  ...INPUT_RULES
+];
 
 // ../core/src/html/contracts.ts
 import { warnDiagnostics } from "../_shared/diagnostics.js";
@@ -2076,6 +2656,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") },
@@ -2130,6 +2766,11 @@ var htmlContracts = {
   details: detailsContract,
   fieldset: fieldsetContract,
   dialog: dialogContract,
+  object: objectContract,
+  button: buttonContract,
+  a: anchorContract,
+  label: labelContract,
+  p: pContract,
   head: headContract,
   html: htmlContract
 };
@@ -2442,21 +3083,21 @@ function validateRenderProps(diagnostics, options, props, recipeKey) {
 import { throwDiagnostics } from "../_shared/diagnostics.js";
 
 // ../core/src/factory/plugin-diagnostics.ts
-import { DiagnosticCategory as DiagnosticCategory4, DiagnosticCode as DiagnosticCode4 } from "../_shared/diagnostics.js";
+import { DiagnosticCategory as DiagnosticCategory5, DiagnosticCode as DiagnosticCode5 } from "../_shared/diagnostics.js";
 var PluginDiagnostics = {
   invalidShape(received) {
     const got = received === null ? "null" : typeof received;
     return {
-      code: DiagnosticCode4.PluginInvalidShape,
-      category: DiagnosticCategory4.Internal,
+      code: DiagnosticCode5.PluginInvalidShape,
+      category: DiagnosticCategory5.Internal,
       message: `[praxis-kit] Plugin factory must return an object with a 'pipeline' function. Got: ${got}.`
     };
   },
   pipelineReturnType(received) {
     const got = received === null ? "null" : Array.isArray(received) ? "array" : typeof received;
     return {
-      code: DiagnosticCode4.PluginPipelineReturnType,
-      category: DiagnosticCategory4.Internal,
+      code: DiagnosticCode5.PluginPipelineReturnType,
+      category: DiagnosticCategory5.Internal,
       message: `[praxis-kit] Plugin pipeline must return a string. Got: ${got}.`
     };
   }