@usefragments/core 1.5.2 → 1.7.0

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.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  RULE_FAMILY_IDS,
+  RULE_FAMILY_MEMBERS,
+  isRuleFamilyId,
+  ruleFamilyMembers,
+} from "./families.js";
+import { compileGlobalGovernanceFacts } from "../facts/index.js";
+import { RULES } from "./index.js";
+import { RULE_TIER } from "./tiers.js";
+
+// The defect this file locks down: the family expansion used to be written out three
+// times (engine finding-overrides, fact compiler, integrity roster) and the three
+// disagreed — `styles/no-raw-typography` was a member in one and absent from another,
+// with nothing asserting they matched. There is one definition now; these tests are what
+// keeps a fourth copy from being worth writing.
+describe("rule families", () => {
+  it("expands only to rule ids that are actually registered", () => {
+    const registered = new Set(RULES.map((rule) => rule.id));
+    const unregistered = Object.values(RULE_FAMILY_MEMBERS)
+      .flat()
+      .filter((ruleId) => !registered.has(ruleId));
+
+    expect(unregistered).toEqual([]);
+  });
+
+  it("classifies every member in the tier map", () => {
+    const unclassified = Object.values(RULE_FAMILY_MEMBERS)
+      .flat()
+      .filter((ruleId) => !(ruleId in RULE_TIER));
+
+    expect(unclassified).toEqual([]);
+  });
+
+  // A family id is a config vocabulary word, not a rule: nothing runs under it. If one
+  // ever collided with a real rule id, `ruleFamilyMembers` would silently expand that
+  // rule into a different set.
+  it("keeps family ids disjoint from rule ids", () => {
+    const registered = new Set(RULES.map((rule) => rule.id));
+    expect([...RULE_FAMILY_IDS].filter((id) => registered.has(id))).toEqual([]);
+  });
+
+  // The member whose absence caused the original divergence. Asserting the definition is
+  // not enough — this pins the BEHAVIOR the consolidation changed: a family entry now
+  // compiles an effective rule config for typography like it always did for color.
+  it("compiles a rule config for every member of an authored family entry", () => {
+    const compiled = compileGlobalGovernanceFacts({
+      rules: { "tokens/hardcoded-values": { enabled: true, severity: "warn" } },
+    })
+      .filter((fact) => fact.kind === "governance_rule_config")
+      .map((fact) => fact.ruleId)
+      .sort();
+
+    // A superset check: the family id keeps its own passthrough entry alongside the
+    // expansion. What matters is that no member is missing.
+    for (const member of RULE_FAMILY_MEMBERS["tokens/hardcoded-values"]!) {
+      expect(compiled).toContain(member);
+    }
+    expect(compiled).toContain("styles/no-raw-typography");
+  });
+
+  it("expands a family and passes a concrete rule id through unchanged", () => {
+    expect(ruleFamilyMembers("tokens/hardcoded-values")).toContain("styles/no-raw-typography");
+    expect(ruleFamilyMembers("styles/no-raw-color")).toEqual(["styles/no-raw-color"]);
+    expect(isRuleFamilyId("tokens/hardcoded-values")).toBe(true);
+    expect(isRuleFamilyId("styles/no-raw-color")).toBe(false);
+  });
+});

package/src/rules/families.ts

@@ -0,0 +1,52 @@
+/**
+ * Rule families — the single source of truth for the broad ids a config may name
+ * instead of a concrete rule.
+ *
+ * `govern.rules` accepts two vocabularies: a concrete rule id (`styles/no-raw-color`)
+ * and a **family** id (`tokens/hardcoded-values`) that stands for several rules at once.
+ * Presets and Cloud-served policies author the family form, so this expansion decides
+ * what a preset or a served policy actually turns on.
+ *
+ * It used to be written out three times — the engine's finding-override pass, the fact
+ * compiler, and the governance-integrity roster — and the three disagreed:
+ * `styles/no-raw-typography` was a member of `tokens/hardcoded-values` in the engine and
+ * absent from the compiler, so one config produced two different answers about the same
+ * rule and nothing asserted they matched. One definition, one expansion, one coverage
+ * test (`families.test.ts` checks every member is a registered rule id).
+ *
+ * Family ids are NOT rule ids: nothing runs under `tokens/hardcoded-values`, it only
+ * expands. Adding a rule to a family is a behavior change for every config that names
+ * the family — classify new rules here in the same change that registers them.
+ */
+
+export const RULE_FAMILY_MEMBERS: Readonly<Record<string, readonly string[]>> = {
+  "tokens/hardcoded-values": [
+    "styles/no-raw-color",
+    "styles/no-raw-spacing",
+    "styles/no-raw-typography",
+    "tokens/require-dual-fallback",
+    "theme/no-theme-coupled-literal",
+  ],
+  "components/usage": [
+    "components/forbidden-prop-value",
+    "components/preferred-component",
+    "components/unknown-prop",
+    "props/invalid-value",
+  ],
+  "a11y/wcag": ["a11y/required-accessible-name", "a11y/standard"],
+};
+
+/** The family ids themselves — recognized in `govern.rules`, never executed. */
+export const RULE_FAMILY_IDS: ReadonlySet<string> = new Set(Object.keys(RULE_FAMILY_MEMBERS));
+
+export function isRuleFamilyId(ruleId: string): boolean {
+  return RULE_FAMILY_IDS.has(ruleId);
+}
+
+/**
+ * The concrete rule ids a `govern.rules` key applies to: a family expands, anything
+ * else is itself. Every consumer of the family vocabulary goes through this.
+ */
+export function ruleFamilyMembers(ruleId: string): readonly string[] {
+  return RULE_FAMILY_MEMBERS[ruleId] ?? [ruleId];
+}

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,
@@ -232,6 +242,12 @@ export {
   compareByVocabularyRank,
 } from "./tiers.js";
 export type { RuleTier } from "./tiers.js";
+export {
+  RULE_FAMILY_IDS,
+  RULE_FAMILY_MEMBERS,
+  isRuleFamilyId,
+  ruleFamilyMembers,
+} from "./families.js";
 export { customerDefaultRuleStates, fragmentsPresetRuleStates } from "./presets.js";
 export type { PresetRuleState } from "./presets.js";
 export {