@sarj/eslint-plugin 16.19.0 → 16.19.2

package/dist/index.cjs

@@ -52,7 +52,7 @@ module.exports = __toCommonJS(src_exports);
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.19.0",
+  version: "16.19.2",
   packageManager: "npm@12.2.0",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -14349,14 +14349,16 @@ var no_duplicate_test_case_default = createRule({
 // src/rules/no-tautological-expect.ts
 var import_utils80 = require("@typescript-eslint/utils");
 var NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION = {
-  summary: "Disallow supported assertions known to pass from literals or immutable scalar setup.",
-  rationale: "An assertion determined entirely by literals does not observe the code under test and can keep passing after that code is removed.",
+  summary: "Disallow supported assertions fixed by literal setup or immutable self identity.",
+  rationale: "An assertion fixed by literal setup or one immutable binding's identity cannot distinguish a wrong result from the intended behavior.",
   remediation: "Assert on a value produced by the behavior under test against an independently specified expectation, or remove only the redundant assertion while preserving coverage.",
   category: "testing",
   limitations: [
-    "Only supported `expect` matcher calls in recognized test files are inspected, including imported aliases and a single `.not` on zero-argument matchers. Local or type-only bindings, regular expressions, async modifiers and unsupported coercions are excluded; failing constant assertions are not tautologies.",
-    "Scalar const bindings and aliases resolve through lexical scope; mutable bindings, objects, arrays, destructuring, runtime initializers and forward references are excluded.",
-    "Expected-side runtime dependence, including a complete inline snapshot computed from its actual value, remains manual review; independent static interpolation and intentional partial masking are valid."
+    "Only supported `expect` matcher calls in recognized test files are inspected, including imported aliases, static string messages on imported Vitest/Playwright expect calls, and a single `.not` on zero-argument matchers. Local or type-only bindings, regular expressions, async modifiers and unsupported coercions are excluded; failing constant assertions are not tautologies.",
+    "The literal proof resolves scalar const bindings and aliases through lexical scope; mutable bindings, objects, arrays, destructuring, runtime initializers and forward references are excluded from that proof.",
+    "Positive toBe assertions on the same initialized, unreassigned local identifier const binding also have fixed identity, including runtime results. Different bindings, imported live values, property/getter accesses and deep-equality reflexivity remain excluded from this identity proof.",
+    "Expected-side runtime dependence, including a complete inline snapshot computed from its actual value, remains manual review; independent static interpolation and intentional partial masking are valid.",
+    "Direct framework expect.extend registrations exclude replaced built-in matchers; opaque registrations exclude all supported matchers, and nonempty custom equality testers exclude deep equality. Direct synchronous expect callbacks observed by a throwing matcher retain their assertion contracts. Cross-file or indirect matcher customization is not inferred."
   ],
   examples: [
     {
@@ -14416,6 +14418,86 @@ var NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION = {
       focusPath: "src/service.test.ts",
       expectedCount: 0,
       public: true
+    },
+    {
+      id: "message-only-oracle",
+      scenarioId: "static-message",
+      title: "A diagnostic string does not make a literal comparison observe behavior",
+      outcome: "match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; expect(true, 'service ready').toBe(true);" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "message-produced-oracle",
+      scenarioId: "static-message",
+      title: "A diagnostic message can describe an observed result",
+      outcome: "no-match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; expect(serviceReady(), 'service ready').toBe(true);" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "uncaptured-matcher",
+      scenarioId: "matcher-contract",
+      title: "An uncaptured literal assertion remains redundant",
+      outcome: "match",
+      files: [{ path: "src/assertion.test.ts", source: "import {expect} from 'vitest'; expect(true).toBeTruthy();" }],
+      focusPath: "src/assertion.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "captured-matcher",
+      scenarioId: "matcher-contract",
+      title: "A throwing matcher observes the inner assertion contract",
+      outcome: "no-match",
+      files: [{ path: "src/assertion.test.ts", source: "import {expect} from 'vitest'; expect(() => expect(true).toBeTruthy()).not.toThrow();" }],
+      focusPath: "src/assertion.test.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "unrelated-custom-matcher",
+      scenarioId: "custom-matcher",
+      title: "Adding a different matcher preserves the built-in proof",
+      outcome: "match",
+      files: [{ path: "src/assertion.test.ts", source: "import {expect} from 'vitest'; expect.extend({toBeReady: custom}); expect(true).toBe(true);" }],
+      focusPath: "src/assertion.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "replaced-custom-matcher",
+      scenarioId: "custom-matcher",
+      title: "A replaced matcher can reject a literal comparison",
+      outcome: "no-match",
+      files: [{ path: "src/assertion.test.ts", source: "import {expect} from 'vitest'; expect.extend({toBe: () => ({pass: false, message: () => 'custom contract'})}); expect(true).toBe(true);" }],
+      focusPath: "src/assertion.test.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "self-identity-oracle",
+      scenarioId: "immutable-identity",
+      title: "A returned value's identity with itself cannot reject a wrong result",
+      outcome: "match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; const result = serviceStatus(); expect(result).toBe(result);" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "independent-result-oracle",
+      scenarioId: "immutable-identity",
+      title: "An independent expected state can reject a wrong result",
+      outcome: "no-match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; const result = serviceStatus(); expect(result.status).toBe('ready');" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 0,
+      public: true
     }
   ]
 };
@@ -14430,6 +14512,7 @@ var ZERO_ARG_MATCHERS = /* @__PURE__ */ new Set([
 ]);
 var OPERAND_PREVIEW_CHARS = 40;
 var NUMERIC_SIGNS = /* @__PURE__ */ new Set(["-", "+"]);
+var THROW_MATCHERS = /* @__PURE__ */ new Set(["toThrow", "toThrowError", "toThrowErrorMatchingSnapshot", "toThrowErrorMatchingInlineSnapshot"]);
 function resolveLiteral(node, sourceCode, seen = /* @__PURE__ */ new Set()) {
   node = unwrapExpression(node);
   if (isLiteral(node)) return node;
@@ -14505,12 +14588,76 @@ function expectOperand(callee, sourceCode) {
   const negated = receiver.type === import_utils80.AST_NODE_TYPES.MemberExpression && import_utils80.ASTUtils.getPropertyName(receiver) === "not";
   if (negated && receiver.type === import_utils80.AST_NODE_TYPES.MemberExpression) receiver = unwrapExpression(receiver.object);
   const expectCallee = receiver.type === import_utils80.AST_NODE_TYPES.CallExpression ? unwrapExpression(receiver.callee) : null;
-  if (receiver.type !== import_utils80.AST_NODE_TYPES.CallExpression || expectCallee?.type !== import_utils80.AST_NODE_TYPES.Identifier || runtimeTestFrameworkName(sourceCode, expectCallee, "assertion") !== "expect" || receiver.arguments.length !== 1) {
+  if (receiver.type !== import_utils80.AST_NODE_TYPES.CallExpression || expectCallee?.type !== import_utils80.AST_NODE_TYPES.Identifier || runtimeTestFrameworkName(sourceCode, expectCallee, "assertion") !== "expect" || receiver.arguments.length !== 1 && !hasStaticMessage(receiver, expectCallee, sourceCode)) {
     return null;
   }
   const operand = receiver.arguments[0];
   return operand === void 0 ? null : { operand, negated };
 }
+function hasStaticMessage(call, callee, source) {
+  if (call.arguments.length !== 2) return false;
+  const definition = import_utils80.ASTUtils.findVariable(source.getScope(callee), callee.name)?.defs[0];
+  if (definition?.type !== "ImportBinding" || definition.parent.type !== import_utils80.AST_NODE_TYPES.ImportDeclaration || !["vitest", "@playwright/test"].includes(definition.parent.source.value)) return false;
+  const message = call.arguments[1];
+  const literal2 = message === void 0 ? null : resolveLiteral(message, source);
+  return literal2?.type === import_utils80.AST_NODE_TYPES.Literal && typeof literal2.value === "string" || literal2?.type === import_utils80.AST_NODE_TYPES.TemplateLiteral;
+}
+function isExceptionContract(node, source) {
+  let callback = node.parent;
+  while (callback !== void 0 && callback.type !== import_utils80.AST_NODE_TYPES.Program && callback.type !== import_utils80.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils80.AST_NODE_TYPES.FunctionExpression && callback.type !== import_utils80.AST_NODE_TYPES.FunctionDeclaration) callback = callback.parent;
+  if (callback === void 0 || callback.type === import_utils80.AST_NODE_TYPES.Program || callback.type === import_utils80.AST_NODE_TYPES.FunctionDeclaration || callback.async || callback.generator) return false;
+  const call = directArgumentCall(callback);
+  if (call === null || call.optional) return false;
+  let member = outerExpression(call).parent;
+  if (member?.type === import_utils80.AST_NODE_TYPES.MemberExpression && import_utils80.ASTUtils.getPropertyName(member) === "not") member = outerExpression(member).parent;
+  if (member?.type !== import_utils80.AST_NODE_TYPES.MemberExpression || member.optional || !THROW_MATCHERS.has(import_utils80.ASTUtils.getPropertyName(member) ?? "")) return false;
+  const invocation = outerExpression(member).parent;
+  return invocation?.type === import_utils80.AST_NODE_TYPES.CallExpression && !invocation.optional && unwrapExpression(expectOperand(member, source)?.operand ?? member) === callback;
+}
+function customizedMatchers(source) {
+  const customized = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node.type === import_utils80.AST_NODE_TYPES.CallExpression) collectCustomization(node, source, customized);
+    for (const key of source.visitorKeys[node.type] ?? []) {
+      const child = node[key];
+      for (const value of Array.isArray(child) ? child : [child]) {
+        if (typeof value === "object" && value !== null && "type" in value) visit(value);
+      }
+    }
+  };
+  visit(source.ast);
+  return customized;
+}
+function collectCustomization(node, source, customized) {
+  const member = unwrapExpression(node.callee);
+  if (member.type !== import_utils80.AST_NODE_TYPES.MemberExpression) return;
+  const receiver = unwrapExpression(member.object);
+  if (receiver.type !== import_utils80.AST_NODE_TYPES.Identifier || runtimeTestFrameworkName(source, receiver, "assertion") !== "expect") return;
+  const method = import_utils80.ASTUtils.getPropertyName(member);
+  const argument = node.arguments[0] === void 0 ? null : unwrapExpression(node.arguments[0]);
+  if (method === "addEqualityTesters" && !(argument?.type === import_utils80.AST_NODE_TYPES.ArrayExpression && argument.elements.length === 0)) {
+    customized.add("toEqual");
+    customized.add("toStrictEqual");
+  }
+  if (method !== "extend") return;
+  if (argument?.type !== import_utils80.AST_NODE_TYPES.ObjectExpression) {
+    customized.add("*");
+    return;
+  }
+  for (const property of argument.properties) {
+    const name = property.type === import_utils80.AST_NODE_TYPES.Property ? import_utils80.ASTUtils.getPropertyName(property) : null;
+    customized.add(name ?? "*");
+  }
+}
+function hasConstSelfIdentity(actual, expected, source) {
+  actual = unwrapExpression(actual);
+  expected = unwrapExpression(expected);
+  if (actual.type !== import_utils80.AST_NODE_TYPES.Identifier || expected.type !== import_utils80.AST_NODE_TYPES.Identifier) return false;
+  const variable = import_utils80.ASTUtils.findVariable(source.getScope(actual), actual.name);
+  if (variable?.defs.length !== 1 || import_utils80.ASTUtils.findVariable(source.getScope(expected), expected.name) !== variable) return false;
+  const definition = variable.defs[0];
+  return definition?.node.type === import_utils80.AST_NODE_TYPES.VariableDeclarator && definition.node.id.type === import_utils80.AST_NODE_TYPES.Identifier && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.init.range[1] <= Math.min(actual.range[0], expected.range[0]) && !variable.references.some((reference) => reference.isWrite() && !reference.init);
+}
 var no_tautological_expect_default = createRule({
   name: "no-tautological-expect",
   documentation: NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION,
@@ -14521,7 +14668,7 @@ var no_tautological_expect_default = createRule({
     },
     schema: [],
     messages: {
-      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` is fixed by literal setup and does not observe behavior. Assert on a produced value or remove only the redundant assertion, preserving other coverage.",
+      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` is fixed by {{reason}} and does not observe behavior. Assert against an independent expectation or remove only the redundant assertion, preserving the action and other coverage.",
       tautologicalMatcher: "`expect({{operand}}).{{matcher}}()` is statically known to pass. Assert on a produced value or remove only the redundant assertion, preserving other coverage."
     }
   },
@@ -14530,6 +14677,7 @@ var no_tautological_expect_default = createRule({
     if (!isTestFile(context.filename)) {
       return {};
     }
+    const customized = customizedMatchers(context.sourceCode);
     const preview2 = (node) => {
       const text = context.sourceCode.getText(node).replaceAll(/\s+/gu, " ");
       return text.length > OPERAND_PREVIEW_CHARS ? `${text.slice(0, OPERAND_PREVIEW_CHARS)}\u2026` : text;
@@ -14539,10 +14687,19 @@ var no_tautological_expect_default = createRule({
         const callee = unwrapExpression(node.callee);
         if (callee.type !== import_utils80.AST_NODE_TYPES.MemberExpression) return;
         const matcher = import_utils80.ASTUtils.getPropertyName(callee);
-        if (matcher === null) return;
+        if (matcher === null || !ZERO_ARG_MATCHERS.has(matcher) && !EQUALITY_MATCHERS.has(matcher) || customized.has("*") || customized.has(matcher)) return;
         const assertion = expectOperand(callee, context.sourceCode);
-        if (assertion === null) return;
+        if (assertion === null || isExceptionContract(node, context.sourceCode)) return;
         const writtenOperand = assertion.operand;
+        const writtenExpected = node.arguments[0];
+        if (!assertion.negated && matcher === "toBe" && node.arguments.length === 1 && writtenExpected !== void 0 && hasConstSelfIdentity(writtenOperand, writtenExpected, context.sourceCode)) {
+          context.report({
+            node,
+            messageId: "tautologicalComparison",
+            data: { operand: preview2(writtenOperand), matcher, reason: "the same immutable binding" }
+          });
+          return;
+        }
         const operand = resolveLiteral(writtenOperand, context.sourceCode);
         if (operand === null) {
           return;
@@ -14556,7 +14713,6 @@ var no_tautological_expect_default = createRule({
           });
           return;
         }
-        const writtenExpected = node.arguments[0];
         const expected = writtenExpected === void 0 ? null : resolveLiteral(writtenExpected, context.sourceCode);
         if (assertion.negated || !EQUALITY_MATCHERS.has(matcher) || node.arguments.length !== 1 || expected === null) {
           return;
@@ -14570,7 +14726,7 @@ var no_tautological_expect_default = createRule({
         context.report({
           node,
           messageId: "tautologicalComparison",
-          data: { operand: preview2(writtenOperand), matcher }
+          data: { operand: preview2(writtenOperand), matcher, reason: "literal setup" }
         });
       }
     };
@@ -26014,7 +26170,7 @@ function classMethodCounts(body2, methods) {
 
 // src/rules/source-coupled-test.ts
 var import_utils136 = require("@typescript-eslint/utils");
-var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc?|toml|py|[cm]?[jt]s)$/iu;
+var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc|toml|py|[cm]?[jt]s)$|(?<!\.(?:tf|tftest))\.json$/iu;
 var FS_MODULES = /* @__PURE__ */ new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"]);
 var FS_READERS = /* @__PURE__ */ new Set(["readFile", "readFileSync"]);
 var TEXT_TRANSFORMS = /* @__PURE__ */ new Set([

package/dist/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.19.0",
+  version: "16.19.2",
   packageManager: "npm@12.2.0",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -14330,14 +14330,16 @@ var no_duplicate_test_case_default = createRule({
 // src/rules/no-tautological-expect.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES65, ASTUtils as ASTUtils40 } from "@typescript-eslint/utils";
 var NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION = {
-  summary: "Disallow supported assertions known to pass from literals or immutable scalar setup.",
-  rationale: "An assertion determined entirely by literals does not observe the code under test and can keep passing after that code is removed.",
+  summary: "Disallow supported assertions fixed by literal setup or immutable self identity.",
+  rationale: "An assertion fixed by literal setup or one immutable binding's identity cannot distinguish a wrong result from the intended behavior.",
   remediation: "Assert on a value produced by the behavior under test against an independently specified expectation, or remove only the redundant assertion while preserving coverage.",
   category: "testing",
   limitations: [
-    "Only supported `expect` matcher calls in recognized test files are inspected, including imported aliases and a single `.not` on zero-argument matchers. Local or type-only bindings, regular expressions, async modifiers and unsupported coercions are excluded; failing constant assertions are not tautologies.",
-    "Scalar const bindings and aliases resolve through lexical scope; mutable bindings, objects, arrays, destructuring, runtime initializers and forward references are excluded.",
-    "Expected-side runtime dependence, including a complete inline snapshot computed from its actual value, remains manual review; independent static interpolation and intentional partial masking are valid."
+    "Only supported `expect` matcher calls in recognized test files are inspected, including imported aliases, static string messages on imported Vitest/Playwright expect calls, and a single `.not` on zero-argument matchers. Local or type-only bindings, regular expressions, async modifiers and unsupported coercions are excluded; failing constant assertions are not tautologies.",
+    "The literal proof resolves scalar const bindings and aliases through lexical scope; mutable bindings, objects, arrays, destructuring, runtime initializers and forward references are excluded from that proof.",
+    "Positive toBe assertions on the same initialized, unreassigned local identifier const binding also have fixed identity, including runtime results. Different bindings, imported live values, property/getter accesses and deep-equality reflexivity remain excluded from this identity proof.",
+    "Expected-side runtime dependence, including a complete inline snapshot computed from its actual value, remains manual review; independent static interpolation and intentional partial masking are valid.",
+    "Direct framework expect.extend registrations exclude replaced built-in matchers; opaque registrations exclude all supported matchers, and nonempty custom equality testers exclude deep equality. Direct synchronous expect callbacks observed by a throwing matcher retain their assertion contracts. Cross-file or indirect matcher customization is not inferred."
   ],
   examples: [
     {
@@ -14397,6 +14399,86 @@ var NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION = {
       focusPath: "src/service.test.ts",
       expectedCount: 0,
       public: true
+    },
+    {
+      id: "message-only-oracle",
+      scenarioId: "static-message",
+      title: "A diagnostic string does not make a literal comparison observe behavior",
+      outcome: "match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; expect(true, 'service ready').toBe(true);" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "message-produced-oracle",
+      scenarioId: "static-message",
+      title: "A diagnostic message can describe an observed result",
+      outcome: "no-match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; expect(serviceReady(), 'service ready').toBe(true);" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "uncaptured-matcher",
+      scenarioId: "matcher-contract",
+      title: "An uncaptured literal assertion remains redundant",
+      outcome: "match",
+      files: [{ path: "src/assertion.test.ts", source: "import {expect} from 'vitest'; expect(true).toBeTruthy();" }],
+      focusPath: "src/assertion.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "captured-matcher",
+      scenarioId: "matcher-contract",
+      title: "A throwing matcher observes the inner assertion contract",
+      outcome: "no-match",
+      files: [{ path: "src/assertion.test.ts", source: "import {expect} from 'vitest'; expect(() => expect(true).toBeTruthy()).not.toThrow();" }],
+      focusPath: "src/assertion.test.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "unrelated-custom-matcher",
+      scenarioId: "custom-matcher",
+      title: "Adding a different matcher preserves the built-in proof",
+      outcome: "match",
+      files: [{ path: "src/assertion.test.ts", source: "import {expect} from 'vitest'; expect.extend({toBeReady: custom}); expect(true).toBe(true);" }],
+      focusPath: "src/assertion.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "replaced-custom-matcher",
+      scenarioId: "custom-matcher",
+      title: "A replaced matcher can reject a literal comparison",
+      outcome: "no-match",
+      files: [{ path: "src/assertion.test.ts", source: "import {expect} from 'vitest'; expect.extend({toBe: () => ({pass: false, message: () => 'custom contract'})}); expect(true).toBe(true);" }],
+      focusPath: "src/assertion.test.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "self-identity-oracle",
+      scenarioId: "immutable-identity",
+      title: "A returned value's identity with itself cannot reject a wrong result",
+      outcome: "match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; const result = serviceStatus(); expect(result).toBe(result);" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "independent-result-oracle",
+      scenarioId: "immutable-identity",
+      title: "An independent expected state can reject a wrong result",
+      outcome: "no-match",
+      files: [{ path: "src/service.test.ts", source: "import {expect} from 'vitest'; const result = serviceStatus(); expect(result.status).toBe('ready');" }],
+      focusPath: "src/service.test.ts",
+      expectedCount: 0,
+      public: true
     }
   ]
 };
@@ -14411,6 +14493,7 @@ var ZERO_ARG_MATCHERS = /* @__PURE__ */ new Set([
 ]);
 var OPERAND_PREVIEW_CHARS = 40;
 var NUMERIC_SIGNS = /* @__PURE__ */ new Set(["-", "+"]);
+var THROW_MATCHERS = /* @__PURE__ */ new Set(["toThrow", "toThrowError", "toThrowErrorMatchingSnapshot", "toThrowErrorMatchingInlineSnapshot"]);
 function resolveLiteral(node, sourceCode, seen = /* @__PURE__ */ new Set()) {
   node = unwrapExpression(node);
   if (isLiteral(node)) return node;
@@ -14486,12 +14569,76 @@ function expectOperand(callee, sourceCode) {
   const negated = receiver.type === AST_NODE_TYPES65.MemberExpression && ASTUtils40.getPropertyName(receiver) === "not";
   if (negated && receiver.type === AST_NODE_TYPES65.MemberExpression) receiver = unwrapExpression(receiver.object);
   const expectCallee = receiver.type === AST_NODE_TYPES65.CallExpression ? unwrapExpression(receiver.callee) : null;
-  if (receiver.type !== AST_NODE_TYPES65.CallExpression || expectCallee?.type !== AST_NODE_TYPES65.Identifier || runtimeTestFrameworkName(sourceCode, expectCallee, "assertion") !== "expect" || receiver.arguments.length !== 1) {
+  if (receiver.type !== AST_NODE_TYPES65.CallExpression || expectCallee?.type !== AST_NODE_TYPES65.Identifier || runtimeTestFrameworkName(sourceCode, expectCallee, "assertion") !== "expect" || receiver.arguments.length !== 1 && !hasStaticMessage(receiver, expectCallee, sourceCode)) {
     return null;
   }
   const operand = receiver.arguments[0];
   return operand === void 0 ? null : { operand, negated };
 }
+function hasStaticMessage(call, callee, source) {
+  if (call.arguments.length !== 2) return false;
+  const definition = ASTUtils40.findVariable(source.getScope(callee), callee.name)?.defs[0];
+  if (definition?.type !== "ImportBinding" || definition.parent.type !== AST_NODE_TYPES65.ImportDeclaration || !["vitest", "@playwright/test"].includes(definition.parent.source.value)) return false;
+  const message = call.arguments[1];
+  const literal2 = message === void 0 ? null : resolveLiteral(message, source);
+  return literal2?.type === AST_NODE_TYPES65.Literal && typeof literal2.value === "string" || literal2?.type === AST_NODE_TYPES65.TemplateLiteral;
+}
+function isExceptionContract(node, source) {
+  let callback = node.parent;
+  while (callback !== void 0 && callback.type !== AST_NODE_TYPES65.Program && callback.type !== AST_NODE_TYPES65.ArrowFunctionExpression && callback.type !== AST_NODE_TYPES65.FunctionExpression && callback.type !== AST_NODE_TYPES65.FunctionDeclaration) callback = callback.parent;
+  if (callback === void 0 || callback.type === AST_NODE_TYPES65.Program || callback.type === AST_NODE_TYPES65.FunctionDeclaration || callback.async || callback.generator) return false;
+  const call = directArgumentCall(callback);
+  if (call === null || call.optional) return false;
+  let member = outerExpression(call).parent;
+  if (member?.type === AST_NODE_TYPES65.MemberExpression && ASTUtils40.getPropertyName(member) === "not") member = outerExpression(member).parent;
+  if (member?.type !== AST_NODE_TYPES65.MemberExpression || member.optional || !THROW_MATCHERS.has(ASTUtils40.getPropertyName(member) ?? "")) return false;
+  const invocation = outerExpression(member).parent;
+  return invocation?.type === AST_NODE_TYPES65.CallExpression && !invocation.optional && unwrapExpression(expectOperand(member, source)?.operand ?? member) === callback;
+}
+function customizedMatchers(source) {
+  const customized = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node.type === AST_NODE_TYPES65.CallExpression) collectCustomization(node, source, customized);
+    for (const key of source.visitorKeys[node.type] ?? []) {
+      const child = node[key];
+      for (const value of Array.isArray(child) ? child : [child]) {
+        if (typeof value === "object" && value !== null && "type" in value) visit(value);
+      }
+    }
+  };
+  visit(source.ast);
+  return customized;
+}
+function collectCustomization(node, source, customized) {
+  const member = unwrapExpression(node.callee);
+  if (member.type !== AST_NODE_TYPES65.MemberExpression) return;
+  const receiver = unwrapExpression(member.object);
+  if (receiver.type !== AST_NODE_TYPES65.Identifier || runtimeTestFrameworkName(source, receiver, "assertion") !== "expect") return;
+  const method = ASTUtils40.getPropertyName(member);
+  const argument = node.arguments[0] === void 0 ? null : unwrapExpression(node.arguments[0]);
+  if (method === "addEqualityTesters" && !(argument?.type === AST_NODE_TYPES65.ArrayExpression && argument.elements.length === 0)) {
+    customized.add("toEqual");
+    customized.add("toStrictEqual");
+  }
+  if (method !== "extend") return;
+  if (argument?.type !== AST_NODE_TYPES65.ObjectExpression) {
+    customized.add("*");
+    return;
+  }
+  for (const property of argument.properties) {
+    const name = property.type === AST_NODE_TYPES65.Property ? ASTUtils40.getPropertyName(property) : null;
+    customized.add(name ?? "*");
+  }
+}
+function hasConstSelfIdentity(actual, expected, source) {
+  actual = unwrapExpression(actual);
+  expected = unwrapExpression(expected);
+  if (actual.type !== AST_NODE_TYPES65.Identifier || expected.type !== AST_NODE_TYPES65.Identifier) return false;
+  const variable = ASTUtils40.findVariable(source.getScope(actual), actual.name);
+  if (variable?.defs.length !== 1 || ASTUtils40.findVariable(source.getScope(expected), expected.name) !== variable) return false;
+  const definition = variable.defs[0];
+  return definition?.node.type === AST_NODE_TYPES65.VariableDeclarator && definition.node.id.type === AST_NODE_TYPES65.Identifier && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.init.range[1] <= Math.min(actual.range[0], expected.range[0]) && !variable.references.some((reference) => reference.isWrite() && !reference.init);
+}
 var no_tautological_expect_default = createRule({
   name: "no-tautological-expect",
   documentation: NO_TAUTOLOGICAL_EXPECT_DOCUMENTATION,
@@ -14502,7 +14649,7 @@ var no_tautological_expect_default = createRule({
     },
     schema: [],
     messages: {
-      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` is fixed by literal setup and does not observe behavior. Assert on a produced value or remove only the redundant assertion, preserving other coverage.",
+      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` is fixed by {{reason}} and does not observe behavior. Assert against an independent expectation or remove only the redundant assertion, preserving the action and other coverage.",
       tautologicalMatcher: "`expect({{operand}}).{{matcher}}()` is statically known to pass. Assert on a produced value or remove only the redundant assertion, preserving other coverage."
     }
   },
@@ -14511,6 +14658,7 @@ var no_tautological_expect_default = createRule({
     if (!isTestFile(context.filename)) {
       return {};
     }
+    const customized = customizedMatchers(context.sourceCode);
     const preview2 = (node) => {
       const text = context.sourceCode.getText(node).replaceAll(/\s+/gu, " ");
       return text.length > OPERAND_PREVIEW_CHARS ? `${text.slice(0, OPERAND_PREVIEW_CHARS)}\u2026` : text;
@@ -14520,10 +14668,19 @@ var no_tautological_expect_default = createRule({
         const callee = unwrapExpression(node.callee);
         if (callee.type !== AST_NODE_TYPES65.MemberExpression) return;
         const matcher = ASTUtils40.getPropertyName(callee);
-        if (matcher === null) return;
+        if (matcher === null || !ZERO_ARG_MATCHERS.has(matcher) && !EQUALITY_MATCHERS.has(matcher) || customized.has("*") || customized.has(matcher)) return;
         const assertion = expectOperand(callee, context.sourceCode);
-        if (assertion === null) return;
+        if (assertion === null || isExceptionContract(node, context.sourceCode)) return;
         const writtenOperand = assertion.operand;
+        const writtenExpected = node.arguments[0];
+        if (!assertion.negated && matcher === "toBe" && node.arguments.length === 1 && writtenExpected !== void 0 && hasConstSelfIdentity(writtenOperand, writtenExpected, context.sourceCode)) {
+          context.report({
+            node,
+            messageId: "tautologicalComparison",
+            data: { operand: preview2(writtenOperand), matcher, reason: "the same immutable binding" }
+          });
+          return;
+        }
         const operand = resolveLiteral(writtenOperand, context.sourceCode);
         if (operand === null) {
           return;
@@ -14537,7 +14694,6 @@ var no_tautological_expect_default = createRule({
           });
           return;
         }
-        const writtenExpected = node.arguments[0];
         const expected = writtenExpected === void 0 ? null : resolveLiteral(writtenExpected, context.sourceCode);
         if (assertion.negated || !EQUALITY_MATCHERS.has(matcher) || node.arguments.length !== 1 || expected === null) {
           return;
@@ -14551,7 +14707,7 @@ var no_tautological_expect_default = createRule({
         context.report({
           node,
           messageId: "tautologicalComparison",
-          data: { operand: preview2(writtenOperand), matcher }
+          data: { operand: preview2(writtenOperand), matcher, reason: "literal setup" }
         });
       }
     };
@@ -26035,7 +26191,7 @@ function classMethodCounts(body2, methods) {
 
 // src/rules/source-coupled-test.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES116, ASTUtils as ASTUtils75 } from "@typescript-eslint/utils";
-var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc?|toml|py|[cm]?[jt]s)$/iu;
+var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc|toml|py|[cm]?[jt]s)$|(?<!\.(?:tf|tftest))\.json$/iu;
 var FS_MODULES = /* @__PURE__ */ new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"]);
 var FS_READERS = /* @__PURE__ */ new Set(["readFile", "readFileSync"]);
 var TEXT_TRANSFORMS = /* @__PURE__ */ new Set([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "16.19.0",
+  "version": "16.19.2",
   "packageManager": "npm@12.2.0",
   "description": "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   "type": "module",