eslint 9.33.0 → 9.34.0

package/lib/eslint/eslint.js

@@ -9,11 +9,13 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const fs = require("node:fs/promises");
 const { existsSync } = require("node:fs");
+const fs = require("node:fs/promises");
+const os = require("node:os");
 const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+const { SHARE_ENV, Worker } = require("node:worker_threads");
 const { version } = require("../../package.json");
-const { Linter } = require("../linter");
 const { defaultConfig } = require("../config/default-config");
 
 const {
@@ -25,14 +27,21 @@ const {
 
 	createIgnoreResult,
 	isErrorMessage,
-	calculateStatsPerFile,
+	getPlaceholderPath,
 
 	processOptions,
+	loadOptionsFromModule,
+
+	getFixerForFixTypes,
+	verifyText,
+	lintFile,
+	createLinter,
+	createLintResultCache,
+	createDefaultConfigs,
+	createConfigLoader,
 } = require("./eslint-helpers");
-const { pathToFileURL } = require("node:url");
-const LintResultCache = require("../cli-engine/lint-result-cache");
 const { Retrier } = require("@humanwhocodes/retry");
-const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
+const { ConfigLoader } = require("../config/config-loader");
 const { WarningService } = require("../services/warning-service");
 const { Config } = require("../config/config.js");
 const {
@@ -53,16 +62,14 @@ const { resolve } = require("../shared/relative-module-resolver.js");
 
 // For VSCode IntelliSense
 /**
- * @import { ConfigArray } from "../cli-engine/cli-engine.js";
- * @import { CLIEngineLintReport } from "./legacy-eslint.js";
+ * @import { Config as CalculatedConfig } from "../config/config.js";
  * @import { FlatConfigArray } from "../config/flat-config-array.js";
- * @import { RuleDefinition } from "@eslint/core";
+ * @import { RuleDefinition, RulesMeta } from "@eslint/core";
+ * @import { WorkerLintResults } from "./worker.js";
  */
 
-/** @typedef {ReturnType<ConfigArray.extractConfig>} ExtractedConfig */
 /** @typedef {import("../types").Linter.Config} Config */
 /** @typedef {import("../types").ESLint.DeprecatedRuleUse} DeprecatedRuleInfo */
-/** @typedef {import("../types").Linter.LintMessage} LintMessage */
 /** @typedef {import("../types").ESLint.LintResult} LintResult */
 /** @typedef {import("../types").ESLint.Plugin} Plugin */
 /** @typedef {import("../types").ESLint.ResultsMeta} ResultsMeta */
@@ -75,6 +82,7 @@ const { resolve } = require("../shared/relative-module-resolver.js");
  * @property {boolean} [cache] Enable result caching.
  * @property {string} [cacheLocation] The cache file to use instead of .eslintcache.
  * @property {"metadata" | "content"} [cacheStrategy] The strategy used to detect changed files.
+ * @property {number | "auto" | "off"} [concurrency] Maximum number of linting threads, "auto" to choose automatically, "off" for no multithreading.
  * @property {string} [cwd] The value to use for the current working directory.
  * @property {boolean} [errorOnUnmatchedPattern] If `false` then `ESLint#lintFiles()` doesn't throw even if no target files found. Defaults to `true`.
  * @property {boolean|Function} [fix] Execute in autofix mode. If a function, should return a boolean.
@@ -87,11 +95,11 @@ const { resolve } = require("../shared/relative-module-resolver.js");
  * @property {boolean|string} [overrideConfigFile] Searches for default config file when falsy;
  *      doesn't do any config file lookup when `true`; considered to be a config filename
  *      when a string.
+ * @property {boolean} [passOnNoPatterns=false] When set to true, missing patterns cause
+ *      the linting operation to short circuit and not report any failures.
  * @property {Record<string,Plugin>} [plugins] An array of plugin implementations.
  * @property {boolean} [stats] True enables added statistics on lint results.
  * @property {boolean} [warnIgnored] Show warnings when the file list includes ignored files
- * @property {boolean} [passOnNoPatterns=false] When set to true, missing patterns cause
- *      the linting operation to short circuit and not report any failures.
  */
 
 //------------------------------------------------------------------------------
@@ -111,11 +119,12 @@ const removedFormatters = new Set([
 	"unix",
 	"visualstudio",
 ]);
+const fileRetryCodes = new Set(["ENFILE", "EMFILE"]);
 
 /**
  * Create rulesMeta object.
- * @param {Map<string,RuleDefinition>} rules a map of rules from which to generate the object.
- * @returns {Object} metadata for all enabled rules.
+ * @param {Map<string, RuleDefinition>} rules a map of rules from which to generate the object.
+ * @returns {Record<string, RulesMeta>} metadata for all enabled rules.
  */
 function createRulesMeta(rules) {
 	return Array.from(rules).reduce((retVal, [id, rule]) => {
@@ -124,17 +133,7 @@ function createRulesMeta(rules) {
 	}, {});
 }
 
-/**
- * Return the absolute path of a file named `"__placeholder__.js"` in a given directory.
- * This is used as a replacement for a missing file path.
- * @param {string} cwd An absolute directory path.
- * @returns {string} The absolute path of a file named `"__placeholder__.js"` in the given directory.
- */
-function getPlaceholderPath(cwd) {
-	return path.join(cwd, "__placeholder__.js");
-}
-
-/** @type {WeakMap<ExtractedConfig, DeprecatedRuleInfo[]>} */
+/** @type {WeakMap<CalculatedConfig, DeprecatedRuleInfo[]>} */
 const usedDeprecatedRulesCache = new WeakMap();
 
 /**
@@ -193,10 +192,10 @@ function getOrFindUsedDeprecatedRules(eslint, maybeFilePath) {
  * Processes the linting results generated by a CLIEngine linting report to
  * match the ESLint class's API.
  * @param {ESLint} eslint The ESLint instance.
- * @param {CLIEngineLintReport} report The CLIEngine linting report to process.
+ * @param {LintResult[]} results The linting results to process.
  * @returns {LintResult[]} The processed linting results.
  */
-function processLintReport(eslint, { results }) {
+function processLintReport(eslint, results) {
 	const descriptor = {
 		configurable: true,
 		enumerable: true,
@@ -263,146 +262,291 @@ async function locateConfigFileToUse({ configFile, cwd }) {
 }
 
 /**
- * Processes an source code using ESLint.
- * @param {Object} config The config object.
- * @param {string} config.text The source code to verify.
- * @param {string} config.cwd The path to the current working directory.
- * @param {string|undefined} config.filePath The path to the file of `text`. If this is undefined, it uses `<text>`.
- * @param {FlatConfigArray} config.configs The config.
- * @param {boolean} config.fix If `true` then it does fix.
- * @param {boolean} config.allowInlineConfig If `true` then it uses directive comments.
- * @param {Function} config.ruleFilter A predicate function to filter which rules should be run.
- * @param {boolean} config.stats If `true`, then if reports extra statistics with the lint results.
- * @param {Linter} config.linter The linter instance to verify.
- * @returns {LintResult} The result of linting.
- * @private
+ * Creates an error to be thrown when an array of results passed to `getRulesMetaForResults` was not created by the current engine.
+ * @returns {TypeError} An error object.
  */
-function verifyText({
-	text,
-	cwd,
-	filePath: providedFilePath,
-	configs,
-	fix,
-	allowInlineConfig,
-	ruleFilter,
-	stats,
-	linter,
-}) {
-	const filePath = providedFilePath || "<text>";
-
-	debug(`Lint ${filePath}`);
-
-	/*
-	 * Verify.
-	 * `config.extractConfig(filePath)` requires an absolute path, but `linter`
-	 * doesn't know CWD, so it gives `linter` an absolute path always.
-	 */
-	const filePathToVerify =
-		filePath === "<text>" ? getPlaceholderPath(cwd) : filePath;
-	const { fixed, messages, output } = linter.verifyAndFix(text, configs, {
-		allowInlineConfig,
-		filename: filePathToVerify,
-		fix,
-		ruleFilter,
-		stats,
-
-		/**
-		 * Check if the linter should adopt a given code block or not.
-		 * @param {string} blockFilename The virtual filename of a code block.
-		 * @returns {boolean} `true` if the linter should adopt the code block.
-		 */
-		filterCodeBlock(blockFilename) {
-			return configs.getConfig(blockFilename) !== void 0;
-		},
-	});
-
-	// Tweak and return.
-	const result = {
-		filePath: filePath === "<text>" ? filePath : path.resolve(filePath),
-		messages,
-		suppressedMessages: linter.getSuppressedMessages(),
-		...calculateStatsPerFile(messages),
-	};
+function createExtraneousResultsError() {
+	return new TypeError(
+		"Results object was not created from this ESLint instance.",
+	);
+}
 
-	if (fixed) {
-		result.output = output;
-	}
+/**
+ * Maximum number of files assumed to be best handled by one worker thread.
+ * This value is a heuristic estimation that can be adjusted if required.
+ */
+const AUTO_FILES_PER_WORKER = 35;
 
-	if (
-		result.errorCount + result.warningCount > 0 &&
-		typeof result.output === "undefined"
-	) {
-		result.source = text;
+/**
+ * Calculates the number of workers to run based on the concurrency setting and the number of files to lint.
+ * @param {number | "auto" | "off"} concurrency The normalized concurrency setting.
+ * @param {number} fileCount The number of files to be linted.
+ * @param {{ availableParallelism: () => number }} [os] Node.js `os` module, or a mock for testing.
+ * @returns {number} The effective number of worker threads to be started. A value of zero disables multithread linting.
+ */
+function calculateWorkerCount(
+	concurrency,
+	fileCount,
+	{ availableParallelism } = os,
+) {
+	let workerCount;
+	switch (concurrency) {
+		case "off":
+			return 0;
+		case "auto": {
+			workerCount = Math.min(
+				availableParallelism() >> 1,
+				Math.ceil(fileCount / AUTO_FILES_PER_WORKER),
+			);
+			break;
+		}
+		default:
+			workerCount = Math.min(concurrency, fileCount);
+			break;
 	}
+	return workerCount > 1 ? workerCount : 0;
+}
 
-	if (stats) {
-		result.stats = {
-			times: linter.getTimes(),
-			fixPasses: linter.getFixPassCount(),
-		};
-	}
+// Used internally. Do not expose.
+const disableCloneabilityCheck = Symbol(
+	"Do not check for uncloneable options.",
+);
 
-	return result;
-}
+/**
+ * The smallest net linting ratio that doesn't trigger a poor concurrency warning.
+ * The net linting ratio is defined as the net linting duration divided by the thread's total runtime,
+ * where the net linting duration is the total linting time minus the time spent on I/O-intensive operations:
+ * **Net Linting Ratio** = (**Linting Time** – **I/O Time**) / **Thread Runtime**.
+ * - **Linting Time**: Total time spent linting files
+ * - **I/O Time**: Portion of linting time spent loading configs and reading files
+ * - **Thread Runtime**: End-to-end execution time of the thread
+ *
+ * This value is a heuristic estimation that can be adjusted if required.
+ */
+const LOW_NET_LINTING_RATIO = 0.7;
 
 /**
- * Checks whether a message's rule type should be fixed.
- * @param {LintMessage} message The message to check.
- * @param {FlatConfigArray} config The config for the file that generated the message.
- * @param {string[]} fixTypes An array of fix types to check.
- * @returns {boolean} Whether the message should be fixed.
+ * Runs worker threads to lint files.
+ * @param {string[]} filePaths File paths to lint.
+ * @param {number} workerCount The number of worker threads to run.
+ * @param {ESLintOptions | string} eslintOptionsOrURL The unprocessed ESLint options or the URL of the options module.
+ * @param {() => void} warnOnLowNetLintingRatio A function to call if the net linting ratio is low.
+ * @returns {Promise<LintResult[]>} Lint results.
  */
-function shouldMessageBeFixed(message, config, fixTypes) {
-	if (!message.ruleId) {
-		return fixTypes.has("directive");
+async function runWorkers(
+	filePaths,
+	workerCount,
+	eslintOptionsOrURL,
+	warnOnLowNetLintingRatio,
+) {
+	const fileCount = filePaths.length;
+	const results = Array(fileCount);
+	const workerURL = pathToFileURL(path.join(__dirname, "./worker.js"));
+	const filePathIndexArray = new Uint32Array(
+		new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT),
+	);
+	const abortController = new AbortController();
+	const abortSignal = abortController.signal;
+	const workerOptions = {
+		env: SHARE_ENV,
+		workerData: {
+			eslintOptionsOrURL,
+			filePathIndexArray,
+			filePaths,
+		},
+	};
+
+	const hrtimeBigint = process.hrtime.bigint;
+	let worstNetLintingRatio = 1;
+
+	/**
+	 * A promise executor function that starts a worker thread on each invocation.
+	 * @param {() => void} resolve_ Called when the worker thread terminates successfully.
+	 * @param {(error: Error) => void} reject Called when the worker thread terminates with an error.
+	 * @returns {void}
+	 */
+	function workerExecutor(resolve_, reject) {
+		const workerStartTime = hrtimeBigint();
+		const worker = new Worker(workerURL, workerOptions);
+		worker.once(
+			"message",
+			(/** @type {WorkerLintResults} */ indexedResults) => {
+				const workerDuration = hrtimeBigint() - workerStartTime;
+
+				// The net linting ratio provides an approximate measure of worker thread efficiency, defined as the net linting duration divided by the thread's total runtime.
+				const netLintingRatio =
+					Number(indexedResults.netLintingDuration) /
+					Number(workerDuration);
+
+				worstNetLintingRatio = Math.min(
+					worstNetLintingRatio,
+					netLintingRatio,
+				);
+				for (const result of indexedResults) {
+					const { index } = result;
+					delete result.index;
+					results[index] = result;
+				}
+				resolve_();
+			},
+		);
+		worker.once("error", error => {
+			abortController.abort(error);
+			reject(error);
+		});
+		abortSignal.addEventListener("abort", () => worker.terminate());
 	}
 
-	const rule = message.ruleId && config.getRuleDefinition(message.ruleId);
+	const promises = Array(workerCount);
+	for (let index = 0; index < workerCount; ++index) {
+		promises[index] = new Promise(workerExecutor);
+	}
+	await Promise.all(promises);
 
-	return Boolean(rule && rule.meta && fixTypes.has(rule.meta.type));
+	if (worstNetLintingRatio < LOW_NET_LINTING_RATIO) {
+		warnOnLowNetLintingRatio();
+	}
+
+	return results;
 }
 
 /**
- * Creates an error to be thrown when an array of results passed to `getRulesMetaForResults` was not created by the current engine.
- * @returns {TypeError} An error object.
+ * Lint files in multithread mode.
+ * @param {ESLint} eslint ESLint instance.
+ * @param {string[]} filePaths File paths to lint.
+ * @param {number} workerCount The number of worker threads to run.
+ * @param {ESLintOptions | string} eslintOptionsOrURL The unprocessed ESLint options or the URL of the options module.
+ * @param {() => void} warnOnLowNetLintingRatio A function to call if the net linting ratio is low.
+ * @returns {Promise<LintResult[]>} Lint results.
  */
-function createExtraneousResultsError() {
-	return new TypeError(
-		"Results object was not created from this ESLint instance.",
+async function lintFilesWithMultithreading(
+	eslint,
+	filePaths,
+	workerCount,
+	eslintOptionsOrURL,
+	warnOnLowNetLintingRatio,
+) {
+	const { configLoader, lintResultCache } = privateMembers.get(eslint);
+
+	const results = await runWorkers(
+		filePaths,
+		workerCount,
+		eslintOptionsOrURL,
+		warnOnLowNetLintingRatio,
 	);
+	// Persist the cache to disk.
+	if (lintResultCache) {
+		results.forEach((result, index) => {
+			if (result) {
+				const filePath = filePaths[index];
+				const configs =
+					configLoader.getCachedConfigArrayForFile(filePath);
+				const config = configs.getConfig(filePath);
+
+				if (config) {
+					/*
+					 * Store the lint result in the LintResultCache.
+					 * NOTE: The LintResultCache will remove the file source and any
+					 * other properties that are difficult to serialize, and will
+					 * hydrate those properties back in on future lint runs.
+					 */
+					lintResultCache.setCachedLintResults(
+						filePath,
+						config,
+						result,
+					);
+				}
+			}
+		});
+	}
+	return results;
 }
 
 /**
- * Creates a fixer function based on the provided fix, fixTypesSet, and config.
- * @param {Function|boolean} fix The original fix option.
- * @param {Set<string>} fixTypesSet A set of fix types to filter messages for fixing.
- * @param {FlatConfigArray} config The config for the file that generated the message.
- * @returns {Function|boolean} The fixer function or the original fix value.
+ * Lint files in single-thread mode.
+ * @param {ESLint} eslint ESLint instance.
+ * @param {string[]} filePaths File paths to lint.
+ * @returns {Promise<LintResult[]>} Lint results.
  */
-function getFixerForFixTypes(fix, fixTypesSet, config) {
-	if (!fix || !fixTypesSet) {
-		return fix;
-	}
+async function lintFilesWithoutMultithreading(eslint, filePaths) {
+	const {
+		configLoader,
+		linter,
+		lintResultCache,
+		options: eslintOptions,
+	} = privateMembers.get(eslint);
+
+	const controller = new AbortController();
+	const retrier = new Retrier(error => fileRetryCodes.has(error.code), {
+		concurrency: 100,
+	});
+
+	/*
+	 * Because we need to process multiple files, including reading from disk,
+	 * it is most efficient to start by reading each file via promises so that
+	 * they can be done in parallel. Then, we can lint the returned text. This
+	 * ensures we are waiting the minimum amount of time in between lints.
+	 */
+	const results = await Promise.all(
+		filePaths.map(async filePath => {
+			const configs = configLoader.getCachedConfigArrayForFile(filePath);
+			const config = configs.getConfig(filePath);
+
+			const result = await lintFile(
+				filePath,
+				configs,
+				eslintOptions,
+				linter,
+				lintResultCache,
+				null,
+				retrier,
+				controller,
+			);
 
-	const originalFix = typeof fix === "function" ? fix : () => true;
+			if (config) {
+				/*
+				 * Store the lint result in the LintResultCache.
+				 * NOTE: The LintResultCache will remove the file source and any
+				 * other properties that are difficult to serialize, and will
+				 * hydrate those properties back in on future lint runs.
+				 */
+				lintResultCache?.setCachedLintResults(filePath, config, result);
+			}
 
-	return message =>
-		shouldMessageBeFixed(message, config, fixTypesSet) &&
-		originalFix(message);
+			return result;
+		}),
+	);
+	return results;
 }
 
 /**
- * Retrieves flags from the environment variable ESLINT_FLAGS.
- * @param {string[]} flags The flags defined via the API.
- * @returns {string[]} The merged flags to use.
+ * Throws an error if the given options are not cloneable.
+ * @param {ESLintOptions} options The options to check.
+ * @returns {void}
+ * @throws {TypeError} If the options are not cloneable.
  */
-function mergeEnvironmentFlags(flags) {
-	if (!process.env.ESLINT_FLAGS) {
-		return flags;
+function validateOptionCloneability(options) {
+	try {
+		structuredClone(options);
+		return;
+	} catch {
+		// continue
 	}
-
-	const envFlags = process.env.ESLINT_FLAGS.trim().split(/\s*,\s*/gu);
-	return Array.from(new Set([...envFlags, ...flags]));
+	const uncloneableOptionKeys = Object.keys(options)
+		.filter(key => {
+			try {
+				structuredClone(options[key]);
+			} catch {
+				return true;
+			}
+			return false;
+		})
+		.sort();
+	const error = new TypeError(
+		`The ${uncloneableOptionKeys.length === 1 ? "option" : "options"} ${new Intl.ListFormat("en-US").format(uncloneableOptionKeys.map(key => `"${key}"`))} cannot be cloned. When concurrency is enabled, all options must be cloneable. Remove uncloneable options or use an options module.`,
+	);
+	error.code = "ESLINT_UNCLONEABLE_OPTIONS";
+	throw error;
 }
 
 //-----------------------------------------------------------------------------
@@ -421,51 +565,51 @@ class ESLint {
 
 	/**
 	 * The loader to use for finding config files.
-	 * @type {ConfigLoader|LegacyConfigLoader}
+	 * @type {ConfigLoader}
 	 */
 	#configLoader;
 
+	/**
+	 * The unprocessed options or the URL of the options module. Only set when concurrency is enabled.
+	 * @type {ESLintOptions | string | undefined}
+	 */
+	#optionsOrURL;
+
 	/**
 	 * Creates a new instance of the main ESLint API.
 	 * @param {ESLintOptions} options The options for this instance.
 	 */
 	constructor(options = {}) {
-		const defaultConfigs = [];
 		const processedOptions = processOptions(options);
+		if (
+			!options[disableCloneabilityCheck] &&
+			processedOptions.concurrency !== "off"
+		) {
+			validateOptionCloneability(options);
+
+			// Save the unprocessed options in an instance field to pass to worker threads in `lintFiles()`.
+			this.#optionsOrURL = options;
+		}
 		const warningService = new WarningService();
-		const linter = new Linter({
-			cwd: processedOptions.cwd,
-			configType: "flat",
-			flags: mergeEnvironmentFlags(processedOptions.flags),
-			warningService,
-		});
+		const linter = createLinter(processedOptions, warningService);
 
 		const cacheFilePath = getCacheFile(
 			processedOptions.cacheLocation,
 			processedOptions.cwd,
 		);
 
-		const lintResultCache = processedOptions.cache
-			? new LintResultCache(cacheFilePath, processedOptions.cacheStrategy)
-			: null;
-
-		const configLoaderOptions = {
-			cwd: processedOptions.cwd,
-			baseConfig: processedOptions.baseConfig,
-			overrideConfig: processedOptions.overrideConfig,
-			configFile: processedOptions.configFile,
-			ignoreEnabled: processedOptions.ignore,
-			ignorePatterns: processedOptions.ignorePatterns,
+		const lintResultCache = createLintResultCache(
+			processedOptions,
+			cacheFilePath,
+		);
+		const defaultConfigs = createDefaultConfigs(options.plugins);
+
+		this.#configLoader = createConfigLoader(
+			processedOptions,
 			defaultConfigs,
-			hasUnstableNativeNodeJsTSConfigFlag: linter.hasFlag(
-				"unstable_native_nodejs_ts_config",
-			),
+			linter,
 			warningService,
-		};
-
-		this.#configLoader = linter.hasFlag("v10_config_lookup_from_file")
-			? new ConfigLoader(configLoaderOptions)
-			: new LegacyConfigLoader(configLoaderOptions);
+		);
 
 		debug(`Using config loader ${this.#configLoader.constructor.name}`);
 
@@ -477,26 +621,9 @@ class ESLint {
 			defaultConfigs,
 			configs: null,
 			configLoader: this.#configLoader,
+			warningService,
 		});
 
-		/**
-		 * If additional plugins are passed in, add that to the default
-		 * configs for this instance.
-		 */
-		if (options.plugins) {
-			const plugins = {};
-
-			for (const [pluginName, plugin] of Object.entries(
-				options.plugins,
-			)) {
-				plugins[getShorthandName(pluginName, "eslint-plugin")] = plugin;
-			}
-
-			defaultConfigs.push({
-				plugins,
-			});
-		}
-
 		// Check for the .eslintignore file, and warn if it's present.
 		if (existsSync(path.resolve(processedOptions.cwd, ".eslintignore"))) {
 			warningService.emitESLintIgnoreWarning();
@@ -514,7 +641,7 @@ class ESLint {
 	/**
 	 * The default configuration that ESLint uses internally. This is provided for tooling that wants to calculate configurations using the same defaults as ESLint.
 	 * Keep in mind that the default configuration may change from version to version, so you shouldn't rely on any particular keys or values to be present.
-	 * @type {ConfigArray}
+	 * @type {FlatConfigArray}
 	 */
 	static get defaultConfig() {
 		return defaultConfig;
@@ -530,8 +657,7 @@ class ESLint {
 			throw new Error("'results' must be an array");
 		}
 
-		const retryCodes = new Set(["ENFILE", "EMFILE"]);
-		const retrier = new Retrier(error => retryCodes.has(error.code), {
+		const retrier = new Retrier(error => fileRetryCodes.has(error.code), {
 			concurrency: 100,
 		});
 
@@ -581,10 +707,31 @@ class ESLint {
 		return filtered;
 	}
 
+	/**
+	 * Creates a new ESLint instance using options loaded from a module.
+	 * @param {URL} optionsURL The URL of the options module.
+	 * @returns {ESLint} The new ESLint instance.
+	 */
+	static async fromOptionsModule(optionsURL) {
+		if (!(optionsURL instanceof URL)) {
+			throw new TypeError("Argument must be a URL object");
+		}
+		const optionsURLString = optionsURL.href;
+		const loadedOptions = await loadOptionsFromModule(optionsURLString);
+		const options = { ...loadedOptions, [disableCloneabilityCheck]: true };
+		const eslint = new ESLint(options);
+
+		if (options.concurrency !== "off") {
+			// Save the options module URL in an instance field to pass to worker threads in `lintFiles()`.
+			eslint.#optionsOrURL = optionsURLString;
+		}
+		return eslint;
+	}
+
 	/**
 	 * Returns meta objects for each rule represented in the lint results.
 	 * @param {LintResult[]} results The results to fetch rules meta for.
-	 * @returns {Object} A mapping of ruleIds to rule meta objects.
+	 * @returns {Record<string, RulesMeta>} A mapping of ruleIds to rule meta objects.
 	 * @throws {TypeError} When the results object wasn't created from this ESLint instance.
 	 * @throws {TypeError} When a plugin or rule is missing.
 	 */
@@ -667,8 +814,8 @@ class ESLint {
 		const {
 			cacheFilePath,
 			lintResultCache,
-			linter,
 			options: eslintOptions,
+			warningService,
 		} = privateMembers.get(this);
 
 		/*
@@ -709,19 +856,12 @@ class ESLint {
 		debug(`Using file patterns: ${normalizedPatterns}`);
 
 		const {
-			allowInlineConfig,
 			cache,
+			concurrency,
 			cwd,
-			fix,
-			fixTypes,
-			ruleFilter,
-			stats,
 			globInputPaths,
 			errorOnUnmatchedPattern,
-			warnIgnored,
 		} = eslintOptions;
-		const startTime = Date.now();
-		const fixTypesSet = fixTypes ? new Set(fixTypes) : null;
 
 		// Delete cache file; should this be done here?
 		if (!cache && cacheFilePath) {
@@ -738,6 +878,7 @@ class ESLint {
 			}
 		}
 
+		const startTime = Date.now();
 		const filePaths = await findFiles({
 			patterns: normalizedPatterns,
 			cwd,
@@ -745,119 +886,45 @@ class ESLint {
 			configLoader: this.#configLoader,
 			errorOnUnmatchedPattern,
 		});
-		const controller = new AbortController();
-		const retryCodes = new Set(["ENFILE", "EMFILE"]);
-		const retrier = new Retrier(error => retryCodes.has(error.code), {
-			concurrency: 100,
-		});
-
 		debug(
 			`${filePaths.length} files found in: ${Date.now() - startTime}ms`,
 		);
 
-		/*
-		 * Because we need to process multiple files, including reading from disk,
-		 * it is most efficient to start by reading each file via promises so that
-		 * they can be done in parallel. Then, we can lint the returned text. This
-		 * ensures we are waiting the minimum amount of time in between lints.
-		 */
-		const results = await Promise.all(
-			filePaths.map(async filePath => {
-				const configs =
-					await this.#configLoader.loadConfigArrayForFile(filePath);
-				const config = configs.getConfig(filePath);
-
-				/*
-				 * If a filename was entered that cannot be matched
-				 * to a config, then notify the user.
-				 */
-				if (!config) {
-					if (warnIgnored) {
-						const configStatus = configs.getConfigStatus(filePath);
+		/** @type {LintResult[]} */
+		let results;
 
-						return createIgnoreResult(filePath, cwd, configStatus);
-					}
-
-					return void 0;
-				}
-
-				// Skip if there is cached result.
-				if (lintResultCache) {
-					const cachedResult = lintResultCache.getCachedLintResults(
-						filePath,
-						config,
-					);
-
-					if (cachedResult) {
-						const hadMessages =
-							cachedResult.messages &&
-							cachedResult.messages.length > 0;
-
-						if (hadMessages && fix) {
-							debug(
-								`Reprocessing cached file to allow autofix: ${filePath}`,
-							);
-						} else {
-							debug(
-								`Skipping file since it hasn't changed: ${filePath}`,
-							);
-							return cachedResult;
-						}
-					}
-				}
-
-				// set up fixer for fixTypes if necessary
-				const fixer = getFixerForFixTypes(fix, fixTypesSet, config);
-
-				return retrier
-					.retry(
-						() =>
-							fs
-								.readFile(filePath, {
-									encoding: "utf8",
-									signal: controller.signal,
-								})
-								.then(text => {
-									// fail immediately if an error occurred in another file
-									controller.signal.throwIfAborted();
-
-									// do the linting
-									const result = verifyText({
-										text,
-										filePath,
-										configs,
-										cwd,
-										fix: fixer,
-										allowInlineConfig,
-										ruleFilter,
-										stats,
-										linter,
-									});
-
-									/*
-									 * Store the lint result in the LintResultCache.
-									 * NOTE: The LintResultCache will remove the file source and any
-									 * other properties that are difficult to serialize, and will
-									 * hydrate those properties back in on future lint runs.
-									 */
-									if (lintResultCache) {
-										lintResultCache.setCachedLintResults(
-											filePath,
-											config,
-											result,
-										);
-									}
-
-									return result;
-								}),
-						{ signal: controller.signal },
-					)
-					.catch(error => {
-						controller.abort(error);
-						throw error;
-					});
-			}),
+		// The value of `module.exports.calculateWorkerCount` can be overridden in tests.
+		const workerCount = module.exports.calculateWorkerCount(
+			concurrency,
+			filePaths.length,
 		);
+		if (workerCount) {
+			debug(`Linting using ${workerCount} worker thread(s).`);
+			let poorConcurrencyNotice;
+			if (workerCount <= 2) {
+				poorConcurrencyNotice = "disable concurrency";
+			} else {
+				if (concurrency === "auto") {
+					poorConcurrencyNotice =
+						"disable concurrency or use a numeric concurrency setting";
+				} else {
+					poorConcurrencyNotice = "reduce or disable concurrency";
+				}
+			}
+			results = await lintFilesWithMultithreading(
+				this,
+				filePaths,
+				workerCount,
+				this.#optionsOrURL,
+				() =>
+					warningService.emitPoorConcurrencyWarning(
+						poorConcurrencyNotice,
+					),
+			);
+		} else {
+			debug(`Linting in single-thread mode.`);
+			results = await lintFilesWithoutMultithreading(this, filePaths);
+		}
 
 		// Persist the cache to disk.
 		if (lintResultCache) {
@@ -866,9 +933,7 @@ class ESLint {
 
 		const finalResults = results.filter(result => !!result);
 
-		return processLintReport(this, {
-			results: finalResults,
-		});
+		return processLintReport(this, finalResults);
 	}
 
 	/**
@@ -977,9 +1042,7 @@ class ESLint {
 
 		debug(`Linting complete in: ${Date.now() - startTime}ms`);
 
-		return processLintReport(this, {
-			results,
-		});
+		return processLintReport(this, results);
 	}
 
 	/**
@@ -1089,7 +1152,7 @@ class ESLint {
 	 * This is the same logic used by the ESLint CLI executable to determine
 	 * configuration for each file it processes.
 	 * @param {string} filePath The path of the file to retrieve a config object for.
-	 * @returns {Promise<Config|undefined>} A configuration object for the file
+	 * @returns {Promise<CalculatedConfig|undefined>} A configuration object for the file
 	 *      or `undefined` if there is no configuration data for the object.
 	 */
 	async calculateConfigForFile(filePath) {
@@ -1161,4 +1224,5 @@ module.exports = {
 	ESLint,
 	shouldUseFlatConfig,
 	locateConfigFileToUse,
+	calculateWorkerCount,
 };