react-doctor 0.2.9 → 0.2.11

package/dist/{cli-logger-BliQX9s8.js → cli-logger-pbFEieEc.js}

@@ -2272,11 +2272,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;
@@ -2695,6 +2697,21 @@ const findDependencyInfoFromMonorepoRoot = (directory) => {
 		framework: rootInfo.framework !== "unknown" ? rootInfo.framework : workspaceInfo.framework
 	};
 };
+const someWorkspacePackageJson = (rootDirectory, rootPackageJson, predicate) => {
+	if (predicate(rootPackageJson)) return true;
+	const patterns = getWorkspacePatterns(rootDirectory, rootPackageJson);
+	if (patterns.length === 0) return false;
+	const visitedDirectories = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) {
+		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
+		for (const workspaceDirectory of directories) {
+			if (visitedDirectories.has(workspaceDirectory)) continue;
+			visitedDirectories.add(workspaceDirectory);
+			if (predicate(readPackageJson(path.join(workspaceDirectory, "package.json")))) return true;
+		}
+	}
+	return false;
+};
 const NAMES = new Set([
 	"react-native",
 	"react-native-tvos",
@@ -2725,20 +2742,13 @@ const isPackageJsonReactNativeAware = (packageJson) => {
 	if (containsAnyReactNativeDependency(packageJson.optionalDependencies)) return true;
 	return false;
 };
-const hasReactNativeWorkspaceAnywhere = (rootDirectory, rootPackageJson) => {
-	if (isPackageJsonReactNativeAware(rootPackageJson)) return true;
-	const patterns = getWorkspacePatterns(rootDirectory, rootPackageJson);
-	if (patterns.length === 0) return false;
-	const visitedDirectories = /* @__PURE__ */ new Set();
-	for (const pattern of patterns) {
-		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
-		for (const workspaceDirectory of directories) {
-			if (visitedDirectories.has(workspaceDirectory)) continue;
-			visitedDirectories.add(workspaceDirectory);
-			if (isPackageJsonReactNativeAware(readPackageJson(path.join(workspaceDirectory, "package.json")))) return true;
-		}
-	}
-	return false;
+const hasReactNativeWorkspaceAnywhere = (rootDirectory, rootPackageJson) => someWorkspacePackageJson(rootDirectory, rootPackageJson, isPackageJsonReactNativeAware);
+const hasPreact = (packageJson) => {
+	return "preact" in {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
 };
 const TANSTACK_QUERY_PACKAGES = new Set([
 	"@tanstack/react-query",
@@ -2753,6 +2763,16 @@ const hasTanStackQuery = (packageJson) => {
 	};
 	return Object.keys(allDependencies).some((packageName) => TANSTACK_QUERY_PACKAGES.has(packageName));
 };
+const REANIMATED_DEPENDENCY_NAME = "react-native-reanimated";
+const isPackageJsonReanimatedAware = (packageJson) => {
+	const allDependencies = {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies,
+		...packageJson.optionalDependencies
+	};
+	return Object.hasOwn(allDependencies, REANIMATED_DEPENDENCY_NAME);
+};
 const hasUpperBoundOnlyPeerRange = (range) => {
 	if (typeof range !== "string") return false;
 	const normalizedRange = normalizeDependencyVersion(range);
@@ -2777,7 +2797,8 @@ const resolveEffectiveReactMajor = (reactVersion, packageJson) => {
 const REACT_DEPENDENCY_NAMES = new Set([
 	"react",
 	"react-native",
-	"next"
+	"next",
+	"preact"
 ]);
 const hasReactDependency = (packageJson) => {
 	const allDependencies = {
@@ -2926,6 +2947,7 @@ const discoverProject = (directory) => {
 	const hasTypeScript = fs.existsSync(path.join(directory, "tsconfig.json"));
 	const sourceFileCount = countSourceFiles(directory);
 	const hasReactNativeWorkspace = framework === "expo" || framework === "react-native" || hasReactNativeWorkspaceAnywhere(directory, packageJson);
+	const hasReanimated = hasReactNativeWorkspace && someWorkspacePackageJson(directory, packageJson, isPackageJsonReanimatedAware);
 	const projectInfo = {
 		rootDirectory: directory,
 		projectName,
@@ -2936,12 +2958,48 @@ const discoverProject = (directory) => {
 		hasTypeScript,
 		hasReactCompiler: detectReactCompiler(directory, packageJson),
 		hasTanStackQuery: hasTanStackQuery(packageJson),
+		hasPreact: hasPreact(packageJson),
 		hasReactNativeWorkspace,
+		hasReanimated,
 		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();
@@ -2972,6 +3030,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 SHARE_BASE_URL = "https://www.react.doctor/share";
 const FETCH_TIMEOUT_MS = 1e4;
@@ -4491,6 +4550,59 @@ const collectIgnorePatterns = (rootDirectory) => {
 	return patterns;
 };
 const TSCONFIG_FILENAMES$1 = ["tsconfig.json", "tsconfig.base.json"];
+const DEAD_CODE_WORKER_SCRIPT = `
+const inputChunks = [];
+process.stdin.on("data", (chunk) => inputChunks.push(chunk));
+process.stdin.on("end", () => {
+  const workerInput = JSON.parse(Buffer.concat(inputChunks).toString("utf8"));
+
+  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) };
+
+  const emit = (message) => {
+    process.stdout.write(JSON.stringify(message), () => process.exit(0));
+  };
+
+  (async () => {
+    try {
+      const { analyze, defineConfig } = await import(workerInput.deslopJsModuleSpecifier);
+      const config = {
+        rootDir: workerInput.rootDirectory,
+        ...(workerInput.tsConfigPath ? { tsConfigPath: workerInput.tsConfigPath } : {}),
+        ...(workerInput.ignorePatterns.length > 0
+          ? { ignorePatterns: workerInput.ignorePatterns }
+          : {}),
+      };
+      const result = await analyze(defineConfig(config));
+      emit({ ok: true, result: normalizeResult(result) });
+    } catch (error) {
+      emit({ ok: false, error: serializeError(error) });
+    }
+  })();
+});
+`;
 const resolveTsConfigPath = (rootDirectory) => {
 	for (const filename of TSCONFIG_FILENAMES$1) {
 		const candidate = path.join(rootDirectory, filename);
@@ -4511,16 +4623,191 @@ 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 child = spawn(process.execPath, ["-e", DEAD_CODE_WORKER_SCRIPT], {
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true
+	});
+	const stdoutChunks = [];
+	const stderrChunks = [];
+	child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+	child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+	let didSettle = false;
+	const result = new Promise((resolve, reject) => {
+		const settle = (callback) => {
+			if (didSettle) return;
+			didSettle = true;
+			callback();
+		};
+		child.once("error", (error) => {
+			settle(() => reject(error));
+		});
+		child.once("close", (exitCode) => {
+			const stdout = Buffer.concat(stdoutChunks).toString("utf8").trim();
+			if (stdout.length === 0) {
+				const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+				settle(() => reject(/* @__PURE__ */ new Error(`Dead-code worker exited with code ${exitCode ?? "null"}${stderr ? `: ${stderr}` : ""}.`)));
+				return;
+			}
+			try {
+				const parsedMessage = parseDeadCodeWorkerMessage(JSON.parse(stdout));
+				if (parsedMessage.ok) {
+					settle(() => resolve(parsedMessage.result));
+					return;
+				}
+				settle(() => reject(buildDeadCodeWorkerError(parsedMessage.error)));
+			} catch (error) {
+				settle(() => reject(error));
+			}
+		});
+	});
+	child.stdin.on("error", () => {});
+	child.stdin.end(JSON.stringify(input));
+	return {
+		result,
+		terminate: () => {
+			didSettle = true;
+			child.kill("SIGKILL");
+		}
+	};
+};
+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({
@@ -5144,7 +5431,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), {
@@ -5155,6 +5450,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) => {
@@ -5409,6 +5708,13 @@ const buildNoSecretsRecommendation = (project, fallbackRecommendation) => {
 	if (!publicEnvPrefix) return fallbackRecommendation;
 	return `Move secrets to server-only code. In ${formatFrameworkName(project.framework)}, only \`${publicEnvPrefix}\` env vars are exposed to the browser, and they must not contain secrets`;
 };
+const REANIMATED_SHARED_VALUE_HINT = "If this is a Reanimated shared value, prefer its React Compiler-compatible `.get()` / `.set()` accessors over `.value` — https://docs.swmansion.com/react-native-reanimated/docs/core/useSharedValue/#react-compiler-support";
+const appendReanimatedSharedValueHint = (help, rule, project) => {
+	if (rule !== "immutability") return help;
+	if (!project.hasReanimated) return help;
+	if (!help) return REANIMATED_SHARED_VALUE_HINT;
+	return `${help}\n\n${REANIMATED_SHARED_VALUE_HINT}`;
+};
 const REACT_MODULE_SOURCE = "react";
 const REQUIRE_IDENTIFIER = "require";
 const USE_IDENTIFIER = "use";
@@ -5732,7 +6038,7 @@ const getRuleCategory = (ruleName) => reactDoctorPlugin.rules[ruleName]?.categor
 const cleanDiagnosticMessage = (message, help, plugin, rule, project) => {
 	if (plugin === "react-hooks-js") return {
 		message: REACT_COMPILER_MESSAGE,
-		help: message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || help
+		help: appendReanimatedSharedValueHint(message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || help, rule, project)
 	};
 	return {
 		message: message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || message,
@@ -6484,17 +6790,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;
@@ -6524,11 +6819,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);
@@ -7023,7 +7325,7 @@ var cli_logger_exports = /* @__PURE__ */ __exportAll({ cliLogger: () => cliLogge
 /**
 * Thin synchronous façade over Effect's `Console` module. Used by
 * the imperative CLI helper files (`select-projects`, `run-explain`,
-* `install-skill`, the legacy paths in `cli/commands/inspect.ts`)
+* `install-react-doctor`, the legacy paths in `cli/commands/inspect.ts`)
 * that aren't yet Effect-typed. Every call drains into a single
 * `Console.*` Effect via `Effect.runSync`, so the underlying logging
 * pipeline is identical to the canonical `yield* Console.log(...)`
@@ -7056,4 +7358,4 @@ const cliLogger = {
 //#endregion
 export { isReactDoctorError as A, filterSourceFiles as C, groupBy as D, getDiffInfo as E, runInspect as F, toRelativePath as I, listWorkspacePackages as M, resolveScanTarget as N, highlighter as O, restoreLegacyThrow as P, filterDiagnosticsForSurface as S, formatReactDoctorError as T, Score as _, DeadCode as a, buildJsonReportError as b, LintPartialFailures as c, OXLINT_NODE_REQUIREMENT as d, Progress as f, SKILL_NAME as g, SHARE_BASE_URL as h, Config as i, layerOtlp as j, isMonorepoRoot as k, Linter as l, Reporter as m, cli_logger_exports as n, Files as o, Project as p, CANONICAL_GITHUB_URL as r, Git as s, cliLogger as t, NodeResolver as u, StagedFiles as v, formatErrorChain as w, discoverReactSubprojects as x, buildJsonReport as y };
 
-//# sourceMappingURL=cli-logger-BliQX9s8.js.map
+//# sourceMappingURL=cli-logger-pbFEieEc.js.map