oxlint-plugin-react-doctor 0.7.5-dev.d9676e2 → 0.7.5

package/dist/index.js

@@ -1,11 +1,14 @@
-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, visitorKeys } from "oxc-parser";
+import { parseSync } 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) => node !== null && typeof node === "object" && "type" in node && node.type === type;
+const isNodeOfType = (node, type) => Boolean(hasTypeProperty(node) && node.type === type);
 //#endregion
 //#region src/plugin/utils/non-react-jsx-dialect.ts
 const NON_REACT_JSX_DIALECT_PACKAGES = new Set([
@@ -397,7 +400,6 @@ const isProductionFilePath = (relativePath, sourceFilePattern) => {
 //#endregion
 //#region src/plugin/rules/security-scan/utils/is-production-source-path.ts
 const isProductionSourcePath = (relativePath) => {
-	if (/\.d\.[cm]?[jt]s$/i.test(relativePath)) return false;
 	return isProductionFilePath(relativePath, SOURCE_FILE_PATTERN);
 };
 //#endregion
@@ -563,8 +565,7 @@ const REACT_RUNTIME_MODULE_SOURCES = new Set([
 	"react",
 	"react-dom",
 	"preact/compat",
-	"preact/hooks",
-	"@wordpress/element"
+	"preact/hooks"
 ]);
 const REACT_ECOSYSTEM_PACKAGE_NAMES = new Set([
 	"next",
@@ -801,55 +802,24 @@ const isHookCall$2 = (node, hookName) => {
 };
 //#endregion
 //#region src/plugin/utils/is-ast-node.ts
-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]
+const isAstNode = (value) => {
+	if (!hasTypeProperty(value)) return false;
+	return typeof value.type === "string";
 };
 //#endregion
 //#region src/plugin/utils/walk-ast.ts
-const forEachChildNode = (node, visit) => {
+const walkAst = (node, visitor) => {
+	if (!node || typeof node !== "object") return;
+	if (visitor(node) === false) return;
 	const nodeRecord = node;
-	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;
+	for (const key of Object.keys(nodeRecord)) {
+		if (key === "parent") continue;
 		const child = nodeRecord[key];
-		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);
+		if (Array.isArray(child)) {
+			for (const item of child) if (isAstNode(item)) walkAst(item, visitor);
+		} else if (isAstNode(child)) walkAst(child, visitor);
 	}
 };
-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"]);
@@ -1292,7 +1262,7 @@ const REGEX_PRECEDING_KEYWORDS = new Set([
 	"await",
 	"throw"
 ]);
-const isRegexLiteralStart = (content, characters, slashIndex) => {
+const isRegexLiteralStart = (characters, slashIndex) => {
 	let cursor = slashIndex - 1;
 	while (cursor >= 0 && WHITESPACE_PATTERN.test(characters[cursor])) cursor -= 1;
 	if (cursor < 0) return true;
@@ -1302,7 +1272,7 @@ const isRegexLiteralStart = (content, 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(content.slice(wordStartIndex, cursor + 1));
+		return REGEX_PRECEDING_KEYWORDS.has(characters.slice(wordStartIndex, cursor + 1).join(""));
 	}
 	if (previousCharacter === "<") return false;
 	if (previousCharacter === ">") return characterBefore === "=";
@@ -1343,15 +1313,13 @@ const quotedLiteralHasWhitespace = (content, openQuoteIndex, delimiter) => {
 	return false;
 };
 const blankNonCodePreservingPositions = (content, blankStringContents) => {
-	let characters = null;
+	const characters = content.split("");
 	let stringDelimiter = null;
 	let isBlankingString = false;
 	const templateExpressionDepths = [];
 	let index = 0;
 	const blankUnlessNewline = (offset) => {
-		if (offset >= content.length || content[offset] === "\n") return;
-		characters ??= content.split("");
-		characters[offset] = " ";
+		if (offset < content.length && content[offset] !== "\n") characters[offset] = " ";
 	};
 	while (index < content.length) {
 		const character = content[index];
@@ -1398,7 +1366,6 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 			continue;
 		}
 		if (character === "/" && nextCharacter === "/") {
-			characters ??= content.split("");
 			while (index < content.length && content[index] !== "\n") {
 				characters[index] = " ";
 				index += 1;
@@ -1406,7 +1373,6 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 			continue;
 		}
 		if (character === "/" && nextCharacter === "*") {
-			characters ??= content.split("");
 			while (index < content.length) {
 				if (content[index] === "*" && content[index + 1] === "/") {
 					characters[index] = " ";
@@ -1420,7 +1386,7 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 			continue;
 		}
 		if (character === "/") {
-			const regexEndIndex = isRegexLiteralStart(content, characters ?? content, index) ? findRegexLiteralEnd(content, index) : null;
+			const regexEndIndex = isRegexLiteralStart(characters, index) ? findRegexLiteralEnd(content, index) : null;
 			if (regexEndIndex !== null) {
 				if (blankStringContents) for (let interiorIndex = index + 1; interiorIndex < regexEndIndex - 1; interiorIndex += 1) blankUnlessNewline(interiorIndex);
 				index = regexEndIndex;
@@ -1438,9 +1404,9 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 		}
 		index += 1;
 	}
-	return characters?.join("") ?? content;
+	return characters.join("");
 };
-const stripCommentsPreservingPositions = (content) => content.includes("//") || content.includes("/*") ? blankNonCodePreservingPositions(content, false) : content;
+const stripCommentsPreservingPositions = (content) => blankNonCodePreservingPositions(content, false);
 const stripCommentsAndStringLiteralsPreservingPositions = (content) => blankNonCodePreservingPositions(content, true);
 //#endregion
 //#region src/plugin/rules/security-scan/utils/scan-by-pattern.ts
@@ -1459,15 +1425,10 @@ 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 [];
-	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 [];
+	const matchedPattern = (pattern instanceof RegExp ? [pattern] : pattern).find((candidate) => candidate.test(content));
+	if (matchedPattern === void 0) return [];
 	if (suppressWhen !== void 0 && suppressWhen.test(content)) return [];
-	const { line, column } = getLocationAtIndex(content, matchIndex);
+	const { line, column } = getMatchLocation(content, matchedPattern);
 	return [{
 		message,
 		line,
@@ -1477,7 +1438,6 @@ 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",
@@ -1485,7 +1445,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) && AGENT_TOOL_DEFINITION_PREFILTER_PATTERN.test(file.content) && AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN.test(file.content),
+		shouldScan: (file) => isProductionSourcePath(file.relativePath) && AGENT_TOOL_CONTEXT_PATH_PATTERN.test(file.relativePath),
 		pattern: AGENT_TOOL_DEFINITION_PATTERN,
 		requireAll: [AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN],
 		ignoreStringLiterals: true,
@@ -5179,10 +5139,8 @@ const STORAGE_GLOBALS = new Set([
 const SENSITIVE_KEY_PATTERN = /token|jwt|secret|password|passwd|credential|api[-_]?key|bearer|private[-_]?key/i;
 const NON_AUTH_TOKEN_PATTERN = /csrf|xsrf|device|fcm|apns|push|design|tokeniz|syntax|css|theme|color/i;
 const STRONG_AUTH_KEY_PATTERN = /jwt|secret|password|passwd|credential|private[-_]?key|api[-_]?key|bearer|access[-_]?token|refresh[-_]?token|auth[-_]?token|id[-_]?token|session/i;
-const PRODUCT_API_KEY_RECORDS_PATTERN = /(?:^|[._:-])(?:created|saved|integration|mailing)[-_]?api[-_]?keys$/i;
 const PRODUCT_API_KEY_COLLECTION_PATTERN = /[._:-](?:created|generated|saved)[-_]?api[-_]?keys$/i;
 const isAuthCredentialKey = (key) => {
-	if (PRODUCT_API_KEY_RECORDS_PATTERN.test(key)) return false;
 	if (!SENSITIVE_KEY_PATTERN.test(key)) return false;
 	if (PRODUCT_API_KEY_COLLECTION_PATTERN.test(key)) return false;
 	if (NON_AUTH_TOKEN_PATTERN.test(key) && !STRONG_AUTH_KEY_PATTERN.test(key)) return false;
@@ -6871,10 +6829,11 @@ const getTemplateInterpolations = (valueTail) => {
 	const interpolations = valueTail.slice(1, closingBacktickIndex).match(/\$\{[^}]*\}/g);
 	return interpolations === null ? "" : interpolations.join(" ");
 };
-const getIdentifierDeclarationInitializer = (identifier, sinkIndex, fileContent) => {
-	const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
-	if (declaration === null) return null;
-	return fileContent.slice(declaration.initializerStartIndex, declaration.initializerStartIndex + STATIC_TEMPLATE_MAX_CHARS);
+const getIdentifierDeclarationInitializer = (identifier, fileContent) => {
+	const declarationMatch = new RegExp(`(?:const|let|var)\\s+${escapeRegExp(identifier)}\\s*(?::[^=\\n]{0,120})?=\\s*`).exec(fileContent);
+	if (declarationMatch === null) return null;
+	const initializerStartIndex = declarationMatch.index + declarationMatch[0].length;
+	return fileContent.slice(initializerStartIndex, initializerStartIndex + STATIC_TEMPLATE_MAX_CHARS);
 };
 const isPureStringLiteralConcat = (initializerText) => {
 	if (!/^["']/.test(initializerText)) return false;
@@ -6944,153 +6903,6 @@ const isAllOperandsDomContentConcat = (valueExpression) => {
 		return !HTML_TAINT_PATTERN.test(withoutCast.replace(DOM_CONTENT_SOURCE_VALUE_PATTERN, ""));
 	});
 };
-const findMatchingBraceIndex = (fileContent, openingBraceIndex) => {
-	let depth = 0;
-	let quote = null;
-	for (let index = openingBraceIndex; index < fileContent.length; index += 1) {
-		const character = fileContent[index];
-		if (quote !== null) {
-			if (character === quote && fileContent[index - 1] !== "\\") quote = null;
-			continue;
-		}
-		if (character === "\"" || character === "'" || character === "`") {
-			quote = character;
-			continue;
-		}
-		if (character === "{") depth += 1;
-		if (character === "}") {
-			depth -= 1;
-			if (depth === 0) return index;
-		}
-	}
-	return fileContent.length;
-};
-const findContainingBlockEndIndex = (fileContent, targetIndex) => {
-	const openingBraceIndexes = [];
-	let quote = null;
-	let isLineComment = false;
-	let isBlockComment = false;
-	for (let index = 0; index < targetIndex; index += 1) {
-		const character = fileContent[index];
-		const nextCharacter = fileContent[index + 1];
-		if (isLineComment) {
-			if (character === "\n") isLineComment = false;
-			continue;
-		}
-		if (isBlockComment) {
-			if (character === "*" && nextCharacter === "/") {
-				isBlockComment = false;
-				index += 1;
-			}
-			continue;
-		}
-		if (quote !== null) {
-			if (character === quote && fileContent[index - 1] !== "\\") quote = null;
-			continue;
-		}
-		if (character === "/" && nextCharacter === "/") {
-			isLineComment = true;
-			index += 1;
-			continue;
-		}
-		if (character === "/" && nextCharacter === "*") {
-			isBlockComment = true;
-			index += 1;
-			continue;
-		}
-		if (character === "\"" || character === "'" || character === "`") {
-			quote = character;
-			continue;
-		}
-		if (character === "{") openingBraceIndexes.push(index);
-		if (character === "}") openingBraceIndexes.pop();
-	}
-	const openingBraceIndex = openingBraceIndexes.at(-1);
-	return openingBraceIndex === void 0 ? fileContent.length : findMatchingBraceIndex(fileContent, openingBraceIndex);
-};
-const findVisibleIdentifierDeclaration = (identifier, sinkIndex, fileContent) => {
-	const initializerPattern = new RegExp(`(?:const|let|var)\\s+${escapeRegExp(identifier)}\\s*(?::[^=\\n]*)?=\\s*([^;\\n]+)`, "g");
-	let nearestDeclaration = null;
-	let nearestDeclarationIndex = -1;
-	for (const match of fileContent.matchAll(initializerPattern)) {
-		const declarationIndex = match.index;
-		if (declarationIndex === void 0 || declarationIndex >= sinkIndex || declarationIndex <= nearestDeclarationIndex || findContainingBlockEndIndex(fileContent, declarationIndex) < sinkIndex) continue;
-		nearestDeclarationIndex = declarationIndex;
-		const initializer = match[1];
-		if (initializer === void 0) continue;
-		nearestDeclaration = {
-			initializer,
-			initializerStartIndex: declarationIndex + match[0].length - initializer.length
-		};
-	}
-	return nearestDeclaration;
-};
-const findContainingFunctionParameterSource = (identifier, sinkIndex, fileContent) => {
-	const patterns = [/function\s+([\w$]+)\s*\(([^)]*)\)\s*\{/g, /(?:const|let|var)\s+([\w$]+)\s*=\s*(?:async\s*)?\(([^)]*)\)\s*=>\s*\{/g];
-	let closestSource = null;
-	let closestStartIndex = -1;
-	for (const pattern of patterns) for (const match of fileContent.matchAll(pattern)) {
-		const matchIndex = match.index;
-		if (matchIndex === void 0 || matchIndex >= sinkIndex || matchIndex < closestStartIndex) continue;
-		if (findMatchingBraceIndex(fileContent, matchIndex + match[0].lastIndexOf("{")) < sinkIndex) continue;
-		const parameterIndex = (match[2] ?? "").split(",").findIndex((parameter) => parameter.trim().match(/^(?:\.\.\.)?([\w$]+)/)?.[1] === identifier);
-		if (parameterIndex < 0) continue;
-		closestStartIndex = matchIndex;
-		closestSource = {
-			functionName: match[1] ?? "",
-			parameterIndex
-		};
-	}
-	return closestSource;
-};
-const splitTopLevelArguments = (argumentText) => {
-	const argumentsList = [];
-	let startIndex = 0;
-	let depth = 0;
-	let quote = null;
-	for (let index = 0; index < argumentText.length; index += 1) {
-		const character = argumentText[index];
-		if (quote !== null) {
-			if (character === quote && argumentText[index - 1] !== "\\") quote = null;
-			continue;
-		}
-		if (character === "\"" || character === "'" || character === "`") {
-			quote = character;
-			continue;
-		}
-		if (character === "(" || character === "[" || character === "{") depth += 1;
-		if (character === ")" || character === "]" || character === "}") depth -= 1;
-		if (character === "," && depth === 0) {
-			argumentsList.push(argumentText.slice(startIndex, index).trim());
-			startIndex = index + 1;
-		}
-	}
-	argumentsList.push(argumentText.slice(startIndex).trim());
-	return argumentsList;
-};
-const isHtmlTainted = (expression, fileContent, sinkIndex, visitedIdentifiers) => {
-	const trimmedExpression = expression.trim();
-	if (STRING_LITERAL_VALUE_PATTERN.test(`${trimmedExpression};`)) return false;
-	if (MODULE_CONSTANT_VALUE_PATTERN.test(`${trimmedExpression};`)) return false;
-	if (SANITIZER_PATTERN.test(trimmedExpression)) return false;
-	if (ENV_CONFIG_VALUE_PATTERN.test(trimmedExpression)) return false;
-	if (I18N_VALUE_PATTERN.test(trimmedExpression)) return false;
-	if (ESCAPING_SERIALIZER_CALL_PATTERN.test(trimmedExpression)) return false;
-	if (HTML_TAINT_PATTERN.test(trimmedExpression)) return true;
-	const identifier = trimmedExpression.match(/^([\w$]+)\s*(?:[;,})\n]|$)/)?.[1];
-	if (identifier === void 0 || visitedIdentifiers.has(identifier)) return false;
-	visitedIdentifiers.add(identifier);
-	const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
-	if (declaration !== null && isHtmlTainted(declaration.initializer, fileContent, sinkIndex, visitedIdentifiers)) return true;
-	const parameterSource = findContainingFunctionParameterSource(identifier, sinkIndex, fileContent);
-	if (parameterSource === null || parameterSource.functionName.length === 0) return false;
-	const callPattern = new RegExp(`\\b${escapeRegExp(parameterSource.functionName)}\\s*\\(([^)]*)\\)`, "g");
-	for (const callMatch of fileContent.matchAll(callPattern)) {
-		const argument = splitTopLevelArguments(callMatch[1] ?? "")[parameterSource.parameterIndex];
-		if (argument !== void 0 && isHtmlTainted(argument, fileContent, sinkIndex, new Set(visitedIdentifiers))) return true;
-	}
-	return false;
-};
 const dangerousHtmlSink = defineRule({
 	id: "dangerous-html-sink",
 	title: "HTML injection sink with dynamic content",
@@ -7117,7 +6929,6 @@ const dangerousHtmlSink = defineRule({
 			const valueTail = fullValueTail.slice(0, VALUE_EXPRESSION_MAX_CHARS);
 			const terminatorIndex = valueTail.search(/[;}]/);
 			const valueExpression = terminatorIndex >= 0 ? valueTail.slice(0, terminatorIndex + 1) : valueTail;
-			const sinkIndex = lines.slice(0, lineIndex).join("\n").length + (lineIndex > 0 ? 1 : 0) + line.search(DANGEROUS_HTML_PATTERN);
 			if (STRING_LITERAL_VALUE_PATTERN.test(valueExpression)) continue;
 			if (MODULE_CONSTANT_VALUE_PATTERN.test(valueExpression)) continue;
 			if (DOM_CONTENT_SOURCE_VALUE_PATTERN.test(valueExpression) && !valueExpression.includes("+")) {
@@ -7129,7 +6940,7 @@ const dangerousHtmlSink = defineRule({
 			let templateInterpolations = getTemplateInterpolations(longValueTail ?? fullValueTail);
 			const valueIdentifier = BARE_IDENTIFIER_VALUE_PATTERN.test(valueExpression) || MEMBER_OR_INDEX_ACCESS_VALUE_PATTERN.test(valueExpression) || IDENTIFIER_WITH_LITERAL_FALLBACK_PATTERN.test(valueExpression) ? valueExpression.match(/^[\w$]+/)?.[0] : void 0;
 			if (templateInterpolations === null && valueIdentifier !== void 0 && BARE_IDENTIFIER_VALUE_PATTERN.test(valueExpression)) {
-				const declarationInitializer = getIdentifierDeclarationInitializer(valueIdentifier, sinkIndex, file.content);
+				const declarationInitializer = getIdentifierDeclarationInitializer(valueIdentifier, file.content);
 				if (declarationInitializer !== null) {
 					if (isPureStringLiteralConcat(declarationInitializer)) continue;
 					templateInterpolations = getTemplateInterpolations(declarationInitializer);
@@ -7140,7 +6951,7 @@ const dangerousHtmlSink = defineRule({
 			if (SANITIZER_PATTERN.test(judgedExpression)) continue;
 			if (ENV_CONFIG_VALUE_PATTERN.test(judgedExpression)) continue;
 			if (I18N_VALUE_PATTERN.test(judgedExpression)) continue;
-			if (!isHtmlTainted(judgedExpression, file.content, sinkIndex, /* @__PURE__ */ new Set())) continue;
+			if (!HTML_TAINT_PATTERN.test(judgedExpression)) continue;
 			if (ESCAPING_SERIALIZER_CALL_PATTERN.test(valueExpression)) continue;
 			if (/highlighted/i.test(valueExpression)) continue;
 			if (/highlight/i.test(valueExpression) && HIGHLIGHTER_LIBRARY_PATTERN.test(file.content)) continue;
@@ -7587,7 +7398,7 @@ const containsJsx$1 = (root) => {
 	containsJsxCache.set(root, found);
 	return found;
 };
-const getStaticMemberName$2 = (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") && typeof node.property.value === "string") return node.property.value;
@@ -7601,7 +7412,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$2(left);
+		if (isNodeOfType(left, "MemberExpression")) return getStaticMemberName$1(left);
 	}
 	return null;
 };
@@ -7609,20 +7420,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$2(left) === "exports";
+	return isNodeOfType(left, "MemberExpression") && isNodeOfType(left.object, "Identifier") && left.object.name === "module" && getStaticMemberName$1(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$2(callee) === "createClass";
+	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName$1(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$2(callee) === "createContext";
+	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName$1(callee) === "createContext";
 };
 const isNamedFunctionLike = (node) => (isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && Boolean(node.id?.name);
 const firstCallArgument = (node) => {
@@ -7680,7 +7491,7 @@ const memberExpressionPath = (node) => {
 	if (isNodeOfType(node, "Identifier")) return [node.name];
 	if (!isNodeOfType(node, "MemberExpression")) return [];
 	const objectPath = memberExpressionPath(node.object);
-	const propertyName = getStaticMemberName$2(node);
+	const propertyName = getStaticMemberName$1(node);
 	return propertyName ? [...objectPath, propertyName] : objectPath;
 };
 const displayNameAssignmentIndexCache = /* @__PURE__ */ new WeakMap();
@@ -7690,7 +7501,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$2(node.left) === "displayName") {
+		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName$1(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);
 		}
@@ -7885,7 +7696,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") && typeof importDeclaration.source.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(importDeclaration.source.value));
+	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react");
 };
 const isNamedReactApiImport = (identifier, apiNames, scopes) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
@@ -9835,11 +9646,6 @@ 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) {
@@ -9852,6 +9658,7 @@ 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;
@@ -9861,9 +9668,6 @@ 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) {
@@ -10066,7 +9870,7 @@ const computeClosureCaptures = (functionNode, scopes) => {
 	const functionScope = scopes.ownScopeFor(functionNode) ?? scopes.scopeFor(functionNode);
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
-	walkAst(functionNode, (node) => {
+	const visit = (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)) {
@@ -10075,7 +9879,7 @@ const computeClosureCaptures = (functionNode, scopes) => {
 					seen.add(reference.id);
 				}
 			}
-			return false;
+			return;
 		}
 		const reference = scopes.referenceFor(node);
 		if (reference && reference.resolvedSymbol) {
@@ -10086,7 +9890,17 @@ 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();
@@ -14406,11 +14220,7 @@ 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")) {
@@ -19114,7 +18924,6 @@ 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",
@@ -19122,7 +18931,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) && KEY_MATERIAL_MARKER_PATTERN.test(file.content),
+		shouldScan: (file) => !TEST_CONTEXT_PATTERN.test(file.relativePath) && !DOCUMENTATION_CONTEXT_PATTERN.test(file.relativePath),
 		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."
 	})
@@ -19828,21 +19637,15 @@ 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) && 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],
+		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],
 		ignoreStringLiterals: true,
 		message: "An MCP tool/resource/prompt handler appears to expose file, shell, network, or code-execution capability."
 	})
@@ -20953,8 +20756,8 @@ const catchClauseRethrowsCaught = (handler) => {
 	return didRethrow;
 };
 //#endregion
-//#region src/plugin/utils/is-immediately-invoked-function.ts
-const isImmediatelyInvokedFunction = (functionNode) => {
+//#region src/plugin/utils/find-guarding-try-statement.ts
+const isImmediatelyInvokedFunctionCallee = (functionNode) => {
 	let wrappedCallee = functionNode;
 	let enclosing = functionNode.parent;
 	while (enclosing && stripParenExpression(enclosing) === functionNode) {
@@ -20963,13 +20766,11 @@ const isImmediatelyInvokedFunction = (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) && !isImmediatelyInvokedFunction(ancestor)) return null;
+		if (isFunctionLike$1(ancestor) && !isImmediatelyInvokedFunctionCallee(ancestor)) return null;
 		if (isNodeOfType(ancestor, "TryStatement") && ancestor.block === child && ancestor.handler && !catchClauseRethrowsCaught(ancestor.handler)) return ancestor;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
@@ -21521,7 +21322,7 @@ const FILENAME_TO_LANG = {
 const resolveLang = (filename) => {
 	return FILENAME_TO_LANG[path.extname(filename).toLowerCase()] ?? "tsx";
 };
-const parseSourceText = ({ filename, sourceText, shouldAttachParentReferences = true }) => {
+const parseSourceText = (filename, sourceText) => {
 	try {
 		const result = parseSync(filename, sourceText, {
 			astType: "ts",
@@ -21529,7 +21330,7 @@ const parseSourceText = ({ filename, sourceText, shouldAttachParentReferences =
 		});
 		if (result.errors.some((parseError) => parseError.severity === "Error")) return null;
 		const parsedProgram = result.program;
-		if (shouldAttachParentReferences) attachParentReferences(parsedProgram);
+		attachParentReferences(parsedProgram);
 		return parsedProgram;
 	} catch {
 		return null;
@@ -21567,10 +21368,7 @@ const parseSourceFile = (absoluteFilePath) => {
 		});
 		return null;
 	}
-	const parsedProgram = parseSourceText({
-		filename: absoluteFilePath,
-		sourceText
-	});
+	const parsedProgram = parseSourceText(absoluteFilePath, sourceText);
 	parseCache.set(absoluteFilePath, {
 		mtimeMs: fileStat.mtimeMs,
 		size: fileStat.size,
@@ -22102,8 +21900,6 @@ const DOM_QUERY_MEMBER_NAMES = new Set([
 ]);
 const LAYOUT_MEASUREMENT_MEMBER_NAMES = new Set([
 	"current",
-	"textContent",
-	"innerText",
 	"scrollWidth",
 	"clientWidth",
 	"offsetWidth",
@@ -22125,7 +21921,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") || name.endsWith("Node") || name.endsWith("node") || name.endsWith("Element") || name.endsWith("element");
+const hasRefLikeName = (name) => name === "ref" || name.endsWith("Ref") || name.endsWith("ref");
 const isRefFactoryInitializer = (init) => {
 	if (!init || !isNodeOfType(init, "CallExpression")) return false;
 	const callee = init.callee;
@@ -22208,37 +22004,88 @@ const readsPostMountValue = (root) => {
 	return found;
 };
 //#endregion
-//#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");
+//#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
+};
 //#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 analysis = {
-		programNode,
-		scopeManager: analyze(programNode, {
+	const restorations = stripAndRecordParents(programNode);
+	let scopeManager;
+	try {
+		scopeManager = analyze(programNode, {
 			ecmaVersion: 2024,
 			sourceType: "module",
-			childVisitorKeys: RUNTIME_VISITOR_KEYS,
-			fallback: getAstChildKeys
-		}),
-		scopeByNode: /* @__PURE__ */ new WeakMap(),
-		referenceByIdentifier: /* @__PURE__ */ new WeakMap()
+			childVisitorKeys: VISITOR_KEYS,
+			fallback: "iteration"
+		});
+	} finally {
+		restoreParents(restorations);
+	}
+	const analysis = {
+		programNode,
+		scopeManager
 	};
 	programToAnalysis.set(programNode, analysis);
 	return analysis;
 };
-const getScopeForNode = (node, analysis) => {
+const scopeByNodeCache = /* @__PURE__ */ new WeakMap();
+const getScopeForNode = (node, manager) => {
 	if (!node.range) return null;
-	const scopeByNode = analysis.scopeByNode;
+	let scopeByNode = scopeByNodeCache.get(manager);
+	if (!scopeByNode) {
+		scopeByNode = /* @__PURE__ */ new WeakMap();
+		scopeByNodeCache.set(manager, scopeByNode);
+	}
 	if (scopeByNode.has(node)) return scopeByNode.get(node) ?? null;
 	let bestScope = null;
 	let bestSize = Infinity;
-	for (const scope of analysis.scopeManager.scopes) {
+	for (const scope of manager.scopes) {
 		const block = scope.block;
 		if (!block?.range) continue;
 		if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
@@ -22253,6 +22100,7 @@ const getScopeForNode = (node, analysis) => {
 };
 //#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;
@@ -22288,7 +22136,7 @@ const descend = (node, visit, visited = /* @__PURE__ */ new Set()) => {
 	if (visited.has(node)) return;
 	visit(node);
 	visited.add(node);
-	const keys = getAstChildKeys(node);
+	const keys = getChildKeys(node);
 	const record = node;
 	for (const key of keys) {
 		const child = record[key];
@@ -22321,11 +22169,16 @@ const findDownstreamNodes = (topNode, type) => {
 	});
 	return nodes;
 };
+const refByIdentifierCache = /* @__PURE__ */ new WeakMap();
 const getRef = (analysis, identifier) => {
-	const refByIdentifier = analysis.referenceByIdentifier;
+	let refByIdentifier = refByIdentifierCache.get(analysis);
+	if (!refByIdentifier) {
+		refByIdentifier = /* @__PURE__ */ new WeakMap();
+		refByIdentifierCache.set(analysis, refByIdentifier);
+	}
 	if (refByIdentifier.has(identifier)) return refByIdentifier.get(identifier) ?? null;
 	let resolvedReference = null;
-	const scope = getScopeForNode(identifier, analysis);
+	const scope = getScopeForNode(identifier, analysis.scopeManager);
 	if (scope) {
 		for (const reference of scope.references) if (reference.identifier === identifier) {
 			resolvedReference = reference;
@@ -22573,7 +22426,7 @@ const isReactFunctionalHOC = (analysis, node) => {
 	const isWrappedSeparately = () => {
 		if (!isNodeOfType(node.id, "Identifier")) return false;
 		const bindingName = node.id.name;
-		const containingScope = getScopeForNode(node, analysis);
+		const containingScope = getScopeForNode(node, analysis.scopeManager);
 		if (!containingScope) return false;
 		const variable = containingScope.variables.find((v) => v.name === bindingName);
 		if (!variable) return false;
@@ -22804,14 +22657,11 @@ 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;
-	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;
+	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;
 	}
 	return false;
 };
@@ -23102,7 +22952,7 @@ const STORAGE_GLOBAL_NAMES$1 = new Set([
 	"localStorage",
 	"sessionStorage"
 ]);
-const getStaticMemberName$1 = (node) => {
+const getStaticMemberName = (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;
@@ -23117,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$1(callee);
+	return getStaticMemberName(callee);
 };
 const getFunctionParameters = (functionNode) => isFunctionLike$1(functionNode) ? functionNode.params ?? [] : [];
 const getIdentifierBindingIdentity = (analysis, identifier) => {
@@ -23233,14 +23083,14 @@ const localUseEventPreservesCallback = (analysis, callee) => {
 			if (!isNodeOfType(child, "CallExpression")) return;
 			const forwardedCallee = stripParenExpression(child.callee);
 			if (!isNodeOfType(forwardedCallee, "MemberExpression")) return;
-			if (getStaticMemberName$1(forwardedCallee) !== "current") return;
+			if (getStaticMemberName(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$1(memberExpression) !== "current" || !assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression") || assignmentExpression.left !== memberExpression) return false;
+				if (!memberExpression || !isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName(memberExpression) !== "current" || !assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression") || assignmentExpression.left !== memberExpression) return false;
 				return getIdentifierBindingIdentity(analysis, assignmentExpression.right) !== callbackBinding;
 			})) forwardsCallback = true;
 		});
@@ -23265,7 +23115,7 @@ const resolveWrappedCallable = (analysis, node) => {
 		return callback && isFunctionLike$1(callback) ? callback : null;
 	}
 	if (!isNodeOfType(candidate, "MemberExpression")) return null;
-	if (getStaticMemberName$1(candidate) !== "current") return null;
+	if (getStaticMemberName(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"));
@@ -23277,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$1(member) === "current" && assignment && isNodeOfType(assignment, "AssignmentExpression") && assignment.left === member);
+		return Boolean(member && isNodeOfType(member, "MemberExpression") && getStaticMemberName(member) === "current" && assignment && isNodeOfType(assignment, "AssignmentExpression") && assignment.left === member);
 	})) ? null : initializer;
 };
 const functionInvokesItself = (analysis, functionNode) => {
@@ -23316,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$1(callee);
+		const memberName = getStaticMemberName(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) => {
@@ -23480,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$1(callee);
+		const namespaceMemberName = getStaticMemberName(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$1(callee) ?? "");
+		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(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));
@@ -23556,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$1(memberExpression) !== "current" || !isNodeOfType(memberExpression.object, "Identifier")) return null;
+	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName(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()) => {
@@ -23625,7 +23475,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		return collectValueEvidence(analysis, initializer.init, frame, remainingCallFrames, visitedBindings);
 	}
 	if (isNodeOfType(node, "MemberExpression")) {
-		if (getStaticMemberName$1(node) === "current" && isNodeOfType(node.object, "Identifier")) {
+		if (getStaticMemberName(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")) {
@@ -23641,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$1(member) !== "current") {
+					if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== identifier || getStaticMemberName(member) !== "current") {
 						evidence.hasUnknownSource = true;
 						continue;
 					}
@@ -23678,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$1(callee) ?? "");
+		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(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 ?? []) {
@@ -24148,26 +23998,6 @@ const STATEFUL_HTML_DESCENDANT_TAGS = new Set([
 	"dialog",
 	"canvas"
 ]);
-const STATEFUL_HTML_ATTRIBUTE_NAMES = new Set([
-	"autofocus",
-	"contenteditable",
-	"draggable",
-	"tabindex"
-]);
-const isStaticallyFalseAttributeValue = (attribute) => {
-	if (!isNodeOfType(attribute, "JSXAttribute") || !attribute.value) return false;
-	const value = isNodeOfType(attribute.value, "JSXExpressionContainer") ? attribute.value.expression : attribute.value;
-	return isNodeOfType(value, "Literal") && (value.value === false || value.value === "false");
-};
-const hasStatefulHtmlAttribute = (openingElement) => {
-	if (!isNodeOfType(openingElement, "JSXOpeningElement")) return false;
-	return openingElement.attributes.some((attribute) => {
-		if (!isNodeOfType(attribute, "JSXAttribute") || !isNodeOfType(attribute.name, "JSXIdentifier")) return false;
-		const attributeName = attribute.name.name.toLowerCase();
-		if (!STATEFUL_HTML_ATTRIBUTE_NAMES.has(attributeName)) return false;
-		return attributeName === "tabindex" || !isStaticallyFalseAttributeValue(attribute);
-	});
-};
 const STATEFUL_DESCENDANT_SCAN_BUDGET = 200;
 const rootIdentifierNameOf = (expression) => {
 	let object = expression;
@@ -24185,8 +24015,7 @@ const containsStatefulDescendant = (jsxElement, options = {}) => {
 		budget -= 1;
 		const node = stack.pop();
 		if (isNodeOfType(node, "JSXElement")) {
-			const opening = node.openingElement;
-			const name = opening.name;
+			const name = node.openingElement.name;
 			if (name && isNodeOfType(name, "JSXIdentifier")) {
 				const tagName = name.name;
 				const firstChar = tagName.charCodeAt(0);
@@ -24194,7 +24023,6 @@ const containsStatefulDescendant = (jsxElement, options = {}) => {
 				if (STATEFUL_HTML_DESCENDANT_TAGS.has(tagName)) return true;
 			}
 			if (name && isNodeOfType(name, "JSXMemberExpression")) return true;
-			if (hasStatefulHtmlAttribute(opening)) return true;
 			const children = node.children ?? [];
 			for (const child of children) stack.push(child);
 			continue;
@@ -24288,7 +24116,6 @@ const ARITHMETIC_KEY_OPERATORS = new Set([
 	"/",
 	"%"
 ]);
-const bindingMutationResultsByProgram = /* @__PURE__ */ new WeakMap();
 const extractCandidateIdentifiers = (expression) => {
 	const node = stripParenExpression(expression);
 	if (isNodeOfType(node, "Identifier")) return [node];
@@ -24329,13 +24156,6 @@ 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;
@@ -24352,7 +24172,6 @@ const isBindingReassignedOrMutated = (referenceNode, bindingName) => {
 			return false;
 		}
 	});
-	mutationResultsByBindingName.set(bindingName, didFindWrite);
 	return didFindWrite;
 };
 /**
@@ -24754,14 +24573,6 @@ const templateHasOuterMemberIdentity = (template, bindingFunction) => {
 	}
 	return false;
 };
-const findBareItemNamesReferencedByTemplate = (template, itemNames) => {
-	const referencedItemNames = /* @__PURE__ */ new Set();
-	for (const expression of template.expressions ?? []) {
-		const unwrappedExpression = stripParenExpression(expression);
-		if (isNodeOfType(unwrappedExpression, "Identifier") && itemNames.has(unwrappedExpression.name)) referencedItemNames.add(unwrappedExpression.name);
-	}
-	return referencedItemNames;
-};
 const forLoopTestReadsDataLength = (test) => {
 	let didFindLengthRead = false;
 	walkAst(test, (child) => {
@@ -24898,11 +24709,9 @@ const noArrayIndexAsKey = defineRule({
 				} else if (STATELESS_HTML_LEAF_TAGS.has(elementName.name)) {
 					const jsxElement = openingElement.parent;
 					if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
-						const isInlineTextRun = INLINE_TEXT_LEAF_TAGS.has(elementName.name);
-						const primitiveItemNames = keyTemplate ? findBareItemNamesReferencedByTemplate(keyTemplate, itemNames) : EMPTY_NAME_SET;
 						if (!containsStatefulDescendant(jsxElement, {
-							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET,
-							bareIdentifierNames: primitiveItemNames.size > 0 ? new Set([...derivedNames, ...primitiveItemNames]) : derivedNames
+							memberRootNames: INLINE_TEXT_LEAF_TAGS.has(elementName.name) ? itemNames : EMPTY_NAME_SET,
+							bareIdentifierNames: derivedNames
 						})) return;
 					}
 				}
@@ -25463,10 +25272,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) => DEPENDENCY_SECTION_NAMES.some((sectionName) => {
-	const section = manifest[sectionName];
-	return typeof section === "object" && section !== null && Object.prototype.propertyIsEnumerable.call(section, dependencyName);
-});
+const declaresDependency = (manifest, dependencyName) => {
+	for (const declaredName of iterateDependencyNames(manifest)) if (declaredName === dependencyName) return true;
+	return false;
+};
 const cachedPlatformByManifest = /* @__PURE__ */ new WeakMap();
 const classifyPackagePlatform = (filename) => {
 	const manifest = readNearestPackageManifest(filename);
@@ -25713,23 +25522,25 @@ 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 = (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 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 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, scopes);
+	const hasRenderOutput = containsRenderOutput$1(functionNode, functionNode, scopes);
 	renderOutputCache.set(functionNode, {
 		scopes,
 		hasRenderOutput
@@ -27535,7 +27346,7 @@ const isSetStateCallInLifecycle = (setStateCall, lifecycleNames, options = {}) =
 	let ancestor = setStateCall.parent;
 	while (ancestor) {
 		if (!lifecycleMember) {
-			if (FUNCTION_NODE_TYPES$1.has(ancestor.type) && (!isImmediatelyInvokedFunction(ancestor) || !("async" in ancestor) || ancestor.async === true)) nestedFunctionCount += 1;
+			if (FUNCTION_NODE_TYPES$1.has(ancestor.type)) nestedFunctionCount += 1;
 			if (isLifecycleMember(ancestor, lifecycleNames)) lifecycleMember = ancestor;
 		} else if (isEs5Component(ancestor) || isEs6Component(ancestor)) {
 			if (nestedFunctionCount > 1 && !options.disallowInNestedFunctions) return false;
@@ -27737,7 +27548,7 @@ const collectDiffSourceLocalNames = (lifecycleFunction, paramNames) => {
 	const body = lifecycleFunction.body;
 	if (!body) return derivedNames;
 	walkAst(body, (node) => {
-		if (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node)) return false;
+		if (FUNCTION_NODE_TYPES.has(node.type)) return false;
 		if (!isNodeOfType(node, "VariableDeclarator")) return;
 		const init = node.init;
 		if (!init) return;
@@ -27747,67 +27558,6 @@ 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;
@@ -27815,7 +27565,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) && (referencesAnyName(node.left, derivedNames) || referencesAnyName(node.right, derivedNames))) {
+		if (isStatefulOperand(node.left, paramNames, derivedNames) && isStatefulOperand(node.right, paramNames, derivedNames)) {
 			qualifies = true;
 			return false;
 		}
@@ -27828,12 +27578,11 @@ 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) || isConvergentPostMountGuard(guardTest, setStateCall, localInitializers))) return true;
+		if (guardTest && isDiffGuardTest(guardTest, paramNames, derivedNames)) return true;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
 	}
@@ -28014,16 +27763,7 @@ 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;
@@ -28040,10 +27780,21 @@ const collectSetterValueObservations = (componentBody, setterNames) => {
 	}, true);
 	return {
 		plainFedSetterNames,
-		opaqueFedSetterNames,
-		callbackRefSetterNames
+		opaqueFedSetterNames
 	};
 };
+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;
@@ -28055,8 +27806,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);
@@ -28064,22 +27815,17 @@ 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")) {
-		const blockBindings = /* @__PURE__ */ new Set();
-		for (const declarator of node.left.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
-		return blockBindings;
-	}
-	return null;
+	if ((isNodeOfType(node, "ForOfStatement") || isNodeOfType(node, "ForInStatement")) && isNodeOfType(node.left, "VariableDeclaration")) for (const declarator of node.left.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
+	return blockBindings;
 };
 const walkComponentRespectingShadows = (node, shadowedStateNames, visit, isComponentBodyRoot = false) => {
 	if (!node || typeof node !== "object") return;
 	let nextShadowedStateNames = shadowedStateNames;
-	const localBindings = isComponentBodyRoot ? null : isFunctionLike$1(node) ? collectFunctionLocalBindings(node) : collectBlockScopedBindings(node);
-	if (localBindings && localBindings.size > 0) {
+	const localBindings = isComponentBodyRoot ? /* @__PURE__ */ new Set() : isFunctionLike$1(node) ? collectFunctionLocalBindings(node) : collectBlockScopedBindings(node);
+	if (localBindings.size > 0) {
 		const merged = new Set(shadowedStateNames);
 		for (const localName of localBindings) merged.add(localName);
 		nextShadowedStateNames = merged;
@@ -28105,10 +27851,11 @@ 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 (setterValueObservations.callbackRefSetterNames.has(binding.setterName)) continue;
+				if (callbackRefSetterNames.has(binding.setterName)) continue;
 				if (!isNodeOfType(binding.declarator.init, "CallExpression")) continue;
 				const initializerArgument = binding.declarator.init.arguments?.[0];
 				if (!initializerMarksPlainState(initializerArgument)) continue;
@@ -32826,60 +32573,25 @@ const resolveSettings$16 = (settings) => {
 };
 const isHocCall = (call, scopes) => {
 	if (!isNodeOfType(call, "CallExpression")) return false;
-	if (isReactApiCall(call, REACT_HOC_NAMES, scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true
-	})) return true;
-	if (isReactHocMemberReference(call.callee, scopes)) return true;
+	const calleeName = flattenCalleeName(call.callee);
+	if (calleeName && REACT_HOC_NAMES.has(calleeName)) return true;
 	if (!isNodeOfType(call.callee, "Identifier")) return false;
 	const symbol = scopes.symbolFor(call.callee);
 	if (!symbol) return false;
-	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));
+	return symbolMapsToHoc(symbol);
 };
-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, 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 symbolMapsToHoc = (symbol) => {
+	if (REACT_HOC_NAMES.has(symbol.name)) {
+		if (symbol.kind === "import") return true;
 	}
 	const init = symbol.initializer;
 	if (!init) return false;
-	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, "MemberExpression")) {
+		const flat = flattenCalleeName(init);
+		if (flat && REACT_HOC_NAMES.has(flat)) return true;
 	}
+	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) => {
@@ -32937,14 +32649,26 @@ const isHocComponent = (call, scopes) => {
 };
 const containsJsx = (root) => {
 	let found = false;
-	walkAst(root, (node) => {
-		if (found) return false;
+	const visit = (node) => {
+		if (found) return;
 		if (node.type === "JSXElement" || node.type === "JSXFragment") {
 			found = true;
-			return false;
+			return;
 		}
-		if (node !== root && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ClassDeclaration" || node.type === "ClassExpression")) return false;
-	});
+		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;
+		}
+	};
+	visit(root);
 	return found;
 };
 const expressionContainsJsx = (expression) => {
@@ -32968,7 +32692,7 @@ const unwrapTsCast = (expression) => {
 	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression") current = stripParenExpression(current.expression);
 	return current;
 };
-const collectReExportedNames = (program, scopes) => {
+const collectReExportedNames = (program) => {
 	const names = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(program, "Program")) return names;
 	for (const statement of program.body) {
@@ -32992,7 +32716,8 @@ const collectReExportedNames = (program, scopes) => {
 			if (!declarator.init) continue;
 			const init = unwrapTsCast(declarator.init);
 			if (isNodeOfType(init, "CallExpression")) {
-				if (isHocCall(init, scopes)) {
+				const calleeName = flattenCalleeName(init.callee);
+				if (calleeName && REACT_HOC_NAMES.has(calleeName)) {
 					const wrappedArg = init.arguments[0];
 					if (wrappedArg && isNodeOfType(wrappedArg, "Identifier")) names.add(wrappedArg.name);
 				}
@@ -33061,7 +32786,16 @@ const recordComponent = (context, name, reportNode, isStateless) => {
 		isStateless
 	});
 };
-const walkChildren = (node, context) => forEachChildNode(node, context.visitChild);
+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 walkComponentSearch = (node, context) => {
 	if (isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression")) {
 		if (isEs6Component(node)) {
@@ -33163,13 +32897,12 @@ const noMultiComp = defineRule({
 				components: [],
 				componentDepth: 0,
 				currentVarName: null,
-				scopes: context.scopes,
-				visitChild: (child) => walkComponentSearch(child, visitContext)
+				scopes: context.scopes
 			};
 			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, context.scopes);
+			const reExportedNames = collectReExportedNames(node);
 			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;
@@ -35199,30 +34932,6 @@ const guardsRenderShape = (comparison) => {
 	}
 	return false;
 };
-const isPropsChildrenLength = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	return isNodeOfType(unwrappedNode, "MemberExpression") && !unwrappedNode.computed && isNodeOfType(unwrappedNode.property, "Identifier") && unwrappedNode.property.name === "length" && resolvesToPropsChildren(stripParenExpression(unwrappedNode.object), scopes);
-};
-const isLargeTextLengthComparison = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "BinaryExpression")) return false;
-	const leftIsLength = isPropsChildrenLength(unwrappedNode.left, scopes);
-	const rightIsLength = isPropsChildrenLength(unwrappedNode.right, scopes);
-	const thresholdNode = leftIsLength ? unwrappedNode.right : unwrappedNode.left;
-	if (!leftIsLength && !rightIsLength || !isNodeOfType(thresholdNode, "Literal")) return false;
-	if (typeof thresholdNode.value !== "number" || thresholdNode.value < 1e3) return false;
-	return leftIsLength ? unwrappedNode.operator === ">" || unwrappedNode.operator === ">=" : unwrappedNode.operator === "<" || unwrappedNode.operator === "<=";
-};
-const isLargeStringOptimizationGuard = (comparison, scopes) => {
-	let current = findTransparentExpressionRoot(comparison);
-	while (current.parent) {
-		const parent = current.parent;
-		if (!isNodeOfType(parent, "LogicalExpression") || parent.operator !== "&&") return false;
-		if (isLargeTextLengthComparison(parent.left === current ? parent.right : parent.left, scopes)) return true;
-		current = findTransparentExpressionRoot(parent);
-	}
-	return false;
-};
 const noPolymorphicChildren = defineRule({
 	id: "no-polymorphic-children",
 	title: "Children type checked at runtime",
@@ -35236,7 +34945,6 @@ const noPolymorphicChildren = defineRule({
 		const isStringLiteral = (operand) => isNodeOfType(operand, "Literal") && operand.value === "string";
 		if (!isStringLiteral(node.left) && !isStringLiteral(node.right)) return;
 		if (!guardsRenderShape(node)) return;
-		if (isLargeStringOptimizationGuard(node, context.scopes)) return;
 		context.report({
 			node,
 			message: "Your users hit inconsistent behavior because `typeof children === \"string\"` makes this component switch on what callers pass, so add clear subcomponents like `<Button.Text>` instead."
@@ -35454,27 +35162,6 @@ const hasPreviousValueDep = (effectNode, depElements) => {
 	}
 	return false;
 };
-const isStateLikeDependency = (analysis, element, isPropName) => {
-	if (!isNodeOfType(element, "Identifier") || isPropName(element.name)) return false;
-	if (!analysis) return true;
-	const reference = getRef(analysis, element);
-	if (!reference) return true;
-	const upstreamReferences = getUpstreamRefs(analysis, reference);
-	if (upstreamReferences.some((upstreamReference) => isState(analysis, upstreamReference))) return true;
-	return !upstreamReferences.some((upstreamReference) => isProp(analysis, upstreamReference));
-};
-const getRefHeldPropCallbackName = (callExpression, isPropName) => {
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "current") return null;
-	const receiver = stripParenExpression(callee.object);
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const binding = findVariableInitializer(callExpression, receiver.name);
-	if (!binding?.initializer || !isNodeOfType(binding.initializer, "CallExpression")) return null;
-	if (getCalleeName$2(binding.initializer) !== "useRef") return null;
-	const callbackArgument = binding.initializer.arguments?.[0];
-	if (!callbackArgument || !isNodeOfType(callbackArgument, "Identifier")) return null;
-	return isPropName(callbackArgument.name) ? callbackArgument.name : null;
-};
 const noPropCallbackInEffect = defineRule({
 	id: "no-prop-callback-in-effect",
 	title: "Parent kept in sync with a callback effect",
@@ -35491,11 +35178,11 @@ const noPropCallbackInEffect = defineRule({
 				if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
 				const depsNode = node.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression") || !depsNode.elements?.length) return;
-				const analysis = getProgramAnalysis(node);
-				const stateLikeDeps = (depsNode.elements ?? []).filter((element) => element && isStateLikeDependency(analysis, element, propStackTracker.isPropName));
+				const stateLikeDeps = (depsNode.elements ?? []).filter((element) => isNodeOfType(element, "Identifier") && !propStackTracker.isPropName(element.name));
 				if (stateLikeDeps.length === 0) return;
 				if (isRefLatchGuardedEffect(callback.body)) return;
 				if (hasPreviousValueDep(node, depsNode.elements ?? [])) return;
+				const analysis = getProgramAnalysis(node);
 				if (analysis) {
 					const stateLikeDepRefs = [];
 					for (const element of stateLikeDeps) {
@@ -35507,9 +35194,9 @@ const noPropCallbackInEffect = defineRule({
 				const reportedNodes = /* @__PURE__ */ new Set();
 				walkInsideStatementBlocks(callback.body, (child) => {
 					if (!isNodeOfType(child, "CallExpression")) return;
-					const directCallee = stripParenExpression(child.callee);
-					const calleeName = isNodeOfType(directCallee, "Identifier") && propStackTracker.isPropName(directCallee.name) && directCallee.name || getRefHeldPropCallbackName(child, propStackTracker.isPropName);
-					if (!calleeName) return;
+					if (!isNodeOfType(child.callee, "Identifier")) return;
+					const calleeName = child.callee.name;
+					if (!propStackTracker.isPropName(calleeName)) return;
 					if (!isResultDiscardedCall(child)) return;
 					if (reportedNodes.has(child)) return;
 					reportedNodes.add(child);
@@ -39683,18 +39370,34 @@ const resolveSettings$8 = (settings) => {
 };
 const expressionContainsJsxOrCreateElement = (root) => {
 	let found = false;
-	walkAst(root, (node) => {
-		if (found) return false;
-		if (node !== root && NESTED_FUNCTION_TYPES.has(node.type)) return false;
+	const visit = (node) => {
+		if (found) return;
 		if (node.type === "JSXElement" || node.type === "JSXFragment") {
 			found = true;
-			return false;
+			return;
 		}
 		if (isNodeOfType(node, "CallExpression") && isCreateElementCall(node)) {
 			found = true;
-			return false;
+			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;
+		}
+	};
+	visit(root);
 	return found;
 };
 const isReactClassComponent = (classNode) => {
@@ -40620,6 +40323,19 @@ 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);
@@ -40658,212 +40374,197 @@ const onlyExportComponents = defineRule({
 	category: "Architecture",
 	create: (context) => {
 		const settings = resolveSettings$6(context.settings);
-		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);
-						}
-					}
+		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);
 				}
-				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, "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 (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({
+				}
+			}
+			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
 							});
-							continue;
-						}
-						if (isNodeOfType(stripped, "Identifier")) {
-							exports.push(classifyExport(stripped.name, stripped, false, null, state));
-							continue;
+							hasReactExport = true;
 						}
-						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({
+						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: 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
+								reportNode: idNode
 							});
+						} 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: child,
+							node: stripped,
 							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
-								});
-							}
+					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));
 						}
-						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);
+						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" });
 						}
+						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({
+			}
+			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: NAMESPACE_OBJECT_MESSAGE
+					message: NAMED_EXPORT_MESSAGE
+				});
+				if (entry.kind === "react-context") context.report({
+					node: entry.reportNode,
+					message: REACT_CONTEXT_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
@@ -40965,12 +40666,7 @@ const postmessageOriginRisk = defineRule({
 	scan: (file) => {
 		if (!isProductionSourcePath(file.relativePath)) return [];
 		if (WORKER_FILE_PATH_PATTERN.test(file.relativePath)) return [];
-		if (!file.content.includes("addEventListener") && !file.content.includes("onmessage")) return [];
-		const ast = parseSourceText({
-			filename: file.absolutePath,
-			sourceText: file.content,
-			shouldAttachParentReferences: false
-		});
+		const ast = parseSourceText(file.absolutePath, file.content);
 		if (ast === null) return [];
 		const findings = [];
 		walkAst(ast, (node) => {
@@ -43350,6 +43046,15 @@ 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",
@@ -59848,10 +59553,7 @@ const appendNode = (builder, block, node) => {
 };
 const mapDescendantsToBlock = (builder, node, block) => {
 	builder.nodeBlock.set(node, block);
-	if (isFunctionLike$1(node)) {
-		builder.nestedFunctions.push(node);
-		return;
-	}
+	if (isFunctionLike$1(node)) return;
 	const record = node;
 	for (const key of Object.keys(record)) {
 		if (key === "parent") continue;
@@ -60085,12 +59787,11 @@ const buildStatement = (builder, statement, current) => {
 	mapDescendantsToBlock(builder, statement, current);
 	return current;
 };
-const buildFunctionCfg = (functionNode, body, nestedFunctionSink) => {
+const buildFunctionCfg = (functionNode, body) => {
 	const builder = {
 		blocks: [],
 		entry: null,
 		exit: null,
-		nestedFunctions: nestedFunctionSink,
 		nodeBlock: /* @__PURE__ */ new Map(),
 		loopStack: [],
 		switchStack: [],
@@ -60108,12 +59809,13 @@ const buildFunctionCfg = (functionNode, body, nestedFunctionSink) => {
 		bodyEnd = entry;
 	}
 	addEdge(bodyEnd, exit, "uncond");
+	const blockOf = (node) => builder.nodeBlock.get(node) ?? null;
 	return {
 		owner: functionNode,
 		entry,
 		exit,
 		blocks: builder.blocks,
-		blockOf: (node) => builder.nodeBlock.get(node) ?? null
+		blockOf
 	};
 };
 const computeUnconditionalSet = (cfg) => {
@@ -60150,9 +59852,8 @@ const computeUnconditionalSet = (cfg) => {
 const analyzeControlFlow = (program) => {
 	nextBlockId = 0;
 	const functionCfgs = /* @__PURE__ */ new Map();
-	const pendingFunctions = [];
 	const buildFor = (functionNode, body) => {
-		const cfg = buildFunctionCfg(functionNode, body, pendingFunctions);
+		const cfg = buildFunctionCfg(functionNode, body);
 		functionCfgs.set(functionNode, {
 			cfg,
 			unconditionalSet: computeUnconditionalSet(cfg)
@@ -60162,18 +59863,21 @@ const analyzeControlFlow = (program) => {
 		type: "BlockStatement",
 		body: program.body
 	});
-	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;
+	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);
+		}
 	};
+	visit(program);
 	const enclosingFunction = (node) => {
 		let current = node;
 		while (current) {
@@ -60184,12 +59888,12 @@ const analyzeControlFlow = (program) => {
 		return null;
 	};
 	const cfgFor = (functionLike) => {
-		return getFunctionEntry(functionLike)?.cfg ?? null;
+		return functionCfgs.get(functionLike)?.cfg ?? null;
 	};
 	const isUnconditionalFromEntry = (node) => {
 		const owner = enclosingFunction(node);
 		if (!owner) return true;
-		const entry = getFunctionEntry(owner);
+		const entry = functionCfgs.get(owner);
 		if (!entry) return true;
 		const block = entry.cfg.blockOf(node);
 		if (!block) return true;
@@ -60263,14 +59967,17 @@ const wrapWithSemanticContext = (rule) => ({
 			}
 		};
 		const visitors = rule.create(enrichedContext);
-		const innerProgramHandler = visitors.Program;
-		return {
-			...visitors,
-			Program: ((node) => {
-				programRoot = node;
-				if (innerProgramHandler) innerProgramHandler(node);
-			})
-		};
+		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;
 	}
 });
 //#endregion