@usefragments/core 1.4.0 → 1.5.1

package/src/rules/__tests__/fix-emission-invariant.test.ts

@@ -65,6 +65,34 @@ describe("proof-carrying fix invariant", () => {
       "token reference is not directly applicable"
     );
   });
+
+  it("keeps JavaScript member tokens advisory without inventing a CSS variable", () => {
+    const ix = buildFixtureCorpus("js-member", "radii.md");
+    const dimension = RULES.find((rule) => rule.id === "styles/no-raw-dimensions")
+      ?.run(ix)
+      .find((finding) => finding.fix);
+
+    expect(dimension?.fix).toMatchObject({
+      value: "radii.md",
+      deterministic: false,
+    });
+    expect(JSON.stringify(dimension?.fix)).not.toContain("var(--radii-md)");
+    expect(dimension?.attributes?.downgradeReason).toContain(
+      "token reference is not directly applicable"
+    );
+  });
+
+  it("fails closed when a legacy token fact has no authored reference format", () => {
+    const ix = buildFixtureCorpus("unknown");
+    const dimension = RULES.find((rule) => rule.id === "styles/no-raw-dimensions")
+      ?.run(ix)
+      .find((finding) => finding.fix);
+
+    expect(dimension?.fix?.deterministic).toBe(false);
+    expect(dimension?.attributes?.downgradeReason).toContain(
+      "token reference is not directly applicable"
+    );
+  });
 });
 
 function runEveryRule(ix: FactIndex): Finding[] {
@@ -98,7 +126,10 @@ function withoutDeterminism(fix: FindingFix): Omit<FindingFix, "deterministic">
   return rest;
 }
 
-function buildFixtureCorpus(radiusReferenceFormat: "css-var" | "dtcg" = "css-var"): FactIndex {
+function buildFixtureCorpus(
+  radiusReferenceFormat: "css-var" | "dtcg" | "js-member" | "unknown" = "css-var",
+  radiusName = "--proof-radius"
+): FactIndex {
   const ix = new FactIndex();
   ix.addMany([
     makeTokenDefinitionFact({
@@ -116,11 +147,11 @@ function buildFixtureCorpus(radiusReferenceFormat: "css-var" | "dtcg" = "css-var
       sourceNames: ["--proof-space"],
     }),
     makeTokenDefinitionFact({
-      name: "--proof-radius",
+      name: radiusName,
       value: "4px",
       category: "radius",
-      referenceFormat: radiusReferenceFormat,
-      sourceNames: ["--proof-radius"],
+      referenceFormat: radiusReferenceFormat === "unknown" ? undefined : radiusReferenceFormat,
+      sourceNames: [radiusName],
     }),
     makeTokenDefinitionFact({
       name: "--proof-font",

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

@@ -4,12 +4,116 @@ import {
   asComponentId,
   compileGlobalGovernanceFacts,
   FactIndex,
+  makeComponentDefinitionFact,
+  makeComponentIdentityFact,
   makeUsageComponentFact,
   makeUsageImportFact,
   makeUsageNodeFact,
   ruleComponentsPreferLibrary,
 } from "../index.js";
 
+describe("components/prefer-library — canonical direction containment", () => {
+  const componentKey = "src/components/Button.tsx#Button";
+
+  function indexFor(decision?: "sanction" | "reject", exported = true) {
+    const ix = new FactIndex();
+    ix.addMany(
+      compileGlobalGovernanceFacts({
+        rules: {
+          "components/prefer-library": {
+            enabled: true,
+            severity: "warning",
+            options: {
+              canonicalSources: [
+                { kind: "npm", specifier: "@mui/material", include: ["Button", "Stepper"] },
+              ],
+            },
+          },
+        },
+      })
+    );
+    const definition = makeComponentDefinitionFact({
+      file: "src/components/Button.tsx",
+      exportName: "Button",
+      exported,
+      componentKey,
+      renderRoot: {
+        resolution: "canonical",
+        canonical: "@mui/material#Button",
+        importSource: "@mui/material",
+      },
+      propSurface: [],
+    });
+    ix.add(definition);
+    ix.add(
+      makeComponentIdentityFact({
+        componentKey,
+        state: decision === "reject" ? "shadow" : "variant",
+        confidence: decision ? "confirmed" : "review",
+        canonicalTarget: "Button",
+        ...(decision ? { decisionId: `local:${decision}:${componentKey}` } : {}),
+        evidence: [definition.id],
+      })
+    );
+    return ix;
+  }
+
+  function addLocalUsage(ix: FactIndex, name: "Button" | "Stepper") {
+    ix.add(
+      makeUsageNodeFact({
+        file: "src/App.tsx",
+        nodePath: `0:${name}`,
+        element: name,
+        location: { file: "src/App.tsx", line: 3, column: 2 },
+      })
+    );
+    ix.add(
+      makeUsageImportFact({
+        file: "src/App.tsx",
+        local: name,
+        imported: name,
+        source: `./components/${name}`,
+        location: { file: "src/App.tsx", line: 1, column: 0 },
+      })
+    );
+  }
+
+  it("suppresses only the exact conflicted npm export when direction is unresolved", () => {
+    const ix = indexFor();
+    addLocalUsage(ix, "Button");
+    addLocalUsage(ix, "Stepper");
+    ix.add(
+      makeUsageNodeFact({
+        file: "src/App.tsx",
+        nodePath: "0:raw-button",
+        element: "button",
+        interactive: true,
+        location: { file: "src/App.tsx", line: 4, column: 2 },
+      })
+    );
+
+    const findings = ruleComponentsPreferLibrary(ix);
+    expect(findings).toHaveLength(1);
+    expect(findings[0]?.attributes?.suggestedComponent).toBe("Stepper");
+  });
+
+  it("keeps a sanctioned wrapper exempt and restores npm guidance after explicit rejection", () => {
+    const sanctioned = indexFor("sanction");
+    addLocalUsage(sanctioned, "Button");
+    expect(ruleComponentsPreferLibrary(sanctioned)).toHaveLength(0);
+
+    const rejected = indexFor("reject");
+    addLocalUsage(rejected, "Button");
+    expect(ruleComponentsPreferLibrary(rejected)).toHaveLength(1);
+  });
+
+  it("does not let a private helper deactivate canonical policy", () => {
+    const ix = indexFor(undefined, false);
+    addLocalUsage(ix, "Button");
+    expect(ruleComponentsPreferLibrary(ix)).toHaveLength(1);
+  });
+});
+
 // #9e — import-path identity for a DIRECTORY canonical source. A directory
 // source (e.g. `src/components/ui`) declares its canonical component NAMES via an
 // include list. The rule must:
@@ -145,4 +249,51 @@ describe("components/prefer-library — #9e directory import-path identity", ()
 
     expect(ruleComponentsPreferLibrary(ix)).toHaveLength(0);
   });
+
+  it("keeps flagging raw render roots when component identity facts are absent", () => {
+    const ix = directoryIndex();
+    ix.add(
+      makeUsageNodeFact({
+        file: "src/components/MyButton.tsx",
+        nodePath: "0:0",
+        element: "button",
+        interactive: true,
+        location: { file: "src/components/MyButton.tsx", line: 5, column: 2 },
+      })
+    );
+
+    expect(ruleComponentsPreferLibrary(ix)).toHaveLength(1);
+  });
+
+  it("suppresses only the render-root node proven to belong to a shadow definition", () => {
+    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 },
+    });
+    const unrelated = makeUsageNodeFact({
+      file: "src/App.tsx",
+      nodePath: "0:0",
+      element: "button",
+      interactive: true,
+      location: { file: "src/App.tsx", line: 9, column: 4 },
+    });
+    ix.addMany([shadowRoot, unrelated]);
+    ix.add(
+      makeComponentIdentityFact({
+        componentKey: "src/components/MyButton.tsx#MyButton",
+        state: "shadow",
+        confidence: "confirmed",
+        canonicalTarget: "Button",
+        evidence: [shadowRoot.id],
+      })
+    );
+
+    const findings = ruleComponentsPreferLibrary(ix);
+    expect(findings).toHaveLength(1);
+    expect(findings[0]?.location.file).toBe("src/App.tsx");
+  });
 });

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

@@ -15,6 +15,11 @@ import {
   type RawHtmlPrecisionTier,
 } from "../raw-html-canonical.js";
 import { ownedImportMatchesRoot, ownedImportsEqual } from "../package-identity-match.js";
+import {
+  canonicalDirectionConflictsTarget,
+  projectCanonicalDirectionConflicts,
+  type CanonicalDirectionConflict,
+} from "../canonical-direction.js";
 
 import { makeFinding } from "./finding.js";
 import type { Finding } from "./types.js";
@@ -254,8 +259,12 @@ function findClassNameReimpl(
 export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
   const policy = ix.policy.ruleConfig(RULE_ID);
   if (!policy?.enabled) return [];
-  const sources = canonicalSourcesFromPolicy(policy.options?.canonicalSources);
-  const mappings = canonicalMappingsFromPolicy(policy.options?.canonicalMappings);
+  const configuredSources = canonicalSourcesFromPolicy(policy.options?.canonicalSources);
+  const conflicts = projectCanonicalDirectionConflicts(ix, configuredSources);
+  const sources = configuredSources.map((source) => suppressConflictedExports(source, conflicts));
+  const mappings = canonicalMappingsFromPolicy(policy.options?.canonicalMappings).filter(
+    (mapping) => !canonicalDirectionConflictsTarget(conflicts, mapping.importPath, mapping.name)
+  );
   if (sources.length === 0 && mappings.length === 0) return [];
 
   const importsByFileAndLocal = indexImportsByFileAndLocal(ix);
@@ -270,6 +279,7 @@ 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 findings: Finding[] = [];
   const seenImportFixes = new Set<string>();
 
@@ -277,6 +287,7 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
     if (isCanonicalSourceImplementationFile(node.file, sources)) continue;
     if (node.element.includes(".")) continue;
     if (canonicalDirectoryResolvedNodes.has(node.id)) continue;
+    if (shadowRenderRootNodeIds.has(node.id)) continue;
     const props = propsByNode.get(node.id) ?? [];
     const textChildren = textByNode.get(node.id) ?? [];
     const importsForFile = importsByFileAndLocal.get(node.file);
@@ -603,6 +614,36 @@ export function ruleComponentsPreferLibrary(ix: FactIndex): Finding[] {
   return findings;
 }
 
+function suppressConflictedExports(
+  source: CanonicalSource,
+  conflicts: readonly CanonicalDirectionConflict[]
+): CanonicalSource {
+  if (source.kind !== "npm") return source;
+  const names = conflicts
+    .filter((conflict) => ownedImportMatchesRoot(source.specifier, conflict.packageName))
+    .map((conflict) => conflict.exportName);
+  if (names.length === 0) return source;
+  const blocked = new Set(names);
+  if (source.include) {
+    return { ...source, include: source.include.filter((name) => !blocked.has(name)) };
+  }
+  return { ...source, exclude: [...new Set([...(source.exclude ?? []), ...names])].sort() };
+}
+
+function indexShadowRenderRootNodeIds(ix: FactIndex): Set<FactId> {
+  const identities = ix.byKind("component_identity");
+  if (identities.length === 0) return new Set();
+
+  const nodeIds = new Set<FactId>();
+  for (const identity of identities) {
+    if (identity.state !== "shadow") continue;
+    for (const evidenceId of identity.evidence) {
+      if (ix.get(evidenceId)?.kind === "usage_node") nodeIds.add(evidenceId);
+    }
+  }
+  return nodeIds;
+}
+
 interface BuiltInRawHtmlMatch {
   canonical: string;
   tier: RawHtmlPrecisionTier;
@@ -1097,8 +1138,9 @@ function indexCanonicalDirectoryResolvedNodes(
 ): Set<FactId> {
   const out = new Set<FactId>();
   const directoryPaths = sources
-    .filter((source): source is Extract<CanonicalSource, { kind: "directory" }> =>
-      source.kind === "directory"
+    .filter(
+      (source): source is Extract<CanonicalSource, { kind: "directory" }> =>
+        source.kind === "directory"
     )
     .map((source) => normalizePath(source.path));
   if (directoryPaths.length === 0) return out;

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

@@ -0,0 +1,145 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  BLOCKING_RULE_ALLOWLIST,
+  compileGlobalGovernanceFacts,
+  FactIndex,
+  isDenyEligible,
+  makeComponentDefinitionFact,
+  makeComponentIdentityFact,
+  makeUsageComponentFact,
+  makeUsageNodeFact,
+  ruleComponentsShadowComponent,
+} from "../index.js";
+
+describe("components/shadow-component", () => {
+  it("emits one definition finding with usage count, blast radius, and a stable fingerprint", () => {
+    const first = shadowIndex({ definitionLine: 8 });
+    const moved = shadowIndex({ definitionLine: 80 });
+
+    const finding = ruleComponentsShadowComponent(first)[0];
+    const movedFinding = ruleComponentsShadowComponent(moved)[0];
+
+    expect(finding).toMatchObject({
+      ruleId: "components/shadow-component",
+      level: "warn",
+      location: { file: "src/components/MyButton.tsx", line: 8, column: 2 },
+      attributes: {
+        canonicalTarget: "Button",
+        usageCount: 3,
+        blastRadius: 2,
+        confidence: "confirmed",
+        state: "shadow",
+      },
+    });
+    expect(finding?.attributes).not.toHaveProperty("advisory");
+    expect(finding?.fingerprint).toBe(movedFinding?.fingerprint);
+  });
+
+  it("keeps review-tier variants permanently advisory at info severity", () => {
+    const ix = shadowIndex({ state: "variant", confidence: "review", severity: "error" });
+
+    const finding = ruleComponentsShadowComponent(ix)[0];
+
+    expect(finding).toMatchObject({
+      severity: "minor",
+      level: "warn",
+      attributes: {
+        canonicalTarget: "Button",
+        confidence: "review",
+        state: "variant",
+        advisory: true,
+      },
+    });
+    expect(isDenyEligible(finding!, true)).toBe(false);
+  });
+
+  it("honors an error severity for a confirmed shadow but never enters the 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);
+  });
+
+  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.add(makeComponentIdentityFact({ ...identity, evidence: [] }));
+
+    expect(() => ruleComponentsShadowComponent(empty)).toThrow(
+      "findings must carry at least one evidence fact"
+    );
+  });
+});
+
+function shadowIndex(
+  options: {
+    state?: "shadow" | "variant";
+    confidence?: "confirmed" | "review";
+    severity?: "warn" | "error";
+    definitionLine?: number;
+  } = {}
+): FactIndex {
+  const componentKey = "src/components/MyButton.tsx#MyButton";
+  const ix = new FactIndex();
+  ix.addMany(
+    compileGlobalGovernanceFacts({
+      rules: {
+        "components/shadow-component": {
+          enabled: true,
+          severity: options.severity ?? "warn",
+        },
+      },
+    })
+  );
+  const definition = makeComponentDefinitionFact({
+    file: "src/components/MyButton.tsx",
+    exportName: "MyButton",
+    componentKey,
+    renderRoot: { resolution: "intrinsic", tag: "button", interactive: true },
+    propSurface: ["children", "disabled"],
+  });
+  const renderRoot = makeUsageNodeFact({
+    file: definition.file,
+    nodePath: "0:0",
+    element: "button",
+    interactive: true,
+    location: {
+      file: definition.file,
+      line: options.definitionLine ?? 8,
+      column: 2,
+    },
+  });
+  ix.addMany([definition, renderRoot]);
+  ix.add(
+    makeComponentIdentityFact({
+      componentKey,
+      state: options.state ?? "shadow",
+      confidence: options.confidence ?? "confirmed",
+      canonicalTarget: "Button",
+      evidence: [definition.id, renderRoot.id],
+    })
+  );
+
+  for (const [index, file] of ["src/App.tsx", "src/App.tsx", "src/Checkout.tsx"].entries()) {
+    const node = makeUsageNodeFact({
+      file,
+      nodePath: `0:${index}`,
+      element: "MyButton",
+      location: { file, line: index + 1, column: 0 },
+    });
+    ix.addMany([
+      node,
+      makeUsageComponentFact({ nodeId: node.id, componentId: definition.componentId }),
+    ]);
+  }
+  return ix;
+}

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

@@ -0,0 +1,81 @@
+import type {
+  ComponentDefinitionFact,
+  ComponentIdentityFact,
+  FactIndex,
+  FactLocation,
+} from "../facts/index.js";
+import { indexComponentIdentityUsage } from "../identity/usage.js";
+
+import { makeFinding } from "./finding.js";
+import type { Finding } from "./types.js";
+
+export const RULE_ID = "components/shadow-component";
+export const RULE_VERSION = "1";
+
+export function ruleComponentsShadowComponent(ix: FactIndex): Finding[] {
+  const policy = ix.policy.ruleConfig(RULE_ID);
+  if (!policy?.enabled) return [];
+
+  const definitions = new Map(
+    ix.byKind("component_definition").map((definition) => [definition.componentKey, definition])
+  );
+  const usageByComponent = indexComponentIdentityUsage(ix);
+  const findings: Finding[] = [];
+
+  for (const identity of ix.byKind("component_identity")) {
+    const reviewVariant = identity.state === "variant" && identity.confidence === "review";
+    if (identity.state !== "shadow" && !reviewVariant) continue;
+
+    const definition = definitions.get(identity.componentKey);
+    if (!definition) continue;
+    const usage = usageByComponent.get(identity.componentKey);
+    const usageCount = usage?.usageCount ?? 0;
+    const blastRadius = usage?.blastRadius ?? 0;
+
+    findings.push(
+      makeFinding({
+        ruleId: RULE_ID,
+        ruleVersion: RULE_VERSION,
+        severity: reviewVariant ? "info" : (policy.severity ?? "warn"),
+        message: reviewVariant
+          ? `${definition.exportName} wraps ${identity.canonicalTarget ?? "a canonical component"}; sanction it as a variant or consolidate its usages.`
+          : `${definition.exportName} shadows ${identity.canonicalTarget ?? "a canonical component"} across ${usageCount} usage${usageCount === 1 ? "" : "s"}.`,
+        location: definitionLocation(ix, definition, identity),
+        evidence: ix.evidence(identity.evidence),
+        fingerprintIdentity: {
+          componentKey: identity.componentKey,
+          canonicalTarget: identity.canonicalTarget,
+        },
+        attributes: {
+          canonicalTarget: identity.canonicalTarget,
+          usageCount,
+          blastRadius,
+          confidence: identity.confidence,
+          state: identity.state,
+          ...(reviewVariant ? { advisory: true } : {}),
+        },
+      })
+    );
+  }
+
+  return findings;
+}
+
+function definitionLocation(
+  ix: FactIndex,
+  definition: ComponentDefinitionFact,
+  identity: ComponentIdentityFact
+): FactLocation {
+  const evidence = ix.evidence(identity.evidence).map(({ fact }) => fact);
+  const inDefinitionFile = evidence.find(
+    (fact) => "location" in fact && fact.location?.file === definition.file
+  );
+  if (inDefinitionFile && "location" in inDefinitionFile && inDefinitionFile.location) {
+    return inDefinitionFile.location;
+  }
+  const sourceLocated = evidence.find((fact) => "location" in fact && fact.location);
+  if (sourceLocated && "location" in sourceLocated && sourceLocated.location) {
+    return sourceLocated.location;
+  }
+  return { file: definition.file, line: 1, column: 0 };
+}

package/src/rules/fix-availability.ts

@@ -12,6 +12,7 @@ export const RULE_FIX_AVAILABLE = {
   "imports/preferred-path": true,
   "components/preferred-component": true,
   "components/prefer-library": true,
+  "components/shadow-component": false,
   "styles/no-raw-color": true,
   "styles/no-raw-dimensions": true,
   "styles/no-raw-spacing": true,
@@ -24,6 +25,7 @@ export const RULE_FIX_AVAILABLE = {
   "tailwind/unknown-class": false,
   "tokens/require-dual-fallback": true,
   "tokens/css-vars-must-be-defined": false,
+  "tokens/upstream-drift": false,
   "theme/no-theme-coupled-literal": false,
   "a11y/required-accessible-name": false,
   "composition/cardinality": false,

package/src/rules/index.ts

@@ -11,6 +11,7 @@ import type { FactIndex } from "../facts/index.js";
 
 import { ruleA11yRequiredAccessibleName } from "./a11y-required-accessible-name.js";
 import { ruleComponentsPreferLibrary } from "./components-prefer-library.js";
+import { ruleComponentsShadowComponent } from "./components-shadow-component.js";
 import { ruleComponentsForbiddenPropValue } from "./components-forbidden-prop-value.js";
 import { ruleComponentsUnknownProp } from "./components-unknown-prop.js";
 import { ruleCompositionCardinality, ruleCompositionCoOccurrence } from "./composition-pattern.js";
@@ -30,6 +31,7 @@ import { ruleTailwindRawColorViaToken } from "./tailwind-raw-color-via-token.js"
 import { ruleTailwindUnknownClass } from "./tailwind-unknown-class.js";
 import { ruleTokensRequireDualFallback } from "./tokens-require-dual-fallback.js";
 import { ruleTokensCssVarsMustBeDefined } from "./tokens-css-vars-must-be-defined.js";
+import { ruleTokensUpstreamDrift } from "./tokens-upstream-drift.js";
 import type { Finding } from "./types.js";
 
 export type RuleFn = (ix: FactIndex) => Finding[];
@@ -71,6 +73,11 @@ export const RULES: readonly Rule[] = [
     version: "1",
     run: ruleComponentsPreferLibrary,
   },
+  {
+    id: "components/shadow-component",
+    version: "1",
+    run: ruleComponentsShadowComponent,
+  },
   {
     id: "styles/no-raw-color",
     version: "1",
@@ -131,6 +138,11 @@ export const RULES: readonly Rule[] = [
     version: "1",
     run: ruleTokensCssVarsMustBeDefined,
   },
+  {
+    id: "tokens/upstream-drift",
+    version: "1",
+    run: ruleTokensUpstreamDrift,
+  },
   {
     id: "theme/no-theme-coupled-literal",
     version: "1",
@@ -189,6 +201,7 @@ export { BLOCKING_RULE_ALLOWLIST, gatesCi, isDenyEligible } from "./emit-gate.js
 export { ruleComponentsUnknownProp } from "./components-unknown-prop.js";
 export { ruleComponentsForbiddenPropValue } from "./components-forbidden-prop-value.js";
 export { ruleComponentsPreferLibrary } from "./components-prefer-library.js";
+export { ruleComponentsShadowComponent } from "./components-shadow-component.js";
 export { rulePropsInvalidValue } from "./props-invalid-value.js";
 export { ruleJsxPreferredImportPath } from "./jsx-preferred-import-path.js";
 export { ruleJsxPreferredComponent } from "./jsx-preferred-component.js";
@@ -204,6 +217,7 @@ export { ruleTailwindRawColorViaToken } from "./tailwind-raw-color-via-token.js"
 export { ruleTailwindUnknownClass } from "./tailwind-unknown-class.js";
 export { ruleTokensRequireDualFallback } from "./tokens-require-dual-fallback.js";
 export { ruleTokensCssVarsMustBeDefined } from "./tokens-css-vars-must-be-defined.js";
+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 { ruleCompositionCardinality, ruleCompositionCoOccurrence } from "./composition-pattern.js";