react-doctor 0.9.1-dev.b1b62db → 0.9.2-dev.01ca0b3

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]="cf9aea89-a185-53f6-9e42-7af2cece64f2")}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]="bb982094-8280-5afe-b061-eb103665c55c")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as NodeChildProcess from "node:child_process";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
@@ -11,14 +11,16 @@ import process$1 from "node:process";
 import reactDoctorPlugin, { ALL_REACT_DOCTOR_RULE_KEYS, CROSS_FILE_DEPENDENCY_COLLECTORS, CROSS_FILE_RULE_IDS, FRAMEWORK_SPECIFIC_RULE_KEYS, FRAMEWORK_TOKENS, MOTION_LIBRARY_PACKAGES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, classifySecurityScanFile, collectCrossFileDependencyProbes, resetManifestCaches, shouldReadSecurityScanContent } from "oxlint-plugin-react-doctor";
 import * as Crypto from "node:crypto";
 import crypto, { createHash, randomUUID } from "node:crypto";
+import { ResolverFactory } from "oxc-resolver";
 import ts from "typescript";
+import * as NodeUrl from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import * as OS from "node:os";
 import os, { tmpdir } from "node:os";
 import { parseJSON5 } from "confbox";
-import * as NodeUrl from "node:url";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { createJiti } from "jiti";
 import { ANALYZED_MANIFEST_FILENAMES, DEFAULT_EXTENSIONS } from "deslop-js/analyzed-inputs";
+import { convertToTSX } from "@astrojs/compiler/sync";
 import { gzipSync } from "node:zlib";
 import * as Sentry from "@sentry/node";
 import { performance as performance$1 } from "node:perf_hooks";
@@ -13341,7 +13343,7 @@ const Number$4 = globalThis.Number;
 * @category constructors
 * @since 2.0.0
 */
-const parse = (s) => {
+const parse$1 = (s) => {
 	if (s === "NaN") return some(NaN);
 	if (s === "Infinity") return some(Infinity);
 	if (s === "-Infinity") return some(-Infinity);
@@ -17404,12 +17406,12 @@ TaggedError("EncodingError");
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.70/node_modules/effect/dist/internal/schema/annotations.js
 /** @internal */
-function resolve(ast) {
+function resolve$1(ast) {
 	return ast.checks ? ast.checks[ast.checks.length - 1].annotations : ast.annotations;
 }
 /** @internal */
 function resolveAt(key) {
-	return (ast) => resolve(ast)?.[key];
+	return (ast) => resolve$1(ast)?.[key];
 }
 /** @internal */
 const resolveIdentifier = /* @__PURE__ */ resolveAt("identifier");
@@ -21161,7 +21163,7 @@ function asSync(parser) {
 }
 const recur$1 = /* @__PURE__ */ memoize((ast) => {
 	let parser;
-	const astOptions = resolve(ast)?.["parseOptions"];
+	const astOptions = resolve$1(ast)?.["parseOptions"];
 	if (!ast.context && !ast.encoding && !ast.checks) return (ou, options) => {
 		parser ??= ast.getParser(recur$1);
 		if (astOptions) options = {
@@ -60766,7 +60768,7 @@ var UrlParamsError = class extends TaggedError("UrlParamsError") {};
 * @category converting
 * @since 4.0.0
 */
-const makeUrl = (url, params, hash) => {
+const makeUrl$1 = (url, params, hash) => {
 	try {
 		const urlInstance = new URL(url, baseUrl());
 		for (let i = 0; i < params.params.length; i++) {
@@ -61400,7 +61402,7 @@ const Proto$2 = {
 const make$10 = (f) => makeWith$1((effect) => flatMap$2(effect, (request) => withFiber((fiber) => {
 	const scopedController = scopedRequests.get(request);
 	const controller = scopedController ?? new AbortController();
-	const urlResult = makeUrl(request.url, request.urlParams, getOrUndefined(request.hash));
+	const urlResult = makeUrl$1(request.url, request.urlParams, getOrUndefined(request.hash));
 	if (isFailure(urlResult)) return fail$4(new HttpClientError({ reason: new InvalidUrlError({
 		request,
 		cause: urlResult.failure
@@ -61839,7 +61841,7 @@ const layer$8 = (loggers, options) => effect(CurrentLoggers, withFiber$1(fnUntra
 * @since 4.0.0
 */
 const policy = /* @__PURE__ */ forever$1.pipe(passthrough$2, /* @__PURE__ */ addDelay((error) => {
-	if (isHttpClientError(error) && error.reason._tag === "StatusCodeError" && error.reason.response.status === 429) return succeed$2(seconds(fromUndefinedOr(error.reason.response.headers["retry-after"]).pipe(flatMap$5(parse), getOrElse$1(() => 5))));
+	if (isHttpClientError(error) && error.reason._tag === "StatusCodeError" && error.reason.response.status === 429) return succeed$2(seconds(fromUndefinedOr(error.reason.response.headers["retry-after"]).pipe(flatMap$5(parse$1), getOrElse$1(() => 5))));
 	return succeed$2(seconds(1));
 }));
 /**
@@ -64548,6 +64550,428 @@ const layer$1 = /* @__PURE__ */ succeed$3(Path$1)({
 	toFileUrl
 });
 //#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt[reader.next()];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) value = -2147483648 | -value;
+	return relative + value;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else seg = [
+					genColumn,
+					sourcesIndex,
+					sourceLine,
+					sourceColumn
+				];
+			} else seg = [genColumn];
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+	return a[0] - b[0];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+* Matches the parts of a URL:
+* 1. Scheme, including ":", guaranteed.
+* 2. User/password, including "@", optional.
+* 3. Host, guaranteed.
+* 4. Port, including ":", optional.
+* 5. Path, including "/", optional.
+* 6. Query, including "?", optional.
+* 7. Hash, including "#", optional.
+*/
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+*
+* 1. Host, optional.
+* 2. Path, which may include "/", guaranteed.
+* 3. Query, including "?", optional.
+* 4. Hash, including "#", optional.
+*/
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+	return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+	return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+	return input.startsWith("/");
+}
+function isFileUrl(input) {
+	return input.startsWith("file:");
+}
+function isRelative(input) {
+	return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+	const match = urlRegex.exec(input);
+	return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+	const match = fileRegex.exec(input);
+	const path = match[2];
+	return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+	return {
+		scheme,
+		user,
+		host,
+		port,
+		path,
+		query,
+		hash,
+		type: 7
+	};
+}
+function parseUrl(input) {
+	if (isSchemeRelativeUrl(input)) {
+		const url = parseAbsoluteUrl("http:" + input);
+		url.scheme = "";
+		url.type = 6;
+		return url;
+	}
+	if (isAbsolutePath(input)) {
+		const url = parseAbsoluteUrl("http://foo.com" + input);
+		url.scheme = "";
+		url.host = "";
+		url.type = 5;
+		return url;
+	}
+	if (isFileUrl(input)) return parseFileUrl(input);
+	if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+	const url = parseAbsoluteUrl("http://foo.com/" + input);
+	url.scheme = "";
+	url.host = "";
+	url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+	return url;
+}
+function stripPathFilename(path) {
+	if (path.endsWith("/..")) return path;
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+	normalizePath(base, base.type);
+	if (url.path === "/") url.path = base.path;
+	else url.path = stripPathFilename(base.path) + url.path;
+}
+/**
+* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+* "foo/.". We need to normalize to a standard representation.
+*/
+function normalizePath(url, type) {
+	const rel = type <= 4;
+	const pieces = url.path.split("/");
+	let pointer = 1;
+	let positive = 0;
+	let addTrailingSlash = false;
+	for (let i = 1; i < pieces.length; i++) {
+		const piece = pieces[i];
+		if (!piece) {
+			addTrailingSlash = true;
+			continue;
+		}
+		addTrailingSlash = false;
+		if (piece === ".") continue;
+		if (piece === "..") {
+			if (positive) {
+				addTrailingSlash = true;
+				positive--;
+				pointer--;
+			} else if (rel) pieces[pointer++] = piece;
+			continue;
+		}
+		pieces[pointer++] = piece;
+		positive++;
+	}
+	let path = "";
+	for (let i = 1; i < pointer; i++) path += "/" + pieces[i];
+	if (!path || addTrailingSlash && !path.endsWith("/..")) path += "/";
+	url.path = path;
+}
+/**
+* Attempts to resolve `input` URL/path relative to `base`.
+*/
+function resolve(input, base) {
+	if (!input && !base) return "";
+	const url = parseUrl(input);
+	let inputType = url.type;
+	if (base && inputType !== 7) {
+		const baseUrl = parseUrl(base);
+		const baseType = baseUrl.type;
+		switch (inputType) {
+			case 1: url.hash = baseUrl.hash;
+			case 2: url.query = baseUrl.query;
+			case 3:
+			case 4: mergePaths(url, baseUrl);
+			case 5:
+				url.user = baseUrl.user;
+				url.host = baseUrl.host;
+				url.port = baseUrl.port;
+			case 6: url.scheme = baseUrl.scheme;
+		}
+		if (baseType > inputType) inputType = baseType;
+	}
+	normalizePath(url, inputType);
+	const queryHash = url.query + url.hash;
+	switch (inputType) {
+		case 2:
+		case 3: return queryHash;
+		case 4: {
+			const path = url.path.slice(1);
+			if (!path) return queryHash || ".";
+			if (isRelative(base || input) && !isRelative(path)) return "./" + path + queryHash;
+			return path + queryHash;
+		}
+		case 5: return url.path + queryHash;
+		default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+	if (!path) return "";
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+	const from = stripFilename(mapUrl);
+	const prefix = sourceRoot ? sourceRoot + "/" : "";
+	return (source) => resolve(prefix + (source || ""), from);
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+	const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+	if (unsortedIndex === mappings.length) return mappings;
+	if (!owned) mappings = mappings.slice();
+	for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) mappings[i] = sortSegments(mappings[i], owned);
+	return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+	for (let i = start; i < mappings.length; i++) if (!isSorted(mappings[i])) return i;
+	return mappings.length;
+}
+function isSorted(line) {
+	for (let j = 1; j < line.length; j++) if (line[j][COLUMN] < line[j - 1][COLUMN]) return false;
+	return true;
+}
+function sortSegments(line, owned) {
+	if (!owned) line = line.slice();
+	return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[COLUMN] - b[COLUMN];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) low = mid + 1;
+		else high = mid - 1;
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
+		else high = lastIndex;
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+	return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var TraceMap = class {
+	constructor(map, mapUrl) {
+		const isString = typeof map === "string";
+		if (!isString && map._decodedMemo) return map;
+		const parsed = parse(map);
+		const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		this.version = version;
+		this.file = file;
+		this.names = names || [];
+		this.sourceRoot = sourceRoot;
+		this.sources = sources;
+		this.sourcesContent = sourcesContent;
+		this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+		const resolve = resolver(mapUrl, sourceRoot);
+		this.resolvedSources = sources.map(resolve);
+		const { mappings } = parsed;
+		if (typeof mappings === "string") {
+			this._encoded = mappings;
+			this._decoded = void 0;
+		} else if (Array.isArray(mappings)) {
+			this._encoded = void 0;
+			this._decoded = maybeSort(mappings, isString);
+		} else if (parsed.sections) throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+		else throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+		this._decodedMemo = memoizedState();
+		this._bySources = void 0;
+		this._bySourceMemos = void 0;
+	}
+};
+function cast(map) {
+	return map;
+}
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+	let { line, column, bias } = needle;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return OMapping(null, null, null, null);
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || 1);
+	if (index === -1) return OMapping(null, null, null, null);
+	const segment = segments[index];
+	if (segment.length === 1) return OMapping(null, null, null, null);
+	const { names, resolvedSources } = map;
+	return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) index = (bias === -1 ? upperBound : lowerBound)(segments, column, index);
+	else if (bias === -1) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+//#endregion
 //#region ../core/dist/index.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -64617,7 +65041,7 @@ var AmbiguousProjectError = class extends Error {
 };
 const isProjectDiscoveryError = (value) => value instanceof ProjectNotFoundError || value instanceof NoReactDependencyError || value instanceof PackageJsonNotFoundError || value instanceof NotADirectoryError || value instanceof AmbiguousProjectError;
 const HTML_FILE_PATTERN = /\.html$/i;
-const SOURCE_FILE_PATTERN = /\.(?:tsx?|jsx?|mts|mjs|[hH][tT][mM][lL])$/;
+const SOURCE_FILE_PATTERN = /\.(?:astro|tsx?|jsx?|mts|mjs|[hH][tT][mM][lL])$/;
 const GENERATED_BUNDLE_FILE_PATTERN = /\.(iife|umd|global|min)\.m?js$/i;
 const GENERATED_SOURCE_DIRECTORY_PATTERN = /(?:^|\/)__generated__\//;
 const MINIFIED_SNIFF_BYTES = 65536;
@@ -64995,7 +65419,7 @@ const SOCKET_FREE_USER_AGENT = "react-doctor-supply-chain";
 const FILE_LINT_CACHE_FILENAME = "file-lint-cache.json";
 const FILE_LINT_CACHE_MAX_FILE_COUNT = 5e4;
 const SIDECAR_LINT_CACHE_FILENAME = "sidecar-lint-cache.json";
-const CORE_PACKAGE_VERSION = "0.9.1";
+const CORE_PACKAGE_VERSION = "0.9.2";
 const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
 const DEAD_CODE_SUMMARY_CACHE_FILENAME = "dead-code-summaries.json";
 const SUPPLY_CHAIN_PLUGIN = "socket";
@@ -65239,8 +65663,13 @@ const findMonorepoRoot = (startDirectory) => {
 * byte-equivalent copy.
 */
 const isProjectBoundary = (directory) => NFS.existsSync(Path.join(directory, ".git")) || isMonorepoRoot(directory);
+const unwrapTypescriptExpression = (expression) => {
+	let currentExpression = expression;
+	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
+	return currentExpression;
+};
 const TSCONFIG_FILENAME = "tsconfig.json";
-const isRelativeExtendsValue = (extendsValue) => extendsValue.startsWith("./") || extendsValue.startsWith("../") || Path.isAbsolute(extendsValue);
+const isLocalModuleSpecifier = (moduleSpecifier) => moduleSpecifier === "." || moduleSpecifier === ".." || moduleSpecifier.startsWith("./") || moduleSpecifier.startsWith("../") || Path.isAbsolute(moduleSpecifier);
 const ensureJsonExtension = (filePath) => Path.extname(filePath) === "" ? `${filePath}.json` : filePath;
 const resolvePackageExtendsPath = (extendsValue, fromConfigDirectory) => {
 	const requireFromConfig = createRequire(Path.join(fromConfigDirectory, "tsconfig.json"));
@@ -65257,7 +65686,12 @@ const resolvePackageExtendsPath = (extendsValue, fromConfigDirectory) => {
 	return null;
 };
 const resolveExtendsPath = (extendsValue, fromConfigDirectory) => {
-	if (isRelativeExtendsValue(extendsValue)) return ensureJsonExtension(Path.resolve(fromConfigDirectory, extendsValue));
+	if (isLocalModuleSpecifier(extendsValue)) {
+		const resolvedPath = Path.resolve(fromConfigDirectory, extendsValue);
+		if (isFile(resolvedPath)) return resolvedPath;
+		const directoryConfigPath = Path.join(resolvedPath, TSCONFIG_FILENAME);
+		return isFile(directoryConfigPath) ? directoryConfigPath : ensureJsonExtension(resolvedPath);
+	}
 	return resolvePackageExtendsPath(extendsValue, fromConfigDirectory);
 };
 const normalizeCompilerOptions = (compilerOptions) => {
@@ -65364,6 +65798,7 @@ const FRAMEWORK_PACKAGES = {
 	"@tanstack/react-start": "tanstack-start",
 	"@remix-run/react": "remix",
 	gatsby: "gatsby",
+	astro: "astro",
 	vite: "vite",
 	"react-scripts": "cra",
 	expo: "expo",
@@ -65451,6 +65886,15 @@ const REACT_COMPILER_CONFIG_SOURCE_EXTENSIONS = [
 	".cts",
 	".json"
 ];
+const REACT_COMPILER_CONFIG_RESOLVER = new ResolverFactory({
+	conditionNames: [
+		"import",
+		"require",
+		"node",
+		"default"
+	],
+	extensions: REACT_COMPILER_CONFIG_SOURCE_EXTENSIONS
+});
 const STATIC_EXPORT_OUTPUT_PATTERN = /(?:^|[^.\w])["']?output["']?\s*:\s*["']export["']/m;
 const hasCompilerPackage = (packageJson, compilerPackages) => {
 	const allDependencies = {
@@ -65474,6 +65918,18 @@ const hasCompilerPackageInAncestors = (directory, compilerPackages) => {
 	return false;
 };
 const resolveImportedConfigFile = (fromFilePath, moduleSpecifier) => {
+	if (!isLocalModuleSpecifier(moduleSpecifier)) {
+		try {
+			const resolvedPath = REACT_COMPILER_CONFIG_RESOLVER.resolveFileSync(fromFilePath, moduleSpecifier).path;
+			if (resolvedPath && isFile(resolvedPath)) return resolvedPath;
+		} catch {}
+		try {
+			const resolvedPath = createRequire(fromFilePath).resolve(moduleSpecifier);
+			return isFile(resolvedPath) ? resolvedPath : null;
+		} catch {
+			return null;
+		}
+	}
 	const unresolvedPath = Path.resolve(Path.dirname(fromFilePath), moduleSpecifier);
 	const extension = Path.extname(unresolvedPath);
 	return (extension ? [unresolvedPath, ...REACT_COMPILER_CONFIG_SOURCE_EXTENSIONS.map((sourceExtension) => `${unresolvedPath.slice(0, -extension.length)}${sourceExtension}`)] : [
@@ -65499,7 +65955,7 @@ const hasTopLevelValueBinding = (sourceFile, bindingName) => sourceFile.statemen
 		const namedBindings = importClause?.namedBindings;
 		return namedBindings ? ts.isNamespaceImport(namedBindings) ? namedBindings.name.text === bindingName : namedBindings.elements.some((element) => element.name.text === bindingName) : false;
 	}
-	if (ts.isVariableStatement(statement)) return statement.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === bindingName);
+	if (ts.isVariableStatement(statement)) return statement.declarationList.declarations.some((declaration) => bindingNameContainsIdentifier(declaration.name, bindingName));
 	return (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name?.text === bindingName;
 });
 const getImportBinding = (sourceFile, bindingName) => {
@@ -65564,10 +66020,16 @@ const getTopLevelBinding = (sourceFile, bindingName) => {
 	}
 	return null;
 };
-const getFunctionLocalBindings = (functionNode, argumentsList) => {
+const getFunctionLocalBindings = (functionNode, argumentsList, argumentAnalysis, functionAnalysis) => {
 	const localBindings = /* @__PURE__ */ new Map();
 	functionNode.parameters.forEach((parameter, parameterIndex) => {
-		if (ts.isIdentifier(parameter.name)) localBindings.set(parameter.name.text, argumentsList[parameterIndex] ?? parameter.initializer ?? null);
+		if (ts.isIdentifier(parameter.name)) {
+			const argument = argumentsList[parameterIndex];
+			localBindings.set(parameter.name.text, {
+				expression: argument ?? parameter.initializer ?? null,
+				analysis: argument ? argumentAnalysis : functionAnalysis
+			});
+		}
 	});
 	return localBindings;
 };
@@ -65600,6 +66062,48 @@ const getScopedConfigBinding = (identifier) => {
 	};
 };
 const isCompilerTransformModule = (moduleSpecifier, exportName) => moduleSpecifier === "babel-plugin-react-compiler" && exportName === "default" || moduleSpecifier === "@vitejs/plugin-react" && exportName === "reactCompilerPreset";
+const NODE_MODULE_SPECIFIERS = new Set(["module", "node:module"]);
+const isConstantVariableInitializer = (node) => ts.isExpression(node) && ts.isVariableDeclaration(node.parent) && ts.isVariableDeclarationList(node.parent.parent) && Boolean(node.parent.parent.flags & ts.NodeFlags.Const);
+const isNodeCreateRequireCall = (node, analysis) => {
+	if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node) || ts.isAwaitExpression(node)) return isNodeCreateRequireCall(node.expression, analysis);
+	if (!ts.isCallExpression(node)) return false;
+	const target = node.expression;
+	if (ts.isIdentifier(target)) {
+		if (analysis.localBindings.has(target.text) || getScopedConfigBinding(target).wasFound) return false;
+		const importBinding = getImportBinding(analysis.sourceFile, target.text);
+		return Boolean(importBinding && NODE_MODULE_SPECIFIERS.has(importBinding.moduleSpecifier) && importBinding.exportName === "createRequire");
+	}
+	if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return false;
+	if ((ts.isPropertyAccessExpression(target) ? target.name.text : target.argumentExpression && ts.isStringLiteralLike(target.argumentExpression) ? target.argumentExpression.text : null) !== "createRequire") return false;
+	const createRequireReceiver = target.expression;
+	if (ts.isCallExpression(createRequireReceiver)) {
+		const requiredModuleSpecifier = getRequireModuleSpecifier$1(createRequireReceiver);
+		if (requiredModuleSpecifier === null || !NODE_MODULE_SPECIFIERS.has(requiredModuleSpecifier) || !ts.isIdentifier(createRequireReceiver.expression)) return false;
+		const requireIdentifier = createRequireReceiver.expression;
+		return !analysis.localBindings.has(requireIdentifier.text) && !getScopedConfigBinding(requireIdentifier).wasFound && !hasTopLevelValueBinding(analysis.sourceFile, requireIdentifier.text);
+	}
+	if (!ts.isIdentifier(createRequireReceiver)) return false;
+	if (analysis.localBindings.has(createRequireReceiver.text) || getScopedConfigBinding(createRequireReceiver).wasFound) return false;
+	const importBinding = getImportBinding(analysis.sourceFile, createRequireReceiver.text);
+	return Boolean(importBinding?.isNamespace && NODE_MODULE_SPECIFIERS.has(importBinding.moduleSpecifier));
+};
+const getNodeRequireResolveModuleSpecifier = (callExpression, analysis) => {
+	const [moduleSpecifierNode] = callExpression.arguments;
+	if (!moduleSpecifierNode || !ts.isStringLiteralLike(moduleSpecifierNode)) return null;
+	const target = callExpression.expression;
+	if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return null;
+	if ((ts.isPropertyAccessExpression(target) ? target.name.text : target.argumentExpression && ts.isStringLiteralLike(target.argumentExpression) ? target.argumentExpression.text : null) !== "resolve") return null;
+	if (isNodeCreateRequireCall(target.expression, analysis)) return moduleSpecifierNode.text;
+	if (!ts.isIdentifier(target.expression)) return null;
+	const resolverIdentifier = target.expression;
+	if (analysis.localBindings.has(resolverIdentifier.text)) return null;
+	const scopedBinding = getScopedConfigBinding(resolverIdentifier);
+	const topLevelBinding = scopedBinding.wasFound ? null : getTopLevelBinding(analysis.sourceFile, resolverIdentifier.text);
+	const resolverInitializer = scopedBinding.wasFound ? scopedBinding.initializer : topLevelBinding;
+	if (resolverInitializer === null && !scopedBinding.wasFound && resolverIdentifier.text === "require" && !hasTopLevelValueBinding(analysis.sourceFile, resolverIdentifier.text) && getImportBinding(analysis.sourceFile, resolverIdentifier.text) === null) return moduleSpecifierNode.text;
+	if (!resolverInitializer || !isConstantVariableInitializer(resolverInitializer) || !isNodeCreateRequireCall(resolverInitializer, analysis)) return null;
+	return moduleSpecifierNode.text;
+};
 const getAssignedPropertyInitializer = (identifier, propertyName) => {
 	let bindingScope = null;
 	let currentNode = identifier;
@@ -65642,9 +66146,11 @@ const getAssignedPropertyInitializer = (identifier, propertyName) => {
 		initializer: assignedInitializer
 	};
 };
-const getStaticConfigValueState = (expression, analysis) => {
-	let unwrappedExpression = expression;
-	while (ts.isParenthesizedExpression(unwrappedExpression) || ts.isAsExpression(unwrappedExpression) || ts.isTypeAssertionExpression(unwrappedExpression) || ts.isSatisfiesExpression(unwrappedExpression) || ts.isNonNullExpression(unwrappedExpression)) unwrappedExpression = unwrappedExpression.expression;
+const getStaticConfigValueState = (expression, analysis, visitedExpressions = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (visitedExpressions.has(unwrappedExpression)) return null;
+	const nextVisitedExpressions = new Set(visitedExpressions);
+	nextVisitedExpressions.add(unwrappedExpression);
 	if (unwrappedExpression.kind === ts.SyntaxKind.NullKeyword || ts.isIdentifier(unwrappedExpression) && unwrappedExpression.text === "undefined") return {
 		isNullish: true,
 		isTruthy: false
@@ -65659,32 +66165,32 @@ const getStaticConfigValueState = (expression, analysis) => {
 	};
 	if (ts.isIdentifier(unwrappedExpression)) {
 		if (analysis.localBindings.has(unwrappedExpression.text)) {
-			const localInitializer = analysis.localBindings.get(unwrappedExpression.text);
-			return localInitializer ? getStaticConfigValueState(localInitializer, analysis) : null;
+			const localReference = analysis.localBindings.get(unwrappedExpression.text);
+			return localReference?.expression ? getStaticConfigValueState(localReference.expression, localReference.analysis, nextVisitedExpressions) : null;
 		}
 		const topLevelBinding = getTopLevelBinding(analysis.sourceFile, unwrappedExpression.text);
-		return topLevelBinding && ts.isExpression(topLevelBinding) ? getStaticConfigValueState(topLevelBinding, analysis) : null;
+		return topLevelBinding && ts.isExpression(topLevelBinding) ? getStaticConfigValueState(topLevelBinding, analysis, nextVisitedExpressions) : null;
 	}
 	if (ts.isConditionalExpression(unwrappedExpression)) {
-		const conditionState = getStaticConfigValueState(unwrappedExpression.condition, analysis);
-		if (conditionState !== null) return getStaticConfigValueState(conditionState.isTruthy ? unwrappedExpression.whenTrue : unwrappedExpression.whenFalse, analysis);
-		const whenTrueState = getStaticConfigValueState(unwrappedExpression.whenTrue, analysis);
-		const whenFalseState = getStaticConfigValueState(unwrappedExpression.whenFalse, analysis);
+		const conditionState = getStaticConfigValueState(unwrappedExpression.condition, analysis, nextVisitedExpressions);
+		if (conditionState !== null) return getStaticConfigValueState(conditionState.isTruthy ? unwrappedExpression.whenTrue : unwrappedExpression.whenFalse, analysis, nextVisitedExpressions);
+		const whenTrueState = getStaticConfigValueState(unwrappedExpression.whenTrue, analysis, nextVisitedExpressions);
+		const whenFalseState = getStaticConfigValueState(unwrappedExpression.whenFalse, analysis, nextVisitedExpressions);
 		return whenTrueState !== null && whenFalseState !== null && whenTrueState.isNullish === whenFalseState.isNullish && whenTrueState.isTruthy === whenFalseState.isTruthy ? whenTrueState : null;
 	}
 	if (ts.isBinaryExpression(unwrappedExpression)) {
-		const leftState = getStaticConfigValueState(unwrappedExpression.left, analysis);
+		const leftState = getStaticConfigValueState(unwrappedExpression.left, analysis, nextVisitedExpressions);
 		if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
 			if (leftState === null) return null;
-			return leftState.isTruthy ? getStaticConfigValueState(unwrappedExpression.right, analysis) : leftState;
+			return leftState.isTruthy ? getStaticConfigValueState(unwrappedExpression.right, analysis, nextVisitedExpressions) : leftState;
 		}
 		if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
 			if (leftState === null) return null;
-			return leftState.isTruthy ? leftState : getStaticConfigValueState(unwrappedExpression.right, analysis);
+			return leftState.isTruthy ? leftState : getStaticConfigValueState(unwrappedExpression.right, analysis, nextVisitedExpressions);
 		}
 		if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
 			if (leftState === null) return null;
-			return leftState.isNullish ? getStaticConfigValueState(unwrappedExpression.right, analysis) : leftState;
+			return leftState.isNullish ? getStaticConfigValueState(unwrappedExpression.right, analysis, nextVisitedExpressions) : leftState;
 		}
 	}
 	return null;
@@ -65693,25 +66199,27 @@ const isStaticallyDisabledConfigExpression = (expression, analysis) => getStatic
 const isStaticallyTruthyConfigExpression = (expression, analysis) => getStaticConfigValueState(expression, analysis)?.isTruthy === true;
 const isStaticallyNullishConfigExpression = (expression, analysis) => getStaticConfigValueState(expression, analysis)?.isNullish === true;
 const isStaticallyNonNullishConfigExpression = (expression, analysis) => getStaticConfigValueState(expression, analysis)?.isNullish === false;
-const getReactCompilerFlagState = (expression, analysis) => {
-	let unwrappedExpression = expression;
-	while (ts.isParenthesizedExpression(unwrappedExpression) || ts.isAsExpression(unwrappedExpression) || ts.isTypeAssertionExpression(unwrappedExpression) || ts.isSatisfiesExpression(unwrappedExpression) || ts.isNonNullExpression(unwrappedExpression)) unwrappedExpression = unwrappedExpression.expression;
+const getReactCompilerFlagState = (expression, analysis, visitedExpressions = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (visitedExpressions.has(unwrappedExpression)) return null;
+	const nextVisitedExpressions = new Set(visitedExpressions);
+	nextVisitedExpressions.add(unwrappedExpression);
 	if (ts.isIdentifier(unwrappedExpression)) {
 		const assignedBinding = getAssignedPropertyInitializer(unwrappedExpression, "reactCompiler");
 		if (assignedBinding.wasFound && assignedBinding.initializer) return { isEnabled: !isStaticallyDisabledConfigExpression(assignedBinding.initializer, analysis) };
 		if (analysis.localBindings.has(unwrappedExpression.text)) {
-			const localInitializer = analysis.localBindings.get(unwrappedExpression.text);
-			return localInitializer ? getReactCompilerFlagState(localInitializer, analysis) : null;
+			const localReference = analysis.localBindings.get(unwrappedExpression.text);
+			return localReference?.expression ? getReactCompilerFlagState(localReference.expression, localReference.analysis, nextVisitedExpressions) : null;
 		}
 		const topLevelBinding = getTopLevelBinding(analysis.sourceFile, unwrappedExpression.text);
-		return topLevelBinding && ts.isExpression(topLevelBinding) ? getReactCompilerFlagState(topLevelBinding, analysis) : null;
+		return topLevelBinding && ts.isExpression(topLevelBinding) ? getReactCompilerFlagState(topLevelBinding, analysis, nextVisitedExpressions) : null;
 	}
 	if (!ts.isObjectLiteralExpression(unwrappedExpression)) return null;
 	for (const property of [...unwrappedExpression.properties].reverse()) {
 		if (ts.isPropertyAssignment(property) && getStaticPropertyName$2(property.name) === "reactCompiler") return { isEnabled: !isStaticallyDisabledConfigExpression(property.initializer, analysis) };
 		if (ts.isShorthandPropertyAssignment(property) && property.name.text === "reactCompiler") return { isEnabled: !isStaticallyDisabledConfigExpression(property.name, analysis) };
 		if (ts.isSpreadAssignment(property)) {
-			const spreadState = getReactCompilerFlagState(property.expression, analysis);
+			const spreadState = getReactCompilerFlagState(property.expression, analysis, nextVisitedExpressions);
 			if (spreadState) return spreadState;
 		}
 	}
@@ -65724,8 +66232,8 @@ const getSelectedObjectProperty = (expression, propertyName, analysis, visitedEx
 	visitedExpressions.add(resolvedExpression);
 	if (ts.isIdentifier(resolvedExpression)) {
 		if (analysis.localBindings.has(resolvedExpression.text)) {
-			const localInitializer = analysis.localBindings.get(resolvedExpression.text);
-			return localInitializer ? getSelectedObjectProperty(localInitializer, propertyName, analysis, visitedExpressions) : null;
+			const localReference = analysis.localBindings.get(resolvedExpression.text);
+			return localReference?.expression ? getSelectedObjectProperty(localReference.expression, propertyName, localReference.analysis, visitedExpressions) : null;
 		}
 		const scopedBinding = getScopedConfigBinding(resolvedExpression);
 		if (scopedBinding.wasFound) return scopedBinding.initializer ? getSelectedObjectProperty(scopedBinding.initializer, propertyName, analysis, visitedExpressions) : null;
@@ -65734,9 +66242,18 @@ const getSelectedObjectProperty = (expression, propertyName, analysis, visitedEx
 	}
 	if (!ts.isObjectLiteralExpression(resolvedExpression)) return null;
 	for (const property of [...resolvedExpression.properties].reverse()) {
-		if (ts.isPropertyAssignment(property) && getStaticPropertyName$2(property.name) === propertyName) return property.initializer;
-		if (ts.isMethodDeclaration(property) && getStaticPropertyName$2(property.name) === propertyName) return property;
-		if (ts.isShorthandPropertyAssignment(property) && property.name.text === propertyName) return property.name;
+		if (ts.isPropertyAssignment(property) && getStaticPropertyName$2(property.name) === propertyName) return {
+			node: property.initializer,
+			analysis
+		};
+		if (ts.isMethodDeclaration(property) && getStaticPropertyName$2(property.name) === propertyName) return {
+			node: property,
+			analysis
+		};
+		if (ts.isShorthandPropertyAssignment(property) && property.name.text === propertyName) return {
+			node: property.name,
+			analysis
+		};
 		if (ts.isSpreadAssignment(property)) {
 			const spreadProperty = getSelectedObjectProperty(property.expression, propertyName, analysis, visitedExpressions);
 			if (spreadProperty) return spreadProperty;
@@ -65749,8 +66266,8 @@ const configExpressionMayDefineProperty = (expression, propertyName, analysis) =
 	while (ts.isParenthesizedExpression(resolvedExpression) || ts.isAsExpression(resolvedExpression) || ts.isTypeAssertionExpression(resolvedExpression) || ts.isSatisfiesExpression(resolvedExpression) || ts.isNonNullExpression(resolvedExpression)) resolvedExpression = resolvedExpression.expression;
 	if (ts.isIdentifier(resolvedExpression)) {
 		if (analysis.localBindings.has(resolvedExpression.text)) {
-			const localInitializer = analysis.localBindings.get(resolvedExpression.text);
-			return localInitializer ? configExpressionMayDefineProperty(localInitializer, propertyName, analysis) : true;
+			const localReference = analysis.localBindings.get(resolvedExpression.text);
+			return localReference?.expression ? configExpressionMayDefineProperty(localReference.expression, propertyName, localReference.analysis) : true;
 		}
 		const scopedBinding = getScopedConfigBinding(resolvedExpression);
 		if (scopedBinding.wasFound) return scopedBinding.initializer ? configExpressionMayDefineProperty(scopedBinding.initializer, propertyName, analysis) : true;
@@ -65834,15 +66351,15 @@ const getReExportedConfigModules = (sourceFile, exportName) => {
 	}
 	return bindings;
 };
-const analyzeConfigModuleExport = (filePath, exportName, allowCompilerTransform, importDepth, visitedModules, argumentsList = []) => {
+const analyzeConfigModuleExport = (filePath, exportName, allowCompilerTransform, importDepth, visitedModules, argumentsList = [], argumentAnalysis) => {
 	if (!isFile(filePath) || importDepth > 4) return false;
 	const moduleVisitKey = `${filePath}:${exportName}:${allowCompilerTransform}`;
 	if (visitedModules.has(moduleVisitKey)) return false;
 	const nextVisitedModules = new Set(visitedModules);
 	nextVisitedModules.add(moduleVisitKey);
-	return analyzeConfigSourceFileExport(parseConfigSourceFile(filePath, NFS.readFileSync(filePath, "utf-8")), filePath, exportName, allowCompilerTransform, importDepth, nextVisitedModules, argumentsList);
+	return analyzeConfigSourceFileExport(parseConfigSourceFile(filePath, NFS.readFileSync(filePath, "utf-8")), filePath, exportName, allowCompilerTransform, importDepth, nextVisitedModules, argumentsList, argumentAnalysis);
 };
-const analyzeConfigSourceFileExport = (sourceFile, filePath, exportName, allowCompilerTransform, importDepth, visitedModules, argumentsList = []) => {
+const analyzeConfigSourceFileExport = (sourceFile, filePath, exportName, allowCompilerTransform, importDepth, visitedModules, argumentsList = [], argumentAnalysis) => {
 	const analysis = {
 		filePath,
 		sourceFile,
@@ -65852,14 +66369,27 @@ const analyzeConfigSourceFileExport = (sourceFile, filePath, exportName, allowCo
 		localBindings: /* @__PURE__ */ new Map(),
 		activeFunctions: /* @__PURE__ */ new Set()
 	};
+	const resolvedArgumentAnalysis = argumentAnalysis ?? analysis;
 	const exportedConfigNodes = getExportedConfigNodes(sourceFile, exportName);
-	return exportedConfigNodes.some((node) => ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) ? analyzeConfigFunction(node, analysis, allowCompilerTransform, argumentsList) : analyzeConfigNode(node, analysis, allowCompilerTransform)) || getReExportedConfigModules(sourceFile, exportName).some((binding) => {
+	return exportedConfigNodes.some((node) => {
+		if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) return analyzeConfigFunction(node, analysis, allowCompilerTransform, argumentsList, resolvedArgumentAnalysis);
+		if (argumentsList.length > 0 && ts.isIdentifier(node)) {
+			const topLevelBinding = getTopLevelBinding(sourceFile, node.text);
+			if (topLevelBinding && ts.isFunctionLike(topLevelBinding)) return analyzeConfigFunction(topLevelBinding, analysis, allowCompilerTransform, argumentsList, resolvedArgumentAnalysis);
+			const importBinding = getImportBinding(sourceFile, node.text);
+			if (importBinding) {
+				const importedFilePath = resolveImportedConfigFile(filePath, importBinding.moduleSpecifier);
+				return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, importBinding.exportName, allowCompilerTransform, importDepth + 1, visitedModules, argumentsList, resolvedArgumentAnalysis));
+			}
+		}
+		return analyzeConfigNode(node, analysis, allowCompilerTransform);
+	}) || getReExportedConfigModules(sourceFile, exportName).some((binding) => {
 		if (exportedConfigNodes.length > 0 && binding.isNamespace) return false;
 		const importedFilePath = resolveImportedConfigFile(filePath, binding.moduleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, binding.exportName, allowCompilerTransform, importDepth + 1, visitedModules, argumentsList));
+		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, binding.exportName, allowCompilerTransform, importDepth + 1, visitedModules, argumentsList, resolvedArgumentAnalysis));
 	});
 };
-const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, argumentsList = []) => {
+const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, argumentsList = [], argumentAnalysis = analysis) => {
 	if (!functionNode.body) return false;
 	if (analysis.activeFunctions.has(functionNode.pos)) return false;
 	const activeFunctions = new Set(analysis.activeFunctions);
@@ -65867,7 +66397,7 @@ const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, a
 	const functionAnalysis = {
 		...analysis,
 		visitedNodes: /* @__PURE__ */ new Set(),
-		localBindings: getFunctionLocalBindings(functionNode, argumentsList),
+		localBindings: getFunctionLocalBindings(functionNode, argumentsList, argumentAnalysis, analysis),
 		activeFunctions
 	};
 	if (!ts.isBlock(functionNode.body)) return analyzeConfigNode(functionNode.body, functionAnalysis, allowCompilerTransform);
@@ -65883,6 +66413,11 @@ const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, a
 	visitReturns(functionNode.body);
 	return hasCompiler;
 };
+const analyzeImportedConfig = ({ analysis, moduleSpecifier, exportName, allowCompilerTransform, argumentsList }) => {
+	const importedFilePath = resolveImportedConfigFile(analysis.filePath, moduleSpecifier);
+	if (!importedFilePath) return null;
+	return analyzeConfigModuleExport(importedFilePath, exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, argumentsList, analysis);
+};
 const analyzeConfigIdentifier = (identifier, analysis, allowCompilerTransform, isCompilerTransformCollection, excludedPropertyNames) => {
 	const assignedReactCompiler = getAssignedPropertyInitializer(identifier, "reactCompiler");
 	if (assignedReactCompiler.initializer && !isStaticallyDisabledConfigExpression(assignedReactCompiler.initializer, analysis)) return true;
@@ -65895,42 +66430,74 @@ const analyzeConfigIdentifier = (identifier, analysis, allowCompilerTransform, i
 	if (assignedPlugins.wasFound) overriddenPropertyNames.add("plugins");
 	if (assignedPresets.wasFound) overriddenPropertyNames.add("presets");
 	if (analysis.localBindings.has(identifier.text)) {
-		const localInitializer = analysis.localBindings.get(identifier.text);
-		return Boolean(localInitializer && analyzeConfigNode(localInitializer, analysis, allowCompilerTransform, isCompilerTransformCollection, overriddenPropertyNames));
+		const localReference = analysis.localBindings.get(identifier.text);
+		return Boolean(localReference?.expression && analyzeConfigNode(localReference.expression, localReference.analysis, allowCompilerTransform, isCompilerTransformCollection, overriddenPropertyNames));
 	}
 	const scopedBinding = getScopedConfigBinding(identifier);
 	if (scopedBinding.wasFound) return Boolean(scopedBinding.initializer && analyzeConfigNode(scopedBinding.initializer, analysis, allowCompilerTransform, isCompilerTransformCollection, overriddenPropertyNames));
 	const importBinding = getImportBinding(analysis.sourceFile, identifier.text);
 	if (importBinding) {
 		if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, importBinding.exportName)) return true;
-		if (!importBinding.moduleSpecifier.startsWith(".")) return false;
-		const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, importBinding.exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules));
+		return Boolean(analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: importBinding.moduleSpecifier,
+			exportName: importBinding.exportName,
+			allowCompilerTransform
+		}));
 	}
 	const topLevelBinding = getTopLevelBinding(analysis.sourceFile, identifier.text);
 	return Boolean(topLevelBinding && analyzeConfigNode(topLevelBinding, analysis, allowCompilerTransform, isCompilerTransformCollection, overriddenPropertyNames));
 };
 const analyzeConfigCallTarget = (callExpression, analysis, allowCompilerTransform) => {
 	const target = callExpression.expression;
+	const callableRequiredModuleSpecifier = getRequireModuleSpecifier$1(target);
+	if (callableRequiredModuleSpecifier !== null) {
+		if (ts.isCallExpression(target) && ts.isIdentifier(target.expression) && (analysis.localBindings.has(target.expression.text) || getScopedConfigBinding(target.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
+		if (allowCompilerTransform && isCompilerTransformModule(callableRequiredModuleSpecifier, "default")) return true;
+		const hasCompilerTransform = analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: callableRequiredModuleSpecifier,
+			exportName: "default",
+			allowCompilerTransform,
+			argumentsList: callExpression.arguments
+		});
+		if (isLocalModuleSpecifier(callableRequiredModuleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+		return null;
+	}
 	if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return null;
 	const propertyName = ts.isPropertyAccessExpression(target) ? target.name.text : target.argumentExpression && ts.isStringLiteralLike(target.argumentExpression) ? target.argumentExpression.text : null;
 	if (propertyName === null) return null;
 	const requiredModuleSpecifier = getRequireModuleSpecifier$1(target.expression);
 	if (requiredModuleSpecifier !== null) {
-		if (ts.isCallExpression(target.expression) && ts.isIdentifier(target.expression.expression) && (getScopedConfigBinding(target.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
-		if (!requiredModuleSpecifier.startsWith(".")) return null;
-		const importedFilePath = resolveImportedConfigFile(analysis.filePath, requiredModuleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, propertyName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, callExpression.arguments));
+		if (ts.isCallExpression(target.expression) && ts.isIdentifier(target.expression.expression) && (analysis.localBindings.has(target.expression.expression.text) || getScopedConfigBinding(target.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
+		if (allowCompilerTransform && isCompilerTransformModule(requiredModuleSpecifier, propertyName)) return true;
+		const hasCompilerTransform = analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: requiredModuleSpecifier,
+			exportName: propertyName,
+			allowCompilerTransform,
+			argumentsList: callExpression.arguments
+		});
+		if (isLocalModuleSpecifier(requiredModuleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+		return null;
 	}
 	if (!ts.isIdentifier(target.expression)) return null;
-	const importBinding = getImportBinding(analysis.sourceFile, target.expression.text);
-	if (importBinding?.isNamespace && importBinding.moduleSpecifier.startsWith(".")) {
-		const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, propertyName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, callExpression.arguments));
+	const importBinding = analysis.localBindings.has(target.expression.text) || getScopedConfigBinding(target.expression).wasFound ? null : getImportBinding(analysis.sourceFile, target.expression.text);
+	if (importBinding?.isNamespace) {
+		if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, propertyName)) return true;
+		const hasCompilerTransform = analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: importBinding.moduleSpecifier,
+			exportName: propertyName,
+			allowCompilerTransform,
+			argumentsList: callExpression.arguments
+		});
+		if (isLocalModuleSpecifier(importBinding.moduleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+		return null;
 	}
 	const selectedProperty = getSelectedObjectProperty(target.expression, propertyName, analysis);
 	if (selectedProperty === null) return null;
-	return ts.isFunctionLike(selectedProperty) ? analyzeConfigFunction(selectedProperty, analysis, allowCompilerTransform, callExpression.arguments) : analyzeConfigNode(selectedProperty, analysis, allowCompilerTransform);
+	return ts.isFunctionLike(selectedProperty.node) ? analyzeConfigFunction(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform, callExpression.arguments, analysis) : analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform);
 };
 const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTransformCollection = false, excludedPropertyNames) => {
 	const excludedPropertiesVisitKey = excludedPropertyNames ? [...excludedPropertyNames].sort().join(",") : "";
@@ -65949,9 +66516,13 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 			if (propertyName === "reactCompiler") continue;
 			if ((propertyName === "plugins" || propertyName === "presets") && node.properties.slice(propertyIndex + 1).some((laterProperty) => ts.isSpreadAssignment(laterProperty) && configExpressionMayDefineProperty(laterProperty.expression, propertyName, analysis) || (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && getStaticPropertyName$2(laterProperty.name) === propertyName)) continue;
 			const propertyAllowsCompilerTransform = propertyName === "plugins" || propertyName === "presets";
-			if (propertyName === "extends" && ts.isStringLiteralLike(property.initializer) && property.initializer.text.startsWith(".")) {
-				const extendedFilePath = resolveImportedConfigFile(analysis.filePath, property.initializer.text);
-				if (extendedFilePath && analyzeConfigModuleExport(extendedFilePath, "default", false, analysis.importDepth + 1, analysis.visitedModules)) return true;
+			if (propertyName === "extends" && ts.isStringLiteralLike(property.initializer)) {
+				if (analyzeImportedConfig({
+					analysis,
+					moduleSpecifier: property.initializer.text,
+					exportName: "default",
+					allowCompilerTransform: false
+				})) return true;
 			}
 			if (analyzeConfigNode(property.initializer, analysis, propertyAllowsCompilerTransform, propertyAllowsCompilerTransform)) return true;
 		} else if (ts.isShorthandPropertyAssignment(property)) {
@@ -65975,6 +66546,8 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		});
 	}
 	if (ts.isCallExpression(node)) {
+		const resolvedModuleSpecifier = getNodeRequireResolveModuleSpecifier(node, analysis);
+		if (resolvedModuleSpecifier !== null) return allowCompilerTransform && isCompilerTransformModule(resolvedModuleSpecifier, "default");
 		const callTargetResult = analyzeConfigCallTarget(node, analysis, allowCompilerTransform);
 		if (callTargetResult !== null) return callTargetResult;
 		const directModuleSpecifier = getRequireModuleSpecifier$1(node);
@@ -65982,16 +66555,27 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		if (directModuleSpecifier && isRequireShadowed) return analyzeConfigNode(node.expression, analysis, allowCompilerTransform);
 		if (directModuleSpecifier && !isRequireShadowed) {
 			if (allowCompilerTransform && isCompilerTransformModule(directModuleSpecifier, "default")) return true;
-			if (directModuleSpecifier.startsWith(".")) {
-				const importedFilePath = resolveImportedConfigFile(analysis.filePath, directModuleSpecifier);
-				if (importedFilePath && analyzeConfigModuleExport(importedFilePath, "default", allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules)) return true;
-			}
+			if (analyzeImportedConfig({
+				analysis,
+				moduleSpecifier: directModuleSpecifier,
+				exportName: "default",
+				allowCompilerTransform
+			})) return true;
 		}
 		if (ts.isIdentifier(node.expression)) {
-			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
-			if (importBinding?.moduleSpecifier.startsWith(".")) {
-				const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-				return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, importBinding.exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, node.arguments));
+			if (!analysis.localBindings.has(node.expression.text) && !getScopedConfigBinding(node.expression).wasFound) {
+				const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
+				if (importBinding) {
+					if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, importBinding.exportName)) return true;
+					const hasCompilerTransform = analyzeImportedConfig({
+						analysis,
+						moduleSpecifier: importBinding.moduleSpecifier,
+						exportName: importBinding.exportName,
+						allowCompilerTransform,
+						argumentsList: node.arguments
+					});
+					if (isLocalModuleSpecifier(importBinding.moduleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+				}
 			}
 			const topLevelBinding = getTopLevelBinding(analysis.sourceFile, node.expression.text);
 			if (topLevelBinding && ts.isFunctionLike(topLevelBinding) && analyzeConfigFunction(topLevelBinding, analysis, allowCompilerTransform, node.arguments)) return true;
@@ -66001,45 +66585,55 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 	if (ts.isPropertyAccessExpression(node)) {
 		const requiredModuleSpecifier = getRequireModuleSpecifier$1(node.expression);
 		if (requiredModuleSpecifier) {
-			if (ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression) && (getScopedConfigBinding(node.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
-			if (requiredModuleSpecifier.startsWith(".")) {
-				const importedFilePath = resolveImportedConfigFile(analysis.filePath, requiredModuleSpecifier);
-				return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, node.name.text, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules));
-			}
+			if (ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression) && (analysis.localBindings.has(node.expression.expression.text) || getScopedConfigBinding(node.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
+			if (analyzeImportedConfig({
+				analysis,
+				moduleSpecifier: requiredModuleSpecifier,
+				exportName: node.name.text,
+				allowCompilerTransform
+			})) return true;
 			return allowCompilerTransform && isCompilerTransformModule(requiredModuleSpecifier, node.name.text);
 		}
 		if (ts.isIdentifier(node.expression)) {
-			if (analysis.localBindings.has(node.expression.text)) {
-				const localInitializer = analysis.localBindings.get(node.expression.text);
-				return Boolean(localInitializer && analyzeConfigNode(localInitializer, analysis, allowCompilerTransform));
+			if (analysis.localBindings.has(node.expression.text) || getScopedConfigBinding(node.expression).wasFound) {
+				const selectedProperty = getSelectedObjectProperty(node.expression, node.name.text, analysis);
+				return Boolean(selectedProperty && analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform));
 			}
 			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
 			if (importBinding?.isNamespace) {
 				if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, node.name.text)) return true;
-				if (importBinding.moduleSpecifier.startsWith(".")) {
-					const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-					if (importedFilePath && analyzeConfigModuleExport(importedFilePath, node.name.text, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules)) return true;
-				}
+				if (analyzeImportedConfig({
+					analysis,
+					moduleSpecifier: importBinding.moduleSpecifier,
+					exportName: node.name.text,
+					allowCompilerTransform
+				})) return true;
 				return false;
 			}
 			const selectedProperty = getSelectedObjectProperty(node.expression, node.name.text, analysis);
-			if (selectedProperty) return analyzeConfigNode(selectedProperty, analysis, allowCompilerTransform);
+			if (selectedProperty) return analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform);
 			return false;
 		}
 		return analyzeConfigNode(node.expression, analysis, allowCompilerTransform);
 	}
 	if (ts.isElementAccessExpression(node) && node.argumentExpression && ts.isStringLiteralLike(node.argumentExpression)) {
 		if (ts.isIdentifier(node.expression)) {
+			if (analysis.localBindings.has(node.expression.text) || getScopedConfigBinding(node.expression).wasFound) {
+				const selectedProperty = getSelectedObjectProperty(node.expression, node.argumentExpression.text, analysis);
+				return Boolean(selectedProperty && analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform));
+			}
 			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
 			if (importBinding?.isNamespace) {
 				if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, node.argumentExpression.text)) return true;
-				if (importBinding.moduleSpecifier.startsWith(".")) {
-					const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-					return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, node.argumentExpression.text, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules));
-				}
+				return Boolean(analyzeImportedConfig({
+					analysis,
+					moduleSpecifier: importBinding.moduleSpecifier,
+					exportName: node.argumentExpression.text,
+					allowCompilerTransform
+				}));
 			}
 			const selectedProperty = getSelectedObjectProperty(node.expression, node.argumentExpression.text, analysis);
-			if (selectedProperty) return analyzeConfigNode(selectedProperty, analysis, allowCompilerTransform);
+			if (selectedProperty) return analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform);
 			return false;
 		}
 		return analyzeConfigNode(node.expression, analysis, allowCompilerTransform);
@@ -66074,14 +66668,19 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 };
 const hasCompilerInConfigFile = (filePath) => analyzeConfigModuleExport(filePath, "default", false, 0, /* @__PURE__ */ new Set());
 const hasCompilerInConfigFiles = (directory, filenames) => filenames.some((filename) => hasCompilerInConfigFile(Path.join(directory, filename)));
-const hasCompilerInPackageJsonConfig = (packageJson) => isPlainObject(packageJson.babel) && analyzeConfigSourceFileExport(ts.parseJsonText("package.json", JSON.stringify(packageJson.babel)), "package.json#babel", "default", false, 0, /* @__PURE__ */ new Set());
-const hasCompilerConfiguration = (directory, packageJson) => hasCompilerInPackageJsonConfig(packageJson) || hasCompilerInConfigFiles(directory, REACT_COMPILER_CONFIG_FILENAMES);
+const hasCompilerInPackageJsonConfig = (directory, packageJson) => {
+	if (!isPlainObject(packageJson.babel)) return false;
+	const packageJsonPath = Path.join(directory, "package.json");
+	return analyzeConfigSourceFileExport(ts.parseJsonText(packageJsonPath, JSON.stringify(packageJson.babel)), packageJsonPath, "default", false, 0, /* @__PURE__ */ new Set());
+};
+const hasCompilerConfiguration = (directory, packageJson) => hasCompilerInPackageJsonConfig(directory, packageJson) || hasCompilerInConfigFiles(directory, REACT_COMPILER_CONFIG_FILENAMES);
 const hasCompilerConfigurationInAncestors = (directory) => {
 	if (isProjectBoundary(directory)) return false;
 	let ancestorDirectory = Path.dirname(directory);
 	while (ancestorDirectory !== Path.dirname(ancestorDirectory)) {
 		const ancestorPackagePath = Path.join(ancestorDirectory, "package.json");
-		if (hasCompilerInPackageJsonConfig(isFile(ancestorPackagePath) ? readPackageJson$1(ancestorPackagePath) : {}) || hasCompilerInConfigFiles(ancestorDirectory, BABEL_CONFIG_FILENAMES)) return true;
+		const ancestorPackageJson = isFile(ancestorPackagePath) ? readPackageJson$1(ancestorPackagePath) : {};
+		if (hasCompilerInPackageJsonConfig(ancestorDirectory, ancestorPackageJson) || hasCompilerInConfigFiles(ancestorDirectory, BABEL_CONFIG_FILENAMES)) return true;
 		if (isProjectBoundary(ancestorDirectory)) return false;
 		ancestorDirectory = Path.dirname(ancestorDirectory);
 	}
@@ -68411,6 +69010,7 @@ const classifyPackageRole = (filename) => {
 * Resolves the absolute path to read for a diagnostic's `filePath`,
 * accounting for the various shapes oxlint emits:
 *
+* - `file://` URL — decode to an absolute filesystem path.
 * - Absolute POSIX (`/abs/path/file.tsx`) — pass through.
 * - Absolute Windows (`C:/...` or `C:\...`) — pass through.
 * - `./relative` or bare relative — join against `rootDirectory`.
@@ -68420,6 +69020,7 @@ const classifyPackageRole = (filename) => {
 * use one canonical resolution path.
 */
 const resolveCandidateReadPath = (rootDirectory, filePath) => {
+	if (filePath.startsWith("file://")) return fileURLToPath(filePath);
 	const normalizedFile = filePath.replace(/\\/g, "/");
 	if (normalizedFile.startsWith("/") || /^[a-zA-Z]:\//.test(normalizedFile) || /^[a-zA-Z]:\\/.test(filePath)) return filePath;
 	return `${rootDirectory.replace(/\\/g, "/").replace(/\/$/, "")}/${normalizedFile.replace(/^\.\//, "")}`;
@@ -70367,11 +70968,6 @@ const getTypescriptScriptKind = (fileName) => {
 	if (fileName.endsWith(".ts")) return ts.ScriptKind.TS;
 	return ts.ScriptKind.JS;
 };
-const unwrapTypescriptExpression = (expression) => {
-	let currentExpression = expression;
-	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
-	return currentExpression;
-};
 const BABEL_CONFIG_FILE_NAMES$1 = [
 	"babel.config.js",
 	"babel.config.cjs",
@@ -72733,7 +73329,10 @@ var Git = class Git extends Service()("react-doctor/Git") {
 				if (argvLengthChars > spawnArgsLengthCap) return yield* foldSpawnFailure(`spawn ENAMETOOLONG (${argvLengthChars} argv chars exceed ${spawnArgsLengthCap})`);
 				const handle = yield* spawner.spawn(make$1(input.command, [...input.args], {
 					cwd: input.directory,
-					env: input.env,
+					env: input.command === "git" ? {
+						...input.env,
+						GIT_DIR: void 0
+					} : input.env,
 					extendEnv: true
 				}));
 				const maxStdoutBytes = input.maxStdoutBytes;
@@ -73006,7 +73605,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 				"--diff-filter=ACMR",
 				"--relative"
 			]).pipe(map$3((result) => {
-				if (result.status !== 0) return [];
+				if (result.status !== 0) return null;
 				return splitNullSeparated(result.stdout);
 			})),
 			showStagedContent: (directory, relativePath, options) => runCommand({
@@ -74094,6 +74693,50 @@ const columnOfUtf8Offset = (sourceBuffer, utf8Offset) => {
 	while (lineStartOffset > 0 && sourceBuffer[lineStartOffset - 1] !== 10) lineStartOffset--;
 	return sourceBuffer.subarray(lineStartOffset, boundedOffset).toString("utf8").length + 1;
 };
+const utf8OffsetFromSourcePosition = (sourceBuffer, lineNumber, zeroBasedColumn) => {
+	if (lineNumber < 1 || zeroBasedColumn < 0) return null;
+	const sourceLines = sourceBuffer.toString("utf8").split("\n");
+	const sourceLine = sourceLines[lineNumber - 1];
+	if (sourceLine === void 0 || zeroBasedColumn > sourceLine.length) return null;
+	const precedingLines = sourceLines.slice(0, lineNumber - 1).join("\n");
+	return (lineNumber === 1 ? 0 : Buffer.byteLength(precedingLines) + Buffer.byteLength("\n")) + Buffer.byteLength(sourceLine.slice(0, zeroBasedColumn));
+};
+const mapPreparedSourceSpan = (span, preparedSourceMap) => {
+	const generatedLine = lineOfUtf8Offset(preparedSourceMap.generatedBuffer, span.offset);
+	const generatedColumn = columnOfUtf8Offset(preparedSourceMap.generatedBuffer, span.offset) - 1;
+	const originalStart = originalPositionFor(preparedSourceMap.traceMap, {
+		line: generatedLine,
+		column: generatedColumn
+	});
+	if (originalStart.source === null || originalStart.line === null || originalStart.column === null) return null;
+	const originalOffset = utf8OffsetFromSourcePosition(preparedSourceMap.sourceBuffer, originalStart.line, originalStart.column);
+	if (originalOffset === null) return null;
+	const generatedSpan = preparedSourceMap.generatedBuffer.subarray(span.offset, span.offset + span.length);
+	return {
+		offset: originalOffset,
+		length: preparedSourceMap.sourceBuffer.subarray(originalOffset, originalOffset + generatedSpan.length).equals(generatedSpan) ? generatedSpan.length : 0,
+		line: originalStart.line,
+		column: originalStart.column + 1
+	};
+};
+const mapPreparedSourceLabels = (labels, preparedSourceMap) => {
+	const primaryLabel = labels[0];
+	if (primaryLabel === void 0) return null;
+	const primarySpan = mapPreparedSourceSpan(primaryLabel.span, preparedSourceMap);
+	if (primarySpan === null) return null;
+	const mappedLabels = [{
+		...primaryLabel,
+		span: primarySpan
+	}];
+	for (const relatedLabel of labels.slice(1)) {
+		const relatedSpan = mapPreparedSourceSpan(relatedLabel.span, preparedSourceMap);
+		if (relatedSpan !== null) mappedLabels.push({
+			...relatedLabel,
+			span: relatedSpan
+		});
+	}
+	return mappedLabels;
+};
 const REDACTED_PLACEHOLDER = "<redacted>";
 const KEEP_PREFIX = `$1${REDACTED_PLACEHOLDER}`;
 const KNOWN_SECRET_RULES = [
@@ -74838,7 +75481,7 @@ const isOxlintOutput = (value) => isRecord$1(value) && Array.isArray(value.diagn
 * to the first `{`. Raises `OxlintOutputUnparseable` when the
 * stdout isn't valid JSON or doesn't carry a `diagnostics` array.
 */
-const parseOxlintOutput = (stdout, project, rootDirectory, sourcePathByLintPath) => {
+const parseOxlintOutput = (stdout, project, rootDirectory, sourcePathByLintPath, sourceMapByLintPath) => {
 	if (!stdout) return [];
 	const jsonStart = stdout.indexOf("{");
 	const sanitizedStdout = jsonStart > 0 ? stdout.slice(jsonStart) : stdout;
@@ -74856,6 +75499,7 @@ const parseOxlintOutput = (stdout, project, rootDirectory, sourcePathByLintPath)
 	const sourceLinesCache = /* @__PURE__ */ new Map();
 	const resolveAbsolutePath = (filename) => Path.isAbsolute(filename) ? filename : Path.resolve(rootDirectory || ".", filename);
 	const resolveMappedSourceFilename = (filename) => sourcePathByLintPath?.get(Path.normalize(resolveAbsolutePath(filename)));
+	const resolvePreparedSourceMap = (filename) => sourceMapByLintPath?.get(Path.normalize(resolveAbsolutePath(filename)));
 	const resolveSourceFilename = (filename) => resolveMappedSourceFilename(filename) ?? filename;
 	const readSourceBuffer = (filename) => {
 		const absolutePath = resolveAbsolutePath(resolveSourceFilename(filename));
@@ -74887,7 +75531,19 @@ const parseOxlintOutput = (stdout, project, rootDirectory, sourcePathByLintPath)
 		minifiedFileCache.set(absolutePath, minified);
 		return minified;
 	};
-	return suppressMemoizationInBailedOutFunctions(parsed.diagnostics.filter((diagnostic) => isMappableOxlintDiagnostic(diagnostic) && isLintableSourceFile(resolveSourceFilename(diagnostic.filename)) && !(TYPESCRIPT_DECLARATION_FILE_PATTERN.test(diagnostic.filename) && OXLINT_IGNORED_DECLARATION_DIAGNOSTIC_CODES.has(diagnostic.code)) && !isMinifiedDiagnosticFile(diagnostic.filename) && !shouldSuppressLocalUseHookDiagnostic(diagnostic, rootDirectory) && !shouldSuppressCompilerFindingInWorklet(diagnostic, project, rootDirectory)).map((diagnostic) => {
+	return suppressMemoizationInBailedOutFunctions(parsed.diagnostics.flatMap((diagnostic) => {
+		const preparedSourceMap = resolvePreparedSourceMap(diagnostic.filename);
+		if (preparedSourceMap === void 0) return [diagnostic];
+		const { plugin, rule } = parseRuleCode(diagnostic.code);
+		if (plugin !== "react-doctor" || !reactDoctorPlugin.rules[rule]?.tags?.includes("design")) return [];
+		const labels = mapPreparedSourceLabels(diagnostic.labels, preparedSourceMap);
+		const sourceFilename = resolveMappedSourceFilename(diagnostic.filename);
+		return labels === null || sourceFilename === void 0 ? [] : [{
+			...diagnostic,
+			filename: sourceFilename,
+			labels
+		}];
+	}).filter((diagnostic) => isMappableOxlintDiagnostic(diagnostic) && isLintableSourceFile(resolveSourceFilename(diagnostic.filename)) && !(TYPESCRIPT_DECLARATION_FILE_PATTERN.test(diagnostic.filename) && OXLINT_IGNORED_DECLARATION_DIAGNOSTIC_CODES.has(diagnostic.code)) && !isMinifiedDiagnosticFile(diagnostic.filename) && !shouldSuppressLocalUseHookDiagnostic(diagnostic, rootDirectory) && !shouldSuppressCompilerFindingInWorklet(diagnostic, project, rootDirectory)).map((diagnostic) => {
 		const { plugin, rule } = parseRuleCode(diagnostic.code);
 		const primaryLabel = diagnostic.labels[0];
 		const cleaned = cleanDiagnosticMessage(diagnostic.message, diagnostic.help, plugin, rule, project);
@@ -75105,7 +75761,7 @@ const isParallelismRelatedSpawnError = (error) => {
 * loop with a slimmer config in that case.
 */
 const spawnLintBatches = async (input) => {
-	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, sourcePathByLintPath, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes, splitTotalBudgetMs = OXLINT_SPLIT_TOTAL_BUDGET_MS, splitMaxDepth = 8, signal, deadlineEpochMs } = input;
+	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, sourcePathByLintPath, sourceMapByLintPath, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes, splitTotalBudgetMs = OXLINT_SPLIT_TOTAL_BUDGET_MS, splitMaxDepth = 8, signal, deadlineEpochMs } = input;
 	const resolveSourcePath = (filePath) => {
 		const absoluteFilePath = Path.isAbsolute(filePath) ? filePath : Path.resolve(rootDirectory, filePath);
 		return sourcePathByLintPath?.get(Path.normalize(absoluteFilePath)) ?? filePath;
@@ -75129,7 +75785,7 @@ const spawnLintBatches = async (input) => {
 			}
 			const batchArgs = [...baseArgs, ...batch];
 			try {
-				return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes, signal), project, rootDirectory, sourcePathByLintPath);
+				return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes, signal), project, rootDirectory, sourcePathByLintPath, sourceMapByLintPath);
 			} catch (error) {
 				if (!isSplittableReactDoctorError(error)) throw error;
 				if (isPastDeadline()) {
@@ -75568,20 +76224,47 @@ const prepareHtmlScriptSource = (sourceBuffer) => {
 		lintBuffer: maskedBuffer ?? sourceBuffer
 	};
 };
-const prepareHtmlLintSources = (rootDirectory, temporaryDirectory, candidateFiles) => {
+const ASTRO_FILE_PATTERN = /\.astro$/;
+const prepareLintSources = (rootDirectory, temporaryDirectory, candidateFiles) => {
 	const lintFiles = [];
 	const sourcePathByLintPath = /* @__PURE__ */ new Map();
+	const sourceMapByLintPath = /* @__PURE__ */ new Map();
 	const sizeByLintPath = /* @__PURE__ */ new Map();
 	const htmlSourcesDirectory = Path.join(temporaryDirectory, "html-sources");
+	const astroSourcesDirectory = Path.join(temporaryDirectory, "astro-sources");
 	let htmlFileIndex = 0;
+	let astroFileIndex = 0;
 	let hasThreeModuleImport = false;
 	for (const candidateFile of candidateFiles) {
-		if (!HTML_FILE_PATTERN.test(candidateFile)) {
+		if (!HTML_FILE_PATTERN.test(candidateFile) && !ASTRO_FILE_PATTERN.test(candidateFile)) {
 			lintFiles.push(candidateFile);
 			continue;
 		}
 		const absoluteSourcePath = Path.isAbsolute(candidateFile) ? candidateFile : Path.resolve(rootDirectory, candidateFile);
 		const sourceBuffer = NFS.readFileSync(absoluteSourcePath);
+		if (ASTRO_FILE_PATTERN.test(candidateFile)) {
+			const compilerSourcePath = absoluteSourcePath.replaceAll("\\", "/");
+			const convertedSource = convertToTSX(sourceBuffer.toString("utf8"), {
+				filename: compilerSourcePath,
+				sourcemap: "external",
+				includeScripts: true
+			});
+			if (astroFileIndex === 0) NFS.mkdirSync(astroSourcesDirectory, { recursive: true });
+			const lintPath = Path.join(astroSourcesDirectory, `${astroFileIndex}.tsx`);
+			const generatedBuffer = Buffer.from(convertedSource.code);
+			NFS.writeFileSync(lintPath, generatedBuffer);
+			lintFiles.push(candidateFile);
+			lintFiles.push(lintPath);
+			sourcePathByLintPath.set(Path.resolve(lintPath), candidateFile);
+			sourceMapByLintPath.set(Path.resolve(lintPath), {
+				traceMap: new TraceMap(JSON.stringify(convertedSource.map)),
+				generatedBuffer,
+				sourceBuffer
+			});
+			sizeByLintPath.set(lintPath, sourceBuffer.length);
+			astroFileIndex++;
+			continue;
+		}
 		const { executableScriptBodies, lintBuffer } = prepareHtmlScriptSource(sourceBuffer);
 		if (htmlFileIndex === 0) NFS.mkdirSync(htmlSourcesDirectory, { recursive: true });
 		const lintPath = Path.join(htmlSourcesDirectory, `${htmlFileIndex}.astro`);
@@ -75595,6 +76278,7 @@ const prepareHtmlLintSources = (rootDirectory, temporaryDirectory, candidateFile
 	return {
 		lintFiles,
 		sourcePathByLintPath,
+		sourceMapByLintPath,
 		sizeByLintPath,
 		hasThreeModuleImport
 	};
@@ -75813,10 +76497,10 @@ const runOxlint = async (options) => {
 			rootDirectory,
 			candidateFiles
 		});
-		const preparedHtmlSources = prepareHtmlLintSources(rootDirectory, configDirectory, candidateFiles);
-		const lintFiles = preparedHtmlSources.lintFiles;
-		const hasHtmlFiles = preparedHtmlSources.sourcePathByLintPath.size > 0;
-		const lintProject = !project.hasThree && preparedHtmlSources.hasThreeModuleImport ? {
+		const preparedLintSources = prepareLintSources(rootDirectory, configDirectory, candidateFiles);
+		const lintFiles = preparedLintSources.lintFiles;
+		const hasPreparedFiles = preparedLintSources.sourcePathByLintPath.size > 0;
+		const lintProject = !project.hasThree && preparedLintSources.hasThreeModuleImport ? {
 			...project,
 			hasThree: true
 		} : project;
@@ -75838,7 +76522,7 @@ const runOxlint = async (options) => {
 			sidecarRuleIdFilter: overrides.sidecarRuleIdFilter
 		});
 		const sizeByFile = sizedScanFiles !== null && lintBatchOrdering === "cost" ? new Map(sizedScanFiles.map((entry) => [entry.path, entry.sizeBytes])) : null;
-		if (sizeByFile !== null) for (const [lintPath, sizeBytes] of preparedHtmlSources.sizeByLintPath) sizeByFile.set(lintPath, sizeBytes);
+		if (sizeByFile !== null) for (const [lintPath, sizeBytes] of preparedLintSources.sizeByLintPath) sizeByFile.set(lintPath, sizeBytes);
 		const buildFileBatches = (passBaseArgs, passFiles) => sizeByFile !== null ? planLintBatches({
 			baseArgs: passBaseArgs,
 			files: passFiles,
@@ -75868,7 +76552,8 @@ const runOxlint = async (options) => {
 					rootDirectory,
 					nodeBinaryPath,
 					project: lintProject,
-					sourcePathByLintPath: preparedHtmlSources.sourcePathByLintPath,
+					sourcePathByLintPath: preparedLintSources.sourcePathByLintPath,
+					sourceMapByLintPath: preparedLintSources.sourceMapByLintPath,
 					onPartialFailure: reportPartialFailure,
 					onAnalyzedFiles: (filePaths) => {
 						analyzedFiles = filePaths;
@@ -75903,7 +76588,7 @@ const runOxlint = async (options) => {
 				};
 			}
 		};
-		if (perFileLintCacheEnabled && !project.hasReactCompiler && project.hasReactCompilerLintPlugin !== true && extendsPaths.length === 0 && userPlugins.length === 0 && !hasHtmlFiles) {
+		if (perFileLintCacheEnabled && !project.hasReactCompiler && project.hasReactCompilerLintPlugin !== true && extendsPaths.length === 0 && userPlugins.length === 0 && !hasPreparedFiles) {
 			const rulesetHash = computeRulesetHash({
 				config: buildConfig({
 					extendsPaths: [],
@@ -76069,7 +76754,8 @@ const runOxlint = async (options) => {
 			rootDirectory,
 			nodeBinaryPath,
 			project: lintProject,
-			sourcePathByLintPath: preparedHtmlSources.sourcePathByLintPath,
+			sourcePathByLintPath: preparedLintSources.sourcePathByLintPath,
+			sourceMapByLintPath: preparedLintSources.sourceMapByLintPath,
 			onPartialFailure,
 			onAnalyzedFiles: (filePaths) => {
 				analyzedFiles = filePaths;
@@ -77429,10 +78115,14 @@ const materializeSourceTree = (input) => gen(function* () {
 		materializedFiles.push(relativePath);
 	}
 	yield* sync(() => {
-		for (const configFilename of STAGED_FILES_PROJECT_CONFIG_FILENAMES) {
-			const sourcePath = path.join(input.directory, configFilename);
-			const targetPath = path.join(resolvedTempDirectory, configFilename);
-			if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) fs.cpSync(sourcePath, targetPath);
+		for (const subdirectory of ["", ...input.configSubdirectories ?? []]) for (const configFilename of STAGED_FILES_PROJECT_CONFIG_FILENAMES) {
+			const sourcePath = path.join(input.directory, subdirectory, configFilename);
+			const targetPath = path.resolve(resolvedTempDirectory, subdirectory, configFilename);
+			if (!isPathInsideDirectory(targetPath, resolvedTempDirectory)) continue;
+			if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) {
+				fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+				fs.cpSync(sourcePath, targetPath);
+			}
 		}
 	});
 	return {
@@ -77465,15 +78155,17 @@ var StagedFiles = class StagedFiles extends Service()("react-doctor/StagedFiles"
 	static layerNode = effect(StagedFiles, gen(function* () {
 		const git = yield* Git;
 		return StagedFiles.of({
-			discoverSourceFiles: (directory) => git.stagedFilePaths(directory).pipe(map$3((entries) => entries.filter(isLintableSourceFile)), withSpan("StagedFiles.discoverSourceFiles")),
-			materialize: ({ directory, stagedFiles, tempDirectory }) => materializeSourceTree({
+			discoverSourceFiles: (directory) => git.stagedFilePaths(directory).pipe(map$3((entries) => entries === null ? null : entries.filter(isLintableSourceFile)), withSpan("StagedFiles.discoverSourceFiles")),
+			materialize: ({ directory, stagedFiles, tempDirectory, configSubdirectories }) => materializeSourceTree({
 				directory,
 				files: stagedFiles,
 				tempDirectory,
+				configSubdirectories,
 				readContent: (relativePath) => git.showStagedContent(directory, relativePath, { maxBufferBytes: GIT_SHOW_MAX_BUFFER_BYTES })
 			}).pipe(map$3((tree) => ({
 				tempDirectory: tree.tempDirectory,
 				stagedFiles: tree.materializedFiles,
+				unmaterializedFiles: tree.unmaterializedFiles,
 				cleanup: tree.cleanup
 			})), withSpan("StagedFiles.materialize"))
 		});
@@ -77488,6 +78180,7 @@ var StagedFiles = class StagedFiles extends Service()("react-doctor/StagedFiles"
 		materialize: ({ tempDirectory }) => succeed$2({
 			tempDirectory,
 			stagedFiles: snapshot.materializedFiles ?? snapshot.sourceFiles ?? [],
+			unmaterializedFiles: [],
 			cleanup: () => {}
 		})
 	}));
@@ -78184,6 +78877,7 @@ const BASELINE_FILES_TEMP_DIR_PREFIX = "react-doctor-baseline-";
 const SCAN_RESULT_CACHE_FILENAME = "scan-cache.json";
 const RUN_GIT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 const GH_DEFAULT_BRANCH_PROBE_TIMEOUT_MS = 5e3;
+const TUI_REPORT_COMPACT_MAX_ROWS = 29;
 const TUI_REPORT_DETAIL_WIDTH_FRACTION = .6;
 const CI_TRUST_COMPANIES = "PayPal, Rippling, and Alibaba";
 const WELCOME_EXPLANATION_HOLD_MS = 1e3;
@@ -78196,11 +78890,13 @@ const METRIC = {
 	cliError: "cli.error",
 	cliEnvironmentError: "cli.env_error",
 	stagedSnapshotDivergence: "staged.snapshot_divergence",
+	stagedPerProject: "staged.per_project",
 	projectDetected: "project.detected",
 	projectPathSelected: "project.path_selected",
 	projectConfigSelected: "project.config_selected",
 	scanCompleted: "scan.completed",
 	scanDuration: "scan.duration",
+	scanFeedbackDelay: "scan.feedback_delay",
 	scanPhaseDuration: "scan.phase_duration",
 	scanFiles: "scan.files",
 	scanScore: "scan.score",
@@ -78232,6 +78928,10 @@ const METRIC = {
 	lspScanCompleted: "lsp.scan.completed",
 	lspScanDuration: "lsp.scan.duration",
 	lspScanDiagnostics: "lsp.scan.diagnostics",
+	tuiActionMenuOpened: "tui.action_menu_opened",
+	tuiCompactReportShown: "tui.compact_report_shown",
+	tuiFindingNavigated: "tui.finding_navigated",
+	tuiStackedReportCapped: "tui.stacked_report_capped",
 	aiTrainingWarningShown: "ai.training.warning_shown",
 	jsonOutUsed: "json.out_used"
 };
@@ -78276,7 +78976,7 @@ const makeNoopConsole = () => ({
 });
 //#endregion
 //#region src/cli/utils/version.ts
-const VERSION = "0.9.1-dev.b1b62db";
+const VERSION = "0.9.2-dev.01ca0b3";
 //#endregion
 //#region src/cli/utils/json-mode.ts
 let context = null;
@@ -78634,13 +79334,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.9.1-dev.b1b62db`;
+const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@0.9.2-dev.01ca0b3`;
 /**
 * 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.9.1-dev.b1b62db") ? "development" : "production");
+const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion("0.9.2-dev.01ca0b3") ? "development" : "production");
 /**
 * Performance-tracing sample rate in `[0, 1]`. Reads `SENTRY_TRACES_SAMPLE_RATE`
 * (set to `0` to disable tracing) and falls back to
@@ -92097,16 +92797,19 @@ const formatClusterLocation = (cluster, resolveSourceRoot, hyperlinks) => {
 	if (!hyperlinks) return `${location}${contextTag}`;
 	return `${formatHyperlink(location, pathToFileURL(resolveAbsolutePath(lead.filePath, resolveSourceRoot(lead))).href)}${contextTag}`;
 };
-const buildDiagnosticClusterLines = (cluster, resolveSourceRoot, renderCodeFrame, hyperlinks) => {
+const buildDiagnosticClusterLines = (cluster, resolveSourceRoot, resolveFrameSourceRoot, renderCodeFrame, hyperlinks) => {
 	const lead = cluster.diagnostics[0];
 	const isMultiSite = cluster.diagnostics.length > 1;
+	const sourceRoot = resolveSourceRoot(lead);
+	const frameSourceRoot = resolveFrameSourceRoot(lead);
+	const frameFilePath = Path.isAbsolute(lead.filePath) && sourceRoot !== frameSourceRoot ? Path.relative(sourceRoot, lead.filePath) : lead.filePath;
 	const lines = ["", highlighter.gray(`${TOP_ERROR_DETAIL_INDENT}${formatClusterLocation(cluster, resolveSourceRoot, hyperlinks)}`)];
 	const codeFrame = renderCodeFrame ? buildCodeFrame({
-		filePath: lead.filePath,
+		filePath: frameFilePath,
 		line: cluster.startLine,
 		column: isMultiSite ? 0 : lead.column,
 		endLine: isMultiSite ? cluster.endLine : void 0,
-		rootDirectory: resolveSourceRoot(lead)
+		rootDirectory: frameSourceRoot
 	}) : null;
 	if (codeFrame) {
 		const boxInnerWidth = resolveMeasureWidth(8);
@@ -92119,7 +92822,7 @@ const buildDiagnosticClusterLines = (cluster, resolveSourceRoot, renderCodeFrame
 	}
 	return lines;
 };
-const buildRuleDetailBlock = (ruleKey, ruleDiagnostics, resolveSourceRoot, renderEverySite, isAgentEnvironment, hyperlinks) => {
+const buildRuleDetailBlock = (ruleKey, ruleDiagnostics, resolveSourceRoot, resolveFrameSourceRoot, renderEverySite, isAgentEnvironment, hyperlinks) => {
 	const representative = pickRepresentativeDiagnostic(ruleDiagnostics);
 	const { severity } = representative;
 	const trailingBadge = formatTrailingSiteBadge(ruleDiagnostics.length);
@@ -92141,7 +92844,7 @@ const buildRuleDetailBlock = (ruleKey, ruleDiagnostics, resolveSourceRoot, rende
 	}
 	const renderCodeFrame = severity === "error";
 	const sites = renderEverySite ? ruleDiagnostics : [representative];
-	if (!(isCollapsedWarningGroup && representative.help.includes(representative.filePath))) for (const cluster of clusterNearbyDiagnostics(sites)) lines.push(...buildDiagnosticClusterLines(cluster, resolveSourceRoot, renderCodeFrame, hyperlinks));
+	if (!(isCollapsedWarningGroup && representative.help.includes(representative.filePath))) for (const cluster of clusterNearbyDiagnostics(sites)) lines.push(...buildDiagnosticClusterLines(cluster, resolveSourceRoot, resolveFrameSourceRoot, renderCodeFrame, hyperlinks));
 	return lines;
 };
 const selectErrorRuleGroups = (diagnostics, rulePriority) => buildSortedRuleGroups(diagnostics.filter((diagnostic) => diagnostic.severity === "error"), rulePriority);
@@ -92167,7 +92870,7 @@ const buildMigrationScaleAdvisoryLines = (diagnostics) => {
 	return lines;
 };
 const getTopErrorRuleKeys = (diagnostics, limit, rulePriority) => new Set(selectTopErrorRuleGroups(diagnostics, limit, rulePriority).map(([ruleKey]) => ruleKey));
-const buildTopErrorsSection = (diagnostics, resolveSourceRoot, hyperlinks, rulePriority) => {
+const buildTopErrorsSection = (diagnostics, resolveSourceRoot, resolveFrameSourceRoot, hyperlinks, rulePriority) => {
 	const topRuleGroups = selectErrorRuleGroups(diagnostics, rulePriority).slice(0, 3);
 	if (topRuleGroups.length === 0) return {
 		lines: [],
@@ -92177,7 +92880,7 @@ const buildTopErrorsSection = (diagnostics, resolveSourceRoot, hyperlinks, ruleP
 	const blockOffsets = [];
 	for (const [ruleKey, ruleDiagnostics] of topRuleGroups) {
 		blockOffsets.push(lines.length);
-		lines.push(...buildRuleDetailBlock(ruleKey, ruleDiagnostics, resolveSourceRoot, false, false, hyperlinks));
+		lines.push(...buildRuleDetailBlock(ruleKey, ruleDiagnostics, resolveSourceRoot, resolveFrameSourceRoot, false, false, hyperlinks));
 		lines.push("");
 	}
 	return {
@@ -92215,18 +92918,19 @@ const buildOverviewHeaderLines = (diagnostics) => {
 * single Effect.forEach over Console.log so failures or fiber
 * interruption produce predictable partial output.
 */
-const printDiagnostics = (diagnostics, isVerbose, sourceRoot, rulePriority, isAgentEnvironment = false, onboarding = {}, hyperlinks = false) => gen(function* () {
+const printDiagnostics = (diagnostics, isVerbose, sourceRoot, rulePriority, isAgentEnvironment = false, onboarding = {}, hyperlinks = false, frameSourceRoot = sourceRoot) => gen(function* () {
 	const sectionPause = onboarding.sectionPause ?? void_;
 	const animateCountUp = onboarding.animateCountUp ?? false;
 	const resolveSourceRoot = typeof sourceRoot === "function" ? sourceRoot : () => sourceRoot;
+	const resolveFrameSourceRoot = typeof frameSourceRoot === "function" ? frameSourceRoot : () => frameSourceRoot;
 	let detailLines;
 	let topErrorBlockOffsets = [];
 	if (!isVerbose) {
-		const topErrors = buildTopErrorsSection(diagnostics, resolveSourceRoot, hyperlinks, rulePriority);
+		const topErrors = buildTopErrorsSection(diagnostics, resolveSourceRoot, resolveFrameSourceRoot, hyperlinks, rulePriority);
 		detailLines = topErrors.lines;
 		topErrorBlockOffsets = topErrors.blockOffsets;
 	} else detailLines = buildSortedRuleGroups(diagnostics, rulePriority).flatMap(([ruleKey, ruleDiagnostics]) => {
-		return [...buildRuleDetailBlock(ruleKey, ruleDiagnostics, resolveSourceRoot, true, isAgentEnvironment, hyperlinks), ""];
+		return [...buildRuleDetailBlock(ruleKey, ruleDiagnostics, resolveSourceRoot, resolveFrameSourceRoot, true, isAgentEnvironment, hyperlinks), ""];
 	});
 	const overflowLine = isVerbose ? void 0 : buildOverflowSummaryLine(diagnostics, rulePriority);
 	const categoryTallies = buildCategoryDiagnosticGroups(diagnostics, rulePriority).map(buildCategoryTally);
@@ -93490,26 +94194,26 @@ const finalizeAndRender = (input) => gen(function* () {
 //#region src/cli/utils/get-staged-files.ts
 const stagedFilesLayer = StagedFiles.layerNode.pipe(provide$2(Git.layerNode));
 const getStagedSourceFiles = async (directory) => {
+	let stagedSourceFiles;
 	try {
-		return [...await runPromise(gen(function* () {
+		stagedSourceFiles = await runPromise(gen(function* () {
 			return yield* (yield* StagedFiles).discoverSourceFiles(directory);
-		}).pipe(provide(stagedFilesLayer)))];
+		}).pipe(provide(stagedFilesLayer)));
 	} catch (error) {
 		cliLogger.warn(`Failed to discover staged files: ${messageFromUnknown(error)}`);
 		return [];
 	}
+	if (stagedSourceFiles === null) throw new CliInputError("Could not read the git index to list staged files. Check that git can read the index in this directory.");
+	return [...stagedSourceFiles];
 };
-const materializeStagedFiles = async (directory, stagedFiles, tempDirectory) => {
+const materializeStagedFiles = async (input) => {
 	const snapshot = await runPromise(gen(function* () {
-		return yield* (yield* StagedFiles).materialize({
-			directory,
-			stagedFiles,
-			tempDirectory
-		});
+		return yield* (yield* StagedFiles).materialize(input);
 	}).pipe(provide(stagedFilesLayer)));
 	return {
 		tempDirectory: snapshot.tempDirectory,
 		stagedFiles: [...snapshot.stagedFiles],
+		unmaterializedFiles: [...snapshot.unmaterializedFiles],
 		cleanup: snapshot.cleanup
 	};
 };
@@ -95383,13 +96087,18 @@ const printMultiProjectSummary = (input) => gen(function* () {
 	const scoreDiagnostics = new Set(filterScansForSurface(completedScans, "score"));
 	const displayedScoreDiagnostics = displayDiagnostics.filter((diagnostic) => scoreDiagnostics.has(diagnostic));
 	const projectRootByDiagnostic = /* @__PURE__ */ new WeakMap();
-	for (const scan of completedScans) for (const diagnostic of scan.result.diagnostics) projectRootByDiagnostic.set(diagnostic, scan.result.project.rootDirectory);
+	const frameSourceRootByDiagnostic = /* @__PURE__ */ new WeakMap();
+	for (const scan of completedScans) for (const diagnostic of scan.result.diagnostics) {
+		projectRootByDiagnostic.set(diagnostic, scan.result.project.rootDirectory);
+		frameSourceRootByDiagnostic.set(diagnostic, scan.frameSourceRoot ?? scan.result.project.rootDirectory);
+	}
 	const resolveDiagnosticSourceRoot = (diagnostic) => projectRootByDiagnostic.get(diagnostic) ?? "";
+	const resolveDiagnosticFrameSourceRoot = (diagnostic) => frameSourceRootByDiagnostic.get(diagnostic) ?? resolveDiagnosticSourceRoot(diagnostic);
 	const totalScannedFileCount = countUniqueScannedFiles(completedScans.map((scan) => scan.result));
 	yield* log(`${highlighter.success("✔")} Scanned ${totalScannedFileCount} ${totalScannedFileCount === 1 ? "file" : "files"} in ${formatElapsedTime(totalElapsedMilliseconds)}`);
 	if (displayDiagnostics.length > 0) {
 		yield* log("");
-		yield* printDiagnostics(displayDiagnostics, verbose, resolveDiagnosticSourceRoot, buildRulePriorityMap(completedScans.map((scan) => scan.result.score)), isCodingAgentEnvironment(), { animateCountUp: animateRender }, shouldRenderHyperlinks(process.stdout));
+		yield* printDiagnostics(displayDiagnostics, verbose, resolveDiagnosticSourceRoot, buildRulePriorityMap(completedScans.map((scan) => scan.result.score)), isCodingAgentEnvironment(), { animateCountUp: animateRender }, shouldRenderHyperlinks(process.stdout), resolveDiagnosticFrameSourceRoot);
 	}
 	const lowestScoredScan = findLowestScoredScan(completedScans);
 	const aggregateScore = lowestScoredScan?.result.score ?? null;
@@ -95777,6 +96486,45 @@ const runExplain = async (fileLineArgument, context) => {
 	}
 };
 //#endregion
+//#region src/cli/utils/run-project-scan-batch.ts
+/**
+* Run one scan per project through the same bounded pool as
+* `diagnose({ projects })`, with the batch spinner and its progress counter.
+*
+* Pool members must not toggle the module-level spinner-silent flag themselves —
+* overlapping save/restore pairs would race — so the batch owns that toggle once
+* around the whole run.
+*
+* A `scanProject` that returns `null` drops the project from the results: diff
+* mode skips projects with no changed source.
+*/
+const runProjectScanBatch = async (input) => {
+	const startTime = performance$1.now();
+	const projectCount = input.projects.length;
+	const isMultiProject = projectCount > 1;
+	const batchSpinner = isMultiProject && !input.isQuiet ? spinner(`Scanning ${projectCount} projects…`).start() : null;
+	const ownsBatchSpinnerSilence = isMultiProject && input.isSilent;
+	const wasSpinnerSilent = isSpinnerSilent();
+	if (ownsBatchSpinnerSilence) setSpinnerSilent(true);
+	let finishedProjectCount = 0;
+	let scanOutcomes;
+	try {
+		scanOutcomes = await mapWithConcurrency(input.projects, isMultiProject ? 4 : 1, async (project) => {
+			const scanOutcome = await input.scanProject(project);
+			finishedProjectCount += 1;
+			batchSpinner?.update(`Scanning ${projectCount} projects… (${finishedProjectCount}/${projectCount})`);
+			return scanOutcome;
+		});
+	} finally {
+		if (ownsBatchSpinnerSilence) setSpinnerSilent(wasSpinnerSilent);
+		batchSpinner?.stop();
+	}
+	return {
+		completedScans: scanOutcomes.filter((scanOutcome) => scanOutcome !== null),
+		elapsedMilliseconds: performance$1.now() - startTime
+	};
+};
+//#endregion
 //#region src/cli/utils/project-manifest-changed.ts
 const PACKAGE_JSON = "package.json";
 /**
@@ -95793,6 +96541,29 @@ const projectManifestChanged = (rootDirectory, projectDirectory, diffInfo) => {
 	return diffInfo.changedFiles.some((filePath) => toForwardSlashes(filePath) === manifestPath);
 };
 //#endregion
+//#region src/cli/utils/select-staged-projects.ts
+/**
+* Appended to the reason a `--staged` run could not scan per package. Shared so
+* both fallback sites word it identically.
+*/
+const STAGED_PROJECT_FALLBACK_HINT = "Scanning the staged files at the scan root instead — fix the `projects` entries in your config to scan per package.";
+/**
+* Resolve the project directories a `--staged` scan owns. The interactive picker
+* is always skipped: a commit hook has nobody to answer it.
+*/
+const selectStagedProjects = async (input) => {
+	if (input.projectFlag) return selectProjects(input.rootDirectory, input.projectFlag, true, void 0);
+	if (input.configProjects === void 0) return [input.rootDirectory];
+	try {
+		return await selectProjects(input.rootDirectory, void 0, true, input.configProjects);
+	} catch (error) {
+		if (!(error instanceof CliInputError)) throw error;
+		cliLogger.warn(`${error.message} ${STAGED_PROJECT_FALLBACK_HINT}`);
+		cliLogger.break();
+		return [input.rootDirectory];
+	}
+};
+//#endregion
 //#region src/cli/utils/should-fail-scan-gate.ts
 const shouldFailScanGate = (input) => {
 	if (input.blockingLevel === "none") return false;
@@ -95958,6 +96729,7 @@ const inspectAction = async (directory, flags, invocationCommand = "inspect") =>
 	const isQuiet = isScoreOnly || isJsonMode;
 	const requestedDirectory = Path.resolve(directory);
 	const startTime = performance$1.now();
+	let scanStartupSpinner = null;
 	if (isJsonMode) {
 		enableJsonMode({
 			compact: Boolean(flags.jsonCompact),
@@ -96013,8 +96785,13 @@ const inspectAction = async (directory, flags, invocationCommand = "inspect") =>
 			json: flags.json
 		});
 		if (flags.staged) {
-			const stagedFiles = await getStagedSourceFiles(resolvedDirectory);
-			if (stagedFiles.length === 0) {
+			const configProjectsApply = (userConfig?.projects ?? []).some((projectName) => projectName.trim().length > 0) && scanTarget.requestedDirectory === scanTarget.configSourceDirectory;
+			const projectDirectories = await selectStagedProjects({
+				rootDirectory: resolvedDirectory,
+				projectFlag: flags.project,
+				configProjects: configProjectsApply ? userConfig?.projects : void 0
+			});
+			const reportNothingToScan = (input) => {
 				if (isJsonMode) writeJsonReport(buildJsonReport({
 					version: VERSION,
 					directory: resolvedDirectory,
@@ -96023,75 +96800,214 @@ const inspectAction = async (directory, flags, invocationCommand = "inspect") =>
 					scans: [],
 					totalElapsedMilliseconds: performance$1.now() - startTime
 				}));
-				else if (!isScoreOnly) cliLogger.dim("No staged source files found.");
+				else if (!isScoreOnly) if (input.severity === "warn") {
+					cliLogger.warn(input.reason);
+					cliLogger.break();
+				} else cliLogger.dim(input.reason);
+			};
+			const rootStagedFiles = await getStagedSourceFiles(resolvedDirectory);
+			if (rootStagedFiles.length === 0) {
+				reportNothingToScan({ reason: "No staged source files found." });
 				return;
 			}
-			if (!isQuiet) {
-				cliLogger.log(`Scanning ${highlighter.info(`${stagedFiles.length}`)} staged files...`);
+			const buildProjectScanContext = async (projectDirectory) => {
+				const projectScanTarget = projectDirectory === resolvedDirectory ? scanTarget : await resolveScanTarget(projectDirectory, { allowAmbiguous: true });
+				const scanDirectory = projectScanTarget.resolvedDirectory;
+				const treeRelativeDirectory = resolveProjectRelativeDirectory(resolvedDirectory, scanDirectory);
+				if (treeRelativeDirectory === null) return null;
+				return {
+					projectDirectory,
+					scanDirectory,
+					treeRelativeDirectory,
+					projectConfig: projectDirectory === resolvedDirectory ? userConfig : mergeReactDoctorConfigs(userConfig, projectScanTarget.userConfig ?? void 0),
+					projectConfigSourceDirectory: projectScanTarget.userConfig?.plugins === void 0 ? scanTarget.configSourceDirectory : projectScanTarget.configSourceDirectory
+				};
+			};
+			const projectScanContexts = [];
+			const seenScanDirectories = /* @__PURE__ */ new Set();
+			for (const projectDirectory of projectDirectories) {
+				const projectScanContext = await buildProjectScanContext(projectDirectory);
+				if (projectScanContext === null) {
+					if (flags.project) throw new CliInputError(`Project "${toRelativePath(projectDirectory, resolvedDirectory)}" is outside ${resolvedDirectory}, so it holds none of the staged files. Run --staged from a directory that contains the project.`);
+					continue;
+				}
+				if (seenScanDirectories.has(projectScanContext.scanDirectory)) continue;
+				seenScanDirectories.add(projectScanContext.scanDirectory);
+				projectScanContexts.push(projectScanContext);
+			}
+			if (projectScanContexts.length === 0) {
+				cliLogger.warn(`No configured project is inside ${resolvedDirectory}. ${STAGED_PROJECT_FALLBACK_HINT}`);
 				cliLogger.break();
+				const rootScanContext = await buildProjectScanContext(resolvedDirectory);
+				if (rootScanContext !== null) projectScanContexts.push(rootScanContext);
 			}
-			const tempDirectory = NFS.mkdtempSync(Path.join(tmpdir(), STAGED_FILES_TEMP_DIR_PREFIX));
-			const snapshot = await materializeStagedFiles(resolvedDirectory, stagedFiles, tempDirectory).catch((error) => {
-				NFS.rmSync(tempDirectory, {
-					recursive: true,
-					force: true
+			const contextsByLongestPathFirst = [...projectScanContexts].sort((left, right) => right.treeRelativeDirectory.length - left.treeRelativeDirectory.length);
+			const ownedStagedFiles = /* @__PURE__ */ new Map();
+			for (const stagedFile of rootStagedFiles) {
+				const owner = contextsByLongestPathFirst.find((context) => context.treeRelativeDirectory.length === 0 || stagedFile.startsWith(`${context.treeRelativeDirectory}/`));
+				if (owner === void 0) continue;
+				const ownedFiles = ownedStagedFiles.get(owner.scanDirectory);
+				if (ownedFiles === void 0) ownedStagedFiles.set(owner.scanDirectory, [stagedFile]);
+				else ownedFiles.push(stagedFile);
+			}
+			const stagedProjectScans = [];
+			for (const projectScanContext of projectScanContexts) {
+				const projectStagedFiles = ownedStagedFiles.get(projectScanContext.scanDirectory);
+				if (projectStagedFiles === void 0) continue;
+				stagedProjectScans.push({
+					...projectScanContext,
+					stagedFiles: projectStagedFiles
 				});
-				throw error;
-			});
+			}
+			if (stagedProjectScans.length === 0) {
+				reportNothingToScan({ reason: "No staged source files in the selected projects." });
+				return;
+			}
+			const selectedStagedFiles = stagedProjectScans.flatMap((projectScan) => projectScan.stagedFiles);
+			const stagedFileCount = selectedStagedFiles.length;
+			const unselectedStagedFileCount = rootStagedFiles.length - stagedFileCount;
+			if (!isQuiet) {
+				cliLogger.log(`Scanning ${highlighter.info(`${stagedFileCount}`)} staged files...`);
+				if (unselectedStagedFileCount > 0) cliLogger.dim(`${unselectedStagedFileCount} more staged file${unselectedStagedFileCount === 1 ? "" : "s"} outside the selected projects.`);
+				cliLogger.break();
+			}
 			const stagedWantsLines = resolveScope(flags, userConfig).scope === "lines";
 			const stagedLineRanges = stagedWantsLines ? await getChangedLineRanges({
 				directory: resolvedDirectory,
 				cached: true,
-				files: snapshot.stagedFiles
+				files: selectedStagedFiles
 			}) : null;
 			if (stagedWantsLines && stagedLineRanges === null && !isQuiet) {
 				cliLogger.warn("Could not determine staged changed lines; reporting all issues in staged files.");
 				cliLogger.break();
 			}
-			try {
-				const scanResult = await inspect(snapshot.tempDirectory, {
+			if (stagedProjectScans.some((projectScan) => projectScan.treeRelativeDirectory.length > 0)) recordCount(METRIC.stagedPerProject, 1, { projectCount: stagedProjectScans.length });
+			const tempDirectory = NFS.mkdtempSync(Path.join(tmpdir(), STAGED_FILES_TEMP_DIR_PREFIX));
+			const configSubdirectories = /* @__PURE__ */ new Set();
+			for (const projectScan of stagedProjectScans) {
+				configSubdirectories.add(projectScan.treeRelativeDirectory);
+				const projectRelativeDirectory = resolveProjectRelativeDirectory(resolvedDirectory, projectScan.projectDirectory);
+				if (projectRelativeDirectory !== null) configSubdirectories.add(projectRelativeDirectory);
+			}
+			const snapshot = await materializeStagedFiles({
+				directory: resolvedDirectory,
+				stagedFiles: selectedStagedFiles,
+				tempDirectory,
+				configSubdirectories: [...configSubdirectories]
+			}).catch((error) => {
+				NFS.rmSync(tempDirectory, {
+					recursive: true,
+					force: true
+				});
+				throw error;
+			});
+			const materializedStagedFiles = new Set(snapshot.stagedFiles);
+			const stagedProjectRuns = stagedProjectScans.map((projectScan) => ({
+				projectScan,
+				includePaths: resolveProjectSourceFilePaths(resolvedDirectory, projectScan.scanDirectory, projectScan.stagedFiles.filter((stagedFile) => materializedStagedFiles.has(stagedFile)))
+			})).filter((projectRun) => projectRun.includePaths.length > 0);
+			const isMultiProject = stagedProjectRuns.length > 1;
+			if (stagedProjectRuns.length === 0) {
+				snapshot.cleanup();
+				reportNothingToScan({
+					reason: `Could not read any of the ${stagedFileCount} staged file${stagedFileCount === 1 ? "" : "s"} out of the index, so nothing was scanned. An unusually large staged file is the usual cause.`,
+					severity: "warn"
+				});
+				return;
+			}
+			if (snapshot.unmaterializedFiles.length > 0 && !isQuiet) {
+				const stagedFileLabel = `staged file${stagedFileCount === 1 ? "" : "s"}`;
+				cliLogger.warn(`Skipped ${snapshot.unmaterializedFiles.length} of ${stagedFileCount} ${stagedFileLabel}; they could not be snapshotted from the index.`);
+				cliLogger.break();
+			}
+			const scanStagedProject = async (projectRun) => {
+				const { projectScan, includePaths } = projectRun;
+				const projectTempDirectory = Path.join(snapshot.tempDirectory, projectScan.treeRelativeDirectory);
+				const scanResult = await inspect(projectTempDirectory, {
 					...scanOptions,
 					deadlineEpochMs: scanDeadlineEpochMs,
-					includePaths: snapshot.stagedFiles,
-					configOverride: userConfig,
-					configSourceDirectory: scanTarget.configSourceDirectory ?? void 0,
-					changedLineRanges: stagedLineRanges ?? void 0
+					includePaths: [...includePaths],
+					configOverride: projectScan.projectConfig,
+					configSourceDirectory: projectScan.projectConfigSourceDirectory ?? void 0,
+					changedLineRanges: stagedLineRanges === null ? void 0 : resolveProjectChangedLineRanges(resolvedDirectory, projectScan.scanDirectory, stagedLineRanges),
+					suppressRendering: isMultiProject,
+					concurrentScan: isMultiProject
 				});
 				const remappedDiagnostics = scanResult.diagnostics.map((diagnostic) => ({
 					...diagnostic,
-					filePath: Path.isAbsolute(diagnostic.filePath) ? diagnostic.filePath.replaceAll(snapshot.tempDirectory, () => resolvedDirectory) : diagnostic.filePath
+					filePath: Path.isAbsolute(diagnostic.filePath) ? diagnostic.filePath.replaceAll(projectTempDirectory, () => projectScan.scanDirectory) : diagnostic.filePath
 				}));
-				finalizeScans({
-					completedScans: [{
-						directory: resolvedDirectory,
-						result: {
-							...scanResult,
-							diagnostics: remappedDiagnostics,
-							project: {
-								...scanResult.project,
-								rootDirectory: resolvedDirectory
-							}
-						},
-						config: userConfig
-					}],
-					mode: "staged",
-					diff: null,
-					baselineIntended: false,
-					isJsonMode,
-					isScoreOnly,
-					flags,
-					categoryFilters,
-					userConfig,
-					resolvedDirectory,
-					startTime
-				});
+				return {
+					directory: projectScan.scanDirectory,
+					result: {
+						...scanResult,
+						diagnostics: remappedDiagnostics,
+						project: {
+							...scanResult.project,
+							rootDirectory: projectScan.scanDirectory
+						}
+					},
+					config: projectScan.projectConfig,
+					frameSourceRoot: projectTempDirectory
+				};
+			};
+			const stagedBatch = await runProjectScanBatch({
+				projects: stagedProjectRuns,
+				isQuiet,
+				isSilent: scanOptions.silent === true,
+				scanProject: scanStagedProject
+			}).catch((error) => {
+				snapshot.cleanup();
+				throw error;
+			});
+			const completedScans = stagedBatch.completedScans;
+			try {
+				if (!isQuiet && isMultiProject) {
+					const showShareLink = !isShareOptedOut(completedScans, scanOptions.noScore) && !scanOptions.isCi;
+					await runPromise(printMultiProjectSummary({
+						completedScans,
+						categoryFilters,
+						verbose: Boolean(flags.verbose),
+						outputDirectory: flags.outputDir,
+						isOffline: !showShareLink,
+						projectName: Path.basename(resolvedDirectory),
+						totalElapsedMilliseconds: stagedBatch.elapsedMilliseconds
+					}));
+				}
+				if (flags.outputDir && isMultiProject && isQuiet) await runPromise(printDiagnosticsDump(filterDiagnosticsByCategories(filterScansForSurface(completedScans, scanOptions.outputSurface ?? "cli"), categoryFilters), flags.outputDir, false, "stderr"));
 			} finally {
 				snapshot.cleanup();
 			}
+			finalizeScans({
+				completedScans,
+				mode: "staged",
+				diff: null,
+				baselineIntended: false,
+				isJsonMode,
+				isScoreOnly,
+				flags,
+				categoryFilters,
+				userConfig,
+				resolvedDirectory,
+				startTime
+			});
 			return;
 		}
 		const projectDirectories = await selectProjects(resolvedDirectory, flags.project, skipPrompts, userConfig?.projects);
-		const changedFilesDiffInfo = flags.changedFilesFrom ? buildChangedFilesDiffInfo(readChangedFilesFrom(Path.resolve(flags.changedFilesFrom))) : null;
+		const projectSelectionCompletedTime = performance$1.now();
+		let changedFilesDiffInfo = flags.changedFilesFrom ? buildChangedFilesDiffInfo(readChangedFilesFrom(Path.resolve(flags.changedFilesFrom))) : null;
+		if (changedFilesDiffInfo !== null && scanTarget.didRedirectViaRootDir) {
+			const relativeProjectDirectory = resolveProjectRelativeDirectory(requestedDirectory, resolvedDirectory);
+			if (relativeProjectDirectory) {
+				const projectPrefix = `${relativeProjectDirectory}/`;
+				changedFilesDiffInfo = {
+					...changedFilesDiffInfo,
+					changedFiles: changedFilesDiffInfo.changedFiles.flatMap((filePath) => {
+						return filePath.startsWith(projectPrefix) ? [filePath.slice(projectPrefix.length)] : [];
+					})
+				};
+			}
+		}
 		const requestedScope = resolveScope(flags, userConfig);
 		const includeUntracked = flags.includeUntracked ?? false;
 		const scopeRequest = requestedScope.scope === void 0 && changedFilesDiffInfo !== null ? {
@@ -96099,15 +97015,20 @@ const inspectAction = async (directory, flags, invocationCommand = "inspect") =>
 			scope: "changed"
 		} : requestedScope;
 		validateIncludeUntrackedScope(includeUntracked, scopeRequest.scope);
+		scanStartupSpinner = !isQuiet ? spinner("Scanning...").start() : null;
+		if (scanStartupSpinner !== null) recordDistribution(METRIC.scanFeedbackDelay, performance$1.now() - projectSelectionCompletedTime, { unit: "millisecond" });
 		const wantsDiffMode = scopeRequest.scope !== void 0 && scopeRequest.scope !== "full";
 		const shouldDetectDiff = changedFilesDiffInfo === null && (wantsDiffMode || scopeRequest.scope === void 0 && !skipPrompts && !isQuiet);
 		const diffInfo = changedFilesDiffInfo ?? (shouldDetectDiff ? await getDiffInfo(resolvedDirectory, scopeRequest.base, includeUntracked) : null);
+		scanStartupSpinner?.stop();
+		scanStartupSpinner = null;
 		const scope = await finalizeScope({
 			requested: scopeRequest,
 			diffInfo,
 			skipPrompts,
 			isQuiet
 		});
+		scanStartupSpinner = !isQuiet ? spinner("Scanning...").start() : null;
 		const isDiffMode = scope !== "full";
 		const comparisonBaseRef = isDiffMode && diffInfo && !diffInfo.isCurrentChanges ? diffInfo.baseSha ? await resolveMergeBaseRef(resolvedDirectory, diffInfo.baseSha) : diffInfo.diffBaseRef ?? await resolveMergeBaseRef(resolvedDirectory, diffInfo.baseBranch) : null;
 		const baselineRef = scope === "changed" ? comparisonBaseRef : null;
@@ -96119,6 +97040,8 @@ const inspectAction = async (directory, flags, invocationCommand = "inspect") =>
 			files: [...diffInfo.changedFiles],
 			includeUntracked
 		}) : null;
+		scanStartupSpinner?.stop();
+		scanStartupSpinner = null;
 		if (scope === "lines" && changedLineRanges === null && !isQuiet) {
 			cliLogger.warn("Could not determine changed lines (no base ref or git diff failed); reporting all issues in changed files.");
 			cliLogger.break();
@@ -96132,7 +97055,6 @@ const inspectAction = async (directory, flags, invocationCommand = "inspect") =>
 			}
 			cliLogger.break();
 		}
-		const completedScans = [];
 		const isMultiProject = projectDirectories.length > 1;
 		const scanProject = async (projectDirectory) => {
 			const projectScanTarget = projectDirectory === resolvedDirectory ? scanTarget : await resolveScanTarget(projectDirectory, { allowAmbiguous: true });
@@ -96183,29 +97105,13 @@ const inspectAction = async (directory, flags, invocationCommand = "inspect") =>
 				config: projectConfig
 			};
 		};
-		const scanLoopStartTime = performance$1.now();
-		const projectCount = projectDirectories.length;
-		const batchSpinner = isMultiProject && !isQuiet ? spinner(`Scanning ${projectCount} projects…`).start() : null;
-		const ownsBatchSpinnerSilence = isMultiProject && scanOptions.silent === true;
-		const wasSpinnerSilent = isSpinnerSilent();
-		if (ownsBatchSpinnerSilence) setSpinnerSilent(true);
-		let finishedProjectCount = 0;
-		let scanOutcomes;
-		try {
-			scanOutcomes = await mapWithConcurrency(projectDirectories, isMultiProject ? 4 : 1, async (projectDirectory) => {
-				const scanOutcome = await scanProject(projectDirectory);
-				finishedProjectCount += 1;
-				batchSpinner?.update(`Scanning ${projectCount} projects… (${finishedProjectCount}/${projectCount})`);
-				return scanOutcome;
-			});
-		} finally {
-			if (ownsBatchSpinnerSilence) setSpinnerSilent(wasSpinnerSilent);
-			batchSpinner?.stop();
-		}
-		for (const scanOutcome of scanOutcomes) {
-			if (scanOutcome === null) continue;
-			completedScans.push(scanOutcome);
-		}
+		const projectBatch = await runProjectScanBatch({
+			projects: projectDirectories,
+			isQuiet,
+			isSilent: scanOptions.silent === true,
+			scanProject
+		});
+		const completedScans = projectBatch.completedScans;
 		if (!isQuiet && isMultiProject && completedScans.length > 0) {
 			const showShareLink = !isShareOptedOut(completedScans, scanOptions.noScore) && !scanOptions.isCi;
 			await runPromise(printMultiProjectSummary({
@@ -96215,7 +97121,7 @@ const inspectAction = async (directory, flags, invocationCommand = "inspect") =>
 				outputDirectory: flags.outputDir,
 				isOffline: !showShareLink,
 				projectName: Path.basename(resolvedDirectory),
-				totalElapsedMilliseconds: performance$1.now() - scanLoopStartTime
+				totalElapsedMilliseconds: projectBatch.elapsedMilliseconds
 			}));
 		}
 		const selectedSurfaceDiagnostics = filterDiagnosticsByCategories(filterScansForSurface(completedScans, scanOptions.outputSurface ?? "cli"), categoryFilters);
@@ -96262,6 +97168,7 @@ const inspectAction = async (directory, flags, invocationCommand = "inspect") =>
 			}
 		}
 	} catch (error) {
+		scanStartupSpinner?.stop();
 		const isUserError = isExpectedUserError(error);
 		const sentryEventId = isUserError ? void 0 : await reportErrorToSentry(error);
 		if (isDebugFlagEnabled()) await flushSentry();
@@ -97196,6 +98103,7 @@ const COMMAND_FLAG_SPECS = new Map([
 			"--no-color",
 			"--no-dead-code",
 			"--no-score",
+			"--no-supply-chain",
 			"--yes"
 		]),
 		longOptionsWithRequiredValues: new Set(["--blocking", "--project"]),
@@ -97359,7 +98267,7 @@ ${highlighter.dim("Learn more:")}
   ${highlighter.info(CI_URL)}
 `;
 const collectCategoryOption = (value, previousValues) => [...previousValues ?? [], value];
-const program = new Command().name("react-doctor").description("Diagnose React codebase health").version(VERSION, "-v, --version", "display the version number").argument("[directory]", "project directory to scan", ".").option("--lint", "enable linting").option("--no-lint", "skip linting").option("--dead-code", "enable dead-code analysis (default)").option("--no-dead-code", "skip dead-code analysis (unused files / exports / dependencies, circular imports)").option("--supply-chain", "enable the dependency supply-chain scan (default)").option("--no-supply-chain", "skip the dependency supply-chain scan (Socket.dev dependency health checks)").option("--verbose", "show every rule and per-file details (default shows top 3 rules)").option("--debug", "force a Sentry trace and print its id at the end (paste it into a bug report)").option("--output-dir <dir>", "directory for the full diagnostics dump (default: a temp folder)").option("--score", "output only the score").option("--json", "output a single structured JSON report (suppresses other output)").option("--json-compact", "with --json, emit compact JSON (no indentation)").option("--json-out <path>", "with --json, write the report to a file instead of stdout").option("-y, --yes", "skip prompts, scan all workspace projects").option("--no-parallel", "lint serially with one worker (default: parallel across CPU cores; set the worker count with REACT_DOCTOR_PARALLEL)").option("--project <name>", "select projects: workspace names or directory paths (comma-separated for multiple); overrides the `projects` config field").option("--scope <value>", "how much supported JS/TS and inline HTML script source to scan/report: full (default), files, changed (only new issues vs base), or lines (issues whose source spans touch changed lines)").option("--base <ref>", "base git ref for files/changed/lines scope (auto-detected when omitted)").option("--include-untracked", "with --scope files/changed/lines, also scan ordinary untracked files (respects .gitignore)").addOption(new Option("--diff [base]", "[deprecated] alias for --scope changed (pass `false` to force a full scan)").hideHelp()).addOption(new Option("--changed-files-from <file>", "scan source files listed in a newline-delimited changed-files file").hideHelp()).option("--no-score", "skip the score API, the share URL, and crash reporting").addOption(new Option("--category <category>", "only show diagnostics in a category (repeatable; e.g. Security)").argParser(collectCategoryOption)).option("--no-telemetry", "alias for --no-score (skip the score API, share URL, and crash reporting)").option("--staged", "scan only staged (git index) files for pre-commit hooks").option("--max-duration <seconds>", "scan time budget for the whole run, shared across workspace projects: past it, remaining lint batches and dead-code are skipped and partial results are reported (skipped files are listed in the JSON report)").option("--blocking <level>", "severity that fails CI: error (default), warning, or none (advisory)").addOption(new Option("--fail-on <level>", "[deprecated] alias for --blocking <level>").hideHelp()).option("--no-respect-inline-disables", "audit mode: neutralize inline lint suppressions before scanning").option("--warnings", "show warning-severity diagnostics (default)").option("--no-warnings", "hide warning-severity diagnostics (errors only)").option("--color", "force colored output").option("--no-color", "disable colored output (also honors NO_COLOR)").addHelpText("after", renderRootHelpEpilog);
+const program = new Command().name("react-doctor").description("Diagnose React codebase health").version(VERSION, "-v, --version", "display the version number").argument("[directory]", "project directory to scan", ".").option("--lint", "enable linting").option("--no-lint", "skip linting").option("--dead-code", "enable dead-code analysis (default)").option("--no-dead-code", "skip dead-code analysis (unused files / exports / dependencies, circular imports)").option("--supply-chain", "enable the dependency supply-chain scan (default)").option("--no-supply-chain", "skip the dependency supply-chain scan (Socket.dev dependency health checks)").option("--verbose", "show every rule and per-file details (default shows top 3 rules)").option("--debug", "force a Sentry trace and print its id at the end (paste it into a bug report)").option("--output-dir <dir>", "directory for the full diagnostics dump (default: a temp folder)").option("--score", "output only the score").option("--json", "output a single structured JSON report (suppresses other output)").option("--json-compact", "with --json, emit compact JSON (no indentation)").option("--json-out <path>", "with --json, write the report to a file instead of stdout").option("-y, --yes", "skip prompts, scan all workspace projects").option("--no-parallel", "lint serially with one worker (default: parallel across CPU cores; set the worker count with REACT_DOCTOR_PARALLEL)").option("--project <name>", "select projects: workspace names or directory paths (comma-separated for multiple); overrides the `projects` config field").option("--scope <value>", "how much supported JS/TS and inline HTML script source to scan/report: full (default), files, changed (only new issues vs base), or lines (issues whose source spans touch changed lines)").option("--base <ref>", "base git ref for files/changed/lines scope (auto-detected when omitted)").option("--include-untracked", "with --scope files/changed/lines, also scan ordinary untracked files (respects .gitignore)").addOption(new Option("--diff [base]", "[deprecated] alias for --scope changed (pass `false` to force a full scan)").hideHelp()).addOption(new Option("--changed-files-from <file>", "scan source files listed in a newline-delimited changed-files file").hideHelp()).option("--no-score", "skip the score API, the share URL, and crash reporting").addOption(new Option("--category <category>", "only show diagnostics in a category (repeatable; e.g. Security)").argParser(collectCategoryOption)).option("--no-telemetry", "alias for --no-score (skip the score API, share URL, and crash reporting)").option("--staged", "scan only staged (git index) files for pre-commit hooks (honors --project and config `projects`; exits 0 when nothing is staged)").option("--max-duration <seconds>", "scan time budget for the whole run, shared across workspace projects: past it, remaining lint batches and dead-code are skipped and partial results are reported (skipped files are listed in the JSON report)").option("--blocking <level>", "severity that fails CI: error (default), warning, or none (advisory)").addOption(new Option("--fail-on <level>", "[deprecated] alias for --blocking <level>").hideHelp()).option("--no-respect-inline-disables", "audit mode: neutralize inline lint suppressions before scanning").option("--warnings", "show warning-severity diagnostics (default)").option("--no-warnings", "hide warning-severity diagnostics (errors only)").option("--color", "force colored output").option("--no-color", "disable colored output (also honors NO_COLOR)").addHelpText("after", renderRootHelpEpilog);
 program.action(inspectAction);
 program.command("design [directory]").description("Run only the focused UI design diagnostics").addHelpText("after", renderDesignHelpEpilog).action((directory, _options, command) => designAction(directory ?? ".", command.optsWithGlobals()));
 program.command("why <location>").description("Explain why a rule fired (or why a suppression didn't apply) at a file:line").option("--project <name>", "select projects: workspace names or directory paths (comma-separated for multiple)").option("-c, --cwd <cwd>", "working directory", process.cwd()).option("--color", "force colored output").option("--no-color", "disable colored output (also honors NO_COLOR)").action((location, options) => whyAction(location, options));
@@ -97381,15 +98289,17 @@ rules.command("category <category> <severity>").description("Set the severity fo
 rules.command("ignore-tag <tag>").description("Skip a whole rule family by tag before linting (e.g. design)").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((tag, _options, command) => rulesIgnoreTagAction(tag, command.optsWithGlobals()));
 rules.command("unignore-tag <tag>").description("Stop ignoring a tag previously skipped via ignore-tag").option("-c, --cwd <cwd>", "working directory", process.cwd()).action((tag, _options, command) => rulesUnignoreTagAction(tag, command.optsWithGlobals()));
 program.command("experimental-lsp", { hidden: false }).description("[experimental] run the React Doctor language server over stdio (for editors)").allowUnknownOption().action(() => {});
-program.command("experimental-tui [directory]", { hidden: true }).description("[experimental] interactive, scrollable scan report").option("--blocking <level>", "severity that fails CI: error (default), warning, or none (advisory)").option("--color", "force colored output").option("--no-color", "disable colored output (also honors NO_COLOR)").option("--no-dead-code", "skip dead-code analysis").option("--no-score", "skip the score API, the share URL, and crash reporting").option("-p, --project <names>", "scan specific workspace projects (comma-separated, or *)").option("-y, --yes", "skip the project prompt and scan every discovered project").action(async (directory = ".", _localOptions, command) => {
+program.command("experimental-tui [directory]", { hidden: true }).description("[experimental] interactive, scrollable scan report").option("--blocking <level>", "severity that fails CI: error (default), warning, or none (advisory)").option("--color", "force colored output").option("--no-color", "disable colored output (also honors NO_COLOR)").option("--no-dead-code", "skip dead-code analysis").option("--no-supply-chain", "skip the dependency supply-chain scan").option("--no-score", "skip the score API, the share URL, and crash reporting").option("-p, --project <names>", "scan specific workspace projects (comma-separated, or *)").option("-y, --yes", "skip the project prompt and scan every discovered project").action(async (directory = ".", _localOptions, command) => {
 	const options = command.optsWithGlobals();
 	const deadCode = options.deadCode === false ? false : void 0;
 	const noScore = options.score === false ? true : void 0;
+	const supplyChain = options.supplyChain === false ? false : void 0;
 	const nodeMajorVersion = Number(process.versions.node.split(".")[0]);
 	if (process.stdout.isTTY !== true || process.stdin.isTTY !== true || isNonInteractiveEnvironment() || nodeMajorVersion < 22) {
 		await inspectAction(directory, {
 			deadCode,
 			score: options.score === false ? false : void 0,
+			supplyChain,
 			project: options.project,
 			yes: options.yes,
 			blocking: options.blocking
@@ -97397,12 +98307,13 @@ program.command("experimental-tui [directory]", { hidden: true }).description("[
 		return;
 	}
 	recordCount(METRIC.cliInvoked, 1, { command: "experimental-tui" });
-	const { runScanApp } = await import("./run-scan-app-DZ5jGWFf.js");
+	const { runScanApp } = await import("./run-scan-app-C9MJnVwv.js");
 	const { shouldFail } = await runScanApp({
 		directory,
 		options: {
 			deadCode,
-			noScore
+			noScore,
+			supplyChain
 		},
 		projectFlag: options.project,
 		skipPrompts: options.yes ?? false,
@@ -97436,7 +98347,7 @@ Promise.resolve().then(() => assertNoRemovedFlags(process.argv)).then(() => prog
 	handleError(error, { sentryEventId });
 });
 //#endregion
-export { toForwardSlashes as A, highlighter as B, buildRulePriorityMap as C, resolveBlockingLevel as D, formatLearnMoreLine as E, isCiEnvironment as F, sync as G, mergeReactDoctorConfigs as H, DIAGNOSTIC_CATEGORY_BUCKETS as I, void_ as K, Progress as L, isUnicodeSupported as M, METRIC as N, isReactDoctorWorkflowInstalled as O, TUI_REPORT_DETAIL_WIDTH_FRACTION as P, Reporter as R, hasLintHardFailure as S, formatFixRecipeLine as T, resolveScanTarget as U, mapWithConcurrency as V, runPromise as W, canAnimateOnboarding as _, resolveCliInspectOptions as a, buildCodeFrame as b, detectLaunchableAgents as c, launchCliAgent as d, isShareOptedOut as f, doctorFace as g, easeOutCubic as h, selectProjects as i, findNearestPackageDirectory as j, recordCount as k, CLI_AGENT_BINARIES as l, printFooter as m, shouldFailScanGate as n, countUniqueScannedFiles as o, inspect as p, succeed$3 as q, discoverWorkspacePackages as r, setUpGitHubActions as s, exitGracefully as t, copyToClipboard as u, computeProjectedScore as v, buildSortedRuleGroups as w, buildNoScoreMessage as x, formatElapsedTime as y, getCategoryImpact as z };
+export { toForwardSlashes as A, getCategoryImpact as B, buildRulePriorityMap as C, resolveBlockingLevel as D, formatLearnMoreLine as E, TUI_REPORT_DETAIL_WIDTH_FRACTION as F, runPromise as G, mapWithConcurrency as H, isCiEnvironment as I, succeed$3 as J, sync as K, DIAGNOSTIC_CATEGORY_BUCKETS as L, isUnicodeSupported as M, METRIC as N, isReactDoctorWorkflowInstalled as O, TUI_REPORT_COMPACT_MAX_ROWS as P, Progress as R, hasLintHardFailure as S, formatFixRecipeLine as T, mergeReactDoctorConfigs as U, highlighter as V, resolveScanTarget as W, canAnimateOnboarding as _, resolveCliInspectOptions as a, buildCodeFrame as b, detectLaunchableAgents as c, launchCliAgent as d, isShareOptedOut as f, doctorFace as g, easeOutCubic as h, selectProjects as i, findNearestPackageDirectory as j, recordCount as k, CLI_AGENT_BINARIES as l, printFooter as m, shouldFailScanGate as n, countUniqueScannedFiles as o, inspect as p, void_ as q, discoverWorkspacePackages as r, setUpGitHubActions as s, exitGracefully as t, copyToClipboard as u, computeProjectedScore as v, buildSortedRuleGroups as w, buildNoScoreMessage as x, formatElapsedTime as y, Reporter as z };
 
 //# sourceMappingURL=cli.js.map
-//# debugId=cf9aea89-a185-53f6-9e42-7af2cece64f2
+//# debugId=bb982094-8280-5afe-b061-eb103665c55c