@starci/eslint-canon-be 1.2.2 → 1.7.1

package/size-budget.mjs

@@ -0,0 +1,106 @@
+/**
+ * The rules that hold the file size budget (catalog R20 `HFS_SIZE_GROWTH`, the file-level half).
+ *
+ * A source file has a hard-growth budget of `fileLines.hardGrowth` lines (`ruleParams.be.fileLines` of the
+ * slot manifest, read through `lib/slots.mjs`). `file-size-growth` is the ratchet and fails only on a file that must not
+ * be this long: a NEW file over the budget, or an existing file over the budget that is longer than its recorded size.
+ * The recorded size is the file's line count at the parent commit (`git show HEAD:<file>`), or an entry of the
+ * `recorded` option. A file may stay as large as it is; it may not grow, and it may not be born large.
+ *
+ * There is no soft-limit lint rule: a warning under a zero-warning gate is an exception in disguise. Listing the
+ * files over the soft budget (`fileLines.soft`) is a report item of the hfs check, never a block.
+ * There is no baseline file and no allowlist: the record is the repository's own history. A migration is exempt
+ * (it is append-only and generated), and so is every test-lane file.
+ */
+import { execFileSync } from "node:child_process"
+import { basename, dirname } from "node:path"
+import { isDeclarationFile, isMigrationFile, isTestLane, normalizePath } from "./lib/path.mjs"
+import { hfsParams } from "./lib/slots.mjs"
+
+const lineCount = (text) => {
+    const lines = text.split(/\r?\n/)
+    return lines.at(-1) === "" ? lines.length - 1 : lines.length
+}
+
+/** Whether a file is a source file this budget governs. */
+const governed = (filename) =>
+    /\.[cm]?tsx?$/.test(filename) &&
+    !isDeclarationFile(filename) &&
+    !isMigrationFile(filename) &&
+    !isTestLane(filename) &&
+    !filename.includes("/__generated__/")
+
+/**
+ * The line count of a file at a git revision, or null when the file did not exist there or git is absent.
+ *
+ * @param {string} filename - Absolute path of the file.
+ * @param {string} ref - The revision, `HEAD` by default (the parent of the commit being made).
+ * @returns {number | null} The recorded line count.
+ */
+export const recordedLines = (filename, ref = "HEAD") => {
+    try {
+        const text = execFileSync("git", ["-C", dirname(filename), "show", `${ref}:./${basename(filename)}`], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            maxBuffer: 64 * 1024 * 1024,
+        })
+        return lineCount(text)
+    } catch {
+        // no repository, no such revision, or a new file: all mean there is no recorded size to compare with
+        return null
+    }
+}
+
+const optionSchema = [
+    {
+        type: "object",
+        properties: {
+            max: { type: "integer", minimum: 1 },
+            ref: { type: "string" },
+            recorded: { type: "object", additionalProperties: { type: "integer", minimum: 0 } },
+        },
+        additionalProperties: false,
+    },
+]
+
+/** The ratchet: a file over the budget must not be new and must not grow. */
+export const fileSizeGrowth = {
+    meta: {
+        type: "problem",
+        docs: { description: "A source file over the budget is neither new nor longer than its recorded size." },
+        schema: optionSchema,
+        messages: {
+            born: "This new file has {{lines}} lines, over the budget of {{max}}. A new file starts within the budget: split it by responsibility.",
+            grew: "This file has {{lines}} lines, over the budget of {{max}}, and it was {{recorded}} at the parent commit. A file over the budget may not grow: move the new code into its own file.",
+        },
+    },
+    create(context) {
+        const filename = normalizePath(context.filename || context.getFilename())
+        if (!governed(filename)) return {}
+        const options = context.options[0] ?? {}
+        const max = options.max ?? hfsParams.fileLines.hardGrowth
+        return {
+            "Program:exit"(node) {
+                const lines = lineCount((context.sourceCode || context.getSourceCode()).text)
+                if (lines <= max) return
+                const listed = options.recorded
+                    ? Object.entries(options.recorded).find(([path]) => filename.endsWith(`/${path}`) || filename === path)
+                    : undefined
+                const recorded = listed ? listed[1] : recordedLines(context.filename || context.getFilename(), options.ref)
+                const loc = { line: 1, column: 0 }
+                if (recorded === null) context.report({ node, loc, messageId: "born", data: { lines, max } })
+                else if (lines > recorded) context.report({ node, loc, messageId: "grew", data: { lines, max, recorded } })
+            },
+        }
+    },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+    "file-size-growth": fileSizeGrowth,
+}
+
+/** The ratchet is an error. */
+export const recommended = {
+    "starci-be/file-size-growth": "error",
+}

package/spec-quality.mjs

@@ -0,0 +1,132 @@
+/**
+ * The rules that hold spec quality (catalog R48 `BE_SPEC_QUALITY`).
+ *
+ *   - `spec-no-source-read` refuses a spec that reads source files. An architecture rule is a lint rule or a
+ *     check, not a unit test that opens `src/` with `fs` and greps it; such a spec passes and fails on text, not on
+ *     behavior, and it goes stale the day a file moves.
+ *   - `spec-typed-doubles` refuses `as never` and `as unknown as X` in a spec. A double of a dependency is
+ *     `mock<T>()` (the typed helper from `@starci/jest-preset`), which fails to compile when the dependency's
+ *     shape changes; a cast keeps compiling and lies.
+ *
+ * The e2e canon rules apply to `src/tests/e2e/**` through the repository's `lint:e2e` script (run by hand, and
+ * green before an e2e conclusion is drawn); that is a matter of which globs the config names, not of a rule.
+ */
+import { walk } from "./lib/ast.mjs"
+import { isDeclarationFile, isSpecFile, normalizePath } from "./lib/path.mjs"
+
+const FS_MODULES = new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"])
+const FS_READERS = new Set(["readFile", "readFileSync", "readdir", "readdirSync", "glob", "globSync", "opendir", "opendirSync", "createReadStream"])
+
+/** A path argument that leads to the repository's own source: a location of this file, the working directory, or a source folder. */
+const SOURCE_TEXT = /(?:^|[\\/])(?:src|apps|libs)(?:[\\/]|$)|\.[cm]?tsx?$/
+const SOURCE_ANCHORS = new Set(["__dirname", "__filename"])
+
+/**
+ * Whether a path expression points at source: it names `__dirname`, `import.meta`, `process.cwd()`, or a
+ * `src`, `apps` or `libs` folder or a `.ts` file. An identifier is followed once to its `const` initializer, so
+ * `const dir = join(__dirname, "x"); readdirSync(dir)` is recognised. A spec that reads the files ITS SUBJECT
+ * wrote to a temporary directory is behavior, and stays outside this rule.
+ */
+const pointsAtSource = (expression, scope, depth = 0) => {
+    if (!expression) return false
+    let found = false
+    walk(expression, (node) => {
+        if (found) return
+        if (node.type === "Identifier" && SOURCE_ANCHORS.has(node.name)) found = true
+        else if (node.type === "MetaProperty") found = true
+        else if (node.type === "MemberExpression" && node.object.type === "MetaProperty") found = true
+        else if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "process" && node.callee.property.name === "cwd") found = true
+        else if (node.type === "Literal" && typeof node.value === "string" && SOURCE_TEXT.test(node.value)) found = true
+        else if (node.type === "TemplateElement" && SOURCE_TEXT.test(node.value.cooked ?? "")) found = true
+        else if (node.type === "Identifier" && depth < 2) {
+            let reference = scope
+            while (reference && !reference.set.has(node.name)) reference = reference.upper
+            const definition = reference?.set.get(node.name)?.defs[0]
+            if (definition?.node.type === "VariableDeclarator" && pointsAtSource(definition.node.init, scope, depth + 1)) found = true
+        }
+    })
+    return found
+}
+
+/** A spec never opens source files to assert on their text. */
+export const specNoSourceRead = {
+    meta: {
+        type: "problem",
+        docs: { description: "A spec does not read files with fs." },
+        schema: [],
+        messages: {
+            read: "This spec reads files with `fs`. A rule about how source is written belongs in the lint canon or an architecture check; a spec asserts behavior.",
+        },
+    },
+    create(context) {
+        const filename = normalizePath(context.filename || context.getFilename())
+        if (isDeclarationFile(filename) || !isSpecFile(filename)) return {}
+        const sourceCode = context.sourceCode || context.getSourceCode()
+        const namespaces = new Set()
+        const named = new Set()
+        return {
+            ImportDeclaration(node) {
+                if (typeof node.source.value !== "string" || !FS_MODULES.has(node.source.value)) return
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === "ImportSpecifier") {
+                        const imported = specifier.imported.name ?? specifier.imported.value
+                        if (FS_READERS.has(imported)) named.add(specifier.local.name)
+                        else if (imported === "promises") namespaces.add(specifier.local.name)
+                    } else {
+                        namespaces.add(specifier.local.name)
+                    }
+                }
+            },
+            CallExpression(node) {
+                const callee = node.callee
+                let reads = false
+                if (callee.type === "Identifier" && named.has(callee.name)) {
+                    reads = true
+                } else if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && FS_READERS.has(callee.property.name)) {
+                    const object = callee.object
+                    const base = object.type === "MemberExpression" ? object.object : object
+                    reads = base.type === "Identifier" && namespaces.has(base.name)
+                }
+                if (reads && pointsAtSource(node.arguments[0], sourceCode.getScope(node))) context.report({ node, messageId: "read" })
+            },
+        }
+    },
+}
+
+/** A double is a typed `mock<T>()`, never a cast. */
+export const specTypedDoubles = {
+    meta: {
+        type: "problem",
+        docs: { description: "A spec uses `mock<T>()` for a double, not `as never` or `as unknown as X`." },
+        schema: [],
+        messages: {
+            never: "`as never` forces a value through the type system. Build the double with `mock<T>()` so it stays checked against the real dependency.",
+            doubleCast: "`as unknown as X` forces a value through the type system. Build the double with `mock<T>()` so it stays checked against the real dependency.",
+        },
+    },
+    create(context) {
+        const filename = normalizePath(context.filename || context.getFilename())
+        if (isDeclarationFile(filename) || !(isSpecFile(filename) || filename.includes("/src/tests/"))) return {}
+        return {
+            TSAsExpression(node) {
+                if (node.typeAnnotation.type === "TSNeverKeyword") {
+                    context.report({ node, messageId: "never" })
+                } else if (node.expression.type === "TSAsExpression" && node.expression.typeAnnotation.type === "TSUnknownKeyword") {
+                    context.report({ node, messageId: "doubleCast" })
+                }
+            },
+        }
+    },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+    "spec-no-source-read": specNoSourceRead,
+    "spec-typed-doubles": specTypedDoubles,
+}
+
+/** Both start at error: the migration lanes replace the casts and the source-reading specs before adoption. */
+export const recommended = {
+    "starci-be/spec-no-source-read": "error",
+    "starci-be/spec-typed-doubles": "error",
+}

package/suppression.mjs

@@ -0,0 +1,60 @@
+/**
+ * The rule that holds "no suppression anywhere" (catalog R18 `HFS_INLINE_SUPPRESSION`).
+ *
+ * `no-inline-suppression` reports every comment that switches a check off at the place it is written:
+ * `eslint-disable` in all its forms (block, line, next-line, and the matching `eslint-enable`), an
+ * `eslint <rule>: off` configuration comment, `@ts-ignore`, `@ts-expect-error`, `@ts-nocheck`, and the
+ * `vn-ok` language marker. The factory also sets `noInlineConfig: true`, so ESLint itself ignores such a
+ * comment; this rule is what turns the ignored comment into a failure a person reads, instead of a silent
+ * no-op that looks like an exemption.
+ *
+ * It replaces `no-line-suppression`, which named only the type-safety rules and so let every other rule be
+ * silenced. There is no exit here: fix the code, or propose a change to the canon.
+ */
+
+const DISABLE = /^\s*eslint-(?:disable|enable)(?:-next-line|-line)?(?:\s|$)/
+const CONFIG = /^\s*eslint\s+[@\w/-]+\s*:\s*(?:0|1|2|off|warn|error|\[)/
+const TS_DIRECTIVE = /^\s*(?:\/\s*)?@ts-(?:ignore|expect-error|nocheck)\b/
+const LANGUAGE_MARKER = /\bvn-ok\b/
+
+const kindOf = (text) => {
+    if (DISABLE.test(text) || CONFIG.test(text)) return "eslint"
+    if (TS_DIRECTIVE.test(text)) return "typescript"
+    if (LANGUAGE_MARKER.test(text)) return "vn-ok"
+    return null
+}
+
+/** No comment switches a check off at the place it is written. */
+export const noInlineSuppression = {
+    meta: {
+        type: "problem",
+        docs: { description: "No eslint-disable, ts-ignore, ts-expect-error, ts-nocheck or vn-ok comment." },
+        schema: [],
+        messages: {
+            eslint: "An `eslint-disable`/`eslint-enable` or rule-configuration comment. HFS does not switch a rule off in place: fix the code, or propose a change to the rule in the canon.",
+            typescript: "A `@ts-` directive silences the compiler at one place. Fix the type, or narrow it with a guard.",
+            "vn-ok": "A `vn-ok` marker exempts a line from the language rule. HFS keeps no exemption marker: write the text in English, or move the data to a locale or data file.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode()
+        return {
+            "Program:exit"() {
+                for (const comment of sourceCode.getAllComments()) {
+                    const kind = kindOf(comment.value)
+                    if (kind) context.report({ loc: comment.loc, messageId: kind })
+                }
+            },
+        }
+    },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+    "no-inline-suppression": noInlineSuppression,
+}
+
+/** Error from the start: there is no baseline and no allowlist for a suppression. */
+export const recommended = {
+    "starci-be/no-inline-suppression": "error",
+}

package/temporal.mjs

@@ -0,0 +1,71 @@
+/**
+ * The rule that holds `platform/clock` (catalog R79 `BE_AMBIENT_CLOCK`).
+ *
+ *   - `no-ambient-clock` refuses `Date.now()`, a bare `new Date()` and `performance.now()` outside
+ *     `platform/clock`. Business code asks the injected `Clock` port for the time (`clock.now()`),
+ *     because a call to the ambient clock cannot be replaced in a spec - a test then either sleeps
+ *     for real or races the wall clock, and a scheduled job cannot be driven to a chosen instant.
+ *
+ * `new Date(value)` - built from a value the caller already holds (a stored timestamp, a parsed
+ * header) - is not an ambient read and is left alone; only the zero-argument form reads "now".
+ */
+import { isDeclarationFile, isTestLane, normalizePath } from "./lib/path.mjs"
+
+const PLATFORM_CLOCK = /\/src\/modules\/platform\/clock\//
+
+/** Whether a callee is `Date.now`. */
+const isDateNow = (node) =>
+    node.type === "MemberExpression" &&
+    !node.computed &&
+    node.object.type === "Identifier" &&
+    node.object.name === "Date" &&
+    node.property.type === "Identifier" &&
+    node.property.name === "now"
+
+/** Whether a callee is `performance.now`. */
+const isPerformanceNow = (node) =>
+    node.type === "MemberExpression" &&
+    !node.computed &&
+    node.object.type === "Identifier" &&
+    node.object.name === "performance" &&
+    node.property.type === "Identifier" &&
+    node.property.name === "now"
+
+/** Only `platform/clock` reads the ambient clock. */
+export const noAmbientClock = {
+    meta: {
+        type: "problem",
+        docs: { description: "`Date.now()`, a bare `new Date()` and `performance.now()` are read only inside `platform/clock`." },
+        schema: [],
+        messages: {
+            now: "`{{call}}` reads the ambient clock directly. Inject the `Clock` port (`clock.now()`) instead: a spec then drives time with a `FakeClock` and a scheduled job can be tested at a chosen instant, neither of which a direct read allows.",
+            date: "`new Date()` with no argument reads the ambient clock. Inject the `Clock` port and build the date from `clock.now()`, or - if this really is parsing a value the caller already holds - pass that value to `new Date(value)`.",
+        },
+    },
+    create(context) {
+        const filename = normalizePath(context.filename || context.getFilename())
+        if (isDeclarationFile(filename) || isTestLane(filename) || PLATFORM_CLOCK.test(filename)) return {}
+        return {
+            CallExpression(node) {
+                const { callee } = node
+                if (isDateNow(callee)) context.report({ node, messageId: "now", data: { call: "Date.now()" } })
+                else if (isPerformanceNow(callee)) context.report({ node, messageId: "now", data: { call: "performance.now()" } })
+            },
+            NewExpression(node) {
+                if (node.callee.type === "Identifier" && node.callee.name === "Date" && node.arguments.length === 0) {
+                    context.report({ node, messageId: "date" })
+                }
+            },
+        }
+    },
+}
+
+/** The rule this law contributes to the plugin. */
+export const rules = {
+    "no-ambient-clock": noAmbientClock,
+}
+
+/** Starts at error: no baseline exists, and the repositories' fix lanes clear the debt with a Clock codemod. */
+export const recommended = {
+    "starci-be/no-ambient-clock": "error",
+}

package/testing.mjs

@@ -43,21 +43,17 @@
 import { statSync } from "node:fs"
 import { normalizePath } from "./lib/path.mjs"
 
-/** The fast lane: a plain unit spec, excluding every other suffix that also ends in `spec.ts`. */
-const isUnitSpec = (filename) => {
-  const file = normalizePath(filename)
-  if (!/\.spec\.ts$/.test(file)) return false
-  return !/\.(?:e2e|int|harness)-spec\.ts$/.test(file)
-}
+/** Test kind 1 of exactly two: a unit spec, `<name>.spec.ts` beside its subject. */
+const isUnitSpec = (filename) => /\.spec\.ts$/.test(normalizePath(filename))
 
-/** The flow lane. */
+/** Test kind 2 of exactly two: `*.e2e-spec.ts`. */
 const isE2eSpec = (filename) => /\.e2e-spec\.ts$/.test(normalizePath(filename))
 
-/** The paid model-quality lane. */
-const isHarnessSpec = (filename) => /\.harness-spec\.ts$/.test(normalizePath(filename))
+/** The opt-in live e2e filter (`test:e2e:live`): e2e specs under `src/tests/e2e/live/` that need live third-party accounts. */
+const isLiveE2eSpec = (filename) => isE2eSpec(filename) && /\/src\/tests\/e2e\/live\//.test(normalizePath(filename))
 
-/** Test-only helpers whose only authority is the harness lane. */
-const isHarnessHelper = (filename) => /\/src\/tests\/helpers\//.test(normalizePath(filename))
+/** Test-only environment helpers whose only authority is the live e2e filter. */
+const isLiveE2eHelper = (filename) => /\/src\/tests\/e2e\/live\//.test(normalizePath(filename)) && !isE2eSpec(filename)
 
 /**
  * Matchers that assert a CALL happened rather than what came out of it.
@@ -136,7 +132,7 @@ export const noCallOnlySpec = {
 // -- TESTING-7 -------------------------------------------------------------------------------------
 
 const UNIT_TEST_BUCKET = /\/(?:src\/tests|tests?\/unit)(?:\/|$)/
-const HFS_TEST_CATEGORY = /\/src\/tests\/(?:integration|fixtures|harness|e2e)\//
+const HFS_TEST_CATEGORY = /\/src\/tests\/(?:fixtures|e2e)\//
 const SUBJECT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs"]
 
 /** A structural test in an HFS test category may test a source file beside it. */
@@ -219,7 +215,7 @@ const PROVIDER_PACKAGES = /^(?:@anthropic-ai\/|openai$|openai\/|ollama$|@google\
  */
 const HARNESS_MODEL_HELPERS = /helpers\/models(?:\.service)?$/
 
-/** An e2e never calls a model; the harness is the only lane that does. */
+/** An e2e never calls a model; only a live e2e (src/tests/e2e/live/) may reach a provider. */
 export const noModelCallInE2e = {
   meta: {
     type: "problem",
@@ -227,11 +223,12 @@ export const noModelCallInE2e = {
     schema: [],
     messages: {
       provider:
-        "`{{source}}` reaches a model provider from an e2e. A model call costs money, takes seconds and answers differently every time - so this makes the flow suite expensive, slow and flaky at once, and the assertion has to be loosened until it stops catching anything. Stub the model and assert what can actually break: the entitlement, the quota, the persisted answer. Judging the answer itself belongs in the harness.",
+        "`{{source}}` reaches a model provider from an e2e. A model call costs money, takes seconds and answers differently every time - so this makes the flow suite expensive, slow and flaky at once, and the assertion has to be loosened until it stops catching anything. Stub the model and assert what can actually break: the entitlement, the quota, the persisted answer. Judging the answer itself belongs in a live e2e under src/tests/e2e/live/.",
     },
   },
   create(context) {
-    if (!isE2eSpec(context.filename || context.getFilename())) return {}
+    const filename = context.filename || context.getFilename()
+    if (!isE2eSpec(filename) || isLiveE2eSpec(filename)) return {}
     return {
       ImportDeclaration(node) {
         const source = node.source && node.source.value
@@ -279,6 +276,16 @@ const aiInvokePickToken = (sourceCode) => {
   return null
 }
 
+/** A file declares itself a model harness with the comment `@harness-kind model`; any other kind is not one. */
+const DECLARED_MODEL_HARNESS = /@harness-kind\s+model\b/
+
+/**
+ * A model harness is identified by what it does, never by where it lives: it imports an LLM provider
+ * SDK, reaches for a house model helper or gateway symbol, or declares `@harness-kind model`. A live
+ * e2e for an identity provider (Keycloak), a payment gateway or any other third party sits in the same
+ * `src/tests/e2e/live/` folder and is not a model harness, so this rule leaves it alone.
+ */
+
 /** A harness calls one explicit provider SDK and never disguises it as `AiInvokeService`. */
 export const harnessCallsProviderDirectly = {
   meta: {
@@ -287,7 +294,7 @@ export const harnessCallsProviderDirectly = {
     schema: [],
     messages: {
       missingProvider:
-        "This harness imports no approved provider SDK. A model-quality harness calls the declared provider client directly; a house helper, tier or gateway override can make it green about a model production does not use.",
+        "This model harness (it reaches for a house model helper or gateway, or declares `@harness-kind model`) imports no approved provider SDK. A model-quality harness calls the declared provider client directly; a house helper, tier or gateway override can make it green about a model production does not use.",
       gateway:
         "`{{name}}` impersonates or replaces the production AI gateway from a harness. Reuse the production prompt builder and parser around a direct provider SDK call instead.",
       helper:
@@ -298,17 +305,19 @@ export const harnessCallsProviderDirectly = {
   },
   create(context) {
     const filename = context.filename || context.getFilename()
-    const harness = isHarnessSpec(filename)
-    const authScope = harness || isHarnessHelper(filename)
+    const harness = isLiveE2eSpec(filename)
+    const authScope = harness || isLiveE2eHelper(filename)
     if (!authScope) return {}
 
     let hasProviderImport = false
+    let modelSignal = false
     return {
       ImportDeclaration(node) {
         const source = node.source && node.source.value
         if (typeof source !== "string") return
         if (harness && DIRECT_PROVIDER_PACKAGES.test(source)) hasProviderImport = true
         if (harness && FORBIDDEN_HARNESS_HELPERS.test(source.replace(/\.(?:ts|js)$/, ""))) {
+          modelSignal = true
           context.report({ node, messageId: "helper", data: { source } })
         }
         if (!harness) return
@@ -317,6 +326,7 @@ export const harnessCallsProviderDirectly = {
           const local = specifier.local && specifier.local.name
           const name = imported || local
           if (!FORBIDDEN_HARNESS_SYMBOLS.has(name)) continue
+          modelSignal = true
           context.report({ node: specifier, messageId: "gateway", data: { name } })
         }
       },
@@ -341,9 +351,11 @@ export const harnessCallsProviderDirectly = {
         const sourceCode = context.sourceCode || context.getSourceCode()
         const pickToken = aiInvokePickToken(sourceCode)
         if (pickToken) {
+          modelSignal = true
           context.report({ node: pickToken, messageId: "gateway", data: { name: 'Pick<AiInvokeService, "run">' } })
         }
-        if (!hasProviderImport) context.report({ node, messageId: "missingProvider" })
+        const declared = sourceCode.getAllComments().some((comment) => DECLARED_MODEL_HARNESS.test(comment.value))
+        if ((modelSignal || declared) && !hasProviderImport) context.report({ node, messageId: "missingProvider" })
       },
     }
   },