react-doctor 0.9.2-dev.86add14 → 0.9.2-dev.992205a

package/dist/lsp.js

@@ -5,7 +5,7 @@ import * as OS from "node:os";
 import os from "node:os";
 import * as Path from "node:path";
 import path from "node:path";
-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 { 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, REACT_DOCTOR_RULE_REGISTRY, REACT_DOCTOR_SCAN_RULES, classifySecurityScanFile, collectCrossFileDependencyProbes, resetManifestCaches, shouldReadSecurityScanContent } from "oxlint-plugin-react-doctor/core";
 import * as Crypto from "node:crypto";
 import crypto, { createHash } from "node:crypto";
 import * as NodeChildProcess from "node:child_process";
@@ -17,6 +17,7 @@ import { fileURLToPath } from "node:url";
 import { parseJSON5 } from "confbox";
 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 { CodeActionKind, CodeActionTriggerKind, DidChangeWatchedFilesNotification, DocumentDiagnosticReportKind, FileChangeType, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node.js";
 import { TextDocument } from "vscode-languageserver-textdocument";
@@ -10280,7 +10281,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);
@@ -14334,12 +14335,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");
@@ -18091,7 +18092,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 = {
@@ -57696,7 +57697,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++) {
@@ -58330,7 +58331,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
@@ -58769,7 +58770,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));
 }));
 /**
@@ -61411,6 +61412,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;
@@ -61480,7 +61903,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;
@@ -62231,6 +62654,7 @@ const FRAMEWORK_PACKAGES = {
 	"@tanstack/react-start": "tanstack-start",
 	"@remix-run/react": "remix",
 	gatsby: "gatsby",
+	astro: "astro",
 	vite: "vite",
 	"react-scripts": "cra",
 	expo: "expo",
@@ -65302,7 +65726,7 @@ const evaluateSuppression = (lines, diagnosticLineIndex, ruleId) => {
 const getDiagnosticRuleIdentity = (diagnostic) => ({
 	ruleKey: `${diagnostic.plugin}/${diagnostic.rule}`,
 	category: diagnostic.category,
-	tags: diagnostic.plugin === "react-doctor" ? reactDoctorPlugin.rules[diagnostic.rule]?.tags ?? [] : []
+	tags: diagnostic.plugin === "react-doctor" ? REACT_DOCTOR_RULE_REGISTRY[diagnostic.rule]?.tags ?? [] : []
 });
 const compileIgnoredFilePatterns = (userConfig) => {
 	const files = userConfig?.ignore?.files;
@@ -65650,7 +66074,7 @@ const buildDiagnosticPipeline = (input) => {
 	};
 	const shouldAutoSuppress = (diagnostic) => {
 		if (diagnostic.plugin !== "react-doctor") return false;
-		const rule = reactDoctorPlugin.rules[diagnostic.rule];
+		const rule = REACT_DOCTOR_RULE_REGISTRY[diagnostic.rule];
 		if (!rule?.tags?.includes("test-noise")) return false;
 		if (rule.tags.includes("migration-hint")) return false;
 		return getFileContext(diagnostic.filePath) !== "production";
@@ -66060,6 +66484,7 @@ var OxlintConcurrency = class extends Reference("react-doctor/OxlintConcurrency"
 	if (Number.isInteger(parsed) && parsed > 0) return resolveScanConcurrency(parsed);
 	return resolveAutoScanConcurrency();
 } }) {};
+var OxlintSpawnSlots = class extends Reference("react-doctor/OxlintSpawnSlots", { defaultValue: () => null }) {};
 /**
 * Three-state control for overlapping the dead-code pass with the lint pass —
 * forking dead-code as a child fiber that runs DURING lint instead of strictly
@@ -68334,8 +68759,8 @@ const getCapabilities = (project) => {
 	const cached = capabilitiesByProject.get(project);
 	if (cached !== void 0) return cached;
 	const capabilities = new Set(buildCapabilities(project));
-	const packageJson = readPackageJson(Path.join(project.rootDirectory, "package.json"));
-	const targetBlankOpenerProtection = detectTargetBlankOpenerProtection(project.rootDirectory, packageJson);
+	const capabilityRootDirectory = isFile(Path.join(project.rootDirectory, "package.json")) ? project.rootDirectory : findNearestAncestorPackageJson(project.rootDirectory) ?? project.rootDirectory;
+	const targetBlankOpenerProtection = detectTargetBlankOpenerProtection(capabilityRootDirectory, readPackageJson(Path.join(capabilityRootDirectory, "package.json")));
 	if (targetBlankOpenerProtection !== void 0) capabilities.add("target-blank-needs-explicit-protection");
 	if (targetBlankOpenerProtection === "noreferrer") capabilities.add("target-blank-needs-noreferrer");
 	capabilitiesByProject.set(project, capabilities);
@@ -68365,7 +68790,7 @@ const createSecurityScanSession = (rootDirectory, options) => {
 	const capabilities = options.project ? getCapabilities(options.project) : /* @__PURE__ */ new Set();
 	const ignoredTags = options.ignoredTags ?? /* @__PURE__ */ new Set();
 	const includedTags = options.includedTags ?? /* @__PURE__ */ new Set();
-	const enabledScanRules = REACT_DOCTOR_RULES.flatMap((entry) => {
+	const enabledScanRules = REACT_DOCTOR_SCAN_RULES.flatMap((entry) => {
 		const rule = entry.rule;
 		const scan = rule.scan;
 		if (typeof scan !== "function") return [];
@@ -68810,47 +69235,55 @@ const resolveDeadCodeConcurrency = (facts = readSystemFacts()) => {
 	const memoryBoundedWorkers = Math.floor(availableMemoryBytes / DEAD_CODE_WORKER_MEM_BUDGET_BYTES);
 	return Math.max(1, Math.min(facts.availableCores, memoryBoundedWorkers));
 };
-let availableSlots = -1;
-const waiters = [];
-const releaseSlot = () => {
-	const nextWaiter = waiters.shift();
-	if (nextWaiter !== void 0) nextWaiter();
-	else availableSlots += 1;
+const createWorkerSlots = (input) => {
+	let availableSlotCount = input.slotCount;
+	const waiters = [];
+	const releaseSlot = () => {
+		const nextWaiter = waiters.shift();
+		if (nextWaiter === void 0) {
+			availableSlotCount += 1;
+			return;
+		}
+		nextWaiter.abortSignal?.removeEventListener("abort", nextWaiter.onAbort);
+		nextWaiter.resolve();
+	};
+	const acquireSlot = async (abortSignal) => {
+		if (abortSignal?.aborted) throw input.createAbortError();
+		if (availableSlotCount > 0) {
+			availableSlotCount -= 1;
+			return;
+		}
+		await new Promise((resolve, reject) => {
+			const onAbort = () => {
+				const waiterIndex = waiters.indexOf(waiter);
+				if (waiterIndex !== -1) waiters.splice(waiterIndex, 1);
+				reject(input.createAbortError());
+			};
+			const waiter = {
+				resolve,
+				abortSignal,
+				onAbort
+			};
+			waiters.push(waiter);
+			abortSignal?.addEventListener("abort", onAbort, { once: true });
+		});
+	};
+	return { run: async (task, abortSignal) => {
+		await acquireSlot(abortSignal);
+		try {
+			return await task();
+		} finally {
+			releaseSlot();
+		}
+	} };
 };
-/**
-* Runs `task` once a dead-code worker slot is free, releasing the slot when the
-* task settles (success or failure). With a high cap (roomy machine) every
-* caller proceeds immediately; with a low cap (constrained runner) callers
-* queue and run as slots free.
-*
-* `abortSignal` short-circuits the WAIT: if it's already aborted, or fires while
-* this caller is queued, the call rejects without acquiring a slot or running
-* `task` — so a cancelled scan (e.g. lint failed) doesn't sit in the queue and
-* then spawn a child only to tear it down. A queued caller that aborts removes
-* its own waiter so a later release never hands a slot to a dead request.
-*/
+let deadCodeWorkerSlots = null;
 const withDeadCodeWorkerSlot = async (task, abortSignal) => {
-	if (abortSignal?.aborted) throw new Error("Dead-code worker aborted.");
-	if (availableSlots < 0) availableSlots = resolveDeadCodeConcurrency();
-	if (availableSlots > 0) availableSlots -= 1;
-	else await new Promise((resolve, reject) => {
-		const waiter = () => {
-			abortSignal?.removeEventListener("abort", onAbort);
-			resolve();
-		};
-		const onAbort = () => {
-			const queuedIndex = waiters.indexOf(waiter);
-			if (queuedIndex !== -1) waiters.splice(queuedIndex, 1);
-			reject(/* @__PURE__ */ new Error("Dead-code worker aborted."));
-		};
-		waiters.push(waiter);
-		abortSignal?.addEventListener("abort", onAbort, { once: true });
+	deadCodeWorkerSlots ??= createWorkerSlots({
+		slotCount: resolveDeadCodeConcurrency(),
+		createAbortError: () => /* @__PURE__ */ new Error("Dead-code worker aborted.")
 	});
-	try {
-		return await task();
-	} finally {
-		releaseSlot();
-	}
+	return deadCodeWorkerSlots.run(task, abortSignal);
 };
 const projectCacheSubdir = (projectDirectory) => crypto.createHash("sha256").update(projectDirectory).digest("hex").slice(0, 16);
 const resolveReactDoctorCacheDir = (projectDirectory) => {
@@ -70377,12 +70810,12 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 	const settingsRootDirectory = resolveSettingsRootDirectory(project.rootDirectory);
 	const enabledReactDoctorRules = {};
 	for (const registryEntry of REACT_DOCTOR_RULES) {
-		const rule = reactDoctorPlugin.rules[registryEntry.id];
+		const rule = REACT_DOCTOR_RULE_REGISTRY[registryEntry.id];
 		if (!rule) continue;
 		if (ruleSelection === "cacheable" && CROSS_FILE_RULE_IDS.has(registryEntry.id)) continue;
 		if (ruleSelection === "sidecar" && !CROSS_FILE_RULE_IDS.has(registryEntry.id)) continue;
 		if (ruleSelection === "sidecar" && sidecarRuleIdFilter !== void 0 && !sidecarRuleIdFilter.has(registryEntry.id)) continue;
-		if (rule.scan !== void 0) continue;
+		if (rule.isScanRule) continue;
 		if (customRulesOnly && registryEntry.originallyExternal) continue;
 		if (rule.framework !== "global" && !rule.requires) continue;
 		if (!shouldEnableRule(rule.requires, rule.tags, capabilities, ignoredTags, rule.disabledWhen, includedTags)) continue;
@@ -71007,6 +71440,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 = [
@@ -71649,7 +72126,7 @@ const PLUGIN_CATEGORY_MAP = {
 };
 const lookupOwnString = (record, key) => Object.hasOwn(record, key) ? record[key] : void 0;
 const getRuleRecommendation = (ruleName, project) => {
-	const rule = reactDoctorPlugin.rules[ruleName];
+	const rule = REACT_DOCTOR_RULE_REGISTRY[ruleName];
 	if (!rule) return void 0;
 	if (rule.recommendationFor) {
 		const capabilities = getCapabilities(project);
@@ -71658,8 +72135,8 @@ const getRuleRecommendation = (ruleName, project) => {
 	}
 	return rule.recommendation;
 };
-const getRuleCategory = (ruleName) => reactDoctorPlugin.rules[ruleName]?.category;
-const getRuleTitle = (ruleName) => reactDoctorPlugin.rules[ruleName]?.title;
+const getRuleCategory = (ruleName) => REACT_DOCTOR_RULE_REGISTRY[ruleName]?.category;
+const getRuleTitle = (ruleName) => REACT_DOCTOR_RULE_REGISTRY[ruleName]?.title;
 const resolveDiagnosticTitle = (plugin, rule) => {
 	if (plugin !== "react-hooks-js") return getRuleTitle(rule);
 	if (rule === "error-boundaries") return REACT_ERROR_BOUNDARY_TITLE;
@@ -71714,7 +72191,7 @@ const resolveDiagnosticCategory = (plugin, rule) => {
 	if (plugin === "react-hooks-js" && rule === "error-boundaries") return "Bugs";
 	return getRuleCategory(rule) ?? lookupOwnString(PLUGIN_CATEGORY_MAP, plugin) ?? "Bugs";
 };
-const resolveMatchByOccurrence = (rule, category) => OCCURRENCE_MATCHED_CATEGORIES.has(category) || Boolean(reactDoctorPlugin.rules[rule]?.matchByOccurrence);
+const resolveMatchByOccurrence = (rule, category) => OCCURRENCE_MATCHED_CATEGORIES.has(category) || Boolean(REACT_DOCTOR_RULE_REGISTRY[rule]?.matchByOccurrence);
 /**
 * Maps oxlint's non-primary labels (`labels[1..]`) into related source
 * locations. Editors surface these as a diagnostic's
@@ -71751,7 +72228,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;
@@ -71769,6 +72246,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));
@@ -71800,7 +72278,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" || !REACT_DOCTOR_RULE_REGISTRY[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);
@@ -71878,11 +72368,12 @@ const SANITIZED_ENV = buildOxlintChildEnv(process.env);
 * The first three are splittable (the caller's binary-split retry
 * shrinks the batch and re-spawns); the fourth isn't.
 */
-const spawnOxlint = (args, rootDirectory, nodeBinaryPath, spawnTimeoutMs = OXLINT_SPAWN_TIMEOUT_MS, outputMaxBytes = OXLINT_OUTPUT_MAX_BYTES, abortSignal) => new Promise((resolve, reject) => {
+const spawnOxlint = (args, rootDirectory, nodeBinaryPath, spawnTimeoutMs = OXLINT_SPAWN_TIMEOUT_MS, outputMaxBytes = OXLINT_OUTPUT_MAX_BYTES, abortSignal, onSpawn) => new Promise((resolve, reject) => {
 	if (abortSignal?.aborted) {
 		reject(new ReactDoctorError({ reason: new OxlintSpawnFailed({ cause: "lint phase aborted" }) }));
 		return;
 	}
+	onSpawn?.();
 	const child = spawn(nodeBinaryPath, buildProfiledNodeArguments({
 		argumentsList: args,
 		cpuProfileDirectory: SANITIZED_ENV.REACT_DOCTOR_CPU_PROFILE_DIR,
@@ -72018,7 +72509,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;
@@ -72042,7 +72533,21 @@ const spawnLintBatches = async (input) => {
 			}
 			const batchArgs = [...baseArgs, ...batch];
 			try {
-				return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes, signal), project, rootDirectory, sourcePathByLintPath);
+				const spawnBatch = () => {
+					if (isPastDeadline()) {
+						deadlineSkippedFiles.push(...batch);
+						batchState.deadlineSkippedFileCount += batch.length;
+						return Promise.resolve(null);
+					}
+					return spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes, signal, () => {
+						if (batchState.didStart) return;
+						batchState.didStart = true;
+						startedFileCount += batchState.initialFileCount;
+					});
+				};
+				const stdout = input.spawnSlots === void 0 ? await spawnBatch() : await input.spawnSlots.run(spawnBatch, signal);
+				if (stdout === null) return [];
+				return parseOxlintOutput(stdout, project, rootDirectory, sourcePathByLintPath, sourceMapByLintPath);
 			} catch (error) {
 				if (!isSplittableReactDoctorError(error)) throw error;
 				if (isPastDeadline()) {
@@ -72086,14 +72591,15 @@ const spawnLintBatches = async (input) => {
 					deadlineSkippedFiles.push(...batch);
 					return [];
 				}
-				startedFileCount += batch.length;
 				const batchState = {
 					deadlineMs: null,
-					deadlineSkippedFileCount: 0
+					deadlineSkippedFileCount: 0,
+					didStart: false,
+					initialFileCount: batch.length
 				};
 				const batchDiagnostics = await spawnLintBatch(batch, 0, batchState);
 				scannedFileCount += batch.length - batchState.deadlineSkippedFileCount;
-				if (passOnFileProgress) {
+				if (passOnFileProgress && batchState.didStart) {
 					displayedFileCount = Math.min(Math.max(displayedFileCount, scannedFileCount), totalFileCount);
 					passOnFileProgress(displayedFileCount, totalFileCount);
 				}
@@ -72177,8 +72683,8 @@ const validateRuleRegistration = () => {
 	for (const fullKey of ALL_REACT_DOCTOR_RULE_KEYS) {
 		const ruleName = fullKey.replace(/^react-doctor\//, "");
 		if (!getRuleCategory(ruleName)) missingCategory.push(fullKey);
-		if (!reactDoctorPlugin.rules[ruleName]?.recommendation) missingHelp.push(fullKey);
-		if (FRAMEWORK_SPECIFIC_RULE_KEYS.has(fullKey) && !reactDoctorPlugin.rules[ruleName]?.requires) missingMetadata.push(fullKey);
+		if (!REACT_DOCTOR_RULE_REGISTRY[ruleName]?.recommendation) missingHelp.push(fullKey);
+		if (FRAMEWORK_SPECIFIC_RULE_KEYS.has(fullKey) && !REACT_DOCTOR_RULE_REGISTRY[ruleName]?.requires) missingMetadata.push(fullKey);
 	}
 	if (missingCategory.length === 0 && missingHelp.length === 0 && missingMetadata.length === 0) return;
 	const detail = [
@@ -72481,20 +72987,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`);
@@ -72508,6 +73041,7 @@ const prepareHtmlLintSources = (rootDirectory, temporaryDirectory, candidateFile
 	return {
 		lintFiles,
 		sourcePathByLintPath,
+		sourceMapByLintPath,
 		sizeByLintPath,
 		hasThreeModuleImport
 	};
@@ -72726,10 +73260,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;
@@ -72751,7 +73285,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,
@@ -72781,7 +73315,8 @@ const runOxlint = async (options) => {
 					rootDirectory,
 					nodeBinaryPath,
 					project: lintProject,
-					sourcePathByLintPath: preparedHtmlSources.sourcePathByLintPath,
+					sourcePathByLintPath: preparedLintSources.sourcePathByLintPath,
+					sourceMapByLintPath: preparedLintSources.sourceMapByLintPath,
 					onPartialFailure: reportPartialFailure,
 					onAnalyzedFiles: (filePaths) => {
 						analyzedFiles = filePaths;
@@ -72790,6 +73325,7 @@ const runOxlint = async (options) => {
 					spawnTimeoutMs,
 					outputMaxBytes,
 					concurrency: options.concurrency,
+					spawnSlots: options.spawnSlots,
 					signal: options.signal,
 					deadlineEpochMs: options.deadlineEpochMs
 				});
@@ -72816,7 +73352,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: [],
@@ -72982,7 +73518,8 @@ const runOxlint = async (options) => {
 			rootDirectory,
 			nodeBinaryPath,
 			project: lintProject,
-			sourcePathByLintPath: preparedHtmlSources.sourcePathByLintPath,
+			sourcePathByLintPath: preparedLintSources.sourcePathByLintPath,
+			sourceMapByLintPath: preparedLintSources.sourceMapByLintPath,
 			onPartialFailure,
 			onAnalyzedFiles: (filePaths) => {
 				analyzedFiles = filePaths;
@@ -72991,6 +73528,7 @@ const runOxlint = async (options) => {
 			spawnTimeoutMs,
 			outputMaxBytes,
 			concurrency: options.concurrency,
+			spawnSlots: options.spawnSlots,
 			signal: options.signal,
 			deadlineEpochMs: options.deadlineEpochMs
 		});
@@ -73085,6 +73623,7 @@ var Linter = class Linter extends Service()("react-doctor/Linter") {
 		const spawnTimeoutMs = yield* OxlintSpawnTimeoutMs;
 		const outputMaxBytes = yield* OxlintOutputMaxBytes;
 		const concurrency = yield* OxlintConcurrency;
+		const spawnSlots = yield* OxlintSpawnSlots;
 		const lintBatchOrdering = yield* LintBatchOrdering;
 		const perFileLintCacheEnabled = yield* PerFileLintCacheEnabled;
 		const sidecarLintCacheEnabled = yield* SidecarLintCacheEnabled;
@@ -73114,6 +73653,7 @@ var Linter = class Linter extends Service()("react-doctor/Linter") {
 				onSidecarStats: input.onSidecarStats,
 				spawnTimeoutMs,
 				outputMaxBytes,
+				spawnSlots: spawnSlots ?? void 0,
 				concurrency,
 				signal,
 				lintBatchOrdering,
@@ -74484,7 +75024,7 @@ const runEditorScan = async (input) => {
 * other `clear*` helpers.
 */
 const clearAutoSuppressionCaches = () => {};
-const lookupOwnRule = (rule) => Object.hasOwn(reactDoctorPlugin.rules, rule) ? reactDoctorPlugin.rules[rule] : void 0;
+const lookupOwnRule = (rule) => Object.hasOwn(REACT_DOCTOR_RULE_REGISTRY, rule) ? REACT_DOCTOR_RULE_REGISTRY[rule] : void 0;
 /**
 * Returns presentation metadata for `<plugin>/<rule>`, or `null` when the
 * rule is not part of the bundled react-doctor plugin (e.g. an adopted
@@ -76560,5 +77100,5 @@ const startLanguageServer = () => {
 };
 //#endregion
 export { startLanguageServer };
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="390ba7cd-f884-5c1e-aa8d-f48ccc1994f7")}catch(e){}}();
-//# debugId=390ba7cd-f884-5c1e-aa8d-f48ccc1994f7
+!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]="ec49e114-f0f3-593d-b3c1-8b1a04d065a6")}catch(e){}}();
+//# debugId=ec49e114-f0f3-593d-b3c1-8b1a04d065a6