@nadicodeai/ui 1.0.2 → 1.1.0

package/dist/eslint/rules/no-elevated-edge.js

@@ -0,0 +1,144 @@
+/*
+ * An elevated surface draws its own edge. `smooth-shadow-ring-*` already
+ * integrates the vendor plugin's adaptive optical ring (DESIGN.md, "material
+ * ladder"), so a border, a second ring, or a local ring tint on the same target
+ * paints a second edge over it — the seam this repository keeps reintroducing
+ * when a stock shadcn shape is pasted next to an elevation.
+ *
+ * Standard tool checked (ADR 0057 tier 2): `better-tailwindcss`'s
+ * `no-restricted-classes` judges one class at a time. `border` and `ring-1` are
+ * legal on their own — they are wrong only beside an elevation, and only when
+ * both land on the same target, so `*:data-[slot=input]:border-input` under an
+ * elevated parent stays legal. That relationship is what this rule reads, on
+ * the shared className reader.
+ *
+ * Replaces the @nadicodeai/ui material-surface-contract scanner (#822), which
+ * built its own TypeScript AST over the package's sources to ask the same
+ * question. It takes no `packageOwnedPrimitives` option: the material ladder
+ * holds wherever an elevation is written, inside the package and out.
+ */
+import { nodeClassUtilities } from "./jsx-class-utility.js";
+
+const ELEVATION = /^smooth-shadow-ring-(?:xs|sm|md|lg|xl|2xl)$/;
+
+/*
+ * The callees that compose a class list out of several strings. A class written
+ * in one argument and an elevation in another are one surface, so the call —
+ * not the string — is the unit this rule reviews.
+ */
+const COMPOSERS = new Set(["cn", "clsx", "cva"]);
+
+/** `md:hover:border` → `{ modifiers: ["md", "hover"], utility: "border" }`. */
+function tailwindToken(token) {
+  const segments = [];
+  let bracketDepth = 0;
+  let start = 0;
+  for (let index = 0; index < token.length; index += 1) {
+    const character = token[index];
+    if (character === "[") bracketDepth += 1;
+    if (character === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+    // A colon inside brackets belongs to an arbitrary value, not to a variant.
+    if (character === ":" && bracketDepth === 0) {
+      segments.push(token.slice(start, index));
+      start = index + 1;
+    }
+  }
+  segments.push(token.slice(start));
+  return { modifiers: segments.slice(0, -1), utility: segments.at(-1) ?? token };
+}
+
+/**
+ * What a utility paints on: the element itself, or the descendants a variant
+ * selects. Two utilities collide only when this matches — an elevation on the
+ * root and a border on `*:data-[slot=input]` are different surfaces.
+ */
+function targetKey(modifiers) {
+  const descendants = modifiers.filter(
+    (modifier) => modifier === "*" || modifier === "**" || /^\[&(?:_|>|\s)/.test(modifier),
+  );
+  return descendants.length === 0 ? "self" : descendants.join(":");
+}
+
+/** A width of zero is the absence of an edge, which is what an elevation wants. */
+function isZeroWidthUtility(utility) {
+  return utility === "border-0" || utility === "ring-0";
+}
+
+function edgeRule(utility) {
+  if (utility.startsWith("smooth-ring-")) return "ringTintOverride";
+  if (/^border(?:$|-)/.test(utility) && !isZeroWidthUtility(utility)) return "borderWithElevation";
+  if (/^ring(?:$|-)/.test(utility) && !isZeroWidthUtility(utility)) return "ringWithElevation";
+  return undefined;
+}
+
+/** One finding per offending edge, however many elevations it sits beside. */
+function edgeViolations(classes) {
+  const tokens = classes.map((token) => ({ token, ...tailwindToken(token) }));
+  const elevations = tokens.filter(({ utility }) => ELEVATION.test(utility));
+  const violations = new Map();
+  for (const elevation of elevations) {
+    const elevationTarget = targetKey(elevation.modifiers);
+    for (const candidate of tokens) {
+      if (targetKey(candidate.modifiers) !== elevationTarget) continue;
+      const messageId = edgeRule(candidate.utility);
+      if (messageId && !violations.has(candidate.token)) {
+        violations.set(candidate.token, { messageId, shadow: elevation.token });
+      }
+    }
+  }
+  return [...violations].map(([token, finding]) => ({ token, ...finding }));
+}
+
+function isComposerCall(node) {
+  return (
+    node?.type === "CallExpression" &&
+    node.callee.type === "Identifier" &&
+    COMPOSERS.has(node.callee.name)
+  );
+}
+
+function insideComposerCall(node) {
+  for (let current = node.parent; current; current = current.parent) {
+    if (isComposerCall(current)) return true;
+  }
+  return false;
+}
+
+export const noElevatedEdge = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow a border, ring, or ring tint on the same target as a smooth-shadow-ring-* elevation",
+    },
+    schema: [],
+    messages: {
+      borderWithElevation:
+        '"{{token}}" draws a hard border on the same target as {{shadow}}. An elevated surface carries the plugin\'s optical ring: drop the border, or drop the elevation.',
+      ringWithElevation:
+        '"{{token}}" draws a second ring on the same target as {{shadow}}. An elevated surface carries the plugin\'s optical ring already.',
+      ringTintOverride:
+        '"{{token}}" repaints the vendor ring beside {{shadow}}. The elevation owns its ring tint, including the dark-mode one.',
+    },
+  },
+  create(context) {
+    const report = (node, classes) => {
+      for (const { token, messageId, shadow } of edgeViolations(classes)) {
+        context.report({ node, messageId, data: { token, shadow } });
+      }
+    };
+
+    return {
+      CallExpression(node) {
+        // The outermost composer owns the surface: a nested one's strings are
+        // already in its list, so reviewing both would report twice.
+        if (!isComposerCall(node) || insideComposerCall(node)) return;
+        report(node, nodeClassUtilities(node, context, { skipPropertyKeys: true }));
+      },
+      Literal(node) {
+        if (typeof node.value !== "string" || insideComposerCall(node)) return;
+        report(node, node.value.split(/\s+/).filter(Boolean));
+      },
+    };
+  },
+};

package/dist/eslint/rules/no-mono-title-register.js

@@ -0,0 +1,73 @@
+/*
+ * Design law 9: a title is prose, so it never renders in the mono-caps
+ * register. The rule is mechanical because the register is — `font-mono`
+ * together with `uppercase` on a slot that carries a title — and everything
+ * judgment-bearing stays out of it: an eyebrow, a fact label, an identifier or
+ * a marketing label may all be mono, and none of them is a title slot.
+ *
+ * Standard tool checked (ADR 0057 tier 2): `better-tailwindcss`'s
+ * `no-restricted-classes` judges one class at a time and never against the
+ * element it lands on, so it can ban `font-mono` everywhere or nowhere. The
+ * register is a PAIR of classes on a TITLE element, which is a relationship —
+ * so it lives here, on the shared className reader.
+ *
+ * Replaces `monoTitleRegisterViolations` in the retired portal page-grammar
+ * analyzers (#821).
+ */
+import { openingElementClassUtilities } from "./jsx-class-utility.js";
+
+// The kit's title elements plus the hand-written headings.
+const TITLE_TAGS = new Set(["CardTitle", "h1", "h2", "h3", "h4"]);
+const TITLE_SLOT = /-title$/;
+
+function withoutVariants(utility) {
+  return utility.slice(utility.lastIndexOf(":") + 1);
+}
+
+function slotName(node) {
+  for (const attribute of node.attributes) {
+    if (attribute.type !== "JSXAttribute" || attribute.name.name !== "data-slot") continue;
+    const value = attribute.value;
+    if (value?.type === "Literal" && typeof value.value === "string") return value.value;
+    if (
+      value?.type === "JSXExpressionContainer" &&
+      value.expression.type === "Literal" &&
+      typeof value.expression.value === "string"
+    ) {
+      return value.expression.value;
+    }
+  }
+  return undefined;
+}
+
+function isTitleElement(node) {
+  if (node.name.type !== "JSXIdentifier") return false;
+  if (TITLE_TAGS.has(node.name.name)) return true;
+  const slot = slotName(node);
+  return Boolean(slot && TITLE_SLOT.test(slot));
+}
+
+export const noMonoTitleRegister = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow the retired mono-caps register on a title slot (design law 9)",
+    },
+    schema: [],
+    messages: {
+      monoTitle:
+        "A title never renders in the mono-caps register: drop font-mono and uppercase (design law 9).",
+    },
+  },
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        if (!isTitleElement(node)) return;
+        const utilities = openingElementClassUtilities(node, context).map(withoutVariants);
+        if (utilities.includes("font-mono") && utilities.includes("uppercase")) {
+          context.report({ node, messageId: "monoTitle" });
+        }
+      },
+    };
+  },
+};

package/dist/eslint/rules/no-native-visible-control.js

@@ -1,4 +1,4 @@
-import { isPackageOwnedPrimitive } from "./jsx-class-utility.js";
+import { packageOwnedPrimitivesSchema, skipsPackageOwnedPrimitive } from "./jsx-class-utility.js";
 
 const NATIVE_CONTROLS = new Set(["button", "input", "select", "textarea"]);
 
@@ -42,14 +42,17 @@ export const noNativeVisibleControl = {
     docs: {
       description: "Disallow visible native controls in app source; use @nadicodeai/ui primitives",
     },
-    schema: [],
+    // Default "exempt": the package's own source is where the primitives that
+    // replace a native control are built, so a native <button> there is the
+    // implementation, not a bypass.
+    schema: [packageOwnedPrimitivesSchema],
     messages: {
       nativeVisibleControl:
         "Use the @nadicodeai/ui primitive instead of native visible <{{element}}>.",
     },
   },
   create(context) {
-    if (isPackageOwnedPrimitive(context.filename)) {
+    if (skipsPackageOwnedPrimitive(context)) {
       return {};
     }
     const packagePrimitiveNames = new Set();

package/dist/eslint/rules/no-package-component-redefinition.js

@@ -0,0 +1,175 @@
+/*
+ * A route does not re-declare a component the package already ships.
+ *
+ * `@nadicodeai/ui` is the website's component surface. A route that declares
+ * its own `Hero`, `Footer` or `NavBar` forks a shipped component into a page,
+ * where the package's next change does not reach it — and the two are then
+ * told apart only by their import paths.
+ *
+ * The names are DERIVED from the package's build surface at lint time: the
+ * `types` target of its `exports` map, followed through the barrel's
+ * `export *` chain. There is no list here to keep in step with the package;
+ * a component added or removed by the package changes this rule's answer with
+ * no edit at all.
+ *
+ * Standard tool checked (ADR 0057 tier 2): core `no-redeclare` and
+ * `no-shadow` answer only inside one scope chain, and `no-restricted-syntax`
+ * would need every name spelled into a selector — the hand list this derivation
+ * exists to avoid. Deferred here from #819 for exactly that reason.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PACKAGE = "@nadicodeai/ui";
+
+/*
+ * TypeScript is loaded when this rule first runs, not when the plugin loads.
+ * The plugin's bytes are published inside `@nadicodeai/ui`, which does not
+ * depend on the compiler; a consumer who never enables this rule never asks
+ * for it, and one who does is already linting TypeScript.
+ */
+let ts;
+function typescript() {
+  ts ??= createRequire(import.meta.url)("typescript");
+  return ts;
+}
+
+/** The `.d.ts` the package's `exports` map names as its root type surface. */
+function typeSurfaceEntry() {
+  let directory = dirname(fileURLToPath(import.meta.resolve(PACKAGE)));
+  for (;;) {
+    const manifestPath = join(directory, "package.json");
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    } catch {
+      const parent = dirname(directory);
+      if (parent === directory) {
+        throw new Error(`${PACKAGE}: no manifest above its resolved entry point`);
+      }
+      directory = parent;
+      continue;
+    }
+    if (manifest.name !== PACKAGE) {
+      throw new Error(`${manifestPath} is not ${PACKAGE}`);
+    }
+    const entry = join(directory, manifest.exports["."].types);
+    if (!existsSync(entry)) {
+      throw new Error(
+        `${PACKAGE} has no built type surface at ${entry}: build the package before linting.`,
+      );
+    }
+    return entry;
+  }
+}
+
+/*
+ * A type is not a component. `export type ChartConfig` names a shape a route
+ * may legitimately declare its own version of, and it cannot be imported as a
+ * component at all, so the derived set holds values only: type aliases,
+ * interfaces, and the `type` marker on an export clause are dropped.
+ */
+function isTypeOnlyStatement(ts, statement) {
+  return (
+    ts.isTypeAliasDeclaration(statement) ||
+    ts.isInterfaceDeclaration(statement) ||
+    statement.isTypeOnly === true
+  );
+}
+
+function exportedNames(file, names = new Set(), seen = new Set()) {
+  if (seen.has(file)) return names;
+  seen.add(file);
+  const ts = typescript();
+  const source = ts.createSourceFile(
+    file,
+    readFileSync(file, "utf8"),
+    ts.ScriptTarget.Latest,
+    false,
+    ts.ScriptKind.TS,
+  );
+  for (const statement of source.statements) {
+    if (ts.isExportDeclaration(statement)) {
+      if (statement.moduleSpecifier && !statement.exportClause) {
+        exportedNames(
+          join(dirname(file), statement.moduleSpecifier.text.replace(/\.js$/, ".d.ts")),
+          names,
+          seen,
+        );
+      } else if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        if (isTypeOnlyStatement(ts, statement)) continue;
+        for (const element of statement.exportClause.elements) {
+          if (element.isTypeOnly) continue;
+          names.add(element.name.text);
+        }
+      }
+      continue;
+    }
+    const modifiers = ts.canHaveModifiers(statement) ? (ts.getModifiers(statement) ?? []) : [];
+    if (!modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) continue;
+    if (isTypeOnlyStatement(ts, statement)) continue;
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) names.add(declaration.name.text);
+      }
+    } else if (statement.name && ts.isIdentifier(statement.name)) {
+      names.add(statement.name.text);
+    }
+  }
+  return names;
+}
+
+let packageExports;
+
+/** Read once per lint process; the built surface does not move under it. */
+function packageExportNames() {
+  packageExports ??= exportedNames(typeSurfaceEntry());
+  return packageExports;
+}
+
+const COMPONENT_NAME = /^[A-Z]/;
+
+function isFunctionLike(node) {
+  return (
+    node?.type === "ArrowFunctionExpression" ||
+    node?.type === "FunctionExpression" ||
+    node?.type === "ClassExpression" ||
+    node?.type === "CallExpression"
+  );
+}
+
+export const noPackageComponentRedefinition = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: `Disallow declaring a component whose name ${PACKAGE} already exports`,
+    },
+    schema: [],
+    messages: {
+      redefined: `{{name}} is exported by ${PACKAGE}: import it instead of declaring a second one here.`,
+    },
+  },
+  create(context) {
+    const report = (node, name) => {
+      if (!COMPONENT_NAME.test(name) || !packageExportNames().has(name)) return;
+      context.report({ node, messageId: "redefined", data: { name } });
+    };
+
+    return {
+      FunctionDeclaration(node) {
+        if (node.id) report(node.id, node.id.name);
+      },
+      // A class is the third way to write a component; React still renders one.
+      ClassDeclaration(node) {
+        if (node.id) report(node.id, node.id.name);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier" && isFunctionLike(node.init)) {
+          report(node.id, node.id.name);
+        }
+      },
+    };
+  },
+};

package/dist/eslint/rules/no-paired-size-utility.js

@@ -0,0 +1,66 @@
+/*
+ * A square is written once: `size-4`, never `h-4 w-4`.
+ *
+ * Standard tool checked (ADR 0057 tier 2): `better-tailwindcss`'s
+ * `no-restricted-classes` judges one class at a time, so it can ban `h-4`
+ * outright but cannot see that a `w-4` is beside it — and the pair is the whole
+ * point, since `h-4 w-full` is fine. The relationship lives here, on the shared
+ * className reader.
+ *
+ * Replaces the `paired-size` half of the retired @nadicodeai/ui
+ * composition-conventions scanner (#822). Stock shadcn shapes that cannot be
+ * written any other way carry an inline disable with the reason at the site.
+ */
+import {
+  openingElementClassUtilities,
+  packageOwnedPrimitivesSchema,
+  skipsPackageOwnedPrimitive,
+} from "./jsx-class-utility.js";
+
+/** `md:h-4` → `{ variants: "md:", axis: "h", value: "4" }`, or undefined. */
+function sizeUtility(utility) {
+  const separator = utility.lastIndexOf(":");
+  const variants = utility.slice(0, separator + 1);
+  const base = utility.slice(separator + 1);
+  const match = /^([hw])-(.+)$/.exec(base);
+  return match ? { variants, axis: match[1], value: match[2] } : undefined;
+}
+
+export const noPairedSizeUtility = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow paired h-* and w-* utilities of equal value; use size-*",
+    },
+    schema: [packageOwnedPrimitivesSchema],
+    messages: {
+      pairedSize: "Write the square once: use {{variants}}size-{{value}} instead of a h/w pair.",
+    },
+  },
+  create(context) {
+    if (skipsPackageOwnedPrimitive(context)) {
+      return {};
+    }
+
+    return {
+      JSXOpeningElement(node) {
+        const seen = new Map();
+        for (const utility of openingElementClassUtilities(node, context)) {
+          const parsed = sizeUtility(utility);
+          if (!parsed) continue;
+          const key = `${parsed.variants}${parsed.value}`;
+          const axes = seen.get(key) ?? new Set();
+          axes.add(parsed.axis);
+          seen.set(key, axes);
+          if (axes.size === 2) {
+            context.report({
+              node,
+              messageId: "pairedSize",
+              data: { variants: parsed.variants, value: parsed.value },
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/dist/eslint/rules/no-repainted-focus.js

@@ -0,0 +1,80 @@
+import { classUtilities } from "./jsx-class-utility.js";
+
+/**
+ * Keyboard focus has one owner: the globals.css base layer draws the offset
+ * ink outline on every :focus-visible element (DESIGN.md "Focus ring"), and an
+ * invalid control takes the same geometry in the destructive hue. A component
+ * that paints focus with a box-shadow ring, a raw outline width, or its own
+ * hue forks that treatment. Standard tool checked (ADR 0057 tier 2): no
+ * upstream Tailwind rule models "focus variant may only suppress or restate
+ * the canonical outline".
+ *
+ * A focus-variant utility may only suppress the outline (outline-none,
+ * outline-hidden), restate the canonical treatment on a proxy target (the
+ * outline style/width/offset tokens plus the ring-role colors, as input-group
+ * does when the group carries the indicator for its inner control), or move
+ * non-paint properties (z-index, colors of the element itself, …).
+ */
+const RING_BASE = /^-?ring(?:-|$)/;
+const ALLOWED_OUTLINE_BASE = new Set(["outline", "outline-none", "outline-hidden"]);
+const ALLOWED_OUTLINE_COLOR = /^outline-(?:ring|sidebar-ring)$/;
+const OUTLINE_TOKEN_LENGTH = /^outline-\[length:var\(--outline-width-focus\)\]$/;
+const OUTLINE_OFFSET = /^-?outline-offset-/;
+
+function baseOf(utility) {
+  let depth = 0;
+  let base = utility;
+  for (let i = 0; i < utility.length; i += 1) {
+    const ch = utility[i];
+    if (ch === "[" || ch === "(") depth += 1;
+    else if (ch === "]" || ch === ")") depth -= 1;
+    else if (ch === ":" && depth === 0) base = utility.slice(i + 1);
+  }
+  return base;
+}
+
+function repaintedFocus(utility) {
+  if (!utility.includes("focus")) return undefined;
+  const base = baseOf(utility);
+  if (base === utility) return undefined;
+  if (RING_BASE.test(base)) return "boxShadowFocus";
+  if (base.startsWith("[outline")) return "customFocusOutline";
+  if (!base.startsWith("outline")) return undefined;
+  if (
+    ALLOWED_OUTLINE_BASE.has(base) ||
+    ALLOWED_OUTLINE_COLOR.test(base) ||
+    OUTLINE_TOKEN_LENGTH.test(base) ||
+    OUTLINE_OFFSET.test(base)
+  ) {
+    return undefined;
+  }
+  return "customFocusOutline";
+}
+
+export const noRepaintedFocus = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Keep keyboard focus on the base-layer outline: no box-shadow ring, raw width, or component hue on a focus variant",
+    },
+    schema: [],
+    messages: {
+      boxShadowFocus:
+        "Focus never paints a box-shadow: the base layer draws the offset outline. Drop {{utility}}.",
+      customFocusOutline:
+        "{{utility}} repaints focus with its own width or hue. The base layer owns the focus outline; a proxy target restates only the canonical tokens.",
+    },
+  },
+  create(context) {
+    return {
+      JSXAttribute(node) {
+        for (const utility of classUtilities(node)) {
+          const messageId = repaintedFocus(utility);
+          if (messageId === undefined) continue;
+          context.report({ node, messageId, data: { utility } });
+        }
+      },
+    };
+  },
+};

package/dist/eslint/rules/no-resting-settings-control.js

@@ -0,0 +1,87 @@
+/*
+ * The settings law, proved on the surfaces that declare they follow it.
+ *
+ * A file that renders `SettingsFactsSection` has said its settings are a
+ * reading surface: current values stated as facts, one affordance opening the
+ * editor that changes them. The regression this catches is a form control
+ * rendered beside those facts rather than inside the editor they summon.
+ *
+ * "Inside the editor" means inside an `ActionDialogForm`'s `fields` prop, or
+ * inside a `Dialog`/`Drawer` subtree for a surface that owns its own. Being a
+ * CHILD of `ActionDialogForm` is the opposite: children are the resting surface
+ * the dialog is opened from, which is exactly where a control must not be.
+ *
+ * The scope is the declaring file rather than every page, so a registry
+ * toolbar's search or a mobile nav select is never a violation — a guard whose
+ * allow-list carries live violations documents debt instead of preventing it.
+ *
+ * Standard tool checked (ADR 0057 tier 2): `no-restricted-syntax` selects one
+ * node by shape and cannot ask what else the file renders, nor whether an
+ * ancestor summoned the subtree. Both are relationships, so the rule lives
+ * here. Replaces `restingSettingsControlViolations` in the retired portal
+ * page-grammar analyzers (#821).
+ */
+
+// The controls a person types or picks into. Lowercase `input` is deliberately
+// absent: a hidden field carries context a summoned editor already decided, and
+// it is not a control anyone rests their eyes on.
+const RESTING_CONTROL_TAGS = new Set([
+  "Checkbox",
+  "Input",
+  "InputOTP",
+  "NativeSelect",
+  "Select",
+  "Switch",
+  "Textarea",
+]);
+
+const FACTS_SECTION_TAG = "SettingsFactsSection";
+
+function elementName(node) {
+  return node?.name?.type === "JSXIdentifier" ? node.name.name : undefined;
+}
+
+function summons(node) {
+  if (node.type === "JSXAttribute") return node.name.name === "fields";
+  if (node.type !== "JSXElement") return false;
+  const name = elementName(node.openingElement);
+  return Boolean(name && (name.startsWith("Dialog") || name.startsWith("Drawer")));
+}
+
+export const noRestingSettingsControl = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow a form control resting beside the facts it should be summoned over, on a settings-facts surface",
+    },
+    schema: [],
+    messages: {
+      restingControl:
+        "<{{tag}}> rests beside its facts: put it in the editor the facts summon (an ActionDialogForm `fields` prop, or a Dialog/Drawer subtree).",
+    },
+  },
+  create(context) {
+    let declaresFacts = false;
+    const resting = [];
+
+    return {
+      JSXOpeningElement(node) {
+        const name = elementName(node);
+        if (name === FACTS_SECTION_TAG) {
+          declaresFacts = true;
+          return;
+        }
+        if (!name || !RESTING_CONTROL_TAGS.has(name)) return;
+        if (context.sourceCode.getAncestors(node).some(summons)) return;
+        resting.push({ node, name });
+      },
+      "Program:exit"() {
+        if (!declaresFacts) return;
+        for (const { node, name } of resting) {
+          context.report({ node, messageId: "restingControl", data: { tag: name } });
+        }
+      },
+    };
+  },
+};