@nadicodeai/ui 12.1.53 → 12.1.55

package/dist/eslint/index.js

@@ -1,40 +1,17 @@
 import { createHash } from "node:crypto";
 import { readdirSync, readFileSync } from "node:fs";
 
-import { menuCommandOwner } from "./rules/menu-command-owner.js";
-import { cardRowOwner } from "./rules/card-row-owner.js";
-import { confirmDestructiveAction } from "./rules/confirm-destructive-action.js";
-import { drawerOwnsItsEdges } from "./rules/drawer-owns-its-edges.js";
-import { iconControlAccessibleName } from "./rules/icon-control-accessible-name.js";
+import { builtinRules } from "eslint/use-at-your-own-risk";
+
 import { noAppFeatureComponent } from "./rules/no-app-feature-component.js";
-import { noBarePageNavigation } from "./rules/no-bare-page-navigation.js";
-import { noStoreCast } from "./rules/no-store-cast.js";
-import { noElevatedEdge } from "./rules/no-elevated-edge.js";
-import { noExistenceOnlyAssertion } from "./rules/no-existence-only-assertion.js";
-import { noNestedOverlay } from "./rules/no-nested-overlay.js";
-import { noOffGridSpacing } from "./rules/no-off-grid-spacing.js";
-import { noRawShadow } from "./rules/no-raw-shadow.js";
-import { noRouteWidthOverride } from "./rules/no-route-width-override.js";
-import { preferRadioForFewStaticOptions } from "./rules/prefer-radio-for-few-static-options.js";
+import { noChoiceControlWrapper } from "./rules/no-choice-control-wrapper.js";
+import { noComment } from "./rules/no-comment.js";
 import { noDeprecatedZodApi } from "./rules/no-deprecated-zod-api.js";
-import { noMonoTitleRegister } from "./rules/no-mono-title-register.js";
 import { noPackageComponentRedefinition } from "./rules/no-package-component-redefinition.js";
-import { noPairedSizeUtility } from "./rules/no-paired-size-utility.js";
-import { noRestingSettingsControl } from "./rules/no-resting-settings-control.js";
-import { oneControlHeight } from "./rules/one-control-height.js";
-import { overlayBodyOwnsScroll } from "./rules/overlay-body-owns-scroll.js";
-import { overlayMountsClosed } from "./rules/overlay-mounts-closed.js";
-import { tableColumnWrapsByMeta } from "./rules/table-column-wraps-by-meta.js";
 import { noShadcnAppearanceOverride } from "./rules/no-shadcn-appearance-override.js";
 import { noSubjectDerivedExpectation } from "./rules/no-subject-derived-expectation.js";
-import { noUnpinnedVercelFunctionsImport } from "./rules/no-unpinned-vercel-functions-import.js";
-import { noNativeVisibleControl } from "./rules/no-native-visible-control.js";
-import { noRepaintedFocus } from "./rules/no-repainted-focus.js";
-import { noInvalidTokenUtility } from "./rules/no-invalid-token-utility.js";
-import { noTokenCategoryBypass } from "./rules/no-token-category-bypass.js";
 import { serverActionDiscipline } from "./rules/server-action-discipline.js";
-import { settingsSectionDescription } from "./rules/settings-section-description.js";
-import { shadcnComposition } from "./rules/shadcn-composition.js";
+import { strictDesignSystemSelectors } from "./strict-design-system.js";
 
 /**
  * The plugin carries no version of its own.
@@ -73,6 +50,7 @@ function readPublishedVersion() {
  */
 export const rulesDigest = digestOf([
   "index.js",
+  "strict-design-system.js",
   ...readdirSync(new URL("./rules/", import.meta.url))
     .filter((name) => name.endsWith(".js") && !name.endsWith(".test.js"))
     .sort()
@@ -90,21 +68,26 @@ function digestOf(paths) {
   return hash.digest("hex").slice(0, 16);
 }
 
+/*
+ * The strict design-system checks that a selector expresses are core
+ * `no-restricted-syntax`, registered here once per check under the check's own
+ * name, with the check's selectors as the rule's default options. A config that
+ * turns on one `nadicodeai/<check>` alone therefore runs that check, and
+ * `flat/strict` is self-contained for a consumer of `@nadicodeai/ui/eslint`.
+ */
+const restrictedSyntax = builtinRules.get("no-restricted-syntax");
+const strictSelectorRules = Object.fromEntries(
+  Object.entries(strictDesignSystemSelectors).map(([name, entries]) => [
+    name,
+    { ...restrictedSyntax, meta: { ...restrictedSyntax.meta, defaultOptions: entries } },
+  ]),
+);
+
 export const strictDesignSystemRules = {
-  "nadicodeai/card-row-owner": "error",
-  "nadicodeai/drawer-owns-its-edges": "error",
-  "nadicodeai/icon-control-accessible-name": "error",
-  "nadicodeai/no-invalid-token-utility": "error",
-  "nadicodeai/no-native-visible-control": "error",
-  "nadicodeai/no-nested-overlay": "error",
-  "nadicodeai/no-off-grid-spacing": "error",
-  "nadicodeai/no-raw-shadow": "error",
-  "nadicodeai/no-repainted-focus": "error",
+  ...Object.fromEntries(
+    Object.keys(strictDesignSystemSelectors).map((name) => [`nadicodeai/${name}`, "error"]),
+  ),
   "nadicodeai/no-shadcn-appearance-override": "error",
-  "nadicodeai/no-token-category-bypass": "error",
-  "nadicodeai/overlay-body-owns-scroll": "error",
-  "nadicodeai/overlay-mounts-closed": "error",
-  "nadicodeai/prefer-radio-for-few-static-options": "error",
 };
 
 /** @type {import('eslint').ESLint.Plugin} */
@@ -115,40 +98,15 @@ const plugin = {
   },
   configs: {},
   rules: {
-    "card-row-owner": cardRowOwner,
-    "menu-command-owner": menuCommandOwner,
-    "confirm-destructive-action": confirmDestructiveAction,
-    "drawer-owns-its-edges": drawerOwnsItsEdges,
-    "icon-control-accessible-name": iconControlAccessibleName,
+    ...strictSelectorRules,
     "no-app-feature-component": noAppFeatureComponent,
-    "no-bare-page-navigation": noBarePageNavigation,
-    "no-store-cast": noStoreCast,
-    "no-elevated-edge": noElevatedEdge,
-    "no-existence-only-assertion": noExistenceOnlyAssertion,
+    "no-choice-control-wrapper": noChoiceControlWrapper,
+    "no-comment": noComment,
     "no-deprecated-zod-api": noDeprecatedZodApi,
-    "no-mono-title-register": noMonoTitleRegister,
-    "no-nested-overlay": noNestedOverlay,
-    "no-off-grid-spacing": noOffGridSpacing,
     "no-package-component-redefinition": noPackageComponentRedefinition,
-    "no-paired-size-utility": noPairedSizeUtility,
-    "no-raw-shadow": noRawShadow,
-    "no-resting-settings-control": noRestingSettingsControl,
-    "no-route-width-override": noRouteWidthOverride,
-    "prefer-radio-for-few-static-options": preferRadioForFewStaticOptions,
     "no-shadcn-appearance-override": noShadcnAppearanceOverride,
     "no-subject-derived-expectation": noSubjectDerivedExpectation,
-    "no-native-visible-control": noNativeVisibleControl,
-    "no-repainted-focus": noRepaintedFocus,
-    "no-unpinned-vercel-functions-import": noUnpinnedVercelFunctionsImport,
-    "no-invalid-token-utility": noInvalidTokenUtility,
-    "no-token-category-bypass": noTokenCategoryBypass,
-    "one-control-height": oneControlHeight,
-    "overlay-body-owns-scroll": overlayBodyOwnsScroll,
-    "overlay-mounts-closed": overlayMountsClosed,
-    "table-column-wraps-by-meta": tableColumnWrapsByMeta,
     "server-action-discipline": serverActionDiscipline,
-    "settings-section-description": settingsSectionDescription,
-    "shadcn-composition": shadcnComposition,
   },
 };
 

package/dist/eslint/rules/jsx-class-utility.js

@@ -1,8 +1,8 @@
 /*
- * The one className reader the plugin's class rules share.
+ * The className reader of no-shadcn-appearance-override.
  *
  * It reads LITERALS: string literals and template quasis anywhere inside a
- * `className` expression, plus the class strings a `cva()` call carries. On top
+ * `className` expression. On top
  * of that it takes EXACTLY ONE HOP: an identifier resolves to a same-file
  * `const` string literal, and an identifier or a `TABLE.key` lookup resolves to
  * a same-file `const` object whose string values are then read as classes. A
@@ -40,18 +40,6 @@ function findVariable(scope, name) {
   return undefined;
 }
 
-/** Resolve renamed component imports while keeping local JSX names available. */
-export function jsxComponentName(node, context) {
-  const name = node?.name;
-  if (name?.type === "JSXMemberExpression") return name.property.name;
-  if (name?.type !== "JSXIdentifier") return undefined;
-  const variable = findVariable(context.sourceCode.getScope(name), name.name);
-  const definition = variable?.defs.find((entry) => entry.type === "ImportBinding");
-  return definition?.node.type === "ImportSpecifier"
-    ? (definition.node.imported.name ?? definition.node.imported.value)
-    : name.name;
-}
-
 /**
  * The initializer of the same-file `const` an identifier names. Undefined for
  * imports, parameters, `let`/`var`, and anything declared more than once —
@@ -148,19 +136,6 @@ function utilities(node, { skipPropertyKeys = false, context } = {}) {
   return fragments.flatMap((fragment) => fragment.split(/\s+/).filter(Boolean));
 }
 
-/**
- * Every class utility written inside one node, wherever it sits. The reader for
- * a rule whose surface is not a JSX element — a `cn()`/`cva()` call assigned to
- * a `className` property, or a bare class string in a props object — which is
- * where this repository's composed class lists actually live.
- *
- * Pass `skipPropertyKeys` for a cva call, whose variant-map keys name variants
- * rather than classes.
- */
-export function nodeClassUtilities(node, context, { skipPropertyKeys = false } = {}) {
-  return utilities(node, { skipPropertyKeys, context });
-}
-
 /**
  * The class utilities written in one `className` JSX attribute. Pass `context`
  * to take the one hop; without it the reader stays literal-only.
@@ -200,35 +175,6 @@ export function openingElementClassUtilities(node, context, includeSlots = false
   );
 }
 
-/**
- * `className` attributes plus `cva()` calls — the two places a design-token
- * utility is written. The token rules run over both because a cva variant map
- * is where a component's class strings actually live.
- */
-export function tokenUtilityVisitors(context, onUtility) {
-  const cvaNames = new Set();
-
-  return {
-    ImportDeclaration(node) {
-      if (node.source.value !== "class-variance-authority") return;
-      for (const specifier of node.specifiers) {
-        if (specifier.type === "ImportSpecifier" && specifier.imported.name === "cva") {
-          cvaNames.add(specifier.local.name);
-        }
-      }
-    },
-    JSXAttribute(node) {
-      for (const utility of classUtilities(node, context)) onUtility(node, utility);
-    },
-    CallExpression(node) {
-      if (node.callee.type !== "Identifier" || !cvaNames.has(node.callee.name)) return;
-      for (const utility of utilities(node, { skipPropertyKeys: true, context })) {
-        onUtility(node, utility);
-      }
-    },
-  };
-}
-
 /*
  * Package ownership as a per-rule option (#821, #822). `@nadicodeai/ui`'s own
  * source is the place the primitives are BUILT, so a rule that polices what

package/dist/eslint/rules/no-choice-control-wrapper.js

@@ -0,0 +1,95 @@
+const CHOICE_CONTROLS = new Set(["Select", "ToggleGroup", "RadioGroup", "Tabs"]);
+
+const FUNCTIONS = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+
+function enclosingFunction(node) {
+  let current = node.parent;
+  while (current && !FUNCTIONS.has(current.type)) current = current.parent;
+  return current;
+}
+
+/** A component's own props: a destructured or typed parameter. */
+const isComponent = (fn) =>
+  fn.params.some((param) => param.type === "ObjectPattern" || param.typeAnnotation);
+
+/** Whether `owner` handed the element its value: the element's own component, or a callback inside it. */
+function handedTo(element, owner) {
+  for (let fn = enclosingFunction(element); fn; fn = enclosingFunction(fn)) {
+    if (fn === owner) return true;
+    if (isComponent(fn)) return false;
+  }
+  return false;
+}
+
+/** The identifiers in a handler that invoke what they name: the handler itself, a callee, or a method's receiver. */
+function invoked(handler) {
+  const found = [];
+  const visit = (node) => {
+    if (!node || typeof node.type !== "string") return;
+    if (node.type === "Identifier") {
+      const parent = node.parent;
+      const isCallee = parent?.type === "CallExpression" && parent.callee === node;
+      const isReceiver =
+        parent?.type === "MemberExpression" &&
+        parent.object === node &&
+        parent.parent?.type === "CallExpression" &&
+        parent.parent.callee === parent;
+      if (node === handler || isCallee || isReceiver) found.push(node);
+    }
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "parent") continue;
+      for (const child of Array.isArray(value) ? value : [value]) {
+        if (child && typeof child.type === "string") visit(child);
+      }
+    }
+  };
+  visit(handler);
+  return found;
+}
+
+/**
+ * A kit choice control whose onValueChange forwards to a callback the enclosing
+ * component was handed. `ToolbarToggle` flattened Base UI's array into a string
+ * there, and "Split by" stopped working while every check stayed green.
+ */
+export const noChoiceControlWrapper = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Render a kit choice control where its value is used, never behind a wrapper that forwards it.",
+    },
+    schema: [],
+    messages: {
+      wrapper:
+        "Render the kit's {{control}} where the value is used, with its own API: this one forwards onValueChange to \"{{name}}\", which the component was handed, and a wrapper is where the value's shape gets lost.",
+    },
+  },
+  create(context) {
+    return {
+      "JSXAttribute[name.name='onValueChange'] > JSXExpressionContainer"(container) {
+        const opening = container.parent.parent;
+        const control = opening.name.type === "JSXIdentifier" ? opening.name.name : null;
+        if (!CHOICE_CONTROLS.has(control)) return;
+        const handler = container.expression;
+        for (const identifier of invoked(handler)) {
+          const scope = context.sourceCode.getScope(identifier);
+          let variable = null;
+          for (let current = scope; current && !variable; current = current.upper) {
+            variable = current.set.get(identifier.name) ?? null;
+          }
+          const definition = variable?.defs[0];
+          if (definition?.type !== "Parameter") continue;
+          if (definition.node === handler) continue;
+          if (!handedTo(opening, definition.node)) continue;
+          context.report({
+            node: container,
+            messageId: "wrapper",
+            data: { control, name: identifier.name },
+          });
+          return;
+        }
+      },
+    };
+  },
+};

package/dist/eslint/rules/no-comment.js

@@ -0,0 +1,44 @@
+/*
+ * Code says what it does in its names and its structure, and a test says what
+ * it proves in its name and its assertions; a comment restates one of them and
+ * nothing keeps it true when the code changes. A directive to a tool is not
+ * prose for the reader: ESLint's, Oxlint's, TypeScript's, Biome's, Prettier's,
+ * coverage's and Vitest's stay, and so does the marker the seam guard requires.
+ */
+
+const DIRECTIVE =
+  /^[*/]?\s*(?:@ts-|eslint-|eslint\s+[\w@/-]+\s*:|oxlint-|biome-ignore|<reference\b|istanbul\b|c8\s|prettier-ignore|@vitest-environment|@jsx)/;
+
+const SEAM_MARKER = /^\s*NADIA\((?:added|changed|removed)\):/;
+
+export const noComment = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow comments in code, but for directives to a tool and the marker the seam guard requires",
+    },
+    schema: [],
+    messages: {
+      comment:
+        "Code says what it does in its names and its structure, never in a comment. Rename or restructure, or remove the comment.",
+    },
+  },
+
+  create(context) {
+    return {
+      Program() {
+        for (const comment of context.sourceCode.getAllComments()) {
+          if (
+            comment.type === "Shebang" ||
+            DIRECTIVE.test(comment.value) ||
+            SEAM_MARKER.test(comment.value)
+          ) {
+            continue;
+          }
+          context.report({ loc: comment.loc, messageId: "comment" });
+        }
+      },
+    };
+  },
+};

package/dist/eslint/rules/no-subject-derived-expectation.js

@@ -34,7 +34,61 @@
  */
 import { dirname, resolve, sep } from "node:path";
 
-import { expectAssertion } from "./expect-chain.js";
+/*
+ * The matcher of `expect(subject).<modifiers>.<matcher>(args)` is not the
+ * callee's property in the general case: `not`, `resolves` and `rejects` sit
+ * between `expect(...)` and the matcher, so it is read by walking the member
+ * chain back to the `expect` call.
+ */
+function propertyName(member) {
+  if (!member.computed && member.property.type === "Identifier") return member.property.name;
+  if (member.computed && member.property.type === "Literal") {
+    return typeof member.property.value === "string" ? member.property.value : undefined;
+  }
+  return undefined;
+}
+
+/** `a?.b` and `a?.()` arrive wrapped; the rules want the expression itself. */
+function unwrapChain(node) {
+  return node?.type === "ChainExpression" ? node.expression : node;
+}
+
+function isExpectCall(node) {
+  if (node?.type !== "CallExpression") return false;
+  if (node.callee.type === "Identifier") return node.callee.name === "expect";
+  // `expect.soft(value)` and `expect.poll(fn)` open the same chain.
+  return node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier"
+    ? node.callee.object.name === "expect"
+    : false;
+}
+
+/**
+ * Reads an assertion call. Returns `{ matcher, modifiers, subject, args }` for
+ * `expect(subject).<modifiers>.<matcher>(args)`, or `undefined` when the call
+ * is not an `expect` chain. `subject` is unwrapped of its `ChainExpression`.
+ */
+function expectAssertion(node) {
+  if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") return undefined;
+  const matcher = propertyName(node.callee);
+  if (!matcher) return undefined;
+
+  const modifiers = [];
+  let current = node.callee.object;
+  while (current.type === "MemberExpression") {
+    const name = propertyName(current);
+    if (!name) return undefined;
+    modifiers.unshift(name);
+    current = current.object;
+  }
+  if (!isExpectCall(current)) return undefined;
+
+  return {
+    matcher,
+    modifiers,
+    subject: unwrapChain(current.arguments[0]),
+    args: node.arguments,
+  };
+}
 
 const EQUALITY_MATCHERS = new Set(["toBe", "toEqual", "toStrictEqual"]);
 const TEST_FILE = /\.test\.tsx?$/;

package/dist/eslint/strict-design-system.js

@@ -0,0 +1,224 @@
+import { createRequire } from "node:module";
+
+/*
+ * The strict design-system checks, as selector lists for core
+ * `no-restricted-syntax`. The plugin registers that core rule once per check,
+ * under the check's own name, so each check keeps its `nadicodeai/<name>` id
+ * and no two checks share one option list (flat config replaces a rule's
+ * options rather than merging them).
+ *
+ * A class check reads the string literals inside a `className` attribute and a
+ * `cva()` call, one class token at a time, variants included.
+ */
+
+const theme = createRequire(import.meta.url)("@nadicodeai/design-system/tailwind").theme.extend;
+const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/** Any variant chain: `md:`, `group-data-x/tabs:`, `has-[[data-slot=a]:focus]:`. */
+const VARIANTS = String.raw`(?:(?:[^\s:\[\]]|\[(?:[^\s\[\]]|\[[^\s\]]*\])*\])+:)*`;
+export const token = (body, variants = VARIANTS) =>
+  String.raw`/(^|\s)${variants}!?(?:${body})!?(\s|$)/`;
+export const literal = (pattern) =>
+  `:matches(Literal[value=${pattern}], TemplateElement[value.raw=${pattern}])`;
+const CLASS_SITES =
+  ":matches(JSXAttribute[name.name='className'], Program:has(ImportDeclaration[source.value='class-variance-authority'] > ImportSpecifier[local.name='cva']) CallExpression[callee.name='cva'])";
+// A cva variant map's keys name variants, not classes.
+const classToken = (body, variants) =>
+  `${CLASS_SITES} ${literal(token(body, variants))}:not(Property > .key)`;
+const ownClass = (body) =>
+  `:has(> JSXOpeningElement:has(JSXAttribute[name.name='className'] ${literal(token(body))}))`;
+
+/** A component import from the package or the app may not be renamed: a check recognises it by its JSX name. */
+export const keepName = (names, checks = "design-system lint checks") =>
+  names.map((name) => ({
+    selector: `ImportDeclaration[source.value=/^(@nadicodeai\\/ui|@\\/components|\\.)/] > ImportSpecifier[imported.name='${name}'][local.name!='${name}']`,
+    message: `Import ${name} under its own name: the ${checks} recognise it by that name.`,
+  }));
+
+const OVERLAY_CONTENT = ["AlertDialogContent", "DialogContent", "DrawerContent", "SheetContent"];
+const OVERLAY_ROOTS = [
+  "Dialog",
+  "AlertDialog",
+  "Drawer",
+  "Sheet",
+  "Popover",
+  "DropdownMenu",
+  "ContextMenu",
+  "Menubar",
+  "Tooltip",
+  "HoverCard",
+  "Combobox",
+  "ActionMenu",
+];
+
+const card = "JSXElement[openingElement.name.name=/^(Card|\\w*Card)$/]";
+const cardChild = `:matches(${card}, JSXExpressionContainer:has(> ${card}), JSXExpressionContainer:has(> :matches(ConditionalExpression, LogicalExpression):has(> ${card})))`;
+const mappedCards = `JSXExpressionContainer:has(> CallExpression[callee.property.name=/^(map|from)$/]:has(${card}))`;
+
+const bareControl =
+  "JSXOpeningElement[name.name=/^(Button|button)$/]:not(:has(> JSXAttribute[name.name=/^aria-label(ledby)?$/])):not(:has(> JSXSpreadAttribute)):not(JSXAttribute[name.name='render'] JSXOpeningElement)";
+const onlyElements =
+  ":not(:matches(JSXElement, JSXFragment, Literal[value=null], Literal[value=false], Identifier[name='undefined'], ConditionalExpression, LogicalExpression))";
+const rendersText = `:matches(JSXText[value=/\\S/], :matches(JSXElement, JSXFragment) > JSXExpressionContainer:not([expression.type=/^(JSXElement|JSXFragment|JSXEmptyExpression|ConditionalExpression|LogicalExpression)$/]), ConditionalExpression > ${onlyElements}:matches(.consequent, .alternate), LogicalExpression > ${onlyElements}.right)`;
+const elementChild =
+  ":matches(JSXElement, JSXFragment, JSXExpressionContainer[expression.type=/^(JSXElement|JSXFragment|ConditionalExpression|LogicalExpression)$/])";
+
+const overlayRoot = `JSXOpeningElement[name.name=/Dialog|Drawer|Sheet|Popover|Menu|Tooltip|HoverCard|Combobox/]:not([name.name=/(Content|Trigger|Title|Description|Header|Footer|Body|Item|Group|Label|Separator|Close|Portal|Overlay|Backdrop)$/])`;
+const isTrue = ":matches([value=null], [value.expression.value=true])";
+
+const selectItem = "JSXElement[openingElement.name.name='SelectItem']";
+const noExpressionChild =
+  ":not(:has(> JSXExpressionContainer[expression.type!='JSXEmptyExpression']))";
+const fewItems = (parent) =>
+  `${parent}:has(> ${selectItem} ~ ${selectItem}):not(:has(> ${selectItem} ~ ${selectItem} ~ ${selectItem} ~ ${selectItem}))${noExpressionChild}`;
+
+const drawerSlot = "/^Drawer(Header|Body|Footer)$/";
+const drawerEdge = literal(token(String.raw`border(-[tby])?(-\d+)?`));
+
+const SPACING =
+  "(?:p|px|py|pt|pr|pb|pl|ps|pe|m|mx|my|mt|mr|mb|ml|ms|me|gap|gap-x|gap-y|space-x|space-y|inset|inset-x|inset-y|top|right|bottom|left|start|end)";
+// The ladder rungs and the control geometry (seam, focus outline and offset, inline padding, touch target).
+const ON_GRID = String.raw`(?:0|1|2|4|8|10|12|16|24|32|40|44|48|64|96|128)(?:\.0+)?`;
+
+const typographyTokens = Object.keys(theme.fontSize).map(escape).join("|");
+const colorTokens = Object.keys(theme.colors).map(escape).join("|");
+const radiusValues = [...new Set(Object.values(theme.borderRadius))].map(escape).join("|");
+const radiusNames = Object.keys(theme.borderRadius).map(escape).join("|");
+const invalidTokenMessage =
+  "This class is not generated by the installed nadicode design system. Use a utility from @nadicodeai/design-system/tailwind.";
+
+export const strictDesignSystemSelectors = {
+  "card-row-owner": [
+    {
+      selector: `JSXElement:not([openingElement.name.name='CardRow']):matches(${ownClass(String.raw`grid-cols-(?!1(\s|$))\S+`)}, ${ownClass("flex-row")}, ${ownClass("flex")}:not(${ownClass("flex-col")})):matches(:has(> ${cardChild} ~ ${cardChild}), :has(> ${mappedCards})) > JSXOpeningElement`,
+      message:
+        "These cards are laid side by side without the owner of that row. An alignment class or a wrapper around a card is then enough for the shortest card to stop at its content and the row to end on a ragged edge. Use CardRow from @nadicodeai/ui, which stretches its cells and makes every card fill the one it lands in (rule/card-row-equal-height).",
+    },
+  ],
+  "drawer-owns-its-edges": [
+    ...keepName(["DrawerHeader", "DrawerBody", "DrawerFooter"]),
+    {
+      selector: `JSXOpeningElement[name.name=${drawerSlot}] > JSXAttribute[name.name='className'] ${drawerEdge}`,
+      message:
+        "This border gives a drawer slot a second edge. The drawer draws the hairline between its header, its body and its footer; drop the border class (rule/drawer-owns-its-edges).",
+    },
+    {
+      selector: `JSXElement:has(> JSXElement[openingElement.name.name=${drawerSlot}]) > JSXOpeningElement > JSXAttribute[name.name='className'] ${drawerEdge}`,
+      message:
+        "This border draws an edge around a drawer slot. The drawer draws the hairline between its header, its body and its footer; render the slot without this wrapper (rule/drawer-owns-its-edges).",
+    },
+  ],
+  "icon-control-accessible-name": [
+    ...keepName(["Button"]),
+    {
+      selector: `JSXElement:not(:has(${rendersText})):matches(:has(> ${bareControl}:has(> JSXAttribute[name.name='size'][value.value=/^icon(-xs|-sm|-lg)?$/])), :has(> ${elementChild})) > ${bareControl}`,
+      message:
+        'A screen reader announces "button" and nothing more for this control: its content is an icon, and an icon carries no name. Add aria-label with the action it performs, point aria-labelledby at the text that names it, or put that text in a child with the sr-only class.',
+    },
+  ],
+  "no-invalid-token-utility": [
+    {
+      selector: classToken(`nc-type-(?!(?:${typographyTokens})(\\s|$))\\S*`),
+      message: invalidTokenMessage,
+    },
+    {
+      selector: classToken(
+        `(?:bg|text|border|outline|ring|fill|stroke|decoration|accent|caret|divide|from|via|to|shadow)-nc-(?!(?:${colorTokens})(\\/\\S*)?(\\s|$))\\S+`,
+      ),
+      message: invalidTokenMessage,
+    },
+  ],
+  "no-native-visible-control": [
+    {
+      selector:
+        "JSXOpeningElement[name.name=/^(button|details|input|select|textarea)$/]:not([name.name='input']:has(> JSXAttribute[name.name='type']:matches([value.value='hidden'], [value.expression.value='hidden'], [value.expression.quasis.0.value.cooked='hidden']))):not(JSXOpeningElement > JSXAttribute[name.name='render'] > JSXExpressionContainer > JSXElement > JSXOpeningElement)",
+      message:
+        "Use the @nadicodeai/ui primitive instead of a native visible control; a <details> takes Disclosure, which draws the one disclosure.",
+    },
+  ],
+  "no-nested-overlay": [
+    ...keepName(OVERLAY_CONTENT),
+    {
+      selector: `JSXElement[openingElement.name.name=/^(${OVERLAY_CONTENT.join("|")})$/] JSXElement[openingElement.name.name=/^(${OVERLAY_CONTENT.join("|")})$/] > JSXOpeningElement`,
+      message:
+        "This overlay is rendered inside another overlay. Two overlays on one tree keep both focus traps armed, so the keyboard cannot reach the outer surface and Escape closes the wrong layer, while the scrims stack. Render the second overlay as a sibling driven by state, or replace it with an inline disclosure inside the first.",
+    },
+  ],
+  "no-off-grid-spacing": [
+    {
+      selector: classToken(String.raw`-?${SPACING}-\[-?(?!${ON_GRID}px\])\d+(?:\.\d+)?px\]`),
+      message:
+        "This pixel step sits off the design-system spacing ladder, so the rhythm reads as almost aligned and the value cannot follow the tokens. Use a rung: 0, nadicode-xxs (4px), nadicode-xs (8), nadicode-sm (12), nadicode-md (16), nadicode-lg (24), nadicode-xl (32), nadicode-2xl (40), nadicode-3xl (48), nadicode-4xl (64), nadicode-5xl (96), nadicode-6xl (128).",
+    },
+  ],
+  "no-raw-shadow": [
+    {
+      selector: classToken(
+        String.raw`shadow(?:-(?:2xs|xs|sm|md|lg|xl|2xl|inner|initial|\[\S*\]))?`,
+      ),
+      message:
+        "A stock shadow paints a light-mode drop shadow with no ring, so the surface loses its edge against the dark workspace and cannot follow the tokens. Choose the physical level instead: nc-elevation-resting, nc-elevation-raised, nc-elevation-floating, or nc-elevation-modal.",
+    },
+  ],
+  "no-repainted-focus": [
+    {
+      selector: classToken(
+        String.raw`-?ring(?:-\S*)?`,
+        String.raw`(?=\S*focus)${VARIANTS.slice(0, -1)}+`,
+      ),
+      message:
+        "Focus never paints a box-shadow: the base layer draws the offset outline. Drop this ring utility.",
+    },
+    {
+      selector: classToken(
+        String.raw`\[outline\S*|outline(?!-(?:none|hidden|ring|sidebar-ring)(?:\s|$))(?!-offset-)(?:-\S*)?`,
+        String.raw`(?=\S*focus)${VARIANTS.slice(0, -1)}+`,
+      ),
+      message:
+        "This utility repaints focus with its own width or hue. The base layer owns the focus outline; a proxy target takes nc-focus-outline plus a ring-role color.",
+    },
+  ],
+  "no-token-category-bypass": [
+    {
+      selector: classToken(
+        String.raw`rounded(?:-(?:t|r|b|l|s|e|ss|se|ee|es|tl|tr|br|bl))?-\[\s*(?:${radiusValues}|var\(--(?:nc-rounded|radius)-(?:${radiusNames})\))\s*\]`,
+      ),
+      message:
+        "This class spells a design-system radius by its value. Use the generated rounded-<token> utility the value belongs to.",
+    },
+  ],
+  "overlay-body-owns-scroll": [
+    ...keepName(["DialogContent", "DrawerContent"]),
+    {
+      selector: `JSXElement[openingElement.name.name=/^(DialogContent|DrawerContent)$/] JSXOpeningElement:not([name.name=/^(DialogContent|DrawerContent)$/]) > JSXAttribute[name.name='className'] ${literal(token("overflow-y-auto|overflow-y-scroll|overflow-auto"))}`,
+      message:
+        "This makes the element a second scroll container inside an overlay. The body slot owns an overlay's scroll, its shrinking and the inset that keeps focus outlines visible. Put the content in DialogBody or DrawerBody from @nadicodeai/ui and drop the overflow classes (rule/overlay-body-owns-scroll).",
+    },
+  ],
+  "overlay-mounts-closed": [
+    ...keepName(OVERLAY_ROOTS),
+    {
+      selector: `${overlayRoot} > JSXAttribute[name.name='open']${isTrue}`,
+      message:
+        "This overlay is given `open` fixed to true, so it only exists while open and neither its fade in nor its fade out runs. Keep it mounted and drive `open` from state.",
+    },
+    {
+      selector: `${overlayRoot} > JSXAttribute[name.name='defaultOpen']${isTrue}`,
+      message:
+        "This overlay mounts open through `defaultOpen`, so its entry never runs. Mount it closed and open it from state.",
+    },
+    {
+      selector: `${overlayRoot} > JSXAttribute[name.name='key'][value.type='JSXExpressionContainer']:not([value.expression.type='Literal']):not([value.expression.type='TemplateLiteral'][value.expression.expressions.length=0]):not(CallExpression[callee.property.name=/^(map|flatMap)$/] > :function JSXAttribute)`,
+      message:
+        "This overlay takes a `key` that remounts it, so an opening that changes the key mounts it already open and its fade in never runs. Keep one mounted overlay and reset its content another way, such as a key on the content inside it.",
+    },
+  ],
+  "prefer-radio-for-few-static-options": [
+    ...keepName(["SelectContent", "SelectItem"]),
+    {
+      selector: `JSXElement[openingElement.name.name='SelectContent']${noExpressionChild}:matches(${fewItems("JSXElement")}, :has(> ${fewItems("JSXElement[openingElement.name.name='SelectGroup']")})) > JSXOpeningElement`,
+      message:
+        "This Select holds two or three options fixed at author time, so a reader has to open it to learn what the alternatives are. RadioGroup shows them all at once and takes one arrow key instead of an open and an arrow. Use RadioGroup with a RadioGroupItem per option.",
+    },
+  ],
+};

package/dist/styles/components.css

@@ -52,7 +52,7 @@
  * own optical ring in the current mode (design-system DESIGN.md
  * "core.elevation"). An elevated surface therefore draws no second edge:
  * never pair one of these with border-*, ring-*, or another box-shadow
- * (`nadicodeai/no-elevated-edge` enforces it). Declared as utilities so
+ * (`repo/no-elevated-edge` enforces it). Declared as utilities so
  * variant prefixes can gate them.
  */
 @utility nc-elevation-resting {