react-doctor 0.9.2-dev.3f3197f → 0.9.2-dev.83f3ff8

package/dist/index.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="41e39010-e2d7-5e6b-9bba-626bf64affe5")}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]="18c61424-4926-5cae-8f2a-6001534ea755")}catch(e){}}();
 import { i as __toESM$1, r as __require, t as __commonJSMin$1 } from "./chunk-ChKA3wi6.js";
 import { createRequire } from "node:module";
 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";
@@ -13,13 +13,14 @@ import * as NodeChildProcess from "node:child_process";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { ResolverFactory } from "oxc-resolver";
 import ts from "typescript";
+import * as NodeUrl from "node:url";
+import { fileURLToPath } from "node:url";
 import * as OS from "node:os";
 import os from "node:os";
 import { parseJSON5 } from "confbox";
-import * as NodeUrl from "node:url";
-import { fileURLToPath } 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";
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.70/node_modules/effect/dist/Pipeable.js
 /**
@@ -10262,7 +10263,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);
@@ -14304,12 +14305,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");
@@ -18061,7 +18062,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 = {
@@ -57666,7 +57667,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++) {
@@ -58300,7 +58301,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
@@ -58739,7 +58740,7 @@ const layer$7 = (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));
 }));
 /**
@@ -61381,6 +61382,428 @@ const layer = /* @__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;
@@ -61450,7 +61873,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;
@@ -62178,6 +62601,7 @@ const FRAMEWORK_PACKAGES = {
 	"@tanstack/react-start": "tanstack-start",
 	"@remix-run/react": "remix",
 	gatsby: "gatsby",
+	astro: "astro",
 	vite: "vite",
 	"react-scripts": "cra",
 	expo: "expo",
@@ -62399,10 +62823,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;
 };
@@ -62538,8 +62968,8 @@ const getStaticConfigValueState = (expression, analysis, visitedExpressions = /*
 	};
 	if (ts.isIdentifier(unwrappedExpression)) {
 		if (analysis.localBindings.has(unwrappedExpression.text)) {
-			const localInitializer = analysis.localBindings.get(unwrappedExpression.text);
-			return localInitializer ? getStaticConfigValueState(localInitializer, analysis, nextVisitedExpressions) : 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, nextVisitedExpressions) : null;
@@ -62581,8 +63011,8 @@ const getReactCompilerFlagState = (expression, analysis, visitedExpressions = /*
 		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, nextVisitedExpressions) : 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, nextVisitedExpressions) : null;
@@ -62605,8 +63035,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;
@@ -62615,9 +63045,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;
@@ -62630,8 +63069,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;
@@ -62715,15 +63154,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,
@@ -62733,14 +63172,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);
@@ -62748,7 +63200,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);
@@ -62767,7 +63219,7 @@ const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, a
 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);
+	return analyzeConfigModuleExport(importedFilePath, exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, argumentsList, analysis);
 };
 const analyzeConfigIdentifier = (identifier, analysis, allowCompilerTransform, isCompilerTransformCollection, excludedPropertyNames) => {
 	const assignedReactCompiler = getAssignedPropertyInitializer(identifier, "reactCompiler");
@@ -62781,8 +63233,8 @@ 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));
@@ -62848,7 +63300,7 @@ const analyzeConfigCallTarget = (callExpression, analysis, allowCompilerTransfor
 	}
 	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(",") : "";
@@ -62948,7 +63400,7 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		if (ts.isIdentifier(node.expression)) {
 			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, analysis, allowCompilerTransform));
+				return Boolean(selectedProperty && analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform));
 			}
 			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
 			if (importBinding?.isNamespace) {
@@ -62962,7 +63414,7 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 				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);
@@ -62971,7 +63423,7 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		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, analysis, allowCompilerTransform));
+				return Boolean(selectedProperty && analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform));
 			}
 			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
 			if (importBinding?.isNamespace) {
@@ -62984,7 +63436,7 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 				}));
 			}
 			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);
@@ -65361,6 +65813,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`.
@@ -65370,6 +65823,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(/^\.\//, "")}`;
@@ -69634,7 +70088,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;
@@ -69907,7 +70364,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({
@@ -70995,6 +71452,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 = [
@@ -71739,7 +72240,7 @@ const isOxlintOutput = (value) => isRecord(value) && Array.isArray(value.diagnos
 * 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;
@@ -71757,6 +72258,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));
@@ -71788,7 +72290,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);
@@ -72006,7 +72520,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;
@@ -72030,7 +72544,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()) {
@@ -72469,20 +72983,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`);
@@ -72496,6 +73037,7 @@ const prepareHtmlLintSources = (rootDirectory, temporaryDirectory, candidateFile
 	return {
 		lintFiles,
 		sourcePathByLintPath,
+		sourceMapByLintPath,
 		sizeByLintPath,
 		hasThreeModuleImport
 	};
@@ -72714,10 +73256,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;
@@ -72739,7 +73281,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,
@@ -72769,7 +73311,8 @@ const runOxlint = async (options) => {
 					rootDirectory,
 					nodeBinaryPath,
 					project: lintProject,
-					sourcePathByLintPath: preparedHtmlSources.sourcePathByLintPath,
+					sourcePathByLintPath: preparedLintSources.sourcePathByLintPath,
+					sourceMapByLintPath: preparedLintSources.sourceMapByLintPath,
 					onPartialFailure: reportPartialFailure,
 					onAnalyzedFiles: (filePaths) => {
 						analyzedFiles = filePaths;
@@ -72804,7 +73347,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: [],
@@ -72970,7 +73513,8 @@ const runOxlint = async (options) => {
 			rootDirectory,
 			nodeBinaryPath,
 			project: lintProject,
-			sourcePathByLintPath: preparedHtmlSources.sourcePathByLintPath,
+			sourcePathByLintPath: preparedLintSources.sourcePathByLintPath,
+			sourceMapByLintPath: preparedLintSources.sourceMapByLintPath,
 			onPartialFailure,
 			onAnalyzedFiles: (filePaths) => {
 				analyzedFiles = filePaths;
@@ -74319,10 +74863,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 {
@@ -74343,15 +74891,17 @@ const materializeSourceTree = (input) => gen(function* () {
 	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"))
 		});
@@ -74366,6 +74916,7 @@ const materializeSourceTree = (input) => gen(function* () {
 		materialize: ({ tempDirectory }) => succeed$2({
 			tempDirectory,
 			stagedFiles: snapshot.materializedFiles ?? snapshot.sourceFiles ?? [],
+			unmaterializedFiles: [],
 			cleanup: () => {}
 		})
 	}));
@@ -74892,4 +75443,4 @@ const toJsonReport = (result, options) => buildJsonReport({
 export { AmbiguousProjectError, NoReactDependencyError, NotADirectoryError, PackageJsonNotFoundError, ProjectNotFoundError, ReactDoctorError, buildJsonReport, buildJsonReportError, clearCaches, defineConfig, diagnose, filterSourceFiles, getDiffInfo, hasReactRuntime, isProjectDiscoveryError, isReactDoctorError, summarizeDiagnostics, toJsonReport };
 
 //# sourceMappingURL=index.js.map
-//# debugId=41e39010-e2d7-5e6b-9bba-626bf64affe5
+//# debugId=18c61424-4926-5cae-8f2a-6001534ea755