@isentinel/eslint-config 6.0.1 → 6.1.0

package/README.md

@@ -253,6 +253,22 @@ Other behaviours:
   re-lint (its own dirty count), rather than eagerly spinning up a worker per
   CPU. The fast pass is cheap per file, so it packs far more files per worker
   (see `FAST_FILES_PER_WORKER`) than the type-aware pass.
+- Sizes the heap of every ESLint child that builds a TypeScript program (the
+  type-aware pass, the full pass and the fix child). Each worker holds its own
+  program, so the limit that matters is workers × heap. By default the runner
+  splits half the machine's memory (or its cgroup limit, when lower) across
+  those workers, and raises Node's heap limit when the share is larger. When the
+  budget cannot give each worker twice Node's default heap, it runs fewer
+  workers: every worker loads the program of nearly every project, so fewer,
+  larger workers need far less memory in total than more, smaller ones. The flag
+  goes in the child's `NODE_OPTIONS`, which every ESLint worker inherits; oxlint
+  and the fast pass never get it. `--print` shows the chosen workers, files per
+  worker and heap on stderr. If a child still runs out of memory, the runner
+  prints a hint that names `LINT_TYPED_HEAP_MB`. A size set in
+  `LINT_TYPED_HEAP_MB` also caps the workers at budget ÷ size. An explicit
+  `LINT_MAX_WORKERS` or `--concurrency` is never reduced. A
+  `--max-old-space-size` already in `NODE_OPTIONS` wins over all of this: the
+  runner adds nothing and keeps the worker count.
 - Keeps a separate ESLint cache per pass so they never invalidate one another:
   `.eslintcache-fast-<key>` (fast pass), `.eslintcache-typeaware-<key>`
   (type-aware pass), and `.eslintcache-<key>` (the full config, used by CI,
@@ -394,6 +410,7 @@ or `--`.
 | `FILES_PER_WORKER`      | Target files a single type-aware ESLint worker handles before adding another (default `350`).                        |
 | `FAST_FILES_PER_WORKER` | Same, for the fast (syntactic) pass, which packs far more files per worker (default `800`).                          |
 | `LINT_MAX_WORKERS`      | Upper bound on ESLint workers (default a quarter of available CPUs).                                                 |
+| `LINT_TYPED_HEAP_MB`    | Heap per worker for the program-building ESLint children: `auto` (default), a size in MB, or `off` (Node's default). |
 | `ESLINT_TYPE_AWARE`     | `off` or `only`; the type-aware mode `--type-aware` sets for the ESLint child (`false` is a legacy alias for `off`). |
 | `CI`                    | When set, the runner uses the single full pass with `--cache-strategy content` (see below).                          |
 

package/dist/cli.mjs

@@ -9,7 +9,7 @@ import path from "node:path";
 import { existsSync, readFileSync } from "fs";
 import { execSync } from "node:child_process";
 //#region package.json
-var version = "6.0.1";
+var version = "6.1.0";
 var package_default = {
 	name: "@isentinel/eslint-config",
 	version,

package/dist/index.d.mts

@@ -28502,7 +28502,14 @@ declare function loadSmallRulesPlugin(): NonNullable<TypedFlatConfigItem["plugin
 declare function smallRules(options?: OptionsComponentExtensions & OptionsFiles & OptionsIsInEditor & OptionsStylistic): Array<TypedFlatConfigItem>;
 //#endregion
 //#region src/eslint/configs/sonarjs.d.ts
-declare function sonarjs({ isInEditor, roblox }: OptionsHasRoblox & Required<OptionsIsInEditor>): Promise<Array<TypedFlatConfigItem>>;
+declare function sonarjs({ complementIgnores, isInEditor, roblox }: OptionsHasRoblox & Required<OptionsIsInEditor> & {
+  /**
+   * When set, re-apply the non-roblox rules to every source file except
+   * these globs (the roblox scope), so the complement is linted as
+   * standard-TS/Node land.
+   */
+  complementIgnores?: Array<string>;
+}): Promise<Array<TypedFlatConfigItem>>;
 //#endregion
 //#region src/eslint/configs/sort.d.ts
 /**

package/dist/index.mjs

@@ -4523,7 +4523,8 @@ function sonarjsTestRules({ jest = false, roblox = true } = {}) {
 }
 //#endregion
 //#region src/eslint/configs/sonarjs.ts
-async function sonarjs({ isInEditor, roblox }) {
+init_globs();
+async function sonarjs({ complementIgnores, isInEditor, roblox }) {
 	return [{
 		name: "isentinel/sonarjs",
 		plugins: { sonar: await interopDefault(import("eslint-plugin-sonarjs")) },
@@ -4531,7 +4532,15 @@ async function sonarjs({ isInEditor, roblox }) {
 			isInEditor,
 			roblox
 		})
-	}];
+	}, ...complementIgnores ? [{
+		name: "isentinel/sonarjs/complement",
+		files: [GLOB_SRC],
+		ignores: complementIgnores,
+		rules: sonarjsRules({
+			isInEditor,
+			roblox: false
+		})
+	}] : []];
 }
 //#endregion
 //#region src/eslint/configs/sort.ts
@@ -5938,7 +5947,6 @@ function typescriptTypeAwareRules({ roblox = true } = {}) {
 		"ts/no-confusing-void-expression": "error",
 		"ts/no-deprecated": "error",
 		"ts/no-duplicate-type-constituents": "error",
-		"ts/no-empty-object-type": "error",
 		"ts/no-floating-promises": ["error", {
 			checkThenables: roblox,
 			ignoreVoid: true
@@ -20314,6 +20322,7 @@ async function isentinel(options, ...userConfigs) {
 		roblox: enableRoblox,
 		stylistic: stylisticOptions
 	}), promise(), sonarjs({
+		...needsComplementOverlay ? { complementIgnores: robloxScopedFiles } : {},
 		isInEditor,
 		roblox: enableRoblox
 	}), typescript({

package/dist/lint-cli.mjs

@@ -14,6 +14,7 @@ import { KillOnSignal, LogError, LogExit, LogOutput, Logger, createConcurrently
 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 +41,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.1.0";
 //#endregion
 //#region src/lint-cli/lib/cli/types.ts
 /**
@@ -570,6 +571,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
@@ -848,6 +1031,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",
@@ -877,6 +1065,17 @@ const PREFIX_COLOR = {
 	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 +1244,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 +1295,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 +1324,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 +1339,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 +1356,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 +1368,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 +1392,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 +1477,8 @@ function composeOxlintCommand(options, context) {
 		args,
 		bin: "oxlint",
 		env: {},
-		label: "oxc"
+		label: "oxc",
+		watchHeap: false
 	};
 }
 /**
@@ -1254,11 +1496,14 @@ 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.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,6 +1551,7 @@ function composePasses(passes, runPlan, options) {
 			concurrency: pass.concurrency,
 			eslintLabel: pass.descriptor.label,
 			fix: false,
+			heap: pass.heap,
 			paths: options.paths,
 			typeAwareEnv: pass.descriptor.typeAwareEnv
 		}));
@@ -4851,6 +5097,7 @@ 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)
@@ -4943,6 +5190,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 +5211,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 +5276,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,13 +5295,13 @@ 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,
 		typeAwareEnv: FULL_PASS.typeAwareEnv
 	});
@@ -5818,12 +6081,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 +6143,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 +6168,7 @@ function sizePass(descriptor, context) {
 		cacheFile,
 		concurrency,
 		descriptor,
+		heap,
 		shouldRun: true,
 		skipReason: void 0
 	};
@@ -5918,9 +6189,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 +6217,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 +6237,7 @@ function plan(options, run) {
 	const inputs = {
 		clearedCaches,
 		files: sizingFiles,
+		heap,
 		limits,
 		multiPass: descriptors.length > 1,
 		newestBustMtime,
@@ -5991,6 +6265,7 @@ function plan(options, run) {
 			return planFixChild(passes, run, {
 				agentsFormatterPath,
 				files: sizingFiles,
+				heap,
 				limits,
 				options
 			});
@@ -6059,6 +6334,7 @@ async function runLint(argv, cwd = process$1.cwd(), environment = process$1.env,
 	const { commands, notice } = compose(staged.eager, options);
 	if (options.print) {
 		for (const command of commands) 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.");

package/dist/oxlint.d.mts

@@ -1382,7 +1382,10 @@ interface OxlintMainRuleDefaults {
     "*": "off";
   };
   "prefer-const": {
-    "*": "error";
+    "*": ["error", {
+      "destructuring": "all";
+      "ignoreReadBeforeAssign": true;
+    }];
   };
   "prefer-destructuring": {
     "*": "off";
@@ -2080,7 +2083,9 @@ interface OxlintMainRuleDefaults {
     "*": "off";
   };
   "typescript/no-empty-object-type": {
-    "*": "error";
+    "*": ["error", {
+      "allowInterfaces": "always";
+    }];
   };
   "typescript/no-explicit-any": {
     "*": "off";

package/dist/oxlint.mjs

@@ -8479,11 +8479,15 @@ function sonarjsTestRules({ jest = false, roblox = true } = {}) {
 }
 //#endregion
 //#region src/oxlint/configs/sonarjs.ts
-function oxlintSonarjs(options) {
+function oxlintSonarjs({ excludeFiles, isInEditor, roblox }) {
 	return createOxlintConfigs({
-		name: "isentinel/sonarjs",
+		name: excludeFiles ? "isentinel/sonarjs/complement" : "isentinel/sonarjs",
+		...excludeFiles ? { excludeFiles } : {},
 		files: [GLOB_SRC],
-		rules: sonarjsRules(options)
+		rules: sonarjsRules({
+			isInEditor,
+			roblox
+		})
 	});
 }
 //#endregion
@@ -9006,7 +9010,6 @@ function typescriptTypeAwareRules({ roblox = true } = {}) {
 		"ts/no-confusing-void-expression": "error",
 		"ts/no-deprecated": "error",
 		"ts/no-duplicate-type-constituents": "error",
-		"ts/no-empty-object-type": "error",
 		"ts/no-floating-promises": ["error", {
 			checkThenables: roblox,
 			ignoreVoid: true
@@ -9107,7 +9110,6 @@ function typescriptRecommendedOverrides() {
 		"no-unsafe-negation": "off",
 		"no-var": "error",
 		"no-with": "off",
-		"prefer-const": "error",
 		"prefer-rest-params": "error",
 		"prefer-spread": "error"
 	};
@@ -9488,7 +9490,21 @@ function isentinel(factoryOptions, ...userConfigs) {
 		componentExts: componentExtensions,
 		stylistic: stylisticOptions
 	}));
-	if (needsComplementOverlay) configs.push(oxlintTypescript({
+	if (needsComplementOverlay) configs.push(oxlintJavascript({
+		...getOverrides(options, "javascript"),
+		excludeFiles: robloxScopedFiles,
+		isInEditor,
+		roblox: false,
+		stylistic: stylisticOptions
+	}), oxlintImports({
+		excludeFiles: robloxScopedFiles,
+		roblox: false,
+		stylistic: stylisticOptions
+	}), oxlintSonarjs({
+		excludeFiles: robloxScopedFiles,
+		isInEditor,
+		roblox: false
+	}), oxlintTypescript({
 		...resolveSubOptions(options, "typescript"),
 		...getOverrides(options, "typescript"),
 		componentExts: componentExtensions,
@@ -9496,21 +9512,11 @@ function isentinel(factoryOptions, ...userConfigs) {
 		roblox: false,
 		stylistic: stylisticOptions,
 		typeAware
-	}), oxlintJavascript({
-		...getOverrides(options, "javascript"),
-		excludeFiles: robloxScopedFiles,
-		isInEditor,
-		roblox: false,
-		stylistic: stylisticOptions
 	}), oxlintUnicorn({
 		...resolveSubOptions(options, "unicorn"),
 		excludeFiles: robloxScopedFiles,
 		roblox: false,
 		stylistic: stylisticOptions
-	}), oxlintImports({
-		excludeFiles: robloxScopedFiles,
-		roblox: false,
-		stylistic: stylisticOptions
 	}));
 	if (enableE18e !== false && hasComplement) configs.push(oxlintE18e({
 		excludeFiles: robloxScopedFiles,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isentinel/eslint-config",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "description": "iSentinel's ESLint config",
   "keywords": [
     "eslint-config",
@@ -67,7 +67,7 @@
     "@typescript-eslint/eslint-plugin": "8.65.0",
     "@typescript-eslint/parser": "8.65.0",
     "ansis": "4.3.1",
-    "concurrently": "10.0.4",
+    "concurrently": "10.0.6",
     "eslint-config-flat-gitignore": "2.3.0",
     "eslint-config-prettier": "10.1.8",
     "eslint-flat-config-utils": "3.2.0",
@@ -98,7 +98,7 @@
     "globals": "17.7.0",
     "jsonc-eslint-parser": "3.1.0",
     "local-pkg": "1.2.1",
-    "oxfmt": "0.63.0",
+    "oxfmt": "0.72.0",
     "oxlint-plugin-eslint": "1.78.0",
     "oxlint-plugin-oxlint-comments": "0.1.0",
     "prettier": "3.9.6",
@@ -145,7 +145,7 @@
     "typescript": "6.0.3",
     "unplugin-unused": "0.5.7",
     "vitest": "4.1.10",
-    "@isentinel/eslint-config": "6.0.1"
+    "@isentinel/eslint-config": "6.1.0"
   },
   "peerDependencies": {
     "@vitest/eslint-plugin": "^1.6.4",