oxlint-plugin-react-doctor 0.7.5-dev.0f07133 → 0.7.5-dev.18e8717

package/dist/index.js

@@ -1,14 +1,11 @@
+import { KEYS } from "eslint-visitor-keys";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { readFileSync } from "node:fs";
-import { parseSync } from "oxc-parser";
+import { parseSync, visitorKeys } from "oxc-parser";
 import { analyze } from "eslint-scope";
-import * as eslintVisitorKeys from "eslint-visitor-keys";
-//#region src/plugin/utils/has-type-property.ts
-const hasTypeProperty = (value) => Boolean(value && typeof value === "object" && "type" in value);
-//#endregion
 //#region src/plugin/utils/is-node-of-type.ts
-const isNodeOfType = (node, type) => Boolean(hasTypeProperty(node) && node.type === type);
+const isNodeOfType = (node, type) => node !== null && typeof node === "object" && "type" in node && node.type === type;
 //#endregion
 //#region src/plugin/utils/non-react-jsx-dialect.ts
 const NON_REACT_JSX_DIALECT_PACKAGES = new Set([
@@ -565,7 +562,8 @@ const REACT_RUNTIME_MODULE_SOURCES = new Set([
 	"react",
 	"react-dom",
 	"preact/compat",
-	"preact/hooks"
+	"preact/hooks",
+	"@wordpress/element"
 ]);
 const REACT_ECOSYSTEM_PACKAGE_NAMES = new Set([
 	"next",
@@ -802,24 +800,55 @@ const isHookCall$2 = (node, hookName) => {
 };
 //#endregion
 //#region src/plugin/utils/is-ast-node.ts
-const isAstNode = (value) => {
-	if (!hasTypeProperty(value)) return false;
-	return typeof value.type === "string";
+const isAstNode = (value) => value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+//#endregion
+//#region src/plugin/utils/runtime-visitor-keys.ts
+const RUNTIME_VISITOR_KEYS = {
+	...KEYS,
+	ArrayPattern: ["decorators", ...KEYS.ArrayPattern],
+	AssignmentPattern: ["decorators", ...KEYS.AssignmentPattern],
+	ClassDeclaration: ["decorators", ...KEYS.ClassDeclaration],
+	ClassExpression: ["decorators", ...KEYS.ClassExpression],
+	Identifier: ["decorators", ...KEYS.Identifier],
+	MethodDefinition: ["decorators", ...KEYS.MethodDefinition],
+	ObjectPattern: ["decorators", ...KEYS.ObjectPattern],
+	PropertyDefinition: ["decorators", ...KEYS.PropertyDefinition],
+	RestElement: ["decorators", ...KEYS.RestElement]
 };
 //#endregion
 //#region src/plugin/utils/walk-ast.ts
-const walkAst = (node, visitor) => {
-	if (!node || typeof node !== "object") return;
-	if (visitor(node) === false) return;
+const forEachChildNode = (node, visit) => {
 	const nodeRecord = node;
-	for (const key of Object.keys(nodeRecord)) {
-		if (key === "parent") continue;
+	const childKeys = RUNTIME_VISITOR_KEYS[node.type];
+	if (childKeys !== void 0) {
+		for (let keyIndex = 0; keyIndex < childKeys.length; keyIndex += 1) {
+			const child = nodeRecord[childKeys[keyIndex]];
+			if (Array.isArray(child)) for (let itemIndex = 0; itemIndex < child.length; itemIndex += 1) {
+				const item = child[itemIndex];
+				if (isAstNode(item)) visit(item);
+			}
+			else if (isAstNode(child)) visit(child);
+		}
+		return;
+	}
+	for (const key in nodeRecord) {
+		if (key === "parent" || !Object.hasOwn(nodeRecord, key)) continue;
 		const child = nodeRecord[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (isAstNode(item)) walkAst(item, visitor);
-		} else if (isAstNode(child)) walkAst(child, visitor);
+		if (Array.isArray(child)) for (let itemIndex = 0; itemIndex < child.length; itemIndex += 1) {
+			const item = child[itemIndex];
+			if (isAstNode(item)) visit(item);
+		}
+		else if (isAstNode(child)) visit(child);
 	}
 };
+const walkAst = (node, visitor) => {
+	if (!node || typeof node !== "object") return;
+	const visitNode = (current) => {
+		if (visitor(current) === false) return;
+		forEachChildNode(current, visitNode);
+	};
+	visitNode(node);
+};
 //#endregion
 //#region src/plugin/rules/state-and-effects/activity-wraps-effect-heavy-subtree.ts
 const ACTIVITY_IMPORTED_NAMES = new Set(["Activity", "unstable_Activity"]);
@@ -1262,7 +1291,7 @@ const REGEX_PRECEDING_KEYWORDS = new Set([
 	"await",
 	"throw"
 ]);
-const isRegexLiteralStart = (characters, slashIndex) => {
+const isRegexLiteralStart = (content, characters, slashIndex) => {
 	let cursor = slashIndex - 1;
 	while (cursor >= 0 && WHITESPACE_PATTERN.test(characters[cursor])) cursor -= 1;
 	if (cursor < 0) return true;
@@ -1272,7 +1301,7 @@ const isRegexLiteralStart = (characters, slashIndex) => {
 		let wordStartIndex = cursor;
 		while (wordStartIndex > 0 && IDENTIFIER_CHARACTER_PATTERN.test(characters[wordStartIndex - 1])) wordStartIndex -= 1;
 		if (wordStartIndex > 0 && characters[wordStartIndex - 1] === ".") return false;
-		return REGEX_PRECEDING_KEYWORDS.has(characters.slice(wordStartIndex, cursor + 1).join(""));
+		return REGEX_PRECEDING_KEYWORDS.has(content.slice(wordStartIndex, cursor + 1));
 	}
 	if (previousCharacter === "<") return false;
 	if (previousCharacter === ">") return characterBefore === "=";
@@ -1313,13 +1342,15 @@ const quotedLiteralHasWhitespace = (content, openQuoteIndex, delimiter) => {
 	return false;
 };
 const blankNonCodePreservingPositions = (content, blankStringContents) => {
-	const characters = content.split("");
+	let characters = null;
 	let stringDelimiter = null;
 	let isBlankingString = false;
 	const templateExpressionDepths = [];
 	let index = 0;
 	const blankUnlessNewline = (offset) => {
-		if (offset < content.length && content[offset] !== "\n") characters[offset] = " ";
+		if (offset >= content.length || content[offset] === "\n") return;
+		characters ??= content.split("");
+		characters[offset] = " ";
 	};
 	while (index < content.length) {
 		const character = content[index];
@@ -1366,6 +1397,7 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 			continue;
 		}
 		if (character === "/" && nextCharacter === "/") {
+			characters ??= content.split("");
 			while (index < content.length && content[index] !== "\n") {
 				characters[index] = " ";
 				index += 1;
@@ -1373,6 +1405,7 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 			continue;
 		}
 		if (character === "/" && nextCharacter === "*") {
+			characters ??= content.split("");
 			while (index < content.length) {
 				if (content[index] === "*" && content[index + 1] === "/") {
 					characters[index] = " ";
@@ -1386,7 +1419,7 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 			continue;
 		}
 		if (character === "/") {
-			const regexEndIndex = isRegexLiteralStart(characters, index) ? findRegexLiteralEnd(content, index) : null;
+			const regexEndIndex = isRegexLiteralStart(content, characters ?? content, index) ? findRegexLiteralEnd(content, index) : null;
 			if (regexEndIndex !== null) {
 				if (blankStringContents) for (let interiorIndex = index + 1; interiorIndex < regexEndIndex - 1; interiorIndex += 1) blankUnlessNewline(interiorIndex);
 				index = regexEndIndex;
@@ -1404,9 +1437,9 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 		}
 		index += 1;
 	}
-	return characters.join("");
+	return characters?.join("") ?? content;
 };
-const stripCommentsPreservingPositions = (content) => blankNonCodePreservingPositions(content, false);
+const stripCommentsPreservingPositions = (content) => content.includes("//") || content.includes("/*") ? blankNonCodePreservingPositions(content, false) : content;
 const stripCommentsAndStringLiteralsPreservingPositions = (content) => blankNonCodePreservingPositions(content, true);
 //#endregion
 //#region src/plugin/rules/security-scan/utils/scan-by-pattern.ts
@@ -1425,10 +1458,15 @@ const scanByPattern = ({ shouldScan, pattern, requireAll, suppressWhen, ignoreSt
 	if (!shouldScan(file)) return [];
 	const content = getScannableContent(file, ignoreStringLiterals);
 	if (requireAll !== void 0 && !requireAll.every((gate) => gate.test(content))) return [];
-	const matchedPattern = (pattern instanceof RegExp ? [pattern] : pattern).find((candidate) => candidate.test(content));
-	if (matchedPattern === void 0) return [];
+	let matchIndex = -1;
+	if (pattern instanceof RegExp) matchIndex = content.search(pattern);
+	else for (let patternIndex = 0; patternIndex < pattern.length; patternIndex += 1) {
+		matchIndex = content.search(pattern[patternIndex]);
+		if (matchIndex >= 0) break;
+	}
+	if (matchIndex < 0) return [];
 	if (suppressWhen !== void 0 && suppressWhen.test(content)) return [];
-	const { line, column } = getMatchLocation(content, matchedPattern);
+	const { line, column } = getLocationAtIndex(content, matchIndex);
 	return [{
 		message,
 		line,
@@ -1438,6 +1476,7 @@ const scanByPattern = ({ shouldScan, pattern, requireAll, suppressWhen, ignoreSt
 //#endregion
 //#region src/plugin/rules/security-scan/agent-tool-capability-risk.ts
 const AGENT_TOOL_DEFINITION_PATTERN = /\b(?:tool\s*\(\s*\{|createTool\s*\(|defineTool\s*\(|new\s+(?:DynamicTool|StructuredTool)\s*\()/;
+const AGENT_TOOL_DEFINITION_PREFILTER_PATTERN = /\b(?:tool|createTool|defineTool|DynamicTool|StructuredTool)\b/;
 const AGENT_TOOL_CONTEXT_PATH_PATTERN = /(?:^|\/)(?:agents?|tools?|mcp)(?:\/|$)|(?:agent|tool|mcp)[^/]*\.[cm]?[jt]sx?$/i;
 const agentToolCapabilityRisk = defineRule({
 	id: "agent-tool-capability-risk",
@@ -1445,7 +1484,7 @@ const agentToolCapabilityRisk = defineRule({
 	severity: "warn",
 	recommendation: "Treat tool inputs as prompt-injection controlled. Validate arguments, scope permissions per call, and avoid exposing shell/file/network primitives directly to agents.",
 	scan: scanByPattern({
-		shouldScan: (file) => isProductionSourcePath(file.relativePath) && AGENT_TOOL_CONTEXT_PATH_PATTERN.test(file.relativePath),
+		shouldScan: (file) => isProductionSourcePath(file.relativePath) && AGENT_TOOL_CONTEXT_PATH_PATTERN.test(file.relativePath) && AGENT_TOOL_DEFINITION_PREFILTER_PATTERN.test(file.content) && AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN.test(file.content),
 		pattern: AGENT_TOOL_DEFINITION_PATTERN,
 		requireAll: [AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN],
 		ignoreStringLiterals: true,
@@ -7398,7 +7437,7 @@ const containsJsx$1 = (root) => {
 	containsJsxCache.set(root, found);
 	return found;
 };
-const getStaticMemberName$1 = (node) => {
+const getStaticMemberName$2 = (node) => {
 	if (!isNodeOfType(node, "MemberExpression")) return null;
 	if (!node.computed && isNodeOfType(node.property, "Identifier")) return node.property.name;
 	if (node.computed && isNodeOfType(node.property, "Literal") && typeof node.property.value === "string") return node.property.value;
@@ -7412,7 +7451,7 @@ const getAssignedName = (node) => {
 	if (isNodeOfType(parent, "AssignmentExpression")) {
 		const left = parent.left;
 		if (isNodeOfType(left, "Identifier")) return left.name;
-		if (isNodeOfType(left, "MemberExpression")) return getStaticMemberName$1(left);
+		if (isNodeOfType(left, "MemberExpression")) return getStaticMemberName$2(left);
 	}
 	return null;
 };
@@ -7420,20 +7459,20 @@ const isModuleExportsAssignment = (node) => {
 	const parent = node.parent;
 	if (!parent || !isNodeOfType(parent, "AssignmentExpression")) return false;
 	const left = parent.left;
-	return isNodeOfType(left, "MemberExpression") && isNodeOfType(left.object, "Identifier") && left.object.name === "module" && getStaticMemberName$1(left) === "exports";
+	return isNodeOfType(left, "MemberExpression") && isNodeOfType(left.object, "Identifier") && left.object.name === "module" && getStaticMemberName$2(left) === "exports";
 };
 const isCreateClassLikeCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	if (isEs5Component(node)) return true;
 	const callee = node.callee;
-	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName$1(callee) === "createClass";
+	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName$2(callee) === "createClass";
 	return false;
 };
 const isCreateContextCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	const callee = node.callee;
 	if (isNodeOfType(callee, "Identifier")) return callee.name === "createContext";
-	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName$1(callee) === "createContext";
+	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName$2(callee) === "createContext";
 };
 const isNamedFunctionLike = (node) => (isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && Boolean(node.id?.name);
 const firstCallArgument = (node) => {
@@ -7491,7 +7530,7 @@ const memberExpressionPath = (node) => {
 	if (isNodeOfType(node, "Identifier")) return [node.name];
 	if (!isNodeOfType(node, "MemberExpression")) return [];
 	const objectPath = memberExpressionPath(node.object);
-	const propertyName = getStaticMemberName$1(node);
+	const propertyName = getStaticMemberName$2(node);
 	return propertyName ? [...objectPath, propertyName] : objectPath;
 };
 const displayNameAssignmentIndexCache = /* @__PURE__ */ new WeakMap();
@@ -7501,7 +7540,7 @@ const getDisplayNameAssignmentIndex = (programRoot) => {
 	const identifierTargets = /* @__PURE__ */ new Set();
 	const memberPathSegments = /* @__PURE__ */ new Set();
 	const visit = (node) => {
-		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName$1(node.left) === "displayName") {
+		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName$2(node.left) === "displayName") {
 			if (isNodeOfType(node.left.object, "Identifier")) identifierTargets.add(node.left.object.name);
 			for (const segment of memberExpressionPath(node.left.object)) memberPathSegments.add(segment);
 		}
@@ -7696,7 +7735,7 @@ const includesApiName = (apiNames, apiName) => typeof apiNames === "string" ? ap
 const isImportedFromReact = (symbol) => {
 	if (symbol.kind !== "import") return false;
 	const importDeclaration = symbol.declarationNode.parent;
-	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react");
+	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && typeof importDeclaration.source.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(importDeclaration.source.value));
 };
 const isNamedReactApiImport = (identifier, apiNames, scopes) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
@@ -9646,6 +9685,11 @@ const walkParameterReferences = (pattern, state) => {
 const walk = (node, state) => {
 	if (isFunctionLike$1(node)) {
 		if (isNodeOfType(node, "FunctionDeclaration") && node.id) handleFunctionDeclaration(node, state);
+		const functionParams = node.params ?? [];
+		for (const param of functionParams) {
+			if (!("decorators" in param) || !Array.isArray(param.decorators)) continue;
+			for (const decorator of param.decorators) if (isAstNode(decorator)) walk(decorator, state);
+		}
 		setNodeScope(node, state);
 		const fnScope = pushScope(node.type === "ArrowFunctionExpression" ? "arrow-function" : "function", node, state);
 		if ((isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && node.id) {
@@ -9658,7 +9702,6 @@ const walk = (node, state) => {
 			});
 			tagAsBinding(state, node.id);
 		}
-		const functionParams = node.params ?? [];
 		handleFunctionParameters(functionParams, fnScope, state);
 		for (const param of functionParams) walkParameterReferences(param, state);
 		const body = node.body;
@@ -9668,6 +9711,9 @@ const walk = (node, state) => {
 	}
 	if (isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression")) {
 		if (isNodeOfType(node, "ClassDeclaration") && node.id) handleClassDeclaration(node, state);
+		if (Array.isArray(node.decorators)) {
+			for (const decorator of node.decorators) if (isAstNode(decorator)) walk(decorator, state);
+		}
 		const classScope = pushScope("class", node, state);
 		setNodeScope(node, state);
 		if (isNodeOfType(node, "ClassExpression") && node.id) {
@@ -9870,7 +9916,7 @@ const computeClosureCaptures = (functionNode, scopes) => {
 	const functionScope = scopes.ownScopeFor(functionNode) ?? scopes.scopeFor(functionNode);
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
-	const visit = (node) => {
+	walkAst(functionNode, (node) => {
 		if (node !== functionNode && isFunctionLike$1(node)) {
 			const innerCaptures = closureCaptures(node, scopes);
 			for (const reference of innerCaptures) if (reference.resolvedSymbol && !isDescendantScope(reference.resolvedSymbol.scope, functionScope)) {
@@ -9879,7 +9925,7 @@ const computeClosureCaptures = (functionNode, scopes) => {
 					seen.add(reference.id);
 				}
 			}
-			return;
+			return false;
 		}
 		const reference = scopes.referenceFor(node);
 		if (reference && reference.resolvedSymbol) {
@@ -9890,17 +9936,7 @@ const computeClosureCaptures = (functionNode, scopes) => {
 				}
 			}
 		}
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			if (TYPE_POSITION_CHILD_KEYS.has(key)) continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-		}
-	};
-	visit(functionNode);
+	});
 	return out;
 };
 const capturesByAnalysis = /* @__PURE__ */ new WeakMap();
@@ -14220,7 +14256,11 @@ const jsIndexMaps = defineRule({
 //#region src/plugin/utils/are-expressions-structurally-equal.ts
 const areExpressionsStructurallyEqual = (a, b) => {
 	if (!a || !b) return a === b;
+	const unwrappedA = stripParenExpression(a);
+	const unwrappedB = stripParenExpression(b);
+	if (unwrappedA !== a || unwrappedB !== b) return areExpressionsStructurallyEqual(unwrappedA, unwrappedB);
 	if (a.type !== b.type) return false;
+	if (isNodeOfType(a, "ThisExpression")) return true;
 	if (isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier")) return a.name === b.name;
 	if (isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal")) return a.value === b.value;
 	if (isNodeOfType(a, "MemberExpression") && isNodeOfType(b, "MemberExpression")) {
@@ -18924,6 +18964,7 @@ const jwtInsecureVerification = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/security-scan/key-lifecycle-risk.ts
+const KEY_MATERIAL_MARKER_PATTERN = /PRIVATE KEY|SSH_PRIVATE_KEY|GPG_PRIVATE_KEY|DEPLOY_KEY|SIGNING_KEY/i;
 const keyLifecycleRisk = defineRule({
 	id: "key-lifecycle-risk",
 	title: "Long-lived key material in repository",
@@ -18931,7 +18972,7 @@ const keyLifecycleRisk = defineRule({
 	committedFilesOnly: true,
 	recommendation: "Remove private keys from source, rotate exposed credentials, prefer short-lived deploy credentials, and document revocation/expiry for release keys.",
 	scan: scanByPattern({
-		shouldScan: (file) => !TEST_CONTEXT_PATTERN.test(file.relativePath) && !DOCUMENTATION_CONTEXT_PATTERN.test(file.relativePath),
+		shouldScan: (file) => !TEST_CONTEXT_PATTERN.test(file.relativePath) && !DOCUMENTATION_CONTEXT_PATTERN.test(file.relativePath) && KEY_MATERIAL_MARKER_PATTERN.test(file.content),
 		pattern: /(?<!(?:placeholder|example|sample|dummy|fake)[\s\S]{0,40})-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----(?:\s|\\r|\\n)*[A-Za-z0-9+/=][A-Za-z0-9+/=\s]{38,}(?![^-]{0,160}\.\.\.)|\b(?:SSH_PRIVATE_KEY|GPG_PRIVATE_KEY|DEPLOY_KEY|SIGNING_KEY)\b\s*[:=]\s*["'][^"'\n]{16,}["']/i,
 		message: "Private or long-lived release key material appears in the repository."
 	})
@@ -19637,15 +19678,21 @@ const localRpcNativeBridgeRisk = defineRule({
 		message: "Code appears to bridge browser code to localhost/native capabilities with weak origin or update/install checks."
 	})
 });
+//#endregion
+//#region src/plugin/rules/security-scan/mcp-tool-capability-risk.ts
+const MCP_IMPORT_PATTERN = /\bfrom\s+["']@modelcontextprotocol\/sdk[^"']*["']|\bMcpServer\b|\bMcpAgent\b/;
+const MCP_IMPORT_PREFILTER_PATTERN = /@modelcontextprotocol\/sdk|\bMcpServer\b|\bMcpAgent\b/;
+const MCP_TOOL_SURFACE_PATTERN = /\bserver\.\s*tool\s*\(|\bregisterTool\s*\(|\bsetRequestHandler\s*\(\s*CallToolRequestSchema/;
+const MCP_TOOL_SURFACE_PREFILTER_PATTERN = /\b(?:tool|registerTool|setRequestHandler)\b/;
 const mcpToolCapabilityRisk = defineRule({
 	id: "mcp-tool-capability-risk",
 	title: "MCP tool exposes dangerous capability",
 	severity: "warn",
 	recommendation: "MCP tool calls run with the connecting client's authority. Validate inputs, enforce per-tool authorization, and avoid raw filesystem/shell/network access where possible.",
 	scan: scanByPattern({
-		shouldScan: (file) => isProductionSourcePath(file.relativePath),
-		pattern: /\bserver\.\s*tool\s*\(|\bregisterTool\s*\(|\bsetRequestHandler\s*\(\s*CallToolRequestSchema/,
-		requireAll: [/\bfrom\s+["']@modelcontextprotocol\/sdk[^"']*["']|\bMcpServer\b|\bMcpAgent\b/, AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN],
+		shouldScan: (file) => isProductionSourcePath(file.relativePath) && MCP_IMPORT_PREFILTER_PATTERN.test(file.content) && MCP_TOOL_SURFACE_PREFILTER_PATTERN.test(file.content) && AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN.test(file.content),
+		pattern: MCP_TOOL_SURFACE_PATTERN,
+		requireAll: [MCP_IMPORT_PATTERN, AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN],
 		ignoreStringLiterals: true,
 		message: "An MCP tool/resource/prompt handler appears to expose file, shell, network, or code-execution capability."
 	})
@@ -20756,8 +20803,8 @@ const catchClauseRethrowsCaught = (handler) => {
 	return didRethrow;
 };
 //#endregion
-//#region src/plugin/utils/find-guarding-try-statement.ts
-const isImmediatelyInvokedFunctionCallee = (functionNode) => {
+//#region src/plugin/utils/is-immediately-invoked-function.ts
+const isImmediatelyInvokedFunction = (functionNode) => {
 	let wrappedCallee = functionNode;
 	let enclosing = functionNode.parent;
 	while (enclosing && stripParenExpression(enclosing) === functionNode) {
@@ -20766,11 +20813,13 @@ const isImmediatelyInvokedFunctionCallee = (functionNode) => {
 	}
 	return Boolean(enclosing && isNodeOfType(enclosing, "CallExpression") && enclosing.callee === wrappedCallee);
 };
+//#endregion
+//#region src/plugin/utils/find-guarding-try-statement.ts
 const findGuardingTryStatement = (node) => {
 	let child = node;
 	let ancestor = node.parent;
 	while (ancestor) {
-		if (isFunctionLike$1(ancestor) && !isImmediatelyInvokedFunctionCallee(ancestor)) return null;
+		if (isFunctionLike$1(ancestor) && !isImmediatelyInvokedFunction(ancestor)) return null;
 		if (isNodeOfType(ancestor, "TryStatement") && ancestor.block === child && ancestor.handler && !catchClauseRethrowsCaught(ancestor.handler)) return ancestor;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
@@ -21322,7 +21371,7 @@ const FILENAME_TO_LANG = {
 const resolveLang = (filename) => {
 	return FILENAME_TO_LANG[path.extname(filename).toLowerCase()] ?? "tsx";
 };
-const parseSourceText = (filename, sourceText) => {
+const parseSourceText = ({ filename, sourceText, shouldAttachParentReferences = true }) => {
 	try {
 		const result = parseSync(filename, sourceText, {
 			astType: "ts",
@@ -21330,7 +21379,7 @@ const parseSourceText = (filename, sourceText) => {
 		});
 		if (result.errors.some((parseError) => parseError.severity === "Error")) return null;
 		const parsedProgram = result.program;
-		attachParentReferences(parsedProgram);
+		if (shouldAttachParentReferences) attachParentReferences(parsedProgram);
 		return parsedProgram;
 	} catch {
 		return null;
@@ -21368,7 +21417,10 @@ const parseSourceFile = (absoluteFilePath) => {
 		});
 		return null;
 	}
-	const parsedProgram = parseSourceText(absoluteFilePath, sourceText);
+	const parsedProgram = parseSourceText({
+		filename: absoluteFilePath,
+		sourceText
+	});
 	parseCache.set(absoluteFilePath, {
 		mtimeMs: fileStat.mtimeMs,
 		size: fileStat.size,
@@ -21900,6 +21952,8 @@ const DOM_QUERY_MEMBER_NAMES = new Set([
 ]);
 const LAYOUT_MEASUREMENT_MEMBER_NAMES = new Set([
 	"current",
+	"textContent",
+	"innerText",
 	"scrollWidth",
 	"clientWidth",
 	"offsetWidth",
@@ -21921,7 +21975,7 @@ const POST_MOUNT_GLOBAL_NAMES = new Set([
 	"navigator"
 ]);
 const REF_FACTORY_CALLEE_NAMES = new Set(["useRef", "createRef"]);
-const hasRefLikeName = (name) => name === "ref" || name.endsWith("Ref") || name.endsWith("ref");
+const hasRefLikeName = (name) => name === "ref" || name.endsWith("Ref") || name.endsWith("ref") || name.endsWith("Node") || name.endsWith("node") || name.endsWith("Element") || name.endsWith("element");
 const isRefFactoryInitializer = (init) => {
 	if (!init || !isNodeOfType(init, "CallExpression")) return false;
 	const callee = init.callee;
@@ -22004,88 +22058,37 @@ const readsPostMountValue = (root) => {
 	return found;
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/effect/constants.ts
-const TYPESCRIPT_VISITOR_KEYS = {
-	TSAsExpression: ["expression", "typeAnnotation"],
-	TSNonNullExpression: ["expression"],
-	TSSatisfiesExpression: ["expression", "typeAnnotation"],
-	TSTypeAssertion: ["typeAnnotation", "expression"],
-	TSInstantiationExpression: ["expression", "typeArguments"]
-};
-const VISITOR_KEYS = {
-	...eslintVisitorKeys.KEYS,
-	...TYPESCRIPT_VISITOR_KEYS
-};
+//#region src/plugin/rules/state-and-effects/utils/effect/get-ast-child-keys.ts
+const getAstChildKeys = (node) => visitorKeys[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/get-program-analysis.ts
 const programToAnalysis = /* @__PURE__ */ new WeakMap();
-const stripAndRecordParents = (root) => {
-	const restorations = [];
-	const seen = /* @__PURE__ */ new WeakSet();
-	const visit = (value) => {
-		if (!value || typeof value !== "object") return;
-		if (seen.has(value)) return;
-		seen.add(value);
-		if (Array.isArray(value)) {
-			for (const item of value) visit(item);
-			return;
-		}
-		const record = value;
-		if (!("type" in record)) return;
-		if ("parent" in record) {
-			restorations.push({
-				node: record,
-				originalParent: record.parent
-			});
-			record.parent = null;
-		}
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			visit(record[key]);
-		}
-	};
-	visit(root);
-	return restorations;
-};
-const restoreParents = (restorations) => {
-	for (const restoration of restorations) restoration.node.parent = restoration.originalParent;
-};
 const getProgramAnalysis = (anyNode) => {
 	const programNode = findProgramRoot(anyNode);
 	if (!programNode) return null;
 	const cached = programToAnalysis.get(programNode);
 	if (cached) return cached;
-	const restorations = stripAndRecordParents(programNode);
-	let scopeManager;
-	try {
-		scopeManager = analyze(programNode, {
-			ecmaVersion: 2024,
-			sourceType: "module",
-			childVisitorKeys: VISITOR_KEYS,
-			fallback: "iteration"
-		});
-	} finally {
-		restoreParents(restorations);
-	}
 	const analysis = {
 		programNode,
-		scopeManager
+		scopeManager: analyze(programNode, {
+			ecmaVersion: 2024,
+			sourceType: "module",
+			childVisitorKeys: RUNTIME_VISITOR_KEYS,
+			fallback: getAstChildKeys
+		}),
+		scopeByNode: /* @__PURE__ */ new WeakMap(),
+		referenceByIdentifier: /* @__PURE__ */ new WeakMap()
 	};
 	programToAnalysis.set(programNode, analysis);
 	return analysis;
 };
-const scopeByNodeCache = /* @__PURE__ */ new WeakMap();
-const getScopeForNode = (node, manager) => {
+const getScopeForNode = (node, analysis) => {
 	if (!node.range) return null;
-	let scopeByNode = scopeByNodeCache.get(manager);
-	if (!scopeByNode) {
-		scopeByNode = /* @__PURE__ */ new WeakMap();
-		scopeByNodeCache.set(manager, scopeByNode);
-	}
+	const scopeByNode = analysis.scopeByNode;
 	if (scopeByNode.has(node)) return scopeByNode.get(node) ?? null;
 	let bestScope = null;
 	let bestSize = Infinity;
-	for (const scope of manager.scopes) {
+	for (const scope of analysis.scopeManager.scopes) {
 		const block = scope.block;
 		if (!block?.range) continue;
 		if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
@@ -22100,7 +22103,6 @@ const getScopeForNode = (node, manager) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/ast.ts
-const getChildKeys = (node) => VISITOR_KEYS[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
 const HOOK_NAME_PATTERN$2 = /^use[A-Z0-9]/;
 const isInsideCallbackArgumentOf = (identifier, initializer) => {
 	if (!isNodeOfType(initializer, "CallExpression") && !isNodeOfType(initializer, "NewExpression")) return false;
@@ -22136,7 +22138,7 @@ const descend = (node, visit, visited = /* @__PURE__ */ new Set()) => {
 	if (visited.has(node)) return;
 	visit(node);
 	visited.add(node);
-	const keys = getChildKeys(node);
+	const keys = getAstChildKeys(node);
 	const record = node;
 	for (const key of keys) {
 		const child = record[key];
@@ -22169,16 +22171,11 @@ const findDownstreamNodes = (topNode, type) => {
 	});
 	return nodes;
 };
-const refByIdentifierCache = /* @__PURE__ */ new WeakMap();
 const getRef = (analysis, identifier) => {
-	let refByIdentifier = refByIdentifierCache.get(analysis);
-	if (!refByIdentifier) {
-		refByIdentifier = /* @__PURE__ */ new WeakMap();
-		refByIdentifierCache.set(analysis, refByIdentifier);
-	}
+	const refByIdentifier = analysis.referenceByIdentifier;
 	if (refByIdentifier.has(identifier)) return refByIdentifier.get(identifier) ?? null;
 	let resolvedReference = null;
-	const scope = getScopeForNode(identifier, analysis.scopeManager);
+	const scope = getScopeForNode(identifier, analysis);
 	if (scope) {
 		for (const reference of scope.references) if (reference.identifier === identifier) {
 			resolvedReference = reference;
@@ -22426,7 +22423,7 @@ const isReactFunctionalHOC = (analysis, node) => {
 	const isWrappedSeparately = () => {
 		if (!isNodeOfType(node.id, "Identifier")) return false;
 		const bindingName = node.id.name;
-		const containingScope = getScopeForNode(node, analysis.scopeManager);
+		const containingScope = getScopeForNode(node, analysis);
 		if (!containingScope) return false;
 		const variable = containingScope.variables.find((v) => v.name === bindingName);
 		if (!variable) return false;
@@ -22657,11 +22654,14 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 	if (isNodeOfType(node, "ReturnStatement") && node.argument != null) return isCleanupReturnArgument(analysis, node.argument);
 	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$1(node)) return false;
 	const record = node;
-	for (const [key, value] of Object.entries(record)) {
-		if (key === "parent") continue;
-		if (Array.isArray(value)) {
-			if (value.some((item) => isAstNode(item) && hasCleanupReturn(analysis, item, visited))) return true;
-		} else if (isAstNode(value) && hasCleanupReturn(analysis, value, visited)) return true;
+	const childKeys = getAstChildKeys(node);
+	for (let keyIndex = 0; keyIndex < childKeys.length; keyIndex += 1) {
+		const value = record[childKeys[keyIndex]];
+		if (Array.isArray(value)) for (let itemIndex = 0; itemIndex < value.length; itemIndex += 1) {
+			const item = value[itemIndex];
+			if (isAstNode(item) && hasCleanupReturn(analysis, item, visited)) return true;
+		}
+		else if (isAstNode(value) && hasCleanupReturn(analysis, value, visited)) return true;
 	}
 	return false;
 };
@@ -22952,7 +22952,7 @@ const STORAGE_GLOBAL_NAMES$1 = new Set([
 	"localStorage",
 	"sessionStorage"
 ]);
-const getStaticMemberName = (node) => {
+const getStaticMemberName$1 = (node) => {
 	if (!isNodeOfType(node, "MemberExpression")) return null;
 	if (!node.computed && isNodeOfType(node.property, "Identifier")) return node.property.name;
 	if (node.computed && isNodeOfType(node.property, "Literal")) return typeof node.property.value === "string" ? node.property.value : null;
@@ -22967,7 +22967,7 @@ const getCallCalleeName$1 = (callExpression) => {
 	if (!isNodeOfType(callExpression, "CallExpression")) return null;
 	const callee = stripParenExpression(callExpression.callee);
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	return getStaticMemberName(callee);
+	return getStaticMemberName$1(callee);
 };
 const getFunctionParameters = (functionNode) => isFunctionLike$1(functionNode) ? functionNode.params ?? [] : [];
 const getIdentifierBindingIdentity = (analysis, identifier) => {
@@ -23083,14 +23083,14 @@ const localUseEventPreservesCallback = (analysis, callee) => {
 			if (!isNodeOfType(child, "CallExpression")) return;
 			const forwardedCallee = stripParenExpression(child.callee);
 			if (!isNodeOfType(forwardedCallee, "MemberExpression")) return;
-			if (getStaticMemberName(forwardedCallee) !== "current") return;
+			if (getStaticMemberName$1(forwardedCallee) !== "current") return;
 			if (!isNodeOfType(forwardedCallee.object, "Identifier")) return;
 			const refReference = getRef(analysis, forwardedCallee.object);
 			if (!callbackRefDeclarators.find((declarator) => refReference?.resolved?.defs.some((definition) => definition.node === declarator)) || !refReference?.resolved) return;
 			if (!refReference.resolved.references.some((candidateReference) => {
 				const memberExpression = candidateReference.identifier.parent;
 				const assignmentExpression = memberExpression?.parent;
-				if (!memberExpression || !isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName(memberExpression) !== "current" || !assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression") || assignmentExpression.left !== memberExpression) return false;
+				if (!memberExpression || !isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName$1(memberExpression) !== "current" || !assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression") || assignmentExpression.left !== memberExpression) return false;
 				return getIdentifierBindingIdentity(analysis, assignmentExpression.right) !== callbackBinding;
 			})) forwardsCallback = true;
 		});
@@ -23115,7 +23115,7 @@ const resolveWrappedCallable = (analysis, node) => {
 		return callback && isFunctionLike$1(callback) ? callback : null;
 	}
 	if (!isNodeOfType(candidate, "MemberExpression")) return null;
-	if (getStaticMemberName(candidate) !== "current") return null;
+	if (getStaticMemberName$1(candidate) !== "current") return null;
 	if (!isNodeOfType(candidate.object, "Identifier")) return null;
 	const reference = getRef(analysis, candidate.object);
 	const declarator = reference?.resolved?.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
@@ -23127,7 +23127,7 @@ const resolveWrappedCallable = (analysis, node) => {
 	return Boolean(reference?.resolved?.references.some((candidateReference) => {
 		const member = candidateReference.identifier.parent;
 		const assignment = member?.parent;
-		return Boolean(member && isNodeOfType(member, "MemberExpression") && getStaticMemberName(member) === "current" && assignment && isNodeOfType(assignment, "AssignmentExpression") && assignment.left === member);
+		return Boolean(member && isNodeOfType(member, "MemberExpression") && getStaticMemberName$1(member) === "current" && assignment && isNodeOfType(assignment, "AssignmentExpression") && assignment.left === member);
 	})) ? null : initializer;
 };
 const functionInvokesItself = (analysis, functionNode) => {
@@ -23166,7 +23166,7 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilena
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const callee = stripParenExpression(child.callee);
 		const calleeName = getCallCalleeName$1(child);
-		const memberName = getStaticMemberName(callee);
+		const memberName = getStaticMemberName$1(callee);
 		const isDeferringCall = calleeName !== null && DEFERRING_CALLEE_NAMES.has(calleeName) || memberName !== null && DEFERRING_MEMBER_NAMES.has(memberName);
 		const isIteratorCall = memberName !== null && SYNCHRONOUS_ITERATOR_METHOD_NAMES$1.has(memberName) && isNodeOfType(callee, "MemberExpression");
 		const enqueueFrame = (callableNode, argumentsForCallable, isDeferred, introducedBindings, allowWithoutInvocationEvidence = false) => {
@@ -23330,9 +23330,9 @@ const analyzeHelperExpression = (expression, environment, usedParameterIndices)
 		const calleeRoot = getMemberRoot(callee);
 		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && !environment.parameterIndices.has(callee.name) && !environment.recursiveNames.has(callee.name) && !environment.shadowedGlobalNames.has(callee.name);
 		const namespaceName = isNodeOfType(calleeRoot, "Identifier") && !environment.parameterIndices.has(calleeRoot.name) && !environment.recursiveNames.has(calleeRoot.name) && !environment.shadowedGlobalNames.has(calleeRoot.name) ? calleeRoot.name : null;
-		const namespaceMemberName = getStaticMemberName(callee);
+		const namespaceMemberName = getStaticMemberName$1(callee);
 		const isPureNamespaceCall = isNodeOfType(callee, "MemberExpression") && namespaceName !== null && namespaceMemberName !== null && PURE_HELPER_NAMESPACE_MEMBER_NAMES.get(namespaceName)?.has(namespaceMemberName) === true;
-		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
+		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName$1(callee) ?? "");
 		if (!isPureGlobalCall && !isPureNamespaceCall && !isPureMemberTransform) return false;
 		if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression") && !analyzeHelperExpression(callee.object, environment, usedParameterIndices)) return false;
 		return (node.arguments ?? []).every((argument) => analyzeHelperExpression(argument, environment, usedParameterIndices));
@@ -23406,7 +23406,7 @@ const isLocallyConstructedObjectMember = (reference, memberExpression) => isNode
 	return isNodeOfType(definitionNode, "VariableDeclarator") && Boolean(definitionNode.init) && (isNodeOfType(definitionNode.init, "ObjectExpression") || isNodeOfType(definitionNode.init, "ArrayExpression"));
 }) === true;
 const getUseRefDeclarator = (analysis, memberExpression) => {
-	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName(memberExpression) !== "current" || !isNodeOfType(memberExpression.object, "Identifier")) return null;
+	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName$1(memberExpression) !== "current" || !isNodeOfType(memberExpression.object, "Identifier")) return null;
 	return getRef(analysis, memberExpression.object)?.resolved?.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator") && isNodeOfType(definitionNode.init, "CallExpression") && getCallCalleeName$1(definitionNode.init) === "useRef") ?? null;
 };
 const collectValueEvidence = (analysis, expression, frame, remainingCallFrames, visitedBindings = /* @__PURE__ */ new Set()) => {
@@ -23475,7 +23475,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		return collectValueEvidence(analysis, initializer.init, frame, remainingCallFrames, visitedBindings);
 	}
 	if (isNodeOfType(node, "MemberExpression")) {
-		if (getStaticMemberName(node) === "current" && isNodeOfType(node.object, "Identifier")) {
+		if (getStaticMemberName$1(node) === "current" && isNodeOfType(node.object, "Identifier")) {
 			const refBinding = getRef(analysis, node.object)?.resolved;
 			const refDeclarator = useRefDeclarator;
 			if (refBinding && refDeclarator && isNodeOfType(refDeclarator, "VariableDeclarator") && isNodeOfType(refDeclarator.init, "CallExpression")) {
@@ -23491,7 +23491,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 					if (candidateReference.init) continue;
 					const identifier = candidateReference.identifier;
 					const member = identifier.parent;
-					if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== identifier || getStaticMemberName(member) !== "current") {
+					if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== identifier || getStaticMemberName$1(member) !== "current") {
 						evidence.hasUnknownSource = true;
 						continue;
 					}
@@ -23528,7 +23528,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		const callee = stripParenExpression(node.callee);
 		const calleeRoot = getMemberRoot(callee);
 		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && getIdentifierBindingIdentity(analysis, callee) === null || isNodeOfType(calleeRoot, "Identifier") && PURE_GLOBAL_NAMESPACE_NAMES.has(calleeRoot.name) && getIdentifierBindingIdentity(analysis, calleeRoot) === null;
-		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
+		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName$1(callee) ?? "");
 		if (isPureGlobalCall || isPureMemberTransform) {
 			if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression")) mergeEvidence(evidence, collectValueEvidence(analysis, callee.object, frame, remainingCallFrames, new Set(visitedBindings)));
 			for (const argument of node.arguments ?? []) {
@@ -24116,6 +24116,7 @@ const ARITHMETIC_KEY_OPERATORS = new Set([
 	"/",
 	"%"
 ]);
+const bindingMutationResultsByProgram = /* @__PURE__ */ new WeakMap();
 const extractCandidateIdentifiers = (expression) => {
 	const node = stripParenExpression(expression);
 	if (isNodeOfType(node, "Identifier")) return [node];
@@ -24156,6 +24157,13 @@ const isArrayFromCall = (node) => {
 const isBindingReassignedOrMutated = (referenceNode, bindingName) => {
 	const programRoot = findProgramRoot(referenceNode);
 	if (!programRoot) return false;
+	let mutationResultsByBindingName = bindingMutationResultsByProgram.get(programRoot);
+	if (!mutationResultsByBindingName) {
+		mutationResultsByBindingName = /* @__PURE__ */ new Map();
+		bindingMutationResultsByProgram.set(programRoot, mutationResultsByBindingName);
+	}
+	const cachedResult = mutationResultsByBindingName.get(bindingName);
+	if (cachedResult !== void 0) return cachedResult;
 	let didFindWrite = false;
 	walkAst(programRoot, (child) => {
 		if (didFindWrite) return false;
@@ -24172,6 +24180,7 @@ const isBindingReassignedOrMutated = (referenceNode, bindingName) => {
 			return false;
 		}
 	});
+	mutationResultsByBindingName.set(bindingName, didFindWrite);
 	return didFindWrite;
 };
 /**
@@ -25272,10 +25281,10 @@ const declaresAnyDependency = (manifest) => DEPENDENCY_SECTION_NAMES.some((secti
 	const section = manifest[sectionName];
 	return typeof section === "object" && section !== null && Object.keys(section).length > 0;
 });
-const declaresDependency = (manifest, dependencyName) => {
-	for (const declaredName of iterateDependencyNames(manifest)) if (declaredName === dependencyName) return true;
-	return false;
-};
+const declaresDependency = (manifest, dependencyName) => DEPENDENCY_SECTION_NAMES.some((sectionName) => {
+	const section = manifest[sectionName];
+	return typeof section === "object" && section !== null && Object.prototype.propertyIsEnumerable.call(section, dependencyName);
+});
 const cachedPlatformByManifest = /* @__PURE__ */ new WeakMap();
 const classifyPackagePlatform = (filename) => {
 	const manifest = readNearestPackageManifest(filename);
@@ -25522,25 +25531,23 @@ const isCallArgumentFunctionExpression = (node) => {
 	return parent.arguments.some((argumentNode) => argumentNode === node);
 };
 const isNestedRenderEvidenceBoundary = (node) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isCallArgumentFunctionExpression(node);
-const containsRenderOutput$1 = (node, rootNode, scopes) => {
-	if (node !== rootNode && isNestedRenderEvidenceBoundary(node)) return false;
-	if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
-	if (isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS)) return true;
-	const nodeRecord = node;
-	for (const key of Object.keys(nodeRecord)) {
-		if (key === "parent") continue;
-		const child = nodeRecord[key];
-		if (Array.isArray(child)) {
-			for (const innerChild of child) if (isAstNode(innerChild) && containsRenderOutput$1(innerChild, rootNode, scopes)) return true;
-		} else if (isAstNode(child) && containsRenderOutput$1(child, rootNode, scopes)) return true;
-	}
-	return false;
+const containsRenderOutput$1 = (rootNode, scopes) => {
+	let hasRenderOutput = false;
+	walkAst(rootNode, (node) => {
+		if (hasRenderOutput) return false;
+		if (node !== rootNode && isNestedRenderEvidenceBoundary(node)) return false;
+		if (node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS)) {
+			hasRenderOutput = true;
+			return false;
+		}
+	});
+	return hasRenderOutput;
 };
 const renderOutputCache = /* @__PURE__ */ new WeakMap();
 const functionContainsReactRenderOutput = (functionNode, scopes) => {
 	const cachedEntry = renderOutputCache.get(functionNode);
 	if (cachedEntry && cachedEntry.scopes === scopes) return cachedEntry.hasRenderOutput;
-	const hasRenderOutput = containsRenderOutput$1(functionNode, functionNode, scopes);
+	const hasRenderOutput = containsRenderOutput$1(functionNode, scopes);
 	renderOutputCache.set(functionNode, {
 		scopes,
 		hasRenderOutput
@@ -27346,7 +27353,7 @@ const isSetStateCallInLifecycle = (setStateCall, lifecycleNames, options = {}) =
 	let ancestor = setStateCall.parent;
 	while (ancestor) {
 		if (!lifecycleMember) {
-			if (FUNCTION_NODE_TYPES$1.has(ancestor.type)) nestedFunctionCount += 1;
+			if (FUNCTION_NODE_TYPES$1.has(ancestor.type) && (!isImmediatelyInvokedFunction(ancestor) || !("async" in ancestor) || ancestor.async === true)) nestedFunctionCount += 1;
 			if (isLifecycleMember(ancestor, lifecycleNames)) lifecycleMember = ancestor;
 		} else if (isEs5Component(ancestor) || isEs6Component(ancestor)) {
 			if (nestedFunctionCount > 1 && !options.disallowInNestedFunctions) return false;
@@ -27548,7 +27555,7 @@ const collectDiffSourceLocalNames = (lifecycleFunction, paramNames) => {
 	const body = lifecycleFunction.body;
 	if (!body) return derivedNames;
 	walkAst(body, (node) => {
-		if (FUNCTION_NODE_TYPES.has(node.type)) return false;
+		if (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node)) return false;
 		if (!isNodeOfType(node, "VariableDeclarator")) return;
 		const init = node.init;
 		if (!init) return;
@@ -27558,6 +27565,67 @@ const collectDiffSourceLocalNames = (lifecycleFunction, paramNames) => {
 	return derivedNames;
 };
 const isStatefulOperand = (node, paramNames, derivedNames) => referencesAnyName(node, paramNames) || referencesAnyName(node, derivedNames) || containsThisStateOrProps(node);
+const getStaticMemberName = (node) => {
+	if (!isNodeOfType(node, "MemberExpression") || node.computed === true) return null;
+	return isNodeOfType(node.property, "Identifier") ? node.property.name : null;
+};
+const getThisStateFieldName = (node) => {
+	const unwrappedNode = stripParenExpression(node);
+	if (!isNodeOfType(unwrappedNode, "MemberExpression")) return null;
+	const object = stripParenExpression(unwrappedNode.object);
+	if (!isNodeOfType(object, "MemberExpression") || !isNodeOfType(stripParenExpression(object.object), "ThisExpression") || getStaticMemberName(object) !== "state") return null;
+	return getStaticMemberName(unwrappedNode);
+};
+const collectLocalInitializers = (lifecycleFunction) => {
+	const initializers = /* @__PURE__ */ new Map();
+	const body = lifecycleFunction.body;
+	if (!body) return initializers;
+	walkAst(body, (node) => {
+		if (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node)) return false;
+		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.init) initializers.set(node.id.name, node.init);
+	});
+	return initializers;
+};
+const derivesFromPostMountValue = (node, localInitializers, visitedNames = /* @__PURE__ */ new Set()) => {
+	if (readsPostMountValue(node)) return true;
+	const referencedNames = /* @__PURE__ */ new Set();
+	collectReferenceIdentifierNames(node, referencedNames);
+	for (const referencedName of referencedNames) {
+		if (visitedNames.has(referencedName)) continue;
+		const initializer = localInitializers.get(referencedName);
+		if (!initializer) continue;
+		if (derivesFromPostMountValue(initializer, localInitializers, new Set([...visitedNames, referencedName]))) return true;
+	}
+	return false;
+};
+const getSetStateFieldValue = (setStateCall, fieldName) => {
+	if (!isNodeOfType(setStateCall, "CallExpression")) return null;
+	const argument = setStateCall.arguments?.[0];
+	if (!argument || !isNodeOfType(argument, "ObjectExpression")) return null;
+	for (const property of argument.properties ?? []) {
+		if (!isNodeOfType(property, "Property") || property.computed === true) continue;
+		if ((isNodeOfType(property.key, "Identifier") && property.key.name || isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" && property.key.value || null) === fieldName) return property.value;
+	}
+	return null;
+};
+const isConvergentPostMountGuard = (test, setStateCall, localInitializers) => {
+	let qualifies = false;
+	walkAst(test, (node) => {
+		if (qualifies) return false;
+		if (!isNodeOfType(node, "BinaryExpression") || !EQUALITY_OPERATORS.has(node.operator)) return;
+		const leftFieldName = getThisStateFieldName(node.left);
+		const rightFieldName = getThisStateFieldName(node.right);
+		const fieldName = leftFieldName ?? rightFieldName;
+		const comparedValue = leftFieldName ? node.right : node.left;
+		if (!fieldName || !leftFieldName && !rightFieldName) return;
+		const assignedValue = getSetStateFieldValue(setStateCall, fieldName);
+		if (!assignedValue || !areExpressionsStructurallyEqual(comparedValue, assignedValue)) return;
+		if (!derivesFromPostMountValue(comparedValue, localInitializers)) return;
+		qualifies = true;
+		return false;
+	});
+	return qualifies;
+};
 const isDiffGuardTest = (test, paramNames, derivedNames) => {
 	if (referencesAnyName(test, paramNames)) return true;
 	let qualifies = false;
@@ -27565,7 +27633,7 @@ const isDiffGuardTest = (test, paramNames, derivedNames) => {
 		if (qualifies) return false;
 		if (!isNodeOfType(node, "BinaryExpression")) return;
 		if (!EQUALITY_OPERATORS.has(node.operator)) return;
-		if (isStatefulOperand(node.left, paramNames, derivedNames) && isStatefulOperand(node.right, paramNames, derivedNames)) {
+		if (isStatefulOperand(node.left, paramNames, derivedNames) && isStatefulOperand(node.right, paramNames, derivedNames) && (referencesAnyName(node.left, derivedNames) || referencesAnyName(node.right, derivedNames))) {
 			qualifies = true;
 			return false;
 		}
@@ -27578,11 +27646,12 @@ const isInsideDiffGuard = (setStateCall) => {
 	const paramNames = /* @__PURE__ */ new Set();
 	for (const param of lifecycleFunction.params ?? []) collectPatternNames(param, paramNames);
 	const derivedNames = collectDiffSourceLocalNames(lifecycleFunction, paramNames);
+	const localInitializers = collectLocalInitializers(lifecycleFunction);
 	let child = setStateCall;
 	let ancestor = setStateCall.parent;
 	while (ancestor && ancestor !== lifecycleFunction) {
 		const guardTest = isNodeOfType(ancestor, "IfStatement") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "ConditionalExpression") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "LogicalExpression") && ancestor.operator === "&&" && child === ancestor.right && ancestor.left || null;
-		if (guardTest && isDiffGuardTest(guardTest, paramNames, derivedNames)) return true;
+		if (guardTest && (isDiffGuardTest(guardTest, paramNames, derivedNames) || isConvergentPostMountGuard(guardTest, setStateCall, localInitializers))) return true;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
 	}
@@ -27763,7 +27832,16 @@ const producesOpaqueInstanceValue = (expression) => {
 const collectSetterValueObservations = (componentBody, setterNames) => {
 	const plainFedSetterNames = /* @__PURE__ */ new Set();
 	const opaqueFedSetterNames = /* @__PURE__ */ new Set();
+	const callbackRefSetterNames = /* @__PURE__ */ new Set();
 	walkComponentRespectingShadows(componentBody, /* @__PURE__ */ new Set(), (node, currentlyShadowed) => {
+		if (isNodeOfType(node, "JSXAttribute")) {
+			const attributeName = node.name;
+			if (isNodeOfType(attributeName, "JSXIdentifier") && attributeName.name === "ref" && node.value && isNodeOfType(node.value, "JSXExpressionContainer")) {
+				const expression = stripParenExpression(node.value.expression);
+				if (isNodeOfType(expression, "Identifier") && setterNames.has(expression.name)) callbackRefSetterNames.add(expression.name);
+			}
+			return;
+		}
 		if (!isNodeOfType(node, "CallExpression")) return;
 		if (!isNodeOfType(node.callee, "Identifier")) return;
 		const setterName = node.callee.name;
@@ -27780,21 +27858,10 @@ const collectSetterValueObservations = (componentBody, setterNames) => {
 	}, true);
 	return {
 		plainFedSetterNames,
-		opaqueFedSetterNames
+		opaqueFedSetterNames,
+		callbackRefSetterNames
 	};
 };
-const collectCallbackRefSetterNames = (componentBody) => {
-	const callbackRefSetterNames = /* @__PURE__ */ new Set();
-	walkAst(componentBody, (node) => {
-		if (!isNodeOfType(node, "JSXAttribute")) return;
-		const attributeName = node.name;
-		if (isNodeOfType(attributeName, "JSXIdentifier") && attributeName.name === "ref" && node.value && isNodeOfType(node.value, "JSXExpressionContainer")) {
-			const expression = stripParenExpression(node.value.expression);
-			if (isNodeOfType(expression, "Identifier")) callbackRefSetterNames.add(expression.name);
-		}
-	});
-	return callbackRefSetterNames;
-};
 const collectFunctionLocalBindings = (functionNode) => {
 	const localBindings = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return localBindings;
@@ -27806,8 +27873,8 @@ const collectFunctionLocalBindings = (functionNode) => {
 	return localBindings;
 };
 const collectBlockScopedBindings = (node) => {
-	const blockBindings = /* @__PURE__ */ new Set();
 	if (isNodeOfType(node, "BlockStatement")) {
+		const blockBindings = /* @__PURE__ */ new Set();
 		for (const statement of node.body ?? []) {
 			if (!isNodeOfType(statement, "VariableDeclaration")) continue;
 			for (const declarator of statement.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
@@ -27815,17 +27882,22 @@ const collectBlockScopedBindings = (node) => {
 		return blockBindings;
 	}
 	if (isNodeOfType(node, "ForStatement") && isNodeOfType(node.init, "VariableDeclaration")) {
+		const blockBindings = /* @__PURE__ */ new Set();
 		for (const declarator of node.init.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
 		return blockBindings;
 	}
-	if ((isNodeOfType(node, "ForOfStatement") || isNodeOfType(node, "ForInStatement")) && isNodeOfType(node.left, "VariableDeclaration")) for (const declarator of node.left.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
-	return blockBindings;
+	if ((isNodeOfType(node, "ForOfStatement") || isNodeOfType(node, "ForInStatement")) && isNodeOfType(node.left, "VariableDeclaration")) {
+		const blockBindings = /* @__PURE__ */ new Set();
+		for (const declarator of node.left.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
+		return blockBindings;
+	}
+	return null;
 };
 const walkComponentRespectingShadows = (node, shadowedStateNames, visit, isComponentBodyRoot = false) => {
 	if (!node || typeof node !== "object") return;
 	let nextShadowedStateNames = shadowedStateNames;
-	const localBindings = isComponentBodyRoot ? /* @__PURE__ */ new Set() : isFunctionLike$1(node) ? collectFunctionLocalBindings(node) : collectBlockScopedBindings(node);
-	if (localBindings.size > 0) {
+	const localBindings = isComponentBodyRoot ? null : isFunctionLike$1(node) ? collectFunctionLocalBindings(node) : collectBlockScopedBindings(node);
+	if (localBindings && localBindings.size > 0) {
 		const merged = new Set(shadowedStateNames);
 		for (const localName of localBindings) merged.add(localName);
 		nextShadowedStateNames = merged;
@@ -27851,11 +27923,10 @@ const noDirectStateMutation = defineRule({
 			const bindings = collectUseStateBindings(componentBody);
 			if (bindings.length === 0) return;
 			const stateValueToSetter = new Map(bindings.map((binding) => [binding.valueName, binding.setterName]));
-			const callbackRefSetterNames = collectCallbackRefSetterNames(componentBody);
 			const setterValueObservations = collectSetterValueObservations(componentBody, new Set(bindings.map((binding) => binding.setterName)));
 			const plainObjectStateValueNames = /* @__PURE__ */ new Set();
 			for (const binding of bindings) {
-				if (callbackRefSetterNames.has(binding.setterName)) continue;
+				if (setterValueObservations.callbackRefSetterNames.has(binding.setterName)) continue;
 				if (!isNodeOfType(binding.declarator.init, "CallExpression")) continue;
 				const initializerArgument = binding.declarator.init.arguments?.[0];
 				if (!initializerMarksPlainState(initializerArgument)) continue;
@@ -32573,25 +32644,60 @@ const resolveSettings$16 = (settings) => {
 };
 const isHocCall = (call, scopes) => {
 	if (!isNodeOfType(call, "CallExpression")) return false;
-	const calleeName = flattenCalleeName(call.callee);
-	if (calleeName && REACT_HOC_NAMES.has(calleeName)) return true;
+	if (isReactApiCall(call, REACT_HOC_NAMES, scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: true
+	})) return true;
+	if (isReactHocMemberReference(call.callee, scopes)) return true;
 	if (!isNodeOfType(call.callee, "Identifier")) return false;
 	const symbol = scopes.symbolFor(call.callee);
 	if (!symbol) return false;
-	return symbolMapsToHoc(symbol);
+	return symbolMapsToHoc(symbol, scopes, /* @__PURE__ */ new Set());
+};
+const isReactImportEquals = (symbol) => {
+	if (symbol.kind !== "ts-import-equals" || !isNodeOfType(symbol.declarationNode, "TSImportEqualsDeclaration")) return false;
+	const moduleReference = symbol.declarationNode.moduleReference;
+	return Boolean(isNodeOfType(moduleReference, "TSExternalModuleReference") && isNodeOfType(moduleReference.expression, "Literal") && typeof moduleReference.expression.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(moduleReference.expression.value));
+};
+const isRequireReactCall$1 = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression") || !isNodeOfType(node.callee, "Identifier") || node.callee.name !== "require" || !scopes.isGlobalReference(node.callee)) return false;
+	const moduleSpecifier = node.arguments[0];
+	return Boolean(moduleSpecifier && isNodeOfType(moduleSpecifier, "Literal") && typeof moduleSpecifier.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(moduleSpecifier.value));
+};
+const isReactNamespaceExpression = (node, scopes) => {
+	if (isRequireReactCall$1(node, scopes)) return true;
+	if (!isNodeOfType(node, "Identifier")) return false;
+	const symbol = scopes.symbolFor(node);
+	if (!symbol) return node.name === "React" && scopes.isGlobalReference(node);
+	if (symbol.initializer && isRequireReactCall$1(symbol.initializer, scopes)) return true;
+	if (isReactImportEquals(symbol)) return true;
+	return isReactNamespaceImport(node, scopes);
+};
+const isReactHocMemberReference = (node, scopes) => Boolean(isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.property, "Identifier") && REACT_HOC_NAMES.has(node.property.name) && isReactNamespaceExpression(node.object, scopes));
+const getDestructuredPropertyName$1 = (symbol) => {
+	const property = symbol.bindingIdentifier.parent;
+	if (!property || !isNodeOfType(property, "Property") || !property.parent || !isNodeOfType(property.parent, "ObjectPattern")) return null;
+	if (isNodeOfType(property.key, "Identifier") && !property.computed) return property.key.name;
+	if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") return property.key.value;
+	return null;
 };
-const symbolMapsToHoc = (symbol) => {
-	if (REACT_HOC_NAMES.has(symbol.name)) {
-		if (symbol.kind === "import") return true;
+const symbolMapsToHoc = (symbol, scopes, visitedSymbolIds) => {
+	if (visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	if (symbol.kind === "import") {
+		const importedName = getImportedName(symbol.declarationNode);
+		return Boolean(isImportedFromReact(symbol) && importedName && REACT_HOC_NAMES.has(importedName));
 	}
 	const init = symbol.initializer;
 	if (!init) return false;
-	if (isNodeOfType(init, "MemberExpression")) {
-		const flat = flattenCalleeName(init);
-		if (flat && REACT_HOC_NAMES.has(flat)) return true;
+	const destructuredPropertyName = getDestructuredPropertyName$1(symbol);
+	if (destructuredPropertyName && REACT_HOC_NAMES.has(destructuredPropertyName) && isReactNamespaceExpression(init, scopes)) return true;
+	if (isReactHocMemberReference(init, scopes)) return true;
+	if (isNodeOfType(init, "Identifier")) {
+		const initializedFromSymbol = scopes.symbolFor(init);
+		if (initializedFromSymbol) return symbolMapsToHoc(initializedFromSymbol, scopes, visitedSymbolIds);
+		return REACT_HOC_NAMES.has(init.name) && scopes.isGlobalReference(init);
 	}
-	if (isNodeOfType(init, "Identifier") && REACT_HOC_NAMES.has(init.name)) return true;
-	if (REACT_HOC_NAMES.has(symbol.name) && isNodeOfType(init, "Identifier") && init.name === "React") return true;
 	return false;
 };
 const isTrivialPassthroughChild = (child) => {
@@ -32649,26 +32755,14 @@ const isHocComponent = (call, scopes) => {
 };
 const containsJsx = (root) => {
 	let found = false;
-	const visit = (node) => {
-		if (found) return;
+	walkAst(root, (node) => {
+		if (found) return false;
 		if (node.type === "JSXElement" || node.type === "JSXFragment") {
 			found = true;
-			return;
-		}
-		if (node !== root) {
-			if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ClassDeclaration" || node.type === "ClassExpression") return;
-		}
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-			if (found) return;
+			return false;
 		}
-	};
-	visit(root);
+		if (node !== root && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ClassDeclaration" || node.type === "ClassExpression")) return false;
+	});
 	return found;
 };
 const expressionContainsJsx = (expression) => {
@@ -32692,7 +32786,7 @@ const unwrapTsCast = (expression) => {
 	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression") current = stripParenExpression(current.expression);
 	return current;
 };
-const collectReExportedNames = (program) => {
+const collectReExportedNames = (program, scopes) => {
 	const names = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(program, "Program")) return names;
 	for (const statement of program.body) {
@@ -32716,8 +32810,7 @@ const collectReExportedNames = (program) => {
 			if (!declarator.init) continue;
 			const init = unwrapTsCast(declarator.init);
 			if (isNodeOfType(init, "CallExpression")) {
-				const calleeName = flattenCalleeName(init.callee);
-				if (calleeName && REACT_HOC_NAMES.has(calleeName)) {
+				if (isHocCall(init, scopes)) {
 					const wrappedArg = init.arguments[0];
 					if (wrappedArg && isNodeOfType(wrappedArg, "Identifier")) names.add(wrappedArg.name);
 				}
@@ -32786,16 +32879,7 @@ const recordComponent = (context, name, reportNode, isStateless) => {
 		isStateless
 	});
 };
-const walkChildren = (node, context) => {
-	const record = node;
-	for (const key of Object.keys(record)) {
-		if (key === "parent") continue;
-		const child = record[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (isAstNode(item)) walkComponentSearch(item, context);
-		} else if (isAstNode(child)) walkComponentSearch(child, context);
-	}
-};
+const walkChildren = (node, context) => forEachChildNode(node, context.visitChild);
 const walkComponentSearch = (node, context) => {
 	if (isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression")) {
 		if (isEs6Component(node)) {
@@ -32897,12 +32981,13 @@ const noMultiComp = defineRule({
 				components: [],
 				componentDepth: 0,
 				currentVarName: null,
-				scopes: context.scopes
+				scopes: context.scopes,
+				visitChild: (child) => walkComponentSearch(child, visitContext)
 			};
 			for (const statement of node.body) walkComponentSearch(statement, visitContext);
 			const flagged = settings.ignoreStateless ? visitContext.components.filter((component) => !component.isStateless) : visitContext.components;
 			if (flagged.length <= 2) return;
-			const reExportedNames = collectReExportedNames(node);
+			const reExportedNames = collectReExportedNames(node, context.scopes);
 			const exportedCount = flagged.filter((component) => isExportedDeclaration(component.reportNode, reExportedNames)).length;
 			if (exportedCount >= flagged.length || flagged.length >= 4 && exportedCount >= Math.floor(flagged.length * .7) || flagged.length >= 8 && exportedCount >= Math.floor(flagged.length * .5)) return;
 			const isSmallFeatureModule = exportedCount > 0 && exportedCount <= 2 && exportedCount < flagged.length;
@@ -39370,34 +39455,18 @@ const resolveSettings$8 = (settings) => {
 };
 const expressionContainsJsxOrCreateElement = (root) => {
 	let found = false;
-	const visit = (node) => {
-		if (found) return;
+	walkAst(root, (node) => {
+		if (found) return false;
+		if (node !== root && NESTED_FUNCTION_TYPES.has(node.type)) return false;
 		if (node.type === "JSXElement" || node.type === "JSXFragment") {
 			found = true;
-			return;
+			return false;
 		}
 		if (isNodeOfType(node, "CallExpression") && isCreateElementCall(node)) {
 			found = true;
-			return;
-		}
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) for (const item of child) {
-				if (!isAstNode(item)) continue;
-				if (NESTED_FUNCTION_TYPES.has(item.type)) continue;
-				visit(item);
-				if (found) return;
-			}
-			else if (isAstNode(child)) {
-				if (NESTED_FUNCTION_TYPES.has(child.type)) continue;
-				visit(child);
-			}
-			if (found) return;
+			return false;
 		}
-	};
-	visit(root);
+	});
 	return found;
 };
 const isReactClassComponent = (classNode) => {
@@ -40323,19 +40392,6 @@ const classifyExport = (name, reportNode, isFunction, initializer, state) => {
 		reportNode
 	};
 };
-const collectRelevantNodes = (programRoot) => {
-	const exportNodes = [];
-	const componentCandidates = [];
-	walkAst(programRoot, (child) => {
-		const childType = child.type;
-		if (childType === "ExportAllDeclaration" || childType === "ExportDefaultDeclaration" || childType === "ExportNamedDeclaration") exportNodes.push(child);
-		else if (childType === "FunctionDeclaration" || childType === "VariableDeclarator" || childType === "ClassDeclaration") componentCandidates.push(child);
-	});
-	return {
-		exportNodes,
-		componentCandidates
-	};
-};
 const isEntryPointFile = (filename) => {
 	const lastSlash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
 	const basename = lastSlash === -1 ? filename : filename.slice(lastSlash + 1);
@@ -40374,197 +40430,212 @@ const onlyExportComponents = defineRule({
 	category: "Architecture",
 	create: (context) => {
 		const settings = resolveSettings$6(context.settings);
-		return { Program(node) {
-			if (!isFileNameAllowed(normalizeFilename(context.filename ?? ""), settings.checkJS)) return;
-			const { exportNodes, componentCandidates } = collectRelevantNodes(node);
-			const localComponentNames = /* @__PURE__ */ new Set();
-			const state = {
-				customHocs: new Set([...DEFAULT_REACT_HOCS, ...settings.customHOCs]),
-				allowExportNames: new Set(settings.allowExportNames),
-				allowConstantExport: settings.allowConstantExport,
-				localComponentNames,
-				scopes: context.scopes
-			};
-			for (const child of componentCandidates) {
-				if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-					if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes)) localComponentNames.add(child.id.name);
-				}
-				if (isNodeOfType(child, "ClassDeclaration") && child.id) {
-					if (isReactComponentName(child.id.name) && isEs6Component(child) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
-				}
-				if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
-					const initializer = child.init;
-					if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) {
-						const expression = initializer ? skipTsExpression(initializer) : null;
-						if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes)) localComponentNames.add(child.id.name);
+		if (!isFileNameAllowed(normalizeFilename(context.filename ?? ""), settings.checkJS)) return {};
+		const exportNodes = [];
+		const componentCandidates = [];
+		const pushExportNode = (node) => {
+			exportNodes.push(node);
+		};
+		const pushComponentCandidate = (node) => {
+			componentCandidates.push(node);
+		};
+		return {
+			ExportAllDeclaration: pushExportNode,
+			ExportDefaultDeclaration: pushExportNode,
+			ExportNamedDeclaration: pushExportNode,
+			FunctionDeclaration: pushComponentCandidate,
+			VariableDeclarator: pushComponentCandidate,
+			ClassDeclaration: pushComponentCandidate,
+			"Program:exit"() {
+				const localComponentNames = /* @__PURE__ */ new Set();
+				const state = {
+					customHocs: new Set([...DEFAULT_REACT_HOCS, ...settings.customHOCs]),
+					allowExportNames: new Set(settings.allowExportNames),
+					allowConstantExport: settings.allowConstantExport,
+					localComponentNames,
+					scopes: context.scopes
+				};
+				for (const child of componentCandidates) {
+					if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
+						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes)) localComponentNames.add(child.id.name);
+					}
+					if (isNodeOfType(child, "ClassDeclaration") && child.id) {
+						if (isReactComponentName(child.id.name) && isEs6Component(child) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
+					}
+					if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
+						const initializer = child.init;
+						if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) {
+							const expression = initializer ? skipTsExpression(initializer) : null;
+							if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes)) localComponentNames.add(child.id.name);
+						}
 					}
 				}
-			}
-			const exports = [];
-			let hasReactExport = false;
-			let hasAnyExports = false;
-			const isExportedNodeIds = /* @__PURE__ */ new WeakSet();
-			for (const child of exportNodes) {
-				if (isNodeOfType(child, "ExportAllDeclaration")) {
-					if (child.exportKind === "type") continue;
-					hasAnyExports = true;
-					context.report({
-						node: child,
-						message: EXPORT_ALL_MESSAGE
-					});
-					continue;
-				}
-				if (isNodeOfType(child, "ExportDefaultDeclaration")) {
-					hasAnyExports = true;
-					const declaration = child.declaration;
-					const stripped = skipTsExpression(declaration);
-					if (isNodeOfType(stripped, "FunctionDeclaration") || isNodeOfType(stripped, "FunctionExpression")) {
-						if (stripped.id) {
-							const idNode = stripped.id;
-							isExportedNodeIds.add(stripped);
-							exports.push(classifyExport(idNode.name, idNode, true, null, state));
-						} else {
-							context.report({
+				const exports = [];
+				let hasReactExport = false;
+				let hasAnyExports = false;
+				const isExportedNodeIds = /* @__PURE__ */ new WeakSet();
+				for (const child of exportNodes) {
+					if (isNodeOfType(child, "ExportAllDeclaration")) {
+						if (child.exportKind === "type") continue;
+						hasAnyExports = true;
+						context.report({
+							node: child,
+							message: EXPORT_ALL_MESSAGE
+						});
+						continue;
+					}
+					if (isNodeOfType(child, "ExportDefaultDeclaration")) {
+						hasAnyExports = true;
+						const declaration = child.declaration;
+						const stripped = skipTsExpression(declaration);
+						if (isNodeOfType(stripped, "FunctionDeclaration") || isNodeOfType(stripped, "FunctionExpression")) {
+							if (stripped.id) {
+								const idNode = stripped.id;
+								isExportedNodeIds.add(stripped);
+								exports.push(classifyExport(idNode.name, idNode, true, null, state));
+							} else {
+								context.report({
+									node: stripped,
+									message: ANONYMOUS_MESSAGE
+								});
+								hasReactExport = true;
+							}
+							continue;
+						}
+						if (isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "ClassExpression")) {
+							if (stripped.id) {
+								const idNode = stripped.id;
+								isExportedNodeIds.add(stripped);
+								if (isReactComponentName(idNode.name) && isEs6Component(stripped)) hasReactExport = true;
+								else exports.push({
+									kind: "non-component",
+									reportNode: idNode
+								});
+							} else context.report({
 								node: stripped,
 								message: ANONYMOUS_MESSAGE
 							});
-							hasReactExport = true;
+							continue;
 						}
-						continue;
-					}
-					if (isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "ClassExpression")) {
-						if (stripped.id) {
-							const idNode = stripped.id;
-							isExportedNodeIds.add(stripped);
-							if (isReactComponentName(idNode.name) && isEs6Component(stripped)) hasReactExport = true;
-							else exports.push({
+						if (isNodeOfType(stripped, "Identifier")) {
+							exports.push(classifyExport(stripped.name, stripped, false, null, state));
+							continue;
+						}
+						if (isNodeOfType(stripped, "CallExpression")) {
+							if (isRouteFactoryCall(stripped)) {
+								hasReactExport = true;
+								continue;
+							}
+							const isHoc = isHocCallee(stripped.callee, state);
+							const firstArg = stripped.arguments[0];
+							const firstArgIsValid = Boolean(firstArg) && (() => {
+								if (!firstArg) return false;
+								const expression = skipTsExpression(firstArg);
+								if (isNodeOfType(expression, "Identifier")) return true;
+								if (isNodeOfType(expression, "FunctionExpression") && expression.id) return true;
+								if (isNodeOfType(expression, "CallExpression") && isHocCallee(expression.callee, state)) return true;
+								return false;
+							})();
+							if (isHoc && firstArgIsValid) hasReactExport = true;
+							else if (!isHoc && isConfigOnlyFactoryCall(stripped)) exports.push({
 								kind: "non-component",
-								reportNode: idNode
+								reportNode: stripped
+							});
+							else context.report({
+								node: stripped,
+								message: ANONYMOUS_MESSAGE
+							});
+							continue;
+						}
+						if (isNodeOfType(stripped, "ObjectExpression")) {
+							context.report({
+								node: stripped,
+								message: objectExpressionBundlesComponents(stripped, state) ? NAMESPACE_OBJECT_MESSAGE : ANONYMOUS_MESSAGE
+							});
+							continue;
+						}
+						if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "Literal")) {
+							context.report({
+								node: stripped,
+								message: ANONYMOUS_MESSAGE
 							});
-						} else context.report({
-							node: stripped,
-							message: ANONYMOUS_MESSAGE
-						});
-						continue;
-					}
-					if (isNodeOfType(stripped, "Identifier")) {
-						exports.push(classifyExport(stripped.name, stripped, false, null, state));
-						continue;
-					}
-					if (isNodeOfType(stripped, "CallExpression")) {
-						if (isRouteFactoryCall(stripped)) {
-							hasReactExport = true;
 							continue;
 						}
-						const isHoc = isHocCallee(stripped.callee, state);
-						const firstArg = stripped.arguments[0];
-						const firstArgIsValid = Boolean(firstArg) && (() => {
-							if (!firstArg) return false;
-							const expression = skipTsExpression(firstArg);
-							if (isNodeOfType(expression, "Identifier")) return true;
-							if (isNodeOfType(expression, "FunctionExpression") && expression.id) return true;
-							if (isNodeOfType(expression, "CallExpression") && isHocCallee(expression.callee, state)) return true;
-							return false;
-						})();
-						if (isHoc && firstArgIsValid) hasReactExport = true;
-						else if (!isHoc && isConfigOnlyFactoryCall(stripped)) exports.push({
-							kind: "non-component",
-							reportNode: stripped
-						});
-						else context.report({
-							node: stripped,
-							message: ANONYMOUS_MESSAGE
-						});
-						continue;
-					}
-					if (isNodeOfType(stripped, "ObjectExpression")) {
-						context.report({
-							node: stripped,
-							message: objectExpressionBundlesComponents(stripped, state) ? NAMESPACE_OBJECT_MESSAGE : ANONYMOUS_MESSAGE
-						});
-						continue;
-					}
-					if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "Literal")) {
 						context.report({
-							node: stripped,
+							node: child,
 							message: ANONYMOUS_MESSAGE
 						});
 						continue;
 					}
-					context.report({
-						node: child,
-						message: ANONYMOUS_MESSAGE
-					});
-					continue;
-				}
-				if (isNodeOfType(child, "ExportNamedDeclaration")) {
-					if (child.exportKind === "type") continue;
-					hasAnyExports = true;
-					if (child.declaration) {
-						const declaration = child.declaration;
-						if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
-							isExportedNodeIds.add(declaration);
-							exports.push(classifyExport(declaration.id.name, declaration.id, true, null, state));
-						} else if (isNodeOfType(declaration, "ClassDeclaration") && declaration.id) {
-							isExportedNodeIds.add(declaration);
-							if (isReactComponentName(declaration.id.name) && isEs6Component(declaration)) exports.push({ kind: "react-component" });
-							else exports.push({
-								kind: "non-component",
-								reportNode: declaration.id
-							});
-						} else if (isNodeOfType(declaration, "VariableDeclaration")) for (const declarator of declaration.declarations) {
-							if (!isNodeOfType(declarator.id, "Identifier")) continue;
-							isExportedNodeIds.add(declarator);
-							const isFunction = canBeReactFunctionComponent(declarator.init ?? null, state);
-							exports.push(classifyExport(declarator.id.name, declarator.id, isFunction, declarator.init, state));
-						}
-						else if (declaration.type === "TSEnumDeclaration" || declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration") {
-							if (declaration.type === "TSEnumDeclaration") exports.push({
-								kind: "non-component",
-								reportNode: declaration
-							});
+					if (isNodeOfType(child, "ExportNamedDeclaration")) {
+						if (child.exportKind === "type") continue;
+						hasAnyExports = true;
+						if (child.declaration) {
+							const declaration = child.declaration;
+							if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
+								isExportedNodeIds.add(declaration);
+								exports.push(classifyExport(declaration.id.name, declaration.id, true, null, state));
+							} else if (isNodeOfType(declaration, "ClassDeclaration") && declaration.id) {
+								isExportedNodeIds.add(declaration);
+								if (isReactComponentName(declaration.id.name) && isEs6Component(declaration)) exports.push({ kind: "react-component" });
+								else exports.push({
+									kind: "non-component",
+									reportNode: declaration.id
+								});
+							} else if (isNodeOfType(declaration, "VariableDeclaration")) for (const declarator of declaration.declarations) {
+								if (!isNodeOfType(declarator.id, "Identifier")) continue;
+								isExportedNodeIds.add(declarator);
+								const isFunction = canBeReactFunctionComponent(declarator.init ?? null, state);
+								exports.push(classifyExport(declarator.id.name, declarator.id, isFunction, declarator.init, state));
+							}
+							else if (declaration.type === "TSEnumDeclaration" || declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration") {
+								if (declaration.type === "TSEnumDeclaration") exports.push({
+									kind: "non-component",
+									reportNode: declaration
+								});
+							}
 						}
-					}
-					const isReExportFromSource = Boolean(child.source);
-					for (const specifier of child.specifiers ?? []) {
-						if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-						const exported = specifier.exported;
-						const local = specifier.local;
-						let exportedName = null;
-						if (exported && isNodeOfType(exported, "Identifier")) exportedName = exported.name;
-						const localName = local && isNodeOfType(local, "Identifier") ? local.name : null;
-						const reportNode = specifier;
-						let entry;
-						if (exportedName === "default" && localName) entry = classifyExport(localName, reportNode, false, null, state);
-						else if (exportedName) entry = classifyExport(exportedName, reportNode, false, null, state);
-						else {
-							entry = {
-								kind: "non-component",
-								reportNode
-							};
-							if (localName && isReactComponentName(localName)) exports.push({ kind: "react-component" });
+						const isReExportFromSource = Boolean(child.source);
+						for (const specifier of child.specifiers ?? []) {
+							if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+							const exported = specifier.exported;
+							const local = specifier.local;
+							let exportedName = null;
+							if (exported && isNodeOfType(exported, "Identifier")) exportedName = exported.name;
+							const localName = local && isNodeOfType(local, "Identifier") ? local.name : null;
+							const reportNode = specifier;
+							let entry;
+							if (exportedName === "default" && localName) entry = classifyExport(localName, reportNode, false, null, state);
+							else if (exportedName) entry = classifyExport(exportedName, reportNode, false, null, state);
+							else {
+								entry = {
+									kind: "non-component",
+									reportNode
+								};
+								if (localName && isReactComponentName(localName)) exports.push({ kind: "react-component" });
+							}
+							if (isReExportFromSource && entry.kind !== "react-component") continue;
+							exports.push(entry);
 						}
-						if (isReExportFromSource && entry.kind !== "react-component") continue;
-						exports.push(entry);
 					}
 				}
-			}
-			for (const entry of exports) if (entry.kind === "react-component") hasReactExport = true;
-			for (const entry of exports) if (entry.kind === "namespace-object") context.report({
-				node: entry.reportNode,
-				message: NAMESPACE_OBJECT_MESSAGE
-			});
-			if (hasAnyExports && hasReactExport) for (const entry of exports) {
-				if (entry.kind === "non-component") context.report({
-					node: entry.reportNode,
-					message: NAMED_EXPORT_MESSAGE
-				});
-				if (entry.kind === "react-context") context.report({
+				for (const entry of exports) if (entry.kind === "react-component") hasReactExport = true;
+				for (const entry of exports) if (entry.kind === "namespace-object") context.report({
 					node: entry.reportNode,
-					message: REACT_CONTEXT_MESSAGE
+					message: NAMESPACE_OBJECT_MESSAGE
 				});
+				if (hasAnyExports && hasReactExport) for (const entry of exports) {
+					if (entry.kind === "non-component") context.report({
+						node: entry.reportNode,
+						message: NAMED_EXPORT_MESSAGE
+					});
+					if (entry.kind === "react-context") context.report({
+						node: entry.reportNode,
+						message: REACT_CONTEXT_MESSAGE
+					});
+				}
 			}
-		} };
+		};
 	}
 });
 //#endregion
@@ -40666,7 +40737,12 @@ const postmessageOriginRisk = defineRule({
 	scan: (file) => {
 		if (!isProductionSourcePath(file.relativePath)) return [];
 		if (WORKER_FILE_PATH_PATTERN.test(file.relativePath)) return [];
-		const ast = parseSourceText(file.absolutePath, file.content);
+		if (!file.content.includes("addEventListener") && !file.content.includes("onmessage")) return [];
+		const ast = parseSourceText({
+			filename: file.absolutePath,
+			sourceText: file.content,
+			shouldAttachParentReferences: false
+		});
 		if (ast === null) return [];
 		const findings = [];
 		walkAst(ast, (node) => {
@@ -43046,15 +43122,6 @@ const isStableHookWrapperArgument = (node) => {
 	const parent = node.parent;
 	return isNodeOfType(parent, "CallExpression") && isNodeOfType(parent.callee, "Identifier") && STABLE_HOOK_WRAPPERS.has(parent.callee.name) && Boolean(parent.arguments?.some((argument) => argument === node));
 };
-const isImmediatelyInvokedFunction = (functionNode) => {
-	let wrappedCallee = functionNode;
-	let enclosing = functionNode.parent;
-	while (enclosing && stripParenExpression(enclosing) === functionNode) {
-		wrappedCallee = enclosing;
-		enclosing = enclosing.parent ?? null;
-	}
-	return Boolean(enclosing && isNodeOfType(enclosing, "CallExpression") && enclosing.callee === wrappedCallee);
-};
 const queryStableQueryClient = defineRule({
 	id: "query-stable-query-client",
 	title: "Unstable QueryClient in component",
@@ -59553,7 +59620,10 @@ const appendNode = (builder, block, node) => {
 };
 const mapDescendantsToBlock = (builder, node, block) => {
 	builder.nodeBlock.set(node, block);
-	if (isFunctionLike$1(node)) return;
+	if (isFunctionLike$1(node)) {
+		builder.nestedFunctions.push(node);
+		return;
+	}
 	const record = node;
 	for (const key of Object.keys(record)) {
 		if (key === "parent") continue;
@@ -59787,11 +59857,12 @@ const buildStatement = (builder, statement, current) => {
 	mapDescendantsToBlock(builder, statement, current);
 	return current;
 };
-const buildFunctionCfg = (functionNode, body) => {
+const buildFunctionCfg = (functionNode, body, nestedFunctionSink) => {
 	const builder = {
 		blocks: [],
 		entry: null,
 		exit: null,
+		nestedFunctions: nestedFunctionSink,
 		nodeBlock: /* @__PURE__ */ new Map(),
 		loopStack: [],
 		switchStack: [],
@@ -59809,13 +59880,12 @@ const buildFunctionCfg = (functionNode, body) => {
 		bodyEnd = entry;
 	}
 	addEdge(bodyEnd, exit, "uncond");
-	const blockOf = (node) => builder.nodeBlock.get(node) ?? null;
 	return {
 		owner: functionNode,
 		entry,
 		exit,
 		blocks: builder.blocks,
-		blockOf
+		blockOf: (node) => builder.nodeBlock.get(node) ?? null
 	};
 };
 const computeUnconditionalSet = (cfg) => {
@@ -59852,8 +59922,9 @@ const computeUnconditionalSet = (cfg) => {
 const analyzeControlFlow = (program) => {
 	nextBlockId = 0;
 	const functionCfgs = /* @__PURE__ */ new Map();
+	const pendingFunctions = [];
 	const buildFor = (functionNode, body) => {
-		const cfg = buildFunctionCfg(functionNode, body);
+		const cfg = buildFunctionCfg(functionNode, body, pendingFunctions);
 		functionCfgs.set(functionNode, {
 			cfg,
 			unconditionalSet: computeUnconditionalSet(cfg)
@@ -59863,21 +59934,18 @@ const analyzeControlFlow = (program) => {
 		type: "BlockStatement",
 		body: program.body
 	});
-	const visit = (node) => {
-		if (isFunctionLike$1(node)) {
-			const body = node.body;
-			if (body) buildFor(node, body);
-		}
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-		}
+	for (let functionIndex = 0; functionIndex < pendingFunctions.length; functionIndex += 1) {
+		const functionNode = pendingFunctions[functionIndex];
+		if (!isFunctionLike$1(functionNode) || !functionNode.body || functionCfgs.has(functionNode)) continue;
+		buildFor(functionNode, functionNode.body);
+	}
+	const getFunctionEntry = (functionNode) => {
+		const existingEntry = functionCfgs.get(functionNode);
+		if (existingEntry) return existingEntry;
+		if (!isFunctionLike$1(functionNode) || !functionNode.body) return null;
+		buildFor(functionNode, functionNode.body);
+		return functionCfgs.get(functionNode) ?? null;
 	};
-	visit(program);
 	const enclosingFunction = (node) => {
 		let current = node;
 		while (current) {
@@ -59888,12 +59956,12 @@ const analyzeControlFlow = (program) => {
 		return null;
 	};
 	const cfgFor = (functionLike) => {
-		return functionCfgs.get(functionLike)?.cfg ?? null;
+		return getFunctionEntry(functionLike)?.cfg ?? null;
 	};
 	const isUnconditionalFromEntry = (node) => {
 		const owner = enclosingFunction(node);
 		if (!owner) return true;
-		const entry = functionCfgs.get(owner);
+		const entry = getFunctionEntry(owner);
 		if (!entry) return true;
 		const block = entry.cfg.blockOf(node);
 		if (!block) return true;
@@ -59967,17 +60035,14 @@ const wrapWithSemanticContext = (rule) => ({
 			}
 		};
 		const visitors = rule.create(enrichedContext);
-		const passthroughVisitors = {};
-		for (const [nodeType, handler] of Object.entries(visitors)) {
-			if (typeof handler !== "function") continue;
-			passthroughVisitors[nodeType] = handler;
-		}
-		const innerProgramHandler = passthroughVisitors.Program;
-		passthroughVisitors.Program = ((node) => {
-			programRoot = node;
-			if (innerProgramHandler) innerProgramHandler(node);
-		});
-		return passthroughVisitors;
+		const innerProgramHandler = visitors.Program;
+		return {
+			...visitors,
+			Program: ((node) => {
+				programRoot = node;
+				if (innerProgramHandler) innerProgramHandler(node);
+			})
+		};
 	}
 });
 //#endregion