@codacy/tools-eslint-9 0.23.1 → 0.25.0

package/dist/index.js

@@ -33,11 +33,11 @@ __export(index_exports, {
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
-var import_tooling2 = require("@codacy/tooling");
+var import_tooling4 = require("@codacy/tooling");
 
 // src/adapter.ts
-var import_tooling = require("@codacy/tooling");
-var import_path3 = __toESM(require("path"));
+var import_tooling3 = require("@codacy/tooling");
+var import_path4 = __toESM(require("path"));
 var import_fs3 = __toESM(require("fs"));
 var import_module = require("module");
 var import_async_hooks = require("async_hooks");
@@ -33634,7 +33634,8 @@ var patterns_default = [
 
 // src/config-builder.ts
 var import_fs2 = __toESM(require("fs"));
-var import_path2 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
+var import_tooling2 = require("@codacy/tooling");
 
 // src/blacklist.ts
 var import_fs = __toESM(require("fs"));
@@ -33835,114 +33836,120 @@ function shouldSkipRule(ruleId, pattern, ctx) {
 }
 
 // src/plugin-registry.ts
-async function loadPlugin(packageName) {
-  const mod = await import(packageName);
-  return mod.default ?? mod;
+var import_tooling = require("@codacy/tooling");
+async function loadPlugin(root, packageName) {
+  return (0, import_tooling.importFromRoot)(root, packageName);
 }
 var KNOWN_PLUGINS = [
   // --- Scoped plugins (@scope/plugin) ---
   {
     prefix: "@angular-eslint",
-    load: () => loadPlugin("@angular-eslint/eslint-plugin")
+    load: (root) => loadPlugin(root, "@angular-eslint/eslint-plugin")
   },
   {
     prefix: "@lwc/lwc",
-    load: () => loadPlugin("@lwc/eslint-plugin-lwc")
+    load: (root) => loadPlugin(root, "@lwc/eslint-plugin-lwc")
   },
   {
     prefix: "@salesforce/lightning",
-    load: () => loadPlugin("@salesforce/eslint-plugin-lightning")
+    load: (root) => loadPlugin(root, "@salesforce/eslint-plugin-lightning")
   },
   {
     prefix: "@shopify",
-    load: () => loadPlugin("@shopify/eslint-plugin")
+    load: (root) => loadPlugin(root, "@shopify/eslint-plugin")
   },
   {
     prefix: "@stylistic",
-    load: () => loadPlugin("@stylistic/eslint-plugin")
+    load: (root) => loadPlugin(root, "@stylistic/eslint-plugin")
   },
   {
     prefix: "@tanstack/query",
-    load: () => loadPlugin("@tanstack/eslint-plugin-query")
+    load: (root) => loadPlugin(root, "@tanstack/eslint-plugin-query")
   },
   {
     prefix: "@typescript-eslint",
-    load: async () => {
-      const mod = await import("typescript-eslint");
+    load: async (root) => {
+      const mod = await (0, import_tooling.importFromRoot)(root, "typescript-eslint", { raw: true });
       return mod.default?.plugin ?? mod.plugin;
     }
   },
   {
     prefix: "@vitest",
-    load: () => loadPlugin("@vitest/eslint-plugin")
+    load: (root) => loadPlugin(root, "@vitest/eslint-plugin")
   },
   // --- Non-scoped plugins (eslint-plugin-xxx) ---
-  { prefix: "angular", load: () => loadPlugin("eslint-plugin-angular") },
-  { prefix: "ava", load: () => loadPlugin("eslint-plugin-ava") },
-  { prefix: "backbone", load: () => loadPlugin("eslint-plugin-backbone") },
-  { prefix: "check-file", load: () => loadPlugin("eslint-plugin-check-file") },
-  { prefix: "compat", load: () => loadPlugin("eslint-plugin-compat") },
-  { prefix: "cypress", load: () => loadPlugin("eslint-plugin-cypress") },
-  { prefix: "ember", load: () => loadPlugin("eslint-plugin-ember") },
-  { prefix: "ember-suave", load: () => loadPlugin("eslint-plugin-ember-suave") },
-  { prefix: "es-x", load: () => loadPlugin("eslint-plugin-es-x") },
-  { prefix: "eslint-plugin", load: () => loadPlugin("eslint-plugin-eslint-plugin") },
-  { prefix: "fp", load: () => loadPlugin("eslint-plugin-fp") },
-  { prefix: "functional", load: () => loadPlugin("eslint-plugin-functional") },
-  { prefix: "i18next", load: () => loadPlugin("eslint-plugin-i18next") },
-  { prefix: "import", load: () => loadPlugin("eslint-plugin-import") },
-  { prefix: "jasmine", load: () => loadPlugin("eslint-plugin-jasmine") },
-  { prefix: "jest", load: () => loadPlugin("eslint-plugin-jest") },
-  { prefix: "jest-dom", load: () => loadPlugin("eslint-plugin-jest-dom") },
-  { prefix: "jest-extended", load: () => loadPlugin("eslint-plugin-jest-extended") },
-  { prefix: "jest-formatting", load: () => loadPlugin("eslint-plugin-jest-formatting") },
-  { prefix: "jsdoc", load: () => loadPlugin("eslint-plugin-jsdoc") },
-  { prefix: "jsonc", load: () => loadPlugin("eslint-plugin-jsonc") },
-  { prefix: "jsx-a11y", load: () => loadPlugin("eslint-plugin-jsx-a11y") },
-  { prefix: "lit", load: () => loadPlugin("eslint-plugin-lit") },
-  { prefix: "lodash", load: () => loadPlugin("eslint-plugin-lodash") },
-  { prefix: "lodash-fp", load: () => loadPlugin("eslint-plugin-lodash-fp") },
-  { prefix: "meteor", load: () => loadPlugin("eslint-plugin-meteor") },
-  { prefix: "mocha", load: () => loadPlugin("eslint-plugin-mocha") },
-  { prefix: "n", load: () => loadPlugin("eslint-plugin-n") },
-  { prefix: "nuxt", load: () => loadPlugin("eslint-plugin-nuxt") },
-  { prefix: "perfectionist", load: () => loadPlugin("eslint-plugin-perfectionist") },
-  { prefix: "playwright", load: () => loadPlugin("eslint-plugin-playwright") },
-  { prefix: "prettier", load: () => loadPlugin("eslint-plugin-prettier") },
-  { prefix: "promise", load: () => loadPlugin("eslint-plugin-promise") },
-  { prefix: "react", load: () => loadPlugin("eslint-plugin-react") },
-  { prefix: "react-hooks", load: () => loadPlugin("eslint-plugin-react-hooks") },
-  { prefix: "react-perf", load: () => loadPlugin("eslint-plugin-react-perf") },
-  { prefix: "react-redux", load: () => loadPlugin("eslint-plugin-react-redux") },
-  { prefix: "redux-saga", load: () => loadPlugin("eslint-plugin-redux-saga") },
-  { prefix: "regexp", load: () => loadPlugin("eslint-plugin-regexp") },
-  { prefix: "security", load: () => loadPlugin("eslint-plugin-security") },
-  { prefix: "security-node", load: () => loadPlugin("eslint-plugin-security-node") },
-  { prefix: "sonarjs", load: () => loadPlugin("eslint-plugin-sonarjs") },
-  { prefix: "sort", load: () => loadPlugin("eslint-plugin-sort") },
+  { prefix: "angular", load: (root) => loadPlugin(root, "eslint-plugin-angular") },
+  { prefix: "ava", load: (root) => loadPlugin(root, "eslint-plugin-ava") },
+  { prefix: "backbone", load: (root) => loadPlugin(root, "eslint-plugin-backbone") },
+  { prefix: "check-file", load: (root) => loadPlugin(root, "eslint-plugin-check-file") },
+  { prefix: "compat", load: (root) => loadPlugin(root, "eslint-plugin-compat") },
+  { prefix: "cypress", load: (root) => loadPlugin(root, "eslint-plugin-cypress") },
+  { prefix: "ember", load: (root) => loadPlugin(root, "eslint-plugin-ember") },
+  { prefix: "ember-suave", load: (root) => loadPlugin(root, "eslint-plugin-ember-suave") },
+  { prefix: "es-x", load: (root) => loadPlugin(root, "eslint-plugin-es-x") },
+  { prefix: "eslint-plugin", load: (root) => loadPlugin(root, "eslint-plugin-eslint-plugin") },
+  { prefix: "fp", load: (root) => loadPlugin(root, "eslint-plugin-fp") },
+  { prefix: "functional", load: (root) => loadPlugin(root, "eslint-plugin-functional") },
+  { prefix: "i18next", load: (root) => loadPlugin(root, "eslint-plugin-i18next") },
+  { prefix: "import", load: (root) => loadPlugin(root, "eslint-plugin-import") },
+  { prefix: "jasmine", load: (root) => loadPlugin(root, "eslint-plugin-jasmine") },
+  { prefix: "jest", load: (root) => loadPlugin(root, "eslint-plugin-jest") },
+  { prefix: "jest-dom", load: (root) => loadPlugin(root, "eslint-plugin-jest-dom") },
+  { prefix: "jest-extended", load: (root) => loadPlugin(root, "eslint-plugin-jest-extended") },
+  { prefix: "jest-formatting", load: (root) => loadPlugin(root, "eslint-plugin-jest-formatting") },
+  { prefix: "jsdoc", load: (root) => loadPlugin(root, "eslint-plugin-jsdoc") },
+  { prefix: "jsonc", load: (root) => loadPlugin(root, "eslint-plugin-jsonc") },
+  { prefix: "jsx-a11y", load: (root) => loadPlugin(root, "eslint-plugin-jsx-a11y") },
+  { prefix: "lit", load: (root) => loadPlugin(root, "eslint-plugin-lit") },
+  { prefix: "lodash", load: (root) => loadPlugin(root, "eslint-plugin-lodash") },
+  { prefix: "lodash-fp", load: (root) => loadPlugin(root, "eslint-plugin-lodash-fp") },
+  { prefix: "meteor", load: (root) => loadPlugin(root, "eslint-plugin-meteor") },
+  { prefix: "mocha", load: (root) => loadPlugin(root, "eslint-plugin-mocha") },
+  { prefix: "n", load: (root) => loadPlugin(root, "eslint-plugin-n") },
+  { prefix: "nuxt", load: (root) => loadPlugin(root, "eslint-plugin-nuxt") },
+  { prefix: "perfectionist", load: (root) => loadPlugin(root, "eslint-plugin-perfectionist") },
+  { prefix: "playwright", load: (root) => loadPlugin(root, "eslint-plugin-playwright") },
+  { prefix: "prettier", load: (root) => loadPlugin(root, "eslint-plugin-prettier") },
+  { prefix: "promise", load: (root) => loadPlugin(root, "eslint-plugin-promise") },
+  { prefix: "react", load: (root) => loadPlugin(root, "eslint-plugin-react") },
+  { prefix: "react-hooks", load: (root) => loadPlugin(root, "eslint-plugin-react-hooks") },
+  { prefix: "react-perf", load: (root) => loadPlugin(root, "eslint-plugin-react-perf") },
+  { prefix: "react-redux", load: (root) => loadPlugin(root, "eslint-plugin-react-redux") },
+  { prefix: "redux-saga", load: (root) => loadPlugin(root, "eslint-plugin-redux-saga") },
+  { prefix: "regexp", load: (root) => loadPlugin(root, "eslint-plugin-regexp") },
+  { prefix: "security", load: (root) => loadPlugin(root, "eslint-plugin-security") },
+  { prefix: "security-node", load: (root) => loadPlugin(root, "eslint-plugin-security-node") },
+  { prefix: "sonarjs", load: (root) => loadPlugin(root, "eslint-plugin-sonarjs") },
+  { prefix: "sort", load: (root) => loadPlugin(root, "eslint-plugin-sort") },
   {
     prefix: "sort-destructure-keys",
-    load: () => loadPlugin("eslint-plugin-sort-destructure-keys")
-  },
-  { prefix: "storybook", load: () => loadPlugin("eslint-plugin-storybook") },
-  { prefix: "suitescript", load: () => loadPlugin("eslint-plugin-suitescript") },
-  { prefix: "svelte", load: () => loadPlugin("eslint-plugin-svelte") },
-  { prefix: "tailwindcss", load: () => loadPlugin("eslint-plugin-tailwindcss") },
-  { prefix: "test-selectors", load: () => loadPlugin("eslint-plugin-test-selectors") },
-  { prefix: "testing-library", load: () => loadPlugin("eslint-plugin-testing-library") },
-  { prefix: "typescript-sort-keys", load: () => loadPlugin("eslint-plugin-typescript-sort-keys") },
-  { prefix: "unicorn", load: () => loadPlugin("eslint-plugin-unicorn") },
-  { prefix: "unused-imports", load: () => loadPlugin("eslint-plugin-unused-imports") },
-  { prefix: "vue", load: () => loadPlugin("eslint-plugin-vue") },
-  { prefix: "vue-scoped-css", load: () => loadPlugin("eslint-plugin-vue-scoped-css") },
-  { prefix: "vuejs-accessibility", load: () => loadPlugin("eslint-plugin-vuejs-accessibility") },
-  { prefix: "vuetify", load: () => loadPlugin("eslint-plugin-vuetify") },
-  { prefix: "wdio", load: () => loadPlugin("eslint-plugin-wdio") },
-  { prefix: "xss", load: () => loadPlugin("eslint-plugin-xss") },
-  { prefix: "yml", load: () => loadPlugin("eslint-plugin-yml") }
+    load: (root) => loadPlugin(root, "eslint-plugin-sort-destructure-keys")
+  },
+  { prefix: "storybook", load: (root) => loadPlugin(root, "eslint-plugin-storybook") },
+  { prefix: "suitescript", load: (root) => loadPlugin(root, "eslint-plugin-suitescript") },
+  { prefix: "svelte", load: (root) => loadPlugin(root, "eslint-plugin-svelte") },
+  { prefix: "tailwindcss", load: (root) => loadPlugin(root, "eslint-plugin-tailwindcss") },
+  { prefix: "test-selectors", load: (root) => loadPlugin(root, "eslint-plugin-test-selectors") },
+  { prefix: "testing-library", load: (root) => loadPlugin(root, "eslint-plugin-testing-library") },
+  {
+    prefix: "typescript-sort-keys",
+    load: (root) => loadPlugin(root, "eslint-plugin-typescript-sort-keys")
+  },
+  { prefix: "unicorn", load: (root) => loadPlugin(root, "eslint-plugin-unicorn") },
+  { prefix: "unused-imports", load: (root) => loadPlugin(root, "eslint-plugin-unused-imports") },
+  { prefix: "vue", load: (root) => loadPlugin(root, "eslint-plugin-vue") },
+  { prefix: "vue-scoped-css", load: (root) => loadPlugin(root, "eslint-plugin-vue-scoped-css") },
+  {
+    prefix: "vuejs-accessibility",
+    load: (root) => loadPlugin(root, "eslint-plugin-vuejs-accessibility")
+  },
+  { prefix: "vuetify", load: (root) => loadPlugin(root, "eslint-plugin-vuetify") },
+  { prefix: "wdio", load: (root) => loadPlugin(root, "eslint-plugin-wdio") },
+  { prefix: "xss", load: (root) => loadPlugin(root, "eslint-plugin-xss") },
+  { prefix: "yml", load: (root) => loadPlugin(root, "eslint-plugin-yml") }
 ];
 var PLUGIN_INDEX = new Map(KNOWN_PLUGINS.map((p) => [p.prefix, p]));
-async function loadRequiredPlugins(ruleIds) {
+async function loadRequiredPlugins(ruleIds, payloadRoot) {
   const neededPrefixes = /* @__PURE__ */ new Set();
   for (const id of ruleIds) {
     const prefix = extractPluginPrefix(id);
@@ -33954,7 +33961,7 @@ async function loadRequiredPlugins(ruleIds) {
   const loadPromises = [...neededPrefixes].map(async (prefix) => {
     const def = PLUGIN_INDEX.get(prefix);
     try {
-      const plugin = await def.load();
+      const plugin = await def.load(payloadRoot);
       plugins.set(prefix, plugin);
     } catch {
     }
@@ -33974,6 +33981,157 @@ function extractPluginPrefix(ruleId) {
   return ruleId.split("/")[0];
 }
 
+// src/payload.ts
+var import_path2 = __toESM(require("path"));
+
+// src/pattern-mappings.json
+var pattern_mappings_default = {
+  react: {
+    prefixes: [
+      "ESLint9_react_",
+      "ESLint9_react-hooks_",
+      "ESLint9_react-perf_",
+      "ESLint9_react-redux_",
+      "ESLint9_jsx-a11y_",
+      "ESLint9_@stylistic_jsx-",
+      "ESLint9_sonarjs_jsx-no-leaked-render",
+      "ESLint9_sonarjs_no-hook-setter-in-body",
+      "ESLint9_sonarjs_no-useless-react-setstate",
+      "ESLint9_sonarjs_prefer-read-only-props"
+    ]
+  },
+  vue: {
+    prefixes: [
+      "ESLint9_vue_",
+      "ESLint9_vue-scoped-css_",
+      "ESLint9_vuejs-accessibility_",
+      "ESLint9_vuetify_",
+      "ESLint9_jsonc_vue-custom-block",
+      "ESLint9_yml_vue-custom-block"
+    ]
+  },
+  angular: {
+    prefixes: ["ESLint9_@angular-eslint_"]
+  },
+  "angular-js": {
+    prefixes: ["ESLint9_angular_"]
+  },
+  "lang:TypeScript": {
+    prefixes: ["ESLint9_@typescript-eslint_"]
+  },
+  svelte: {
+    prefixes: ["ESLint9_svelte_"]
+  },
+  lit: {
+    prefixes: ["ESLint9_lit_"]
+  },
+  ember: {
+    prefixes: ["ESLint9_ember_", "ESLint9_ember-suave_"]
+  },
+  nuxt: {
+    prefixes: ["ESLint9_nuxt_"]
+  },
+  jest: {
+    prefixes: [
+      "ESLint9_jest_",
+      "ESLint9_jest-dom_",
+      "ESLint9_jest-extended_",
+      "ESLint9_jest-formatting_"
+    ]
+  },
+  vitest: {
+    prefixes: ["ESLint9_@vitest_"]
+  },
+  cypress: {
+    prefixes: ["ESLint9_cypress_"]
+  },
+  mocha: {
+    prefixes: ["ESLint9_mocha_"]
+  },
+  playwright: {
+    prefixes: ["ESLint9_playwright_"]
+  },
+  ava: {
+    prefixes: ["ESLint9_ava_"]
+  },
+  jasmine: {
+    prefixes: ["ESLint9_jasmine_"]
+  },
+  "testing-library": {
+    prefixes: ["ESLint9_testing-library_"]
+  },
+  storybook: {
+    prefixes: ["ESLint9_storybook_"]
+  },
+  "tailwind-css": {
+    prefixes: ["ESLint9_tailwindcss_"]
+  },
+  lodash: {
+    prefixes: ["ESLint9_lodash_", "ESLint9_lodash-fp_"]
+  },
+  redux: {
+    prefixes: ["ESLint9_redux-saga_"]
+  },
+  i18next: {
+    prefixes: ["ESLint9_i18next_"]
+  },
+  backbone: {
+    prefixes: ["ESLint9_backbone_"]
+  },
+  tanstack: {
+    prefixes: ["ESLint9_@tanstack_"]
+  },
+  shopify: {
+    prefixes: ["ESLint9_@shopify_"]
+  },
+  "lightning-web-components": {
+    prefixes: ["ESLint9_@lwc_"]
+  },
+  salesforce: {
+    prefixes: ["ESLint9_@salesforce_"]
+  },
+  meteor: {
+    prefixes: ["ESLint9_meteor_"]
+  },
+  suitescript: {
+    prefixes: ["ESLint9_suitescript_"]
+  },
+  "eslint-plugin": {
+    prefixes: ["ESLint9_eslint-plugin_"]
+  }
+};
+
+// src/metadata.ts
+var descriptor = {
+  id: "ESLint9",
+  shortName: "eslint-9",
+  displayName: "ESLint 9",
+  preferredVersion: "9.39.5",
+  languages: ["Javascript", "TypeScript"],
+  // ESLint and Biome are alternative JS/TS linters — auto-init keeps only one.
+  // ESLint 9 is the default pick when no local config file decides it.
+  alternativeGroup: "ecmascript-lint",
+  alternativeGroupDefault: true,
+  filePatterns: ["**/*.js", "**/*.jsx", "**/*.mjs", "**/*.cjs", "**/*.ts", "**/*.tsx"],
+  supportedOS: ["linux", "darwin", "win32"],
+  supportedArch: ["x64", "arm64"],
+  supportedRunners: ["local", "container"],
+  frameworkMappings: pattern_mappings_default
+};
+
+// src/payload.ts
+var PACKAGE_ROOT = import_path2.default.resolve(__dirname, "..");
+var PAYLOAD = {
+  adapterId: descriptor.id,
+  displayName: descriptor.displayName,
+  version: descriptor.preferredVersion,
+  manifestDir: import_path2.default.join(PACKAGE_ROOT, "payload"),
+  probe: "eslint",
+  adjacentFrom: PACKAGE_ROOT,
+  // A v8 tree must never be handed to the v9 adapter.
+  isCompatible: (version) => version.startsWith("9.")
+};
+
 // src/config-builder.ts
 var TSCONFIG_CANDIDATES = [
   "tsconfig.json",
@@ -33984,7 +34142,7 @@ var TSCONFIG_CANDIDATES = [
 function hasTypeScriptProjectConfig(repositoryRoot) {
   for (const name of TSCONFIG_CANDIDATES) {
     try {
-      import_fs2.default.accessSync(import_path2.default.join(repositoryRoot, name));
+      import_fs2.default.accessSync(import_path3.default.join(repositoryRoot, name));
       return true;
     } catch {
     }
@@ -34035,7 +34193,10 @@ function decodePatternId(patternId) {
 function encodePatternId(ruleId) {
   return `${PREFIX}${ruleId.replace(/_/g, "__").replace(/\//g, "_")}`;
 }
-async function buildESLintConfig(patterns, ctx = { repositoryRoot: process.cwd() }) {
+async function buildESLintConfig(patterns, ctx = {
+  repositoryRoot: process.cwd(),
+  payloadRoot: PACKAGE_ROOT
+}) {
   const ruleEntries = [];
   for (const p of patterns) {
     const ruleId = decodePatternId(p.patternId);
@@ -34043,7 +34204,7 @@ async function buildESLintConfig(patterns, ctx = { repositoryRoot: process.cwd()
     ruleEntries.push({ ruleId, pattern: p });
   }
   const allRuleIds = ruleEntries.map((e) => e.ruleId);
-  const plugins = await loadRequiredPlugins(allRuleIds);
+  const plugins = await loadRequiredPlugins(allRuleIds, ctx.payloadRoot);
   const coreRules = {};
   const pluginRuleGroups = /* @__PURE__ */ new Map();
   for (const { ruleId, pattern } of ruleEntries) {
@@ -34078,7 +34239,7 @@ async function buildESLintConfig(patterns, ctx = { repositoryRoot: process.cwd()
   const tsRules = pluginRuleGroups.get("@typescript-eslint");
   if (tsRules && tsPlugin) {
     const tsLanguageOptions = {
-      parser: await loadTsParser()
+      parser: await loadTsParser(ctx.payloadRoot)
     };
     if (hasTypeScriptProjectConfig(ctx.repositoryRoot)) {
       tsLanguageOptions.parserOptions = { projectService: true };
@@ -34193,8 +34354,8 @@ function parseParamValue(value) {
   }
   return value;
 }
-async function loadTsParser() {
-  const mod = await import("typescript-eslint");
+async function loadTsParser(payloadRoot) {
+  const mod = await (0, import_tooling2.importFromRoot)(payloadRoot, "typescript-eslint", { raw: true });
   return mod.default?.parser ?? mod.parser;
 }
 function pluginExposesRule(plugin, prefix, fullRuleId) {
@@ -34207,140 +34368,6 @@ function pluginExposesRule(plugin, prefix, fullRuleId) {
   return Object.prototype.hasOwnProperty.call(rules, shortName);
 }
 
-// src/pattern-mappings.json
-var pattern_mappings_default = {
-  react: {
-    prefixes: [
-      "ESLint9_react_",
-      "ESLint9_react-hooks_",
-      "ESLint9_react-perf_",
-      "ESLint9_react-redux_",
-      "ESLint9_jsx-a11y_",
-      "ESLint9_@stylistic_jsx-",
-      "ESLint9_sonarjs_jsx-no-leaked-render",
-      "ESLint9_sonarjs_no-hook-setter-in-body",
-      "ESLint9_sonarjs_no-useless-react-setstate",
-      "ESLint9_sonarjs_prefer-read-only-props"
-    ]
-  },
-  vue: {
-    prefixes: [
-      "ESLint9_vue_",
-      "ESLint9_vue-scoped-css_",
-      "ESLint9_vuejs-accessibility_",
-      "ESLint9_vuetify_",
-      "ESLint9_jsonc_vue-custom-block",
-      "ESLint9_yml_vue-custom-block"
-    ]
-  },
-  angular: {
-    prefixes: ["ESLint9_@angular-eslint_"]
-  },
-  "angular-js": {
-    prefixes: ["ESLint9_angular_"]
-  },
-  "lang:TypeScript": {
-    prefixes: ["ESLint9_@typescript-eslint_"]
-  },
-  svelte: {
-    prefixes: ["ESLint9_svelte_"]
-  },
-  lit: {
-    prefixes: ["ESLint9_lit_"]
-  },
-  ember: {
-    prefixes: ["ESLint9_ember_", "ESLint9_ember-suave_"]
-  },
-  nuxt: {
-    prefixes: ["ESLint9_nuxt_"]
-  },
-  jest: {
-    prefixes: [
-      "ESLint9_jest_",
-      "ESLint9_jest-dom_",
-      "ESLint9_jest-extended_",
-      "ESLint9_jest-formatting_"
-    ]
-  },
-  vitest: {
-    prefixes: ["ESLint9_@vitest_"]
-  },
-  cypress: {
-    prefixes: ["ESLint9_cypress_"]
-  },
-  mocha: {
-    prefixes: ["ESLint9_mocha_"]
-  },
-  playwright: {
-    prefixes: ["ESLint9_playwright_"]
-  },
-  ava: {
-    prefixes: ["ESLint9_ava_"]
-  },
-  jasmine: {
-    prefixes: ["ESLint9_jasmine_"]
-  },
-  "testing-library": {
-    prefixes: ["ESLint9_testing-library_"]
-  },
-  storybook: {
-    prefixes: ["ESLint9_storybook_"]
-  },
-  "tailwind-css": {
-    prefixes: ["ESLint9_tailwindcss_"]
-  },
-  lodash: {
-    prefixes: ["ESLint9_lodash_", "ESLint9_lodash-fp_"]
-  },
-  redux: {
-    prefixes: ["ESLint9_redux-saga_"]
-  },
-  i18next: {
-    prefixes: ["ESLint9_i18next_"]
-  },
-  backbone: {
-    prefixes: ["ESLint9_backbone_"]
-  },
-  tanstack: {
-    prefixes: ["ESLint9_@tanstack_"]
-  },
-  shopify: {
-    prefixes: ["ESLint9_@shopify_"]
-  },
-  "lightning-web-components": {
-    prefixes: ["ESLint9_@lwc_"]
-  },
-  salesforce: {
-    prefixes: ["ESLint9_@salesforce_"]
-  },
-  meteor: {
-    prefixes: ["ESLint9_meteor_"]
-  },
-  suitescript: {
-    prefixes: ["ESLint9_suitescript_"]
-  },
-  "eslint-plugin": {
-    prefixes: ["ESLint9_eslint-plugin_"]
-  }
-};
-
-// src/metadata.ts
-var descriptor = {
-  id: "ESLint9",
-  displayName: "ESLint 9",
-  preferredVersion: "9.39.5",
-  languages: ["Javascript", "TypeScript"],
-  // ESLint and Biome are alternative JS/TS linters — auto-init keeps only one.
-  // ESLint 9 is the default pick when no local config file decides it.
-  alternativeGroup: "ecmascript-lint",
-  alternativeGroupDefault: true,
-  filePatterns: ["**/*.js", "**/*.jsx", "**/*.mjs", "**/*.cjs", "**/*.ts", "**/*.tsx"],
-  supportedOS: ["linux", "darwin", "win32"],
-  supportedArch: ["x64", "arm64"],
-  supportedRunners: ["local", "container"],
-  frameworkMappings: pattern_mappings_default
-};
-
 // src/adapter.ts
 var yieldToEventLoop = () => (0, import_promises.setTimeout)(0);
 var TOOL_ID2 = "ESLint9";
@@ -34348,12 +34375,12 @@ var ESLINT_MAX_FILE_SIZE_BYTES = 512 * 1024;
 var LINT_BATCH_SIZE = 50;
 var ESLINT_SKIP_DIRS = /* @__PURE__ */ new Set([".yarn", "vendor", ".next", ".nuxt"]);
 function shouldSkipFile(filePath, repositoryRoot) {
-  const relPath = import_path3.default.relative(repositoryRoot, filePath).replace(/\\/g, "/");
+  const relPath = import_path4.default.relative(repositoryRoot, filePath).replace(/\\/g, "/");
   const segments = relPath.split("/");
   for (const seg of segments) {
     if (ESLINT_SKIP_DIRS.has(seg)) return `path contains skip directory "${seg}"`;
   }
-  if (/\.min\.[cm]?[jt]sx?$/.test(import_path3.default.basename(filePath))) return "minified file";
+  if (/\.min\.[cm]?[jt]sx?$/.test(import_path4.default.basename(filePath))) return "minified file";
   try {
     const stat = import_fs3.default.statSync(filePath);
     if (stat.size > ESLINT_MAX_FILE_SIZE_BYTES) {
@@ -34398,7 +34425,7 @@ var PROBE_SNIPPETS = [
 async function probeConfig(eslint, repositoryRoot) {
   for (const { filePath, source } of PROBE_SNIPPETS) {
     try {
-      await eslint.lintText(source, { filePath: import_path3.default.join(repositoryRoot, filePath) });
+      await eslint.lintText(source, { filePath: import_path4.default.join(repositoryRoot, filePath) });
     } catch (err) {
       return err instanceof Error ? err : new Error(String(err));
     }
@@ -34461,7 +34488,7 @@ function removeRulesByPluginFromFlatConfig(config, pluginPrefix) {
 }
 async function resolveProjectESLint(repositoryRoot) {
   try {
-    const projectRequire = (0, import_module.createRequire)(import_path3.default.join(repositoryRoot, "__placeholder__.js"));
+    const projectRequire = (0, import_module.createRequire)(import_path4.default.join(repositoryRoot, "__placeholder__.js"));
     const mod = projectRequire("eslint");
     const version = mod.ESLint?.version ?? "";
     const major = parseInt(version.split(".")[0], 10);
@@ -34471,6 +34498,12 @@ async function resolveProjectESLint(repositoryRoot) {
     return void 0;
   }
 }
+async function resolveLocalProjectESLint(repositoryRoot) {
+  const hasFlatConfig = LOCAL_CONFIG_FILES.some(
+    (name) => import_fs3.default.existsSync(import_path4.default.join(repositoryRoot, name))
+  );
+  return hasFlatConfig ? resolveProjectESLint(repositoryRoot) : void 0;
+}
 var consoleCaptureStorage = new import_async_hooks.AsyncLocalStorage();
 var consoleGlobalsPatched = false;
 function patchConsoleGlobals() {
@@ -34522,14 +34555,49 @@ var adapter = {
   website: "https://eslint.org",
   prerequisites: [],
   /**
-   * Verifies that the ESLint npm package is loadable and returns its version.
+   * Resolves the ESLint 9 payload (rejecting any non-9.x tree), verifies it is
+   * loadable, and returns its version and where it was found — or, when it is
+   * not installed anywhere, the roots searched and how to install it.
+   *
+   * Without a payload, a repository that has a flat config and its own ESLint 9
+   * is still reported available, as `"global"` (the user's install, never
+   * modified). Local-config mode runs on that ESLint anyway. This check cannot
+   * see the Codacy config, so in Codacy-patterns mode such a repository gets an
+   * actionable "install the payload" error from `analyze()` instead of a skip.
    */
   async checkAvailability(ctx) {
     ctx.logger.debug("Checking availability", { toolId: TOOL_ID2 });
+    const payload = (0, import_tooling3.resolvePayload)(ctx, PAYLOAD);
+    if (!payload.found) {
+      const project = await resolveLocalProjectESLint(ctx.repositoryRoot);
+      if (project) {
+        ctx.logger.debug("ESLint payload not installed; using the project's ESLint", {
+          toolId: TOOL_ID2,
+          version: project.version
+        });
+        return {
+          available: true,
+          version: project.version,
+          path: ctx.repositoryRoot,
+          installation: "global"
+        };
+      }
+      ctx.logger.debug("ESLint not available", { toolId: TOOL_ID2, reason: payload.reason });
+      return (0, import_tooling3.payloadUnavailable)(payload, PAYLOAD);
+    }
     try {
-      const { ESLint } = await import("eslint");
+      const { ESLint } = await (0, import_tooling3.importFromRoot)(
+        payload.root,
+        "eslint",
+        { raw: true }
+      );
       ctx.logger.debug("ESLint available", { toolId: TOOL_ID2, version: ESLint.version });
-      return { available: true, version: ESLint.version, installation: "bundled" };
+      return {
+        available: true,
+        version: ESLint.version,
+        path: payload.root,
+        installation: payload.source
+      };
     } catch (err) {
       const reason = `eslint package not loadable: ${err instanceof Error ? err.message : String(err)}`;
       ctx.logger.debug("ESLint not available", { toolId: TOOL_ID2, reason });
@@ -34540,14 +34608,13 @@ var adapter = {
     }
   },
   /**
-   * No-op — ESLint is an npm dependency and requires no runtime installation.
+   * Installs the pinned ESLint 9 payload — ESLint, its plugins and parsers,
+   * together in one tree — into the Codacy-managed directory with `npm ci`
+   * against the committed lockfile. Refuses in container mode.
    */
   async install(ctx) {
     ctx.logger.info("Starting install", { toolId: TOOL_ID2 });
-    ctx.logger.info("ESLint is bundled as an npm dependency \u2014 no installation needed", {
-      toolId: TOOL_ID2
-    });
-    return { success: true, installedVersion: adapter.preferredVersion };
+    return (0, import_tooling3.installNpmPayload)(ctx, PAYLOAD);
   },
   /**
    * Looks for ESLint flat config files in the repository root.
@@ -34555,7 +34622,7 @@ var adapter = {
   async checkLocalConfigurationFile(ctx) {
     ctx.logger.debug("Checking for local config", { toolId: TOOL_ID2 });
     for (const name of LOCAL_CONFIG_FILES) {
-      const candidate = import_path3.default.join(ctx.repositoryRoot, name);
+      const candidate = import_path4.default.join(ctx.repositoryRoot, name);
       try {
         import_fs3.default.accessSync(candidate);
         ctx.logger.debug("Local config found", { toolId: TOOL_ID2, path: candidate });
@@ -34579,12 +34646,12 @@ var adapter = {
     const startedAt = /* @__PURE__ */ new Date();
     const issues = [];
     const errors = [];
-    const allAbsoluteFiles = ctx.targetFiles.map((f) => import_path3.default.resolve(ctx.repositoryRoot, f));
+    const allAbsoluteFiles = ctx.targetFiles.map((f) => import_path4.default.resolve(ctx.repositoryRoot, f));
     const absoluteFiles = [];
     for (const f of allAbsoluteFiles) {
       const skipReason = shouldSkipFile(f, ctx.repositoryRoot);
       if (skipReason) {
-        const relPath = import_path3.default.relative(ctx.repositoryRoot, f);
+        const relPath = import_path4.default.relative(ctx.repositoryRoot, f);
         ctx.logger.debug("Skipping file", { toolId: TOOL_ID2, file: relPath, reason: skipReason });
       } else {
         absoluteFiles.push(f);
@@ -34600,43 +34667,59 @@ var adapter = {
     }
     if (absoluteFiles.length === 0) {
       const completedAt2 = /* @__PURE__ */ new Date();
-      return (0, import_tooling.buildResult)(TOOL_ID2, startedAt, completedAt2, issues, errors, ctx.targetFiles.length);
+      return (0, import_tooling3.buildResult)(TOOL_ID2, startedAt, completedAt2, issues, errors, ctx.targetFiles.length);
     }
     let ESLintClass;
-    try {
-      const mod = await import("eslint");
-      ESLintClass = mod.ESLint;
-    } catch (err) {
-      const completedAt2 = /* @__PURE__ */ new Date();
-      errors.push({
-        toolId: TOOL_ID2,
-        phase: "toolInvoke",
-        kind: "InvocationError",
-        message: `Failed to load eslint: ${err instanceof Error ? err.message : String(err)}`,
-        level: "error"
-      });
-      return (0, import_tooling.buildResult)(TOOL_ID2, startedAt, completedAt2, issues, errors, ctx.targetFiles.length);
-    }
-    const eslintOptions = { cwd: ctx.repositoryRoot };
     const usingLocalConfig = Boolean(
       codacyConfig.useLocalConfigurationFile && codacyConfig.localConfigurationFile
     );
-    if (usingLocalConfig) {
-      const projectESLint = await resolveProjectESLint(ctx.repositoryRoot);
-      if (projectESLint) {
-        ESLintClass = projectESLint.ESLintClass;
-        ctx.logger.info("Using project ESLint", {
+    const projectESLint = usingLocalConfig ? await resolveProjectESLint(ctx.repositoryRoot) : void 0;
+    let payloadRoot = "";
+    if (projectESLint) {
+      ESLintClass = projectESLint.ESLintClass;
+      ctx.logger.info("Using project ESLint", {
+        toolId: TOOL_ID2,
+        version: projectESLint.version
+      });
+    } else {
+      const payload = (0, import_tooling3.resolvePayload)(ctx, PAYLOAD);
+      if (!payload.found) {
+        errors.push({
           toolId: TOOL_ID2,
-          version: projectESLint.version
+          phase: "toolInvoke",
+          kind: "InvocationError",
+          message: `Failed to load eslint: ${payload.reason}. Install it with: codacy-analysis install --tool ${TOOL_ID2}`,
+          level: "error"
         });
-      } else {
-        eslintOptions.overrideConfigFile = codacyConfig.localConfigurationFile;
+        return (0, import_tooling3.buildResult)(TOOL_ID2, startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
       }
+      try {
+        payloadRoot = payload.root;
+        const mod = await (0, import_tooling3.importFromRoot)(payloadRoot, "eslint", {
+          raw: true
+        });
+        ESLintClass = mod.ESLint;
+      } catch (err) {
+        const completedAt2 = /* @__PURE__ */ new Date();
+        errors.push({
+          toolId: TOOL_ID2,
+          phase: "toolInvoke",
+          kind: "InvocationError",
+          message: `Failed to load eslint: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        });
+        return (0, import_tooling3.buildResult)(TOOL_ID2, startedAt, completedAt2, issues, errors, ctx.targetFiles.length);
+      }
+    }
+    const eslintOptions = { cwd: ctx.repositoryRoot };
+    if (usingLocalConfig) {
+      if (!projectESLint) eslintOptions.overrideConfigFile = codacyConfig.localConfigurationFile;
     } else if (codacyConfig.patterns.length > 0) {
       const buildStartMs = Date.now();
       try {
         const config = await buildESLintConfig(codacyConfig.patterns, {
-          repositoryRoot: ctx.repositoryRoot
+          repositoryRoot: ctx.repositoryRoot,
+          payloadRoot
         });
         eslintOptions.overrideConfig = config;
         eslintOptions.overrideConfigFile = true;
@@ -34654,13 +34737,13 @@ var adapter = {
           message: `Failed to build ESLint config: ${err instanceof Error ? err.message : String(err)}`,
           level: "error"
         });
-        return (0, import_tooling.buildResult)(TOOL_ID2, startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+        return (0, import_tooling3.buildResult)(TOOL_ID2, startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
       }
     } else {
       ctx.logger.info("Skipping analysis: no local config and no patterns enabled", {
         toolId: TOOL_ID2
       });
-      return (0, import_tooling.buildResult)(TOOL_ID2, startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      return (0, import_tooling3.buildResult)(TOOL_ID2, startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
     }
     const enabledPatterns = new Set(codacyConfig.patterns.map((p) => p.patternId));
     const MAX_CONFIG_RETRIES = 30;
@@ -34811,7 +34894,7 @@ var adapter = {
       ctx.onProgress?.(`Processing results from ${results.length} files`);
       for (const fileResult of results) {
         if (fileResult.messages.length === 0) continue;
-        const relPath = import_path3.default.relative(ctx.repositoryRoot, fileResult.filePath);
+        const relPath = import_path4.default.relative(ctx.repositoryRoot, fileResult.filePath);
         let lines;
         for (const msg of fileResult.messages) {
           if (!msg.ruleId) continue;
@@ -34826,7 +34909,7 @@ var adapter = {
             suggestion = msg.suggestions[0].desc;
           }
           if (lines === void 0) {
-            lines = await (0, import_tooling.readFileLines)(fileResult.filePath);
+            lines = await (0, import_tooling3.readFileLines)(fileResult.filePath);
           }
           issues.push({
             filePath: relPath,
@@ -34837,7 +34920,7 @@ var adapter = {
             endLine: msg.endLine,
             endColumn: msg.endColumn,
             message: msg.message,
-            lineContent: (0, import_tooling.getLineContent)(lines, msg.line),
+            lineContent: (0, import_tooling3.getLineContent)(lines, msg.line),
             category: meta.category,
             severity: meta.severity,
             suggestion
@@ -34872,9 +34955,9 @@ var adapter = {
       errorCount: errors.length,
       durationMs
     });
-    return (0, import_tooling.buildResult)(TOOL_ID2, startedAt, completedAt, issues, errors, ctx.targetFiles.length);
+    return (0, import_tooling3.buildResult)(TOOL_ID2, startedAt, completedAt, issues, errors, ctx.targetFiles.length);
   }
 };
 
 // src/index.ts
-var index_default = (0, import_tooling2.defineToolAdapter)(adapter);
+var index_default = (0, import_tooling4.defineToolAdapter)(adapter);