oxlint-plugin-react-doctor 0.6.3-dev.8325343 → 0.6.3-dev.bdf8074

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { StaticImport } from "oxc-parser";
 import { TSESTree } from "@typescript-eslint/types";
 
 //#region src/plugin/utils/es-tree-node.d.ts
@@ -16644,6 +16645,85 @@ declare const MOTION_LIBRARY_PACKAGES: Set<string>;
 //#region src/plugin/constants/cross-file-rule-ids.d.ts
 declare const CROSS_FILE_RULE_IDS: ReadonlySet<string>;
 //#endregion
+//#region src/plugin/utils/cross-file-probe-recorder.d.ts
+interface CrossFileProbeTrace {
+  /** Paths whose existence classification (file / dir / none) was consulted. */
+  readonly existencePaths: Set<string>;
+  /** Paths whose content (bytes, exports, parse) was consulted. */
+  readonly contentPaths: Set<string>;
+}
+//#endregion
+//#region src/plugin/cross-file-dependencies.d.ts
+/**
+ * Per-rule cross-file dependency collectors — the foundation of the sidecar
+ * lint cache's dependency fingerprints (`@react-doctor/core`,
+ * `runners/oxlint/sidecar-lint-cache.ts`).
+ *
+ * A collector re-runs the SAME resolver helpers its rule calls at lint time
+ * (import resolution, barrel following, ancestor-layout walks, package.json
+ * classification) under the probe recorder
+ * (`utils/cross-file-probe-recorder.ts`), so the recorded probe set is the
+ * exact set of filesystem facts the rule's execution consulted — including
+ * the negative probes (extension candidates that did NOT exist) that make
+ * resolution shadowing detectable when a new file appears.
+ *
+ * SOUNDNESS INVARIANT — each collector's probe set must be a SUPERSET of
+ * every filesystem read its rule can make while linting the file, for any
+ * file content and any filesystem state:
+ *
+ *   - Over-approximation is always safe (extra probes only cause a spurious
+ *     re-lint); under-approximation is forbidden (a missed probe could
+ *     replay a stale verdict).
+ *   - Where a rule gates its cross-file reads on in-file conditions, a
+ *     collector may skip the gate (probe more) or must mirror it EXACTLY
+ *     (probe the same). Each collector documents which it does per gate.
+ *   - The replay argument: the stored probe set is the complete read set of
+ *     the collector's execution at store time. If every stored probe has
+ *     the same answer on a later scan, re-executing the collector — and
+ *     therefore the rule, whose reads are a subset — reproduces the same
+ *     execution step by step (the file's own content is pinned separately
+ *     by the cache key's content hash), so the stored diagnostics are
+ *     exactly what a fresh sidecar lint would produce.
+ *
+ * A cross-file rule WITHOUT a collector here must be listed in
+ * `UNBOUNDED_CROSS_FILE_RULE_IDS` — it then re-lints every file on every
+ * scan (the sound fallback). `cross-file-rule-ids.test.ts` in
+ * `@react-doctor/core` forces every `CROSS_FILE_RULE_IDS` entry into
+ * exactly one of the two classifications.
+ */
+interface CrossFileDependencyCollectorInput {
+  /** Absolute, forward-slash-normalized path of the file being fingerprinted. */
+  readonly absoluteFilePath: string;
+  readonly sourceText: string;
+  /** oxc module record — the file's static import declarations. */
+  readonly staticImports: ReadonlyArray<StaticImport>;
+  /** Parsed program (no parent references attached). */
+  readonly program: EsTreeNode;
+}
+type CrossFileDependencyCollector = (input: CrossFileDependencyCollectorInput) => void;
+declare const CROSS_FILE_DEPENDENCY_COLLECTORS: ReadonlyMap<string, CrossFileDependencyCollector>;
+/**
+ * Cross-file rules whose dependency set CANNOT be soundly bounded — they are
+ * excluded from fingerprinting and re-lint every file on every scan. Empty
+ * today; a new cross-file rule must be added either here or to
+ * `CROSS_FILE_DEPENDENCY_COLLECTORS` (the core guard test enforces the
+ * partition), forcing a conscious classification.
+ */
+declare const UNBOUNDED_CROSS_FILE_RULE_IDS: ReadonlySet<string>;
+/**
+ * Runs the collectors for `ruleIds` over one file and returns every
+ * filesystem probe they made — the file's cross-file dependency set.
+ *
+ * Returns `null` (caller must treat the file as unfingerprintable and always
+ * re-lint it) when the file has a fatal parse error — an execution the
+ * collectors cannot mirror — or when a requested rule has no collector.
+ */
+declare const collectCrossFileDependencyProbes: (input: {
+  absoluteFilePath: string;
+  sourceText: string;
+  ruleIds: ReadonlyArray<string>;
+}) => CrossFileProbeTrace | null;
+//#endregion
 //#region src/plugin/rules/security-scan/utils/classify-security-scan-file.d.ts
 interface SecurityScanFileClassification {
   readonly bucket: "priority" | "artifact" | "other";
@@ -16657,5 +16737,5 @@ declare const REACT_NATIVE_DEPENDENCY_NAMES: ReadonlySet<string>;
 declare const REACT_NATIVE_DEPENDENCY_PREFIXES: ReadonlyArray<string>;
 declare const isReactNativeDependencyName: (dependencyName: string) => boolean;
 //#endregion
-export { ALL_REACT_DOCTOR_RULES, ALL_REACT_DOCTOR_RULE_KEYS, CROSS_FILE_RULE_IDS, EXTERNAL_RULES, type EsTreeNode, FRAMEWORK_SPECIFIC_RULE_KEYS, type FileScan, MOTION_LIBRARY_PACKAGES, NEXTJS_RULES, type OxlintRuleSeverity, PREACT_RULES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, REACT_NATIVE_DEPENDENCY_NAMES, REACT_NATIVE_DEPENDENCY_PREFIXES, REACT_NATIVE_RULES, RECOMMENDED_RULES, RULES, type Rule, type RuleFramework, type RulePlugin, type RuleSeverity, type RuleVisitors, type ScanFinding, type ScannedFile, TANSTACK_QUERY_RULES, TANSTACK_START_RULES, classifySecurityScanFile, plugin as default, isReactNativeDependencyName, shouldReadSecurityScanContent };
+export { ALL_REACT_DOCTOR_RULES, ALL_REACT_DOCTOR_RULE_KEYS, CROSS_FILE_DEPENDENCY_COLLECTORS, CROSS_FILE_RULE_IDS, type CrossFileProbeTrace, EXTERNAL_RULES, type EsTreeNode, FRAMEWORK_SPECIFIC_RULE_KEYS, type FileScan, MOTION_LIBRARY_PACKAGES, NEXTJS_RULES, type OxlintRuleSeverity, PREACT_RULES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, REACT_NATIVE_DEPENDENCY_NAMES, REACT_NATIVE_DEPENDENCY_PREFIXES, REACT_NATIVE_RULES, RECOMMENDED_RULES, RULES, type Rule, type RuleFramework, type RulePlugin, type RuleSeverity, type RuleVisitors, type ScanFinding, type ScannedFile, TANSTACK_QUERY_RULES, TANSTACK_START_RULES, UNBOUNDED_CROSS_FILE_RULE_IDS, classifySecurityScanFile, collectCrossFileDependencyProbes, plugin as default, isReactNativeDependencyName, shouldReadSecurityScanContent };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -15564,6 +15564,30 @@ const nextjsInlineScriptMissingId = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/cross-file-probe-recorder.ts
+let activeProbeTrace = null;
+const recordExistenceProbe = (absolutePath) => {
+	activeProbeTrace?.existencePaths.add(absolutePath);
+};
+const recordContentProbe = (absolutePath) => {
+	activeProbeTrace?.contentPaths.add(absolutePath);
+};
+const isProbeRecorderActive = () => activeProbeTrace !== null;
+const collectCrossFileProbes = (collect) => {
+	const previousTrace = activeProbeTrace;
+	const trace = {
+		existencePaths: /* @__PURE__ */ new Set(),
+		contentPaths: /* @__PURE__ */ new Set()
+	};
+	activeProbeTrace = trace;
+	try {
+		collect();
+	} finally {
+		activeProbeTrace = previousTrace;
+	}
+	return trace;
+};
+//#endregion
 //#region src/plugin/utils/parse-export-specifiers.ts
 const getSpecifierName = (rawName) => rawName.replace(/^type\s+/, "").trim();
 const parseExportSpecifiers = (specifiersText, declarationIsTypeOnly) => specifiersText.split(",").map((specifierText) => specifierText.trim()).filter(Boolean).map((specifierText) => {
@@ -15599,6 +15623,7 @@ const collectSourceTextExportNames = (sourceText) => {
 };
 const exportNamesCache = /* @__PURE__ */ new Map();
 const doesModuleExportName = (filePath, exportedName) => {
+	recordContentProbe(filePath);
 	try {
 		const fileStat = fs.statSync(filePath);
 		const cached = exportNamesCache.get(filePath);
@@ -16643,6 +16668,7 @@ const parseSourceText = (filename, sourceText) => {
 };
 const parseCache = /* @__PURE__ */ new Map();
 const parseSourceFile = (absoluteFilePath) => {
+	if (!(absoluteFilePath.endsWith(".d.ts") || absoluteFilePath.endsWith(".d.mts") || absoluteFilePath.endsWith(".d.cts"))) recordContentProbe(absoluteFilePath);
 	let fileStat;
 	try {
 		fileStat = fs.statSync(absoluteFilePath);
@@ -16789,15 +16815,27 @@ const classifyBarrelModule = (sourceText) => {
 };
 const getBarrelIndexModuleInfo = (filePath) => {
 	if (!isIndexModuleFilePath(filePath)) return createNonBarrelInfo();
+	recordContentProbe(filePath);
+	let fileStat;
+	try {
+		fileStat = fs.statSync(filePath);
+	} catch {
+		fileStat = null;
+	}
 	const cachedResult = barrelIndexModuleInfoCache.get(filePath);
-	if (cachedResult !== void 0) return cachedResult;
+	if (cachedResult !== void 0 && fileStat !== null && cachedResult.mtimeMs === fileStat.mtimeMs && cachedResult.size === fileStat.size) return cachedResult.moduleInfo;
+	if (fileStat === null) return createNonBarrelInfo();
 	let moduleInfo = createNonBarrelInfo();
 	try {
 		moduleInfo = classifyBarrelModule(fs.readFileSync(filePath, "utf8"));
 	} catch {
 		moduleInfo = createNonBarrelInfo();
 	}
-	barrelIndexModuleInfoCache.set(filePath, moduleInfo);
+	barrelIndexModuleInfoCache.set(filePath, {
+		mtimeMs: fileStat.mtimeMs,
+		size: fileStat.size,
+		moduleInfo
+	});
 	return moduleInfo;
 };
 const isBarrelIndexModule = (filePath) => getBarrelIndexModuleInfo(filePath).isBarrel;
@@ -16826,6 +16864,7 @@ const PACKAGE_ENTRY_FIELDS = [
 	"browser"
 ];
 const getExistingFilePath = (filePath) => {
+	recordExistenceProbe(filePath);
 	try {
 		return fs.statSync(filePath).isFile() ? filePath : null;
 	} catch {
@@ -16833,6 +16872,7 @@ const getExistingFilePath = (filePath) => {
 	}
 };
 const getExistingDirectoryPath = (directoryPath) => {
+	recordExistenceProbe(directoryPath);
 	try {
 		return fs.statSync(directoryPath).isDirectory() ? directoryPath : null;
 	} catch {
@@ -16888,6 +16928,7 @@ const resolvePackageDirectoryEntry = (directoryPath) => {
 	const existingDirectoryPath = getExistingDirectoryPath(directoryPath);
 	if (!existingDirectoryPath) return null;
 	const packageJsonPath = path.join(existingDirectoryPath, "package.json");
+	recordContentProbe(packageJsonPath);
 	try {
 		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
 		const packageEntry = getPackageExportEntry(packageJson) ?? PACKAGE_ENTRY_FIELDS.map((fieldName) => packageJson[fieldName]).find((value) => typeof value === "string");
@@ -16996,7 +17037,9 @@ const stripJsonComments = (text) => {
 	}
 	return output.replace(/,(\s*[}\]])/g, "$1");
 };
-const parseTsconfigFile = (configFilePath) => {
+const parseTsconfigFile = (configFilePath, probedPaths) => {
+	recordContentProbe(configFilePath);
+	probedPaths.push(configFilePath);
 	let sourceText;
 	try {
 		sourceText = fs.readFileSync(configFilePath, "utf8");
@@ -17025,8 +17068,8 @@ const parsePathsField = (pathsField) => {
 	}
 	return paths;
 };
-const readResolvedTsconfig = (configFilePath, extendsDepth) => {
-	const parsed = parseTsconfigFile(configFilePath);
+const readResolvedTsconfig = (configFilePath, extendsDepth, probedPaths) => {
+	const parsed = parseTsconfigFile(configFilePath, probedPaths);
 	if (!parsed) return null;
 	const configDirectory = path.dirname(configFilePath);
 	const compilerOptions = isObjectRecord(parsed.compilerOptions) ? parsed.compilerOptions : {};
@@ -17040,7 +17083,7 @@ const readResolvedTsconfig = (configFilePath, extendsDepth) => {
 	};
 	if (typeof parsed.extends === "string" && extendsDepth < 8) {
 		const parentPath = resolveExtendsPath(parsed.extends, configDirectory);
-		const inherited = parentPath ? readResolvedTsconfig(parentPath, extendsDepth + 1) : null;
+		const inherited = parentPath ? readResolvedTsconfig(parentPath, extendsDepth + 1, probedPaths) : null;
 		if (inherited) return inherited;
 	}
 	return hasExplicitBaseUrl ? {
@@ -17051,6 +17094,7 @@ const readResolvedTsconfig = (configFilePath, extendsDepth) => {
 };
 const configByFilePath = /* @__PURE__ */ new Map();
 const loadTsconfigCached = (configFilePath) => {
+	recordContentProbe(configFilePath);
 	let fileStat;
 	try {
 		fileStat = fs.statSync(configFilePath);
@@ -17058,11 +17102,16 @@ const loadTsconfigCached = (configFilePath) => {
 		return null;
 	}
 	const cached = configByFilePath.get(configFilePath);
-	if (cached && cached.mtimeMs === fileStat.mtimeMs) return cached.config;
-	const config = readResolvedTsconfig(configFilePath, 0);
+	if (cached && cached.mtimeMs === fileStat.mtimeMs) {
+		for (const probedPath of cached.probedChainPaths) recordContentProbe(probedPath);
+		return cached.config;
+	}
+	const probedChainPaths = [];
+	const config = readResolvedTsconfig(configFilePath, 0, probedChainPaths);
 	configByFilePath.set(configFilePath, {
 		mtimeMs: fileStat.mtimeMs,
-		config
+		config,
+		probedChainPaths
 	});
 	return config;
 };
@@ -18909,10 +18958,23 @@ const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
 const findNearestPackageDirectory = (filename) => {
 	if (!filename) return null;
 	const fromCache = cachedPackageDirectoryByFilename.get(filename);
-	if (fromCache !== void 0) return fromCache;
+	if (fromCache !== void 0) {
+		if (isProbeRecorderActive()) {
+			let probedDirectory = path.dirname(filename);
+			while (true) {
+				recordExistenceProbe(path.join(probedDirectory, "package.json"));
+				if (probedDirectory === fromCache) break;
+				const parentDirectory = path.dirname(probedDirectory);
+				if (parentDirectory === probedDirectory) break;
+				probedDirectory = parentDirectory;
+			}
+		}
+		return fromCache;
+	}
 	let currentDirectory = path.dirname(filename);
 	while (true) {
 		const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
+		recordExistenceProbe(candidatePackageJsonPath);
 		let hasPackageJson = false;
 		try {
 			hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
@@ -18975,6 +19037,7 @@ const isWebFrameworkOnly = (packageJson) => {
 const classifyPackagePlatform = (filename) => {
 	const packageDirectory = findNearestPackageDirectory(filename);
 	if (!packageDirectory) return "unknown";
+	recordContentProbe(path.join(packageDirectory, "package.json"));
 	const cached = cachedPlatformByPackageDirectory.get(packageDirectory);
 	if (cached !== void 0) return cached;
 	const packageJson = readPackageJsonSafe(path.join(packageDirectory, "package.json"));
@@ -47486,6 +47549,178 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"rn-prefer-expo-image"
 ]);
 //#endregion
+//#region src/plugin/cross-file-dependencies.ts
+const flattenImportEntries = (staticImports) => {
+	const flattened = [];
+	for (const staticImport of staticImports) for (const entry of staticImport.entries) {
+		if (entry.importName.kind === "NamespaceObject") continue;
+		const exportedName = entry.importName.kind === "Default" ? "default" : entry.importName.name ?? null;
+		if (exportedName === null) continue;
+		flattened.push({
+			source: staticImport.moduleRequest.value,
+			exportedName
+		});
+	}
+	return flattened;
+};
+const collectNoBarrelImportDependencies = ({ absoluteFilePath, staticImports }) => {
+	let didProbePackagePlatform = false;
+	for (const staticImport of staticImports) {
+		const source = staticImport.moduleRequest.value;
+		if (!source.startsWith(".")) continue;
+		const runtimeEntries = staticImport.entries.filter((entry) => !entry.isType);
+		if (runtimeEntries.length === 0) continue;
+		const resolvedImportPath = resolveRelativeImportPath(absoluteFilePath, source);
+		if (!resolvedImportPath || !isBarrelIndexModule(resolvedImportPath)) continue;
+		if (!didProbePackagePlatform) {
+			didProbePackagePlatform = true;
+			classifyPackagePlatform(absoluteFilePath);
+		}
+		for (const entry of runtimeEntries) {
+			const importedName = entry.importName.kind === "Default" ? "default" : entry.importName.name;
+			if (importedName) resolveBarrelExportFilePath(resolvedImportPath, importedName);
+		}
+	}
+};
+const collectNextjsMissingMetadataDependencies = ({ absoluteFilePath }) => {
+	if (!PAGE_FILE_PATTERN.test(absoluteFilePath)) return;
+	if (INTERNAL_PAGE_PATH_PATTERN.test(absoluteFilePath)) return;
+	hasAncestorMetadataLayout(absoluteFilePath);
+};
+const collectNextjsSearchParamsDependencies = ({ absoluteFilePath, staticImports }) => {
+	if (!PAGE_OR_LAYOUT_FILE_PATTERN.test(absoluteFilePath)) return;
+	if (hasAncestorSuspenseLayout(absoluteFilePath)) return;
+	for (const entry of flattenImportEntries(staticImports)) resolveCrossFileFunctionExport(absoluteFilePath, entry.source, entry.exportedName);
+};
+const collectMutatingReducerDependencies = ({ absoluteFilePath, sourceText, staticImports, program }) => {
+	const namedUseReducerLocals = /* @__PURE__ */ new Set();
+	const reactObjectLocals = /* @__PURE__ */ new Set();
+	for (const staticImport of staticImports) {
+		if (staticImport.moduleRequest.value !== "react") continue;
+		for (const entry of staticImport.entries) if (entry.importName.kind === "Name" && entry.importName.name === "useReducer") namedUseReducerLocals.add(entry.localName.value);
+		else if (entry.importName.kind === "Default" || entry.importName.kind === "NamespaceObject") reactObjectLocals.add(entry.localName.value);
+	}
+	if (!(namedUseReducerLocals.size > 0 || reactObjectLocals.size > 0 && (sourceText.includes("useReducer") || sourceText.includes("\\u")))) return;
+	const identifierName = (node) => {
+		if (node?.type !== "Identifier") return null;
+		const { name } = node;
+		return typeof name === "string" ? name : null;
+	};
+	const isUseReducerCallee = (callee) => {
+		const calleeName = identifierName(callee);
+		if (calleeName !== null) return namedUseReducerLocals.has(calleeName);
+		if (callee.type !== "MemberExpression") return false;
+		const member = callee;
+		const objectName = identifierName(member.object);
+		return objectName !== null && reactObjectLocals.has(objectName) && identifierName(member.property) === "useReducer";
+	};
+	const reducerArgumentNames = /* @__PURE__ */ new Set();
+	walkAst(program, (node) => {
+		if (node.type !== "CallExpression") return;
+		const call = node;
+		if (!call.callee || !isUseReducerCallee(call.callee)) return;
+		const reducerArgument = call.arguments?.[0];
+		if (!reducerArgument) return;
+		const argumentName = identifierName(stripParenExpression(reducerArgument));
+		if (argumentName !== null) reducerArgumentNames.add(argumentName);
+	});
+	if (reducerArgumentNames.size === 0) return;
+	for (const staticImport of staticImports) for (const entry of staticImport.entries) {
+		if (entry.importName.kind === "NamespaceObject") continue;
+		if (!reducerArgumentNames.has(entry.localName.value)) continue;
+		const exportedName = entry.importName.kind === "Default" ? "default" : entry.importName.name;
+		if (exportedName) resolveCrossFileFunctionExport(absoluteFilePath, staticImport.moduleRequest.value, exportedName);
+	}
+};
+const collectJsxBoundaryNames = (program) => {
+	const jsxNames = /* @__PURE__ */ new Set();
+	walkAst(program, (node) => {
+		if (node.type !== "JSXOpeningElement") return;
+		const nameNode = node.name;
+		if (!nameNode) return;
+		if (nameNode.type === "JSXIdentifier") {
+			const name = nameNode.name;
+			if (typeof name === "string") jsxNames.add(name);
+		} else if (nameNode.type === "JSXMemberExpression") {
+			const property = nameNode.property;
+			if (property?.type === "JSXIdentifier" && typeof property.name === "string") jsxNames.add(property.name);
+		} else if (nameNode.type === "JSXNamespacedName") {
+			const namespace = nameNode.namespace;
+			if (typeof namespace?.name === "string") jsxNames.add(namespace.name);
+		}
+	});
+	return jsxNames;
+};
+const collectRnNoRawTextDependencies = ({ absoluteFilePath, staticImports, program }) => {
+	classifyPackagePlatform(absoluteFilePath);
+	const jsxNames = collectJsxBoundaryNames(program);
+	if (jsxNames.size === 0) return;
+	for (const staticImport of staticImports) for (const entry of staticImport.entries) {
+		if (entry.importName.kind === "NamespaceObject") continue;
+		if (!jsxNames.has(entry.localName.value)) continue;
+		const exportedName = entry.importName.kind === "Default" ? "default" : entry.importName.name;
+		if (exportedName) resolveCrossFileFunctionExport(absoluteFilePath, staticImport.moduleRequest.value, exportedName);
+	}
+};
+const collectRnPreferExpoImageDependencies = ({ absoluteFilePath }) => {
+	classifyPackagePlatform(absoluteFilePath);
+};
+const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
+	["no-barrel-import", collectNoBarrelImportDependencies],
+	["nextjs-missing-metadata", collectNextjsMissingMetadataDependencies],
+	["nextjs-no-use-search-params-without-suspense", collectNextjsSearchParamsDependencies],
+	["no-mutating-reducer-state", collectMutatingReducerDependencies],
+	["rn-no-raw-text", collectRnNoRawTextDependencies],
+	["rn-prefer-expo-image", collectRnPreferExpoImageDependencies]
+]);
+/**
+* Cross-file rules whose dependency set CANNOT be soundly bounded — they are
+* excluded from fingerprinting and re-lint every file on every scan. Empty
+* today; a new cross-file rule must be added either here or to
+* `CROSS_FILE_DEPENDENCY_COLLECTORS` (the core guard test enforces the
+* partition), forcing a conscious classification.
+*/
+const UNBOUNDED_CROSS_FILE_RULE_IDS = /* @__PURE__ */ new Set();
+/**
+* Runs the collectors for `ruleIds` over one file and returns every
+* filesystem probe they made — the file's cross-file dependency set.
+*
+* Returns `null` (caller must treat the file as unfingerprintable and always
+* re-lint it) when the file has a fatal parse error — an execution the
+* collectors cannot mirror — or when a requested rule has no collector.
+*/
+const collectCrossFileDependencyProbes = (input) => {
+	const collectors = [];
+	for (const ruleId of input.ruleIds) {
+		const collector = CROSS_FILE_DEPENDENCY_COLLECTORS.get(ruleId);
+		if (!collector) return null;
+		collectors.push(collector);
+	}
+	const absoluteFilePath = normalizeFilename(input.absoluteFilePath);
+	let staticImports;
+	let program;
+	try {
+		const parseResult = parseSync(absoluteFilePath, input.sourceText, {
+			astType: "ts",
+			lang: resolveLang(absoluteFilePath)
+		});
+		if (parseResult.errors.some((parseError) => parseError.severity === "Error")) return null;
+		staticImports = parseResult.module.staticImports;
+		program = parseResult.program;
+	} catch {
+		return null;
+	}
+	const collectorInput = {
+		absoluteFilePath,
+		sourceText: input.sourceText,
+		staticImports,
+		program
+	};
+	return collectCrossFileProbes(() => {
+		for (const collector of collectors) collector(collectorInput);
+	});
+};
+//#endregion
 //#region src/plugin/rules/security-scan/utils/is-probably-text-file.ts
 const isProbablyTextFile = (relativePath) => TEXT_FILE_PATTERN.test(relativePath) || DOTENV_FILE_PATTERN.test(relativePath);
 //#endregion
@@ -47511,6 +47746,6 @@ const shouldReadSecurityScanContent = (relativePath, isGeneratedBundle) => isGen
 //#region src/index.ts
 var src_default = plugin;
 //#endregion
-export { ALL_REACT_DOCTOR_RULES, ALL_REACT_DOCTOR_RULE_KEYS, CROSS_FILE_RULE_IDS, EXTERNAL_RULES, FRAMEWORK_SPECIFIC_RULE_KEYS, MOTION_LIBRARY_PACKAGES, NEXTJS_RULES, PREACT_RULES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, REACT_NATIVE_DEPENDENCY_NAMES, REACT_NATIVE_DEPENDENCY_PREFIXES, REACT_NATIVE_RULES, RECOMMENDED_RULES, RULES, TANSTACK_QUERY_RULES, TANSTACK_START_RULES, classifySecurityScanFile, src_default as default, isReactNativeDependencyName, shouldReadSecurityScanContent };
+export { ALL_REACT_DOCTOR_RULES, ALL_REACT_DOCTOR_RULE_KEYS, CROSS_FILE_DEPENDENCY_COLLECTORS, CROSS_FILE_RULE_IDS, EXTERNAL_RULES, FRAMEWORK_SPECIFIC_RULE_KEYS, MOTION_LIBRARY_PACKAGES, NEXTJS_RULES, PREACT_RULES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, REACT_NATIVE_DEPENDENCY_NAMES, REACT_NATIVE_DEPENDENCY_PREFIXES, REACT_NATIVE_RULES, RECOMMENDED_RULES, RULES, TANSTACK_QUERY_RULES, TANSTACK_START_RULES, UNBOUNDED_CROSS_FILE_RULE_IDS, classifySecurityScanFile, collectCrossFileDependencyProbes, src_default as default, isReactNativeDependencyName, shouldReadSecurityScanContent };
 
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.6.3-dev.8325343",
+  "version": "0.6.3-dev.bdf8074",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",