react-doctor 0.6.1 → 0.6.2-dev.173cc0a

package/dist/cli.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a28b8f59-6a38-551a-b87f-c7af571b4588")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="2921b8ff-14cf-5604-8ae5-b65b4f1347fc")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as NodeChildProcess from "node:child_process";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
@@ -38678,7 +38678,7 @@ const resolveAutoScanConcurrency = (facts = readSystemFacts$1()) => {
 	return resolveScanConcurrency(Math.min(facts.availableCores, memoryBoundedWorkers));
 };
 const resolveLintBatchOrdering = () => {
-	return process.env["REACT_DOCTOR_LINT_BATCH_ORDERING"]?.trim().toLowerCase() === "cost" ? "cost" : "arrival";
+	return process.env["REACT_DOCTOR_LINT_BATCH_ORDERING"]?.trim().toLowerCase() === "arrival" ? "arrival" : "cost";
 };
 /**
 * Per-batch oxlint wall-clock budget. Reads from the env var on
@@ -38775,17 +38775,19 @@ var DeadCodeOverlap = class extends Reference("react-doctor/DeadCodeOverlap", {
 	return "auto";
 } }) {};
 /**
-* How the full-scan lint pass orders its file batches. `"arrival"` (the
-* default) keeps `git ls-files` discovery order. `"cost"` opts into LPT (feed
-* the largest files first); set `REACT_DOCTOR_LINT_BATCH_ORDERING=cost`. NOTE:
-* `cost` is OFF by default because the current sort-desc-then-chunk-100 packs
-* the heaviest files into one wave-1 batch — on size-skewed repos that mega-
-* batch is a straggler (and can trip the per-batch timeout + split), measurably
-* regressing the common full-scan case. LPT needs the heavy files SPREAD across
-* batches before `cost` earns the default. Tests override via
-* `Layer.succeed(LintBatchOrdering, ...)`. Diff / staged scans never reach this
-* — they pass user-scoped `includePaths` that skip discovery and stay in
-* arrival order; only the full-scan branch reads it.
+* How the full-scan lint pass plans its file batches. `"cost"` (the default)
+* builds size-balanced LPT batches (`planLintBatches`): the same mandatory
+* batch count as greedy chunking (`ceil(files / 100)`), but every batch gets
+* an even share of files AND bytes, so no 100-file chunk is a straggler while
+* the remainder-batch worker idles — and the heavy files are SPREAD across
+* batches, the precondition the old sort-desc-then-chunk-100 `cost` mode
+* lacked (it packed the heaviest files into one wave-1 straggler batch,
+* measurably regressing size-skewed repos, which is why it never earned the
+* default). `"arrival"` (`REACT_DOCTOR_LINT_BATCH_ORDERING=arrival`) is the
+* rollback hatch to plain greedy 100-file chunking in discovery order. Tests
+* override via `Layer.succeed(LintBatchOrdering, ...)`. Diff / staged scans
+* never reach this — they pass user-scoped `includePaths` that skip discovery
+* and stay in arrival order; only the full-scan branch reads it.
 */
 var LintBatchOrdering = class extends Reference("react-doctor/LintBatchOrdering", { defaultValue: resolveLintBatchOrdering }) {};
 const CACHE_DISABLED_VALUES$1 = new Set(["1", "true"]);
@@ -40170,6 +40172,7 @@ function* collectSecurityScanFiles(rootDirectory) {
 				isGeneratedBundleByName: classification.isGeneratedBundleByName
 			});
 		}
+		yield null;
 	}
 	for (const candidates of [
 		priorityCandidates,
@@ -40273,31 +40276,39 @@ const createSecurityScanSession = (rootDirectory, options) => {
 		}
 		return status === true;
 	};
-	const scanFile = (file) => {
-		for (const { entry, scan, committedFilesOnly } of enabledScanRules) for (const finding of scan(file)) {
-			if (committedFilesOnly && isFileGitIgnored(file)) continue;
-			const diagnostic = buildSecurityScanDiagnostic(finding, entry, file.relativePath);
-			const key = `${diagnostic.rule}:${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.message}`;
-			if (seen.has(key)) continue;
-			seen.add(key);
-			diagnostics.push(diagnostic);
+	const scanFileByRule = function* (file) {
+		for (const { entry, scan, committedFilesOnly } of enabledScanRules) {
+			for (const finding of scan(file)) {
+				if (committedFilesOnly && isFileGitIgnored(file)) continue;
+				const diagnostic = buildSecurityScanDiagnostic(finding, entry, file.relativePath);
+				const key = `${diagnostic.rule}:${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.message}`;
+				if (seen.has(key)) continue;
+				seen.add(key);
+				diagnostics.push(diagnostic);
+			}
+			yield;
 		}
 	};
 	return {
-		scanFile,
+		scanFileByRule,
 		diagnostics
 	};
 };
 const checkSecurityScanCooperative = async (rootDirectory, options = {}) => {
 	const session = createSecurityScanSession(rootDirectory, options);
 	if (session === null) return [];
-	let filesSinceYield = 0;
+	let sliceStartedAt = performance.now();
 	for (const file of collectSecurityScanFiles(rootDirectory)) {
-		session.scanFile(file);
-		filesSinceYield += 1;
-		if (filesSinceYield >= 16) {
-			filesSinceYield = 0;
+		if (file === null) {
+			if (performance.now() - sliceStartedAt >= 12) {
+				await yieldToEventLoop();
+				sliceStartedAt = performance.now();
+			}
+			continue;
+		}
+		for (const _ruleStep of session.scanFileByRule(file)) if (performance.now() - sliceStartedAt >= 12) {
 			await yieldToEventLoop();
+			sliceStartedAt = performance.now();
 		}
 	}
 	return session.diagnostics;
@@ -43076,6 +43087,70 @@ const hashFileContents = (filePath) => {
 		return null;
 	}
 };
+/**
+* Balanced LPT (longest-processing-time-first) lint batch planner. Where
+* `batchIncludePaths` greedily fills 100-file batches and leaves a small
+* remainder batch (617 files → 6×100 + 17, so the parallel pool's wall clock
+* is set by whichever 100-file chunk happened to collect the most work while
+* the remainder's worker idles), this planner keeps the SAME mandatory batch
+* count — `ceil(files / OXLINT_MAX_FILES_PER_BATCH)`, the JS-plugin
+* perf-cliff / native-binding SIGABRT guard — and assigns files largest-first,
+* each to the least-loaded batch by cumulative byte size. Every batch ends up
+* with an even share of files AND bytes, so no batch is a straggler; heavy
+* files are SPREAD across batches (the documented precondition for `cost`
+* ordering to beat `arrival`) instead of concentrated in one.
+*
+* Deliberately NOT worker-count-aware: splitting into extra batches to feed
+* idle workers was measured (619-file corpus, 10 cores) to REGRESS the lint
+* wall — each additional concurrent subprocess pays a contended cold start
+* (node boot + plugin import + native dlopen, ~180 ms uncontended and 2-3×
+* that in a full wave) that outweighs the smaller per-batch file share.
+*
+* Every batch also respects the spawn-args char budget; a file that fits no
+* existing batch opens a new one, mirroring `batchIncludePaths`. Within a
+* batch, files return in arrival order, and the assignment is fully
+* deterministic (ties broken by lowest batch index), so a plan is
+* reproducible for a fixed (files, sizes) input. Batch composition cannot
+* change diagnostics — rules that look beyond one file (`CROSS_FILE_RULE_IDS`)
+* read the OTHER files via the filesystem, never via batch-mates — so the
+* plan only moves wall-clock time.
+*
+* O(files × batches); the linear least-loaded scan is fine at real-world
+* scale (a 3,500-file monorepo is 36 batches ≈ 126k comparisons).
+*/
+const planLintBatches = ({ baseArgs, files, sizeByFile }) => {
+	if (files.length === 0) return [];
+	const batchCount = Math.ceil(files.length / 100);
+	const maxFilesPerBatch = Math.ceil(files.length / batchCount);
+	const baseArgsLengthChars = estimateArgsLength(baseArgs);
+	const descendingSizeIndexes = [...files.keys()].sort((leftIndex, rightIndex) => (sizeByFile.get(files[rightIndex]) ?? 0) - (sizeByFile.get(files[leftIndex]) ?? 0));
+	const batches = Array.from({ length: batchCount }, () => ({
+		fileIndexes: [],
+		totalSizeBytes: 0,
+		argsLengthChars: baseArgsLengthChars
+	}));
+	for (const fileIndex of descendingSizeIndexes) {
+		const entryLengthChars = files[fileIndex].length + 1;
+		let targetBatch = null;
+		for (const batch of batches) {
+			if (batch.fileIndexes.length >= maxFilesPerBatch) continue;
+			if (batch.fileIndexes.length > 0 && batch.argsLengthChars + entryLengthChars > 24e3) continue;
+			if (targetBatch === null || batch.totalSizeBytes < targetBatch.totalSizeBytes || batch.totalSizeBytes === targetBatch.totalSizeBytes && batch.fileIndexes.length < targetBatch.fileIndexes.length) targetBatch = batch;
+		}
+		if (targetBatch === null) {
+			targetBatch = {
+				fileIndexes: [],
+				totalSizeBytes: 0,
+				argsLengthChars: baseArgsLengthChars
+			};
+			batches.push(targetBatch);
+		}
+		targetBatch.fileIndexes.push(fileIndex);
+		targetBatch.totalSizeBytes += sizeByFile.get(files[fileIndex]) ?? 0;
+		targetBatch.argsLengthChars += entryLengthChars;
+	}
+	return batches.filter((batch) => batch.fileIndexes.length > 0).map((batch) => batch.fileIndexes.sort((leftIndex, rightIndex) => leftIndex - rightIndex).map((fileIndex) => files[fileIndex]));
+};
 const projectCacheSubdir = (projectDirectory) => crypto.createHash("sha256").update(projectDirectory).digest("hex").slice(0, 16);
 const resolveReactDoctorCacheDir = (projectDirectory) => {
 	const cacheDirOverride = process.env["REACT_DOCTOR_CACHE_DIR"]?.trim();
@@ -43091,7 +43166,6 @@ const resolveUserCacheScope = () => {
 		return "shared";
 	}
 };
-const sortSourceFilesByCost = (entries) => [...entries].sort((left, right) => right.sizeBytes - left.sizeBytes).map((entry) => entry.path);
 /**
 * Atomically (re)writes the generated oxlintrc.json. Used twice in
 * the runner: once for the primary scan, once for the
@@ -43150,7 +43224,7 @@ const reactHooksJsPluginDropNote = (error) => {
 *   6. always restore disable directives + clean up the temp dir
 */
 const runOxlint = async (options) => {
-	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure, perFileLintCacheEnabled = false, onCacheStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "arrival" } = options;
+	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure, perFileLintCacheEnabled = false, onCacheStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "cost" } = options;
 	const serverAuthFunctionNames = Array.isArray(userConfig?.serverAuthFunctionNames) ? userConfig.serverAuthFunctionNames.filter((entry) => typeof entry === "string" && entry.length > 0) : void 0;
 	const severityControls = buildRuleSeverityControls(userConfig);
 	validateRuleRegistration();
@@ -43202,8 +43276,15 @@ const runOxlint = async (options) => {
 			"json",
 			...sharedArgs
 		];
-		const discoverScanFiles = () => lintBatchOrdering === "cost" ? sortSourceFilesByCost(listSourceFilesWithSize(rootDirectory)) : listSourceFiles(rootDirectory);
-		const candidateFiles = includePaths !== void 0 ? includePaths : discoverScanFiles();
+		await yieldToEventLoop();
+		const sizedScanFiles = includePaths === void 0 ? listSourceFilesWithSize(rootDirectory) : null;
+		const candidateFiles = includePaths !== void 0 ? includePaths : (sizedScanFiles ?? []).map((entry) => entry.path);
+		const sizeByFile = sizedScanFiles !== null && lintBatchOrdering === "cost" ? new Map(sizedScanFiles.map((entry) => [entry.path, entry.sizeBytes])) : null;
+		const buildFileBatches = (passBaseArgs, passFiles) => sizeByFile !== null ? planLintBatches({
+			baseArgs: passBaseArgs,
+			files: passFiles,
+			sizeByFile
+		}) : batchIncludePaths(passBaseArgs, passFiles);
 		const runConfigOverFiles = async (buildConfigForPass, configFileName, files, fileProgress) => {
 			if (files.length === 0) return {
 				diagnostics: [],
@@ -43217,7 +43298,7 @@ const runOxlint = async (options) => {
 			};
 			const passConfigPath = Path.join(configDirectory, configFileName);
 			const passBaseArgs = makeBaseArgs(passConfigPath);
-			const passFileBatches = batchIncludePaths(passBaseArgs, files);
+			const passFileBatches = buildFileBatches(passBaseArgs, files);
 			const spawnPass = () => spawnLintBatches({
 				baseArgs: passBaseArgs,
 				fileBatches: passFileBatches,
@@ -43266,6 +43347,7 @@ const runOxlint = async (options) => {
 			const cacheKeyByFile = /* @__PURE__ */ new Map();
 			const missFiles = [];
 			const replayedDiagnostics = [];
+			let hashSliceStartedAt = performance.now();
 			for (const candidateFile of candidateFiles) {
 				const contentHash = hashFileContents(Path.resolve(rootDirectory, candidateFile));
 				if (contentHash === null) {
@@ -43277,23 +43359,29 @@ const runOxlint = async (options) => {
 				const cachedDiagnostics = cache.lookup(cacheKey);
 				if (cachedDiagnostics === null) missFiles.push(candidateFile);
 				else replayedDiagnostics.push(...cachedDiagnostics);
+				if (performance.now() - hashSliceStartedAt >= 12) {
+					await yieldToEventLoop();
+					hashSliceStartedAt = performance.now();
+				}
 			}
 			const cacheHitFileCount = candidateFiles.length - missFiles.length;
-			const cacheableResult = await runConfigOverFiles((overrides) => buildConfig({
+			const fullResult = await runConfigOverFiles((overrides) => buildConfig({
 				extendsPaths: [],
-				ruleSelection: "cacheable",
 				disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin
-			}), "oxlintrc.cacheable.json", missFiles, void 0);
+			}), "oxlintrc.full.json", missFiles, options.onFileProgress && ((scannedFileCount) => options.onFileProgress?.(scannedFileCount, candidateFiles.length)));
+			const missFileSet = new Set(missFiles);
 			const sidecarResult = await runConfigOverFiles(() => buildConfig({
 				extendsPaths: [],
 				ruleSelection: "sidecar"
-			}), "oxlintrc.sidecar.json", candidateFiles, options.onFileProgress);
+			}), "oxlintrc.sidecar.json", candidateFiles.filter((candidateFile) => !missFileSet.has(candidateFile)), options.onFileProgress && ((scannedFileCount) => options.onFileProgress?.(missFiles.length + scannedFileCount, candidateFiles.length)));
+			const freshCacheableDiagnostics = [];
+			for (const diagnostic of fullResult.diagnostics) if (!CROSS_FILE_RULE_IDS.has(diagnostic.rule)) freshCacheableDiagnostics.push(diagnostic);
 			onCacheStats?.(cacheHitFileCount, candidateFiles.length);
 			const missFileByNormalizedPath = /* @__PURE__ */ new Map();
 			for (const missFile of missFiles) missFileByNormalizedPath.set(missFile.replaceAll("\\", "/"), missFile);
 			const freshDiagnosticsByFile = /* @__PURE__ */ new Map();
 			let isAttributionSound = true;
-			for (const diagnostic of cacheableResult.diagnostics) {
+			for (const diagnostic of freshCacheableDiagnostics) {
 				const missFile = missFileByNormalizedPath.get(diagnostic.filePath);
 				if (missFile === void 0) {
 					isAttributionSound = false;
@@ -43303,7 +43391,7 @@ const runOxlint = async (options) => {
 				fileDiagnostics.push(diagnostic);
 				freshDiagnosticsByFile.set(missFile, fileDiagnostics);
 			}
-			if (!cacheableResult.didDropReactHooksJsPlugin && !cacheableResult.hadPartialFailure && isAttributionSound) {
+			if (!fullResult.didDropReactHooksJsPlugin && !fullResult.hadPartialFailure && isAttributionSound) {
 				for (const missFile of missFiles) {
 					const cacheKey = cacheKeyByFile.get(missFile);
 					if (cacheKey !== void 0) cache.store(cacheKey, freshDiagnosticsByFile.get(missFile) ?? []);
@@ -43312,12 +43400,12 @@ const runOxlint = async (options) => {
 			}
 			return dedupeDiagnostics([
 				...replayedDiagnostics,
-				...cacheableResult.diagnostics,
+				...fullResult.diagnostics,
 				...sidecarResult.diagnostics
 			]);
 		}
 		const baseArgs = makeBaseArgs(configPath);
-		const fileBatches = batchIncludePaths(baseArgs, candidateFiles);
+		const fileBatches = buildFileBatches(baseArgs, candidateFiles);
 		const runBatches = () => spawnLintBatches({
 			baseArgs,
 			fileBatches,
@@ -45232,7 +45320,7 @@ const makeNoopConsole = () => ({
 });
 //#endregion
 //#region src/cli/utils/version.ts
-const VERSION = "0.6.1";
+const VERSION = "0.6.2-dev.173cc0a";
 //#endregion
 //#region src/cli/utils/json-mode.ts
 let context = null;
@@ -45601,13 +45689,13 @@ const isDevVersion = (version) => version === "0.0.0" || version.includes("-");
 * uploads source-map artifacts under, so stack frames symbolicate. Honors the
 * standard `SENTRY_RELEASE` override.
 */
-const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@0.6.1`;
+const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@0.6.2-dev.173cc0a`;
 /**
 * Deployment environment shown in Sentry's environment filter. Defaults to
 * `production` for tagged releases and `development` for dev/unbuilt versions,
 * overridable via the standard `SENTRY_ENVIRONMENT` env var.
 */
-const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion("0.6.1") ? "development" : "production");
+const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion("0.6.2-dev.173cc0a") ? "development" : "production");
 /**
 * Performance-tracing sample rate in `[0, 1]`. Reads `SENTRY_TRACES_SAMPLE_RATE`
 * (set to `0` to disable tracing) and falls back to
@@ -63590,4 +63678,4 @@ Promise.resolve().then(() => assertNoRemovedFlags(process.argv)).then(() => prog
 export {};
 
 //# sourceMappingURL=cli.js.map
-//# debugId=a28b8f59-6a38-551a-b87f-c7af571b4588
+//# debugId=2921b8ff-14cf-5604-8ae5-b65b4f1347fc

package/dist/index.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="62cf4740-7938-5db0-8b80-dc81b60af36a")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="8565c6ea-39f3-51e6-895a-ae9f7c026d0e")}catch(e){}}();
 import { r as __toESM$1, t as __commonJSMin$1 } from "./chunk-N93fKeF6.js";
 import { createRequire } from "node:module";
 import * as NFS from "node:fs";
@@ -35479,7 +35479,7 @@ const resolveAutoScanConcurrency = (facts = readSystemFacts$1()) => {
 	return resolveScanConcurrency(Math.min(facts.availableCores, memoryBoundedWorkers));
 };
 const resolveLintBatchOrdering = () => {
-	return process.env["REACT_DOCTOR_LINT_BATCH_ORDERING"]?.trim().toLowerCase() === "cost" ? "cost" : "arrival";
+	return process.env["REACT_DOCTOR_LINT_BATCH_ORDERING"]?.trim().toLowerCase() === "arrival" ? "arrival" : "cost";
 };
 /**
 * Per-batch oxlint wall-clock budget. Reads from the env var on
@@ -35576,17 +35576,19 @@ var DeadCodeOverlap = class extends Reference("react-doctor/DeadCodeOverlap", {
 	return "auto";
 } }) {};
 /**
-* How the full-scan lint pass orders its file batches. `"arrival"` (the
-* default) keeps `git ls-files` discovery order. `"cost"` opts into LPT (feed
-* the largest files first); set `REACT_DOCTOR_LINT_BATCH_ORDERING=cost`. NOTE:
-* `cost` is OFF by default because the current sort-desc-then-chunk-100 packs
-* the heaviest files into one wave-1 batch — on size-skewed repos that mega-
-* batch is a straggler (and can trip the per-batch timeout + split), measurably
-* regressing the common full-scan case. LPT needs the heavy files SPREAD across
-* batches before `cost` earns the default. Tests override via
-* `Layer.succeed(LintBatchOrdering, ...)`. Diff / staged scans never reach this
-* — they pass user-scoped `includePaths` that skip discovery and stay in
-* arrival order; only the full-scan branch reads it.
+* How the full-scan lint pass plans its file batches. `"cost"` (the default)
+* builds size-balanced LPT batches (`planLintBatches`): the same mandatory
+* batch count as greedy chunking (`ceil(files / 100)`), but every batch gets
+* an even share of files AND bytes, so no 100-file chunk is a straggler while
+* the remainder-batch worker idles — and the heavy files are SPREAD across
+* batches, the precondition the old sort-desc-then-chunk-100 `cost` mode
+* lacked (it packed the heaviest files into one wave-1 straggler batch,
+* measurably regressing size-skewed repos, which is why it never earned the
+* default). `"arrival"` (`REACT_DOCTOR_LINT_BATCH_ORDERING=arrival`) is the
+* rollback hatch to plain greedy 100-file chunking in discovery order. Tests
+* override via `Layer.succeed(LintBatchOrdering, ...)`. Diff / staged scans
+* never reach this — they pass user-scoped `includePaths` that skip discovery
+* and stay in arrival order; only the full-scan branch reads it.
 */
 var LintBatchOrdering = class extends Reference("react-doctor/LintBatchOrdering", { defaultValue: resolveLintBatchOrdering }) {};
 const CACHE_DISABLED_VALUES = new Set(["1", "true"]);
@@ -36943,6 +36945,7 @@ function* collectSecurityScanFiles(rootDirectory) {
 				isGeneratedBundleByName: classification.isGeneratedBundleByName
 			});
 		}
+		yield null;
 	}
 	for (const candidates of [
 		priorityCandidates,
@@ -37046,31 +37049,39 @@ const createSecurityScanSession = (rootDirectory, options) => {
 		}
 		return status === true;
 	};
-	const scanFile = (file) => {
-		for (const { entry, scan, committedFilesOnly } of enabledScanRules) for (const finding of scan(file)) {
-			if (committedFilesOnly && isFileGitIgnored(file)) continue;
-			const diagnostic = buildSecurityScanDiagnostic(finding, entry, file.relativePath);
-			const key = `${diagnostic.rule}:${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.message}`;
-			if (seen.has(key)) continue;
-			seen.add(key);
-			diagnostics.push(diagnostic);
+	const scanFileByRule = function* (file) {
+		for (const { entry, scan, committedFilesOnly } of enabledScanRules) {
+			for (const finding of scan(file)) {
+				if (committedFilesOnly && isFileGitIgnored(file)) continue;
+				const diagnostic = buildSecurityScanDiagnostic(finding, entry, file.relativePath);
+				const key = `${diagnostic.rule}:${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.message}`;
+				if (seen.has(key)) continue;
+				seen.add(key);
+				diagnostics.push(diagnostic);
+			}
+			yield;
 		}
 	};
 	return {
-		scanFile,
+		scanFileByRule,
 		diagnostics
 	};
 };
 const checkSecurityScanCooperative = async (rootDirectory, options = {}) => {
 	const session = createSecurityScanSession(rootDirectory, options);
 	if (session === null) return [];
-	let filesSinceYield = 0;
+	let sliceStartedAt = performance.now();
 	for (const file of collectSecurityScanFiles(rootDirectory)) {
-		session.scanFile(file);
-		filesSinceYield += 1;
-		if (filesSinceYield >= 16) {
-			filesSinceYield = 0;
+		if (file === null) {
+			if (performance.now() - sliceStartedAt >= 12) {
+				await yieldToEventLoop();
+				sliceStartedAt = performance.now();
+			}
+			continue;
+		}
+		for (const _ruleStep of session.scanFileByRule(file)) if (performance.now() - sliceStartedAt >= 12) {
 			await yieldToEventLoop();
+			sliceStartedAt = performance.now();
 		}
 	}
 	return session.diagnostics;
@@ -39833,6 +39844,70 @@ const hashFileContents = (filePath) => {
 		return null;
 	}
 };
+/**
+* Balanced LPT (longest-processing-time-first) lint batch planner. Where
+* `batchIncludePaths` greedily fills 100-file batches and leaves a small
+* remainder batch (617 files → 6×100 + 17, so the parallel pool's wall clock
+* is set by whichever 100-file chunk happened to collect the most work while
+* the remainder's worker idles), this planner keeps the SAME mandatory batch
+* count — `ceil(files / OXLINT_MAX_FILES_PER_BATCH)`, the JS-plugin
+* perf-cliff / native-binding SIGABRT guard — and assigns files largest-first,
+* each to the least-loaded batch by cumulative byte size. Every batch ends up
+* with an even share of files AND bytes, so no batch is a straggler; heavy
+* files are SPREAD across batches (the documented precondition for `cost`
+* ordering to beat `arrival`) instead of concentrated in one.
+*
+* Deliberately NOT worker-count-aware: splitting into extra batches to feed
+* idle workers was measured (619-file corpus, 10 cores) to REGRESS the lint
+* wall — each additional concurrent subprocess pays a contended cold start
+* (node boot + plugin import + native dlopen, ~180 ms uncontended and 2-3×
+* that in a full wave) that outweighs the smaller per-batch file share.
+*
+* Every batch also respects the spawn-args char budget; a file that fits no
+* existing batch opens a new one, mirroring `batchIncludePaths`. Within a
+* batch, files return in arrival order, and the assignment is fully
+* deterministic (ties broken by lowest batch index), so a plan is
+* reproducible for a fixed (files, sizes) input. Batch composition cannot
+* change diagnostics — rules that look beyond one file (`CROSS_FILE_RULE_IDS`)
+* read the OTHER files via the filesystem, never via batch-mates — so the
+* plan only moves wall-clock time.
+*
+* O(files × batches); the linear least-loaded scan is fine at real-world
+* scale (a 3,500-file monorepo is 36 batches ≈ 126k comparisons).
+*/
+const planLintBatches = ({ baseArgs, files, sizeByFile }) => {
+	if (files.length === 0) return [];
+	const batchCount = Math.ceil(files.length / 100);
+	const maxFilesPerBatch = Math.ceil(files.length / batchCount);
+	const baseArgsLengthChars = estimateArgsLength(baseArgs);
+	const descendingSizeIndexes = [...files.keys()].sort((leftIndex, rightIndex) => (sizeByFile.get(files[rightIndex]) ?? 0) - (sizeByFile.get(files[leftIndex]) ?? 0));
+	const batches = Array.from({ length: batchCount }, () => ({
+		fileIndexes: [],
+		totalSizeBytes: 0,
+		argsLengthChars: baseArgsLengthChars
+	}));
+	for (const fileIndex of descendingSizeIndexes) {
+		const entryLengthChars = files[fileIndex].length + 1;
+		let targetBatch = null;
+		for (const batch of batches) {
+			if (batch.fileIndexes.length >= maxFilesPerBatch) continue;
+			if (batch.fileIndexes.length > 0 && batch.argsLengthChars + entryLengthChars > 24e3) continue;
+			if (targetBatch === null || batch.totalSizeBytes < targetBatch.totalSizeBytes || batch.totalSizeBytes === targetBatch.totalSizeBytes && batch.fileIndexes.length < targetBatch.fileIndexes.length) targetBatch = batch;
+		}
+		if (targetBatch === null) {
+			targetBatch = {
+				fileIndexes: [],
+				totalSizeBytes: 0,
+				argsLengthChars: baseArgsLengthChars
+			};
+			batches.push(targetBatch);
+		}
+		targetBatch.fileIndexes.push(fileIndex);
+		targetBatch.totalSizeBytes += sizeByFile.get(files[fileIndex]) ?? 0;
+		targetBatch.argsLengthChars += entryLengthChars;
+	}
+	return batches.filter((batch) => batch.fileIndexes.length > 0).map((batch) => batch.fileIndexes.sort((leftIndex, rightIndex) => leftIndex - rightIndex).map((fileIndex) => files[fileIndex]));
+};
 const projectCacheSubdir = (projectDirectory) => crypto.createHash("sha256").update(projectDirectory).digest("hex").slice(0, 16);
 const resolveReactDoctorCacheDir = (projectDirectory) => {
 	const cacheDirOverride = process.env["REACT_DOCTOR_CACHE_DIR"]?.trim();
@@ -39848,7 +39923,6 @@ const resolveUserCacheScope = () => {
 		return "shared";
 	}
 };
-const sortSourceFilesByCost = (entries) => [...entries].sort((left, right) => right.sizeBytes - left.sizeBytes).map((entry) => entry.path);
 /**
 * Atomically (re)writes the generated oxlintrc.json. Used twice in
 * the runner: once for the primary scan, once for the
@@ -39907,7 +39981,7 @@ const reactHooksJsPluginDropNote = (error) => {
 *   6. always restore disable directives + clean up the temp dir
 */
 const runOxlint = async (options) => {
-	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure, perFileLintCacheEnabled = false, onCacheStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "arrival" } = options;
+	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure, perFileLintCacheEnabled = false, onCacheStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "cost" } = options;
 	const serverAuthFunctionNames = Array.isArray(userConfig?.serverAuthFunctionNames) ? userConfig.serverAuthFunctionNames.filter((entry) => typeof entry === "string" && entry.length > 0) : void 0;
 	const severityControls = buildRuleSeverityControls(userConfig);
 	validateRuleRegistration();
@@ -39959,8 +40033,15 @@ const runOxlint = async (options) => {
 			"json",
 			...sharedArgs
 		];
-		const discoverScanFiles = () => lintBatchOrdering === "cost" ? sortSourceFilesByCost(listSourceFilesWithSize(rootDirectory)) : listSourceFiles(rootDirectory);
-		const candidateFiles = includePaths !== void 0 ? includePaths : discoverScanFiles();
+		await yieldToEventLoop();
+		const sizedScanFiles = includePaths === void 0 ? listSourceFilesWithSize(rootDirectory) : null;
+		const candidateFiles = includePaths !== void 0 ? includePaths : (sizedScanFiles ?? []).map((entry) => entry.path);
+		const sizeByFile = sizedScanFiles !== null && lintBatchOrdering === "cost" ? new Map(sizedScanFiles.map((entry) => [entry.path, entry.sizeBytes])) : null;
+		const buildFileBatches = (passBaseArgs, passFiles) => sizeByFile !== null ? planLintBatches({
+			baseArgs: passBaseArgs,
+			files: passFiles,
+			sizeByFile
+		}) : batchIncludePaths(passBaseArgs, passFiles);
 		const runConfigOverFiles = async (buildConfigForPass, configFileName, files, fileProgress) => {
 			if (files.length === 0) return {
 				diagnostics: [],
@@ -39974,7 +40055,7 @@ const runOxlint = async (options) => {
 			};
 			const passConfigPath = Path.join(configDirectory, configFileName);
 			const passBaseArgs = makeBaseArgs(passConfigPath);
-			const passFileBatches = batchIncludePaths(passBaseArgs, files);
+			const passFileBatches = buildFileBatches(passBaseArgs, files);
 			const spawnPass = () => spawnLintBatches({
 				baseArgs: passBaseArgs,
 				fileBatches: passFileBatches,
@@ -40023,6 +40104,7 @@ const runOxlint = async (options) => {
 			const cacheKeyByFile = /* @__PURE__ */ new Map();
 			const missFiles = [];
 			const replayedDiagnostics = [];
+			let hashSliceStartedAt = performance.now();
 			for (const candidateFile of candidateFiles) {
 				const contentHash = hashFileContents(Path.resolve(rootDirectory, candidateFile));
 				if (contentHash === null) {
@@ -40034,23 +40116,29 @@ const runOxlint = async (options) => {
 				const cachedDiagnostics = cache.lookup(cacheKey);
 				if (cachedDiagnostics === null) missFiles.push(candidateFile);
 				else replayedDiagnostics.push(...cachedDiagnostics);
+				if (performance.now() - hashSliceStartedAt >= 12) {
+					await yieldToEventLoop();
+					hashSliceStartedAt = performance.now();
+				}
 			}
 			const cacheHitFileCount = candidateFiles.length - missFiles.length;
-			const cacheableResult = await runConfigOverFiles((overrides) => buildConfig({
+			const fullResult = await runConfigOverFiles((overrides) => buildConfig({
 				extendsPaths: [],
-				ruleSelection: "cacheable",
 				disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin
-			}), "oxlintrc.cacheable.json", missFiles, void 0);
+			}), "oxlintrc.full.json", missFiles, options.onFileProgress && ((scannedFileCount) => options.onFileProgress?.(scannedFileCount, candidateFiles.length)));
+			const missFileSet = new Set(missFiles);
 			const sidecarResult = await runConfigOverFiles(() => buildConfig({
 				extendsPaths: [],
 				ruleSelection: "sidecar"
-			}), "oxlintrc.sidecar.json", candidateFiles, options.onFileProgress);
+			}), "oxlintrc.sidecar.json", candidateFiles.filter((candidateFile) => !missFileSet.has(candidateFile)), options.onFileProgress && ((scannedFileCount) => options.onFileProgress?.(missFiles.length + scannedFileCount, candidateFiles.length)));
+			const freshCacheableDiagnostics = [];
+			for (const diagnostic of fullResult.diagnostics) if (!CROSS_FILE_RULE_IDS.has(diagnostic.rule)) freshCacheableDiagnostics.push(diagnostic);
 			onCacheStats?.(cacheHitFileCount, candidateFiles.length);
 			const missFileByNormalizedPath = /* @__PURE__ */ new Map();
 			for (const missFile of missFiles) missFileByNormalizedPath.set(missFile.replaceAll("\\", "/"), missFile);
 			const freshDiagnosticsByFile = /* @__PURE__ */ new Map();
 			let isAttributionSound = true;
-			for (const diagnostic of cacheableResult.diagnostics) {
+			for (const diagnostic of freshCacheableDiagnostics) {
 				const missFile = missFileByNormalizedPath.get(diagnostic.filePath);
 				if (missFile === void 0) {
 					isAttributionSound = false;
@@ -40060,7 +40148,7 @@ const runOxlint = async (options) => {
 				fileDiagnostics.push(diagnostic);
 				freshDiagnosticsByFile.set(missFile, fileDiagnostics);
 			}
-			if (!cacheableResult.didDropReactHooksJsPlugin && !cacheableResult.hadPartialFailure && isAttributionSound) {
+			if (!fullResult.didDropReactHooksJsPlugin && !fullResult.hadPartialFailure && isAttributionSound) {
 				for (const missFile of missFiles) {
 					const cacheKey = cacheKeyByFile.get(missFile);
 					if (cacheKey !== void 0) cache.store(cacheKey, freshDiagnosticsByFile.get(missFile) ?? []);
@@ -40069,12 +40157,12 @@ const runOxlint = async (options) => {
 			}
 			return dedupeDiagnostics([
 				...replayedDiagnostics,
-				...cacheableResult.diagnostics,
+				...fullResult.diagnostics,
 				...sidecarResult.diagnostics
 			]);
 		}
 		const baseArgs = makeBaseArgs(configPath);
-		const fileBatches = batchIncludePaths(baseArgs, candidateFiles);
+		const fileBatches = buildFileBatches(baseArgs, candidateFiles);
 		const runBatches = () => spawnLintBatches({
 			baseArgs,
 			fileBatches,
@@ -41758,4 +41846,4 @@ const toJsonReport = (result, options) => buildJsonReport({
 export { AmbiguousProjectError, NoReactDependencyError, NotADirectoryError, PackageJsonNotFoundError, ProjectNotFoundError, ReactDoctorError, buildJsonReport, buildJsonReportError, clearCaches, defineConfig, diagnose, filterSourceFiles, getDiffInfo, isProjectDiscoveryError, isReactDoctorError, summarizeDiagnostics, toJsonReport };
 
 //# sourceMappingURL=index.js.map
-//# debugId=62cf4740-7938-5db0-8b80-dc81b60af36a
+//# debugId=8565c6ea-39f3-51e6-895a-ae9f7c026d0e

package/dist/lsp.js

@@ -35512,7 +35512,7 @@ const resolveAutoScanConcurrency = (facts = readSystemFacts$1()) => {
 	return resolveScanConcurrency(Math.min(facts.availableCores, memoryBoundedWorkers));
 };
 const resolveLintBatchOrdering = () => {
-	return process.env["REACT_DOCTOR_LINT_BATCH_ORDERING"]?.trim().toLowerCase() === "cost" ? "cost" : "arrival";
+	return process.env["REACT_DOCTOR_LINT_BATCH_ORDERING"]?.trim().toLowerCase() === "arrival" ? "arrival" : "cost";
 };
 /**
 * Per-batch oxlint wall-clock budget. Reads from the env var on
@@ -35609,17 +35609,19 @@ var DeadCodeOverlap = class extends Reference("react-doctor/DeadCodeOverlap", {
 	return "auto";
 } }) {};
 /**
-* How the full-scan lint pass orders its file batches. `"arrival"` (the
-* default) keeps `git ls-files` discovery order. `"cost"` opts into LPT (feed
-* the largest files first); set `REACT_DOCTOR_LINT_BATCH_ORDERING=cost`. NOTE:
-* `cost` is OFF by default because the current sort-desc-then-chunk-100 packs
-* the heaviest files into one wave-1 batch — on size-skewed repos that mega-
-* batch is a straggler (and can trip the per-batch timeout + split), measurably
-* regressing the common full-scan case. LPT needs the heavy files SPREAD across
-* batches before `cost` earns the default. Tests override via
-* `Layer.succeed(LintBatchOrdering, ...)`. Diff / staged scans never reach this
-* — they pass user-scoped `includePaths` that skip discovery and stay in
-* arrival order; only the full-scan branch reads it.
+* How the full-scan lint pass plans its file batches. `"cost"` (the default)
+* builds size-balanced LPT batches (`planLintBatches`): the same mandatory
+* batch count as greedy chunking (`ceil(files / 100)`), but every batch gets
+* an even share of files AND bytes, so no 100-file chunk is a straggler while
+* the remainder-batch worker idles — and the heavy files are SPREAD across
+* batches, the precondition the old sort-desc-then-chunk-100 `cost` mode
+* lacked (it packed the heaviest files into one wave-1 straggler batch,
+* measurably regressing size-skewed repos, which is why it never earned the
+* default). `"arrival"` (`REACT_DOCTOR_LINT_BATCH_ORDERING=arrival`) is the
+* rollback hatch to plain greedy 100-file chunking in discovery order. Tests
+* override via `Layer.succeed(LintBatchOrdering, ...)`. Diff / staged scans
+* never reach this — they pass user-scoped `includePaths` that skip discovery
+* and stay in arrival order; only the full-scan branch reads it.
 */
 var LintBatchOrdering = class extends Reference("react-doctor/LintBatchOrdering", { defaultValue: resolveLintBatchOrdering }) {};
 const CACHE_DISABLED_VALUES = new Set(["1", "true"]);
@@ -36928,6 +36930,7 @@ function* collectSecurityScanFiles(rootDirectory) {
 				isGeneratedBundleByName: classification.isGeneratedBundleByName
 			});
 		}
+		yield null;
 	}
 	for (const candidates of [
 		priorityCandidates,
@@ -37031,31 +37034,39 @@ const createSecurityScanSession = (rootDirectory, options) => {
 		}
 		return status === true;
 	};
-	const scanFile = (file) => {
-		for (const { entry, scan, committedFilesOnly } of enabledScanRules) for (const finding of scan(file)) {
-			if (committedFilesOnly && isFileGitIgnored(file)) continue;
-			const diagnostic = buildSecurityScanDiagnostic(finding, entry, file.relativePath);
-			const key = `${diagnostic.rule}:${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.message}`;
-			if (seen.has(key)) continue;
-			seen.add(key);
-			diagnostics.push(diagnostic);
+	const scanFileByRule = function* (file) {
+		for (const { entry, scan, committedFilesOnly } of enabledScanRules) {
+			for (const finding of scan(file)) {
+				if (committedFilesOnly && isFileGitIgnored(file)) continue;
+				const diagnostic = buildSecurityScanDiagnostic(finding, entry, file.relativePath);
+				const key = `${diagnostic.rule}:${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.message}`;
+				if (seen.has(key)) continue;
+				seen.add(key);
+				diagnostics.push(diagnostic);
+			}
+			yield;
 		}
 	};
 	return {
-		scanFile,
+		scanFileByRule,
 		diagnostics
 	};
 };
 const checkSecurityScanCooperative = async (rootDirectory, options = {}) => {
 	const session = createSecurityScanSession(rootDirectory, options);
 	if (session === null) return [];
-	let filesSinceYield = 0;
+	let sliceStartedAt = performance.now();
 	for (const file of collectSecurityScanFiles(rootDirectory)) {
-		session.scanFile(file);
-		filesSinceYield += 1;
-		if (filesSinceYield >= 16) {
-			filesSinceYield = 0;
+		if (file === null) {
+			if (performance.now() - sliceStartedAt >= 12) {
+				await yieldToEventLoop();
+				sliceStartedAt = performance.now();
+			}
+			continue;
+		}
+		for (const _ruleStep of session.scanFileByRule(file)) if (performance.now() - sliceStartedAt >= 12) {
 			await yieldToEventLoop();
+			sliceStartedAt = performance.now();
 		}
 	}
 	return session.diagnostics;
@@ -39818,6 +39829,70 @@ const hashFileContents = (filePath) => {
 		return null;
 	}
 };
+/**
+* Balanced LPT (longest-processing-time-first) lint batch planner. Where
+* `batchIncludePaths` greedily fills 100-file batches and leaves a small
+* remainder batch (617 files → 6×100 + 17, so the parallel pool's wall clock
+* is set by whichever 100-file chunk happened to collect the most work while
+* the remainder's worker idles), this planner keeps the SAME mandatory batch
+* count — `ceil(files / OXLINT_MAX_FILES_PER_BATCH)`, the JS-plugin
+* perf-cliff / native-binding SIGABRT guard — and assigns files largest-first,
+* each to the least-loaded batch by cumulative byte size. Every batch ends up
+* with an even share of files AND bytes, so no batch is a straggler; heavy
+* files are SPREAD across batches (the documented precondition for `cost`
+* ordering to beat `arrival`) instead of concentrated in one.
+*
+* Deliberately NOT worker-count-aware: splitting into extra batches to feed
+* idle workers was measured (619-file corpus, 10 cores) to REGRESS the lint
+* wall — each additional concurrent subprocess pays a contended cold start
+* (node boot + plugin import + native dlopen, ~180 ms uncontended and 2-3×
+* that in a full wave) that outweighs the smaller per-batch file share.
+*
+* Every batch also respects the spawn-args char budget; a file that fits no
+* existing batch opens a new one, mirroring `batchIncludePaths`. Within a
+* batch, files return in arrival order, and the assignment is fully
+* deterministic (ties broken by lowest batch index), so a plan is
+* reproducible for a fixed (files, sizes) input. Batch composition cannot
+* change diagnostics — rules that look beyond one file (`CROSS_FILE_RULE_IDS`)
+* read the OTHER files via the filesystem, never via batch-mates — so the
+* plan only moves wall-clock time.
+*
+* O(files × batches); the linear least-loaded scan is fine at real-world
+* scale (a 3,500-file monorepo is 36 batches ≈ 126k comparisons).
+*/
+const planLintBatches = ({ baseArgs, files, sizeByFile }) => {
+	if (files.length === 0) return [];
+	const batchCount = Math.ceil(files.length / 100);
+	const maxFilesPerBatch = Math.ceil(files.length / batchCount);
+	const baseArgsLengthChars = estimateArgsLength(baseArgs);
+	const descendingSizeIndexes = [...files.keys()].sort((leftIndex, rightIndex) => (sizeByFile.get(files[rightIndex]) ?? 0) - (sizeByFile.get(files[leftIndex]) ?? 0));
+	const batches = Array.from({ length: batchCount }, () => ({
+		fileIndexes: [],
+		totalSizeBytes: 0,
+		argsLengthChars: baseArgsLengthChars
+	}));
+	for (const fileIndex of descendingSizeIndexes) {
+		const entryLengthChars = files[fileIndex].length + 1;
+		let targetBatch = null;
+		for (const batch of batches) {
+			if (batch.fileIndexes.length >= maxFilesPerBatch) continue;
+			if (batch.fileIndexes.length > 0 && batch.argsLengthChars + entryLengthChars > 24e3) continue;
+			if (targetBatch === null || batch.totalSizeBytes < targetBatch.totalSizeBytes || batch.totalSizeBytes === targetBatch.totalSizeBytes && batch.fileIndexes.length < targetBatch.fileIndexes.length) targetBatch = batch;
+		}
+		if (targetBatch === null) {
+			targetBatch = {
+				fileIndexes: [],
+				totalSizeBytes: 0,
+				argsLengthChars: baseArgsLengthChars
+			};
+			batches.push(targetBatch);
+		}
+		targetBatch.fileIndexes.push(fileIndex);
+		targetBatch.totalSizeBytes += sizeByFile.get(files[fileIndex]) ?? 0;
+		targetBatch.argsLengthChars += entryLengthChars;
+	}
+	return batches.filter((batch) => batch.fileIndexes.length > 0).map((batch) => batch.fileIndexes.sort((leftIndex, rightIndex) => leftIndex - rightIndex).map((fileIndex) => files[fileIndex]));
+};
 const projectCacheSubdir = (projectDirectory) => crypto.createHash("sha256").update(projectDirectory).digest("hex").slice(0, 16);
 const resolveReactDoctorCacheDir = (projectDirectory) => {
 	const cacheDirOverride = process.env["REACT_DOCTOR_CACHE_DIR"]?.trim();
@@ -39833,7 +39908,6 @@ const resolveUserCacheScope = () => {
 		return "shared";
 	}
 };
-const sortSourceFilesByCost = (entries) => [...entries].sort((left, right) => right.sizeBytes - left.sizeBytes).map((entry) => entry.path);
 /**
 * Atomically (re)writes the generated oxlintrc.json. Used twice in
 * the runner: once for the primary scan, once for the
@@ -39892,7 +39966,7 @@ const reactHooksJsPluginDropNote = (error) => {
 *   6. always restore disable directives + clean up the temp dir
 */
 const runOxlint = async (options) => {
-	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure, perFileLintCacheEnabled = false, onCacheStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "arrival" } = options;
+	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure, perFileLintCacheEnabled = false, onCacheStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "cost" } = options;
 	const serverAuthFunctionNames = Array.isArray(userConfig?.serverAuthFunctionNames) ? userConfig.serverAuthFunctionNames.filter((entry) => typeof entry === "string" && entry.length > 0) : void 0;
 	const severityControls = buildRuleSeverityControls(userConfig);
 	validateRuleRegistration();
@@ -39944,8 +40018,15 @@ const runOxlint = async (options) => {
 			"json",
 			...sharedArgs
 		];
-		const discoverScanFiles = () => lintBatchOrdering === "cost" ? sortSourceFilesByCost(listSourceFilesWithSize(rootDirectory)) : listSourceFiles(rootDirectory);
-		const candidateFiles = includePaths !== void 0 ? includePaths : discoverScanFiles();
+		await yieldToEventLoop();
+		const sizedScanFiles = includePaths === void 0 ? listSourceFilesWithSize(rootDirectory) : null;
+		const candidateFiles = includePaths !== void 0 ? includePaths : (sizedScanFiles ?? []).map((entry) => entry.path);
+		const sizeByFile = sizedScanFiles !== null && lintBatchOrdering === "cost" ? new Map(sizedScanFiles.map((entry) => [entry.path, entry.sizeBytes])) : null;
+		const buildFileBatches = (passBaseArgs, passFiles) => sizeByFile !== null ? planLintBatches({
+			baseArgs: passBaseArgs,
+			files: passFiles,
+			sizeByFile
+		}) : batchIncludePaths(passBaseArgs, passFiles);
 		const runConfigOverFiles = async (buildConfigForPass, configFileName, files, fileProgress) => {
 			if (files.length === 0) return {
 				diagnostics: [],
@@ -39959,7 +40040,7 @@ const runOxlint = async (options) => {
 			};
 			const passConfigPath = Path.join(configDirectory, configFileName);
 			const passBaseArgs = makeBaseArgs(passConfigPath);
-			const passFileBatches = batchIncludePaths(passBaseArgs, files);
+			const passFileBatches = buildFileBatches(passBaseArgs, files);
 			const spawnPass = () => spawnLintBatches({
 				baseArgs: passBaseArgs,
 				fileBatches: passFileBatches,
@@ -40008,6 +40089,7 @@ const runOxlint = async (options) => {
 			const cacheKeyByFile = /* @__PURE__ */ new Map();
 			const missFiles = [];
 			const replayedDiagnostics = [];
+			let hashSliceStartedAt = performance.now();
 			for (const candidateFile of candidateFiles) {
 				const contentHash = hashFileContents(Path.resolve(rootDirectory, candidateFile));
 				if (contentHash === null) {
@@ -40019,23 +40101,29 @@ const runOxlint = async (options) => {
 				const cachedDiagnostics = cache.lookup(cacheKey);
 				if (cachedDiagnostics === null) missFiles.push(candidateFile);
 				else replayedDiagnostics.push(...cachedDiagnostics);
+				if (performance.now() - hashSliceStartedAt >= 12) {
+					await yieldToEventLoop();
+					hashSliceStartedAt = performance.now();
+				}
 			}
 			const cacheHitFileCount = candidateFiles.length - missFiles.length;
-			const cacheableResult = await runConfigOverFiles((overrides) => buildConfig({
+			const fullResult = await runConfigOverFiles((overrides) => buildConfig({
 				extendsPaths: [],
-				ruleSelection: "cacheable",
 				disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin
-			}), "oxlintrc.cacheable.json", missFiles, void 0);
+			}), "oxlintrc.full.json", missFiles, options.onFileProgress && ((scannedFileCount) => options.onFileProgress?.(scannedFileCount, candidateFiles.length)));
+			const missFileSet = new Set(missFiles);
 			const sidecarResult = await runConfigOverFiles(() => buildConfig({
 				extendsPaths: [],
 				ruleSelection: "sidecar"
-			}), "oxlintrc.sidecar.json", candidateFiles, options.onFileProgress);
+			}), "oxlintrc.sidecar.json", candidateFiles.filter((candidateFile) => !missFileSet.has(candidateFile)), options.onFileProgress && ((scannedFileCount) => options.onFileProgress?.(missFiles.length + scannedFileCount, candidateFiles.length)));
+			const freshCacheableDiagnostics = [];
+			for (const diagnostic of fullResult.diagnostics) if (!CROSS_FILE_RULE_IDS.has(diagnostic.rule)) freshCacheableDiagnostics.push(diagnostic);
 			onCacheStats?.(cacheHitFileCount, candidateFiles.length);
 			const missFileByNormalizedPath = /* @__PURE__ */ new Map();
 			for (const missFile of missFiles) missFileByNormalizedPath.set(missFile.replaceAll("\\", "/"), missFile);
 			const freshDiagnosticsByFile = /* @__PURE__ */ new Map();
 			let isAttributionSound = true;
-			for (const diagnostic of cacheableResult.diagnostics) {
+			for (const diagnostic of freshCacheableDiagnostics) {
 				const missFile = missFileByNormalizedPath.get(diagnostic.filePath);
 				if (missFile === void 0) {
 					isAttributionSound = false;
@@ -40045,7 +40133,7 @@ const runOxlint = async (options) => {
 				fileDiagnostics.push(diagnostic);
 				freshDiagnosticsByFile.set(missFile, fileDiagnostics);
 			}
-			if (!cacheableResult.didDropReactHooksJsPlugin && !cacheableResult.hadPartialFailure && isAttributionSound) {
+			if (!fullResult.didDropReactHooksJsPlugin && !fullResult.hadPartialFailure && isAttributionSound) {
 				for (const missFile of missFiles) {
 					const cacheKey = cacheKeyByFile.get(missFile);
 					if (cacheKey !== void 0) cache.store(cacheKey, freshDiagnosticsByFile.get(missFile) ?? []);
@@ -40054,12 +40142,12 @@ const runOxlint = async (options) => {
 			}
 			return dedupeDiagnostics([
 				...replayedDiagnostics,
-				...cacheableResult.diagnostics,
+				...fullResult.diagnostics,
 				...sidecarResult.diagnostics
 			]);
 		}
 		const baseArgs = makeBaseArgs(configPath);
-		const fileBatches = batchIncludePaths(baseArgs, candidateFiles);
+		const fileBatches = buildFileBatches(baseArgs, candidateFiles);
 		const runBatches = () => spawnLintBatches({
 			baseArgs,
 			fileBatches,
@@ -41432,7 +41520,7 @@ const computeConfigFingerprint = (projectDirectory, version) => {
 /** Display name used in client-facing messages and progress titles. */
 const SERVER_DISPLAY_NAME = "React Doctor";
 /** Server version reported in `serverInfo`; injected at build, `dev` from source. */
-const SERVER_VERSION = "0.6.1";
+const SERVER_VERSION = "0.6.2";
 /** `Diagnostic.source` shown next to every published diagnostic. */
 const DIAGNOSTIC_SOURCE = "react-doctor";
 /**
@@ -43482,5 +43570,5 @@ const startLanguageServer = () => {
 };
 //#endregion
 export { startLanguageServer };
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="8f8aecec-ef3d-52f9-9f55-e02e7e4631ba")}catch(e){}}();
-//# debugId=8f8aecec-ef3d-52f9-9f55-e02e7e4631ba
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="ec0a0a63-f78d-58b0-abbd-1faf2b2f859a")}catch(e){}}();
+//# debugId=ec0a0a63-f78d-58b0-abbd-1faf2b2f859a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-doctor",
-  "version": "0.6.1",
+  "version": "0.6.2-dev.173cc0a",
   "description": "Your agent writes bad React. This catches it",
   "keywords": [
     "accessibility",
@@ -65,8 +65,8 @@
     "vscode-languageserver-textdocument": "^1.0.12",
     "vscode-uri": "^3.1.0",
     "yaml": "^2.9.0",
-    "deslop-js": "0.6.1",
-    "oxlint-plugin-react-doctor": "0.6.1"
+    "deslop-js": "0.6.2",
+    "oxlint-plugin-react-doctor": "0.6.2-dev.173cc0a"
   },
   "devDependencies": {
     "@types/babel__code-frame": "^7.27.0",
@@ -74,9 +74,9 @@
     "@xterm/headless": "^6.0.0",
     "commander": "^14.0.3",
     "ora": "^9.4.0",
-    "@react-doctor/api": "0.6.1",
-    "@react-doctor/core": "0.6.1",
-    "@react-doctor/language-server": "0.6.1"
+    "@react-doctor/core": "0.6.2",
+    "@react-doctor/api": "0.6.2",
+    "@react-doctor/language-server": "0.6.2"
   },
   "engines": {
     "node": "^20.19.0 || >=22.13.0"