@starci/eslint-canon-be 1.0.0

package/authorization.mjs

@@ -0,0 +1,106 @@
+/**
+ * The rule that holds `authorization.md`.
+ *
+ * ONE rule, and the honest reason is worth stating: authorization is decided against a row, and a
+ * parser does not know which row a handler is reaching for or what owning it means. AUTHZ-3, -4 and
+ * -5 all turn on that, so a rule aimed at them would fire on shape rather than on meaning - and a
+ * rule that fires on shape is one authors learn to disable, which leaves the law worse off than when
+ * nothing enforced it.
+ *
+ * AUTHZ-1 was measured and deliberately left alone. A handler checking `if (!user)` reads like
+ * duplication of the door's guard and is not: the guard belongs to one door and the handler belongs
+ * to every caller of the bus. A rule refusing it would fire on the majority of correct handlers in
+ * this tree, which is a gate contradicting canon rather than holding it.
+ *
+ * What IS checkable in one file is the door: a resolver method that READS the authenticated user
+ * while nothing on that method or its class establishes the identity. That failure looks like
+ * nothing at all - the parameter still says `user`, the handler still receives one - and the only
+ * missing piece is the line that proved it belonged to the caller.
+ */
+
+/** Parameter decorators that read an already-authenticated identity off the request. */
+const IDENTITY_PARAM_DECORATORS = new Set([
+  "KeycloakGraphQLUser",
+  "KeycloakUser",
+  "CurrentUser",
+])
+
+/** The decorator that establishes the identity a door then reads. */
+const GUARD_DECORATOR = "UseGuards"
+
+/** Reads the callee name off a decorator expression, whether or not it is called. */
+const decoratorName = (decorator) => {
+  const expression = decorator.expression
+  if (!expression) return undefined
+  if (expression.type === "CallExpression") {
+    return expression.callee && expression.callee.type === "Identifier"
+      ? expression.callee.name
+      : undefined
+  }
+  return expression.type === "Identifier" ? expression.name : undefined
+}
+
+/** Whether any decorator in the list is the guard. */
+const hasGuard = (decorators) =>
+  (decorators || []).some((decorator) => decoratorName(decorator) === GUARD_DECORATOR)
+
+/** The identity parameter on a method, when it has one. */
+const identityParameter = (node) => {
+  for (const parameter of node.value && node.value.params ? node.value.params : []) {
+    // a decorated parameter carries its decorators on the parameter node itself, and TS-ESTree
+    // wraps a typed+decorated parameter in TSParameterProperty for constructor promotion
+    const carrier = parameter.type === "TSParameterProperty" ? parameter.parameter : parameter
+    const decorators = parameter.decorators || (carrier && carrier.decorators) || []
+    for (const decorator of decorators) {
+      if (IDENTITY_PARAM_DECORATORS.has(decoratorName(decorator))) return parameter
+    }
+  }
+  return undefined
+}
+
+// -- AUTHZ-2 ---------------------------------------------------------------------------------------
+
+/** A door that reads an identity carries the guard that establishes it. */
+export const identityNeedsGuard = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "A resolver or controller method reading the authenticated user must carry a guard on that method or its class.",
+    },
+    schema: [],
+    messages: {
+      unguarded:
+        "This door reads the authenticated user through `@{{decorator}}()` while neither the method nor its class carries `@UseGuards(...)`. Nothing established the identity, so what reaches the handler is whatever the pipeline left there - and the failure is silent, because the parameter still says `user` and the handler still receives one. Put the guard on the door that reads the identity.",
+    },
+  },
+  create(context) {
+    return {
+      MethodDefinition(node) {
+        const parameter = identityParameter(node)
+        if (!parameter) return
+        if (hasGuard(node.decorators)) return
+
+        // the guard may sit on the class instead, covering every method on it
+        const classBody = node.parent
+        const classNode = classBody && classBody.parent
+        if (classNode && hasGuard(classNode.decorators)) return
+
+        const carrier = parameter.type === "TSParameterProperty" ? parameter.parameter : parameter
+        const decorators = parameter.decorators || (carrier && carrier.decorators) || []
+        const named = decorators.map(decoratorName).find((name) => IDENTITY_PARAM_DECORATORS.has(name))
+        context.report({ node: parameter, messageId: "unguarded", data: { decorator: named } })
+      },
+    }
+  },
+}
+
+/** Every rule this module ships, by the name a config switches it on under. */
+export const rules = {
+  "identity-needs-guard": identityNeedsGuard,
+}
+
+/** The level a consuming repository switches this on at. */
+export const recommended = {
+  "starci-be/identity-needs-guard": "error",
+}

package/cdc.mjs

@@ -0,0 +1,44 @@
+const isProjectionListener = (filename) => /projection\.listener\.ts$/.test(
+  String(filename || "").replace(/\\/g, "/"),
+) && !String(filename || "").replace(/\\/g, "/").endsWith("/abstract-projection.listener.ts")
+
+const memberName = (member) => member.key && (member.key.name || member.key.value)
+
+/** A projection listener declares mapping while AbstractProjectionListener owns Kafka lifecycle. */
+export const projectionListenerContract = {
+  meta: {
+    type: "problem",
+    docs: { description: "Projection CDC listeners share one Kafka lifecycle contract." },
+    schema: [],
+    messages: {
+      base: "A projection CDC listener extends AbstractProjectionListener; the shared base owns subscription, envelope parsing and failure isolation.",
+      member: "A projection CDC listener must declare `{{name}}`.",
+      lifecycle: "A concrete projection listener must not override `onModuleInit`; Kafka lifecycle belongs to AbstractProjectionListener.",
+    },
+  },
+  create(context) {
+    if (!isProjectionListener(context.filename || context.getFilename())) return {}
+    return {
+      ClassDeclaration(node) {
+        if (!node.superClass || node.superClass.name !== "AbstractProjectionListener") {
+          context.report({ node: node.id || node, messageId: "base" })
+        }
+        const members = node.body.body || []
+        const names = new Set(members.map(memberName))
+        for (const name of ["groupId", "topics", "deriveTargets", "recomputeTarget"]) {
+          if (!names.has(name)) {
+            context.report({ node: node.id || node, messageId: "member", data: { name } })
+          }
+        }
+        const lifecycle = members.find((member) => memberName(member) === "onModuleInit")
+        if (lifecycle) context.report({ node: lifecycle.key, messageId: "lifecycle" })
+      },
+    }
+  },
+}
+
+export const rules = { "projection-listener-contract": projectionListenerContract }
+
+export const recommended = {
+  "starci-be/projection-listener-contract": "error",
+}

package/comments.mjs

@@ -0,0 +1,243 @@
+/**
+ * The rules that hold `comments.md`.
+ *
+ * Three rules, and each is careful about a different false positive:
+ *
+ *   - `require-export-jsdoc` skips plain data constants. `export const MAX_ATTEMPTS = 3` is already
+ *     fully described by its own name, and demanding a sentence there produces sentences that
+ *     restate the name - which COMMENT-3 forbids. Only declarations with a surface get the check.
+ *   - `require-enum-member-jsdoc` can check that a doc EXISTS and never that it states a
+ *     consequence. That half is read by a person, and the rule says so rather than pretending.
+ *   - `no-non-ascii-source` exempts a marked line, because text a program matches on or emits is
+ *     data wearing prose, and translating it breaks the program.
+ */
+
+/** Forward-slash form of a filename, so Windows paths compare like every other path. */
+const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** The marker that keeps a non-ASCII literal the program depends on. */
+const KEEP_MARKER = /\bvn-ok\b/
+
+/**
+ * The character classes this refuses, and why it is NOT simply "ASCII only".
+ *
+ * A first cut of this rule banned every non-ASCII codepoint. Measured against the reference
+ * repository it reported 857 offenders -- and every one was an em dash, a box-drawing run in a
+ * comment banner, or a middle dot. The code has used those freely and deliberately for its whole
+ * life, so "ASCII only" was not the law being recorded; it was a stricter law being invented, which
+ * is the one thing canon must not do.
+ *
+ * What the law actually refuses is three things, for three different reasons:
+ *
+ *   - VIETNAMESE letters, because a reader who does not share the author's first language loses
+ *     exactly the half of the reasoning that explains the surprising parts. Matched precisely, so a
+ *     European loanword (`naive`, `facade`, `Muller`) is never a false positive.
+ *   - EMOJI, because they carry tone rather than information, and tone reads differently to
+ *     everybody.
+ *   - DECORATIVE symbols -- check marks, crosses, arrows used as ornament -- for the same reason.
+ *
+ * Typographic punctuation is none of those and stays.
+ */
+const VIETNAMESE_LETTER = /[À-ÃÈ-ÊÌÍÒ-ÕÙÚÝà-ãè-êìíò-õùúýĂăĐđĨĩŨũƠơƯưẠ-ỿ]/
+
+/** Emoji and pictographs. */
+const EMOJI = /[\u{1F300}-\u{1FAFF}\u{1F000}-\u{1F0FF}\u{2600}-\u{27BF}\u{FE0F}\u{1F1E6}-\u{1F1FF}]/u
+
+/** Ornamental marks that stand in for a word. */
+const ORNAMENT = /[✅❌✔✖✗✘⭐⬆⬇➡⬅]/
+
+/** The Vietnamese language's own name, which is a label rather than prose. */
+const ENDONYM = /Tiếng Việt/
+
+/** Declarations whose surface other files depend on. */
+const DOCUMENTED_KINDS = new Set([
+  "TSInterfaceDeclaration",
+  "TSTypeAliasDeclaration",
+  "TSEnumDeclaration",
+  "ClassDeclaration",
+  "FunctionDeclaration",
+])
+
+/** What a line offends with, or null. */
+const offenceIn = (line) => {
+  const withoutEndonym = line.replace(ENDONYM, "")
+  if (VIETNAMESE_LETTER.test(withoutEndonym)) return "a Vietnamese letter"
+  if (EMOJI.test(withoutEndonym)) return "an emoji"
+  if (ORNAMENT.test(withoutEndonym)) return "an ornamental symbol"
+  return null
+}
+
+/** Whether a JSDoc block sits immediately before a node. */
+const hasJsdocBefore = (sourceCode, node) =>
+  sourceCode
+    .getCommentsBefore(node)
+    .some((comment) => comment.type === "Block" && comment.value.startsWith("*"))
+
+/** The declared name, for the message. */
+const nameOf = (declaration) => {
+  if (declaration.id) return declaration.id.name
+  const first = declaration.declarations && declaration.declarations[0]
+  return (first && first.id && first.id.name) || "this export"
+}
+
+// -- COMMENT-1 -------------------------------------------------------------------------------------
+
+/** Every export with a surface opens with a doc block. */
+export const requireExportJsdoc = {
+  meta: {
+    type: "suggestion",
+    docs: { description: "An exported class/interface/type/enum/function opens with JSDoc." },
+    schema: [],
+    messages: {
+      jsdoc:
+        "`{{name}}` is exported with no doc block. This is surface other files depend on, and a name plus a signature says what it TAKES - never what it is for, or when to reach for it rather than the thing beside it.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode()
+    const check = (node) => {
+      const declaration = node.declaration
+      // a re-export has nothing here to attach a doc to
+      if (!declaration) return
+      if (declaration.type === "VariableDeclaration") {
+        // only a const bound to a function has a surface; a data constant is already described
+        const first = declaration.declarations[0]
+        const init = first && first.init
+        const isFunction = init
+          && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")
+        if (!isFunction) return
+      } else if (!DOCUMENTED_KINDS.has(declaration.type)) {
+        return
+      }
+      if (hasJsdocBefore(sourceCode, node)) return
+      context.report({
+        node: declaration.id || declaration,
+        messageId: "jsdoc",
+        data: { name: nameOf(declaration) },
+      })
+    }
+    return {
+      ExportNamedDeclaration: check,
+      ExportDefaultDeclaration: check,
+    }
+  },
+}
+
+// -- COMMENT-2 -------------------------------------------------------------------------------------
+
+/** Every member of an exported enum carries its own doc. */
+export const requireEnumMemberJsdoc = {
+  meta: {
+    type: "suggestion",
+    docs: { description: "Every member of an exported enum carries its own JSDoc." },
+    schema: [],
+    messages: {
+      jsdoc:
+        "Enum member `{{name}}` has no doc. State what CHOOSING it causes, not what it is called - a member is picked at a call site far from the switch that gives it meaning. (A rule can only see that a doc exists; whether it states a consequence is read by a person.)",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode()
+    return {
+      TSEnumDeclaration(node) {
+        if (!node.parent || node.parent.type !== "ExportNamedDeclaration") return
+        for (const member of node.members || []) {
+          if (hasJsdocBefore(sourceCode, member)) continue
+          const name = member.id && (member.id.name || member.id.value)
+          context.report({ node: member, messageId: "jsdoc", data: { name: name || "?" } })
+        }
+      },
+    }
+  },
+}
+
+// -- COMMENT-4 -------------------------------------------------------------------------------------
+
+/** Source is English ASCII, except where a literal is data the program depends on. */
+export const noNonAsciiSource = {
+  meta: {
+    type: "problem",
+    docs: { description: "Source stays English ASCII; a depended-upon literal is marked instead." },
+    schema: [],
+    messages: {
+      nonAscii:
+        "This line carries {{offence}}. The bar is a reader who does not share the author's first language: a codebase with two languages in it has somebody for whom half the reasoning is unavailable, and it is the half explaining the surprising parts - and an emoji or an ornament carries tone rather than information, which reads differently to everybody. If this is text the program MATCHES on or EMITS, it is data rather than prose: keep it and mark the line `vn-ok: <reason>` so the next sweep does not turn it into a bug.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode()
+    const file = normalizePath(context.filename || context.getFilename())
+    // locale files are wholly product copy; policing them would be policing the product
+    if (/\/(?:messages|locales|i18n)\//.test(file)) return {}
+
+    /*
+     * IN A TEST LANE, A STRING IS A FIXTURE AND A COMMENT IS STILL PROSE.
+     *
+     * The rule's own reason draws this line already: prose in a second language leaves half the
+     * reasoning unavailable to a reader, while "text the program MATCHES on or EMITS is data rather
+     * than prose". A spec that feeds an agent the sentence a real customer would type - "khach vua
+     * chuyen khoan" - is feeding it data, and translating it would test a system nobody uses.
+     *
+     * Measured before it was written: of 92 findings in one back end, 89 were fixture strings and 3
+     * were comments. Demanding `vn-ok` on all 92 would have put a marker on every line of every
+     * conversation fixture, which is noise that teaches a reader to stop seeing the marker.
+     *
+     * The exemption is for STRINGS ONLY. A Vietnamese comment in a spec is the same problem it is
+     * anywhere else - the next reader still cannot follow the reasoning - so it is still refused.
+     */
+    const fixtureLane = /\.spec\.ts$|-spec\.ts$|\/src\/tests\//.test(file)
+    const commentLines = fixtureLane
+      ? new Set(sourceCode.getAllComments().flatMap((comment) => {
+        const span = []
+        for (let line = comment.loc.start.line; line <= comment.loc.end.line; line += 1) span.push(line)
+        return span
+      }))
+      : null
+
+    return {
+      "Program:exit"(node) {
+        const lines = sourceCode.getLines()
+        for (let index = 0; index < lines.length; index += 1) {
+          const line = lines[index]
+          if (KEEP_MARKER.test(line)) continue
+          // in a fixture lane only prose is policed; the data the fixture feeds is the point of it
+          if (commentLines && !commentLines.has(index + 1)) continue
+          const offence = offenceIn(line)
+          if (offence === null) continue
+          context.report({
+            node,
+            loc: {
+              line: index + 1,
+              column: 0,
+            },
+            messageId: "nonAscii",
+            data: {
+              offence,
+            },
+          })
+        }
+      },
+    }
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "require-export-jsdoc": requireExportJsdoc,
+  "require-enum-member-jsdoc": requireEnumMemberJsdoc,
+  "no-non-ascii-source": noNonAsciiSource,
+}
+
+/**
+ * The level this law asks for, as the plugin's own opinion.
+ *
+ * `no-non-ascii-source` replaces three separate rules in the reference plugin - one for Vietnamese,
+ * one for emoji, one for decorative symbols. They were three character classes answering one
+ * question, and a reader who hit the emoji rule learned nothing about the other two. One rule with
+ * one reason is easier to obey, and impossible to satisfy by switching alphabets.
+ */
+export const recommended = {
+  "starci-be/require-export-jsdoc": "error",
+  "starci-be/require-enum-member-jsdoc": "error",
+  "starci-be/no-non-ascii-source": "error",
+}

package/cqrs.mjs

@@ -0,0 +1,207 @@
+/**
+ * The rules that hold `cqrs.md`.
+ *
+ * Three of the seven rules are shapes a parser can see. The other four - where the work lives, how
+ * thin the service is, whether an event is one the caller waits on - are judgements, and a rule
+ * that guessed at them would fire on correct code often enough that everybody would learn to
+ * disable it.
+ *
+ * The one worth explaining is CQRS-3. A handler that overrides `execute` still compiles and still
+ * runs; the template method in the base is simply skipped. Nothing goes red, and the file stays
+ * wrong until the day a cross-cutting concern is added to the base and silently misses it. That is
+ * exactly the class of mistake a rule is for: invisible at the call site, expensive later.
+ */
+
+/** Forward-slash form of a filename, so Windows paths compare like every other path. */
+const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** Decorators that mark a class as a CQRS handler. */
+const HANDLER_DECORATORS = /^(?:Command|Query|Events)Handler$/
+
+/** A `<operation>.handler.ts`, and the operation it is named for. */
+const handlerFile = (filename) => {
+  const hit = normalizePath(filename).match(/\/([a-z0-9-]+)\.handler\.ts$/)
+  return hit ? hit[1] : null
+}
+
+/** A `<operation>.command.ts` or `<operation>.query.ts`, and the operation it is named for. */
+const messageFile = (filename) => {
+  const hit = normalizePath(filename).match(/\/([a-z0-9-]+)\.(command|query)\.ts$/)
+  return hit ? { operation: hit[1], kind: hit[2] } : null
+}
+
+/** Decorator names carried by a class declaration. */
+const decoratorNames = (node) =>
+  (node.decorators || []).map((decorator) => {
+    const expression = decorator.expression
+    if (expression.type === "CallExpression" && expression.callee.type === "Identifier") return expression.callee.name
+    if (expression.type === "Identifier") return expression.name
+    return null
+  }).filter(Boolean)
+
+/** Whether a class body declares a method of the given name. */
+const declaredMethod = (node, name) =>
+  (node.body.body || []).find(
+    (member) => member.type === "MethodDefinition" && member.key && member.key.name === name,
+  )
+
+// -- CQRS-3 ----------------------------------------------------------------------------------------
+
+/** A handler implements the template's `process`, never its public `execute`. */
+export const handlerOverridesProcess = {
+  meta: {
+    type: "problem",
+    docs: { description: "A CQRS handler overrides `process`, not `execute`." },
+    schema: [],
+    messages: {
+      overridesExecute:
+        "`{{name}}` overrides `execute`, which takes it OUT of the template method in the base handler. It compiles and it runs, so nothing goes red - and it is the one handler the next cross-cutting change (a timing, a transaction, a retry added to the base) will silently miss. Rename this to `protected override async process(...)`.",
+      noProcess:
+        "`{{name}}` is a CQRS handler with no `process` method. The base declares `process` abstract and calls it from `execute`; a handler that implements neither has no work to dispatch to.",
+    },
+  },
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        if (!decoratorNames(node).some((name) => HANDLER_DECORATORS.test(name))) return
+        const name = (node.id && node.id.name) || "this handler"
+        const execute = declaredMethod(node, "execute")
+        if (execute) {
+          context.report({ node: execute.key, messageId: "overridesExecute", data: { name } })
+          return
+        }
+        // A handler that extends anything may inherit `process` from that base, and an
+        // intermediate abstract handler is a legitimate shape - a family of suggestion queries
+        // that all search the same way implements `process` once and is subclassed. Measured
+        // against real source, reporting here regardless of the superclass produced ten false
+        // positives and three true ones, so the check applies only to a standalone class.
+        if (node.superClass) return
+        if (!declaredMethod(node, "process")) {
+          context.report({ node: node.id || node, messageId: "noProcess", data: { name } })
+        }
+      },
+    }
+  },
+}
+
+// -- CQRS-2 ----------------------------------------------------------------------------------------
+
+/** A message carries request context and nothing else. */
+export const messageCarriesParamsOnly = {
+  meta: {
+    type: "problem",
+    docs: { description: "A command or query holds `params` and declares no logic." },
+    schema: [],
+    messages: {
+      method:
+        "`{{name}}` declares `{{member}}`. A message that computes has moved a decision into a file nobody reads for decisions, and two dispatchers of this message would then disagree about what it means. Keep the message to its `params`; compute in the handler.",
+      shape:
+        "`{{name}}` does not carry a single `params` field. A message is request context - the request, the user, the locale - handed to the handler whole; a message with several fields makes every dispatcher assemble it differently.",
+    },
+  },
+  create(context) {
+    const message = messageFile(context.filename || context.getFilename())
+    if (!message) return {}
+    return {
+      ClassDeclaration(node) {
+        // `.command.ts` is not one thing. A CLI framework uses the same suffix for a decorated
+        // class with a `run` method, which is a DOOR rather than a message - measured against
+        // real source, that family produced nineteen of this rule's twenty-one reports. A CQRS
+        // message is a plain class; anything decorated here belongs to some other framework.
+        if ((node.decorators || []).length > 0) return
+        const members = node.body.body || []
+        for (const member of members) {
+          if (member.type !== "MethodDefinition" || member.kind === "constructor") continue
+          context.report({
+            node: member.key,
+            messageId: "method",
+            data: { name: (node.id && node.id.name) || "this message", member: member.key.name || "a method" },
+          })
+        }
+        const constructor = members.find((member) => member.type === "MethodDefinition" && member.kind === "constructor")
+        if (!constructor || !constructor.value) return
+        const params = constructor.value.params || []
+        const carriesParams = params.length === 1
+          && (params[0].type === "TSParameterProperty" ? params[0].parameter : params[0]).name === "params"
+        if (!carriesParams) {
+          context.report({
+            node: node.id || node,
+            messageId: "shape",
+            data: { name: (node.id && node.id.name) || "this message" },
+          })
+        }
+      },
+    }
+  },
+}
+
+// -- CQRS-7 ----------------------------------------------------------------------------------------
+
+/**
+ * A handler has its twin spec beside it.
+ *
+ * The check is the FILENAME, not the disk: a rule that stats the filesystem reports differently
+ * depending on what else is checked out, and a rule whose answer depends on the working tree is one
+ * nobody can reproduce. This rule fires on the handler and names the file that should exist; a gate
+ * that walks the tree is what counts them.
+ */
+export const handlerHasTwinSpec = {
+  meta: {
+    type: "problem",
+    docs: { description: "A CQRS handler declares its twin spec filename in the same folder." },
+    schema: [
+      {
+        type: "object",
+        properties: { specs: { type: "array", items: { type: "string" } } },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      missing:
+        "`{{operation}}.handler.ts` has no `{{operation}}.handler.spec.ts` beside it. The decisions live in the handler, so an untested handler is an untested decision - and a spec in the same folder is found by whoever edits the handler rather than by whoever goes looking in a test tree.",
+    },
+  },
+  create(context) {
+    const filename = context.filename || context.getFilename()
+    const operation = handlerFile(filename)
+    if (!operation) return {}
+    const options = context.options && context.options[0]
+    const known = options && Array.isArray(options.specs) ? options.specs : null
+    if (!known) return {}
+    if (known.includes(`${operation}.handler.spec.ts`)) return {}
+    return {
+      "Program:exit"(node) {
+        context.report({ node, messageId: "missing", data: { operation } })
+      },
+    }
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "handler-overrides-process": handlerOverridesProcess,
+  "message-carries-params-only": messageCarriesParamsOnly,
+  "handler-has-twin-spec": handlerHasTwinSpec,
+}
+
+/**
+ * The level this law asks for, as the plugin's own opinion.
+ *
+ * MEASURED AGAINST THE REFERENCE REPOSITORY, not estimated: 3 of 141 handlers override `execute`,
+ * and 2 of 138 messages carry something other than a single `params`. Debt above zero means the
+ * rule lands at `warn` with the count beside it, gets burned down, and flips to `error` at zero -
+ * shipping at `error` with debt outstanding blocks every commit that touches an offender.
+ *
+ * COUNT ONLY THIS RULE'S REPORTS when measuring. Inline `eslint-disable` comments in the source
+ * refer to rules a minimal measuring config never loads, and eslint reports each of those as a
+ * problem of its own - which inflated the first measurement of every rule here by the same seven
+ * files, and this rule's by two.
+ *
+ * `handler-has-twin-spec` is off by default because it needs the folder listing passed as an
+ * option; a repository that wires it supplies the listing from its own gate.
+ */
+export const recommended = {
+  "starci-be/handler-overrides-process": "error", // no=0 of 141 - burned down from 3
+  "starci-be/message-carries-params-only": "error", // no=0 of 138 - burned down from 2
+  "starci-be/handler-has-twin-spec": "off", // needs the folder listing as an option; a repo that wires it turns this on
+}