@starci/eslint-canon-fe 1.0.0

package/tokens.mjs

@@ -0,0 +1,268 @@
+import { existsSync, readFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+/**
+ * The rules that hold `tokens.md`.
+ *
+ * THE UNION DOES MOST OF THIS, AND THESE RULES COVER WHAT IT CANNOT SEE. Every tier above the
+ * leaves takes its classes from a typed entry, so an off-scale value there does not fail review -
+ * it fails to compile, and there is nothing left to patrol. The leaf folder writes its own classes
+ * and is exempt from the entry rules by policy, which makes it the one place a fractional step or a
+ * bracketed length can still be typed. That folder is what these rules are for.
+ *
+ * THEY READ CONSTANTS AS WELL AS MARKUP. The last off-scale value in the source these were written
+ * for lived in a module constant - `size-3.5` in one leaf, and a `py-1.5` in another - where every
+ * rule that only walked JSX attributes looked straight past it. Hoisting hides a value; it does not
+ * license one.
+ */
+
+/** Forward-slash form of a filename, so Windows paths compare like every other path. */
+const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** Product source lives under `src/`; tooling and config are out of scope. */
+const isSourceFile = (filename) => normalizePath(filename).includes("/src/")
+
+/**
+ * A fractional step, in any family that measures.
+ *
+ * The rungs are whole and unevenly spaced, so half of one is not "between two rungs" - it is off
+ * the ladder, and it will match nothing else on any screen.
+ */
+const FRACTIONAL =
+  /\b(?:gap|gap-x|gap-y|p|px|py|pt|pb|pl|pr|m|mx|my|mt|mb|ml|mr|space-x|space-y|inset|top|bottom|left|right|size|w|h)-\d+\.\d+\b/
+
+/** A bracketed length: a value chosen once, for one screen, findable by nobody. */
+const ARBITRARY_LENGTH =
+  /\b(?:gap|gap-x|gap-y|p|px|py|pt|pb|pl|pr|m|mx|my|mt|mb|ml|mr|space-x|space-y|size|w|h|min-w|min-h|max-w|max-h)-\[[^\]]+\]/
+
+/** A raw colour, which escapes the semantic palette even when it matches it today. */
+const RAW_COLOUR = /\b(?:text|bg|border|ring|from|to|via|fill|stroke|shadow|decoration)-\[#[0-9a-fA-F]/
+
+/** Large text. Paired with a heavy weight it is a heading, whatever element carries it. */
+const LARGE_TEXT = /\btext-(?:xl|2xl|3xl|4xl|5xl)\b/
+
+/** A heavy weight. */
+const HEAVY_WEIGHT = /\bfont-(?:bold|extrabold|black)\b/
+
+/** True for a `className` / `class` JSX attribute. */
+const isClassAttribute = (node) =>
+  node.type === "JSXAttribute" && node.name && (node.name.name === "className" || node.name.name === "class")
+
+/** Static string carried by a JSX attribute, a module constant, or an array member. */
+const staticText = (value) => {
+  if (!value) return null
+  if (value.type === "Literal" && typeof value.value === "string") return value.value
+  if (value.type === "TemplateLiteral" && value.expressions.length === 0) {
+    return value.quasis.map((quasi) => quasi.value.cooked).join(" ")
+  }
+  if (value.type === "JSXExpressionContainer") return staticText(value.expression)
+  if (value.type === "ArrayExpression") {
+    const members = value.elements.map((element) => staticText(element)).filter(Boolean)
+    return members.length > 0 ? members.join(" ") : null
+  }
+  return null
+}
+
+/** Walk every place a class string can be written: markup, a constant, or an entry's array. */
+const classTextVisitors = (context, report) => {
+  if (!isSourceFile(context.filename || context.getFilename())) return {}
+  return {
+    JSXAttribute(node) {
+      if (!isClassAttribute(node)) return
+      report(node, staticText(node.value))
+    },
+    VariableDeclarator(node) {
+      report(node, staticText(node.init))
+    },
+    Property(node) {
+      if (node.computed) return
+      const key = node.key.type === "Identifier" ? node.key.name : null
+      if (key !== "classes") return
+      report(node, staticText(node.value))
+    },
+  }
+}
+
+// -- TOKEN-3 ---------------------------------------------------------------------------------------
+
+/** A fractional step is off the ladder, not between two rungs. */
+export const noFractionalStep = {
+  meta: {
+    type: "problem",
+    docs: { description: "A measurement takes a whole rung; a fractional step is off the scale." },
+    schema: [],
+    messages: {
+      fractional:
+        "`{{cls}}` is half a rung. The scale is whole steps, unevenly spaced, so this is not between two rungs - it is off the ladder, and it will match nothing else on any screen. Use the nearest rung; there is no case where the right answer is half of one.",
+    },
+  },
+  create(context) {
+    return classTextVisitors(context, (node, text) => {
+      if (!text) return
+      const hit = text.match(FRACTIONAL)
+      if (hit) context.report({ node, messageId: "fractional", data: { cls: hit[0] } })
+    })
+  },
+}
+
+// -- TOKEN-4 ---------------------------------------------------------------------------------------
+
+/** An arbitrary value escapes the system, whatever it happens to evaluate to. */
+export const noArbitraryValue = {
+  meta: {
+    type: "problem",
+    docs: { description: "Bracketed lengths and raw colours escape the closed vocabulary." },
+    schema: [],
+    messages: {
+      length:
+        "`{{cls}}` is a value chosen once, for one screen. Even where it happens to equal a rung, nobody searching the scale can find it and it does not move when the scale moves. Use a member of the vocabulary, or add one deliberately.",
+      colour:
+        "`{{cls}}` is a raw colour, outside the semantic palette. A colour named for what it MEANS follows the theme; one named for what it is stays the same in a theme where it is wrong.",
+    },
+  },
+  create(context) {
+    return classTextVisitors(context, (node, text) => {
+      if (!text) return
+      const length = text.match(ARBITRARY_LENGTH)
+      if (length) context.report({ node, messageId: "length", data: { cls: length[0] } })
+      const colour = text.match(RAW_COLOUR)
+      if (colour) context.report({ node, messageId: "colour", data: { cls: colour[0] } })
+    })
+  },
+}
+
+// -- TOKEN-5 ---------------------------------------------------------------------------------------
+
+/** Large text plus a heavy weight is a heading, and headings come from the component that owns both. */
+export const noHandRolledHeading = {
+  meta: {
+    type: "problem",
+    docs: { description: "A heading comes from the heading component, not from raw type classes." },
+    schema: [],
+    messages: {
+      heading:
+        "Large text and a heavy weight together are a heading, whatever element carries them - and assembled here it is a heading nothing else knows about: the outline a screen reader builds does not contain it, and it stays behind the day the type scale changes. Render the heading component, which owns the tag and the size as one decision.",
+    },
+  },
+  create(context) {
+    return classTextVisitors(context, (node, text) => {
+      if (!text) return
+      if (LARGE_TEXT.test(text) && HEAVY_WEIGHT.test(text)) {
+        context.report({ node, messageId: "heading" })
+      }
+    })
+  },
+}
+
+/**
+ * The class families whose names are PROMISES about a theme token, and the variable each needs.
+ *
+ * Tailwind resolves `max-w-app-lg` by looking for `--container-app-lg`. Nothing warns when that
+ * variable does not exist: the class is emitted, the element gets no width, and the type system
+ * is satisfied because the name IS in the union. That is the failure this rule exists for - a
+ * class can be typesafe and mean nothing at the same time, and the union is exactly what makes
+ * it look settled.
+ *
+ * Only families whose token name is DERIVABLE from the class name are listed. A colour or a
+ * spacing step resolves through Tailwind's own scale as well as the theme, so a rule guessing at
+ * those would report classes that work.
+ */
+/**
+ * Names Tailwind resolves ITSELF, which therefore promise nothing about this theme.
+ *
+ * `min-h-screen` is the viewport, not a variable; so are `full`, `fit`, `auto` and the viewport
+ * units. Reported as unresolved tokens they would send an author to define `--min-height-screen`,
+ * which is a variable nothing reads - the rule would have invented work and broken a working class.
+ * Measured on both repositories the first time this ran: two findings, both wrong, both this list.
+ */
+const TAILWIND_OWN_NAMES = new Set([
+  "screen", "full", "fit", "auto", "none", "min", "max", "prose",
+  "dvh", "svh", "lvh", "dvw", "svw", "lvw", "px",
+])
+const TOKEN_CLASS_FAMILIES = [
+  { pattern: /^max-w-app-([a-z0-9]+)$/, variable: (name) => `--container-app-${name}` },
+  { pattern: /^max-h-([a-z][a-z0-9-]*)$/, variable: (name) => `--max-height-${name}` },
+  { pattern: /^min-h-([a-z][a-z0-9-]*)$/, variable: (name) => `--min-height-${name}` },
+]
+
+/** Stylesheets a repository may declare its theme in, relative to the repository root. */
+const STYLESHEET_CANDIDATES = [
+  "src/app/globals.css",
+  "apps/app/src/app/globals.css",
+  "apps/expert/src/app/globals.css",
+  "apps/landing/src/app/globals.css",
+  "packages/ui/src/styles/globals.css",
+]
+
+/** Every stylesheet found above the linted file, read once and cached for the run. */
+const themeCache = new Map()
+const themeTextFor = (filename) => {
+  let directory = dirname(normalizePath(filename))
+  for (let depth = 0; depth < 12 && directory !== "/" && directory !== ""; depth += 1) {
+    if (themeCache.has(directory)) return themeCache.get(directory)
+    const found = STYLESHEET_CANDIDATES
+      .map((relative) => join(directory, relative))
+      .filter((candidate) => existsSync(candidate))
+      .map((candidate) => readFileSync(candidate, "utf8"))
+    if (found.length > 0) {
+      const text = found.join("\n")
+      themeCache.set(directory, text)
+      return text
+    }
+    directory = dirname(directory)
+  }
+  return null
+}
+
+/** A class naming a token the theme never defines is a class that draws nothing. */
+export const noUnresolvedTokenClass = {
+  meta: {
+    type: "problem",
+    docs: { description: "A class naming a theme token resolves only when the theme defines it." },
+    schema: [],
+    messages: {
+      unresolved:
+        "`{{value}}` reads as a token this theme defines, and `{{variable}}` is defined nowhere in it. Tailwind emits the class, the element gets nothing, and both the union and the compiler stay happy - which is why this is the one dead class no type can catch. Define `{{variable}}` in the stylesheet, or name a token that exists.",
+    },
+  },
+  create(context) {
+    const file = normalizePath(context.filename || context.getFilename())
+    if (!isSourceFile(file)) return {}
+    const theme = themeTextFor(file)
+    // A reader that cannot find the stylesheet stays quiet rather than calling every token dead.
+    if (theme === null) return {}
+    // The visitor hands (node, text) in that order; reversing them here is how a rule reports the
+    // node as its message and the message as its node, and neither complains.
+    const check = (node, value) => {
+      for (const raw of String(value).split(/\s+/)) {
+        const bare = raw.replace(/^[a-z-]+:/, "").replace(/^!/, "")
+        for (const family of TOKEN_CLASS_FAMILIES) {
+          const match = family.pattern.exec(bare)
+          if (match === null) continue
+          if (TAILWIND_OWN_NAMES.has(match[1])) continue
+          const variable = family.variable(match[1])
+          if (theme.includes(variable)) continue
+          context.report({ node, messageId: "unresolved", data: { value: bare, variable } })
+        }
+      }
+    }
+    return classTextVisitors(context, check)
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "no-fractional-step": noFractionalStep,
+  "no-arbitrary-value": noArbitraryValue,
+  "no-hand-rolled-heading": noHandRolledHeading,
+  "no-unresolved-token-class": noUnresolvedTokenClass,
+}
+
+/**
+ * The level this law asks for, as the plugin's own opinion.
+ *
+ * All three match on shape rather than judgement, so none carries the false-positive risk that
+ * would justify adopting it at `warn`. A repository with history should expect the arbitrary-value
+ * rule to report most: a bracketed length is the usual shape of a one-off fix.
+ */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/translation.mjs

@@ -0,0 +1,122 @@
+/**
+ * The rules that hold `translation.md`.
+ *
+ * TWO RULES, AND THE SECOND ONE IS THE INTERESTING ONE. Forbidding a translation call below a block
+ * is easy and mostly redundant - the split rule already stops the drawing half reaching for the
+ * runtime. What nothing else catches is a literal that a reader can SEE, sitting in a tier that is
+ * supposed to receive every word it renders.
+ *
+ * THE ATTRIBUTES MATTER MORE THAN THE MARKUP. Copy hides in `aria-label`, `placeholder`, `title`
+ * and `alt` precisely because none of them reads as a sentence when you scan the file - and an
+ * `aria-label` is not a small case: a screen reader treats it as the primary text, so an English
+ * one on a translated surface is the loudest defect on the page for the reader least able to work
+ * around it.
+ *
+ * The prose test is deliberately crude - a space and a leading capital - because the alternative is
+ * a rule that argues about whether a given string is a sentence. A crude test that fires on real
+ * copy and spares tokens is worth more than a clever one nobody trusts.
+ */
+
+/** Forward-slash form of a filename, so Windows paths compare like every other path. */
+const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** Tiers that receive every word they render: they know no domain, so they can know no sentence. */
+const VOCABULARY_DIRS = ["leaves", "shells", "composites", "branches"]
+
+/** True when a file sits in a tier that must not hold copy. */
+const isVocabularyFile = (filename) => {
+  const file = normalizePath(filename)
+  return VOCABULARY_DIRS.some((dir) => file.includes(`/src/components/${dir}/`))
+}
+
+/** Attributes a reader sees or hears, none of which looks like a sentence in the markup. */
+const VISIBLE_ATTRS = new Set(["aria-label", "placeholder", "title", "alt", "aria-description"])
+
+/** Calls that resolve a word at render time. */
+const RESOLVES_COPY = /^(?:useTranslations|useLocale|useFormatter|getTranslations)$/
+
+/** Prose rather than a token: it has a space and it starts like a sentence. */
+const looksLikeProse = (text) => typeof text === "string" && /\s/.test(text) && /^[A-Z]/.test(text)
+
+/** Static string carried by a JSX attribute. */
+const attributeText = (node) => {
+  const value = node && node.value
+  if (!value) return null
+  if (value.type === "Literal" && typeof value.value === "string") return value.value
+  if (value.type === "JSXExpressionContainer" && value.expression.type === "Literal") {
+    return typeof value.expression.value === "string" ? value.expression.value : null
+  }
+  return null
+}
+
+// -- COPY-1 ----------------------------------------------------------------------------------------
+
+/** A component below a block never resolves a word. */
+export const noCopyResolutionBelowBlock = {
+  meta: {
+    type: "problem",
+    docs: { description: "The vocabulary tiers receive resolved strings; they never resolve one." },
+    schema: [],
+    messages: {
+      resolves:
+        "`{{name}}(...)` resolves a word in a tier that receives every word it renders. This component would then need the translation runtime to be rendered from a fixture, and it would have to know which situation the reader is in to pick the right sentence - which is the connected half's job, one file away.",
+    },
+  },
+  create(context) {
+    if (!isVocabularyFile(context.filename || context.getFilename())) return {}
+    return {
+      CallExpression(node) {
+        const callee = node.callee
+        if (!callee || callee.type !== "Identifier" || !RESOLVES_COPY.test(callee.name)) return
+        context.report({ node, messageId: "resolves", data: { name: callee.name } })
+      },
+    }
+  },
+}
+
+// -- COPY-2 ----------------------------------------------------------------------------------------
+
+/** A component below a block holds no literal a reader can see or hear. */
+export const noHardcodedCopyInVocabulary = {
+  meta: {
+    type: "problem",
+    docs: { description: "No visible or spoken literal in a tier that receives its words." },
+    schema: [],
+    messages: {
+      hardcoded:
+        "`{{attr}}=\"{{text}}\"` is copy, hardcoded in a tier that receives every word it renders - so one reader in another language sees English here. It also does not read as a sentence when scanning this file, which is why this attribute is where copy hides. Take a resolved string through `props`.",
+      text:
+        "`{{text}}` is copy written into a tier that receives its words. A reader in another language sees this exactly as written. Take a resolved string through `props`.",
+    },
+  },
+  create(context) {
+    if (!isVocabularyFile(context.filename || context.getFilename())) return {}
+    return {
+      JSXAttribute(node) {
+        const attr = node.name && node.name.type === "JSXIdentifier" ? node.name.name : null
+        if (!attr || !VISIBLE_ATTRS.has(attr)) return
+        const text = attributeText(node)
+        if (looksLikeProse(text)) context.report({ node, messageId: "hardcoded", data: { attr, text } })
+      },
+      JSXText(node) {
+        const text = String(node.value || "").trim()
+        if (looksLikeProse(text)) context.report({ node, messageId: "text", data: { text } })
+      },
+    }
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "no-copy-resolution-below-block": noCopyResolutionBelowBlock,
+  "no-hardcoded-copy-in-vocabulary": noHardcodedCopyInVocabulary,
+}
+
+/**
+ * The level this law asks for, as the plugin's own opinion.
+ *
+ * The second rule is the one a repository with history should expect a count from, and every report
+ * is a real move: the string has to be lifted to a connected half and given a key, which is work
+ * rather than a deletion.
+ */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/type-safety.mjs

@@ -0,0 +1,74 @@
+/**
+ * The rules that hold `type-safety.md`.
+ *
+ * ONE RULE HERE, AND TWO ELSEWHERE. `any` is refused by the TypeScript plugin's own rule and the
+ * array spelling by its formatter rule, so neither is reimplemented - a second copy of somebody
+ * else's rule is a second thing to keep in step, and the one nobody edits is the one that stops
+ * matching. What is left is the double cast, which no off-the-shelf rule refuses because most
+ * codebases consider it a legitimate escape.
+ *
+ * THE EXEMPTION IS A PATH, and it has to be. Proving a closed API refuses bad input means building
+ * bad input, and there is no way to construct a value the types forbid without telling the compiler
+ * to forget them. A judgement-based exemption would be argued at every call site; a path is argued
+ * once, here.
+ */
+
+/** Forward-slash form of a filename, so Windows paths compare like every other path. */
+const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** Product source lives under `src/`; tooling and config are out of scope. */
+const isSourceFile = (filename) => normalizePath(filename).includes("/src/")
+
+/** A test may build a value the types forbid, because that is what it is proving. */
+const isTestFile = (filename) => /\.(?:test|spec)\.(?:ts|tsx)$/.test(normalizePath(filename))
+
+/** Product source this rule governs. */
+const isGoverned = (filename) => isSourceFile(filename) && !isTestFile(filename)
+
+/** True when a type node is the `unknown` keyword. */
+const isUnknown = (node) => Boolean(node) && node.type === "TSUnknownKeyword"
+
+// -- TYPE-SAFETY-1 ---------------------------------------------------------------------------------
+
+/** A cast through `unknown` erases what the compiler knew, at the seam where it mattered. */
+export const noDoubleCast = {
+  meta: {
+    type: "problem",
+    docs: { description: "No cast through `unknown`; it turns checking off at the boundary." },
+    schema: [],
+    messages: {
+      double:
+        "Casting through `unknown` tells the compiler to forget everything it knew about this value, because the two types have nothing in common. That is not a narrowing - a narrowing is a claim the compiler can still partly check - it is an erasure, and the seam it erases is the one worth checking: where a value crosses from outside the program to inside it. Narrow from `unknown` with a check the compiler can follow, or fix the shape.",
+    },
+  },
+  create(context) {
+    if (!isGoverned(context.filename || context.getFilename())) return {}
+    return {
+      TSAsExpression(node) {
+        // The outer cast of a `x as unknown as T` pair: its operand is itself a cast to `unknown`.
+        const inner = node.expression
+        if (!inner || inner.type !== "TSAsExpression") return
+        if (!isUnknown(inner.typeAnnotation)) return
+        context.report({ node, messageId: "double" })
+      },
+    }
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "no-double-cast": noDoubleCast,
+}
+
+/**
+ * The level this law asks for, as the plugin's own opinion.
+ *
+ * Exact - it matches one syntactic shape - but a repository adopting it with history should expect
+ * each report to be real work: a double cast is usually load-bearing by the time anybody notices,
+ * and removing one means giving the value a shape it did not have.
+ *
+ * `any` and the array spelling are NOT published here. They belong to the TypeScript plugin's own
+ * rules, which a consuming repository already has: `@typescript-eslint/no-explicit-any` and
+ * `@typescript-eslint/array-type` with the generic default.
+ */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/typography.mjs

@@ -0,0 +1,83 @@
+/**
+ * The rule that holds `typography.md`.
+ *
+ * MOST OF THIS LAW IS A UNION, and what is left is one shape a type cannot see: a heading TAG
+ * written by hand. The level union stops a fifth step being asked for; nothing in the type system
+ * notices an `<h2>` in a file that never mentions the heading component at all.
+ *
+ * The rule's own twin lives in `tokens.mjs`: that one catches a heading assembled out of a large
+ * size and a heavy weight on some other element. Between them they cover both ways a heading gets
+ * hand-rolled - with the right tag and the wrong look, or the right look and no tag.
+ */
+
+/** Forward-slash form of a filename, so Windows paths compare like every other path. */
+const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** Product source lives under `src/`; tooling and config are out of scope. */
+const isSourceFile = (filename) => normalizePath(filename).includes("/src/")
+
+/** A twin test may build heading markup by hand to assert against it. */
+const isTestFile = (filename) => /\.(?:test|spec)\.(?:ts|tsx)$/.test(normalizePath(filename))
+
+/** The one component that owns the tag and the size together, and therefore may write the tag. */
+const isHeadingComponent = (filename) => normalizePath(filename).includes("/src/components/leaves/Heading/")
+
+/** The tags a document outline is built from. */
+const HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"])
+
+/** The deepest level the component draws; below this a page has nested too far. */
+const DEEPEST_LEVEL = 4
+
+/** Intrinsic (lowercase) tag name, or null for a component. */
+const tagName = (opening) => {
+  const name = opening && opening.name
+  if (!name || name.type !== "JSXIdentifier") return null
+  return name.name === name.name.toLowerCase() ? name.name : null
+}
+
+// -- TYPESET-1 · TYPESET-2 -------------------------------------------------------------------------------
+
+/** A heading comes from the component that owns its tag and its size as one decision. */
+export const noHeadingTagOutsideHeadingComponent = {
+  meta: {
+    type: "problem",
+    docs: { description: "Heading tags are written by the heading component, from a level." },
+    schema: [],
+    messages: {
+      tag:
+        "`<{{tag}}>` written here throws away the two facts the heading component exists to keep together: the tag a screen reader builds the document outline from, and the size a reader sees. Set separately they drift, and a screen's third-largest text becomes its first heading. Render the heading component with a level of {{level}}; one prop decides both, so they cannot disagree.",
+      tooDeep:
+        "`<{{tag}}>` is deeper than the scale goes: levels stop at {{deepest}}, because a fifth means the page has nested further than a reader can hold. That is a structure problem wearing a styling problem's clothes - flatten the section, then render the title with a level the scale has.",
+    },
+  },
+  create(context) {
+    const file = normalizePath(context.filename || context.getFilename())
+    if (!isSourceFile(file) || isTestFile(file) || isHeadingComponent(file)) return {}
+    return {
+      JSXOpeningElement(node) {
+        const tag = tagName(node)
+        if (!tag || !HEADING_TAGS.has(tag)) return
+        const level = Number(tag.slice(1))
+        if (level > DEEPEST_LEVEL) {
+          context.report({ node, messageId: "tooDeep", data: { tag, deepest: DEEPEST_LEVEL } })
+          return
+        }
+        context.report({ node, messageId: "tag", data: { tag, level } })
+      },
+    }
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "no-heading-tag-outside-heading-component": noHeadingTagOutsideHeadingComponent,
+}
+
+/**
+ * The level this law asks for, as the plugin's own opinion.
+ *
+ * Exact: a tag name in a file that is not the component that owns it. A repository adopting this
+ * with history should expect the deeper levels to report a structure problem rather than a styling
+ * one, and those take longer to fix than the message suggests.
+ */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))