react-doctor 0.9.1 → 0.9.2

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]="eb93b210-c190-581c-8fe2-f1e1c70e0bab")}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]="41e39010-e2d7-5e6b-9bba-626bf64affe5")}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";
@@ -11,6 +11,7 @@ import * as Path from "node:path";
 import path from "node:path";
 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 OS from "node:os";
 import os from "node:os";
@@ -61448,7 +61449,8 @@ var AmbiguousProjectError = class extends Error {
 	}
 };
 const isProjectDiscoveryError = (value) => value instanceof ProjectNotFoundError || value instanceof NoReactDependencyError || value instanceof PackageJsonNotFoundError || value instanceof NotADirectoryError || value instanceof AmbiguousProjectError;
-const SOURCE_FILE_PATTERN = /\.(tsx?|jsx?|mts|mjs)$/;
+const HTML_FILE_PATTERN = /\.html$/i;
+const SOURCE_FILE_PATTERN = /\.(?: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;
@@ -61791,7 +61793,7 @@ const SOCKET_FREE_USER_AGENT = "react-doctor-supply-chain";
 const FILE_LINT_CACHE_FILENAME = "file-lint-cache.json";
 const FILE_LINT_CACHE_MAX_FILE_COUNT = 5e4;
 const SIDECAR_LINT_CACHE_FILENAME = "sidecar-lint-cache.json";
-const CORE_PACKAGE_VERSION = "0.9.1";
+const CORE_PACKAGE_VERSION = "0.9.2";
 const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
 const DEAD_CODE_SUMMARY_CACHE_FILENAME = "dead-code-summaries.json";
 const SUPPLY_CHAIN_PLUGIN = "socket";
@@ -62041,8 +62043,13 @@ const findMonorepoRoot = (startDirectory) => {
 * byte-equivalent copy.
 */
 const isProjectBoundary = (directory) => NFS.existsSync(Path.join(directory, ".git")) || isMonorepoRoot(directory);
+const unwrapTypescriptExpression = (expression) => {
+	let currentExpression = expression;
+	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
+	return currentExpression;
+};
 const TSCONFIG_FILENAME = "tsconfig.json";
-const isRelativeExtendsValue = (extendsValue) => extendsValue.startsWith("./") || extendsValue.startsWith("../") || Path.isAbsolute(extendsValue);
+const isLocalModuleSpecifier = (moduleSpecifier) => moduleSpecifier === "." || moduleSpecifier === ".." || moduleSpecifier.startsWith("./") || moduleSpecifier.startsWith("../") || Path.isAbsolute(moduleSpecifier);
 const ensureJsonExtension = (filePath) => Path.extname(filePath) === "" ? `${filePath}.json` : filePath;
 const resolvePackageExtendsPath = (extendsValue, fromConfigDirectory) => {
 	const requireFromConfig = createRequire(Path.join(fromConfigDirectory, "tsconfig.json"));
@@ -62059,7 +62066,12 @@ const resolvePackageExtendsPath = (extendsValue, fromConfigDirectory) => {
 	return null;
 };
 const resolveExtendsPath = (extendsValue, fromConfigDirectory) => {
-	if (isRelativeExtendsValue(extendsValue)) return ensureJsonExtension(Path.resolve(fromConfigDirectory, extendsValue));
+	if (isLocalModuleSpecifier(extendsValue)) {
+		const resolvedPath = Path.resolve(fromConfigDirectory, extendsValue);
+		if (isFile(resolvedPath)) return resolvedPath;
+		const directoryConfigPath = Path.join(resolvedPath, TSCONFIG_FILENAME);
+		return isFile(directoryConfigPath) ? directoryConfigPath : ensureJsonExtension(resolvedPath);
+	}
 	return resolvePackageExtendsPath(extendsValue, fromConfigDirectory);
 };
 const normalizeCompilerOptions = (compilerOptions) => {
@@ -62253,6 +62265,15 @@ const REACT_COMPILER_CONFIG_SOURCE_EXTENSIONS = [
 	".cts",
 	".json"
 ];
+const REACT_COMPILER_CONFIG_RESOLVER = new ResolverFactory({
+	conditionNames: [
+		"import",
+		"require",
+		"node",
+		"default"
+	],
+	extensions: REACT_COMPILER_CONFIG_SOURCE_EXTENSIONS
+});
 const STATIC_EXPORT_OUTPUT_PATTERN = /(?:^|[^.\w])["']?output["']?\s*:\s*["']export["']/m;
 const hasCompilerPackage = (packageJson, compilerPackages) => {
 	const allDependencies = {
@@ -62276,6 +62297,18 @@ const hasCompilerPackageInAncestors = (directory, compilerPackages) => {
 	return false;
 };
 const resolveImportedConfigFile = (fromFilePath, moduleSpecifier) => {
+	if (!isLocalModuleSpecifier(moduleSpecifier)) {
+		try {
+			const resolvedPath = REACT_COMPILER_CONFIG_RESOLVER.resolveFileSync(fromFilePath, moduleSpecifier).path;
+			if (resolvedPath && isFile(resolvedPath)) return resolvedPath;
+		} catch {}
+		try {
+			const resolvedPath = createRequire(fromFilePath).resolve(moduleSpecifier);
+			return isFile(resolvedPath) ? resolvedPath : null;
+		} catch {
+			return null;
+		}
+	}
 	const unresolvedPath = Path.resolve(Path.dirname(fromFilePath), moduleSpecifier);
 	const extension = Path.extname(unresolvedPath);
 	return (extension ? [unresolvedPath, ...REACT_COMPILER_CONFIG_SOURCE_EXTENSIONS.map((sourceExtension) => `${unresolvedPath.slice(0, -extension.length)}${sourceExtension}`)] : [
@@ -62285,10 +62318,10 @@ const resolveImportedConfigFile = (fromFilePath, moduleSpecifier) => {
 	]).find(isFile) ?? null;
 };
 const parseConfigSourceFile = (filePath, content) => filePath.endsWith(".json") || Path.basename(filePath) === ".babelrc" ? ts.parseJsonText(filePath, content) : ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-const getStaticPropertyName$1 = (propertyName) => ts.isIdentifier(propertyName) || ts.isStringLiteralLike(propertyName) ? propertyName.text : ts.isComputedPropertyName(propertyName) && ts.isStringLiteralLike(propertyName.expression) ? propertyName.expression.text : null;
+const getStaticPropertyName$2 = (propertyName) => ts.isIdentifier(propertyName) || ts.isStringLiteralLike(propertyName) ? propertyName.text : ts.isComputedPropertyName(propertyName) && ts.isStringLiteralLike(propertyName.expression) ? propertyName.expression.text : null;
 const isCommonJsConfigExportAssignment = (node, sourceFile) => ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && (node.left.getText(sourceFile) === "module.exports" || node.left.getText(sourceFile) === "exports.default");
 const hasExportModifier = (node) => ts.canHaveModifiers(node) && Boolean(ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
-const getRequireModuleSpecifier = (expression) => {
+const getRequireModuleSpecifier$1 = (expression) => {
 	if (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.expression.text !== "require" || expression.arguments.length !== 1) return null;
 	const moduleSpecifier = expression.arguments[0];
 	return moduleSpecifier && ts.isStringLiteralLike(moduleSpecifier) ? moduleSpecifier.text : null;
@@ -62301,7 +62334,7 @@ const hasTopLevelValueBinding = (sourceFile, bindingName) => sourceFile.statemen
 		const namedBindings = importClause?.namedBindings;
 		return namedBindings ? ts.isNamespaceImport(namedBindings) ? namedBindings.name.text === bindingName : namedBindings.elements.some((element) => element.name.text === bindingName) : false;
 	}
-	if (ts.isVariableStatement(statement)) return statement.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === bindingName);
+	if (ts.isVariableStatement(statement)) return statement.declarationList.declarations.some((declaration) => bindingNameContainsIdentifier(declaration.name, bindingName));
 	return (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name?.text === bindingName;
 });
 const getImportBinding = (sourceFile, bindingName) => {
@@ -62332,24 +62365,24 @@ const getImportBinding = (sourceFile, bindingName) => {
 		for (const declaration of statement.declarationList.declarations) {
 			if (!declaration.initializer) continue;
 			if (ts.isIdentifier(declaration.name) && declaration.name.text === bindingName) {
-				const directModuleSpecifier = getRequireModuleSpecifier(declaration.initializer);
+				const directModuleSpecifier = getRequireModuleSpecifier$1(declaration.initializer);
 				if (directModuleSpecifier) return {
 					moduleSpecifier: directModuleSpecifier,
 					exportName: "default",
 					isNamespace: true
 				};
-				if (ts.isPropertyAccessExpression(declaration.initializer) && getRequireModuleSpecifier(declaration.initializer.expression) !== null) return {
-					moduleSpecifier: getRequireModuleSpecifier(declaration.initializer.expression) ?? "",
+				if (ts.isPropertyAccessExpression(declaration.initializer) && getRequireModuleSpecifier$1(declaration.initializer.expression) !== null) return {
+					moduleSpecifier: getRequireModuleSpecifier$1(declaration.initializer.expression) ?? "",
 					exportName: declaration.initializer.name.text,
 					isNamespace: false
 				};
 			}
 			if (!ts.isObjectBindingPattern(declaration.name)) continue;
 			const bindingElement = declaration.name.elements.find((element) => ts.isIdentifier(element.name) && element.name.text === bindingName);
-			const moduleSpecifier = getRequireModuleSpecifier(declaration.initializer);
+			const moduleSpecifier = getRequireModuleSpecifier$1(declaration.initializer);
 			if (bindingElement && moduleSpecifier) return {
 				moduleSpecifier,
-				exportName: bindingElement.propertyName ? getStaticPropertyName$1(bindingElement.propertyName) ?? bindingElement.propertyName.getText(sourceFile) : bindingElement.name.getText(sourceFile),
+				exportName: bindingElement.propertyName ? getStaticPropertyName$2(bindingElement.propertyName) ?? bindingElement.propertyName.getText(sourceFile) : bindingElement.name.getText(sourceFile),
 				isNamespace: false
 			};
 		}
@@ -62402,6 +62435,48 @@ const getScopedConfigBinding = (identifier) => {
 	};
 };
 const isCompilerTransformModule = (moduleSpecifier, exportName) => moduleSpecifier === "babel-plugin-react-compiler" && exportName === "default" || moduleSpecifier === "@vitejs/plugin-react" && exportName === "reactCompilerPreset";
+const NODE_MODULE_SPECIFIERS = new Set(["module", "node:module"]);
+const isConstantVariableInitializer = (node) => ts.isExpression(node) && ts.isVariableDeclaration(node.parent) && ts.isVariableDeclarationList(node.parent.parent) && Boolean(node.parent.parent.flags & ts.NodeFlags.Const);
+const isNodeCreateRequireCall = (node, analysis) => {
+	if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node) || ts.isAwaitExpression(node)) return isNodeCreateRequireCall(node.expression, analysis);
+	if (!ts.isCallExpression(node)) return false;
+	const target = node.expression;
+	if (ts.isIdentifier(target)) {
+		if (analysis.localBindings.has(target.text) || getScopedConfigBinding(target).wasFound) return false;
+		const importBinding = getImportBinding(analysis.sourceFile, target.text);
+		return Boolean(importBinding && NODE_MODULE_SPECIFIERS.has(importBinding.moduleSpecifier) && importBinding.exportName === "createRequire");
+	}
+	if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return false;
+	if ((ts.isPropertyAccessExpression(target) ? target.name.text : target.argumentExpression && ts.isStringLiteralLike(target.argumentExpression) ? target.argumentExpression.text : null) !== "createRequire") return false;
+	const createRequireReceiver = target.expression;
+	if (ts.isCallExpression(createRequireReceiver)) {
+		const requiredModuleSpecifier = getRequireModuleSpecifier$1(createRequireReceiver);
+		if (requiredModuleSpecifier === null || !NODE_MODULE_SPECIFIERS.has(requiredModuleSpecifier) || !ts.isIdentifier(createRequireReceiver.expression)) return false;
+		const requireIdentifier = createRequireReceiver.expression;
+		return !analysis.localBindings.has(requireIdentifier.text) && !getScopedConfigBinding(requireIdentifier).wasFound && !hasTopLevelValueBinding(analysis.sourceFile, requireIdentifier.text);
+	}
+	if (!ts.isIdentifier(createRequireReceiver)) return false;
+	if (analysis.localBindings.has(createRequireReceiver.text) || getScopedConfigBinding(createRequireReceiver).wasFound) return false;
+	const importBinding = getImportBinding(analysis.sourceFile, createRequireReceiver.text);
+	return Boolean(importBinding?.isNamespace && NODE_MODULE_SPECIFIERS.has(importBinding.moduleSpecifier));
+};
+const getNodeRequireResolveModuleSpecifier = (callExpression, analysis) => {
+	const [moduleSpecifierNode] = callExpression.arguments;
+	if (!moduleSpecifierNode || !ts.isStringLiteralLike(moduleSpecifierNode)) return null;
+	const target = callExpression.expression;
+	if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return null;
+	if ((ts.isPropertyAccessExpression(target) ? target.name.text : target.argumentExpression && ts.isStringLiteralLike(target.argumentExpression) ? target.argumentExpression.text : null) !== "resolve") return null;
+	if (isNodeCreateRequireCall(target.expression, analysis)) return moduleSpecifierNode.text;
+	if (!ts.isIdentifier(target.expression)) return null;
+	const resolverIdentifier = target.expression;
+	if (analysis.localBindings.has(resolverIdentifier.text)) return null;
+	const scopedBinding = getScopedConfigBinding(resolverIdentifier);
+	const topLevelBinding = scopedBinding.wasFound ? null : getTopLevelBinding(analysis.sourceFile, resolverIdentifier.text);
+	const resolverInitializer = scopedBinding.wasFound ? scopedBinding.initializer : topLevelBinding;
+	if (resolverInitializer === null && !scopedBinding.wasFound && resolverIdentifier.text === "require" && !hasTopLevelValueBinding(analysis.sourceFile, resolverIdentifier.text) && getImportBinding(analysis.sourceFile, resolverIdentifier.text) === null) return moduleSpecifierNode.text;
+	if (!resolverInitializer || !isConstantVariableInitializer(resolverInitializer) || !isNodeCreateRequireCall(resolverInitializer, analysis)) return null;
+	return moduleSpecifierNode.text;
+};
 const getAssignedPropertyInitializer = (identifier, propertyName) => {
 	let bindingScope = null;
 	let currentNode = identifier;
@@ -62444,9 +62519,11 @@ const getAssignedPropertyInitializer = (identifier, propertyName) => {
 		initializer: assignedInitializer
 	};
 };
-const getStaticConfigValueState = (expression, analysis) => {
-	let unwrappedExpression = expression;
-	while (ts.isParenthesizedExpression(unwrappedExpression) || ts.isAsExpression(unwrappedExpression) || ts.isTypeAssertionExpression(unwrappedExpression) || ts.isSatisfiesExpression(unwrappedExpression) || ts.isNonNullExpression(unwrappedExpression)) unwrappedExpression = unwrappedExpression.expression;
+const getStaticConfigValueState = (expression, analysis, visitedExpressions = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (visitedExpressions.has(unwrappedExpression)) return null;
+	const nextVisitedExpressions = new Set(visitedExpressions);
+	nextVisitedExpressions.add(unwrappedExpression);
 	if (unwrappedExpression.kind === ts.SyntaxKind.NullKeyword || ts.isIdentifier(unwrappedExpression) && unwrappedExpression.text === "undefined") return {
 		isNullish: true,
 		isTruthy: false
@@ -62462,31 +62539,31 @@ const getStaticConfigValueState = (expression, analysis) => {
 	if (ts.isIdentifier(unwrappedExpression)) {
 		if (analysis.localBindings.has(unwrappedExpression.text)) {
 			const localInitializer = analysis.localBindings.get(unwrappedExpression.text);
-			return localInitializer ? getStaticConfigValueState(localInitializer, analysis) : null;
+			return localInitializer ? getStaticConfigValueState(localInitializer, analysis, nextVisitedExpressions) : null;
 		}
 		const topLevelBinding = getTopLevelBinding(analysis.sourceFile, unwrappedExpression.text);
-		return topLevelBinding && ts.isExpression(topLevelBinding) ? getStaticConfigValueState(topLevelBinding, analysis) : null;
+		return topLevelBinding && ts.isExpression(topLevelBinding) ? getStaticConfigValueState(topLevelBinding, analysis, nextVisitedExpressions) : null;
 	}
 	if (ts.isConditionalExpression(unwrappedExpression)) {
-		const conditionState = getStaticConfigValueState(unwrappedExpression.condition, analysis);
-		if (conditionState !== null) return getStaticConfigValueState(conditionState.isTruthy ? unwrappedExpression.whenTrue : unwrappedExpression.whenFalse, analysis);
-		const whenTrueState = getStaticConfigValueState(unwrappedExpression.whenTrue, analysis);
-		const whenFalseState = getStaticConfigValueState(unwrappedExpression.whenFalse, analysis);
+		const conditionState = getStaticConfigValueState(unwrappedExpression.condition, analysis, nextVisitedExpressions);
+		if (conditionState !== null) return getStaticConfigValueState(conditionState.isTruthy ? unwrappedExpression.whenTrue : unwrappedExpression.whenFalse, analysis, nextVisitedExpressions);
+		const whenTrueState = getStaticConfigValueState(unwrappedExpression.whenTrue, analysis, nextVisitedExpressions);
+		const whenFalseState = getStaticConfigValueState(unwrappedExpression.whenFalse, analysis, nextVisitedExpressions);
 		return whenTrueState !== null && whenFalseState !== null && whenTrueState.isNullish === whenFalseState.isNullish && whenTrueState.isTruthy === whenFalseState.isTruthy ? whenTrueState : null;
 	}
 	if (ts.isBinaryExpression(unwrappedExpression)) {
-		const leftState = getStaticConfigValueState(unwrappedExpression.left, analysis);
+		const leftState = getStaticConfigValueState(unwrappedExpression.left, analysis, nextVisitedExpressions);
 		if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
 			if (leftState === null) return null;
-			return leftState.isTruthy ? getStaticConfigValueState(unwrappedExpression.right, analysis) : leftState;
+			return leftState.isTruthy ? getStaticConfigValueState(unwrappedExpression.right, analysis, nextVisitedExpressions) : leftState;
 		}
 		if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
 			if (leftState === null) return null;
-			return leftState.isTruthy ? leftState : getStaticConfigValueState(unwrappedExpression.right, analysis);
+			return leftState.isTruthy ? leftState : getStaticConfigValueState(unwrappedExpression.right, analysis, nextVisitedExpressions);
 		}
 		if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
 			if (leftState === null) return null;
-			return leftState.isNullish ? getStaticConfigValueState(unwrappedExpression.right, analysis) : leftState;
+			return leftState.isNullish ? getStaticConfigValueState(unwrappedExpression.right, analysis, nextVisitedExpressions) : leftState;
 		}
 	}
 	return null;
@@ -62495,25 +62572,27 @@ const isStaticallyDisabledConfigExpression = (expression, analysis) => getStatic
 const isStaticallyTruthyConfigExpression = (expression, analysis) => getStaticConfigValueState(expression, analysis)?.isTruthy === true;
 const isStaticallyNullishConfigExpression = (expression, analysis) => getStaticConfigValueState(expression, analysis)?.isNullish === true;
 const isStaticallyNonNullishConfigExpression = (expression, analysis) => getStaticConfigValueState(expression, analysis)?.isNullish === false;
-const getReactCompilerFlagState = (expression, analysis) => {
-	let unwrappedExpression = expression;
-	while (ts.isParenthesizedExpression(unwrappedExpression) || ts.isAsExpression(unwrappedExpression) || ts.isTypeAssertionExpression(unwrappedExpression) || ts.isSatisfiesExpression(unwrappedExpression) || ts.isNonNullExpression(unwrappedExpression)) unwrappedExpression = unwrappedExpression.expression;
+const getReactCompilerFlagState = (expression, analysis, visitedExpressions = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (visitedExpressions.has(unwrappedExpression)) return null;
+	const nextVisitedExpressions = new Set(visitedExpressions);
+	nextVisitedExpressions.add(unwrappedExpression);
 	if (ts.isIdentifier(unwrappedExpression)) {
 		const assignedBinding = getAssignedPropertyInitializer(unwrappedExpression, "reactCompiler");
 		if (assignedBinding.wasFound && assignedBinding.initializer) return { isEnabled: !isStaticallyDisabledConfigExpression(assignedBinding.initializer, analysis) };
 		if (analysis.localBindings.has(unwrappedExpression.text)) {
 			const localInitializer = analysis.localBindings.get(unwrappedExpression.text);
-			return localInitializer ? getReactCompilerFlagState(localInitializer, analysis) : null;
+			return localInitializer ? getReactCompilerFlagState(localInitializer, analysis, nextVisitedExpressions) : null;
 		}
 		const topLevelBinding = getTopLevelBinding(analysis.sourceFile, unwrappedExpression.text);
-		return topLevelBinding && ts.isExpression(topLevelBinding) ? getReactCompilerFlagState(topLevelBinding, analysis) : null;
+		return topLevelBinding && ts.isExpression(topLevelBinding) ? getReactCompilerFlagState(topLevelBinding, analysis, nextVisitedExpressions) : null;
 	}
 	if (!ts.isObjectLiteralExpression(unwrappedExpression)) return null;
 	for (const property of [...unwrappedExpression.properties].reverse()) {
-		if (ts.isPropertyAssignment(property) && getStaticPropertyName$1(property.name) === "reactCompiler") return { isEnabled: !isStaticallyDisabledConfigExpression(property.initializer, analysis) };
+		if (ts.isPropertyAssignment(property) && getStaticPropertyName$2(property.name) === "reactCompiler") return { isEnabled: !isStaticallyDisabledConfigExpression(property.initializer, analysis) };
 		if (ts.isShorthandPropertyAssignment(property) && property.name.text === "reactCompiler") return { isEnabled: !isStaticallyDisabledConfigExpression(property.name, analysis) };
 		if (ts.isSpreadAssignment(property)) {
-			const spreadState = getReactCompilerFlagState(property.expression, analysis);
+			const spreadState = getReactCompilerFlagState(property.expression, analysis, nextVisitedExpressions);
 			if (spreadState) return spreadState;
 		}
 	}
@@ -62536,8 +62615,8 @@ const getSelectedObjectProperty = (expression, propertyName, analysis, visitedEx
 	}
 	if (!ts.isObjectLiteralExpression(resolvedExpression)) return null;
 	for (const property of [...resolvedExpression.properties].reverse()) {
-		if (ts.isPropertyAssignment(property) && getStaticPropertyName$1(property.name) === propertyName) return property.initializer;
-		if (ts.isMethodDeclaration(property) && getStaticPropertyName$1(property.name) === propertyName) return property;
+		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.isSpreadAssignment(property)) {
 			const spreadProperty = getSelectedObjectProperty(property.expression, propertyName, analysis, visitedExpressions);
@@ -62568,7 +62647,7 @@ const configExpressionMayDefineProperty = (expression, propertyName, analysis) =
 	return resolvedExpression.properties.some((property) => {
 		if (ts.isSpreadAssignment(property)) return configExpressionMayDefineProperty(property.expression, propertyName, analysis);
 		if (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property) || ts.isMethodDeclaration(property) || ts.isGetAccessorDeclaration(property) || ts.isSetAccessorDeclaration(property)) {
-			const staticPropertyName = getStaticPropertyName$1(property.name);
+			const staticPropertyName = getStaticPropertyName$2(property.name);
 			return staticPropertyName === null || staticPropertyName === propertyName;
 		}
 		return false;
@@ -62587,7 +62666,7 @@ const getExportedConfigNodes = (sourceFile, exportName) => {
 			continue;
 		}
 		if (ts.isExpressionStatement(statement) && isCommonJsConfigExportAssignment(statement.expression, sourceFile) && exportName !== "default" && ts.isObjectLiteralExpression(statement.expression.right)) for (const property of [...statement.expression.right.properties].reverse()) {
-			if (ts.isPropertyAssignment(property) && getStaticPropertyName$1(property.name) === exportName) {
+			if (ts.isPropertyAssignment(property) && getStaticPropertyName$2(property.name) === exportName) {
 				exportedNodes.push(property.initializer);
 				break;
 			}
@@ -62685,6 +62764,11 @@ const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, a
 	visitReturns(functionNode.body);
 	return hasCompiler;
 };
+const analyzeImportedConfig = ({ analysis, moduleSpecifier, exportName, allowCompilerTransform, argumentsList }) => {
+	const importedFilePath = resolveImportedConfigFile(analysis.filePath, moduleSpecifier);
+	if (!importedFilePath) return null;
+	return analyzeConfigModuleExport(importedFilePath, exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, argumentsList);
+};
 const analyzeConfigIdentifier = (identifier, analysis, allowCompilerTransform, isCompilerTransformCollection, excludedPropertyNames) => {
 	const assignedReactCompiler = getAssignedPropertyInitializer(identifier, "reactCompiler");
 	if (assignedReactCompiler.initializer && !isStaticallyDisabledConfigExpression(assignedReactCompiler.initializer, analysis)) return true;
@@ -62705,30 +62789,62 @@ const analyzeConfigIdentifier = (identifier, analysis, allowCompilerTransform, i
 	const importBinding = getImportBinding(analysis.sourceFile, identifier.text);
 	if (importBinding) {
 		if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, importBinding.exportName)) return true;
-		if (!importBinding.moduleSpecifier.startsWith(".")) return false;
-		const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, importBinding.exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules));
+		return Boolean(analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: importBinding.moduleSpecifier,
+			exportName: importBinding.exportName,
+			allowCompilerTransform
+		}));
 	}
 	const topLevelBinding = getTopLevelBinding(analysis.sourceFile, identifier.text);
 	return Boolean(topLevelBinding && analyzeConfigNode(topLevelBinding, analysis, allowCompilerTransform, isCompilerTransformCollection, overriddenPropertyNames));
 };
 const analyzeConfigCallTarget = (callExpression, analysis, allowCompilerTransform) => {
 	const target = callExpression.expression;
+	const callableRequiredModuleSpecifier = getRequireModuleSpecifier$1(target);
+	if (callableRequiredModuleSpecifier !== null) {
+		if (ts.isCallExpression(target) && ts.isIdentifier(target.expression) && (analysis.localBindings.has(target.expression.text) || getScopedConfigBinding(target.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
+		if (allowCompilerTransform && isCompilerTransformModule(callableRequiredModuleSpecifier, "default")) return true;
+		const hasCompilerTransform = analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: callableRequiredModuleSpecifier,
+			exportName: "default",
+			allowCompilerTransform,
+			argumentsList: callExpression.arguments
+		});
+		if (isLocalModuleSpecifier(callableRequiredModuleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+		return null;
+	}
 	if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return null;
 	const propertyName = ts.isPropertyAccessExpression(target) ? target.name.text : target.argumentExpression && ts.isStringLiteralLike(target.argumentExpression) ? target.argumentExpression.text : null;
 	if (propertyName === null) return null;
-	const requiredModuleSpecifier = getRequireModuleSpecifier(target.expression);
+	const requiredModuleSpecifier = getRequireModuleSpecifier$1(target.expression);
 	if (requiredModuleSpecifier !== null) {
-		if (ts.isCallExpression(target.expression) && ts.isIdentifier(target.expression.expression) && (getScopedConfigBinding(target.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
-		if (!requiredModuleSpecifier.startsWith(".")) return null;
-		const importedFilePath = resolveImportedConfigFile(analysis.filePath, requiredModuleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, propertyName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, callExpression.arguments));
+		if (ts.isCallExpression(target.expression) && ts.isIdentifier(target.expression.expression) && (analysis.localBindings.has(target.expression.expression.text) || getScopedConfigBinding(target.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
+		if (allowCompilerTransform && isCompilerTransformModule(requiredModuleSpecifier, propertyName)) return true;
+		const hasCompilerTransform = analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: requiredModuleSpecifier,
+			exportName: propertyName,
+			allowCompilerTransform,
+			argumentsList: callExpression.arguments
+		});
+		if (isLocalModuleSpecifier(requiredModuleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+		return null;
 	}
 	if (!ts.isIdentifier(target.expression)) return null;
-	const importBinding = getImportBinding(analysis.sourceFile, target.expression.text);
-	if (importBinding?.isNamespace && importBinding.moduleSpecifier.startsWith(".")) {
-		const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, propertyName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, callExpression.arguments));
+	const importBinding = analysis.localBindings.has(target.expression.text) || getScopedConfigBinding(target.expression).wasFound ? null : getImportBinding(analysis.sourceFile, target.expression.text);
+	if (importBinding?.isNamespace) {
+		if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, propertyName)) return true;
+		const hasCompilerTransform = analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: importBinding.moduleSpecifier,
+			exportName: propertyName,
+			allowCompilerTransform,
+			argumentsList: callExpression.arguments
+		});
+		if (isLocalModuleSpecifier(importBinding.moduleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+		return null;
 	}
 	const selectedProperty = getSelectedObjectProperty(target.expression, propertyName, analysis);
 	if (selectedProperty === null) return null;
@@ -62746,25 +62862,29 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		const reactCompilerFlagState = excludedPropertyNames?.has("reactCompiler") ? null : getReactCompilerFlagState(node, analysis);
 		if (reactCompilerFlagState?.isEnabled) return true;
 		for (const [propertyIndex, property] of node.properties.entries()) if (ts.isPropertyAssignment(property)) {
-			const propertyName = getStaticPropertyName$1(property.name);
+			const propertyName = getStaticPropertyName$2(property.name);
 			if (propertyName && excludedPropertyNames?.has(propertyName)) continue;
 			if (propertyName === "reactCompiler") continue;
-			if ((propertyName === "plugins" || propertyName === "presets") && node.properties.slice(propertyIndex + 1).some((laterProperty) => ts.isSpreadAssignment(laterProperty) && configExpressionMayDefineProperty(laterProperty.expression, propertyName, analysis) || (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && getStaticPropertyName$1(laterProperty.name) === propertyName)) continue;
+			if ((propertyName === "plugins" || propertyName === "presets") && node.properties.slice(propertyIndex + 1).some((laterProperty) => ts.isSpreadAssignment(laterProperty) && configExpressionMayDefineProperty(laterProperty.expression, propertyName, analysis) || (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && getStaticPropertyName$2(laterProperty.name) === propertyName)) continue;
 			const propertyAllowsCompilerTransform = propertyName === "plugins" || propertyName === "presets";
-			if (propertyName === "extends" && ts.isStringLiteralLike(property.initializer) && property.initializer.text.startsWith(".")) {
-				const extendedFilePath = resolveImportedConfigFile(analysis.filePath, property.initializer.text);
-				if (extendedFilePath && analyzeConfigModuleExport(extendedFilePath, "default", false, analysis.importDepth + 1, analysis.visitedModules)) return true;
+			if (propertyName === "extends" && ts.isStringLiteralLike(property.initializer)) {
+				if (analyzeImportedConfig({
+					analysis,
+					moduleSpecifier: property.initializer.text,
+					exportName: "default",
+					allowCompilerTransform: false
+				})) return true;
 			}
 			if (analyzeConfigNode(property.initializer, analysis, propertyAllowsCompilerTransform, propertyAllowsCompilerTransform)) return true;
 		} else if (ts.isShorthandPropertyAssignment(property)) {
 			if (excludedPropertyNames?.has(property.name.text)) continue;
 			if (property.name.text === "reactCompiler") continue;
-			if ((property.name.text === "plugins" || property.name.text === "presets") && node.properties.slice(propertyIndex + 1).some((laterProperty) => ts.isSpreadAssignment(laterProperty) && configExpressionMayDefineProperty(laterProperty.expression, property.name.text, analysis) || (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && getStaticPropertyName$1(laterProperty.name) === property.name.text)) continue;
+			if ((property.name.text === "plugins" || property.name.text === "presets") && node.properties.slice(propertyIndex + 1).some((laterProperty) => ts.isSpreadAssignment(laterProperty) && configExpressionMayDefineProperty(laterProperty.expression, property.name.text, analysis) || (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && getStaticPropertyName$2(laterProperty.name) === property.name.text)) continue;
 			const propertyAllowsCompilerTransform = property.name.text === "plugins" || property.name.text === "presets";
 			if (analyzeConfigNode(property.name, analysis, propertyAllowsCompilerTransform, propertyAllowsCompilerTransform)) return true;
 		} else if (ts.isSpreadAssignment(property)) {
 			if (reactCompilerFlagState && getReactCompilerFlagState(property.expression, analysis) !== null) continue;
-			if (node.properties.slice(propertyIndex + 1).some((laterProperty) => (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && (getStaticPropertyName$1(laterProperty.name) === "plugins" || getStaticPropertyName$1(laterProperty.name) === "presets"))) continue;
+			if (node.properties.slice(propertyIndex + 1).some((laterProperty) => (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && (getStaticPropertyName$2(laterProperty.name) === "plugins" || getStaticPropertyName$2(laterProperty.name) === "presets"))) continue;
 			if (analyzeConfigNode(property.expression, analysis, allowCompilerTransform, false, excludedPropertyNames)) return true;
 		}
 		return false;
@@ -62777,23 +62897,36 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		});
 	}
 	if (ts.isCallExpression(node)) {
+		const resolvedModuleSpecifier = getNodeRequireResolveModuleSpecifier(node, analysis);
+		if (resolvedModuleSpecifier !== null) return allowCompilerTransform && isCompilerTransformModule(resolvedModuleSpecifier, "default");
 		const callTargetResult = analyzeConfigCallTarget(node, analysis, allowCompilerTransform);
 		if (callTargetResult !== null) return callTargetResult;
-		const directModuleSpecifier = getRequireModuleSpecifier(node);
+		const directModuleSpecifier = getRequireModuleSpecifier$1(node);
 		const isRequireShadowed = analysis.localBindings.has("require") || ts.isIdentifier(node.expression) && getScopedConfigBinding(node.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require");
 		if (directModuleSpecifier && isRequireShadowed) return analyzeConfigNode(node.expression, analysis, allowCompilerTransform);
 		if (directModuleSpecifier && !isRequireShadowed) {
 			if (allowCompilerTransform && isCompilerTransformModule(directModuleSpecifier, "default")) return true;
-			if (directModuleSpecifier.startsWith(".")) {
-				const importedFilePath = resolveImportedConfigFile(analysis.filePath, directModuleSpecifier);
-				if (importedFilePath && analyzeConfigModuleExport(importedFilePath, "default", allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules)) return true;
-			}
+			if (analyzeImportedConfig({
+				analysis,
+				moduleSpecifier: directModuleSpecifier,
+				exportName: "default",
+				allowCompilerTransform
+			})) return true;
 		}
 		if (ts.isIdentifier(node.expression)) {
-			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
-			if (importBinding?.moduleSpecifier.startsWith(".")) {
-				const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-				return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, importBinding.exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, node.arguments));
+			if (!analysis.localBindings.has(node.expression.text) && !getScopedConfigBinding(node.expression).wasFound) {
+				const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
+				if (importBinding) {
+					if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, importBinding.exportName)) return true;
+					const hasCompilerTransform = analyzeImportedConfig({
+						analysis,
+						moduleSpecifier: importBinding.moduleSpecifier,
+						exportName: importBinding.exportName,
+						allowCompilerTransform,
+						argumentsList: node.arguments
+					});
+					if (isLocalModuleSpecifier(importBinding.moduleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+				}
 			}
 			const topLevelBinding = getTopLevelBinding(analysis.sourceFile, node.expression.text);
 			if (topLevelBinding && ts.isFunctionLike(topLevelBinding) && analyzeConfigFunction(topLevelBinding, analysis, allowCompilerTransform, node.arguments)) return true;
@@ -62801,27 +62934,31 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		return analyzeConfigNode(node.expression, analysis, allowCompilerTransform) || node.arguments.some((argument) => analyzeConfigNode(argument, analysis, false));
 	}
 	if (ts.isPropertyAccessExpression(node)) {
-		const requiredModuleSpecifier = getRequireModuleSpecifier(node.expression);
+		const requiredModuleSpecifier = getRequireModuleSpecifier$1(node.expression);
 		if (requiredModuleSpecifier) {
-			if (ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression) && (getScopedConfigBinding(node.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
-			if (requiredModuleSpecifier.startsWith(".")) {
-				const importedFilePath = resolveImportedConfigFile(analysis.filePath, requiredModuleSpecifier);
-				return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, node.name.text, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules));
-			}
+			if (ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression) && (analysis.localBindings.has(node.expression.expression.text) || getScopedConfigBinding(node.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
+			if (analyzeImportedConfig({
+				analysis,
+				moduleSpecifier: requiredModuleSpecifier,
+				exportName: node.name.text,
+				allowCompilerTransform
+			})) return true;
 			return allowCompilerTransform && isCompilerTransformModule(requiredModuleSpecifier, node.name.text);
 		}
 		if (ts.isIdentifier(node.expression)) {
-			if (analysis.localBindings.has(node.expression.text)) {
-				const localInitializer = analysis.localBindings.get(node.expression.text);
-				return Boolean(localInitializer && analyzeConfigNode(localInitializer, analysis, allowCompilerTransform));
+			if (analysis.localBindings.has(node.expression.text) || getScopedConfigBinding(node.expression).wasFound) {
+				const selectedProperty = getSelectedObjectProperty(node.expression, node.name.text, analysis);
+				return Boolean(selectedProperty && analyzeConfigNode(selectedProperty, analysis, allowCompilerTransform));
 			}
 			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
 			if (importBinding?.isNamespace) {
 				if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, node.name.text)) return true;
-				if (importBinding.moduleSpecifier.startsWith(".")) {
-					const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-					if (importedFilePath && analyzeConfigModuleExport(importedFilePath, node.name.text, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules)) return true;
-				}
+				if (analyzeImportedConfig({
+					analysis,
+					moduleSpecifier: importBinding.moduleSpecifier,
+					exportName: node.name.text,
+					allowCompilerTransform
+				})) return true;
 				return false;
 			}
 			const selectedProperty = getSelectedObjectProperty(node.expression, node.name.text, analysis);
@@ -62832,13 +62969,19 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 	}
 	if (ts.isElementAccessExpression(node) && node.argumentExpression && ts.isStringLiteralLike(node.argumentExpression)) {
 		if (ts.isIdentifier(node.expression)) {
+			if (analysis.localBindings.has(node.expression.text) || getScopedConfigBinding(node.expression).wasFound) {
+				const selectedProperty = getSelectedObjectProperty(node.expression, node.argumentExpression.text, analysis);
+				return Boolean(selectedProperty && analyzeConfigNode(selectedProperty, analysis, allowCompilerTransform));
+			}
 			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
 			if (importBinding?.isNamespace) {
 				if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, node.argumentExpression.text)) return true;
-				if (importBinding.moduleSpecifier.startsWith(".")) {
-					const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-					return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, node.argumentExpression.text, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules));
-				}
+				return Boolean(analyzeImportedConfig({
+					analysis,
+					moduleSpecifier: importBinding.moduleSpecifier,
+					exportName: node.argumentExpression.text,
+					allowCompilerTransform
+				}));
 			}
 			const selectedProperty = getSelectedObjectProperty(node.expression, node.argumentExpression.text, analysis);
 			if (selectedProperty) return analyzeConfigNode(selectedProperty, analysis, allowCompilerTransform);
@@ -62876,14 +63019,19 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 };
 const hasCompilerInConfigFile = (filePath) => analyzeConfigModuleExport(filePath, "default", false, 0, /* @__PURE__ */ new Set());
 const hasCompilerInConfigFiles = (directory, filenames) => filenames.some((filename) => hasCompilerInConfigFile(Path.join(directory, filename)));
-const hasCompilerInPackageJsonConfig = (packageJson) => isPlainObject(packageJson.babel) && analyzeConfigSourceFileExport(ts.parseJsonText("package.json", JSON.stringify(packageJson.babel)), "package.json#babel", "default", false, 0, /* @__PURE__ */ new Set());
-const hasCompilerConfiguration = (directory, packageJson) => hasCompilerInPackageJsonConfig(packageJson) || hasCompilerInConfigFiles(directory, REACT_COMPILER_CONFIG_FILENAMES);
+const hasCompilerInPackageJsonConfig = (directory, packageJson) => {
+	if (!isPlainObject(packageJson.babel)) return false;
+	const packageJsonPath = Path.join(directory, "package.json");
+	return analyzeConfigSourceFileExport(ts.parseJsonText(packageJsonPath, JSON.stringify(packageJson.babel)), packageJsonPath, "default", false, 0, /* @__PURE__ */ new Set());
+};
+const hasCompilerConfiguration = (directory, packageJson) => hasCompilerInPackageJsonConfig(directory, packageJson) || hasCompilerInConfigFiles(directory, REACT_COMPILER_CONFIG_FILENAMES);
 const hasCompilerConfigurationInAncestors = (directory) => {
 	if (isProjectBoundary(directory)) return false;
 	let ancestorDirectory = Path.dirname(directory);
 	while (ancestorDirectory !== Path.dirname(ancestorDirectory)) {
 		const ancestorPackagePath = Path.join(ancestorDirectory, "package.json");
-		if (hasCompilerInPackageJsonConfig(isFile(ancestorPackagePath) ? readPackageJson(ancestorPackagePath) : {}) || hasCompilerInConfigFiles(ancestorDirectory, BABEL_CONFIG_FILENAMES)) return true;
+		const ancestorPackageJson = isFile(ancestorPackagePath) ? readPackageJson(ancestorPackagePath) : {};
+		if (hasCompilerInPackageJsonConfig(ancestorDirectory, ancestorPackageJson) || hasCompilerInConfigFiles(ancestorDirectory, BABEL_CONFIG_FILENAMES)) return true;
 		if (isProjectBoundary(ancestorDirectory)) return false;
 		ancestorDirectory = Path.dirname(ancestorDirectory);
 	}
@@ -66138,7 +66286,7 @@ const warn = (message) => {
 	runSync(warn$1(message));
 };
 const CONFIG_BASENAME = "doctor.config";
-const CONFIG_EXTENSIONS = [
+const CONFIG_EXTENSIONS$1 = [
 	"ts",
 	"mts",
 	"cts",
@@ -66242,7 +66390,7 @@ const loadLegacyConfig = (directory) => {
 };
 const loadConfigFromDirectory = async (directory) => {
 	let sawBrokenConfigFile = false;
-	for (const extension of CONFIG_EXTENSIONS) {
+	for (const extension of CONFIG_EXTENSIONS$1) {
 		const filePath = Path.join(directory, `${CONFIG_BASENAME}.${extension}`);
 		if (!isFile(filePath)) continue;
 		const isDataFile = DATA_CONFIG_EXTENSIONS.has(extension);
@@ -66977,6 +67125,316 @@ const buildReactNativeDiagnostic = (input) => ({
 	column: input.column ?? 0,
 	category: input.category ?? "Correctness"
 });
+const ANDROID_APP_BUILD_FILE_NAMES = ["build.gradle", "build.gradle.kts"];
+const BUILD_TYPES_BLOCK_PATTERN = /\bbuildTypes\s*\{/g;
+const RELEASE_STRING_MARKER = "__RD_RELEASE__";
+const RELEASE_BLOCK_PATTERNS = [/\brelease\s*\{/g, /\b(?:getByName|named)\s*\(\s*(?:["']release["']|__RD_RELEASE__)\s*\)\s*\{/g];
+const MINIFY_ASSIGNMENT_PATTERN = /\b(?:isMinifyEnabled|minifyEnabled)\b\s*(?:\(\s*|=\s*|\s+)([^;}\r\n]+)/g;
+const SHRINK_RESOURCES_ASSIGNMENT_PATTERN = /\b(?:isShrinkResources|shrinkResources)\b\s*(?:\(\s*|=\s*|\s+)([^;}\r\n]+)/g;
+const stripGradleComments = (contents) => {
+	let result = "";
+	let index = 0;
+	let quote = null;
+	while (index < contents.length) {
+		const character = contents[index];
+		const nextCharacter = contents[index + 1];
+		if (quote !== null) {
+			result += character;
+			if (character === "\\") {
+				result += nextCharacter ?? "";
+				index += 2;
+				continue;
+			}
+			if (character === quote) quote = null;
+			index += 1;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			result += character;
+			index += 1;
+			continue;
+		}
+		if (character === "/" && nextCharacter === "/") {
+			while (index < contents.length && contents[index] !== "\n") {
+				result += " ";
+				index += 1;
+			}
+			continue;
+		}
+		if (character === "/" && nextCharacter === "*") {
+			result += "  ";
+			index += 2;
+			while (index < contents.length && !(contents[index] === "*" && contents[index + 1] === "/")) {
+				result += contents[index] === "\n" ? "\n" : " ";
+				index += 1;
+			}
+			if (index < contents.length) {
+				result += "  ";
+				index += 2;
+			}
+			continue;
+		}
+		result += character;
+		index += 1;
+	}
+	return result;
+};
+const maskGradleStrings = (contents) => {
+	let result = "";
+	let index = 0;
+	let quote = null;
+	while (index < contents.length) {
+		const character = contents[index];
+		if (quote === null) {
+			if (character === "\"" || character === "'") {
+				quote = character;
+				result += " ";
+			} else result += character;
+			index += 1;
+			continue;
+		}
+		if (character === "\\") {
+			result += "  ";
+			index += 2;
+			continue;
+		}
+		if (character === quote) quote = null;
+		result += character === "\n" ? "\n" : " ";
+		index += 1;
+	}
+	return result;
+};
+const findBlockContents = (contents, pattern) => {
+	const blocks = [];
+	pattern.lastIndex = 0;
+	let match = pattern.exec(contents);
+	while (match !== null) {
+		const openingBraceIndex = pattern.lastIndex - 1;
+		let depth = 1;
+		let index = openingBraceIndex + 1;
+		let quote = null;
+		while (index < contents.length && depth > 0) {
+			const character = contents[index];
+			if (quote !== null) {
+				if (character === "\\") {
+					index += 2;
+					continue;
+				}
+				if (character === quote) quote = null;
+			} else if (character === "\"" || character === "'") quote = character;
+			else if (character === "{") depth += 1;
+			else if (character === "}") depth -= 1;
+			index += 1;
+		}
+		if (depth === 0) blocks.push(contents.slice(openingBraceIndex + 1, index - 1));
+		match = pattern.exec(contents);
+	}
+	return blocks;
+};
+const getFinalStaticBoolean = (contents, pattern) => {
+	pattern.lastIndex = 0;
+	let finalValue = null;
+	let match = pattern.exec(contents);
+	while (match !== null) {
+		const staticValue = match[1]?.trim().replace(/\)$/, "").trim();
+		if (staticValue === "true") finalValue = true;
+		else if (staticValue === "false") finalValue = false;
+		else finalValue = null;
+		match = pattern.exec(contents);
+	}
+	return finalValue;
+};
+const getReleaseBlocks = (contents) => findBlockContents(contents, BUILD_TYPES_BLOCK_PATTERN).flatMap((buildTypesBlock) => RELEASE_BLOCK_PATTERNS.flatMap((pattern) => findBlockContents(buildTypesBlock, pattern)));
+const readAndroidReleaseShrinking = (rootDirectory) => {
+	for (const buildFileName of ANDROID_APP_BUILD_FILE_NAMES) {
+		const filePath = Path.posix.join("android", "app", buildFileName);
+		const absoluteFilePath = Path.join(rootDirectory, filePath);
+		if (!isFile(absoluteFilePath)) continue;
+		let contents;
+		try {
+			contents = stripGradleComments(NFS.readFileSync(absoluteFilePath, "utf-8"));
+		} catch {
+			return null;
+		}
+		const releaseBlocks = getReleaseBlocks(maskGradleStrings(contents.replace(/(["'])release\1/g, RELEASE_STRING_MARKER)));
+		const [releaseBlock] = releaseBlocks;
+		if (releaseBlock === void 0 || releaseBlocks.length !== 1) return null;
+		const hasDisabledMinification = getFinalStaticBoolean(releaseBlock, MINIFY_ASSIGNMENT_PATTERN) === false;
+		const hasDisabledResourceShrinking = getFinalStaticBoolean(releaseBlock, SHRINK_RESOURCES_ASSIGNMENT_PATTERN) === false;
+		if (!hasDisabledMinification && !hasDisabledResourceShrinking) return null;
+		return {
+			filePath,
+			hasDisabledMinification,
+			hasDisabledResourceShrinking
+		};
+	}
+	return null;
+};
+const checkReactNativeAndroidReleaseShrinking = (rootDirectory) => {
+	const releaseShrinking = readAndroidReleaseShrinking(rootDirectory);
+	if (releaseShrinking === null) return [];
+	const disabledFeatures = [releaseShrinking.hasDisabledMinification ? "code minification" : null, releaseShrinking.hasDisabledResourceShrinking ? "resource shrinking" : null].filter((feature) => feature !== null);
+	return [buildReactNativeDiagnostic({
+		filePath: releaseShrinking.filePath,
+		rule: "rn-android-release-shrinking-disabled",
+		category: "Performance",
+		message: `The Android release build explicitly disables ${disabledFeatures.join(" and ")}, leaving unreachable code or resources in the shipped app.`,
+		help: "Enable release code minification and resource shrinking, then test the optimized build and add keep rules for libraries that require them."
+	})];
+};
+const getTypescriptScriptKind = (fileName) => {
+	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (fileName.endsWith(".ts")) return ts.ScriptKind.TS;
+	return ts.ScriptKind.JS;
+};
+const BABEL_CONFIG_FILE_NAMES$1 = [
+	"babel.config.js",
+	"babel.config.cjs",
+	"babel.config.mjs",
+	"babel.config.ts",
+	"babel.config.cts",
+	"babel.config.json",
+	".babelrc",
+	".babelrc.js",
+	".babelrc.cjs",
+	".babelrc.mjs",
+	".babelrc.cts",
+	".babelrc.json"
+];
+const readUnknownPluginNames = (value) => {
+	if (!Array.isArray(value)) return null;
+	const pluginNames = [];
+	for (const entry of value) {
+		if (typeof entry === "string") {
+			pluginNames.push(entry);
+			continue;
+		}
+		if (Array.isArray(entry) && typeof entry[0] === "string") {
+			pluginNames.push(entry[0]);
+			continue;
+		}
+		return null;
+	}
+	return pluginNames;
+};
+const getStaticPropertyName$1 = (propertyName) => {
+	if (ts.isIdentifier(propertyName) || ts.isStringLiteralLike(propertyName)) return propertyName.text;
+	return null;
+};
+const getStaticPluginName = (expression) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (ts.isStringLiteralLike(unwrappedExpression)) return unwrappedExpression.text;
+	if (!ts.isArrayLiteralExpression(unwrappedExpression)) return null;
+	const pluginExpression = unwrappedExpression.elements[0];
+	return pluginExpression && ts.isStringLiteralLike(pluginExpression) ? pluginExpression.text : null;
+};
+const getPluginNamesFromObject = (objectExpression) => {
+	if (objectExpression.properties.some((property) => ts.isSpreadAssignment(property))) return null;
+	const pluginProperties = objectExpression.properties.filter((property) => ts.isPropertyAssignment(property) && getStaticPropertyName$1(property.name) === "plugins");
+	if (pluginProperties.length !== 1) return pluginProperties.length === 0 ? [] : null;
+	const pluginListExpression = unwrapTypescriptExpression(pluginProperties[0].initializer);
+	if (!ts.isArrayLiteralExpression(pluginListExpression)) return null;
+	const pluginNames = [];
+	for (const element of pluginListExpression.elements) {
+		if (ts.isSpreadElement(element)) return null;
+		const pluginName = getStaticPluginName(element);
+		if (pluginName === null) return null;
+		pluginNames.push(pluginName);
+	}
+	return pluginNames;
+};
+const isModuleExports = (expression) => ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "module" && expression.name.text === "exports" || ts.isElementAccessExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "module" && expression.argumentExpression !== void 0 && ts.isStringLiteralLike(expression.argumentExpression) && expression.argumentExpression.text === "exports";
+const getDirectExportedObject = (sourceFile) => {
+	const exportedExpressions = [];
+	for (const statement of sourceFile.statements) {
+		if (ts.isExportAssignment(statement)) {
+			exportedExpressions.push(statement.expression);
+			continue;
+		}
+		if (ts.isExpressionStatement(statement) && ts.isBinaryExpression(statement.expression) && statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken && isModuleExports(statement.expression.left)) exportedExpressions.push(statement.expression.right);
+	}
+	if (exportedExpressions.length !== 1) return null;
+	const exportedExpression = unwrapTypescriptExpression(exportedExpressions[0]);
+	return ts.isObjectLiteralExpression(exportedExpression) ? exportedExpression : null;
+};
+const parseConfigPluginNames = (filePath, contents) => {
+	try {
+		const parsedJson = JSON.parse(contents);
+		return isPlainObject(parsedJson) ? readUnknownPluginNames(parsedJson.plugins) : null;
+	} catch {
+		if (ts.transpileModule(contents, {
+			fileName: filePath,
+			reportDiagnostics: true,
+			compilerOptions: { allowJs: true }
+		}).diagnostics?.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)) return null;
+		const exportedObject = getDirectExportedObject(ts.createSourceFile(filePath, contents, ts.ScriptTarget.Latest, true, getTypescriptScriptKind(filePath)));
+		return exportedObject === null ? null : getPluginNamesFromObject(exportedObject);
+	}
+};
+const readStaticBabelPluginNames = (rootDirectory) => {
+	for (const fileName of BABEL_CONFIG_FILE_NAMES$1) {
+		const absoluteFilePath = Path.join(rootDirectory, fileName);
+		if (!isFile(absoluteFilePath)) continue;
+		try {
+			return {
+				filePath: fileName,
+				pluginNames: parseConfigPluginNames(fileName, NFS.readFileSync(absoluteFilePath, "utf-8"))
+			};
+		} catch {
+			return {
+				filePath: fileName,
+				pluginNames: null
+			};
+		}
+	}
+	const packageJson = readPackageJson(Path.join(rootDirectory, "package.json"));
+	if (!isPlainObject(packageJson.babel)) return null;
+	return {
+		filePath: "package.json",
+		pluginNames: readUnknownPluginNames(packageJson.babel.plugins)
+	};
+};
+const REACT_COMPILER_PLUGIN_NAMES = new Set(["babel-plugin-react-compiler", "react-compiler"]);
+const REANIMATED_PLUGIN_NAME = "react-native-reanimated/plugin";
+const WORKLETS_PLUGIN_NAME = "react-native-worklets/plugin";
+const checkReactCompilerPluginOrder = (filePath, pluginNames) => {
+	if (pluginNames.findIndex((pluginName) => REACT_COMPILER_PLUGIN_NAMES.has(pluginName)) <= 0) return [];
+	return [buildReactNativeDiagnostic({
+		filePath,
+		rule: "rn-react-compiler-plugin-first",
+		category: "Performance",
+		message: "The React Compiler Babel plugin is not first, so an earlier transform can change component or hook code before the compiler analyzes it.",
+		help: "Move `babel-plugin-react-compiler` to the first entry in the Babel `plugins` array."
+	})];
+};
+const checkReanimatedPluginOrder = (project, filePath, pluginNames) => {
+	const reanimatedMajorVersion = project.reanimatedVersion === null || project.reanimatedVersion === void 0 ? null : getLowestDependencyMajor(project.reanimatedVersion);
+	if (reanimatedMajorVersion === null || reanimatedMajorVersion < 4) return [];
+	const diagnostics = [];
+	if (pluginNames.includes(REANIMATED_PLUGIN_NAME)) diagnostics.push(buildReactNativeDiagnostic({
+		filePath,
+		rule: "rn-reanimated-worklets-plugin-last",
+		category: "Performance",
+		message: "This Reanimated 4 project still uses `react-native-reanimated/plugin`, which was renamed to the Worklets Babel plugin.",
+		help: "Replace it with `react-native-worklets/plugin` and keep that plugin last in the Babel `plugins` array."
+	}));
+	const workletsPluginIndex = pluginNames.lastIndexOf(WORKLETS_PLUGIN_NAME);
+	if (workletsPluginIndex !== -1 && workletsPluginIndex !== pluginNames.length - 1) diagnostics.push(buildReactNativeDiagnostic({
+		filePath,
+		rule: "rn-reanimated-worklets-plugin-last",
+		category: "Performance",
+		message: "`react-native-worklets/plugin` is not last in the Babel `plugins` array, so later transforms can prevent worklets from being compiled correctly.",
+		help: "Move `react-native-worklets/plugin` to the final entry in the Babel `plugins` array."
+	}));
+	return diagnostics;
+};
+const checkReactNativeBabelPluginOrder = (rootDirectory, project) => {
+	const babelPlugins = readStaticBabelPluginNames(rootDirectory);
+	if (babelPlugins === null || babelPlugins.pluginNames === null) return [];
+	return [...checkReactCompilerPluginOrder(babelPlugins.filePath, babelPlugins.pluginNames), ...checkReanimatedPluginOrder(project, babelPlugins.filePath, babelPlugins.pluginNames)];
+};
 const BUILDER_BOB_PACKAGE = "react-native-builder-bob";
 const isBuilderBobLibrary = (packageJson) => {
 	const bobConfig = packageJson[BUILDER_BOB_PACKAGE];
@@ -67053,7 +67511,12 @@ const checkReactNativeMetroBabelPreset = (rootDirectory) => {
 const isReactNativeProject = (project) => project.framework === "react-native" || project.framework === "expo" || project.hasReactNativeWorkspace || project.expoVersion !== null;
 const checkReactNativeProject = (rootDirectory, project) => {
 	if (!isReactNativeProject(project)) return [];
-	return [...checkReactNativeMetroBabelPreset(rootDirectory), ...checkReactNativeLibraryDependencies(rootDirectory)];
+	return [
+		...checkReactNativeMetroBabelPreset(rootDirectory),
+		...checkReactNativeBabelPluginOrder(rootDirectory, project),
+		...checkReactNativeAndroidReleaseShrinking(rootDirectory),
+		...checkReactNativeLibraryDependencies(rootDirectory)
+	];
 };
 const RULE_KEY = "no-vulnerable-react-server-components";
 const REACT_RSC_ADVISORIES_BY_MINOR = {
@@ -67204,17 +67667,6 @@ const checkReactServerComponentsAdvisory = (scanDirectory, project) => {
 	}
 	return diagnostics;
 };
-const getTypescriptScriptKind = (fileName) => {
-	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
-	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
-	if (fileName.endsWith(".ts")) return ts.ScriptKind.TS;
-	return ts.ScriptKind.JS;
-};
-const unwrapTypescriptExpression = (expression) => {
-	let currentExpression = expression;
-	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
-	return currentExpression;
-};
 const EMPTY_MOTION_EXPRESSION_EVIDENCE = {
 	isAnimationFunction: false,
 	isMotionComponent: false,
@@ -67770,7 +68222,11 @@ const buildCapabilities = (project) => {
 	capabilities.add(project.framework);
 	if (project.reactVersion !== null || project.preactVersion !== null) capabilities.add("react");
 	if (project.framework === "expo" || project.framework === "react-native" || project.hasReactNativeWorkspace) capabilities.add("react-native");
-	if (project.expoVersion !== null) capabilities.add("expo");
+	if (project.expoVersion !== null) {
+		capabilities.add("expo");
+		const expoSdkMajorVersion = getLowestDependencyMajor(project.expoVersion);
+		if (expoSdkMajorVersion !== null && expoSdkMajorVersion >= 54) capabilities.add("expo:54");
+	}
 	if ((project.framework === "nextjs" || project.framework === "tanstack-start" || project.framework === "remix") && !project.isStaticExport) capabilities.add("server-actions");
 	if (SSR_FRAMEWORKS.has(project.framework) || project.hasSsrDependency) capabilities.add("ssr");
 	if (CLIENT_ONLY_FRAMEWORKS.has(project.framework)) capabilities.add("client-only");
@@ -67834,6 +68290,11 @@ const buildCapabilities = (project) => {
 	if (project.zustandMajorVersion !== void 0 && project.zustandMajorVersion !== null && project.zustandMajorVersion >= 1 && project.zustandMajorVersion <= 5) addVersionCapabilityLadder(capabilities, "zustand", project.zustandMajorVersion, 1, 5);
 	if (project.isPreES2023Target) capabilities.add("pre-es2023");
 	if (project.hasReactCompiler) capabilities.add("react-compiler");
+	if (project.reanimatedVersion !== void 0 && project.reanimatedVersion !== null) {
+		capabilities.add("reanimated");
+		const reanimatedMajorVersion = getLowestDependencyMajor(project.reanimatedVersion);
+		if (reanimatedMajorVersion !== null && reanimatedMajorVersion >= 4) capabilities.add("reanimated:4");
+	}
 	if (Boolean(project.hasTanStackQuery) || Boolean(project.tanstackQueryVersion)) capabilities.add("tanstack-query");
 	if (project.styledComponentsVersion) {
 		capabilities.add("styled-components");
@@ -69731,7 +70192,11 @@ const neutralizeDisableDirectives = async (rootDirectory, includePaths) => {
 const ROOT_DIRECTORY_PLACEHOLDER = "<root>";
 const normalizeConfigForHash = (config) => {
 	const clone = JSON.parse(JSON.stringify(config));
-	if (clone?.settings?.["react-doctor"]) clone.settings["react-doctor"].rootDirectory = ROOT_DIRECTORY_PLACEHOLDER;
+	if (clone?.settings?.["react-doctor"]) {
+		const reactDoctorSettings = clone.settings["react-doctor"];
+		reactDoctorSettings.rootDirectory = ROOT_DIRECTORY_PLACEHOLDER;
+		if (Array.isArray(reactDoctorSettings.unpluginAutoImportRootDirectories)) reactDoctorSettings.unpluginAutoImportRootDirectories = [ROOT_DIRECTORY_PLACEHOLDER];
+	}
 	if (Array.isArray(clone?.jsPlugins)) clone.jsPlugins = clone.jsPlugins.map((_, index) => `<plugin:${index}>`);
 	return clone;
 };
@@ -69890,13 +70355,14 @@ const buildUserPluginRules = (userPlugin, severityControls) => {
 	}
 	return enabled;
 };
-const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, extendsPaths = [], ignoredTags = /* @__PURE__ */ new Set(), includedTags = /* @__PURE__ */ new Set(), includeTagDefaults = false, serverAuthFunctionNames, severityControls, userPlugins = [], disableReactHooksJsPlugin = false, ruleSelection, sidecarRuleIdFilter }) => {
+const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, extendsPaths = [], ignoredTags = /* @__PURE__ */ new Set(), includedTags = /* @__PURE__ */ new Set(), includeTagDefaults = false, runtimeGlobals, unpluginAutoImportGlobalScopes, serverAuthFunctionNames, severityControls, userPlugins = [], disableReactHooksJsPlugin = false, ruleSelection, sidecarRuleIdFilter }) => {
 	const hasIncludedTags = includedTags.size > 0;
 	const reactHooksJsPlugin = disableReactHooksJsPlugin || ruleSelection === "sidecar" || hasIncludedTags ? null : resolveReactHooksJsPlugin(project.hasReactCompiler || project.hasReactCompilerLintPlugin === true, customRulesOnly);
 	const reactCompilerRules = reactHooksJsPlugin ? applyRuleSeverityControls(filterRulesToAvailable(REACT_COMPILER_RULES, "react-hooks-js", reactHooksJsPlugin.availableRuleNames), severityControls) : {};
 	const jsPlugins = [];
 	if (reactHooksJsPlugin) jsPlugins.push(reactHooksJsPlugin.entry);
 	const capabilities = getCapabilities(project);
+	const settingsRootDirectory = resolveSettingsRootDirectory(project.rootDirectory);
 	const enabledReactDoctorRules = {};
 	for (const registryEntry of REACT_DOCTOR_RULES) {
 		const rule = reactDoctorPlugin.rules[registryEntry.id];
@@ -69942,8 +70408,16 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 		jsPlugins: [...jsPlugins, pluginPath],
 		settings: { "react-doctor": {
 			framework: project.framework,
-			rootDirectory: resolveSettingsRootDirectory(project.rootDirectory),
+			rootDirectory: settingsRootDirectory,
 			capabilities: [...capabilities].sort(),
+			...runtimeGlobals && runtimeGlobals.length > 0 ? { runtimeGlobals: [...runtimeGlobals] } : {},
+			...unpluginAutoImportGlobalScopes && unpluginAutoImportGlobalScopes.length > 0 ? {
+				unpluginAutoImportRootDirectories: [...new Set([settingsRootDirectory, project.rootDirectory])],
+				unpluginAutoImportGlobalScopes: unpluginAutoImportGlobalScopes.map((scope) => ({
+					directory: scope.directory,
+					names: [...scope.names]
+				}))
+			} : {},
 			...project.shopifyFlashListMajorVersion !== null ? { shopifyFlashListMajorVersion: project.shopifyFlashListMajorVersion } : {},
 			...serverAuthFunctionNames && serverAuthFunctionNames.length > 0 ? { serverAuthFunctionNames: [...serverAuthFunctionNames] } : {}
 		} },
@@ -69954,6 +70428,245 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 		}
 	};
 };
+const AUTO_IMPORT_ADAPTER_PATTERN = /^unplugin-auto-import\/(?:astro|esbuild|rollup|rolldown|rspack|vite|webpack)$/;
+const CONFIG_BASENAMES = [
+	"astro.config",
+	"esbuild.config",
+	"rollup.config",
+	"rolldown.config",
+	"rspack.config",
+	"vite.config",
+	"webpack.config"
+];
+const CONFIG_EXTENSIONS = [
+	".cjs",
+	".cts",
+	".js",
+	".mjs",
+	".mts",
+	".ts"
+];
+const CONFIG_FILENAMES = new Set(CONFIG_BASENAMES.flatMap((basename) => CONFIG_EXTENSIONS.map((extension) => `${basename}${extension}`)));
+const DEFAULT_ESLINT_GLOBALS_PATH = ".eslintrc-auto-import.json";
+const SUPPORTED_GLOBAL_VALUES = new Set([
+	true,
+	false,
+	"readable",
+	"readonly",
+	"writable",
+	"writeable"
+]);
+const getStaticProperty = (objectExpression, propertyName) => objectExpression.properties.find((property) => {
+	if (ts.isSpreadAssignment(property)) return false;
+	const name = ts.isComputedPropertyName(property.name) ? unwrapTypescriptExpression(property.name.expression) : property.name;
+	return (ts.isIdentifier(name) || ts.isStringLiteralLike(name)) && name.text === propertyName;
+}) ?? null;
+const hasNonLiteralComputedProperty = (objectExpression) => objectExpression.properties.some((property) => !ts.isSpreadAssignment(property) && ts.isComputedPropertyName(property.name) && !ts.isStringLiteralLike(unwrapTypescriptExpression(property.name.expression)));
+const getStaticPropertyAssignment = (objectExpression, propertyName) => {
+	const property = getStaticProperty(objectExpression, propertyName);
+	return property && ts.isPropertyAssignment(property) ? property : null;
+};
+const getRequireModuleSpecifier = (expression) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (ts.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === "default") return getRequireModuleSpecifier(unwrappedExpression.expression);
+	if (!ts.isCallExpression(unwrappedExpression) || !ts.isIdentifier(unwrappedExpression.expression) || unwrappedExpression.expression.text !== "require" || unwrappedExpression.arguments.length !== 1) return null;
+	const moduleSpecifier = unwrappedExpression.arguments[0];
+	return moduleSpecifier && ts.isStringLiteralLike(moduleSpecifier) ? moduleSpecifier.text : null;
+};
+const getRequiredPropertyModuleSpecifier = (expression, propertyName) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	return ts.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === propertyName ? getRequireModuleSpecifier(unwrappedExpression.expression) : null;
+};
+const isCommonJsExportAssignment = (node, sourceFile) => ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && (node.left.getText(sourceFile) === "module.exports" || node.left.getText(sourceFile) === "exports.default");
+const isTopLevelExpression = (node) => {
+	let ancestor = node.parent;
+	while (ancestor && !ts.isSourceFile(ancestor)) {
+		if (ts.isExpressionStatement(ancestor)) return ts.isSourceFile(ancestor.parent);
+		if (!ts.isParenthesizedExpression(ancestor) && !ts.isAsExpression(ancestor) && !ts.isSatisfiesExpression(ancestor) && !ts.isNonNullExpression(ancestor) && !ts.isTypeAssertionExpression(ancestor) && !ts.isAwaitExpression(ancestor)) return false;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isInsideActiveConfigProperty = (node, propertyName, sourceFile, esbuildBindings, esbuildNamespaceBindings) => {
+	let ancestor = node.parent;
+	let didFindConfigProperty = false;
+	while (ancestor && !ts.isSourceFile(ancestor)) {
+		if (!didFindConfigProperty && !ts.isArrayLiteralExpression(ancestor) && !ts.isParenthesizedExpression(ancestor) && !ts.isAsExpression(ancestor) && !ts.isSatisfiesExpression(ancestor) && !ts.isNonNullExpression(ancestor) && !ts.isTypeAssertionExpression(ancestor) && !ts.isPropertyAssignment(ancestor)) return false;
+		if (ts.isPropertyAssignment(ancestor)) {
+			const isConfigProperty = (ts.isIdentifier(ancestor.name) || ts.isStringLiteralLike(ancestor.name)) && ancestor.name.text === propertyName;
+			if (didFindConfigProperty || !isConfigProperty) return false;
+			if (!ts.isObjectLiteralExpression(ancestor.parent) || ancestor.parent.properties.some(ts.isSpreadAssignment)) return false;
+			didFindConfigProperty = true;
+			ancestor = ancestor.parent;
+			continue;
+		}
+		if (didFindConfigProperty) {
+			if (ts.isExportAssignment(ancestor)) return true;
+			if (isCommonJsExportAssignment(ancestor, sourceFile)) return isTopLevelExpression(ancestor);
+			if (propertyName === "plugins" && ts.isCallExpression(ancestor) && (ts.isIdentifier(ancestor.expression) ? esbuildBindings.has(ancestor.expression.text) : ts.isPropertyAccessExpression(ancestor.expression) && ancestor.expression.name.text === "build" && (ts.isIdentifier(ancestor.expression.expression) && esbuildNamespaceBindings.has(ancestor.expression.expression.text) || getRequireModuleSpecifier(ancestor.expression.expression) === "esbuild"))) return isTopLevelExpression(ancestor);
+			if (!(ts.isObjectLiteralExpression(ancestor) || ts.isParenthesizedExpression(ancestor) || ts.isAsExpression(ancestor) || ts.isSatisfiesExpression(ancestor) || ts.isNonNullExpression(ancestor) || ts.isTypeAssertionExpression(ancestor) || ts.isCallExpression(ancestor) && ts.isIdentifier(ancestor.expression) && ancestor.expression.text === "defineConfig")) return false;
+		}
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const getGlobalsPathFromActiveAutoImportCall = (callExpression, packageDirectory) => {
+	const optionsExpression = callExpression.arguments[0];
+	if (!optionsExpression) return null;
+	const unwrappedOptions = unwrapTypescriptExpression(optionsExpression);
+	if (!ts.isObjectLiteralExpression(unwrappedOptions)) return null;
+	if (unwrappedOptions.properties.some(ts.isSpreadAssignment) || hasNonLiteralComputedProperty(unwrappedOptions)) return null;
+	if (getStaticProperty(unwrappedOptions, "include") || getStaticProperty(unwrappedOptions, "exclude")) return null;
+	const eslintrcProperty = getStaticPropertyAssignment(unwrappedOptions, "eslintrc");
+	if (!eslintrcProperty) return null;
+	const eslintrcExpression = unwrapTypescriptExpression(eslintrcProperty.initializer);
+	if (!ts.isObjectLiteralExpression(eslintrcExpression)) return null;
+	if (eslintrcExpression.properties.some(ts.isSpreadAssignment) || hasNonLiteralComputedProperty(eslintrcExpression)) return null;
+	const enabledProperty = getStaticPropertyAssignment(eslintrcExpression, "enabled");
+	if (!enabledProperty || unwrapTypescriptExpression(enabledProperty.initializer).kind !== ts.SyntaxKind.TrueKeyword) return null;
+	const filepathProperty = getStaticProperty(eslintrcExpression, "filepath");
+	if (!filepathProperty) return Path.join(packageDirectory, DEFAULT_ESLINT_GLOBALS_PATH);
+	if (!ts.isPropertyAssignment(filepathProperty)) return null;
+	const filepathExpression = unwrapTypescriptExpression(filepathProperty.initializer);
+	return ts.isStringLiteralLike(filepathExpression) ? Path.resolve(packageDirectory, filepathExpression.text) : null;
+};
+const collectGlobalsPathsFromConfig = (configPath, packageDirectory) => {
+	let sourceText;
+	try {
+		sourceText = NFS.readFileSync(configPath, "utf8");
+	} catch {
+		return {
+			didFindActiveAutoImport: false,
+			globalsPaths: []
+		};
+	}
+	const sourceFile = ts.createSourceFile(configPath, sourceText, ts.ScriptTarget.Latest, true);
+	const autoImportBindings = /* @__PURE__ */ new Map();
+	const esbuildBindings = /* @__PURE__ */ new Set();
+	const esbuildNamespaceBindings = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (ts.isImportDeclaration(statement) && ts.isStringLiteralLike(statement.moduleSpecifier)) {
+			const moduleSpecifier = statement.moduleSpecifier.text;
+			if (AUTO_IMPORT_ADAPTER_PATTERN.test(moduleSpecifier)) {
+				const defaultBinding = statement.importClause?.name;
+				if (defaultBinding) autoImportBindings.set(defaultBinding.text, moduleSpecifier);
+			}
+			if (moduleSpecifier === "esbuild") {
+				const defaultBinding = statement.importClause?.name;
+				if (defaultBinding) esbuildNamespaceBindings.add(defaultBinding.text);
+				const namedBindings = statement.importClause?.namedBindings;
+				if (namedBindings && ts.isNamedImports(namedBindings)) {
+					for (const importSpecifier of namedBindings.elements) if ((importSpecifier.propertyName ?? importSpecifier.name).text === "build") esbuildBindings.add(importSpecifier.name.text);
+				}
+				if (namedBindings && ts.isNamespaceImport(namedBindings)) esbuildNamespaceBindings.add(namedBindings.name.text);
+			}
+		}
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) {
+			if (!declaration.initializer) continue;
+			const declarationName = ts.isIdentifier(declaration.name) ? declaration.name.text : null;
+			const moduleSpecifier = getRequireModuleSpecifier(declaration.initializer);
+			if (declarationName && moduleSpecifier && AUTO_IMPORT_ADAPTER_PATTERN.test(moduleSpecifier)) autoImportBindings.set(declarationName, moduleSpecifier);
+			if (moduleSpecifier === "esbuild") {
+				if (declarationName) esbuildNamespaceBindings.add(declarationName);
+				if (ts.isObjectBindingPattern(declaration.name)) for (const bindingElement of declaration.name.elements) {
+					const importedName = bindingElement.propertyName ?? bindingElement.name;
+					if (ts.isIdentifier(importedName) && importedName.text === "build" && ts.isIdentifier(bindingElement.name)) esbuildBindings.add(bindingElement.name.text);
+				}
+			}
+			if (declarationName && getRequiredPropertyModuleSpecifier(declaration.initializer, "build") === "esbuild") esbuildBindings.add(declarationName);
+		}
+	}
+	const globalsPaths = /* @__PURE__ */ new Set();
+	let didFindActiveAutoImport = false;
+	let didFindUnsafeActiveAutoImport = false;
+	const visit = (node) => {
+		if (ts.isCallExpression(node)) {
+			const moduleSpecifier = ts.isIdentifier(node.expression) ? autoImportBindings.get(node.expression.text) : getRequireModuleSpecifier(node.expression);
+			if (moduleSpecifier && AUTO_IMPORT_ADAPTER_PATTERN.test(moduleSpecifier)) {
+				if (isInsideActiveConfigProperty(node, moduleSpecifier.endsWith("/astro") ? "integrations" : "plugins", sourceFile, esbuildBindings, esbuildNamespaceBindings)) {
+					didFindActiveAutoImport = true;
+					const globalsPath = getGlobalsPathFromActiveAutoImportCall(node, packageDirectory);
+					if (globalsPath) globalsPaths.add(globalsPath);
+					else didFindUnsafeActiveAutoImport = true;
+				}
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return {
+		didFindActiveAutoImport,
+		globalsPaths: didFindUnsafeActiveAutoImport ? [] : [...globalsPaths]
+	};
+};
+const collectGeneratedGlobalNames = (globalsPath, rootDirectory) => {
+	const relativePath = Path.relative(rootDirectory, globalsPath);
+	if (relativePath.startsWith("..") || Path.isAbsolute(relativePath)) return [];
+	const parsed = failOpenReadJson(globalsPath, null);
+	if (!isPlainObject(parsed) || !isPlainObject(parsed.globals)) return [];
+	return Object.entries(parsed.globals).filter((entry) => entry[0].length > 0 && (typeof entry[1] === "boolean" || typeof entry[1] === "string") && SUPPORTED_GLOBAL_VALUES.has(entry[1])).map(([name]) => name).sort();
+};
+const findOwningPackageDirectory = (absoluteFilePath, rootDirectory, cache) => {
+	let currentDirectory = Path.dirname(absoluteFilePath);
+	const visitedDirectories = [];
+	while (true) {
+		const cachedDirectory = cache.get(currentDirectory);
+		if (cachedDirectory !== void 0) {
+			for (const visitedDirectory of visitedDirectories) cache.set(visitedDirectory, cachedDirectory);
+			return cachedDirectory;
+		}
+		const relativeDirectory = Path.relative(rootDirectory, currentDirectory);
+		if (relativeDirectory.startsWith("..") || Path.isAbsolute(relativeDirectory)) {
+			for (const visitedDirectory of visitedDirectories) cache.set(visitedDirectory, null);
+			return null;
+		}
+		visitedDirectories.push(currentDirectory);
+		if (NFS.existsSync(Path.join(currentDirectory, "package.json"))) {
+			for (const visitedDirectory of visitedDirectories) cache.set(visitedDirectory, currentDirectory);
+			return currentDirectory;
+		}
+		if (currentDirectory === rootDirectory) {
+			for (const visitedDirectory of visitedDirectories) cache.set(visitedDirectory, null);
+			return null;
+		}
+		currentDirectory = Path.dirname(currentDirectory);
+	}
+};
+const collectPackageGlobalNames = (packageDirectory, rootDirectory) => {
+	let directoryEntries;
+	try {
+		directoryEntries = NFS.readdirSync(packageDirectory, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	const configuredGlobalsPaths = [];
+	for (const entry of directoryEntries) {
+		if (!entry.isFile() && !entry.isSymbolicLink() || !CONFIG_FILENAMES.has(entry.name)) continue;
+		const configGlobalsPaths = collectGlobalsPathsFromConfig(Path.join(packageDirectory, entry.name), packageDirectory);
+		if (configGlobalsPaths.didFindActiveAutoImport) configuredGlobalsPaths.push(configGlobalsPaths.globalsPaths.toSorted());
+	}
+	if (configuredGlobalsPaths.length === 0) return [];
+	const globalsPaths = configuredGlobalsPaths[0];
+	if (configuredGlobalsPaths.some((candidatePaths) => candidatePaths.length !== globalsPaths.length || candidatePaths.some((candidatePath, index) => candidatePath !== globalsPaths[index]))) return [];
+	const names = /* @__PURE__ */ new Set();
+	for (const globalsPath of globalsPaths) for (const name of collectGeneratedGlobalNames(globalsPath, rootDirectory)) names.add(name);
+	return [...names].sort();
+};
+const collectUnpluginAutoImportGlobalScopes = ({ rootDirectory, candidateFiles }) => {
+	const absoluteRootDirectory = Path.resolve(rootDirectory);
+	const packageDirectoryCache = /* @__PURE__ */ new Map();
+	const packageDirectories = /* @__PURE__ */ new Set();
+	for (const candidateFile of candidateFiles) {
+		const packageDirectory = findOwningPackageDirectory(Path.resolve(absoluteRootDirectory, candidateFile), absoluteRootDirectory, packageDirectoryCache);
+		if (packageDirectory) packageDirectories.add(packageDirectory);
+	}
+	const scopes = [...packageDirectories].map((packageDirectory) => ({
+		directory: Path.relative(absoluteRootDirectory, packageDirectory).replaceAll("\\", "/"),
+		names: collectPackageGlobalNames(packageDirectory, absoluteRootDirectory)
+	})).sort((firstScope, secondScope) => firstScope.directory.localeCompare(secondScope.directory));
+	return scopes.some((scope) => scope.names.length > 0) ? scopes : [];
+};
 const validateDiagnostic$1 = decodeUnknownSync(Diagnostic);
 const decodeFileDiagnostics = (raw) => {
 	if (!Array.isArray(raw)) return null;
@@ -70276,6 +70989,12 @@ const appendReanimatedSharedValueHint = (help, rule, project) => {
 	if (!help) return REANIMATED_SHARED_VALUE_HINT;
 	return `${help}\n\n${REANIMATED_SHARED_VALUE_HINT}`;
 };
+const columnOfUtf8Offset = (sourceBuffer, utf8Offset) => {
+	const boundedOffset = Math.min(Math.max(utf8Offset, 0), sourceBuffer.length);
+	let lineStartOffset = boundedOffset;
+	while (lineStartOffset > 0 && sourceBuffer[lineStartOffset - 1] !== 10) lineStartOffset--;
+	return sourceBuffer.subarray(lineStartOffset, boundedOffset).toString("utf8").length + 1;
+};
 const REDACTED_PLACEHOLDER = "<redacted>";
 const KEEP_PREFIX = `$1${REDACTED_PLACEHOLDER}`;
 const KNOWN_SECRET_RULES = [
@@ -70991,7 +71710,7 @@ const resolveMatchByOccurrence = (rule, category) => OCCURRENCE_MATCHED_CATEGORI
 * with empty text still carry a useful jump target, so they're kept
 * with a neutral message.
 */
-const buildRelatedLocations = (labels, filePath) => {
+const buildRelatedLocations = (labels, filePath, sourceBuffer) => {
 	if (labels.length <= 1) return [];
 	const related = [];
 	for (let labelIndex = 1; labelIndex < labels.length; labelIndex++) {
@@ -70999,8 +71718,8 @@ const buildRelatedLocations = (labels, filePath) => {
 		if (!label?.span) continue;
 		related.push({
 			filePath,
-			line: label.span.line ?? 0,
-			column: label.span.column ?? 0,
+			line: sourceBuffer === null ? label.span.line ?? 0 : lineOfUtf8Offset(sourceBuffer, label.span.offset),
+			column: sourceBuffer === null ? label.span.column ?? 0 : columnOfUtf8Offset(sourceBuffer, label.span.offset),
 			offset: label.span.offset,
 			length: label.span.length,
 			message: label.label ?? ""
@@ -71020,7 +71739,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) => {
+const parseOxlintOutput = (stdout, project, rootDirectory, sourcePathByLintPath) => {
 	if (!stdout) return [];
 	const jsonStart = stdout.indexOf("{");
 	const sanitizedStdout = jsonStart > 0 ? stdout.slice(jsonStart) : stdout;
@@ -71037,8 +71756,10 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 	const sourceBufferCache = /* @__PURE__ */ new Map();
 	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 resolveSourceFilename = (filename) => resolveMappedSourceFilename(filename) ?? filename;
 	const readSourceBuffer = (filename) => {
-		const absolutePath = resolveAbsolutePath(filename);
+		const absolutePath = resolveAbsolutePath(resolveSourceFilename(filename));
 		const cached = sourceBufferCache.get(absolutePath);
 		if (cached !== void 0) return cached;
 		let sourceBuffer;
@@ -71051,7 +71772,7 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 		return sourceBuffer;
 	};
 	const readSourceLines = (filename) => {
-		const absolutePath = resolveAbsolutePath(filename);
+		const absolutePath = resolveAbsolutePath(resolveSourceFilename(filename));
 		const cached = sourceLinesCache.get(absolutePath);
 		if (cached !== void 0) return cached;
 		const sourceBuffer = readSourceBuffer(filename);
@@ -71060,27 +71781,30 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 		return sourceLines;
 	};
 	const isMinifiedDiagnosticFile = (filename) => {
-		const absolutePath = resolveAbsolutePath(filename);
+		const absolutePath = resolveAbsolutePath(resolveSourceFilename(filename));
 		const cached = minifiedFileCache.get(absolutePath);
 		if (cached !== void 0) return cached;
 		const minified = isMinifiedSource(absolutePath);
 		minifiedFileCache.set(absolutePath, minified);
 		return minified;
 	};
-	return suppressMemoizationInBailedOutFunctions(parsed.diagnostics.filter((diagnostic) => isMappableOxlintDiagnostic(diagnostic) && isLintableSourceFile(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.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);
-		const normalizedFilePath = diagnostic.filename.replaceAll("\\", "/");
+		const mappedSourceFilename = resolveMappedSourceFilename(diagnostic.filename);
+		const normalizedFilePath = (mappedSourceFilename ?? diagnostic.filename).replaceAll("\\", "/");
 		const primarySpan = primaryLabel?.span;
 		const sourceBuffer = primarySpan ? readSourceBuffer(diagnostic.filename) : null;
-		const relatedLocations = buildRelatedLocations(diagnostic.labels, normalizedFilePath);
+		const relatedLocations = buildRelatedLocations(diagnostic.labels, normalizedFilePath, mappedSourceFilename === void 0 ? null : sourceBuffer);
 		const category = resolveDiagnosticCategory(plugin, rule);
 		const matchByOccurrence = resolveMatchByOccurrence(rule, category);
 		const sourceLines = primarySpan ? readSourceLines(diagnostic.filename) : null;
-		const primaryLineIndex = primarySpan ? primarySpan.line - 1 : -1;
+		const primaryLineNumber = primarySpan && mappedSourceFilename !== void 0 && sourceBuffer !== null ? lineOfUtf8Offset(sourceBuffer, primarySpan.offset) : primarySpan?.line ?? 0;
+		const primaryColumnNumber = primarySpan && mappedSourceFilename !== void 0 && sourceBuffer !== null ? columnOfUtf8Offset(sourceBuffer, primarySpan.offset) : primarySpan?.column ?? 0;
+		const primaryLineIndex = primarySpan ? primaryLineNumber - 1 : -1;
 		const primaryLine = sourceLines?.[primaryLineIndex];
-		const primaryColumnIndex = primarySpan ? primarySpan.column - 1 : -1;
+		const primaryColumnIndex = primarySpan ? primaryColumnNumber - 1 : -1;
 		const isJsxTagLabel = primaryLine !== void 0 && primaryColumnIndex >= 0 && (primaryLine[primaryColumnIndex] === "<" || primaryLine[primaryColumnIndex - 1] === "<");
 		const jsxOpenerEndLineIndex = sourceLines && isJsxTagLabel ? findJsxOpenerSpan(sourceLines, primaryLineIndex) : null;
 		const primarySpanEndLine = jsxOpenerEndLineIndex !== null ? jsxOpenerEndLineIndex + 1 : primarySpan && sourceBuffer ? lineOfUtf8Offset(sourceBuffer, primarySpan.offset + Math.max(primarySpan.length - 1, 0)) : void 0;
@@ -71093,8 +71817,8 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 			message: cleaned.message,
 			help: cleaned.help,
 			url: diagnostic.url,
-			line: primarySpan?.line ?? 0,
-			column: primarySpan?.column ?? 0,
+			line: primaryLineNumber,
+			column: primaryColumnNumber,
 			...primarySpan ? {
 				offset: primarySpan.offset,
 				length: primarySpan.length,
@@ -71282,7 +72006,11 @@ const isParallelismRelatedSpawnError = (error) => {
 * loop with a slimmer config in that case.
 */
 const spawnLintBatches = async (input) => {
-	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes, splitTotalBudgetMs = OXLINT_SPLIT_TOTAL_BUDGET_MS, splitMaxDepth = 8, signal, deadlineEpochMs } = input;
+	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, sourcePathByLintPath, 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;
+	};
 	const requestedConcurrency = resolveScanConcurrency(input.concurrency ?? 1);
 	let rescueDeadlineEpochMs;
 	const isPastDeadline = () => deadlineEpochMs !== void 0 && remainingDeadlineBudgetMs(deadlineEpochMs) === 0 || rescueDeadlineEpochMs !== void 0 && remainingDeadlineBudgetMs(rescueDeadlineEpochMs) === 0;
@@ -71302,7 +72030,7 @@ const spawnLintBatches = async (input) => {
 			}
 			const batchArgs = [...baseArgs, ...batch];
 			try {
-				return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes, signal), project, rootDirectory);
+				return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes, signal), project, rootDirectory, sourcePathByLintPath);
 			} catch (error) {
 				if (!isSplittableReactDoctorError(error)) throw error;
 				if (isPastDeadline()) {
@@ -71408,10 +72136,12 @@ const spawnLintBatches = async (input) => {
 		onPartialFailure(buildMessage(`${skippedFiles.slice(0, 3).join(", ")}${skippedFiles.length > 3 ? `, +${skippedFiles.length - 3} more` : ""}`));
 	};
 	const reasonHint = firstDropReason ? ` — first failure: ${firstDropReason}` : "";
-	reportSkippedFiles(droppedFiles, (fileListPreview) => `${droppedFiles.length} file(s) failed to lint and were skipped (${fileListPreview})${reasonHint}`);
-	reportSkippedFiles(outcome.deadlineSkippedFiles, (fileListPreview) => `${outcome.deadlineSkippedFiles.length} file(s) skipped — max scan duration reached before they were linted (${fileListPreview})`);
+	const droppedSourceFiles = [...new Set(droppedFiles.map(resolveSourcePath))];
+	const deadlineSkippedSourceFiles = [...new Set(outcome.deadlineSkippedFiles.map(resolveSourcePath))];
+	reportSkippedFiles(droppedSourceFiles, (fileListPreview) => `${droppedSourceFiles.length} file(s) failed to lint and were skipped (${fileListPreview})${reasonHint}`);
+	reportSkippedFiles(deadlineSkippedSourceFiles, (fileListPreview) => `${deadlineSkippedSourceFiles.length} file(s) skipped — max scan duration reached before they were linted (${fileListPreview})`);
 	const unavailableFiles = new Set([...droppedFiles, ...outcome.deadlineSkippedFiles]);
-	input.onAnalyzedFiles?.([...new Set(fileBatches.flat().filter((filePath) => !unavailableFiles.has(filePath)))].sort());
+	input.onAnalyzedFiles?.([...new Set(fileBatches.flat().filter((filePath) => !unavailableFiles.has(filePath)).map(resolveSourcePath))].sort());
 	return dedupeDiagnostics(diagnostics);
 };
 let didValidate = false;
@@ -71510,6 +72240,266 @@ const planLintBatches = ({ baseArgs, files, sizeByFile }) => {
 	}
 	return batches.filter((batch) => batch.fileIndexes.length > 0).map((batch) => batch.fileIndexes.sort((leftIndex, rightIndex) => leftIndex - rightIndex).map((fileIndex) => files[fileIndex]));
 };
+const THREE_MODULE_IMPORT_PATTERN = /\b(?:from\s*|import\s*(?:\(\s*)?|require\s*\(\s*)["']three(?:\/[^"']*)?["']/;
+const containsThreeModuleImport = (sourceText) => THREE_MODULE_IMPORT_PATTERN.test(sourceText);
+const COMMENT_OPEN = "<!--";
+const COMMENT_CLOSE = "-->";
+const FRONTMATTER_FENCE = "---";
+const SCRIPT_TAG_NAME = "script";
+const SCRIPT_OPEN = `<${SCRIPT_TAG_NAME}`;
+const SCRIPT_CLOSE = `</${SCRIPT_TAG_NAME}`;
+const TEMPLATE_TAG_NAME = "template";
+const TEMPLATE_CLOSE = `</${TEMPLATE_TAG_NAME}`;
+const JAVASCRIPT_MIME_TYPES = new Set([
+	"application/ecmascript",
+	"application/javascript",
+	"application/x-ecmascript",
+	"application/x-javascript",
+	"text/ecmascript",
+	"text/javascript",
+	"text/javascript1.0",
+	"text/javascript1.1",
+	"text/javascript1.2",
+	"text/javascript1.3",
+	"text/javascript1.4",
+	"text/javascript1.5",
+	"text/jscript",
+	"text/livescript",
+	"text/x-ecmascript",
+	"text/x-javascript"
+]);
+const RAW_TEXT_TAG_NAMES = new Set([
+	"iframe",
+	"noembed",
+	"noframes",
+	"noscript",
+	"style",
+	"textarea",
+	"title",
+	"xmp"
+]);
+const PLAINTEXT_TAG_NAME = "plaintext";
+const TAG_OPEN_UTF8_BYTE = "<".charCodeAt(0);
+const TAG_CLOSE_UTF8_BYTE = ">".charCodeAt(0);
+const SINGLE_QUOTE_UTF8_BYTE = "'".charCodeAt(0);
+const DOUBLE_QUOTE_UTF8_BYTE = "\"".charCodeAt(0);
+const ATTRIBUTE_ASSIGNMENT_UTF8_BYTE = "=".charCodeAt(0);
+const TAG_SELF_CLOSE_UTF8_BYTE = "/".charCodeAt(0);
+const TAB_UTF8_BYTE = "	".charCodeAt(0);
+const FORM_FEED_UTF8_BYTE = "\f".charCodeAt(0);
+const isHtmlWhitespace = (byte) => byte === TAB_UTF8_BYTE || byte === 10 || byte === FORM_FEED_UTF8_BYTE || byte === 13 || byte === 32;
+const matchesAsciiCaseInsensitive = (sourceBuffer, startByte, expected) => {
+	if (startByte + expected.length > sourceBuffer.length) return false;
+	for (let expectedIndex = 0; expectedIndex < expected.length; expectedIndex++) {
+		const sourceByte = sourceBuffer[startByte + expectedIndex];
+		if (sourceByte === void 0 || String.fromCharCode(sourceByte).toLowerCase() !== expected[expectedIndex]) return false;
+	}
+	return true;
+};
+const isTagBoundary = (byte) => byte === TAG_CLOSE_UTF8_BYTE || byte === TAG_SELF_CLOSE_UTF8_BYTE || isHtmlWhitespace(byte);
+const isPotentialTagStart = (byte) => {
+	if (byte === void 0) return false;
+	return /[A-Za-z!/?]/.test(String.fromCharCode(byte));
+};
+const findLineEnd = (sourceBuffer, lineStartByte) => {
+	let byteIndex = lineStartByte;
+	while (byteIndex < sourceBuffer.length && sourceBuffer[byteIndex] !== 10 && sourceBuffer[byteIndex] !== 13) byteIndex++;
+	return byteIndex;
+};
+const findNextLineStart = (sourceBuffer, lineStartByte) => {
+	const lineEndByte = findLineEnd(sourceBuffer, lineStartByte);
+	if (sourceBuffer[lineEndByte] === 13 && sourceBuffer[lineEndByte + 1] === 10) return lineEndByte + 2;
+	return Math.min(lineEndByte + 1, sourceBuffer.length);
+};
+const isFrontmatterFenceLine = (sourceBuffer, lineStartByte) => {
+	if (!matchesAsciiCaseInsensitive(sourceBuffer, lineStartByte, FRONTMATTER_FENCE)) return false;
+	const lineEndByte = findLineEnd(sourceBuffer, lineStartByte);
+	for (let byteIndex = lineStartByte + 3; byteIndex < lineEndByte; byteIndex++) if (!isHtmlWhitespace(sourceBuffer[byteIndex])) return false;
+	return true;
+};
+const findFrontmatterEnd = (sourceBuffer) => {
+	if (!isFrontmatterFenceLine(sourceBuffer, 0)) return 0;
+	const openingFenceEndByte = findLineEnd(sourceBuffer, 0);
+	let lineStartByte = findNextLineStart(sourceBuffer, 0);
+	while (lineStartByte < sourceBuffer.length) {
+		if (isFrontmatterFenceLine(sourceBuffer, lineStartByte)) return findLineEnd(sourceBuffer, lineStartByte);
+		lineStartByte = findNextLineStart(sourceBuffer, lineStartByte);
+	}
+	return openingFenceEndByte;
+};
+const maskByteRange = (maskedBuffer, startByte, endByte) => {
+	for (let byteIndex = startByte; byteIndex < endByte; byteIndex++) {
+		const byte = maskedBuffer[byteIndex];
+		if (byte !== 10 && byte !== 13) maskedBuffer[byteIndex] = 32;
+	}
+};
+const readStartTagName = (sourceBuffer, tagStartByte) => {
+	const firstNameByte = sourceBuffer[tagStartByte + 1];
+	if (firstNameByte === void 0 || !/[A-Za-z]/.test(String.fromCharCode(firstNameByte))) return null;
+	let nameEndByte = tagStartByte + 2;
+	while (nameEndByte < sourceBuffer.length && /[A-Za-z0-9:-]/.test(String.fromCharCode(sourceBuffer[nameEndByte] ?? 32))) nameEndByte++;
+	return sourceBuffer.subarray(tagStartByte + 1, nameEndByte).toString("ascii").toLowerCase();
+};
+const findTagEnd = (sourceBuffer, startByte) => {
+	let quoteByte = null;
+	for (let byteIndex = startByte; byteIndex < sourceBuffer.length; byteIndex++) {
+		const byte = sourceBuffer[byteIndex];
+		if (quoteByte !== null) {
+			if (byte === quoteByte) quoteByte = null;
+			continue;
+		}
+		if (byte === SINGLE_QUOTE_UTF8_BYTE || byte === DOUBLE_QUOTE_UTF8_BYTE) {
+			quoteByte = byte;
+			continue;
+		}
+		if (byte === TAG_CLOSE_UTF8_BYTE) return byteIndex;
+	}
+	return sourceBuffer.length;
+};
+const parseScriptAttributes = (sourceBuffer, attributesStartByte, tagEndByte) => {
+	let byteIndex = attributesStartByte;
+	let hasSource = false;
+	let language = null;
+	let scriptType = null;
+	while (byteIndex < tagEndByte) {
+		while (byteIndex < tagEndByte && (isHtmlWhitespace(sourceBuffer[byteIndex]) || sourceBuffer[byteIndex] === TAG_SELF_CLOSE_UTF8_BYTE)) byteIndex++;
+		const attributeNameStartByte = byteIndex;
+		while (byteIndex < tagEndByte && !isHtmlWhitespace(sourceBuffer[byteIndex]) && sourceBuffer[byteIndex] !== ATTRIBUTE_ASSIGNMENT_UTF8_BYTE && sourceBuffer[byteIndex] !== TAG_SELF_CLOSE_UTF8_BYTE) byteIndex++;
+		const attributeName = sourceBuffer.subarray(attributeNameStartByte, byteIndex).toString("ascii").toLowerCase();
+		while (byteIndex < tagEndByte && isHtmlWhitespace(sourceBuffer[byteIndex])) byteIndex++;
+		let attributeValue = "";
+		if (sourceBuffer[byteIndex] === ATTRIBUTE_ASSIGNMENT_UTF8_BYTE) {
+			byteIndex++;
+			while (byteIndex < tagEndByte && isHtmlWhitespace(sourceBuffer[byteIndex])) byteIndex++;
+			const quoteByte = sourceBuffer[byteIndex];
+			if (quoteByte === SINGLE_QUOTE_UTF8_BYTE || quoteByte === DOUBLE_QUOTE_UTF8_BYTE) {
+				const valueStartByte = byteIndex + 1;
+				byteIndex = valueStartByte;
+				while (byteIndex < tagEndByte && sourceBuffer[byteIndex] !== quoteByte) byteIndex++;
+				attributeValue = sourceBuffer.subarray(valueStartByte, byteIndex).toString("utf8");
+				if (byteIndex < tagEndByte) byteIndex++;
+			} else {
+				const valueStartByte = byteIndex;
+				while (byteIndex < tagEndByte && !isHtmlWhitespace(sourceBuffer[byteIndex]) && sourceBuffer[byteIndex] !== TAG_CLOSE_UTF8_BYTE) byteIndex++;
+				attributeValue = sourceBuffer.subarray(valueStartByte, byteIndex).toString("utf8");
+			}
+		}
+		if (attributeName === "src") hasSource = true;
+		else if (attributeName === "type" && scriptType === null) scriptType = attributeValue;
+		else if (attributeName === "language" && language === null) language = attributeValue;
+	}
+	return {
+		hasSource,
+		language,
+		type: scriptType
+	};
+};
+const isExecutableScript = (attributes) => {
+	if (attributes.hasSource) return false;
+	const type = attributes.type?.trim().toLowerCase() ?? "";
+	if (type !== "") {
+		const mimeType = type.split(";")[0]?.trim() ?? "";
+		return mimeType === "module" || JAVASCRIPT_MIME_TYPES.has(mimeType);
+	}
+	const language = attributes.language?.trim().toLowerCase() ?? "";
+	return language === "" || JAVASCRIPT_MIME_TYPES.has(`text/${language}`);
+};
+const findElementClose = (sourceBuffer, startByte, tagName) => {
+	const closeTagStart = `</${tagName}`;
+	for (let byteIndex = startByte; byteIndex < sourceBuffer.length; byteIndex++) if (sourceBuffer[byteIndex] === TAG_OPEN_UTF8_BYTE && matchesAsciiCaseInsensitive(sourceBuffer, byteIndex, closeTagStart) && isTagBoundary(sourceBuffer[byteIndex + closeTagStart.length])) return byteIndex;
+	return sourceBuffer.length;
+};
+const prepareHtmlScriptSource = (sourceBuffer) => {
+	const frontmatterEndByte = findFrontmatterEnd(sourceBuffer);
+	let maskedBuffer = frontmatterEndByte > 0 ? Buffer.from(sourceBuffer) : null;
+	if (maskedBuffer !== null) maskByteRange(maskedBuffer, 0, frontmatterEndByte);
+	const executableScriptBodies = [];
+	let byteIndex = frontmatterEndByte;
+	let templateDepth = 0;
+	while (byteIndex < sourceBuffer.length) {
+		if (sourceBuffer[byteIndex] !== TAG_OPEN_UTF8_BYTE) {
+			byteIndex++;
+			continue;
+		}
+		if (matchesAsciiCaseInsensitive(sourceBuffer, byteIndex, COMMENT_OPEN)) {
+			const commentEndByte = sourceBuffer.indexOf(COMMENT_CLOSE, byteIndex + 4);
+			byteIndex = commentEndByte === -1 ? sourceBuffer.length : commentEndByte + 3;
+			continue;
+		}
+		if (matchesAsciiCaseInsensitive(sourceBuffer, byteIndex, TEMPLATE_CLOSE) && isTagBoundary(sourceBuffer[byteIndex + TEMPLATE_CLOSE.length])) {
+			const tagEndByte = findTagEnd(sourceBuffer, byteIndex + TEMPLATE_CLOSE.length);
+			if (templateDepth > 0) templateDepth--;
+			byteIndex = Math.min(tagEndByte + 1, sourceBuffer.length);
+			continue;
+		}
+		if (!matchesAsciiCaseInsensitive(sourceBuffer, byteIndex, SCRIPT_OPEN) || !isTagBoundary(sourceBuffer[byteIndex + SCRIPT_OPEN.length])) {
+			if (!isPotentialTagStart(sourceBuffer[byteIndex + 1])) {
+				byteIndex++;
+				continue;
+			}
+			const tagEndByte = findTagEnd(sourceBuffer, byteIndex + 1);
+			const tagName = readStartTagName(sourceBuffer, byteIndex);
+			if (tagName === PLAINTEXT_TAG_NAME) break;
+			if (tagName === TEMPLATE_TAG_NAME) templateDepth++;
+			if (tagName !== null && RAW_TEXT_TAG_NAMES.has(tagName)) {
+				const closeTagStartByte = findElementClose(sourceBuffer, tagEndByte + 1, tagName);
+				if (closeTagStartByte === sourceBuffer.length) break;
+				const closeTagEndByte = findTagEnd(sourceBuffer, closeTagStartByte + tagName.length + 2);
+				byteIndex = Math.min(closeTagEndByte + 1, sourceBuffer.length);
+				continue;
+			}
+			byteIndex = Math.min(tagEndByte + 1, sourceBuffer.length);
+			continue;
+		}
+		const tagEndByte = findTagEnd(sourceBuffer, byteIndex + SCRIPT_OPEN.length);
+		if (tagEndByte === sourceBuffer.length) break;
+		const bodyStartByte = tagEndByte + 1;
+		const bodyEndByte = findElementClose(sourceBuffer, bodyStartByte, SCRIPT_TAG_NAME);
+		const attributes = parseScriptAttributes(sourceBuffer, byteIndex + SCRIPT_OPEN.length, tagEndByte);
+		if (attributes.hasSource || templateDepth > 0) {
+			maskedBuffer ??= Buffer.from(sourceBuffer);
+			maskByteRange(maskedBuffer, bodyStartByte, bodyEndByte);
+		} else if (isExecutableScript(attributes)) executableScriptBodies.push(sourceBuffer.subarray(bodyStartByte, bodyEndByte));
+		if (bodyEndByte === sourceBuffer.length) break;
+		const closeTagEndByte = findTagEnd(sourceBuffer, bodyEndByte + SCRIPT_CLOSE.length);
+		byteIndex = Math.min(closeTagEndByte + 1, sourceBuffer.length);
+	}
+	return {
+		executableScriptBodies,
+		lintBuffer: maskedBuffer ?? sourceBuffer
+	};
+};
+const prepareHtmlLintSources = (rootDirectory, temporaryDirectory, candidateFiles) => {
+	const lintFiles = [];
+	const sourcePathByLintPath = /* @__PURE__ */ new Map();
+	const sizeByLintPath = /* @__PURE__ */ new Map();
+	const htmlSourcesDirectory = Path.join(temporaryDirectory, "html-sources");
+	let htmlFileIndex = 0;
+	let hasThreeModuleImport = false;
+	for (const candidateFile of candidateFiles) {
+		if (!HTML_FILE_PATTERN.test(candidateFile)) {
+			lintFiles.push(candidateFile);
+			continue;
+		}
+		const absoluteSourcePath = Path.isAbsolute(candidateFile) ? candidateFile : Path.resolve(rootDirectory, candidateFile);
+		const sourceBuffer = NFS.readFileSync(absoluteSourcePath);
+		const { executableScriptBodies, lintBuffer } = prepareHtmlScriptSource(sourceBuffer);
+		if (htmlFileIndex === 0) NFS.mkdirSync(htmlSourcesDirectory, { recursive: true });
+		const lintPath = Path.join(htmlSourcesDirectory, `${htmlFileIndex}.astro`);
+		NFS.writeFileSync(lintPath, lintBuffer);
+		lintFiles.push(lintPath);
+		sourcePathByLintPath.set(Path.resolve(lintPath), candidateFile);
+		sizeByLintPath.set(lintPath, sourceBuffer.length);
+		hasThreeModuleImport ||= executableScriptBodies.some((scriptBody) => containsThreeModuleImport(scriptBody.toString("utf8")));
+		htmlFileIndex++;
+	}
+	return {
+		lintFiles,
+		sourcePathByLintPath,
+		sizeByLintPath,
+		hasThreeModuleImport
+	};
+};
 /**
 * Atomically (re)writes the generated oxlintrc.json. Used twice in
 * the runner: once for the primary scan, once for the
@@ -71670,6 +72660,8 @@ const reactHooksJsPluginDropNote = (error) => {
 const runOxlint = async (options) => {
 	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), includedTags = /* @__PURE__ */ new Set(), includeTagDefaults = false, userConfig, configSourceDirectory = rootDirectory, onPartialFailure, onFileCoverage, perFileLintCacheEnabled = false, sidecarLintCacheEnabled = false, onCacheStats, onSidecarStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "cost" } = options;
 	const serverAuthFunctionNames = Array.isArray(userConfig?.serverAuthFunctionNames) ? userConfig.serverAuthFunctionNames.filter((entry) => typeof entry === "string" && entry.length > 0) : void 0;
+	const runtimeGlobals = Array.isArray(userConfig?.runtimeGlobals) ? userConfig.runtimeGlobals.filter((entry) => typeof entry === "string" && entry.length > 0) : void 0;
+	let unpluginAutoImportGlobalScopes = [];
 	const severityControls = buildRuleSeverityControls(userConfig);
 	validateRuleRegistration();
 	resetManifestCaches();
@@ -71683,21 +72675,6 @@ const runOxlint = async (options) => {
 	const pluginPath = resolvePluginPath();
 	const extendsPaths = (adoptExistingLintConfig && !customRulesOnly ? detectUserLintConfigPaths(rootDirectory) : []).filter(canOxlintExtendConfig);
 	const userPlugins = includedTags.size > 0 ? [] : resolveUserPlugins(userConfig?.plugins, configSourceDirectory);
-	const buildConfig = (overrides) => createOxlintConfig({
-		pluginPath,
-		project,
-		customRulesOnly,
-		extendsPaths: overrides.extendsPaths,
-		ignoredTags,
-		includedTags,
-		includeTagDefaults,
-		serverAuthFunctionNames,
-		severityControls,
-		userPlugins,
-		disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin,
-		ruleSelection: overrides.ruleSelection,
-		sidecarRuleIdFilter: overrides.sidecarRuleIdFilter
-	});
 	const restoreDisableDirectives = respectInlineDisables ? () => {} : await neutralizeDisableDirectives(rootDirectory, includePaths);
 	const configDirectory = NFS.mkdtempSync(Path.join(os.tmpdir(), "react-doctor-oxlintrc-"));
 	const configPath = Path.join(configDirectory, "oxlintrc.json");
@@ -71733,7 +72710,36 @@ const runOxlint = async (options) => {
 		await yieldToEventLoop();
 		const sizedScanFiles = includePaths === void 0 ? listSourceFilesWithSize(rootDirectory) : null;
 		const candidateFiles = includePaths !== void 0 ? includePaths : (sizedScanFiles ?? []).map((entry) => entry.path);
+		unpluginAutoImportGlobalScopes = collectUnpluginAutoImportGlobalScopes({
+			rootDirectory,
+			candidateFiles
+		});
+		const preparedHtmlSources = prepareHtmlLintSources(rootDirectory, configDirectory, candidateFiles);
+		const lintFiles = preparedHtmlSources.lintFiles;
+		const hasHtmlFiles = preparedHtmlSources.sourcePathByLintPath.size > 0;
+		const lintProject = !project.hasThree && preparedHtmlSources.hasThreeModuleImport ? {
+			...project,
+			hasThree: true
+		} : project;
+		const buildConfig = (overrides) => createOxlintConfig({
+			pluginPath,
+			project: lintProject,
+			customRulesOnly,
+			extendsPaths: overrides.extendsPaths,
+			ignoredTags,
+			includedTags,
+			includeTagDefaults,
+			runtimeGlobals,
+			unpluginAutoImportGlobalScopes,
+			serverAuthFunctionNames,
+			severityControls,
+			userPlugins,
+			disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin,
+			ruleSelection: overrides.ruleSelection,
+			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);
 		const buildFileBatches = (passBaseArgs, passFiles) => sizeByFile !== null ? planLintBatches({
 			baseArgs: passBaseArgs,
 			files: passFiles,
@@ -71762,7 +72768,8 @@ const runOxlint = async (options) => {
 					fileBatches: passFileBatches,
 					rootDirectory,
 					nodeBinaryPath,
-					project,
+					project: lintProject,
+					sourcePathByLintPath: preparedHtmlSources.sourcePathByLintPath,
 					onPartialFailure: reportPartialFailure,
 					onAnalyzedFiles: (filePaths) => {
 						analyzedFiles = filePaths;
@@ -71797,7 +72804,7 @@ const runOxlint = async (options) => {
 				};
 			}
 		};
-		if (perFileLintCacheEnabled && !project.hasReactCompiler && project.hasReactCompilerLintPlugin !== true && extendsPaths.length === 0 && userPlugins.length === 0) {
+		if (perFileLintCacheEnabled && !project.hasReactCompiler && project.hasReactCompilerLintPlugin !== true && extendsPaths.length === 0 && userPlugins.length === 0 && !hasHtmlFiles) {
 			const rulesetHash = computeRulesetHash({
 				config: buildConfig({
 					extendsPaths: [],
@@ -71955,14 +72962,15 @@ const runOxlint = async (options) => {
 			]);
 		}
 		const baseArgs = makeBaseArgs(configPath);
-		const fileBatches = buildFileBatches(baseArgs, candidateFiles);
+		const fileBatches = buildFileBatches(baseArgs, lintFiles);
 		let analyzedFiles = [];
 		const runBatches = () => spawnLintBatches({
 			baseArgs,
 			fileBatches,
 			rootDirectory,
 			nodeBinaryPath,
-			project,
+			project: lintProject,
+			sourcePathByLintPath: preparedHtmlSources.sourcePathByLintPath,
 			onPartialFailure,
 			onAnalyzedFiles: (filePaths) => {
 				analyzedFiles = filePaths;
@@ -73884,4 +74892,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=eb93b210-c190-581c-8fe2-f1e1c70e0bab
+//# debugId=41e39010-e2d7-5e6b-9bba-626bf64affe5