@starci/eslint-canon-fe 6.0.2 → 7.1.0

package/e2e-shape.mjs

@@ -1,345 +0,0 @@
-/**
- * The rules that hold `e2e-shape.md` (HFS R66, `FE_E2E_SHAPE`).
- *
- * THESE RULES GOVERN THE E2E TREE, NOT `src/`. `starciFeConfig` attaches them to `e2e/**` and
- * `playwright.config.*`; every rule here also scopes itself by HFS slot (tier e2e, the Playwright config role), so a config that reaches it by
- * mistake governs nothing it should not.
- *
- * WHY THE SHAPE IS FIXED. An e2e suite is the only proof that the whole app works, and it is run by
- * hand, so it rots quietly: absolute paths that exist on one machine, a Docker dependency that makes
- * it unrunnable in CI, a helper that writes into the OTHER repository's tree, a `test.skip` that
- * turns a missing environment into a green run, and helpers whose untyped parameters hide the fields
- * a test depends on. One layout - `e2e/<area>/<name>.e2e-spec.ts`, three viewports, typed helpers -
- * is what lets the land gate check it statically even though it cannot run it.
- *
- * WHAT IS NOT HERE. That `typecheck:e2e` runs before `test:e2e` is a `package.json` fact (the
- * architecture machine reads it); that the specs pass is the run itself.
- */
-
-import { baseName, classOf, fileOf, inSlot, isE2eSource, roleOfFile } from "./lib/scope.mjs"
-
-/** The three viewports every e2e project set covers, as `width x height`. */
-export const VIEWPORTS = Object.freeze(["1440x900", "768x1024", "390x844"])
-
-/** A file that reads like a spec, by any of the common spellings. */
-const SPEC_LIKE = /(?:\.|-)(?:e2e-)?(?:spec|test)\.[cm]?tsx?$/
-
-/** A helper file that is named as a spec. */
-const E2E_SPEC_NAME = /\.e2e-spec\./
-
-/** The slots of the e2e tree: the specs (`fe.e2e`) and their helpers (`fe.e2e-support`). */
-const E2E_SLOTS = ["fe.e2e", "fe.e2e-support"]
-
-/** An absolute filesystem path: a drive, a UNC share, or a well-known root. */
-const ABSOLUTE_PATH = /^(?:[A-Za-z]:[\\/]|\\\\|\/(?:Users|home|tmp|mnt|var|opt|etc|root|d|c)\/)/
-
-/** A `..` segment in a path string. */
-const PARENT_SEGMENT = /(?:^|[\\/])\.\.(?:[\\/]|$)/
-
-/** Static string of a literal or an expression-free template, else null. */
-const staticString = (node) => {
-  if (!node) return null
-  if (node.type === "Literal" && typeof node.value === "string") return node.value
-  if (node.type === "TemplateLiteral") return node.quasis.map((quasi) => quasi.value.cooked ?? "").join("")
-  return null
-}
-
-/** Every string in a subtree, so `path.join(__dirname, "..", "..")` is read as its parts. */
-const stringsIn = (node, source) => {
-  const found = []
-  const walk = (current) => {
-    if (!current || typeof current.type !== "string") return
-    const text = staticString(current)
-    if (text !== null) found.push(text)
-    for (const key of source.visitorKeys[current.type] ?? []) {
-      const child = current[key]
-      if (Array.isArray(child)) child.forEach(walk)
-      else walk(child)
-    }
-  }
-  walk(node)
-  return found
-}
-
-// -- E2E-1 -----------------------------------------------------------------------------------------
-
-/** Specs live at `e2e/<area>/<name>.e2e-spec.ts`. */
-export const e2eSpecLocation = {
-  meta: {
-    type: "problem",
-    docs: { description: "An e2e spec is `e2e/<area>/<name>.e2e-spec.ts`; helpers live under `support/` or `fixtures/`." },
-    schema: [],
-    messages: {
-      location:
-        "`{{name}}` is not at `e2e/<area>/<name>.e2e-spec.ts`. One shape - an area folder, the `.e2e-spec.ts` suffix - is what lets the gate find every spec without running them; helpers go in `e2e/support/` or `e2e/fixtures/` and are never named like a spec.",
-    },
-  },
-  create(context) {
-    const name = baseName(fileOf(context))
-    const found = classOf(context)
-    // A helper slot (`fe.e2e-support`) owns no spec: a helper named like one is a spec in the wrong place.
-    const helperNamedSpec = inSlot(context, "fe.e2e-support") && E2E_SPEC_NAME.test(name)
-    // A spec-looking file no slot owns but that sits inside the e2e tree (the nearest slot is an e2e slot, matched past the repository root)
-    // is a spec off the one place `fe.e2e` gives it. A file outside the e2e tree is not this rule's business.
-    const misplacedSpec = found.status === "no-slot" && E2E_SLOTS.includes(found.nearest?.slot) && found.nearest.matchedDepth >= 1 && SPEC_LIKE.test(name)
-    if (helperNamedSpec || misplacedSpec) return { Program: (node) => context.report({ node, messageId: "location", data: { name } }) }
-    return {}
-  },
-}
-
-// -- E2E-2 -----------------------------------------------------------------------------------------
-
-/** No absolute path in e2e source. */
-export const e2eNoAbsolutePath = {
-  meta: {
-    type: "problem",
-    docs: { description: "No absolute filesystem path in e2e source." },
-    schema: [],
-    messages: {
-      absolute:
-        "An absolute path (`{{path}}`). It exists on one machine and nowhere else, so the suite passes locally and cannot run in CI or on another machine. Build the path from the config or the test's own directory.",
-    },
-  },
-  create(context) {
-    if (!isE2eSource(context)) return {}
-    const check = (node, text) => {
-      if (typeof text === "string" && ABSOLUTE_PATH.test(text)) context.report({ node, messageId: "absolute", data: { path: text } })
-    }
-    return {
-      Literal: (node) => check(node, node.value),
-      TemplateElement: (node) => check(node, node.value && node.value.cooked),
-    }
-  },
-}
-
-// -- E2E-3 -----------------------------------------------------------------------------------------
-
-/** Container tooling that an e2e suite must not depend on. */
-const DOCKER_MODULE = /^(?:dockerode|testcontainers|@testcontainers\/.+|docker-compose)$/
-
-/** A command or string that starts Docker. */
-const DOCKER_TEXT = /\bdocker(?:-compose)?\b|\bdocker\s+compose\b/i
-
-/** No Docker in e2e. */
-export const e2eNoDocker = {
-  meta: {
-    type: "problem",
-    docs: { description: "An e2e suite does not start or require Docker." },
-    schema: [],
-    messages: {
-      docker:
-        "Docker in an e2e suite. A suite that needs a container runtime cannot run where the app can, and it hides the real prerequisite (a running app and backend) behind a tool. Point the suite at a URL from the config and let the environment provide the stack.",
-    },
-  },
-  create(context) {
-    if (!isE2eSource(context)) return {}
-    return {
-      ImportDeclaration(node) {
-        if (DOCKER_MODULE.test(String(node.source.value))) context.report({ node, messageId: "docker" })
-      },
-      Literal(node) {
-        if (typeof node.value === "string" && DOCKER_TEXT.test(node.value)) context.report({ node, messageId: "docker" })
-      },
-      TemplateElement(node) {
-        if (DOCKER_TEXT.test((node.value && node.value.cooked) || "")) context.report({ node, messageId: "docker" })
-      },
-    }
-  },
-}
-
-// -- E2E-4 -----------------------------------------------------------------------------------------
-
-/** Filesystem calls that write, move or remove. */
-const FS_WRITE = new Set([
-  "writeFile",
-  "writeFileSync",
-  "appendFile",
-  "appendFileSync",
-  "mkdir",
-  "mkdirSync",
-  "rm",
-  "rmSync",
-  "rmdir",
-  "rmdirSync",
-  "copyFile",
-  "copyFileSync",
-  "cp",
-  "cpSync",
-  "rename",
-  "renameSync",
-  "unlink",
-  "unlinkSync",
-  "createWriteStream",
-])
-
-/** The name a call is made through: `writeFile` or `fs.writeFile` or `fs.promises.writeFile`. */
-const calleeName = (callee) => {
-  if (callee.type === "Identifier") return callee.name
-  if (callee.type === "MemberExpression" && !callee.computed) return callee.property.name
-  return null
-}
-
-/** No e2e write outside the repository's own tree. */
-export const e2eNoCrossRepoWrite = {
-  meta: {
-    type: "problem",
-    docs: { description: "An e2e file write never targets an absolute path or climbs out of the repository." },
-    schema: [],
-    messages: {
-      write:
-        "This file operation writes to a path that is absolute or climbs out with `..`. An e2e run that writes into another repository (the backend's tree, a shared folder) changes state it does not own, and its result depends on a checkout layout. Write under this repository's own output folder.",
-    },
-  },
-  create(context) {
-    if (!isE2eSource(context)) return {}
-    const source = context.sourceCode || context.getSourceCode()
-    return {
-      CallExpression(node) {
-        const name = calleeName(node.callee)
-        if (!name || !FS_WRITE.has(name)) return
-        const strings = node.arguments.flatMap((argument) => stringsIn(argument, source))
-        if (strings.some((text) => ABSOLUTE_PATH.test(text) || PARENT_SEGMENT.test(text) || text === "..")) {
-          context.report({ node, messageId: "write" })
-        }
-      },
-    }
-  },
-}
-
-// -- E2E-5 -----------------------------------------------------------------------------------------
-
-/** The root identifier of a member chain: `test` in `test.describe.skip`. */
-const chainRoot = (node) => {
-  let current = node
-  while (current && current.type === "MemberExpression") current = current.object
-  return current && current.type === "Identifier" ? current.name : null
-}
-
-/** No skipped test: a missing environment is a failure. */
-export const e2eNoSkip = {
-  meta: {
-    type: "problem",
-    docs: { description: "No `test.skip`, `test.fixme` or `describe.skip`: a missing environment fails the run." },
-    schema: [],
-    messages: {
-      skip:
-        "A skipped test. Skipping because the environment is missing turns \"the suite cannot run\" into a green run, which is the one result an e2e suite must never give. Fix the environment, or delete the test.",
-    },
-  },
-  create(context) {
-    if (!isE2eSource(context)) return {}
-    return {
-      CallExpression(node) {
-        const callee = node.callee
-        if (callee.type !== "MemberExpression" || callee.computed) return
-        if (!["skip", "fixme"].includes(callee.property.name)) return
-        if (["test", "it", "describe"].includes(chainRoot(callee.object))) context.report({ node, messageId: "skip" })
-      },
-    }
-  },
-}
-
-// -- E2E-6 -----------------------------------------------------------------------------------------
-
-/** True when a function is a module-level helper: declared, or bound to a top-level `const`. */
-const isModuleLevel = (node) => {
-  let current = node.parent
-  if (node.type !== "FunctionDeclaration") {
-    if (!current || current.type !== "VariableDeclarator") return false
-    current = current.parent && current.parent.parent
-  }
-  return Boolean(current) && ["Program", "ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(current.type)
-}
-
-/** Helpers carry types; nothing is `any`. */
-export const e2eTypedHelpers = {
-  meta: {
-    type: "problem",
-    docs: { description: "e2e helper parameters are typed and nothing is `any`." },
-    schema: [],
-    messages: {
-      untyped:
-        "A helper parameter with no type. A test depends on the fields a helper takes and returns; untyped, a renamed field fails at run time in a test nobody touched. Annotate the parameter.",
-      any: "`any` in e2e source. It turns the compiler off for the value a test asserts on. Type it, or narrow from `unknown`.",
-    },
-  },
-  create(context) {
-    if (!isE2eSource(context)) return {}
-    const checkParams = (node) => {
-      if (!isModuleLevel(node)) return
-      for (const parameter of node.params) {
-        const target = parameter.type === "AssignmentPattern" ? parameter.left : parameter
-        // A default value gives the parameter a type the compiler infers.
-        if (parameter.type === "AssignmentPattern" && parameter.right.type === "Literal") continue
-        if (target.type === "RestElement") {
-          if (!target.typeAnnotation) context.report({ node: target, messageId: "untyped" })
-          continue
-        }
-        if (!target.typeAnnotation) context.report({ node: target, messageId: "untyped" })
-      }
-    }
-    return {
-      FunctionDeclaration: checkParams,
-      ArrowFunctionExpression: checkParams,
-      FunctionExpression: checkParams,
-      TSAnyKeyword(node) {
-        context.report({ node, messageId: "any" })
-      },
-    }
-  },
-}
-
-// -- E2E-7 -----------------------------------------------------------------------------------------
-
-/** Every Playwright config declares exactly the three viewports. */
-export const playwrightViewports = {
-  meta: {
-    type: "problem",
-    docs: { description: `playwright.config declares the viewports ${VIEWPORTS.join(", ")} and no others.` },
-    schema: [],
-    messages: {
-      missing:
-        "The Playwright config does not declare the viewport {{size}}. Every app is proved at 1440x900, 768x1024 and 390x844 so a layout that only works on a desktop screen fails here.",
-      extra:
-        "The Playwright config declares the viewport {{size}}, which is not one of 1440x900, 768x1024, 390x844. A fourth size is a fourth thing to keep passing that no design covers.",
-    },
-  },
-  create(context) {
-    if (roleOfFile(context) !== "playwright") return {}
-    const seen = new Map()
-    return {
-      Property(node) {
-        if (node.computed || node.key.type !== "Identifier" || node.key.name !== "viewport") return
-        if (node.value.type !== "ObjectExpression") return
-        const field = (name) => {
-          const property = node.value.properties.find((p) => p.type === "Property" && p.key.type === "Identifier" && p.key.name === name)
-          return property && property.value.type === "Literal" ? property.value.value : null
-        }
-        const width = field("width")
-        const height = field("height")
-        if (typeof width === "number" && typeof height === "number") seen.set(`${width}x${height}`, node)
-      },
-      "Program:exit"(program) {
-        for (const size of VIEWPORTS) if (!seen.has(size)) context.report({ node: program, messageId: "missing", data: { size } })
-        for (const [size, node] of seen) if (!VIEWPORTS.includes(size)) context.report({ node, messageId: "extra", data: { size } })
-      },
-    }
-  },
-}
-
-/** The rules this law contributes to the plugin. */
-export const rules = {
-  "e2e-spec-location": e2eSpecLocation,
-  "e2e-no-absolute-path": e2eNoAbsolutePath,
-  "e2e-no-docker": e2eNoDocker,
-  "e2e-no-cross-repo-write": e2eNoCrossRepoWrite,
-  "e2e-no-skip": e2eNoSkip,
-  "e2e-typed-helpers": e2eTypedHelpers,
-  "playwright-viewports": playwrightViewports,
-}
-
-/** Which tree these rules govern: the factory attaches them to `e2e/**`, not to `src/**`. */
-export const scope = "e2e"
-
-/** Every rule is an error. */
-export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/spec-quality.mjs

@@ -1,318 +0,0 @@
-/**
- * The rules that hold `spec-quality.md` (HFS R67 `FE_SPEC_QUALITY`, and the "specs use the real
- * catalogue" half of R60).
- *
- * A SPEC IS A CLAIM ABOUT ONE UNIT'S BEHAVIOUR. The defects these rules refuse are the ones that made
- * specs pass while the product was wrong, or fail while it was right:
- *
- *   - pinning a class string: the spec fails when a designer changes a token, and passes when the
- *     element that carries it is gone;
- *   - testing something other than the neighbour: a spec that imports a different unit is that
- *     unit's spec in the wrong folder, and its owner will not find it;
- *   - a spec for a barrel: there is no behaviour in `export * from`, so the spec asserts that the
- *     language works;
- *   - a double cast (`as unknown as T`) to build a value the types forbid: the spec then proves the
- *     unit against a shape it can never receive;
- *   - a connected screen with no accessibility assertion: the state a reader with a screen reader
- *     meets is the one nobody looked at;
- *   - a mocked `next-intl`: the spec then passes on the KEY, so a missing or misspelled catalogue
- *     entry is invisible until a reader sees `course.titel`.
- */
-
-import { existsSync, readFileSync } from "node:fs"
-import { dirname, join } from "node:path"
-import ts from "typescript"
-import { hfsOf } from "./lib/hfs.mjs"
-import { baseName, isSpecFile, resolveImport } from "./lib/scope.mjs"
-import { normalizePath } from "./lib/path.mjs"
-
-/** The subject a spec sits beside: `Feed.test.tsx` -> `Feed`. */
-const subjectOf = (file) => baseName(file).replace(/\.(?:test|spec)\.[cm]?tsx?$/, "")
-
-/** The name a call is made through: `toHaveClass` in `expect(x).toHaveClass(...)`, or `axe` in `axe(x)`. */
-const calleeName = (callee) => {
-  if (callee.type === "Identifier") return callee.name
-  if (callee.type === "MemberExpression" && !callee.computed) return callee.property.name
-  return null
-}
-
-/** Static string of a literal or an expression-free template, else null. */
-const staticString = (node) => {
-  if (!node) return null
-  if (node.type === "Literal" && typeof node.value === "string") return node.value
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? ""
-  return null
-}
-
-// -- SPEC-1 ----------------------------------------------------------------------------------------
-
-/** A spec does not pin class strings. */
-export const noClassStringInSpec = {
-  meta: {
-    type: "problem",
-    docs: { description: "A component spec asserts behaviour, never a class string." },
-    schema: [],
-    messages: {
-      pinned:
-        "This spec pins a class string. It fails when a designer changes a token and passes when the element that carried it is gone - it tests the stylesheet, not the unit. Assert what the reader gets: a role, a name, a state, or the text.",
-    },
-  },
-  create(context) {
-    if (!isSpecFile(context.filename || context.getFilename())) return {}
-    return {
-      CallExpression(node) {
-        const name = calleeName(node.callee)
-        if (name === "toHaveClass") return context.report({ node, messageId: "pinned" })
-        if ((name === "toHaveAttribute" || name === "getAttribute") && staticString(node.arguments[0]) === "class") {
-          return context.report({ node, messageId: "pinned" })
-        }
-        if (name === "querySelector" || name === "querySelectorAll") {
-          const selector = staticString(node.arguments[0])
-          if (selector !== null && /(?:^|[\s>+~,])\.[\w-]|\[class/.test(selector)) context.report({ node, messageId: "pinned" })
-        }
-      },
-      MemberExpression(node) {
-        if (node.computed || !["className", "classList"].includes(node.property.name)) return
-        context.report({ node, messageId: "pinned" })
-      },
-    }
-  },
-}
-
-// -- SPEC-2 ----------------------------------------------------------------------------------------
-
-/** A spec imports the unit beside it. */
-export const specTestsItsNeighbour = {
-  meta: {
-    type: "problem",
-    docs: { description: "A spec imports its sibling subject: `X.test.tsx` imports `./X`." },
-    schema: [],
-    messages: {
-      subject:
-        "This spec does not import its neighbour `./{{subject}}`. A spec exercises the unit beside it; one that imports something else is that unit's spec in the wrong folder, and its owner will not find it. Move it beside its subject, or test the neighbour.",
-    },
-  },
-  create(context) {
-    const file = normalizePath(context.filename || context.getFilename())
-    if (!isSpecFile(file)) return {}
-    const subject = subjectOf(file)
-    const accepted = new Set([`./${subject}`, `./${subject}.tsx`, `./${subject}.ts`, `./${subject}.js`, `./${subject}.jsx`])
-    if (subject === "index") ["./", ".", "./index"].forEach((entry) => accepted.add(entry))
-    let imported = false
-    return {
-      ImportDeclaration(node) {
-        if (accepted.has(String(node.source.value))) imported = true
-      },
-      CallExpression(node) {
-        // `await import("./X")` and `require("./X")` are also an import of the subject.
-        const isImport = node.callee.type === "Import" || (node.callee.type === "Identifier" && node.callee.name === "require")
-        if (isImport && accepted.has(staticString(node.arguments[0]))) imported = true
-      },
-      ImportExpression(node) {
-        if (accepted.has(staticString(node.source))) imported = true
-      },
-      "Program:exit"(program) {
-        if (!imported) context.report({ node: program, messageId: "subject", data: { subject } })
-      },
-    }
-  },
-}
-
-// -- SPEC-3 ----------------------------------------------------------------------------------------
-
-/** The siblings `index.spec.ts(x)` can be the spec of. */
-const INDEX_SIBLINGS = ["index.ts", "index.tsx"]
-
-/** A statement that holds no behaviour: an import or an export declaration (a re-export, `export {}`, `export type {}`). */
-const isBarrelStatement = (statement) => ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)
-
-/** True when the file holds nothing but import and export declarations. */
-const isBarrelSource = (text) => {
-  const source = ts.createSourceFile("index.tsx", text, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX)
-  return source.statements.every(isBarrelStatement)
-}
-
-/** No spec for a barrel: the spec's `index.ts(x)` sibling holds only imports and re-exports. */
-export const noBarrelSpec = {
-  meta: {
-    type: "problem",
-    docs: { description: "No `index.spec.ts` beside an `index.ts` that is only a barrel." },
-    schema: [],
-    messages: {
-      barrel:
-        "A spec for a barrel. The sibling `index.ts` holds only imports and re-exports, which have no behaviour; a spec beside one asserts that the language works. Test the units the barrel re-exports, beside each of them. (An `index.ts` that holds implementation - a function, a class or a value - may have this spec.)",
-    },
-  },
-  create(context) {
-    const file = normalizePath(context.filename || context.getFilename())
-    if (!isSpecFile(file) || subjectOf(file) !== "index") return {}
-    const sibling = INDEX_SIBLINGS.map((name) => join(dirname(file), name)).find((candidate) => existsSync(candidate))
-    if (!sibling || !isBarrelSource(readFileSync(sibling, "utf8"))) return {}
-    return { Program: (node) => context.report({ node, messageId: "barrel" }) }
-  },
-}
-
-// -- SPEC-4 ----------------------------------------------------------------------------------------
-
-/** No `as unknown as T` in a spec. */
-export const noDoubleCastInSpec = {
-  meta: {
-    type: "problem",
-    docs: { description: "A spec builds its values with the type's own shape, not `as unknown as`." },
-    schema: [],
-    messages: {
-      double:
-        "A double cast in a spec. It builds a value the types forbid, so the spec proves the unit against a shape it can never receive. Build the value with a typed factory (`mock<T>()` or a fixture builder), or narrow from `unknown` with a check.",
-    },
-  },
-  create(context) {
-    if (!isSpecFile(context.filename || context.getFilename())) return {}
-    return {
-      TSAsExpression(node) {
-        const inner = node.expression
-        if (inner && inner.type === "TSAsExpression" && inner.typeAnnotation.type === "TSUnknownKeyword") {
-          context.report({ node, messageId: "double" })
-        }
-      },
-    }
-  },
-}
-
-// -- SPEC-5 ----------------------------------------------------------------------------------------
-
-/**
- * The spec of a connected screen: the spec of the entry (`index.tsx`, role `entry`) of a block or of a feature. The slot answers
- * both: the sibling the spec is named after is classified, and it must be a component-tier entry in the `blocks` layer or a
- * `fe.feature` entry.
- */
-const isConnectedSpec = (context, file) => {
-  const subject = subjectOf(file)
-  const hfs = hfsOf(context)
-  const entry = hfs.classify(join(dirname(file), `${subject}.tsx`))
-  if (entry.role !== "entry") return false
-  return (entry.slot === "fe.components" && entry.kind === "blocks") || entry.slot === "fe.feature"
-}
-
-/** Names that run an accessibility check. */
-const AXE_CALLS = new Set(["axe", "runAxe", "expectNoAxeViolations", "expectNoA11yViolations", "toHaveNoViolations"])
-
-/** A connected screen's spec asserts accessibility. */
-export const connectedSpecHasAxe = {
-  meta: {
-    type: "problem",
-    docs: { description: "The spec of a connected block or feature runs an axe assertion." },
-    schema: [],
-    messages: {
-      axe:
-        "This spec covers a connected screen but runs no accessibility assertion. The state a reader with a screen reader meets is the one nobody looked at; add `expect(await axe(container)).toHaveNoViolations()`.",
-    },
-  },
-  create(context) {
-    const file = normalizePath(context.filename || context.getFilename())
-    if (!isSpecFile(file) || !isConnectedSpec(context, file)) return {}
-    let ran = false
-    return {
-      CallExpression(node) {
-        const name = calleeName(node.callee)
-        if (name && AXE_CALLS.has(name)) ran = true
-      },
-      "Program:exit"(program) {
-        if (!ran) context.report({ node: program, messageId: "axe" })
-      },
-    }
-  },
-}
-
-// -- SPEC-6 ----------------------------------------------------------------------------------------
-
-/** The functions a spec mocks a module with. */
-const MOCK_CALLS = new Set(["mock", "doMock", "unstable_mockModule"])
-
-/** Every node under `root` (inclusive), through the parser's visitor keys. */
-const walk = (root, keys, visit) => {
-  if (!root || typeof root.type !== "string") return
-  visit(root)
-  for (const key of keys[root.type] ?? []) {
-    const child = root[key]
-    for (const item of Array.isArray(child) ? child : [child]) walk(item, keys, visit)
-  }
-}
-
-/** True when the specifier is the app's message catalogue: a file under `messages/` of the i18n module slot. */
-const isCatalogSpecifier = (context, specifier) => {
-  const target = resolveImport(context, specifier)
-  if (!target) return false
-  const hfs = hfsOf(context)
-  const { slot, root } = hfs.classify(target)
-  return slot === "fe.modules.i18n" && hfs.relative(target).startsWith(`${root}/messages/`)
-}
-
-/** A spec renders with the real catalogue; a server helper's mock serves it. */
-export const noMockedTranslations = {
-  meta: {
-    type: "problem",
-    docs: { description: "A spec renders with the real catalogue; it never mocks `next-intl` (a `next-intl/server` mock must serve the real catalogue)." },
-    schema: [],
-    messages: {
-      mocked:
-        "A mocked `next-intl`. The spec then passes on the KEY, so a missing or misspelled catalogue entry is invisible until a reader sees `course.titel`. Render inside `NextIntlClientProvider` with the real `messages/<locale>.json`.",
-      mockedServer:
-        "A `next-intl/server` mock that does not serve the real catalogue. A server helper has no provider to render inside, so the mock is allowed - but its factory must build the translator from the app's real messages (import `modules/i18n/messages/<locale>.json` and pass it to `createTranslator` from `next-intl`); a literal or key-echoing translator passes on the KEY and hides a missing or misspelled entry.",
-    },
-  },
-  create(context) {
-    const file = context.filename || context.getFilename()
-    if (!isSpecFile(file)) return {}
-    const source = context.sourceCode ?? context.getSourceCode()
-    const keys = source.visitorKeys
-    const catalogBindings = new Set()
-    const mocks = []
-    const hoisted = []
-    return {
-      ImportDeclaration(node) {
-        if (!isCatalogSpecifier(context, String(node.source.value))) return
-        for (const specifier of node.specifiers) catalogBindings.add(specifier.local.name)
-      },
-      CallExpression(node) {
-        const callee = node.callee
-        if (callee.type !== "MemberExpression" || callee.computed) return
-        if (["vi", "jest"].includes(callee.object.name) && callee.property.name === "hoisted") hoisted.push(node)
-        if (!MOCK_CALLS.has(callee.property.name) || !["vi", "jest"].includes(callee.object.name)) return
-        const target = staticString(node.arguments[0])
-        if (target !== null && /^next-intl(?:\/|$)/.test(target)) mocks.push({ node, target })
-      },
-      "Program:exit"() {
-        // The catalogue is served when a catalogue binding, or a dynamic import of the catalogue, is used by the factory or by a `vi.hoisted` block.
-        const serves = (root) => {
-          let found = false
-          walk(root, keys, (inner) => {
-            if (inner.type === "Identifier" && catalogBindings.has(inner.name)) found = true
-            const specifier = inner.type === "ImportExpression" ? staticString(inner.source) : null
-            if (specifier !== null && isCatalogSpecifier(context, specifier)) found = true
-          })
-          return found
-        }
-        for (const { node, target } of mocks) {
-          if (target === "next-intl/server") {
-            const factory = node.arguments[1]
-            if (factory && (serves(factory) || hoisted.some(serves))) continue
-            context.report({ node, messageId: "mockedServer" })
-          } else context.report({ node, messageId: "mocked" })
-        }
-      },
-    }
-  },
-}
-
-/** The rules this law contributes to the plugin. */
-export const rules = {
-  "no-class-string-in-spec": noClassStringInSpec,
-  "spec-tests-its-neighbour": specTestsItsNeighbour,
-  "no-barrel-spec": noBarrelSpec,
-  "no-double-cast-in-spec": noDoubleCastInSpec,
-  "connected-spec-has-axe": connectedSpecHasAxe,
-  "no-mocked-translations": noMockedTranslations,
-}
-
-/** Every rule is an error. */
-export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))