@isentinel/eslint-config 6.0.1 → 6.2.0

package/dist/lint-cli.mjs

@@ -1,19 +1,21 @@
 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";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import os, { availableParallelism } from "node:os";
 import { Writable } from "node:stream";
+import v8 from "node:v8";
 import { fileURLToPath } from "node:url";
 import fileEntryCache from "file-entry-cache";
 //#region \0rolldown/runtime.js
@@ -40,7 +42,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 //#region package.json
-var version = "6.0.1";
+var version = "6.2.0";
 //#endregion
 //#region src/lint-cli/lib/cli/types.ts
 /**
@@ -50,78 +52,6 @@ var version = "6.0.1";
 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
@@ -183,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"`
@@ -301,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
 /**
@@ -412,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.",
@@ -456,6 +508,7 @@ function parseArguments(argv, environment = process$1.env) {
 		eslintArgs,
 		filesFrom,
 		fix,
+		oxfmt: parsed.oxfmt,
 		oxlint: oxlintOnly,
 		oxlintArgs,
 		oxlintTypeAware: parsed.oxlintTypeAware,
@@ -570,6 +623,188 @@ function resolveRunContext(cwd, environment, mutate) {
 	};
 }
 //#endregion
+//#region src/lint-cli/lib/plan/heap.ts
+/**
+* Environment variable that sets the heap of a program-building ESLint child.
+*/
+const HEAP_ENV = "LINT_TYPED_HEAP_MB";
+/**
+* Share of the machine's memory the program-building workers may claim between
+* them. The rest is left for the oxlint child, the fast pass, the editor and
+* the OS, all of which run alongside the type-aware pass locally.
+*/
+const HEAP_BUDGET_SHARE = .5;
+const BYTES_PER_MB = 1024 * 1024;
+const MAX_OLD_SPACE = /--max[-_]old[-_]space[-_]size\b/;
+/**
+* Read the machine's memory facts.
+*
+* @returns The available memory and V8's default heap limit, in MB.
+*/
+function probeMemory() {
+	const total = os.totalmem();
+	const constrained = process$1.constrainedMemory();
+	return {
+		availableMb: Math.floor((constrained > 0 ? Math.min(total, constrained) : total) / BYTES_PER_MB),
+		defaultHeapMb: Math.floor(v8.getHeapStatistics().heap_size_limit / BYTES_PER_MB)
+	};
+}
+/**
+* Resolve the heap setting from the environment. An invalid {@link HEAP_ENV}
+* falls back to `auto`, as the other numeric knobs fall back to their
+* defaults.
+*
+* @param environment - Where {@link HEAP_ENV} and `NODE_OPTIONS` are read.
+* @returns Which of the four modes applies, with its size when fixed.
+*/
+function resolveHeapSetting(environment) {
+	if (MAX_OLD_SPACE.test(environment["NODE_OPTIONS"] ?? "")) return { kind: "inherited" };
+	const raw = environment[HEAP_ENV]?.trim();
+	if (raw === "off") return { kind: "off" };
+	const mb = parseBoundedInteger(raw, 1);
+	return mb === void 0 ? { kind: "auto" } : {
+		kind: "fixed",
+		mb
+	};
+}
+/**
+* The memory all program-building workers may claim together, in MB.
+*
+* @param memory - What the machine offers.
+* @returns The budget share of the available memory, in MB.
+*/
+function heapBudgetMb(memory) {
+	return Math.floor(memory.availableMb * HEAP_BUDGET_SHARE);
+}
+/**
+* The most program-building workers the budget can hold, or `undefined` when
+* the setting places no limit. Each worker is counted at the heap it may grow
+* to: the requested size, or {@link AUTO_HEAP_FLOOR} times Node's default
+* under `auto`. Never below one.
+*
+* @param budget - The setting and the machine it applies to.
+* @returns How many workers fit, if the setting limits them.
+*/
+function heapWorkerCap({ memory, setting }) {
+	if (setting.kind !== "auto" && setting.kind !== "fixed") return;
+	const perWorker = setting.kind === "fixed" ? setting.mb : memory.defaultHeapMb * 2;
+	return Math.max(1, Math.floor(heapBudgetMb(memory) / perWorker));
+}
+/**
+* The heap each worker of a program-building pass gets, or `undefined` for
+* Node's default. `auto` splits the budget across the workers and only raises
+* the limit: a share below the default adds no flag.
+*
+* @param budget - The setting and the machine it applies to.
+* @param concurrency - The pass's resolved concurrency (`off` lints on the
+*   main thread, which is one heap).
+* @returns The size in MB to pass to Node, if it should change.
+*/
+function heapPerWorkerMb({ memory, setting }, concurrency) {
+	if (setting.kind === "fixed") return setting.mb;
+	if (setting.kind !== "auto") return;
+	const share = Math.floor(heapBudgetMb(memory) / workerCount(concurrency));
+	return share > memory.defaultHeapMb ? share : void 0;
+}
+/**
+* Pair the run's heap setting with the machine it applies to.
+*
+* @param environment - Where {@link HEAP_ENV} and `NODE_OPTIONS` are read.
+* @param memory - What the machine offers.
+* @returns Everything sizing needs to give a program-building pass its heap.
+*/
+function resolveHeapBudget(environment, memory) {
+	return {
+		memory,
+		nodeOptions: environment["NODE_OPTIONS"],
+		setting: resolveHeapSetting(environment)
+	};
+}
+/**
+* The worker cap of a program-building pass once the heap budget is applied.
+* An explicit `LINT_MAX_WORKERS` is never tightened.
+*
+* @param maxWorkers - The pass's cap before the budget.
+* @param explicit - Whether `LINT_MAX_WORKERS` set that cap.
+* @param budget - The setting and the machine it applies to.
+* @returns The cap to size the pass against.
+*/
+function capWorkersForHeap(maxWorkers, explicit, budget) {
+	const cap = explicit ? void 0 : heapWorkerCap(budget);
+	return cap === void 0 ? maxWorkers : Math.min(maxWorkers, cap);
+}
+/**
+* Plan the heap of one program-building child from its sizing.
+*
+* @param label - The child's label, for the `--print` line.
+* @param budget - The setting and the machine it applies to.
+* @param sizing - The child's concurrency and file count.
+* @returns Its `NODE_OPTIONS`, its `--print` line and whether it is watched.
+*/
+function planPassHeap(label, budget, sizing) {
+	const heapMb = heapPerWorkerMb(budget, sizing.concurrency);
+	return {
+		nodeOptions: heapNodeOptions(budget, heapMb),
+		note: describeHeapPlan(label, budget, sizing, heapMb),
+		watch: budget.setting.kind !== "off"
+	};
+}
+/**
+* The number of heaps a concurrency value runs: `off` lints on the main
+* thread, which is one.
+*
+* @param concurrency - A resolved ESLint concurrency.
+* @returns How many threads lint.
+*/
+function workerCount(concurrency) {
+	return concurrency === "off" ? 1 : concurrency;
+}
+/**
+* The `NODE_OPTIONS` a program-building child runs under: the inherited value
+* with the heap flag appended. Node's `worker_threads` take their heap limit
+* from `--max-old-space-size` when it is set, so this one flag reaches every
+* ESLint worker.
+*
+* @param budget - Carries the inherited `NODE_OPTIONS`.
+* @param heapMb - The size in MB for each worker, if it should change.
+* @returns The value to set, or `undefined` to leave `NODE_OPTIONS` alone.
+*/
+function heapNodeOptions({ nodeOptions }, heapMb) {
+	if (heapMb === void 0) return;
+	const flag = `--max-old-space-size=${String(heapMb)}`;
+	const inherited = nodeOptions?.trim() ?? "";
+	return inherited.length > 0 ? `${inherited} ${flag}` : flag;
+}
+/**
+* How the `--print` line names a heap the runner left alone.
+*
+* @param budget - Says whether the user's `NODE_OPTIONS` set it.
+* @returns The user's heap, or Node's default with its size.
+*/
+function unchangedHeap({ memory, setting }) {
+	return setting.kind === "inherited" ? "the NODE_OPTIONS heap" : `Node's default heap (${String(memory.defaultHeapMb)} MB)`;
+}
+/**
+* Describe the memory plan of a program-building pass for `--print`.
+*
+* @param label - The pass's child label.
+* @param budget - The setting and the machine it applies to.
+* @param sizing - The pass's concurrency and file count.
+* @param heapMb - The size given to each worker, if it changed.
+* @returns One stderr line naming the workers, files per worker and heap.
+*/
+function describeHeapPlan(label, budget, { concurrency, dirtyCount }, heapMb) {
+	const workers = workerCount(concurrency);
+	const heap = heapMb === void 0 ? unchangedHeap(budget) : `${String(heapMb)} MB heap`;
+	const source = {
+		auto: `auto, budget ${String(heapBudgetMb(budget.memory))} MB`,
+		fixed: HEAP_ENV,
+		inherited: "NODE_OPTIONS",
+		off: `${HEAP_ENV}=off`
+	}[budget.setting.kind];
+	return `isentinel-lint: ${label} pass: ${String(workers)} worker(s), ~${String(Math.ceil(dirtyCount / workers))} files per worker, ${heap} per worker (${source}).\n`;
+}
+//#endregion
 //#region src/lint-cli/lib/state.ts
 /**
 * Directory (relative to the project root) where the CLI keeps its persisted
@@ -610,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;
 	}
@@ -651,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 {}
 	}
 }
@@ -691,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 {}
 }
 /**
@@ -784,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
@@ -800,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,
@@ -848,6 +1083,11 @@ function resolveManifest(name, cwd) {
 }
 //#endregion
 //#region src/lint-cli/lib/exec/execute.ts
+/**
+* What V8 writes when a heap fills: `ERR_WORKER_OUT_OF_MEMORY` from a worker,
+* `JavaScript heap out of memory` from the main thread.
+*/
+const OUT_OF_MEMORY = /ERR_WORKER_OUT_OF_MEMORY|heap out of memory/;
 /** The signals that cancel a run, matching `concurrently`'s `KillOnSignal`. */
 const CANCEL_SIGNALS = [
 	"SIGHUP",
@@ -874,9 +1114,21 @@ const PREFIX_COLOR = {
 	eslint: "blue",
 	fast: "blue",
 	oxc: "magenta",
+	oxfmt: "yellow",
 	typed: "cyan"
 };
 /**
+* The hint printed after a program-building child ran out of heap, below the
+* engine's own stack trace.
+*
+* @param label - The child's label.
+* @returns One stderr line.
+*/
+function outOfMemoryHint(label) {
+	return `isentinel-lint: the ${label} ESLint pass ran out of memory. Set ${HEAP_ENV}=<mb> to give each worker more heap; the runner starts fewer workers to keep them in budget.
+`;
+}
+/**
 * Run the composed children and aggregate their exit codes.
 *
 * Sequential when the caller asks for it: a lone child gains nothing from the
@@ -1045,6 +1297,27 @@ function trackCancellation(onSignal) {
 	};
 }
 /**
+* Watch a child's stderr for V8's out-of-memory report. Reads alongside
+* whatever else consumes the stream, and never alters it.
+*
+* @param child - The spawned child.
+* @param onExhausted - Called once, when the report is seen.
+*/
+function watchOutOfMemory(child, onExhausted) {
+	let tail = "";
+	let seen = false;
+	child.stderr?.on("data", (chunk) => {
+		if (seen) return;
+		const text = tail + String(chunk);
+		if (OUT_OF_MEMORY.test(text)) {
+			seen = true;
+			onExhausted();
+			return;
+		}
+		tail = text.slice(-64);
+	});
+}
+/**
 * Start every command as one `concurrently` group and announce the children.
 * Unlike the previous `killOthersOn: ["failure"]` behaviour, an ordinary lint
 * failure in one child no longer kills its siblings — each runs to the end so
@@ -1075,6 +1348,7 @@ async function startGroup(commands, cwd, outputStream = process$1.stdout) {
 		}];
 	}));
 	const logger = new Logger({});
+	const exhausted = /* @__PURE__ */ new Set();
 	const abortController = new AbortController();
 	const stopTracking = trackCancellation();
 	const { result } = createConcurrently(Array.from(launches, ([name, { command }]) => {
@@ -1103,7 +1377,11 @@ async function startGroup(commands, cwd, outputStream = process$1.stdout) {
 		spawn: (name, options) => {
 			const launch = launches.get(name);
 			if (launch === void 0) throw new Error(`isentinel-lint: no engine registered as "${name}".`);
-			return launchEngine(launch, options);
+			const child = launchEngine(launch, options);
+			if (launch.command.watchHeap) watchOutOfMemory(child, () => {
+				exhausted.add(launch.command.label);
+			});
+			return child;
 		}
 	});
 	for (const command of commands) announce(command);
@@ -1114,6 +1392,7 @@ async function startGroup(commands, cwd, outputStream = process$1.stdout) {
 		return 1;
 	} finally {
 		stopTracking();
+		for (const label of exhausted) process$1.stderr.write(outOfMemoryHint(label));
 	}
 }
 function signalExitCode(signal) {
@@ -1130,6 +1409,8 @@ function cancelledCode() {
 }
 async function spawnChild(command, cwd) {
 	const bin = resolveLocalBin(command.bin, cwd);
+	const watched = command.watchHeap;
+	let exhausted = false;
 	return new Promise((resolve) => {
 		const child = launchEngine({
 			bin,
@@ -1140,8 +1421,20 @@ async function spawnChild(command, cwd) {
 				...process$1.env,
 				...command.env
 			},
-			stdio: "inherit"
+			stdio: [
+				"inherit",
+				"inherit",
+				watched ? "pipe" : "inherit"
+			]
 		});
+		if (watched) {
+			child.stderr?.on("data", (chunk) => {
+				process$1.stderr.write(chunk);
+			});
+			watchOutOfMemory(child, () => {
+				exhausted = true;
+			});
+		}
 		announce(command);
 		const stopTracking = trackCancellation((signal) => {
 			child.kill(signal);
@@ -1152,6 +1445,7 @@ async function spawnChild(command, cwd) {
 		});
 		child.on("close", (code, signal) => {
 			stopTracking();
+			if (exhausted) process$1.stderr.write(outOfMemoryHint(command.label));
 			resolve(code ?? (signal === null ? 1 : signalExitCode(signal)));
 		});
 	});
@@ -1236,7 +1530,37 @@ function composeOxlintCommand(options, context) {
 		args,
 		bin: "oxlint",
 		env: {},
-		label: "oxc"
+		label: "oxc",
+		watchHeap: false
+	};
+}
+/**
+* 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
 	};
 }
 /**
@@ -1254,11 +1578,15 @@ function composeEslintCommand(options, context) {
 	if (options.agents) args.push("--format", context.agentsFormatterPath);
 	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,
 		bin: "eslint",
-		env: { ESLINT_TYPE_AWARE: context.typeAwareEnv },
-		label: context.eslintLabel
+		env: environment,
+		label: context.eslintLabel,
+		watchHeap: context.heap?.watch ?? false
 	};
 }
 /**
@@ -1306,7 +1634,9 @@ function composePasses(passes, runPlan, options) {
 			concurrency: pass.concurrency,
 			eslintLabel: pass.descriptor.label,
 			fix: false,
+			heap: pass.heap,
 			paths: options.paths,
+			quietWarnings: commands.length > 0,
 			typeAwareEnv: pass.descriptor.typeAwareEnv
 		}));
 	}
@@ -1440,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 {
@@ -1717,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),
@@ -1727,7 +2057,7 @@ function openCache(cacheFilePath, useChecksum) {
 }
 function safeMtimeMs(filePath) {
 	try {
-		return fs$1.statSync(filePath).mtimeMs;
+		return fs.statSync(filePath).mtimeMs;
 	} catch {
 		return;
 	}
@@ -1744,7 +2074,7 @@ function safeMtimeMs(filePath) {
 function listCacheFiles(cwd) {
 	let entries;
 	try {
-		entries = fs$1.readdirSync(cwd);
+		entries = fs.readdirSync(cwd);
 	} catch {
 		return [];
 	}
@@ -1752,7 +2082,7 @@ function listCacheFiles(cwd) {
 }
 function removeCacheFile(cacheFilePath) {
 	try {
-		fs$1.rmSync(cacheFilePath, { force: true });
+		fs.rmSync(cacheFilePath, { force: true });
 	} catch {}
 }
 /**
@@ -3761,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;
@@ -3805,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;
 		}
@@ -3815,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;
@@ -4033,6 +4363,8 @@ const CACHE_BUST_PATTERNS = [
 	"*.config.*",
 	"**/tsconfig*.json",
 	".oxlintrc*",
+	".oxfmtrc*",
+	"oxfmt.config.*",
 	".prettierrc*",
 	"pnpm-lock.yaml",
 	"package-lock.json",
@@ -4143,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;
 		}
@@ -4180,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 = [];
 		}
@@ -4269,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;
 	}
@@ -4288,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;
 		}
@@ -4613,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 {
@@ -4629,7 +4961,7 @@ function queryIgnoredFiles(cwd, targets) {
 	} catch {
 		return;
 	} finally {
-		fs$1.rmSync(outFile, { force: true });
+		fs.rmSync(outFile, { force: true });
 	}
 }
 //#endregion
@@ -4672,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;
 	}
@@ -4851,9 +5183,10 @@ function resolveWorkerLimits(environment, availableParallelism, ci) {
 	const explicit = parsePositiveInteger(environment["LINT_MAX_WORKERS"]);
 	const maxWorkers = explicit ?? (ci ? availableParallelism : Math.floor(availableParallelism / 4));
 	return {
+		explicitMaxWorkers: explicit !== void 0,
 		filesPerWorker,
 		maxWorkers,
-		typedMaxWorkers: explicit ?? Math.min(maxWorkers, 6)
+		typedMaxWorkers: explicit ?? Math.min(maxWorkers, 5)
 	};
 }
 /**
@@ -4943,6 +5276,17 @@ function selectPasses(options, ci) {
 	return [FAST_PASS, TYPED_PASS];
 }
 /**
+* Whether a pass builds a TypeScript program in each of its workers. The pass
+* that runs no builder is exactly the one that builds no program, so
+* `invalidation` records both.
+*
+* @param descriptor - The pass.
+* @returns Whether its workers hold a program, and so need heap sizing.
+*/
+function buildsProgram(descriptor) {
+	return descriptor.invalidation !== "none";
+}
+/**
 * The worker cap for a pass. `invalidation` already records whether a pass
 * builds a TypeScript program — the fast pass runs no builder precisely because
 * it builds none — so it doubles as the cap selector rather than restating the
@@ -4953,7 +5297,7 @@ function selectPasses(options, ci) {
 * @returns The worker cap for this pass.
 */
 function maxWorkersFor(descriptor, limits) {
-	return descriptor.invalidation === "none" ? limits.maxWorkers : limits.typedMaxWorkers;
+	return buildsProgram(descriptor) ? limits.typedMaxWorkers : limits.maxWorkers;
 }
 //#endregion
 //#region src/lint-cli/lib/plan/fix.ts
@@ -5018,13 +5362,18 @@ function collectFixTargets(passes, run, files) {
 * @returns The fix child, or `undefined` when nothing was reported.
 */
 function planFixChild(passes, run, inputs) {
-	const { files, limits, options } = inputs;
+	const { files, heap, limits, options } = inputs;
 	const covered = options.cache ? collectFixTargets(passes, run, files) : [];
 	const uncovered = options.cache ? files.outsideCwdTargets : options.paths;
 	const targets = [...covered, ...uncovered];
 	if (targets.length === 0) return;
 	const cacheFile = cacheFileFor(CACHE_FILE_DEFAULT, run.key);
 	if (covered.length > 0) openCache(path.resolve(run.cwd, cacheFile), run.ci)?.removeEntries(covered);
+	const concurrency = options.concurrency ?? computeWorkerCount({
+		dirtyCount: targets.length,
+		filesPerWorker: limits.filesPerWorker,
+		maxWorkers: capWorkersForHeap(limits.typedMaxWorkers, limits.explicitMaxWorkers, heap)
+	});
 	return composeEslintCommand({
 		...options,
 		cache: options.cache && uncovered.length === 0
@@ -5032,14 +5381,15 @@ function planFixChild(passes, run, inputs) {
 		agentsFormatterPath: inputs.agentsFormatterPath,
 		cacheLocation: cacheFile,
 		ci: run.ci,
-		concurrency: options.concurrency ?? computeWorkerCount({
-			dirtyCount: targets.length,
-			filesPerWorker: limits.filesPerWorker,
-			maxWorkers: limits.typedMaxWorkers
-		}),
+		concurrency,
 		eslintLabel: FULL_PASS.label,
 		fix: true,
+		heap: planPassHeap(FULL_PASS.label, heap, {
+			concurrency,
+			dirtyCount: targets.length
+		}),
 		paths: targets,
+		quietWarnings: true,
 		typeAwareEnv: FULL_PASS.typeAwareEnv
 	});
 }
@@ -5375,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;
@@ -5422,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;
 	}
@@ -5637,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;
 		}
 	});
@@ -5655,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);
@@ -5676,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,
@@ -5759,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,
@@ -5818,12 +6168,12 @@ function sizePasses(descriptors, run, inputs) {
 * @returns The number of dirty files.
 */
 function mutatingDirtyCount(descriptor, cacheLocation, targetFiles, { clearedCaches, run }) {
-	const buildsProgram = descriptor.invalidation !== "none";
+	const program = buildsProgram(descriptor);
 	const mode = descriptor.invalidation === "only" ? "only" : void 0;
-	if (clearedCaches.has(cacheLocation) && (!buildsProgram || hasBuilderState(run, mode))) return targetFiles.length;
+	if (clearedCaches.has(cacheLocation) && (!program || hasBuilderState(run, mode))) return targetFiles.length;
 	const cache = openCache(cacheLocation, run.ci);
 	const dirty = new Set((cache?.getUpdatedFiles(targetFiles) ?? targetFiles).map((file) => normalizePath(file)));
-	if (buildsProgram) {
+	if (program) {
 		const outcome = applyTypeAwareInvalidation(run, {
 			alreadyDirty: dirty,
 			cache,
@@ -5880,17 +6230,24 @@ function sizePass(descriptor, context) {
 	const dirtyCount = passDirtyCount(descriptor, cacheFile, context);
 	const conservative = context.files.outsideCwdTargets.length > 0;
 	const filesPerWorker = descriptor.filesPerWorker(context.limits, context.run.environment);
-	const maxWorkers = maxWorkersFor(descriptor, context.limits);
+	const program = buildsProgram(descriptor);
+	const passMaxWorkers = maxWorkersFor(descriptor, context.limits);
+	const maxWorkers = program ? capWorkersForHeap(passMaxWorkers, context.limits.explicitMaxWorkers, context.heap) : passMaxWorkers;
 	const sizingDirtyCount = conservative ? maxWorkers * filesPerWorker : dirtyCount;
 	const concurrency = context.options.concurrency ?? computeWorkerCount({
 		dirtyCount: sizingDirtyCount,
 		filesPerWorker,
 		maxWorkers
 	});
+	const heap = program ? planPassHeap(descriptor.label, context.heap, {
+		concurrency,
+		dirtyCount: sizingDirtyCount
+	}) : void 0;
 	if (context.run.mutate && context.multiPass && descriptor === TYPED_PASS && !conservative && dirtyCount === 0) return {
 		cacheFile,
 		concurrency,
 		descriptor,
+		heap,
 		shouldRun: false,
 		skipReason: TYPED_SKIP_NOTICE
 	};
@@ -5898,6 +6255,7 @@ function sizePass(descriptor, context) {
 		cacheFile,
 		concurrency,
 		descriptor,
+		heap,
 		shouldRun: true,
 		skipReason: void 0
 	};
@@ -5918,9 +6276,10 @@ function sizePass(descriptor, context) {
 *
 * @param options - The parsed CLI options.
 * @param run - The run context (cwd, variant key, environment, mutate).
+* @param memory - The machine's memory facts (injected in tests).
 * @returns The staged run plan.
 */
-function plan(options, run) {
+function plan(options, run, memory = probeMemory()) {
 	const { ci, cwd, environment, mutate } = run;
 	const runEslint = !options.oxlint;
 	const oxlintTypeAware = resolveOxlintTypeAware(options);
@@ -5945,6 +6304,7 @@ function plan(options, run) {
 	const files = collectRepoFiles(cwd, options.paths);
 	const newestBustMtime = maxMtimeMs(files.bustFiles);
 	const limits = resolveWorkerLimits(environment, availableParallelism(), ci);
+	const heap = resolveHeapBudget(environment, memory);
 	const oxlintDecision = resolveOxlintRun(run, {
 		files,
 		runEslint,
@@ -5964,6 +6324,7 @@ function plan(options, run) {
 	const inputs = {
 		clearedCaches,
 		files: sizingFiles,
+		heap,
 		limits,
 		multiPass: descriptors.length > 1,
 		newestBustMtime,
@@ -5991,6 +6352,7 @@ function plan(options, run) {
 			return planFixChild(passes, run, {
 				agentsFormatterPath,
 				files: sizingFiles,
+				heap,
 				limits,
 				options
 			});
@@ -6057,20 +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.
@@ -6117,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