react-doctor 0.2.8 → 0.2.10

package/dist/index.js

@@ -21,6 +21,7 @@ import * as Option from "effect/Option";
 import * as Ref from "effect/Ref";
 import * as Stream from "effect/Stream";
 import * as Cache from "effect/Cache";
+import { Worker } from "node:worker_threads";
 import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
 import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
 import * as NodePath from "@effect/platform-node-shared/NodePath";
@@ -2067,6 +2068,14 @@ var PackageJsonNotFoundError = class extends Error {
 		this.directory = directory;
 	}
 };
+var NotADirectoryError = class extends Error {
+	name = "NotADirectoryError";
+	resolvedPath;
+	constructor(resolvedPath, options) {
+		super(`Resolved scan target "${resolvedPath}" is not a directory. Ensure the path exists and points to a project directory, not a file.`, options);
+		this.resolvedPath = resolvedPath;
+	}
+};
 var AmbiguousProjectError = class extends Error {
 	name = "AmbiguousProjectError";
 	directory;
@@ -2077,7 +2086,7 @@ var AmbiguousProjectError = class extends Error {
 		this.candidates = candidates;
 	}
 };
-const isProjectDiscoveryError = (value) => value instanceof ProjectNotFoundError || value instanceof NoReactDependencyError || value instanceof PackageJsonNotFoundError || value instanceof AmbiguousProjectError;
+const isProjectDiscoveryError = (value) => value instanceof ProjectNotFoundError || value instanceof NoReactDependencyError || value instanceof PackageJsonNotFoundError || value instanceof NotADirectoryError || value instanceof AmbiguousProjectError;
 const isFile = (filePath) => {
 	try {
 		return fs.statSync(filePath).isFile();
@@ -2290,11 +2299,13 @@ const FRAMEWORK_DISPLAY_NAMES = {
 	gatsby: "Gatsby",
 	expo: "Expo",
 	"react-native": "React Native",
+	preact: "Preact",
 	unknown: "React"
 };
 const formatFrameworkName = (framework) => FRAMEWORK_DISPLAY_NAMES[framework];
 const detectFramework = (dependencies) => {
 	for (const [packageName, frameworkName] of Object.entries(FRAMEWORK_PACKAGES)) if (dependencies[packageName]) return frameworkName;
+	if (dependencies.preact && !dependencies.react) return "preact";
 	return "unknown";
 };
 const UPPER_BOUND_COMPARATOR = /<\s*=?\s*\d+(?:\.\d+){0,2}(?:-[^\s,|]+)?/g;
@@ -2758,6 +2769,13 @@ const hasReactNativeWorkspaceAnywhere = (rootDirectory, rootPackageJson) => {
 	}
 	return false;
 };
+const hasPreact = (packageJson) => {
+	return "preact" in {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+};
 const TANSTACK_QUERY_PACKAGES = new Set([
 	"@tanstack/react-query",
 	"@tanstack/query-core",
@@ -2795,7 +2813,8 @@ const resolveEffectiveReactMajor = (reactVersion, packageJson) => {
 const REACT_DEPENDENCY_NAMES = new Set([
 	"react",
 	"react-native",
-	"next"
+	"next",
+	"preact"
 ]);
 const hasReactDependency = (packageJson) => {
 	const allDependencies = {
@@ -2957,12 +2976,47 @@ const discoverProject = (directory) => {
 		hasTypeScript,
 		hasReactCompiler: detectReactCompiler(directory, packageJson),
 		hasTanStackQuery: hasTanStackQuery(packageJson),
+		hasPreact: hasPreact(packageJson),
 		hasReactNativeWorkspace,
 		sourceFileCount
 	};
 	cachedProjectInfos.set(directory, projectInfo);
 	return projectInfo;
 };
+const MAJOR_MINOR_PATTERN = /(\d{1,4})\.(\d{1,4})/;
+const MAJOR_ONLY_PATTERN = /(\d{1,4})/;
+const UPPER_BOUND_COMPARATOR_PATTERN = /<=?\s{0,8}\d{1,4}(?:\.\d{1,4}){0,2}(?:-[^\s,|]+)?/g;
+const parseReactMajorMinor = (reactVersion) => {
+	if (typeof reactVersion !== "string") return null;
+	const trimmed = reactVersion.trim();
+	if (trimmed.length === 0) return null;
+	const lowerBoundsOnly = trimmed.replace(UPPER_BOUND_COMPARATOR_PATTERN, " ").trim();
+	if (lowerBoundsOnly.length === 0) return null;
+	const majorMinorMatch = lowerBoundsOnly.match(MAJOR_MINOR_PATTERN);
+	if (majorMinorMatch) {
+		const major = Number.parseInt(majorMinorMatch[1], 10);
+		const minor = Number.parseInt(majorMinorMatch[2], 10);
+		if (!Number.isFinite(major) || major <= 0) return null;
+		if (!Number.isFinite(minor) || minor < 0) return null;
+		return {
+			major,
+			minor
+		};
+	}
+	const majorOnlyMatch = lowerBoundsOnly.match(MAJOR_ONLY_PATTERN);
+	if (!majorOnlyMatch) return null;
+	const major = Number.parseInt(majorOnlyMatch[1], 10);
+	if (!Number.isFinite(major) || major <= 0) return null;
+	return {
+		major,
+		minor: 0
+	};
+};
+const isReactAtLeast = (detected, required) => {
+	if (detected === null) return true;
+	if (detected.major !== required.major) return detected.major > required.major;
+	return detected.minor >= required.minor;
+};
 const parseTailwindMajorMinor = (tailwindVersion) => {
 	if (typeof tailwindVersion !== "string") return null;
 	const trimmed = tailwindVersion.trim();
@@ -2993,6 +3047,7 @@ const isTailwindAtLeast = (detected, required) => {
 	return detected.minor >= required.minor;
 };
 const JSX_FILE_PATTERN = /\.(tsx|jsx)$/;
+const MILLISECONDS_PER_SECOND = 1e3;
 const SCORE_API_URL = "https://www.react.doctor/api/score";
 const FETCH_TIMEOUT_MS = 1e4;
 const GITHUB_VIEWER_PERMISSION_TIMEOUT_MS = 2e3;
@@ -4160,8 +4215,10 @@ const resolveScanTarget = (requestedDirectory) => {
 	const configSourceDirectory = loadedConfig?.sourceDirectory ?? null;
 	const redirectedDirectory = resolveConfigRootDir(userConfig, configSourceDirectory);
 	const directoryAfterRedirect = redirectedDirectory ?? absoluteRequested;
+	const resolvedDirectory = resolveDiagnoseTarget(directoryAfterRedirect) ?? directoryAfterRedirect;
+	if (!isDirectory(resolvedDirectory)) throw existsSync(resolvedDirectory) ? new NotADirectoryError(resolvedDirectory) : new ProjectNotFoundError(resolvedDirectory);
 	return {
-		resolvedDirectory: resolveDiagnoseTarget(directoryAfterRedirect) ?? directoryAfterRedirect,
+		resolvedDirectory,
 		requestedDirectory: absoluteRequested,
 		userConfig,
 		configSourceDirectory,
@@ -4512,6 +4569,49 @@ const collectIgnorePatterns = (rootDirectory) => {
 	return patterns;
 };
 const TSCONFIG_FILENAMES$1 = ["tsconfig.json", "tsconfig.base.json"];
+const DEAD_CODE_WORKER_SCRIPT = `
+const { parentPort, workerData } = require("node:worker_threads");
+
+const normalizeResult = (result) => ({
+  unusedFiles: result.unusedFiles.map((unusedFile) => ({
+    path: unusedFile.path,
+  })),
+  unusedExports: result.unusedExports.map((unusedExport) => ({
+    path: unusedExport.path,
+    name: unusedExport.name,
+    line: unusedExport.line,
+    column: unusedExport.column,
+    isTypeOnly: unusedExport.isTypeOnly,
+  })),
+  unusedDependencies: result.unusedDependencies.map((unusedDependency) => ({
+    name: unusedDependency.name,
+    isDevDependency: unusedDependency.isDevDependency,
+  })),
+  circularDependencies: result.circularDependencies.map((cycle) => ({
+    files: cycle.files,
+  })),
+});
+
+const serializeError = (error) =>
+  error instanceof Error
+    ? { name: error.name, message: error.message, stack: error.stack }
+    : { message: String(error) };
+
+(async () => {
+  try {
+    const { analyze, defineConfig } = await import(workerData.deslopJsModuleSpecifier);
+    const config = {
+      rootDir: workerData.rootDirectory,
+      ...(workerData.tsConfigPath ? { tsConfigPath: workerData.tsConfigPath } : {}),
+      ...(workerData.ignorePatterns.length > 0 ? { ignorePatterns: workerData.ignorePatterns } : {}),
+    };
+    const result = await analyze(defineConfig(config));
+    parentPort.postMessage({ ok: true, result: normalizeResult(result) });
+  } catch (error) {
+    parentPort.postMessage({ ok: false, error: serializeError(error) });
+  }
+})();
+`;
 const resolveTsConfigPath = (rootDirectory) => {
 	for (const filename of TSCONFIG_FILENAMES$1) {
 		const candidate = path.join(rootDirectory, filename);
@@ -4532,16 +4632,180 @@ const toRelativeFilePath = (rootDirectory, filePath) => {
 	const relative = toRelativePath(filePath, rootDirectory);
 	return relative.length > 0 ? relative : filePath.replace(/\\/g, "/");
 };
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseArray = (value, label) => {
+	if (!Array.isArray(value)) throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseString = (value, label) => {
+	if (typeof value !== "string") throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseNumber = (value, label) => {
+	if (typeof value !== "number") throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseBoolean = (value, label) => {
+	if (typeof value !== "boolean") throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseStringArray = (value, label) => {
+	return parseArray(value, label).map((entry, index) => parseString(entry, `${label}[${index}]`));
+};
+const parseUnusedFiles = (value) => {
+	const values = parseArray(value, "unusedFiles");
+	const unusedFiles = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid unusedFiles[${index}].`);
+		unusedFiles.push({ path: parseString(entry.path, `unusedFiles[${index}].path`) });
+	}
+	return unusedFiles;
+};
+const parseUnusedExports = (value) => {
+	const values = parseArray(value, "unusedExports");
+	const unusedExports = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid unusedExports[${index}].`);
+		unusedExports.push({
+			path: parseString(entry.path, `unusedExports[${index}].path`),
+			name: parseString(entry.name, `unusedExports[${index}].name`),
+			line: parseNumber(entry.line, `unusedExports[${index}].line`),
+			column: parseNumber(entry.column, `unusedExports[${index}].column`),
+			isTypeOnly: parseBoolean(entry.isTypeOnly, `unusedExports[${index}].isTypeOnly`)
+		});
+	}
+	return unusedExports;
+};
+const parseUnusedDependencies = (value) => {
+	const values = parseArray(value, "unusedDependencies");
+	const unusedDependencies = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid unusedDependencies[${index}].`);
+		unusedDependencies.push({
+			name: parseString(entry.name, `unusedDependencies[${index}].name`),
+			isDevDependency: parseBoolean(entry.isDevDependency, `unusedDependencies[${index}].isDevDependency`)
+		});
+	}
+	return unusedDependencies;
+};
+const parseCircularDependencies = (value) => {
+	const values = parseArray(value, "circularDependencies");
+	const circularDependencies = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid circularDependencies[${index}].`);
+		circularDependencies.push({ files: parseStringArray(entry.files, `circularDependencies[${index}].files`) });
+	}
+	return circularDependencies;
+};
+const parseDeadCodeWorkerResult = (value) => {
+	if (!isRecord(value)) throw new Error("Dead-code worker returned an invalid result.");
+	return {
+		unusedFiles: parseUnusedFiles(value.unusedFiles),
+		unusedExports: parseUnusedExports(value.unusedExports),
+		unusedDependencies: parseUnusedDependencies(value.unusedDependencies),
+		circularDependencies: parseCircularDependencies(value.circularDependencies)
+	};
+};
+const parseDeadCodeWorkerError = (value) => {
+	if (!isRecord(value) || typeof value.message !== "string") return { message: "Dead-code worker failed." };
+	return {
+		...typeof value.name === "string" ? { name: value.name } : {},
+		message: value.message,
+		...typeof value.stack === "string" ? { stack: value.stack } : {}
+	};
+};
+const parseDeadCodeWorkerMessage = (value) => {
+	if (!isRecord(value)) throw new Error("Dead-code worker returned an invalid message.");
+	if (value.ok === true) return {
+		ok: true,
+		result: value.result
+	};
+	if (value.ok === false) return {
+		ok: false,
+		error: parseDeadCodeWorkerError(value.error)
+	};
+	throw new Error("Dead-code worker returned an invalid status.");
+};
+const buildDeadCodeWorkerError = (workerError) => {
+	const error = new Error(workerError.message);
+	if (workerError.name !== void 0) error.name = workerError.name;
+	if (workerError.stack !== void 0) error.stack = workerError.stack;
+	return error;
+};
+const createDeadCodeWorker = (input) => {
+	const worker = new Worker(DEAD_CODE_WORKER_SCRIPT, {
+		eval: true,
+		workerData: input
+	});
+	let didSettle = false;
+	return {
+		result: new Promise((resolve, reject) => {
+			const settle = (callback) => {
+				if (didSettle) return;
+				didSettle = true;
+				worker.removeAllListeners();
+				callback();
+			};
+			worker.once("message", (message) => {
+				try {
+					const parsedMessage = parseDeadCodeWorkerMessage(message);
+					if (parsedMessage.ok) {
+						settle(() => resolve(parsedMessage.result));
+						return;
+					}
+					settle(() => reject(buildDeadCodeWorkerError(parsedMessage.error)));
+				} catch (error) {
+					settle(() => reject(error));
+				}
+			});
+			worker.once("error", (error) => {
+				settle(() => reject(error));
+			});
+			worker.once("exit", (exitCode) => {
+				if (exitCode === 0) return;
+				settle(() => reject(/* @__PURE__ */ new Error(`Dead-code worker exited with code ${exitCode}.`)));
+			});
+		}),
+		terminate: () => {
+			didSettle = true;
+			worker.removeAllListeners();
+			return worker.terminate();
+		}
+	};
+};
+const runDeadCodeWorkerWithTimeout = (handle, timeoutMs) => new Promise((resolve, reject) => {
+	let didSettle = false;
+	const timeoutHandle = setTimeout(() => {
+		if (didSettle) return;
+		didSettle = true;
+		handle.terminate?.();
+		reject(/* @__PURE__ */ new Error(`Dead-code worker timed out after ${timeoutMs / MILLISECONDS_PER_SECOND}s.`));
+	}, timeoutMs);
+	timeoutHandle.unref?.();
+	handle.result.then((value) => {
+		if (didSettle) return;
+		didSettle = true;
+		clearTimeout(timeoutHandle);
+		handle.terminate?.();
+		resolve(value);
+	}, (error) => {
+		if (didSettle) return;
+		didSettle = true;
+		clearTimeout(timeoutHandle);
+		handle.terminate?.();
+		reject(error);
+	});
+});
 const checkDeadCode = async (options) => {
 	const { rootDirectory, userConfig } = options;
 	if (!fs.existsSync(path.join(rootDirectory, "package.json"))) return [];
-	const { analyze, defineConfig } = await import("deslop-js");
 	const ignorePatterns = collectDeadCodeIgnorePatterns(rootDirectory, userConfig);
-	const result = await analyze(defineConfig({
-		rootDir: rootDirectory,
+	const result = parseDeadCodeWorkerResult(await runDeadCodeWorkerWithTimeout((options.createWorker ?? createDeadCodeWorker)({
+		rootDirectory,
 		tsConfigPath: resolveTsConfigPath(rootDirectory),
-		...ignorePatterns.length > 0 ? { ignorePatterns } : {}
-	}));
+		ignorePatterns,
+		deslopJsModuleSpecifier: options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js")
+	}), options.workerTimeoutMs ?? 12e4));
 	const toRelative = (filePath) => toRelativeFilePath(rootDirectory, filePath);
 	const diagnostics = [];
 	for (const unusedFile of result.unusedFiles) diagnostics.push({
@@ -4645,7 +4909,7 @@ var Files = class Files extends Context.Service()("react-doctor/Files") {
 	* pattern in react-doctor-evals' test layers.
 	*/
 	static layerInMemory = (tree) => {
-		const resolveAbsolute = (filePath, rootDirectory) => Path.isAbsolute(filePath) ? filePath : Path.join(rootDirectory, filePath);
+		const resolveAbsolute = (filePath, rootDirectory) => Path.isAbsolute(filePath) ? filePath : `${rootDirectory}/${filePath}`;
 		return Layer.succeed(Files, Files.of({
 			readLines: (input) => Effect.sync(() => {
 				const absolute = resolveAbsolute(input.filePath, input.rootDirectory);
@@ -4653,17 +4917,17 @@ var Files = class Files extends Context.Service()("react-doctor/Files") {
 				return content === void 0 ? null : content.split("\n");
 			}),
 			listSourceFiles: (rootDirectory) => Effect.sync(() => {
-				const prefix = rootDirectory.endsWith(Path.sep) ? rootDirectory : `${rootDirectory}${Path.sep}`;
+				const prefix = rootDirectory.endsWith("/") ? rootDirectory : `${rootDirectory}/`;
 				const files = [];
 				for (const absolute of tree.keys()) {
 					if (!absolute.startsWith(prefix)) continue;
-					files.push(absolute.slice(prefix.length).split(Path.sep).join("/"));
+					files.push(absolute.slice(prefix.length));
 				}
 				return files;
 			}),
 			isFile: (filePath) => Effect.sync(() => tree.has(filePath)),
 			isDirectory: (filePath) => Effect.sync(() => {
-				const prefix = filePath.endsWith(Path.sep) ? filePath : `${filePath}${Path.sep}`;
+				const prefix = filePath.endsWith("/") ? filePath : `${filePath}/`;
 				for (const absolute of tree.keys()) if (absolute.startsWith(prefix)) return true;
 				return false;
 			})
@@ -5165,7 +5429,15 @@ const buildCapabilities = (project) => {
 	capabilities.add(project.framework);
 	if (project.framework === "expo" || project.framework === "react-native" || project.hasReactNativeWorkspace) capabilities.add("react-native");
 	const reactMajor = project.reactMajorVersion;
-	if (reactMajor !== null) for (let major = 17; major <= reactMajor; major++) capabilities.add(`react:${major}`);
+	if (reactMajor !== null) {
+		for (let major = 17; major <= reactMajor; major++) capabilities.add(`react:${major}`);
+		if (reactMajor >= 19) {
+			if (isReactAtLeast(parseReactMajorMinor(project.reactVersion), {
+				major: 19,
+				minor: 2
+			})) capabilities.add("react:19.2");
+		}
+	}
 	if (project.tailwindVersion !== null) {
 		capabilities.add("tailwind");
 		if (isTailwindAtLeast(parseTailwindMajorMinor(project.tailwindVersion), {
@@ -5176,6 +5448,10 @@ const buildCapabilities = (project) => {
 	if (project.hasReactCompiler) capabilities.add("react-compiler");
 	if (project.hasTanStackQuery) capabilities.add("tanstack-query");
 	if (project.hasTypeScript) capabilities.add("typescript");
+	if (project.hasPreact) {
+		capabilities.add("preact");
+		if (project.reactVersion === null) capabilities.add("pure-preact");
+	}
 	return capabilities;
 };
 const shouldEnableRule = (requires, tags, capabilities, ignoredTags, disabledBy) => {
@@ -5800,7 +6076,7 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 		const primaryLabel = diagnostic.labels[0];
 		const cleaned = cleanDiagnosticMessage(diagnostic.message, diagnostic.help, plugin, rule, project);
 		return {
-			filePath: diagnostic.filename,
+			filePath: diagnostic.filename.replaceAll("\\", "/"),
 			plugin,
 			rule,
 			severity: diagnostic.severity,
@@ -6505,17 +6781,6 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 		didFail: false,
 		reason: null
 	});
-	const shouldRunDeadCode = input.runDeadCode && !isDiffMode;
-	const deadCodeFiber = yield* Effect.forkChild(shouldRunDeadCode ? Stream.runCollect(applyPerElementPipeline(deadCodeService.run({
-		rootDirectory: scanDirectory,
-		userConfig: resolvedConfig.config
-	}).pipe(Stream.catchTag("ReactDoctorError", (error) => Stream.unwrap(Effect.gen(function* () {
-		yield* Ref.set(deadCodeFailure, {
-			didFail: true,
-			reason: error.message
-		});
-		return Stream.empty;
-	})))))) : Effect.succeed([]));
 	const scanProgress = yield* progressService.start("Scanning...");
 	const scanStartTime = Date.now();
 	let lastReportedTotalFileCount = 0;
@@ -6545,11 +6810,18 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 	const lintCollected = yield* Stream.runCollect(applyPerElementPipeline(rawLintStream));
 	const lintFailureState = yield* Ref.get(lintFailure);
 	yield* afterLint(lintFailureState.didFail);
-	if (lintFailureState.didFail) {
-		yield* Fiber.interrupt(deadCodeFiber);
-		yield* scanProgress.fail(formatLintFailText(lintFailureState.reasonTag, process.version));
-	}
-	const deadCodeCollected = lintFailureState.didFail ? [] : yield* Fiber.join(deadCodeFiber);
+	if (lintFailureState.didFail) yield* scanProgress.fail(formatLintFailText(lintFailureState.reasonTag, process.version));
+	const shouldRunDeadCode = input.runDeadCode && !isDiffMode;
+	const deadCodeCollected = lintFailureState.didFail || !shouldRunDeadCode ? [] : yield* scanProgress.update("Analyzing dead code...").pipe(Effect.andThen(Stream.runCollect(applyPerElementPipeline(deadCodeService.run({
+		rootDirectory: scanDirectory,
+		userConfig: resolvedConfig.config
+	}).pipe(Stream.catchTag("ReactDoctorError", (error) => Stream.unwrap(Effect.gen(function* () {
+		yield* Ref.set(deadCodeFailure, {
+			didFail: true,
+			reason: error.message
+		});
+		return Stream.empty;
+	}))))))));
 	const deadCodeFailureState = yield* Ref.get(deadCodeFailure);
 	const scanElapsedSeconds = ((Date.now() - scanStartTime) / 1e3).toFixed(1);
 	const totalFileCount = lastReportedTotalFileCount || (lintIncludePaths?.length ?? project.sourceFileCount);
@@ -6602,22 +6874,7 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 	"inspect.isCi": input.isCi,
 	"inspect.scoreSurface": input.scoreSurface ?? "score"
 } }));
-/**
-* Default layer stack for the production CLI / programmatic API:
-* real Node-side services for Project / Config / Files / Git / Linter /
-* DeadCode; HTTP for Score; noop Progress (the CLI overrides with
-* `Progress.layerOra(...)` for terminal feedback); the silent Reporter
-* (the orchestrator already returns the diagnostic array via
-* `Stream.runCollect`).
-*
-* Callers tweak by replacing individual layers: `--no-score` swaps
-* `Score.layerHttp` for `Score.layerOf(null)`; `--no-lint` swaps
-* `Linter.layerOxlint` for `Linter.layerOf([])`; `--no-dead-code`
-* swaps `DeadCode.layerNode` for `DeadCode.layerOf([])`; a caller
-* with a pre-loaded config swaps `Config.layerNode` for
-* `Config.layerOf(resolved)`.
-*/
-const layerInspectLive = Layer.mergeAll(Project.layerNode, Config.layerNode, DeadCode.layerNode, Files.layerNode, Git.layerNode, Linter.layerOxlint, LintPartialFailures.layerLive, Progress.layerNoop, Reporter.layerNoop, Score.layerHttp);
+Layer.mergeAll(Project.layerNode, Config.layerNode, DeadCode.layerNode, Files.layerNode, Git.layerNode, Linter.layerOxlint, LintPartialFailures.layerLive, Progress.layerNoop, Reporter.layerNoop, Score.layerHttp);
 const parseNodeVersion = (versionString) => {
 	const [major = 0, minor = 0, patch = 0] = versionString.replace(/^v/, "").trim().split(".").map(Number);
 	return {
@@ -7021,22 +7278,23 @@ import_picocolors.default.red, import_picocolors.default.yellow, import_picocolo
 const clearAutoSuppressionCaches = () => {};
 //#endregion
 //#region ../api/dist/index.js
-const diagnose = async (directory, options = {}) => {
-	const startTime = globalThis.performance.now();
-	const scanTarget = resolveScanTarget(directory);
+const DEFAULT_LAYER = Layer.mergeAll(Project.layerNode, Config.layerNode, DeadCode.layerNode, Files.layerNode, Git.layerNode, Linter.layerOxlint, LintPartialFailures.layerLive, Progress.layerNoop, Reporter.layerNoop, Score.layerHttp);
+const buildInspectProgram = (scanTarget, options, configOverride) => {
+	const effectiveConfig = configOverride ?? scanTarget.userConfig;
 	const includePaths = options.includePaths ?? [];
-	const program = runInspect({
+	return runInspect({
 		directory: scanTarget.resolvedDirectory,
 		includePaths,
-		customRulesOnly: scanTarget.userConfig?.customRulesOnly ?? false,
-		respectInlineDisables: options.respectInlineDisables ?? scanTarget.userConfig?.respectInlineDisables ?? true,
-		adoptExistingLintConfig: scanTarget.userConfig?.adoptExistingLintConfig ?? true,
-		ignoredTags: new Set(scanTarget.userConfig?.ignore?.tags ?? []),
-		runDeadCode: options.deadCode ?? scanTarget.userConfig?.deadCode ?? true,
+		customRulesOnly: effectiveConfig?.customRulesOnly ?? false,
+		respectInlineDisables: options.respectInlineDisables ?? effectiveConfig?.respectInlineDisables ?? true,
+		adoptExistingLintConfig: effectiveConfig?.adoptExistingLintConfig ?? true,
+		ignoredTags: new Set(effectiveConfig?.ignore?.tags ?? []),
+		runDeadCode: options.deadCode ?? effectiveConfig?.deadCode ?? true,
 		isCi: false,
 		resolveLocalGithubViewerPermission: true
 	});
-	const output = await Effect.runPromise(restoreLegacyThrow(program.pipe(Effect.provide(layerInspectLive), Effect.provide(layerOtlp))));
+};
+const outputToDiagnoseResult = (output, elapsedMilliseconds) => {
 	if (output.didLintFail && output.lintFailureReason !== null) console.error("Lint failed:", output.lintFailureReason);
 	const skippedChecks = [];
 	const skippedCheckReasons = {};
@@ -7050,9 +7308,14 @@ const diagnose = async (directory, options = {}) => {
 		skippedChecks,
 		...Object.keys(skippedCheckReasons).length > 0 ? { skippedCheckReasons } : {},
 		project: output.project,
-		elapsedMilliseconds: globalThis.performance.now() - startTime
+		elapsedMilliseconds
 	};
 };
+const diagnose = async (directory, options = {}) => {
+	const startTime = globalThis.performance.now();
+	const program = buildInspectProgram(resolveScanTarget(directory), options);
+	return outputToDiagnoseResult(await Effect.runPromise(restoreLegacyThrow(program.pipe(Effect.provide(DEFAULT_LAYER), Effect.provide(layerOtlp)))), globalThis.performance.now() - startTime);
+};
 //#endregion
 //#region src/index.ts
 const clearCaches = () => {
@@ -7081,6 +7344,6 @@ const toJsonReport = (result, options) => buildJsonReport({
 	totalElapsedMilliseconds: result.elapsedMilliseconds
 });
 //#endregion
-export { AmbiguousProjectError, NoReactDependencyError, PackageJsonNotFoundError, ProjectNotFoundError, ReactDoctorError, buildJsonReport, buildJsonReportError, clearCaches, diagnose, filterSourceFiles, getDiffInfo, isProjectDiscoveryError, isReactDoctorError, summarizeDiagnostics, toJsonReport };
+export { AmbiguousProjectError, NoReactDependencyError, NotADirectoryError, PackageJsonNotFoundError, ProjectNotFoundError, ReactDoctorError, buildJsonReport, buildJsonReportError, clearCaches, diagnose, filterSourceFiles, getDiffInfo, isProjectDiscoveryError, isReactDoctorError, summarizeDiagnostics, toJsonReport };
 
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-doctor",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Diagnose and fix React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",
@@ -58,21 +58,21 @@
     "oxlint": "^1.66.0",
     "prompts": "^2.4.2",
     "typescript": ">=5.0.4 <7",
-    "oxlint-plugin-react-doctor": "0.2.8"
+    "oxlint-plugin-react-doctor": "0.2.10"
   },
   "devDependencies": {
     "@types/prompts": "^2.4.9",
     "commander": "^14.0.3",
     "ora": "^9.4.0",
-    "@react-doctor/api": "0.2.8",
-    "@react-doctor/core": "0.2.8"
+    "@react-doctor/api": "0.2.10",
+    "@react-doctor/core": "0.2.10"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },
   "scripts": {
     "dev": "vp pack --watch",
-    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && NODE_ENV=production vp pack",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && cross-env NODE_ENV=production vp pack",
     "typecheck": "tsc --noEmit",
     "test": "vp test run"
   }