@isentinel/eslint-config 6.1.0 → 6.2.0

package/dist/lint-cli.mjs

@@ -1,13 +1,14 @@
 import { createRequire } from "node:module";
 import process$1 from "node:process";
 import { isPackageExists } from "local-pkg";
-import { Buffer as Buffer$1 } from "node:buffer";
-import fs from "node:fs/promises";
-import path from "node:path";
-import yargs from "yargs";
 import "find-up-simple";
-import fs$1 from "node:fs";
+import "jsonc-eslint-parser";
+import fs from "node:fs";
+import path from "node:path";
 import "semver";
+import { Buffer as Buffer$1 } from "node:buffer";
+import fs$1 from "node:fs/promises";
+import yargs from "yargs";
 import crypto from "node:crypto";
 import ansis from "ansis";
 import { KillOnSignal, LogError, LogExit, LogOutput, Logger, createConcurrently } from "concurrently";
@@ -41,7 +42,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 //#region package.json
-var version = "6.1.0";
+var version = "6.2.0";
 //#endregion
 //#region src/lint-cli/lib/cli/types.ts
 /**
@@ -51,78 +52,6 @@ var version = "6.1.0";
 var CliError = class extends Error {
 	name = "CliError";
 };
-//#endregion
-//#region src/lint-cli/lib/cli/file-list.ts
-/** The `--files0-from` value that names stdin rather than a file. */
-const STDIN_SOURCE = "-";
-/**
-* Split a NUL-delimited, UTF-8 path list (the `git ls-files -z` / `find
-* -print0` shape) into its paths.
-*
-* Every path is terminated by a NUL, though the last terminator may be left off
-* as GNU's own `--files0-from` allows. Nothing else is interpreted: spaces,
-* newlines, quotes, shell metacharacters and leading hyphens all stay part of
-* the name. The bytes must be valid UTF-8 — a lossy decode would lint a file
-* that is not the one selected — and no entry may be empty, since an empty
-* path is never a file and most likely a broken producer.
-*
-* @param bytes - The raw list.
-* @returns The paths, in list order. Empty for an empty list.
-*/
-function decodeFileList(bytes) {
-	const decoder = new TextDecoder("utf-8", {
-		fatal: true,
-		ignoreBOM: true
-	});
-	let text;
-	try {
-		text = decoder.decode(bytes);
-	} catch {
-		throw new CliError("--files0-from: the file list is not valid UTF-8.");
-	}
-	if (text.length === 0) return [];
-	const entries = text.split("\0");
-	if (entries.at(-1) === "") entries.pop();
-	const empty = entries.indexOf("");
-	if (empty !== -1) throw new CliError(`--files0-from: entry ${empty + 1} of the file list is empty; expected NUL-terminated paths.`);
-	return entries;
-}
-/**
-* Fill the run's paths from its `--files0-from` list, reading it once. Options
-* without a list are returned as they are.
-*
-* An empty list stays empty: the caller treats it as nothing to lint, and it
-* must never become the whole-tree default `.`.
-*
-* @param options - The parsed CLI options.
-* @param cwd - The directory a relative list path resolves against.
-* @param stdin - The stream `-` reads.
-* @returns The options with `paths` set from the list.
-* @rejects {CliError} When the list cannot be read or is malformed.
-*/
-async function readFileList(options, cwd, stdin) {
-	const source = options.filesFrom;
-	if (source === void 0) return options;
-	const bytes = source === STDIN_SOURCE ? await readAll(stdin) : await readFile(source, cwd);
-	return {
-		...options,
-		paths: decodeFileList(bytes)
-	};
-}
-async function readFile(source, cwd) {
-	try {
-		return await fs.readFile(path.resolve(cwd, source));
-	} catch (err) {
-		throw new CliError(`--files0-from: cannot read "${source}": ${err instanceof Error ? err.message : String(err)}`);
-	}
-}
-async function readAll(stream) {
-	const chunks = [];
-	for await (const chunk of stream) if (typeof chunk === "string") chunks.push(Buffer$1.from(chunk, "utf8"));
-	else if (chunk instanceof Uint8Array) chunks.push(Buffer$1.from(chunk));
-	else throw new CliError("--files0-from: stdin produced a non-byte chunk.");
-	return Buffer$1.concat(chunks);
-}
 /**
 * The real TS/JS-family file extensions {@link GLOB_SRC_EXT} encodes (the glob
 * additionally matches non-existent combinations such as `cjsx`). Kept next to
@@ -184,6 +113,10 @@ function isRecord(value) {
 function isStringArray(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+//#endregion
+//#region src/quiet-warnings.ts
+/** Set in an ESLint child that must not repeat the preset's config warnings. */
+const QUIET_WARNINGS_ENV = "ISENTINEL_QUIET_CONFIG_WARNINGS";
 createRequire(import.meta.url);
 /**
 * Whether the environment signals a CI run. Treats an unset, empty, `"false"`
@@ -302,6 +235,120 @@ function environmentMatcher(name, pattern, { noTty = false } = {}) {
 		return value !== void 0 && pattern.test(value);
 	};
 }
+/** JSON oxfmt config files oxfmt discovers. */
+const OXFMT_RC_FILES = [".oxfmtrc.json", ".oxfmtrc.jsonc"];
+/**
+* Oxfmt config modules oxfmt discovers. It loads other module extensions only
+* through `--config`, never by search.
+*/
+const OXFMT_CONFIG_MODULES = ["oxfmt.config.ts", "oxfmt.config.mts"];
+OXFMT_CONFIG_MODULES[0];
+/** Every file name oxfmt discovers. One directory may hold only one of them. */
+const OXFMT_CONFIG_NAMES = [...OXFMT_RC_FILES, ...OXFMT_CONFIG_MODULES];
+/**
+* List the oxfmt config files in one directory, without walking up.
+*
+* @param directory - Directory to check.
+* @returns The file names found, sorted.
+*/
+function oxfmtConfigNamesIn(directory) {
+	return OXFMT_CONFIG_NAMES.filter((name) => fs.existsSync(path.join(directory, name))).sort();
+}
+/**
+* Find the oxfmt config the way oxfmt does: walk up from `cwd` to the
+* filesystem root and take the first directory that holds one. Like oxfmt,
+* refuse a directory that holds more than one.
+*
+* @param cwd - Directory to start from.
+* @returns The config file, if any.
+* @throws When one directory holds more than one oxfmt config file.
+*/
+function findOxfmtConfig(cwd = process$1.cwd()) {
+	let directory = path.resolve(cwd);
+	for (;;) {
+		const [first, second] = oxfmtConfigNamesIn(directory);
+		if (second !== void 0) throw new Error(`[@isentinel/eslint-config] Both '${first}' and '${second}' found in ${directory}. Keep one oxfmt config file.`);
+		if (first !== void 0) return {
+			isModule: OXFMT_CONFIG_MODULES.some((name) => name === first),
+			path: path.join(directory, first)
+		};
+		const parent = path.dirname(directory);
+		if (parent === directory) return;
+		directory = parent;
+	}
+}
+//#endregion
+//#region src/lint-cli/lib/cli/file-list.ts
+/** The `--files0-from` value that names stdin rather than a file. */
+const STDIN_SOURCE = "-";
+/**
+* Split a NUL-delimited, UTF-8 path list (the `git ls-files -z` / `find
+* -print0` shape) into its paths.
+*
+* Every path is terminated by a NUL, though the last terminator may be left off
+* as GNU's own `--files0-from` allows. Nothing else is interpreted: spaces,
+* newlines, quotes, shell metacharacters and leading hyphens all stay part of
+* the name. The bytes must be valid UTF-8 — a lossy decode would lint a file
+* that is not the one selected — and no entry may be empty, since an empty
+* path is never a file and most likely a broken producer.
+*
+* @param bytes - The raw list.
+* @returns The paths, in list order. Empty for an empty list.
+*/
+function decodeFileList(bytes) {
+	const decoder = new TextDecoder("utf-8", {
+		fatal: true,
+		ignoreBOM: true
+	});
+	let text;
+	try {
+		text = decoder.decode(bytes);
+	} catch {
+		throw new CliError("--files0-from: the file list is not valid UTF-8.");
+	}
+	if (text.length === 0) return [];
+	const entries = text.split("\0");
+	if (entries.at(-1) === "") entries.pop();
+	const empty = entries.indexOf("");
+	if (empty !== -1) throw new CliError(`--files0-from: entry ${empty + 1} of the file list is empty; expected NUL-terminated paths.`);
+	return entries;
+}
+/**
+* Fill the run's paths from its `--files0-from` list, reading it once. Options
+* without a list are returned as they are.
+*
+* An empty list stays empty: the caller treats it as nothing to lint, and it
+* must never become the whole-tree default `.`.
+*
+* @param options - The parsed CLI options.
+* @param cwd - The directory a relative list path resolves against.
+* @param stdin - The stream `-` reads.
+* @returns The options with `paths` set from the list.
+* @rejects {CliError} When the list cannot be read or is malformed.
+*/
+async function readFileList(options, cwd, stdin) {
+	const source = options.filesFrom;
+	if (source === void 0) return options;
+	const bytes = source === STDIN_SOURCE ? await readAll(stdin) : await readFile(source, cwd);
+	return {
+		...options,
+		paths: decodeFileList(bytes)
+	};
+}
+async function readFile(source, cwd) {
+	try {
+		return await fs$1.readFile(path.resolve(cwd, source));
+	} catch (err) {
+		throw new CliError(`--files0-from: cannot read "${source}": ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+async function readAll(stream) {
+	const chunks = [];
+	for await (const chunk of stream) if (typeof chunk === "string") chunks.push(Buffer$1.from(chunk, "utf8"));
+	else if (chunk instanceof Uint8Array) chunks.push(Buffer$1.from(chunk));
+	else throw new CliError("--files0-from: stdin produced a non-byte chunk.");
+	return Buffer$1.concat(chunks);
+}
 //#endregion
 //#region src/lint-cli/lib/cli/parse.ts
 /**
@@ -413,6 +460,10 @@ function parseArguments(argv, environment = process$1.env) {
 		default: true,
 		description: "Use ESLint's on-disk cache.",
 		type: "boolean"
+	}).option("oxfmt", {
+		default: true,
+		description: "Run oxfmt when an oxfmt.config.* file exists.",
+		type: "boolean"
 	}).option("oxlint-type-aware", {
 		default: true,
 		description: "Pass --type-aware to oxlint.",
@@ -457,6 +508,7 @@ function parseArguments(argv, environment = process$1.env) {
 		eslintArgs,
 		filesFrom,
 		fix,
+		oxfmt: parsed.oxfmt,
 		oxlint: oxlintOnly,
 		oxlintArgs,
 		oxlintTypeAware: parsed.oxlintTypeAware,
@@ -793,7 +845,7 @@ function statePath(cwd, name, ...parts) {
 */
 function readFileIfPresent(filePath) {
 	try {
-		return fs$1.readFileSync(filePath, "utf8");
+		return fs.readFileSync(filePath, "utf8");
 	} catch {
 		return;
 	}
@@ -834,12 +886,12 @@ function writeState(filePath, data) {
 	})}\n`;
 	const temporary = `${filePath}.${process$1.pid}.tmp`;
 	try {
-		fs$1.mkdirSync(path.dirname(filePath), { recursive: true });
-		fs$1.writeFileSync(temporary, content);
-		fs$1.renameSync(temporary, filePath);
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.writeFileSync(temporary, content);
+		fs.renameSync(temporary, filePath);
 	} catch {
 		try {
-			fs$1.rmSync(temporary, { force: true });
+			fs.rmSync(temporary, { force: true });
 		} catch {}
 	}
 }
@@ -874,7 +926,7 @@ function swapState(filePath, value) {
 function touchState(filePath) {
 	try {
 		const now = Date.now() / 1e3;
-		fs$1.utimesSync(filePath, now, now);
+		fs.utimesSync(filePath, now, now);
 	} catch {}
 }
 /**
@@ -967,7 +1019,7 @@ function resolveAgentsFormatter() {
 */
 function resolveIgnoredHelper() {
 	const built = fileURLToPath(new URL("./lint-ignored.mjs", import.meta.url));
-	return fs$1.existsSync(built) ? built : fileURLToPath(new URL("../../ignored-child.ts", import.meta.url));
+	return fs.existsSync(built) ? built : fileURLToPath(new URL("../../ignored-child.ts", import.meta.url));
 }
 /**
 * Resolve the engine bootstrap shipped alongside this entry (built from
@@ -983,7 +1035,7 @@ function resolveIgnoredHelper() {
 */
 function resolveBootstrap() {
 	const built = fileURLToPath(new URL("./lint-bootstrap.mjs", import.meta.url));
-	return fs$1.existsSync(built) ? built : fileURLToPath(new URL("../../bootstrap.ts", import.meta.url));
+	return fs.existsSync(built) ? built : fileURLToPath(new URL("../../bootstrap.ts", import.meta.url));
 }
 /**
 * The path a package's manifest declares as the bin of the package's own name,
@@ -1062,6 +1114,7 @@ const PREFIX_COLOR = {
 	eslint: "blue",
 	fast: "blue",
 	oxc: "magenta",
+	oxfmt: "yellow",
 	typed: "cyan"
 };
 /**
@@ -1482,6 +1535,35 @@ function composeOxlintCommand(options, context) {
 	};
 }
 /**
+* Compose the oxfmt child command. Oxfmt receives the run's own targets and
+* applies its config's `ignorePatterns` to them, so a whole-tree run passes
+* `.` and lets oxfmt walk the tree itself. Like every engine child it is
+* launched through the bootstrap, so a long file list never reaches the OS
+* command line..
+*
+* @param options - The parsed CLI options.
+* @param context - The child's settings.
+* @param context.configPath - The config module, passed as `--config` so oxfmt
+*   uses the file the lint factories read.
+* @param context.write - Format the files in place rather than check them.
+* @returns The oxfmt child command.
+*/
+function composeOxfmtCommand(options, { configPath, write }) {
+	return {
+		args: [
+			write ? "--write" : "--check",
+			"--config",
+			configPath,
+			"--no-error-on-unmatched-pattern",
+			...pathArguments(options.paths)
+		],
+		bin: "oxfmt",
+		env: {},
+		label: "oxfmt",
+		watchHeap: false
+	};
+}
+/**
 * Compose the ESLint child command.
 *
 * @param options - The parsed CLI options.
@@ -1497,6 +1579,7 @@ function composeEslintCommand(options, context) {
 	if (context.fix) args.push("--fix");
 	args.push(...options.eslintArgs, ...pathArguments(context.paths));
 	const environment = { ESLINT_TYPE_AWARE: context.typeAwareEnv };
+	if (context.quietWarnings === true) environment[QUIET_WARNINGS_ENV] = "1";
 	if (context.heap?.nodeOptions !== void 0) environment["NODE_OPTIONS"] = context.heap.nodeOptions;
 	return {
 		args,
@@ -1553,6 +1636,7 @@ function composePasses(passes, runPlan, options) {
 			fix: false,
 			heap: pass.heap,
 			paths: options.paths,
+			quietWarnings: commands.length > 0,
 			typeAwareEnv: pass.descriptor.typeAwareEnv
 		}));
 	}
@@ -1686,7 +1770,7 @@ function applyHashBust(run, bust, hash) {
 	const cleared = [];
 	for (const base of bust.caches) {
 		const cacheFilePath = path.resolve(run.cwd, cacheFileFor(base, run.key));
-		fs$1.rmSync(cacheFilePath, { force: true });
+		fs.rmSync(cacheFilePath, { force: true });
 		cleared.push(cacheFilePath);
 	}
 	return {
@@ -1963,7 +2047,7 @@ function normalizePath(filePath, platform = process$1.platform) {
 * @returns The loaded cache, or `undefined` when the file does not exist.
 */
 function openCache(cacheFilePath, useChecksum) {
-	if (!fs$1.existsSync(cacheFilePath)) return;
+	if (!fs.existsSync(cacheFilePath)) return;
 	const cache = load(cacheFilePath, useChecksum);
 	return {
 		filesWithMessages: (files) => filesWithMessagesIn(cache, files),
@@ -1973,7 +2057,7 @@ function openCache(cacheFilePath, useChecksum) {
 }
 function safeMtimeMs(filePath) {
 	try {
-		return fs$1.statSync(filePath).mtimeMs;
+		return fs.statSync(filePath).mtimeMs;
 	} catch {
 		return;
 	}
@@ -1990,7 +2074,7 @@ function safeMtimeMs(filePath) {
 function listCacheFiles(cwd) {
 	let entries;
 	try {
-		entries = fs$1.readdirSync(cwd);
+		entries = fs.readdirSync(cwd);
 	} catch {
 		return [];
 	}
@@ -1998,7 +2082,7 @@ function listCacheFiles(cwd) {
 }
 function removeCacheFile(cacheFilePath) {
 	try {
-		fs$1.rmSync(cacheFilePath, { force: true });
+		fs.rmSync(cacheFilePath, { force: true });
 	} catch {}
 }
 /**
@@ -4007,7 +4091,7 @@ const WALK_BUDGET = 8192;
 function findWorkspaceRoot(cwd) {
 	let current = cwd;
 	for (;;) {
-		for (const marker of WORKSPACE_ROOT_MARKERS) if (fs$1.existsSync(path.join(current, marker))) return current;
+		for (const marker of WORKSPACE_ROOT_MARKERS) if (fs.existsSync(path.join(current, marker))) return current;
 		const parent = path.dirname(current);
 		if (parent === current) return cwd;
 		current = parent;
@@ -4051,7 +4135,7 @@ function findWorkspaceMembers(root) {
 	function walk(directory, depth) {
 		let entries;
 		try {
-			entries = fs$1.readdirSync(directory, { withFileTypes: true });
+			entries = fs.readdirSync(directory, { withFileTypes: true });
 		} catch {
 			return true;
 		}
@@ -4061,7 +4145,7 @@ function findWorkspaceMembers(root) {
 			if (budget < 0) return false;
 			const absolute = path.join(directory, entry.name);
 			const relative = toPosix(path.relative(root, absolute));
-			if (isMember(relative) && fs$1.existsSync(path.join(absolute, "package.json"))) members.push(absolute);
+			if (isMember(relative) && fs.existsSync(path.join(absolute, "package.json"))) members.push(absolute);
 			if (depth < maxDepth && !walk(absolute, depth + 1)) return false;
 		}
 		return true;
@@ -4279,6 +4363,8 @@ const CACHE_BUST_PATTERNS = [
 	"*.config.*",
 	"**/tsconfig*.json",
 	".oxlintrc*",
+	".oxfmtrc*",
+	"oxfmt.config.*",
 	".prettierrc*",
 	"pnpm-lock.yaml",
 	"package-lock.json",
@@ -4389,7 +4475,7 @@ function oxlintTargets(cwd, targets) {
 		const extension = path.extname(target).toLowerCase();
 		if (extension === "" || TYPE_AWARE_EXTENSION_SET.has(extension)) return true;
 		try {
-			return fs$1.statSync(path.resolve(cwd, target)).isDirectory();
+			return fs.statSync(path.resolve(cwd, target)).isDirectory();
 		} catch {
 			return false;
 		}
@@ -4426,7 +4512,7 @@ function collectAncestorBustFiles(cwd) {
 	for (;;) {
 		let entries = [];
 		try {
-			entries = fs$1.readdirSync(current, { withFileTypes: true });
+			entries = fs.readdirSync(current, { withFileTypes: true });
 		} catch {
 			entries = [];
 		}
@@ -4515,7 +4601,7 @@ function gitListFiles(cwd, pathSpecs) {
 function walkDirectory(root, current, accumulator) {
 	let entries;
 	try {
-		entries = fs$1.readdirSync(current, { withFileTypes: true });
+		entries = fs.readdirSync(current, { withFileTypes: true });
 	} catch {
 		return;
 	}
@@ -4534,7 +4620,7 @@ function walkFallback(cwd, targets) {
 		const absolute = path.resolve(cwd, target);
 		let stat;
 		try {
-			stat = fs$1.statSync(absolute);
+			stat = fs.statSync(absolute);
 		} catch {
 			continue;
 		}
@@ -4859,7 +4945,7 @@ function queryIgnoredFiles(cwd, targets) {
 				"ignore"
 			]
 		});
-		const parsed = JSON.parse(fs$1.readFileSync(outFile, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(outFile, "utf8"));
 		if (!isRecord(parsed)) return;
 		const { basePath, entries, ignored, mode } = parsed;
 		if (mode === "answers" && isStringArray(ignored)) return {
@@ -4875,7 +4961,7 @@ function queryIgnoredFiles(cwd, targets) {
 	} catch {
 		return;
 	} finally {
-		fs$1.rmSync(outFile, { force: true });
+		fs.rmSync(outFile, { force: true });
 	}
 }
 //#endregion
@@ -4918,7 +5004,7 @@ function readHybridStatus(cwd) {
 function writeHybridStatus(cwd, oxlint) {
 	let installed;
 	try {
-		installed = fs$1.existsSync(path.resolve(cwd, "node_modules"));
+		installed = fs.existsSync(path.resolve(cwd, "node_modules"));
 	} catch {
 		return;
 	}
@@ -5100,7 +5186,7 @@ function resolveWorkerLimits(environment, availableParallelism, ci) {
 		explicitMaxWorkers: explicit !== void 0,
 		filesPerWorker,
 		maxWorkers,
-		typedMaxWorkers: explicit ?? Math.min(maxWorkers, 6)
+		typedMaxWorkers: explicit ?? Math.min(maxWorkers, 5)
 	};
 }
 /**
@@ -5303,6 +5389,7 @@ function planFixChild(passes, run, inputs) {
 			dirtyCount: targets.length
 		}),
 		paths: targets,
+		quietWarnings: true,
 		typeAwareEnv: FULL_PASS.typeAwareEnv
 	});
 }
@@ -5638,7 +5725,7 @@ function computeAffectedFiles({ key, cwd }, mode) {
 			if (entryReadable) warnOnce(`no TypeScript files resolved from ${path.basename(configPath)}; skipping type-aware cache invalidation`);
 			return;
 		}
-		fs$1.mkdirSync(stateDirectory(cwd), { recursive: true });
+		fs.mkdirSync(stateDirectory(cwd), { recursive: true });
 		const resolutionGate = computeResolutionGate(cwd);
 		const affected = /* @__PURE__ */ new Set();
 		let warmProjects = 0;
@@ -5685,7 +5772,7 @@ function computeAffectedFiles({ key, cwd }, mode) {
 function hasBuilderState({ key, cwd }, mode) {
 	const prefix = `${path.basename(statePath(cwd, BUILD_INFO_STATE, modeSuffix(mode), key))}-`;
 	try {
-		return fs$1.readdirSync(stateDirectory(cwd)).some((name) => name.startsWith(prefix) && !name.endsWith(".tmp"));
+		return fs.readdirSync(stateDirectory(cwd)).some((name) => name.startsWith(prefix) && !name.endsWith(".tmp"));
 	} catch {
 		return false;
 	}
@@ -5900,10 +5987,10 @@ function persistBuilderState(builder, buildInfoPath) {
 		if (path.normalize(fileName) !== normalizedBuildInfo) return;
 		const temporary = `${fileName}.${process$1.pid}.tmp`;
 		try {
-			fs$1.writeFileSync(temporary, data);
-			fs$1.renameSync(temporary, fileName);
+			fs.writeFileSync(temporary, data);
+			fs.renameSync(temporary, fileName);
 		} catch (err) {
-			fs$1.rmSync(temporary, { force: true });
+			fs.rmSync(temporary, { force: true });
 			throw err;
 		}
 	});
@@ -5918,7 +6005,7 @@ function persistBuilderState(builder, buildInfoPath) {
 */
 function writeGateState(gatePath, gateValue) {
 	if (gateValue === void 0) {
-		fs$1.rmSync(gatePath, { force: true });
+		fs.rmSync(gatePath, { force: true });
 		return;
 	}
 	writeState(gatePath, gateValue);
@@ -5939,7 +6026,7 @@ function writeGateState(gatePath, gateValue) {
 * @returns The affected result.
 */
 function runBuilder({ buildInfoPath, gatePath, project, resolutionGate, ts }) {
-	const firstRun = !fs$1.existsSync(buildInfoPath);
+	const firstRun = !fs.existsSync(buildInfoPath);
 	const options = {
 		...project.options,
 		composite: false,
@@ -6022,7 +6109,7 @@ function applyTypeAwareInvalidation(run, { alreadyDirty, cache, cacheLocation, m
 	}
 	const threshold = resolveAffectedBustThreshold(run.environment);
 	if (affectedTargets.length > threshold) {
-		fs$1.rmSync(cacheLocation, { force: true });
+		fs.rmSync(cacheLocation, { force: true });
 		return {
 			busted: true,
 			firstRun: false,
@@ -6332,21 +6419,51 @@ async function runLint(argv, cwd = process$1.cwd(), environment = process$1.env,
 	if (options.paths.length === 0) return 0;
 	const staged = plan(options, resolveRunContext(cwd, environment, !options.print));
 	const { commands, notice } = compose(staged.eager, options);
+	const oxfmtConfig = findOxfmtModule(options, cwd);
+	const formatCommand = oxfmtConfig === void 0 ? void 0 : composeOxfmtCommand(options, {
+		configPath: oxfmtConfig,
+		write: options.fix
+	});
 	if (options.print) {
-		for (const command of commands) process$1.stdout.write(`${formatCommandLine(command)}\n`);
+		const printed = formatCommand === void 0 ? commands : [...commands, formatCommand];
+		for (const command of printed) process$1.stdout.write(`${formatCommandLine(command)}\n`);
 		for (const pass of staged.eager.passes) if (pass.shouldRun && pass.heap !== void 0) process$1.stderr.write(pass.heap.note);
 		return 0;
 	}
 	if (commands.some((command) => command.bin === "oxlint" && command.args.includes("--type-aware")) && !isPackageExists("oxlint-tsgolint", { paths: [cwd] })) throw new CliError("oxlint-tsgolint is not installed, so oxlint cannot run type-aware rules. Install oxlint-tsgolint, or pass --no-oxlint-type-aware to skip type-aware linting.");
+	if (formatCommand !== void 0 && !isPackageExists("oxfmt", { paths: [cwd] })) throw new CliError("oxfmt is not installed, but this project has an `oxfmt.config.*` file. Install oxfmt, or pass --no-oxfmt to skip formatting.");
 	if (notice !== void 0) process$1.stderr.write(notice);
 	const { resolveFixChild } = staged;
-	if (resolveFixChild === void 0) return (await runChecks(commands, cwd, staged, options)).code;
+	if (resolveFixChild === void 0) return (await runChecks(formatCommand === void 0 ? commands : [...commands, formatCommand], cwd, staged, options)).code;
 	const byBin = Object.groupBy(commands, (command) => command.bin);
 	const oxlintCode = await execute(byBin.oxlint ?? [], cwd, true);
 	const checks = await runChecks(byBin.eslint ?? [], cwd, staged, options);
 	const fixChild = resolveFixChild(checks.passes);
-	if (fixChild === void 0) return oxlintCode || checks.code;
-	return oxlintCode || await execute([fixChild], cwd, true);
+	const lintCode = fixChild === void 0 ? oxlintCode || checks.code : oxlintCode || await execute([fixChild], cwd, true);
+	if (formatCommand === void 0) return lintCode;
+	const formatCode = await execute([formatCommand], cwd, true);
+	return lintCode || formatCode;
+}
+/**
+* The oxfmt config module the run formats with. The oxfmt pass is on when the
+* project runs oxfmt as its own tool (an `oxfmt.config.ts` or
+* `oxfmt.config.mts`, found the way oxfmt finds it), unless `--no-oxfmt` or a
+* single-engine flag (`--eslint`, `--oxlint`) says otherwise.
+*
+* @param options - The parsed CLI options.
+* @param cwd - The working directory.
+* @returns The config module path, or `undefined` to skip the pass.
+* @throws {CliError} When one directory holds more than one oxfmt config.
+*/
+function findOxfmtModule(options, cwd) {
+	if (!options.oxfmt || options.eslint || options.oxlint) return;
+	let config;
+	try {
+		config = findOxfmtConfig(cwd);
+	} catch (err) {
+		throw new CliError(err instanceof Error ? err.message : String(err));
+	}
+	return config?.isModule === true ? config.path : void 0;
 }
 /**
 * Run a run's ESLint check children and report which passes they covered.
@@ -6393,6 +6510,9 @@ Flags:
   --oxlint                 Run only oxlint.
   --fix                    Check as usual, then fix only the files the checks
                            reported, in one further ESLint child.
+  --no-oxfmt               Skip the oxfmt pass. It runs when the project has an
+                           oxfmt.config.* file: oxfmt --check alongside the
+                           linters, or oxfmt --write last with --fix.
   --agents, --no-agents    Emit agent-friendly output. On by default when an AI
                            agent session is detected (AI_AGENT, CLAUDECODE, ...).
   --type-aware=off|only|full