@usefragments/core 1.6.0 → 1.7.0

package/src/rules/a11y-standard.ts

@@ -0,0 +1,102 @@
+import type { FactIndex, UsagePropResolvedFact } from "../facts/index.js";
+
+import { isAriaHidden } from "./a11y-utils.js";
+import { makeFinding } from "./finding.js";
+import type { Finding } from "./types.js";
+import { indexPropsByNodeId } from "./utils.js";
+
+export const RULE_ID = "a11y/standard";
+export const RULE_VERSION = "1";
+
+const KEY_HANDLERS = new Set(["onKeyDown", "onKeyUp", "onKeyPress"]);
+
+/**
+ * Narrow static standard check: a non-native `role="button"` needs both a
+ * keyboard-focus path and a keyboard activation handler. This intentionally
+ * does not claim to be a complete WCAG or axe implementation.
+ */
+export function ruleA11yStandard(ix: FactIndex): Finding[] {
+  const policy = ix.policy.ruleConfig(RULE_ID);
+  if (!policy?.enabled) return [];
+
+  const propsByNode = indexPropsByNodeId(ix);
+  const findings: Finding[] = [];
+  for (const node of ix.byKind("usage_node")) {
+    if (node.role?.trim().toLowerCase() !== "button") continue;
+    const props = propsByNode.get(node.id) ?? [];
+    if (isAriaHidden(props) || isNativeButton(node.element, props)) continue;
+
+    const missing = [
+      ...(hasFocusableTabIndex(props) ? [] : ["tabIndex"]),
+      ...(hasKeyHandler(props) ? [] : ["keyboard handler"]),
+    ];
+    if (missing.length === 0) continue;
+
+    findings.push(
+      makeFinding({
+        ruleId: RULE_ID,
+        ruleVersion: RULE_VERSION,
+        severity: policy.severity ?? "warn",
+        message: `<${node.element} role="button"> is missing ${missing.join(
+          " and "
+        )}. Non-native buttons need tabIndex plus keyboard activation handling.`,
+        location: node.location,
+        evidence: ix.evidence([
+          node.id,
+          policy.id,
+          ...props
+            .filter(
+              (prop) =>
+                prop.prop === "tabIndex" ||
+                prop.prop === "tabindex" ||
+                KEY_HANDLERS.has(prop.prop)
+            )
+            .map((prop) => prop.id),
+        ]),
+        fingerprintIdentity: {
+          file: node.file,
+          element: node.element,
+          nodePath: node.nodePath,
+          standard: "keyboard-role-button",
+        },
+        attributes: {
+          standard: "keyboard-role-button",
+          role: "button",
+          missing,
+        },
+      })
+    );
+  }
+  return findings;
+}
+
+function isNativeButton(element: string, props: readonly UsagePropResolvedFact[]): boolean {
+  if (element.toLowerCase() === "button") return true;
+  if (element.toLowerCase() !== "input") return false;
+  return props.some(
+    (prop) =>
+      prop.prop === "type" &&
+      prop.resolution === "static" &&
+      ["button", "submit", "reset"].includes(String(prop.value).toLowerCase())
+  );
+}
+
+function hasFocusableTabIndex(props: readonly UsagePropResolvedFact[]): boolean {
+  return props.some((prop) => {
+    if (prop.prop !== "tabIndex" && prop.prop !== "tabindex") return false;
+    if (prop.resolution === "dynamic") return true;
+    if (prop.resolution !== "static") return false;
+    const value = typeof prop.value === "number" ? prop.value : Number(prop.value);
+    return Number.isFinite(value) && value >= 0;
+  });
+}
+
+function hasKeyHandler(props: readonly UsagePropResolvedFact[]): boolean {
+  return props.some(
+    (prop) =>
+      KEY_HANDLERS.has(prop.prop) &&
+      prop.resolution !== "spread" &&
+      prop.value !== null &&
+      prop.value !== false
+  );
+}

package/src/rules/a11y-utils.ts

@@ -0,0 +1,7 @@
+import type { UsagePropResolvedFact } from "../facts/index.js";
+
+export function isAriaHidden(props: readonly UsagePropResolvedFact[]): boolean {
+  const prop = props.find((candidate) => candidate.prop === "aria-hidden");
+  if (!prop || prop.resolution !== "static") return false;
+  return prop.value === true || prop.value === "true";
+}

package/src/rules/components-prefer-library.test.ts

@@ -125,20 +125,19 @@ describe("components/prefer-library — canonical direction containment", () =>
 describe("components/prefer-library — #9e directory import-path identity", () => {
   const CANONICAL_DIR = "src/components/ui";
 
-  function directoryIndex() {
+  function directoryIndex(options: { shadowEnabled?: boolean } = {}) {
     const ix = new FactIndex();
     ix.addMany(
       compileGlobalGovernanceFacts({
+        canonicalSources: [
+          { kind: "directory", path: CANONICAL_DIR, include: ["Button", "Input"] },
+        ],
         rules: {
           "components/prefer-library": {
             enabled: true,
             severity: "warning",
-            options: {
-              canonicalSources: [
-                { kind: "directory", path: CANONICAL_DIR, include: ["Button", "Input"] },
-              ],
-            },
           },
+          ...(options.shadowEnabled === false ? { "components/shadow-component": false } : {}),
         },
       })
     );
@@ -184,31 +183,12 @@ describe("components/prefer-library — #9e directory import-path identity", ()
     expect(ruleComponentsPreferLibrary(ix)).toHaveLength(0);
   });
 
-  it("flags a local impostor Button imported from outside the canonical directory and redirects to the canonical path", () => {
+  it("does not advertise a directory path as an import redirect for a local impostor", () => {
     const ix = directoryIndex();
     // No usage_component fact: the impostor's import resolved OUTSIDE the dir.
     addButtonUsage(ix, { source: "../features/FakeButton" });
 
-    const findings = ruleComponentsPreferLibrary(ix);
-    expect(findings).toHaveLength(1);
-    expect(findings[0]).toMatchObject({
-      ruleId: "components/prefer-library",
-      code: "FUI1004",
-      fix: {
-        kind: "replaceImport",
-        from: "../features/FakeButton",
-        to: CANONICAL_DIR,
-        deterministic: false,
-      },
-      attributes: {
-        suggestedComponent: "Button",
-        suggestedImport: CANONICAL_DIR,
-        advisory: true,
-        contractProof: "missing",
-      },
-    });
-    // Advisory only — never a hard error/block.
-    expect(findings[0].level).toBe("warn");
+    expect(ruleComponentsPreferLibrary(ix)).toHaveLength(0);
   });
 
   it("does not flag a same-name Button imported from a third-party package (collision guard)", () => {
@@ -282,13 +262,22 @@ describe("components/prefer-library — #9e directory import-path identity", ()
       location: { file: "src/App.tsx", line: 9, column: 4 },
     });
     ix.addMany([shadowRoot, unrelated]);
+    ix.add(
+      makeComponentDefinitionFact({
+        file: "src/components/MyButton.tsx",
+        exportName: "MyButton",
+        componentKey: "src/components/MyButton.tsx#MyButton",
+        renderRoot: { resolution: "intrinsic", tag: "button", interactive: true },
+        propSurface: [],
+      })
+    );
     ix.add(
       makeComponentIdentityFact({
         componentKey: "src/components/MyButton.tsx#MyButton",
         state: "shadow",
         confidence: "confirmed",
         canonicalTarget: "Button",
-        evidence: [shadowRoot.id],
+        evidence: [shadowRoot.id, unrelated.id],
       })
     );
 
@@ -296,4 +285,62 @@ describe("components/prefer-library — #9e directory import-path identity", ()
     expect(findings).toHaveLength(1);
     expect(findings[0]?.location.file).toBe("src/App.tsx");
   });
+
+  it("keeps the usage-level finding when shadow-component is explicitly disabled", () => {
+    const ix = directoryIndex({ shadowEnabled: false });
+    const shadowRoot = makeUsageNodeFact({
+      file: "src/components/MyButton.tsx",
+      nodePath: "0:0",
+      element: "button",
+      interactive: true,
+      location: { file: "src/components/MyButton.tsx", line: 5, column: 2 },
+    });
+    ix.addMany([
+      shadowRoot,
+      makeComponentDefinitionFact({
+        file: "src/components/MyButton.tsx",
+        exportName: "MyButton",
+        componentKey: "src/components/MyButton.tsx#MyButton",
+        renderRoot: { resolution: "intrinsic", tag: "button", interactive: true },
+        propSurface: [],
+      }),
+      makeComponentIdentityFact({
+        componentKey: "src/components/MyButton.tsx#MyButton",
+        state: "shadow",
+        confidence: "confirmed",
+        canonicalTarget: "Button",
+        evidence: [shadowRoot.id],
+      }),
+    ]);
+
+    expect(ruleComponentsPreferLibrary(ix)).toEqual([
+      expect.objectContaining({
+        ruleId: "components/prefer-library",
+        location: expect.objectContaining({ file: "src/components/MyButton.tsx" }),
+      }),
+    ]);
+  });
+
+  it("keeps the usage-level finding for an orphan shadow identity that cannot emit", () => {
+    const ix = directoryIndex();
+    const shadowRoot = makeUsageNodeFact({
+      file: "src/components/MyButton.tsx",
+      nodePath: "0:0",
+      element: "button",
+      interactive: true,
+      location: { file: "src/components/MyButton.tsx", line: 5, column: 2 },
+    });
+    ix.addMany([
+      shadowRoot,
+      makeComponentIdentityFact({
+        componentKey: "src/components/MyButton.tsx#MyButton",
+        state: "shadow",
+        confidence: "confirmed",
+        canonicalTarget: "Button",
+        evidence: [shadowRoot.id],
+      }),
+    ]);
+
+    expect(ruleComponentsPreferLibrary(ix)).toHaveLength(1);
+  });
 });

package/src/rules/components-prefer-library.ts

@@ -279,7 +279,10 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
   // comparison of the raw specifier could never recognize them, so the resolved
   // fact is the identity of record. Never flag them as import impostors.
   const canonicalDirectoryResolvedNodes = indexCanonicalDirectoryResolvedNodes(ix, sources);
-  const shadowRenderRootNodeIds = indexShadowRenderRootNodeIds(ix);
+  const shadowRenderRootNodeIds =
+    ix.policy.ruleConfig("components/shadow-component")?.enabled === true
+      ? indexShadowRenderRootNodeIds(ix)
+      : new Set<FactId>();
   const findings: Finding[] = [];
   const seenImportFixes = new Set<string>();
 
@@ -555,7 +558,10 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
         continue;
       }
     }
-    const suggestedImport = sourceLabel(suggestion);
+    const importReady = suggestion.kind !== "directory";
+    const suggestedImport = importReady
+      ? sourceLabel(suggestion)
+      : "the canonical component directory (resolve its configured import alias)";
     const precisionTier = builtIn?.tier ?? "exact-html";
     const rawElement = formatRawElement(node, props);
 
@@ -563,7 +569,9 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
       makeFinding({
         ruleId: RULE_ID,
         ruleVersion: RULE_VERSION,
-        severity: severityForTier(policy.severity, precisionTier),
+        severity: importReady
+          ? severityForTier(policy.severity, precisionTier)
+          : capAdvisorySeverity(policy.severity),
         message: messageForBuiltInMatch({
           node,
           rawElement,
@@ -580,7 +588,8 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
           suggestedComponent,
           suggestedImport,
         },
-        ...(!isRawHtmlAdvisoryTier(precisionTier) &&
+        ...(importReady &&
+        !isRawHtmlAdvisoryTier(precisionTier) &&
         isIdentifier(node.element) &&
         isIdentifier(suggestedComponent)
           ? {
@@ -599,13 +608,15 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
         attributes: {
           rawValue: node.element,
           suggestedComponent,
-          suggestedImport,
           suggestedImportSourceKind: suggestion.kind,
+          ...(importReady
+            ? { suggestedImport }
+            : { canonicalDirectory: suggestion.path, importReady: false }),
           precisionTier,
           propCompatibility: "unknown",
           ...(builtIn?.matchedRole ? { matchedRole: builtIn.matchedRole } : {}),
           ...(builtIn?.inputType ? { matchedInputType: builtIn.inputType } : {}),
-          ...(isRawHtmlAdvisoryTier(precisionTier) ? { advisory: true } : {}),
+          ...(isRawHtmlAdvisoryTier(precisionTier) || !importReady ? { advisory: true } : {}),
         },
       })
     );
@@ -634,11 +645,24 @@ function indexShadowRenderRootNodeIds(ix: FactIndex): Set<FactId> {
   const identities = ix.byKind("component_identity");
   if (identities.length === 0) return new Set();
 
+  const definitions = new Map(
+    ix
+      .byKind("component_definition")
+      .map((definition) => [definition.componentKey, definition] as const)
+  );
   const nodeIds = new Set<FactId>();
   for (const identity of identities) {
     if (identity.state !== "shadow") continue;
+    // Suppress the usage-level duplicate only when the definition-level shadow
+    // rule can actually emit. An orphan identity fact must not turn governance
+    // into a no-op by hiding the only actionable finding.
+    const definition = definitions.get(identity.componentKey);
+    if (!definition) continue;
     for (const evidenceId of identity.evidence) {
-      if (ix.get(evidenceId)?.kind === "usage_node") nodeIds.add(evidenceId);
+      const evidence = ix.get(evidenceId);
+      if (evidence?.kind === "usage_node" && evidence.file === definition.file) {
+        nodeIds.add(evidenceId);
+      }
     }
   }
   return nodeIds;
@@ -1115,14 +1139,10 @@ function sourceLabel(source: CanonicalSource): string {
 function canonicalImportPath(source: CanonicalSource): string | undefined {
   if (source.kind === "npm") return source.specifier;
   if (source.kind === "registry") return source.importPath;
-  // #9e — a directory canonical source *does* have a redirect target: its own
-  // directory path. Returning it lets the import-identity branch point a local
-  // impostor (`<Button>` from `../features/FakeButton`) back at the canonical
-  // directory instead of `continue`-ing to zero findings. Gate on an explicit
-  // include list: without curated NAMES, `sourceIncludesComponent` matches every
-  // PascalCase import, so a redirect target here would blanket-flag them all
-  // (#224). Include-less directory sources keep the old no-target behavior.
-  return source.include?.length ? source.path : undefined;
+  // A filesystem directory proves ownership but is not necessarily a valid
+  // module specifier. Only an explicit mapping/registry importPath can produce
+  // an import redirect.
+  return undefined;
 }
 
 /**

package/src/rules/components-shadow-component.test.ts

@@ -54,24 +54,36 @@ describe("components/shadow-component", () => {
     expect(isDenyEligible(finding!, true)).toBe(false);
   });
 
-  it("honors an error severity for a confirmed shadow but never enters the write deny-set", () => {
+  it("allows a confirmed error-severity shadow to enter the shared CI/write deny-set", () => {
     const finding = ruleComponentsShadowComponent(shadowIndex({ severity: "error" }))[0];
 
     expect(finding?.level).toBe("error");
     expect(finding?.attributes).not.toHaveProperty("advisory");
-    expect(BLOCKING_RULE_ALLOWLIST.has("components/shadow-component")).toBe(false);
-    expect(isDenyEligible(finding!, false)).toBe(false);
+    expect(BLOCKING_RULE_ALLOWLIST.has("components/shadow-component")).toBe(true);
+    expect(isDenyEligible(finding!, false)).toBe(true);
+  });
+
+  it("never denies a likely shadow classification, even when CI severity is error", () => {
+    const finding = ruleComponentsShadowComponent(
+      shadowIndex({ confidence: "likely", severity: "error" })
+    )[0];
+
+    expect(finding).toMatchObject({
+      level: "error",
+      attributes: {
+        state: "shadow",
+        confidence: "likely",
+        canonicalTarget: "Button",
+      },
+    });
+    expect(isDenyEligible(finding!, true)).toBe(false);
   });
 
   it("throws rather than emitting an evidence-free finding", () => {
     const ix = shadowIndex();
     const identity = ix.byKind("component_identity")[0]!;
     const empty = new FactIndex();
-    empty.addMany(
-      ix
-        .all()
-        .filter((fact) => fact.id !== identity.id)
-    );
+    empty.addMany(ix.all().filter((fact) => fact.id !== identity.id));
     empty.add(makeComponentIdentityFact({ ...identity, evidence: [] }));
 
     expect(() => ruleComponentsShadowComponent(empty)).toThrow(
@@ -83,7 +95,7 @@ describe("components/shadow-component", () => {
 function shadowIndex(
   options: {
     state?: "shadow" | "variant";
-    confidence?: "confirmed" | "review";
+    confidence?: "confirmed" | "likely" | "review";
     severity?: "warn" | "error";
     definitionLine?: number;
   } = {}

package/src/rules/emit-gate.test.ts

@@ -11,6 +11,18 @@ const base = {
   fix: { deterministic: true },
 } as unknown as Finding;
 
+const confirmedShadowAttributes = {
+  state: "shadow",
+  confidence: "confirmed",
+  canonicalTarget: "Button",
+};
+
+const confirmedShadow = {
+  ruleId: "components/shadow-component",
+  severity: "serious",
+  attributes: confirmedShadowAttributes,
+} as unknown as Finding;
+
 describe("isDenyEligible", () => {
   it("denies a confident, allowlisted, CI-gating, deterministic finding", () => {
     expect(isDenyEligible(base, false)).toBe(true);
@@ -35,6 +47,15 @@ describe("isDenyEligible", () => {
     expect(isDenyEligible(warn, true)).toBe(true);
   });
 
+  it("denies a source-backed off-contract token at error severity", () => {
+    const tokenDrift = {
+      ruleId: "tokens/css-vars-must-be-defined",
+      severity: "serious",
+      evidenceGrade: "source_backed",
+    } as unknown as Finding;
+    expect(isDenyEligible(tokenDrift, false)).toBe(true);
+  });
+
   it.each(["none", "runtime_advisory", "provenance_bound"] as const)(
     "never gates or denies %s evidence",
     (evidenceGrade) => {
@@ -64,17 +85,66 @@ describe("isDenyEligible", () => {
     const exactComponent = {
       ...base,
       fix: { deterministic: false },
-      attributes: { precisionTier: "exact-html", propCompatibility: "observed-complete" },
+      attributes: {
+        precisionTier: "exact-html",
+        propCompatibility: "observed-complete",
+        suggestedComponent: "Button",
+      },
     } as unknown as Finding;
     expect(isDenyEligible(exactComponent, false)).toBe(true);
   });
 
-  it("keeps a component replacement advisory when observed props are not proven compatible", () => {
+  it("denies an exact canonical bypass even when no deterministic replacement is available", () => {
     const incompleteComponent = {
       ...base,
       fix: { deterministic: false },
-      attributes: { precisionTier: "exact-html", propCompatibility: "incomplete" },
+      attributes: {
+        precisionTier: "exact-html",
+        propCompatibility: "unknown",
+        suggestedComponent: "Button",
+        suggestedImportSourceKind: "directory",
+      },
     } as unknown as Finding;
-    expect(isDenyEligible(incompleteComponent, false)).toBe(false);
+    expect(isDenyEligible(incompleteComponent, false)).toBe(true);
+  });
+
+  it("denies a confirmed, non-advisory shadow that gates CI", () => {
+    expect(isDenyEligible(confirmedShadow, false)).toBe(true);
+  });
+
+  it("does not deny a non-confirmed or malformed shadow classification", () => {
+    expect(
+      isDenyEligible(
+        {
+          ...confirmedShadow,
+          attributes: { ...confirmedShadowAttributes, confidence: "likely" },
+        } as unknown as Finding,
+        false
+      )
+    ).toBe(false);
+    expect(
+      isDenyEligible(
+        {
+          ...confirmedShadow,
+          attributes: { ...confirmedShadowAttributes, state: "variant" },
+        } as unknown as Finding,
+        false
+      )
+    ).toBe(false);
+    expect(
+      isDenyEligible(
+        {
+          ...confirmedShadow,
+          attributes: { state: "shadow", confidence: "confirmed" },
+        } as unknown as Finding,
+        false
+      )
+    ).toBe(false);
+  });
+
+  it("only denies a warn-level confirmed shadow under failOnWarnings", () => {
+    const warn = { ...confirmedShadow, severity: "moderate" } as unknown as Finding;
+    expect(isDenyEligible(warn, false)).toBe(false);
+    expect(isDenyEligible(warn, true)).toBe(true);
   });
 });

package/src/rules/emit-gate.ts

@@ -27,7 +27,9 @@ export const BLOCKING_RULE_ALLOWLIST: ReadonlySet<string> = new Set([
   "styles/no-raw-spacing", // off-scale / untokenized spacing literal
   "tailwind/off-scale-spacing-token", // off-scale Tailwind spacing utility
   "components/prefer-library", // raw element bypasses a canonical component
+  "components/shadow-component", // confirmed local semantic control shadows a canonical
   "components/preferred-component", // imported component bypasses its canonical
+  "tokens/css-vars-must-be-defined", // off-contract custom property reference
 ]);
 
 /**
@@ -52,18 +54,31 @@ export function isDenyEligible(finding: Finding, failOnWarnings: boolean): boole
   // their severity or sets failOnWarnings. Same "only deny when the engine is
   // confident" principle as the non-deterministic-fix guard below.
   if (finding.attributes?.advisory === true) return false;
+  // A shadow classification is deterministic enough to deny only when the
+  // identity engine confirmed both the shadow state and its canonical target.
+  // Likely/review identities remain reportable, but the write gate stays a
+  // strict high-confidence subset of CI.
+  if (
+    finding.ruleId === "components/shadow-component" &&
+    (finding.attributes?.state !== "shadow" ||
+      finding.attributes?.confidence !== "confirmed" ||
+      typeof finding.attributes?.canonicalTarget !== "string")
+  ) {
+    return false;
+  }
   if (!gatesCi(finding, failOnWarnings)) return false;
   // Most explicitly non-deterministic fixes are the engine's own low-confidence
-  // signal (for example, several tokens share a value). A prefer-library
-  // finding may still be an exact policy violation, but hard-denying it is only
-  // DX-safe when the configured mapping proves that every observed prop can be
-  // preserved. The conform AST preflight independently checks the source and
-  // binding before any edit is applied.
+  // signal (for example, several tokens share a value). Exact raw-HTML bypasses
+  // are different: the declared canonical source proves the policy violation
+  // even when the engine cannot safely rewrite every prop. Enforcement and
+  // autofix confidence are intentionally separate; advisory precision tiers
+  // were already rejected above.
   if (finding.fix?.deterministic === false) {
-    if (
-      finding.ruleId !== "components/prefer-library" ||
-      finding.attributes?.propCompatibility !== "observed-complete"
-    ) {
+    const exactCanonicalBypass =
+      finding.ruleId === "components/prefer-library" &&
+      finding.attributes?.precisionTier === "exact-html" &&
+      typeof finding.attributes?.suggestedComponent === "string";
+    if (!exactCanonicalBypass) {
       return false;
     }
   }

package/src/rules/families.ts

@@ -33,7 +33,7 @@ export const RULE_FAMILY_MEMBERS: Readonly<Record<string, readonly string[]>> =
     "components/unknown-prop",
     "props/invalid-value",
   ],
-  "a11y/wcag": ["a11y/required-accessible-name"],
+  "a11y/wcag": ["a11y/required-accessible-name", "a11y/standard"],
 };
 
 /** The family ids themselves — recognized in `govern.rules`, never executed. */

package/src/rules/fix-availability.ts

@@ -28,6 +28,7 @@ export const RULE_FIX_AVAILABLE = {
   "tokens/upstream-drift": false,
   "theme/no-theme-coupled-literal": false,
   "a11y/required-accessible-name": false,
+  "a11y/standard": false,
   "composition/cardinality": false,
   "composition/co-occurrence": false,
 } as const satisfies Readonly<Record<string, boolean>>;

package/src/rules/index.ts

@@ -9,7 +9,11 @@
 
 import type { FactIndex } from "../facts/index.js";
 
-import { ruleA11yRequiredAccessibleName } from "./a11y-required-accessible-name.js";
+import {
+  RULE_VERSION as A11Y_REQUIRED_ACCESSIBLE_NAME_VERSION,
+  ruleA11yRequiredAccessibleName,
+} from "./a11y-required-accessible-name.js";
+import { ruleA11yStandard } from "./a11y-standard.js";
 import { ruleComponentsPreferLibrary } from "./components-prefer-library.js";
 import { ruleComponentsShadowComponent } from "./components-shadow-component.js";
 import { ruleComponentsForbiddenPropValue } from "./components-forbidden-prop-value.js";
@@ -150,9 +154,14 @@ export const RULES: readonly Rule[] = [
   },
   {
     id: "a11y/required-accessible-name",
-    version: "1",
+    version: A11Y_REQUIRED_ACCESSIBLE_NAME_VERSION,
     run: ruleA11yRequiredAccessibleName,
   },
+  {
+    id: "a11y/standard",
+    version: "1",
+    run: ruleA11yStandard,
+  },
   {
     id: "composition/cardinality",
     version: "1",
@@ -220,6 +229,7 @@ export { ruleTokensCssVarsMustBeDefined } from "./tokens-css-vars-must-be-define
 export { ruleTokensUpstreamDrift } from "./tokens-upstream-drift.js";
 export { ruleThemeNoThemeCoupledLiteral } from "./theme-no-theme-coupled-literal.js";
 export { ruleA11yRequiredAccessibleName } from "./a11y-required-accessible-name.js";
+export { ruleA11yStandard } from "./a11y-standard.js";
 export { ruleCompositionCardinality, ruleCompositionCoOccurrence } from "./composition-pattern.js";
 export {
   RULE_TIER,