oxlint-plugin-react-doctor 0.7.5 → 0.7.6-dev.0150fc9

package/dist/index.js

@@ -1,14 +1,11 @@
+import { KEYS } from "eslint-visitor-keys";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { readFileSync } from "node:fs";
-import { parseSync } from "oxc-parser";
+import { parseSync, visitorKeys } from "oxc-parser";
 import { analyze } from "eslint-scope";
-import * as eslintVisitorKeys from "eslint-visitor-keys";
-//#region src/plugin/utils/has-type-property.ts
-const hasTypeProperty = (value) => Boolean(value && typeof value === "object" && "type" in value);
-//#endregion
 //#region src/plugin/utils/is-node-of-type.ts
-const isNodeOfType = (node, type) => Boolean(hasTypeProperty(node) && node.type === type);
+const isNodeOfType = (node, type) => node !== null && typeof node === "object" && "type" in node && node.type === type;
 //#endregion
 //#region src/plugin/utils/non-react-jsx-dialect.ts
 const NON_REACT_JSX_DIALECT_PACKAGES = new Set([
@@ -400,6 +397,7 @@ 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
@@ -565,7 +563,8 @@ const REACT_RUNTIME_MODULE_SOURCES = new Set([
 	"react",
 	"react-dom",
 	"preact/compat",
-	"preact/hooks"
+	"preact/hooks",
+	"@wordpress/element"
 ]);
 const REACT_ECOSYSTEM_PACKAGE_NAMES = new Set([
 	"next",
@@ -802,24 +801,55 @@ const isHookCall$2 = (node, hookName) => {
 };
 //#endregion
 //#region src/plugin/utils/is-ast-node.ts
-const isAstNode = (value) => {
-	if (!hasTypeProperty(value)) return false;
-	return typeof value.type === "string";
+const isAstNode = (value) => value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+//#endregion
+//#region src/plugin/utils/runtime-visitor-keys.ts
+const RUNTIME_VISITOR_KEYS = {
+	...KEYS,
+	ArrayPattern: ["decorators", ...KEYS.ArrayPattern],
+	AssignmentPattern: ["decorators", ...KEYS.AssignmentPattern],
+	ClassDeclaration: ["decorators", ...KEYS.ClassDeclaration],
+	ClassExpression: ["decorators", ...KEYS.ClassExpression],
+	Identifier: ["decorators", ...KEYS.Identifier],
+	MethodDefinition: ["decorators", ...KEYS.MethodDefinition],
+	ObjectPattern: ["decorators", ...KEYS.ObjectPattern],
+	PropertyDefinition: ["decorators", ...KEYS.PropertyDefinition],
+	RestElement: ["decorators", ...KEYS.RestElement]
 };
 //#endregion
 //#region src/plugin/utils/walk-ast.ts
-const walkAst = (node, visitor) => {
-	if (!node || typeof node !== "object") return;
-	if (visitor(node) === false) return;
+const forEachChildNode = (node, visit) => {
 	const nodeRecord = node;
-	for (const key of Object.keys(nodeRecord)) {
-		if (key === "parent") continue;
+	const childKeys = RUNTIME_VISITOR_KEYS[node.type];
+	if (childKeys !== void 0) {
+		for (let keyIndex = 0; keyIndex < childKeys.length; keyIndex += 1) {
+			const child = nodeRecord[childKeys[keyIndex]];
+			if (Array.isArray(child)) for (let itemIndex = 0; itemIndex < child.length; itemIndex += 1) {
+				const item = child[itemIndex];
+				if (isAstNode(item)) visit(item);
+			}
+			else if (isAstNode(child)) visit(child);
+		}
+		return;
+	}
+	for (const key in nodeRecord) {
+		if (key === "parent" || !Object.hasOwn(nodeRecord, key)) continue;
 		const child = nodeRecord[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (isAstNode(item)) walkAst(item, visitor);
-		} else if (isAstNode(child)) walkAst(child, visitor);
+		if (Array.isArray(child)) for (let itemIndex = 0; itemIndex < child.length; itemIndex += 1) {
+			const item = child[itemIndex];
+			if (isAstNode(item)) visit(item);
+		}
+		else if (isAstNode(child)) visit(child);
 	}
 };
+const walkAst = (node, visitor) => {
+	if (!node || typeof node !== "object") return;
+	const visitNode = (current) => {
+		if (visitor(current) === false) return;
+		forEachChildNode(current, visitNode);
+	};
+	visitNode(node);
+};
 //#endregion
 //#region src/plugin/rules/state-and-effects/activity-wraps-effect-heavy-subtree.ts
 const ACTIVITY_IMPORTED_NAMES = new Set(["Activity", "unstable_Activity"]);
@@ -1262,7 +1292,7 @@ const REGEX_PRECEDING_KEYWORDS = new Set([
 	"await",
 	"throw"
 ]);
-const isRegexLiteralStart = (characters, slashIndex) => {
+const isRegexLiteralStart = (content, characters, slashIndex) => {
 	let cursor = slashIndex - 1;
 	while (cursor >= 0 && WHITESPACE_PATTERN.test(characters[cursor])) cursor -= 1;
 	if (cursor < 0) return true;
@@ -1272,7 +1302,7 @@ const isRegexLiteralStart = (characters, slashIndex) => {
 		let wordStartIndex = cursor;
 		while (wordStartIndex > 0 && IDENTIFIER_CHARACTER_PATTERN.test(characters[wordStartIndex - 1])) wordStartIndex -= 1;
 		if (wordStartIndex > 0 && characters[wordStartIndex - 1] === ".") return false;
-		return REGEX_PRECEDING_KEYWORDS.has(characters.slice(wordStartIndex, cursor + 1).join(""));
+		return REGEX_PRECEDING_KEYWORDS.has(content.slice(wordStartIndex, cursor + 1));
 	}
 	if (previousCharacter === "<") return false;
 	if (previousCharacter === ">") return characterBefore === "=";
@@ -1313,13 +1343,15 @@ const quotedLiteralHasWhitespace = (content, openQuoteIndex, delimiter) => {
 	return false;
 };
 const blankNonCodePreservingPositions = (content, blankStringContents) => {
-	const characters = content.split("");
+	let characters = null;
 	let stringDelimiter = null;
 	let isBlankingString = false;
 	const templateExpressionDepths = [];
 	let index = 0;
 	const blankUnlessNewline = (offset) => {
-		if (offset < content.length && content[offset] !== "\n") characters[offset] = " ";
+		if (offset >= content.length || content[offset] === "\n") return;
+		characters ??= content.split("");
+		characters[offset] = " ";
 	};
 	while (index < content.length) {
 		const character = content[index];
@@ -1366,6 +1398,7 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 			continue;
 		}
 		if (character === "/" && nextCharacter === "/") {
+			characters ??= content.split("");
 			while (index < content.length && content[index] !== "\n") {
 				characters[index] = " ";
 				index += 1;
@@ -1373,6 +1406,7 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 			continue;
 		}
 		if (character === "/" && nextCharacter === "*") {
+			characters ??= content.split("");
 			while (index < content.length) {
 				if (content[index] === "*" && content[index + 1] === "/") {
 					characters[index] = " ";
@@ -1386,7 +1420,7 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 			continue;
 		}
 		if (character === "/") {
-			const regexEndIndex = isRegexLiteralStart(characters, index) ? findRegexLiteralEnd(content, index) : null;
+			const regexEndIndex = isRegexLiteralStart(content, characters ?? content, index) ? findRegexLiteralEnd(content, index) : null;
 			if (regexEndIndex !== null) {
 				if (blankStringContents) for (let interiorIndex = index + 1; interiorIndex < regexEndIndex - 1; interiorIndex += 1) blankUnlessNewline(interiorIndex);
 				index = regexEndIndex;
@@ -1404,9 +1438,9 @@ const blankNonCodePreservingPositions = (content, blankStringContents) => {
 		}
 		index += 1;
 	}
-	return characters.join("");
+	return characters?.join("") ?? content;
 };
-const stripCommentsPreservingPositions = (content) => blankNonCodePreservingPositions(content, false);
+const stripCommentsPreservingPositions = (content) => content.includes("//") || content.includes("/*") ? blankNonCodePreservingPositions(content, false) : content;
 const stripCommentsAndStringLiteralsPreservingPositions = (content) => blankNonCodePreservingPositions(content, true);
 //#endregion
 //#region src/plugin/rules/security-scan/utils/scan-by-pattern.ts
@@ -1425,10 +1459,15 @@ const scanByPattern = ({ shouldScan, pattern, requireAll, suppressWhen, ignoreSt
 	if (!shouldScan(file)) return [];
 	const content = getScannableContent(file, ignoreStringLiterals);
 	if (requireAll !== void 0 && !requireAll.every((gate) => gate.test(content))) return [];
-	const matchedPattern = (pattern instanceof RegExp ? [pattern] : pattern).find((candidate) => candidate.test(content));
-	if (matchedPattern === void 0) return [];
+	let matchIndex = -1;
+	if (pattern instanceof RegExp) matchIndex = content.search(pattern);
+	else for (let patternIndex = 0; patternIndex < pattern.length; patternIndex += 1) {
+		matchIndex = content.search(pattern[patternIndex]);
+		if (matchIndex >= 0) break;
+	}
+	if (matchIndex < 0) return [];
 	if (suppressWhen !== void 0 && suppressWhen.test(content)) return [];
-	const { line, column } = getMatchLocation(content, matchedPattern);
+	const { line, column } = getLocationAtIndex(content, matchIndex);
 	return [{
 		message,
 		line,
@@ -1438,6 +1477,7 @@ const scanByPattern = ({ shouldScan, pattern, requireAll, suppressWhen, ignoreSt
 //#endregion
 //#region src/plugin/rules/security-scan/agent-tool-capability-risk.ts
 const AGENT_TOOL_DEFINITION_PATTERN = /\b(?:tool\s*\(\s*\{|createTool\s*\(|defineTool\s*\(|new\s+(?:DynamicTool|StructuredTool)\s*\()/;
+const AGENT_TOOL_DEFINITION_PREFILTER_PATTERN = /\b(?:tool|createTool|defineTool|DynamicTool|StructuredTool)\b/;
 const AGENT_TOOL_CONTEXT_PATH_PATTERN = /(?:^|\/)(?:agents?|tools?|mcp)(?:\/|$)|(?:agent|tool|mcp)[^/]*\.[cm]?[jt]sx?$/i;
 const agentToolCapabilityRisk = defineRule({
 	id: "agent-tool-capability-risk",
@@ -1445,7 +1485,7 @@ const agentToolCapabilityRisk = defineRule({
 	severity: "warn",
 	recommendation: "Treat tool inputs as prompt-injection controlled. Validate arguments, scope permissions per call, and avoid exposing shell/file/network primitives directly to agents.",
 	scan: scanByPattern({
-		shouldScan: (file) => isProductionSourcePath(file.relativePath) && AGENT_TOOL_CONTEXT_PATH_PATTERN.test(file.relativePath),
+		shouldScan: (file) => isProductionSourcePath(file.relativePath) && AGENT_TOOL_CONTEXT_PATH_PATTERN.test(file.relativePath) && AGENT_TOOL_DEFINITION_PREFILTER_PATTERN.test(file.content) && AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN.test(file.content),
 		pattern: AGENT_TOOL_DEFINITION_PATTERN,
 		requireAll: [AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN],
 		ignoreStringLiterals: true,
@@ -1478,6 +1518,37 @@ const hasJsxPropIgnoreCase = (attributes, targetProp) => {
 	}
 };
 //#endregion
+//#region src/plugin/utils/is-uppercase-name.ts
+const isUppercaseName = (name) => UPPERCASE_PATTERN.test(name);
+//#endregion
+//#region src/plugin/utils/resolve-jsx-element-type.ts
+const resolveConstantStringBinding = (name) => {
+	const binding = findVariableInitializer(name, name.name);
+	if (!binding?.initializer) return null;
+	const declarator = binding.bindingIdentifier.parent;
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return null;
+	if (declarator.id !== binding.bindingIdentifier) return null;
+	const declaration = declarator.parent;
+	if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) return null;
+	if (declaration.kind !== "const") return null;
+	const initializer = stripParenExpression(binding.initializer);
+	return isNodeOfType(initializer, "Literal") && typeof initializer.value === "string" ? initializer.value : null;
+};
+const flattenJsxName$2 = (name) => {
+	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
+	if (isNodeOfType(name, "JSXMemberExpression")) return `${flattenJsxName$2(name.object)}.${name.property.name}`;
+	if (isNodeOfType(name, "JSXNamespacedName")) return `${name.namespace.name}:${name.name.name}`;
+	return "";
+};
+const resolveJsxElementType = (openingElement) => {
+	const name = openingElement.name;
+	if (isNodeOfType(name, "JSXIdentifier")) {
+		if (!isUppercaseName(name.name)) return name.name;
+		return resolveConstantStringBinding(name) ?? name.name;
+	}
+	return flattenJsxName$2(name);
+};
+//#endregion
 //#region src/plugin/utils/get-element-type.ts
 const EMPTY_JSX_A11Y_SETTINGS = Object.freeze({});
 const jsxA11ySettingsCache = /* @__PURE__ */ new WeakMap();
@@ -1490,14 +1561,8 @@ const readJsxA11ySettings = (settings) => {
 	jsxA11ySettingsCache.set(settings, a11ySettings);
 	return a11ySettings;
 };
-const flattenJsxName$2 = (name) => {
-	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
-	if (isNodeOfType(name, "JSXMemberExpression")) return `${flattenJsxName$2(name.object)}.${name.property.name}`;
-	if (isNodeOfType(name, "JSXNamespacedName")) return `${name.namespace.name}:${name.name.name}`;
-	return "";
-};
 const computeElementType = (openingElement, a11ySettings) => {
-	const baseName = flattenJsxName$2(openingElement.name);
+	const baseName = resolveJsxElementType(openingElement);
 	if (a11ySettings.polymorphicPropName) {
 		const polymorphicAttribute = hasJsxPropIgnoreCase(openingElement.attributes, a11ySettings.polymorphicPropName);
 		if (polymorphicAttribute) {
@@ -2332,8 +2397,9 @@ const anchorIsValid = defineRule({
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return { JSXOpeningElement(node) {
 			if (isTestlikeFile) return;
-			if (!fileHasJsxA11ySettings && (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a")) return;
-			if (getElementType(node, context.settings) !== "a") return;
+			const tag = getElementType(node, context.settings);
+			if (!fileHasJsxA11ySettings && tag !== "a") return;
+			if (tag !== "a") return;
 			let hrefAttribute;
 			for (const attributeName of settings.hrefAttributeNames) {
 				hrefAttribute = hasJsxPropIgnoreCase(node.attributes, attributeName);
@@ -5139,8 +5205,10 @@ 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;
@@ -5686,7 +5754,7 @@ const buttonHasType = defineRule({
 		return {
 			JSXOpeningElement(node) {
 				if (isTestlikeFile) return;
-				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "button") return;
+				if (resolveJsxElementType(node) !== "button") return;
 				const typeAttr = hasJsxPropIgnoreCase(node.attributes, "type");
 				if (!typeAttr) {
 					if (hasJsxSpreadAttribute$1(node.attributes)) {
@@ -5876,7 +5944,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 		};
 		return {
 			JSXOpeningElement(node) {
-				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "input") return;
+				if (resolveJsxElementType(node) !== "input") return;
 				reportFromPresence(collectFromJsxAttributes(node.attributes));
 			},
 			CallExpression(node) {
@@ -5892,6 +5960,21 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-static-property-key-name.ts
+const getStaticPropertyKeyName = (node, options = {}) => {
+	if (!isNodeOfType(node, "Property")) return null;
+	if (node.computed) {
+		if (options.allowComputedString && isNodeOfType(node.key, "Literal") && typeof node.key.value === "string") return node.key.value;
+		return null;
+	}
+	if (isNodeOfType(node.key, "Identifier")) return node.key.name;
+	if (isNodeOfType(node.key, "Literal")) {
+		if (typeof node.key.value === "string") return node.key.value;
+		if (options.stringifyNonStringLiterals) return String(node.key.value);
+	}
+	return null;
+};
+//#endregion
 //#region src/plugin/utils/is-presentation-role.ts
 const isPresentationRole = (openingElement) => {
 	const roleAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "role");
@@ -5936,6 +6019,21 @@ const isPureEventBlockerHandler = (attribute) => {
 	return false;
 };
 //#endregion
+//#region src/plugin/utils/resolve-const-identifier-alias.ts
+const resolveConstIdentifierAlias = (identifier, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let symbol = scopes.symbolFor(identifier);
+	while (symbol?.kind === "const") {
+		if (visitedSymbolIds.has(symbol.id) || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
+		visitedSymbolIds.add(symbol.id);
+		const initializer = stripParenExpression(symbol.initializer);
+		if (!isNodeOfType(initializer, "Identifier")) return symbol;
+		symbol = scopes.symbolFor(initializer);
+	}
+	return symbol;
+};
+//#endregion
 //#region src/plugin/rules/a11y/click-events-have-key-events.ts
 const MESSAGE$57 = "Keyboard users can't trigger this click handler because there's no keyboard one, so add `onKeyUp`, `onKeyDown`, or `onKeyPress`.";
 const KEY_HANDLERS = [
@@ -5946,6 +6044,63 @@ const KEY_HANDLERS = [
 	"onKeyDownCapture",
 	"onKeyPressCapture"
 ];
+const CLICK_HANDLERS = ["onClick", "onClickCapture"];
+const TRANSPARENT_SPREAD_EVENT_NAMES = new Set([...CLICK_HANDLERS, ...KEY_HANDLERS].map((eventName) => eventName.toLowerCase()));
+const CONSERVATIVE_SPREAD_PROP_NAMES = new Set([
+	"aria-hidden",
+	"onmouseenter",
+	"onmouseover",
+	"role"
+]);
+const resolveSpreadObjectExpression = (expression, scopes) => {
+	const innerExpression = stripParenExpression(expression);
+	if (isNodeOfType(innerExpression, "ObjectExpression")) return innerExpression;
+	if (!isNodeOfType(innerExpression, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(innerExpression, scopes);
+	if (symbol?.kind !== "const" || !symbol.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	return isNodeOfType(initializer, "ObjectExpression") ? initializer : null;
+};
+const collectTransparentSpreadEventNames = (expression, scopes, eventValues, visitedObjectExpressions) => {
+	const objectExpression = resolveSpreadObjectExpression(expression, scopes);
+	if (!objectExpression || visitedObjectExpressions.has(objectExpression)) return false;
+	visitedObjectExpressions.add(objectExpression);
+	let isTransparent = true;
+	for (const property of objectExpression.properties) {
+		if (isNodeOfType(property, "SpreadElement")) {
+			if (!collectTransparentSpreadEventNames(property.argument, scopes, eventValues, visitedObjectExpressions)) {
+				isTransparent = false;
+				break;
+			}
+			continue;
+		}
+		if (!isNodeOfType(property, "Property")) {
+			isTransparent = false;
+			break;
+		}
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (!propertyName) {
+			isTransparent = false;
+			break;
+		}
+		const normalizedPropertyName = propertyName.toLowerCase();
+		if (CONSERVATIVE_SPREAD_PROP_NAMES.has(normalizedPropertyName)) {
+			isTransparent = false;
+			break;
+		}
+		if (TRANSPARENT_SPREAD_EVENT_NAMES.has(normalizedPropertyName)) eventValues.set(normalizedPropertyName, property.value);
+	}
+	visitedObjectExpressions.delete(objectExpression);
+	return isTransparent;
+};
+const getTransparentSpreadEventValues = (attributes, scopes) => {
+	const eventValues = /* @__PURE__ */ new Map();
+	for (const attribute of attributes) {
+		if (!isNodeOfType(attribute, "JSXSpreadAttribute")) continue;
+		if (!collectTransparentSpreadEventNames(attribute.argument, scopes, eventValues, /* @__PURE__ */ new Set())) return null;
+	}
+	return eventValues;
+};
 const FOCUSLESS_CONTAINER_TAGS = new Set([
 	"tr",
 	"td",
@@ -5993,7 +6148,10 @@ const isFocusForwardingFunctionBody = (body) => {
 };
 const resolveHandlerFunction = (attribute) => {
 	if (!attribute.value || !isNodeOfType(attribute.value, "JSXExpressionContainer")) return null;
-	let expression = attribute.value.expression;
+	return resolveHandlerFunctionExpression(attribute.value.expression);
+};
+const resolveHandlerFunctionExpression = (handlerExpression) => {
+	let expression = handlerExpression;
 	if (isNodeOfType(expression, "Identifier")) {
 		const binding = findVariableInitializer(expression, expression.name);
 		if (!binding?.initializer) return null;
@@ -6092,18 +6250,22 @@ const clickEventsHaveKeyEvents = defineRule({
 			if (!HTML_TAGS.has(tag)) return;
 			if (tag === "label") return;
 			if (!FOCUSLESS_CONTAINER_TAGS.has(tag) && isInteractiveElement(tag, node)) return;
+			const spreadEventValues = getTransparentSpreadEventValues(node.attributes, context.scopes);
+			if (!spreadEventValues) return;
 			const onClick = hasJsxPropIgnoreCase(node.attributes, "onClick") ?? hasJsxPropIgnoreCase(node.attributes, "onClickCapture");
-			if (!onClick) return;
-			if (isPureEventBlockerHandler(onClick)) return;
-			if (isFocusForwardingHandler(onClick)) return;
-			if (hasJsxSpreadAttribute$1(node.attributes)) return;
+			const spreadOnClickExpression = CLICK_HANDLERS.map((name) => spreadEventValues.get(name.toLowerCase())).find((expression) => expression !== void 0);
+			if (!onClick && !spreadOnClickExpression) return;
+			if (onClick && isPureEventBlockerHandler(onClick)) return;
+			if (onClick && isFocusForwardingHandler(onClick)) return;
+			const spreadHandlerFunction = spreadOnClickExpression ? resolveHandlerFunctionExpression(spreadOnClickExpression) : null;
+			if (spreadHandlerFunction && (isFocusForwardingFunctionBody(spreadHandlerFunction.body ?? null) || containsBackdropDismissComparison(spreadHandlerFunction.body ?? null))) return;
 			if (hasCompositeItemRole(node)) return;
 			if (isHoverSelectionListItem(tag, node)) return;
-			if (isBackdropDismissHandler(onClick)) return;
+			if (onClick && isBackdropDismissHandler(onClick)) return;
 			if (containsKeyboardActivatableDescendant(node.parent)) return;
 			if (isHiddenFromScreenReader(node, context.settings)) return;
 			if (isPresentationRole(node)) return;
-			if (KEY_HANDLERS.some((handler) => hasJsxPropIgnoreCase(node.attributes, handler))) return;
+			if (KEY_HANDLERS.some((handler) => hasJsxPropIgnoreCase(node.attributes, handler) || spreadEventValues.has(handler.toLowerCase()))) return;
 			context.report({
 				node: node.name,
 				message: MESSAGE$57
@@ -6134,6 +6296,131 @@ const isGlobalMethodCall = (node, objectName, methodName) => {
 	return isNodeOfType(receiver, "Identifier") && receiver.name === objectName && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
 };
 //#endregion
+//#region src/plugin/utils/collect-safely-validated-local-storage-keys.ts
+const isLocalStorageCall = (node, methodName) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === "localStorage" && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
+};
+const catchReturnsFallback = (tryStatement) => {
+	const handler = tryStatement.handler;
+	if (!handler) return false;
+	let hasReturn = false;
+	let hasThrow = false;
+	walkAst(handler.body, (child) => {
+		if (isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "ReturnStatement")) hasReturn = true;
+		if (isNodeOfType(child, "ThrowStatement")) hasThrow = true;
+	});
+	return hasReturn && !hasThrow;
+};
+const resolveValidatorFunction = (callee, scopes) => {
+	const unwrappedCallee = stripParenExpression(callee);
+	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
+	const symbol = scopes.symbolFor(unwrappedCallee);
+	if (!symbol) return null;
+	const candidate = symbol.kind === "function" ? symbol.declarationNode : symbol.initializer;
+	return isFunctionLike$1(candidate) ? candidate : null;
+};
+const validatorChecksPayloadProperties = (validatorFunction, scopes) => {
+	if (!isFunctionLike$1(validatorFunction)) return false;
+	const firstParameter = validatorFunction.params?.[0];
+	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
+	const parameterSymbol = scopes.symbolFor(firstParameter);
+	if (!parameterSymbol) return false;
+	const payloadSymbolIds = new Set([parameterSymbol.id]);
+	let hasPropertyTypeCheck = false;
+	walkAst(validatorFunction.body, (child) => {
+		if (isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.init) {
+			const initializer = stripParenExpression(child.init);
+			if (isNodeOfType(initializer, "Identifier")) {
+				const initializerSymbol = scopes.symbolFor(initializer);
+				if (initializerSymbol && payloadSymbolIds.has(initializerSymbol.id)) {
+					const aliasSymbol = scopes.symbolFor(child.id);
+					if (aliasSymbol) payloadSymbolIds.add(aliasSymbol.id);
+				}
+			}
+		}
+		if (!isNodeOfType(child, "UnaryExpression") || child.operator !== "typeof") return;
+		const checkedValue = stripParenExpression(child.argument);
+		if (!isNodeOfType(checkedValue, "MemberExpression")) return;
+		const receiver = stripParenExpression(checkedValue.object);
+		if (!isNodeOfType(receiver, "Identifier")) return;
+		const receiverSymbol = scopes.symbolFor(receiver);
+		if (receiverSymbol && payloadSymbolIds.has(receiverSymbol.id)) hasPropertyTypeCheck = true;
+	});
+	return hasPropertyTypeCheck;
+};
+const incrementCount = (counts, keyValue) => {
+	counts.set(keyValue, (counts.get(keyValue) ?? 0) + 1);
+};
+const isReturnedExpression = (expression) => {
+	const parent = expression.parent;
+	return Boolean(parent && isNodeOfType(parent, "ReturnStatement") && parent.argument === expression);
+};
+const collectSafelyValidatedLocalStorageKeys = ({ programNode, scopes, resolveKey }) => {
+	const readCountsByKey = /* @__PURE__ */ new Map();
+	const safeReadCountsByKey = /* @__PURE__ */ new Map();
+	const safeReadSymbolIds = /* @__PURE__ */ new Set();
+	walkAst(programNode, (child) => {
+		if (!isNodeOfType(child, "CallExpression") || !isLocalStorageCall(child, "getItem")) return;
+		const keyArgument = child.arguments?.[0];
+		if (!keyArgument) return;
+		const keyValue = resolveKey(keyArgument);
+		if (keyValue !== null) incrementCount(readCountsByKey, keyValue);
+	});
+	walkAst(programNode, (child) => {
+		if (!isNodeOfType(child, "TryStatement") || !catchReturnsFallback(child)) return;
+		const rawValueKeys = /* @__PURE__ */ new Map();
+		const parsedValueSources = /* @__PURE__ */ new Map();
+		walkAst(child.block, (tryChild) => {
+			if (isFunctionLike$1(tryChild)) return false;
+			if (isNodeOfType(tryChild, "VariableDeclarator") && isNodeOfType(tryChild.id, "Identifier") && tryChild.init) {
+				const initializer = stripParenExpression(tryChild.init);
+				if (isNodeOfType(initializer, "CallExpression") && isLocalStorageCall(initializer, "getItem")) {
+					const keyArgument = initializer.arguments?.[0];
+					const bindingSymbol = scopes.symbolFor(tryChild.id);
+					if (keyArgument && bindingSymbol) {
+						const keyValue = resolveKey(keyArgument);
+						if (keyValue !== null) rawValueKeys.set(bindingSymbol.id, keyValue);
+					}
+				}
+				if (isNodeOfType(initializer, "CallExpression") && isGlobalMethodCall(initializer, "JSON", "parse")) {
+					const rawValueArgument = initializer.arguments?.[0];
+					const parsedValueSymbol = scopes.symbolFor(tryChild.id);
+					if (rawValueArgument && isNodeOfType(rawValueArgument, "Identifier") && parsedValueSymbol) {
+						const rawValueSymbol = scopes.symbolFor(rawValueArgument);
+						if (rawValueSymbol && rawValueKeys.has(rawValueSymbol.id)) parsedValueSources.set(parsedValueSymbol.id, rawValueSymbol.id);
+					}
+				}
+			}
+			if (!isNodeOfType(tryChild, "ConditionalExpression") || !isReturnedExpression(tryChild)) return;
+			const test = stripParenExpression(tryChild.test);
+			if (!isNodeOfType(test, "CallExpression")) return;
+			const testedValue = test.arguments?.[0];
+			if (!testedValue || !isNodeOfType(testedValue, "Identifier")) return;
+			const parsedValueSymbol = scopes.symbolFor(testedValue);
+			if (!parsedValueSymbol) return;
+			const rawValueSymbolId = parsedValueSources.get(parsedValueSymbol.id);
+			if (rawValueSymbolId === void 0) return;
+			const returnedValue = stripParenExpression(tryChild.consequent);
+			if (!isNodeOfType(returnedValue, "Identifier") || scopes.symbolFor(returnedValue)?.id !== parsedValueSymbol.id) return;
+			const validatorFunction = resolveValidatorFunction(test.callee, scopes);
+			if (!validatorFunction || !validatorChecksPayloadProperties(validatorFunction, scopes)) return;
+			const keyValue = rawValueKeys.get(rawValueSymbolId);
+			if (keyValue === void 0 || safeReadSymbolIds.has(rawValueSymbolId)) return;
+			safeReadSymbolIds.add(rawValueSymbolId);
+			incrementCount(safeReadCountsByKey, keyValue);
+		});
+	});
+	const safeKeys = /* @__PURE__ */ new Set();
+	for (const [keyValue, readCount] of readCountsByKey) if (safeReadCountsByKey.get(keyValue) === readCount) safeKeys.add(keyValue);
+	return safeKeys;
+};
+//#endregion
 //#region src/plugin/rules/client/client-localstorage-no-version.ts
 const VERSIONED_KEY_PATTERN = /(?:[._:-]v\d+|@\d+|\bv\d+\b)/i;
 const CAMEL_CASE_VERSIONED_KEY_PATTERN = /[a-z]V\d+/;
@@ -6155,26 +6442,39 @@ const clientLocalstorageNoVersion = defineRule({
 	severity: "warn",
 	category: "Correctness",
 	recommendation: "Put a version in the storage key (e.g. \"myKey:v1\"). If you change the data shape later, old saved data can be ignored instead of crashing the app.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isNodeOfType(node.callee, "MemberExpression")) return;
-		const receiver = stripParenExpression(node.callee.object);
-		if (!isNodeOfType(receiver, "Identifier")) return;
-		if (receiver.name !== "localStorage") return;
-		if (!isNodeOfType(node.callee.property, "Identifier")) return;
-		if (node.callee.property.name !== "setItem") return;
-		const keyArg = node.arguments?.[0];
-		if (!keyArg) return;
-		const keyValue = resolveStringKey(keyArg, context);
-		if (keyValue === null) return;
-		if (isVersionedKey(keyValue)) return;
-		const valueArg = node.arguments?.[1];
-		if (!valueArg) return;
-		if (!isJsonStringifyCall(valueArg)) return;
-		context.report({
-			node: keyArg,
-			message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
-		});
-	} })
+	create: (context) => {
+		let safelyValidatedStorageKeys = /* @__PURE__ */ new Set();
+		return {
+			Program(node) {
+				safelyValidatedStorageKeys = collectSafelyValidatedLocalStorageKeys({
+					programNode: node,
+					scopes: context.scopes,
+					resolveKey: (keyNode) => resolveStringKey(keyNode, context)
+				});
+			},
+			CallExpression(node) {
+				if (!isNodeOfType(node.callee, "MemberExpression")) return;
+				const receiver = stripParenExpression(node.callee.object);
+				if (!isNodeOfType(receiver, "Identifier")) return;
+				if (receiver.name !== "localStorage") return;
+				if (!isNodeOfType(node.callee.property, "Identifier")) return;
+				if (node.callee.property.name !== "setItem") return;
+				const keyArg = node.arguments?.[0];
+				if (!keyArg) return;
+				const keyValue = resolveStringKey(keyArg, context);
+				if (keyValue === null) return;
+				if (isVersionedKey(keyValue)) return;
+				if (safelyValidatedStorageKeys.has(keyValue)) return;
+				const valueArg = node.arguments?.[1];
+				if (!valueArg) return;
+				if (!isJsonStringifyCall(valueArg)) return;
+				context.report({
+					node: keyArg,
+					message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
+				});
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rules/client/client-passive-event-listeners.ts
@@ -6793,6 +7093,30 @@ const corsCookieTrustRisk = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/rules/security-scan/utils/find-matching-bracket.ts
+const findMatchingBracket = (content, openIndex) => {
+	const open = content[openIndex];
+	const close = open === "(" ? ")" : open === "{" ? "}" : open === "[" ? "]" : "";
+	if (close === "") return -1;
+	let depth = 0;
+	let stringDelimiter = null;
+	for (let index = openIndex; index < content.length; index += 1) {
+		const character = content[index];
+		if (stringDelimiter !== null) {
+			if (character === "\\") index += 1;
+			else if (character === stringDelimiter) stringDelimiter = null;
+			continue;
+		}
+		if (character === "\"" || character === "'" || character === "`") stringDelimiter = character;
+		else if (character === open) depth += 1;
+		else if (character === close) {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+};
+//#endregion
 //#region src/plugin/rules/security-scan/dangerous-html-sink.ts
 const DANGEROUS_HTML_PATTERN = /dangerouslySetInnerHTML|(?:\.(?:inner|outer)HTML|\[\s*["'](?:inner|outer)HTML["']\s*\])\s*[+]?=(?!=)|\.insertAdjacentHTML\s*\(|\bdocument\.write(?:ln)?\s*\(|\.(?:createContextualFragment|setHTMLUnsafe)\s*\(/;
 const HTML_VALUE_START_PATTERN = /(?:__html\s*:|(?:\.(?:inner|outer)HTML|\[\s*["'](?:inner|outer)HTML["']\s*\])\s*[+]?=(?!=)|\.insertAdjacentHTML\s*\(\s*[^,]*,|\bdocument\.write(?:ln)?\s*\(|\.(?:createContextualFragment|setHTMLUnsafe)\s*\()\s*([\s\S]*)/;
@@ -6808,6 +7132,7 @@ const I18N_VALUE_PATTERN = /\b(?:t|i18n|translate|formatMessage|intl)\s*[.(]/;
 const ESCAPING_SERIALIZER_CALL_PATTERN = /^(?:[\w$.]+\.)?(?:toHtml|render[A-Za-z]*(?:Html|HTML)|renderToString|renderToStaticMarkup|codeToHtml|codeToHast|highlight[A-Za-z]*)\s*\(/;
 const HIGHLIGHTER_LIBRARY_PATTERN = /\b(?:shiki|prism|hljs|highlightjs|getHighlighter|codeToHtml|codeToHast|refractor|lowlight|starry-night)\b|highlight\.js/i;
 const SERIALIZER_ASSIGNMENT_PATTERN = /[:=]\s*[^\n;]*(?:\b(?:katex|shiki|hljs|prism|mermaid)\b|hast-util-to-html|renderHtmlFromRichText|(?:toHtml|render[A-Za-z]*(?:Html|HTML)|renderToString|renderToStaticMarkup|codeToHtml|codeToHast)\s*\()/i;
+const SERIALIZER_CALL_PROVENANCE_PATTERN = /\b(?:(?:katex|shiki|hljs|prism|mermaid|highlighter)[\w$]*\.(?:render\w*|highlight\w*|codeTo(?:Html|Hast))|(?:toHtml|render(?:Html|HTML)[A-Za-z]*|render[A-Za-z]*(?:Html|HTML)|renderToString|renderToStaticMarkup|codeToHtml|codeToHast|highlight[A-Za-z]*))\s*\(/i;
 const BARE_IDENTIFIER_VALUE_PATTERN = /^[\w$]+\s*(?:[;,})\n]|$)/;
 const IDENTIFIER_WITH_LITERAL_FALLBACK_PATTERN = /^[\w$]+\s*(?:\|\||\?\?)\s*(?:"[^"\n]*"|'[^'\n]*'|`[^`$]*`)\s*(?:[;,})\n]|$)/;
 const MEMBER_OR_INDEX_ACCESS_VALUE_PATTERN = /^[\w$]+(?:\.[\w$]+|\[[^\]]*\])+\s*(?:[;,})\n]|$)/;
@@ -6829,11 +7154,10 @@ const getTemplateInterpolations = (valueTail) => {
 	const interpolations = valueTail.slice(1, closingBacktickIndex).match(/\$\{[^}]*\}/g);
 	return interpolations === null ? "" : interpolations.join(" ");
 };
-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 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 isPureStringLiteralConcat = (initializerText) => {
 	if (!/^["']/.test(initializerText)) return false;
@@ -6903,6 +7227,229 @@ 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[2];
+		if (initializer === void 0) continue;
+		nearestDeclaration = {
+			declarationIndex,
+			initializer,
+			initializerStartIndex: declarationIndex + match[0].length - initializer.length,
+			isImmutable: match[1] === "const"
+		};
+	}
+	return nearestDeclaration;
+};
+const isDeclarationStable = (identifier, declaration, usageIndex, fileContent) => {
+	if (declaration.isImmutable) return true;
+	const textAfterInitializer = fileContent.slice(declaration.initializerStartIndex + declaration.initializer.length, usageIndex);
+	return !new RegExp(`(?:^|[^\\w$.])${escapeRegExp(identifier)}\\s*=(?!=)`).test(textAfterInitializer);
+};
+const isTrustedHighlighterValue = (valueExpression, fileContent, sinkIndex) => {
+	if (!/highlight/i.test(valueExpression)) return false;
+	const identifier = valueExpression.match(/^([\w$]+)/)?.[1];
+	if (identifier === void 0) return false;
+	const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
+	if (declaration !== null) return isDeclarationStable(identifier, declaration, sinkIndex, fileContent) && SERIALIZER_CALL_PROVENANCE_PATTERN.test(declaration.initializer);
+	return /highlighted/i.test(valueExpression) || HIGHLIGHTER_LIBRARY_PATTERN.test(fileContent);
+};
+const isExplicitlyTrustedHtmlValue = (valueExpression, fileContent, sinkIndex, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
+	const trimmedExpression = valueExpression.trim();
+	const concatenatedParts = splitTopLevelByPlus(trimmedExpression);
+	if (concatenatedParts.length > 1) return concatenatedParts.every((part) => isExplicitlyTrustedHtmlValue(part, fileContent, sinkIndex, visitedIdentifiers));
+	const interpolationParts = [...trimmedExpression.matchAll(/\$\{([^}]*)\}/g)].flatMap((match) => match[1] === void 0 ? [] : [match[1]]);
+	if (interpolationParts.length > 1) return interpolationParts.every((part) => isExplicitlyTrustedHtmlValue(part, fileContent, sinkIndex, visitedIdentifiers));
+	const identifier = trimmedExpression.match(/^([\w$]+)(?:(?:\??\.[\w$]+)|(?:\[\s*(?:"[^"\n]*"|'[^'\n]*'|\d+)\s*\]))*$/)?.[1];
+	if (identifier && !visitedIdentifiers.has(identifier)) {
+		const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
+		if (declaration && isDeclarationStable(identifier, declaration, sinkIndex, fileContent)) {
+			const nextVisitedIdentifiers = new Set(visitedIdentifiers);
+			nextVisitedIdentifiers.add(identifier);
+			return isExplicitlyTrustedHtmlValue(declaration.initializer, fileContent, declaration.initializerStartIndex, nextVisitedIdentifiers);
+		}
+	}
+	if (STRING_LITERAL_VALUE_PATTERN.test(`${trimmedExpression};`) || MODULE_CONSTANT_VALUE_PATTERN.test(`${trimmedExpression};`) || SANITIZER_PATTERN.test(trimmedExpression) || ENV_CONFIG_VALUE_PATTERN.test(trimmedExpression) || I18N_VALUE_PATTERN.test(trimmedExpression) || ESCAPING_SERIALIZER_CALL_PATTERN.test(trimmedExpression) || isTrustedHighlighterValue(trimmedExpression, fileContent, sinkIndex)) return true;
+	return false;
+};
+const doesExpressionAliasIdentifier = (expression, targetIdentifier, expressionIndex, fileContent, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
+	const identifier = expression.trim().match(/^([\w$]+)$/)?.[1];
+	if (!identifier) return false;
+	if (identifier === targetIdentifier) return true;
+	if (visitedIdentifiers.has(identifier)) return false;
+	const declaration = findVisibleIdentifierDeclaration(identifier, expressionIndex, fileContent);
+	if (!declaration?.isImmutable) return false;
+	const nextVisitedIdentifiers = new Set(visitedIdentifiers);
+	nextVisitedIdentifiers.add(identifier);
+	return doesExpressionAliasIdentifier(declaration.initializer, targetIdentifier, declaration.initializerStartIndex, fileContent, nextVisitedIdentifiers);
+};
+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;
+		const bodyEndIndex = findMatchingBraceIndex(fileContent, matchIndex + match[0].lastIndexOf("{"));
+		if (bodyEndIndex < sinkIndex) continue;
+		const parameterIndex = (match[2] ?? "").split(",").findIndex((parameter) => parameter.trim().match(/^(?:\.\.\.)?([\w$]+)/)?.[1] === identifier);
+		if (parameterIndex < 0) continue;
+		closestStartIndex = matchIndex;
+		const functionName = match[1] ?? "";
+		closestSource = {
+			bodyEndIndex,
+			declarationNameIndex: matchIndex + match[0].indexOf(functionName),
+			functionName,
+			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 isBackedByFunctionParameter = (expression, expressionIndex, fileContent, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
+	const identifier = expression.trim().match(/^([\w$]+)$/)?.[1];
+	if (identifier === void 0 || visitedIdentifiers.has(identifier)) return false;
+	if (findContainingFunctionParameterSource(identifier, expressionIndex, fileContent) !== null) return true;
+	const declaration = findVisibleIdentifierDeclaration(identifier, expressionIndex, fileContent);
+	if (!declaration || !isDeclarationStable(identifier, declaration, expressionIndex, fileContent)) return false;
+	const nextVisitedIdentifiers = new Set(visitedIdentifiers);
+	nextVisitedIdentifiers.add(identifier);
+	return isBackedByFunctionParameter(declaration.initializer, declaration.initializerStartIndex, fileContent, nextVisitedIdentifiers);
+};
+const isHtmlTainted = (expression, fileContent, sinkIndex, visitedIdentifiers, visitedCallSites) => {
+	const trimmedExpression = expression.trim();
+	if (isExplicitlyTrustedHtmlValue(trimmedExpression, fileContent, sinkIndex)) return false;
+	const identifier = trimmedExpression.match(/^([\w$]+)(?:\.|\s*(?:[;,})\n]|$))/)?.[1];
+	if (identifier === void 0) return HTML_TAINT_PATTERN.test(trimmedExpression);
+	if (visitedIdentifiers.has(identifier)) return false;
+	visitedIdentifiers.add(identifier);
+	const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
+	const parameterSource = findContainingFunctionParameterSource(identifier, sinkIndex, fileContent);
+	if (declaration !== null && (parameterSource === null || declaration.declarationIndex > parameterSource.declarationNameIndex)) {
+		if (isDeclarationStable(identifier, declaration, sinkIndex, fileContent) && isExplicitlyTrustedHtmlValue(declaration.initializer, fileContent, declaration.initializerStartIndex)) return false;
+		if (!isDeclarationStable(identifier, declaration, sinkIndex, fileContent)) return true;
+		if (isHtmlTainted(declaration.initializer, fileContent, declaration.initializerStartIndex, visitedIdentifiers, visitedCallSites)) return true;
+		if (isBackedByFunctionParameter(declaration.initializer, declaration.initializerStartIndex, fileContent)) return false;
+		return HTML_TAINT_PATTERN.test(trimmedExpression);
+	}
+	if (parameterSource !== null && parameterSource.functionName.length > 0) {
+		const callPattern = new RegExp(`\\b${escapeRegExp(parameterSource.functionName)}\\s*\\(`, "g");
+		let didInspectCallArgument = false;
+		let didInspectOnlyExplicitlyTrustedArguments = true;
+		for (const callMatch of fileContent.matchAll(callPattern)) {
+			if (callMatch.index === parameterSource.declarationNameIndex || visitedCallSites.has(callMatch.index)) continue;
+			const openingParenthesisIndex = callMatch.index + callMatch[0].lastIndexOf("(");
+			const closingParenthesisIndex = findMatchingBracket(fileContent, openingParenthesisIndex);
+			if (closingParenthesisIndex < 0) continue;
+			const argument = splitTopLevelArguments(fileContent.slice(openingParenthesisIndex + 1, closingParenthesisIndex))[parameterSource.parameterIndex];
+			if (argument === void 0) continue;
+			if (callMatch.index >= parameterSource.declarationNameIndex && callMatch.index <= parameterSource.bodyEndIndex && doesExpressionAliasIdentifier(argument, identifier, callMatch.index, fileContent)) continue;
+			didInspectCallArgument = true;
+			didInspectOnlyExplicitlyTrustedArguments &&= isExplicitlyTrustedHtmlValue(argument, fileContent, callMatch.index);
+			const callVisitedIdentifiers = new Set(visitedIdentifiers);
+			callVisitedIdentifiers.delete(identifier);
+			const nextVisitedCallSites = new Set(visitedCallSites);
+			nextVisitedCallSites.add(callMatch.index);
+			if (isHtmlTainted(argument, fileContent, callMatch.index, callVisitedIdentifiers, nextVisitedCallSites)) return true;
+		}
+		if (didInspectCallArgument) return !didInspectOnlyExplicitlyTrustedArguments && HTML_TAINT_PATTERN.test(trimmedExpression);
+		return HTML_TAINT_PATTERN.test(trimmedExpression);
+	}
+	return HTML_TAINT_PATTERN.test(trimmedExpression);
+};
 const dangerousHtmlSink = defineRule({
 	id: "dangerous-html-sink",
 	title: "HTML injection sink with dynamic content",
@@ -6929,6 +7476,7 @@ 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("+")) {
@@ -6939,8 +7487,8 @@ const dangerousHtmlSink = defineRule({
 			const longValueTail = HTML_VALUE_START_PATTERN.exec(lines.slice(lineIndex, lineIndex + 1 + STATIC_TEMPLATE_LOOKAHEAD_LINES).join("\n"))?.[1]?.trimStart();
 			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, file.content);
+			if (templateInterpolations === null && valueIdentifier !== void 0 && BARE_IDENTIFIER_VALUE_PATTERN.test(valueExpression) && findContainingFunctionParameterSource(valueIdentifier, sinkIndex, file.content) === null) {
+				const declarationInitializer = getIdentifierDeclarationInitializer(valueIdentifier, sinkIndex, file.content);
 				if (declarationInitializer !== null) {
 					if (isPureStringLiteralConcat(declarationInitializer)) continue;
 					templateInterpolations = getTemplateInterpolations(declarationInitializer);
@@ -6948,17 +7496,23 @@ const dangerousHtmlSink = defineRule({
 			}
 			if (templateInterpolations === "") continue;
 			const judgedExpression = templateInterpolations ?? valueExpression;
-			if (SANITIZER_PATTERN.test(judgedExpression)) continue;
-			if (ENV_CONFIG_VALUE_PATTERN.test(judgedExpression)) continue;
-			if (I18N_VALUE_PATTERN.test(judgedExpression)) continue;
-			if (!HTML_TAINT_PATTERN.test(judgedExpression)) continue;
+			const doesJudgedExpressionCombineValues = splitTopLevelByPlus(judgedExpression).length > 1 || (templateInterpolations?.match(/\$\{/g)?.length ?? 0) > 1;
+			if (!doesJudgedExpressionCombineValues && SANITIZER_PATTERN.test(judgedExpression)) continue;
+			if (!doesJudgedExpressionCombineValues && ENV_CONFIG_VALUE_PATTERN.test(judgedExpression)) continue;
+			if (!doesJudgedExpressionCombineValues && I18N_VALUE_PATTERN.test(judgedExpression)) continue;
+			if (!isHtmlTainted(judgedExpression, file.content, sinkIndex, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set())) 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;
+			if (isTrustedHighlighterValue(valueExpression, file.content, sinkIndex)) continue;
 			if (valueIdentifier !== void 0) {
 				const escapedIdentifier = escapeRegExp(valueIdentifier);
-				if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${SERIALIZER_ASSIGNMENT_PATTERN.source}`, "i").test(file.content)) continue;
-				if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${SANITIZED_ASSIGNMENT_PATTERN.source}`, "i").test(file.content)) continue;
+				const visibleDeclaration = findVisibleIdentifierDeclaration(valueIdentifier, sinkIndex, file.content);
+				const visibleInitializer = visibleDeclaration?.initializer;
+				if (!(visibleInitializer !== void 0 && (splitTopLevelByPlus(visibleInitializer).length > 1 || (visibleInitializer.match(/\$\{/g)?.length ?? 0) > 1))) {
+					const fromSerializer = new RegExp(`\\b${escapedIdentifier}\\b\\s*${SERIALIZER_ASSIGNMENT_PATTERN.source}`, "i");
+					if (visibleInitializer === void 0 ? fromSerializer.test(file.content) : visibleDeclaration !== null && isDeclarationStable(valueIdentifier, visibleDeclaration, sinkIndex, file.content) && SERIALIZER_CALL_PROVENANCE_PATTERN.test(visibleInitializer)) continue;
+					const fromSanitizer = new RegExp(`\\b${escapedIdentifier}\\b\\s*${SANITIZED_ASSIGNMENT_PATTERN.source}`, "i");
+					if (visibleInitializer === void 0 ? fromSanitizer.test(file.content) : visibleDeclaration !== null && isDeclarationStable(valueIdentifier, visibleDeclaration, sinkIndex, file.content) && SANITIZED_ASSIGNMENT_PATTERN.test(`=${visibleInitializer}`)) continue;
+				}
 				if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${DOM_CONTENT_ASSIGNMENT_PATTERN.source}`).test(file.content)) continue;
 				if (new RegExp(`highlight[\\w$]*\\s*\\.map\\(\\s*(?:async\\s+)?\\(?\\s*${escapedIdentifier}\\b`, "i").test(file.content) && HIGHLIGHTER_LIBRARY_PATTERN.test(file.content)) continue;
 			}
@@ -7043,7 +7597,7 @@ const findJsxAttribute = (attributes, attributeName) => attributes?.find((attrib
 const getOpeningElementTagName = (openingElement) => {
 	if (!openingElement) return null;
 	if (!isNodeOfType(openingElement, "JSXOpeningElement")) return null;
-	if (isNodeOfType(openingElement.name, "JSXIdentifier")) return openingElement.name.name;
+	if (isNodeOfType(openingElement.name, "JSXIdentifier")) return resolveJsxElementType(openingElement);
 	if (isNodeOfType(openingElement.name, "JSXMemberExpression")) {
 		let cursor = openingElement.name;
 		while (isNodeOfType(cursor, "JSXMemberExpression")) cursor = cursor.property;
@@ -7295,7 +7849,7 @@ const dialogHasAccessibleName = defineRule({
 		if (isTestlikeFilename(context.filename)) return {};
 		return { JSXOpeningElement(node) {
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const tagName = node.name.name;
+			const tagName = resolveJsxElementType(node);
 			if (tagName[0] !== tagName[0]?.toLowerCase()) return;
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 			const roleValue = roleAttribute ? getJsxPropStringValue(roleAttribute) : null;
@@ -7398,7 +7952,7 @@ const containsJsx$1 = (root) => {
 	containsJsxCache.set(root, found);
 	return found;
 };
-const getStaticMemberName$1 = (node) => {
+const getStaticMemberName$2 = (node) => {
 	if (!isNodeOfType(node, "MemberExpression")) return null;
 	if (!node.computed && isNodeOfType(node.property, "Identifier")) return node.property.name;
 	if (node.computed && isNodeOfType(node.property, "Literal") && typeof node.property.value === "string") return node.property.value;
@@ -7412,7 +7966,7 @@ const getAssignedName = (node) => {
 	if (isNodeOfType(parent, "AssignmentExpression")) {
 		const left = parent.left;
 		if (isNodeOfType(left, "Identifier")) return left.name;
-		if (isNodeOfType(left, "MemberExpression")) return getStaticMemberName$1(left);
+		if (isNodeOfType(left, "MemberExpression")) return getStaticMemberName$2(left);
 	}
 	return null;
 };
@@ -7420,20 +7974,20 @@ const isModuleExportsAssignment = (node) => {
 	const parent = node.parent;
 	if (!parent || !isNodeOfType(parent, "AssignmentExpression")) return false;
 	const left = parent.left;
-	return isNodeOfType(left, "MemberExpression") && isNodeOfType(left.object, "Identifier") && left.object.name === "module" && getStaticMemberName$1(left) === "exports";
+	return isNodeOfType(left, "MemberExpression") && isNodeOfType(left.object, "Identifier") && left.object.name === "module" && getStaticMemberName$2(left) === "exports";
 };
 const isCreateClassLikeCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	if (isEs5Component(node)) return true;
 	const callee = node.callee;
-	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName$1(callee) === "createClass";
+	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName$2(callee) === "createClass";
 	return false;
 };
-const isCreateContextCall = (node) => {
+const isCreateContextCall$1 = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	const callee = node.callee;
 	if (isNodeOfType(callee, "Identifier")) return callee.name === "createContext";
-	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName$1(callee) === "createContext";
+	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName$2(callee) === "createContext";
 };
 const isNamedFunctionLike = (node) => (isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && Boolean(node.id?.name);
 const firstCallArgument = (node) => {
@@ -7491,7 +8045,7 @@ const memberExpressionPath = (node) => {
 	if (isNodeOfType(node, "Identifier")) return [node.name];
 	if (!isNodeOfType(node, "MemberExpression")) return [];
 	const objectPath = memberExpressionPath(node.object);
-	const propertyName = getStaticMemberName$1(node);
+	const propertyName = getStaticMemberName$2(node);
 	return propertyName ? [...objectPath, propertyName] : objectPath;
 };
 const displayNameAssignmentIndexCache = /* @__PURE__ */ new WeakMap();
@@ -7501,7 +8055,7 @@ const getDisplayNameAssignmentIndex = (programRoot) => {
 	const identifierTargets = /* @__PURE__ */ new Set();
 	const memberPathSegments = /* @__PURE__ */ new Set();
 	const visit = (node) => {
-		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName$1(node.left) === "displayName") {
+		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName$2(node.left) === "displayName") {
 			if (isNodeOfType(node.left.object, "Identifier")) identifierTargets.add(node.left.object.name);
 			for (const segment of memberExpressionPath(node.left.object)) memberPathSegments.add(segment);
 		}
@@ -7606,7 +8160,7 @@ const displayName = defineRule({
 				}
 			},
 			CallExpression(node) {
-				if (settings.checkContextObjects && isReactVersionAtLeast$1(settings.reactVersion, 16, 3) && isCreateContextCall(node)) {
+				if (settings.checkContextObjects && isReactVersionAtLeast$1(settings.reactVersion, 16, 3) && isCreateContextCall$1(node)) {
 					const assignedName = getAssignedName(node);
 					if (assignedName) {
 						const programRoot = findProgramRoot(node);
@@ -7653,21 +8207,6 @@ const displayName = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-static-property-key-name.ts
-const getStaticPropertyKeyName = (node, options = {}) => {
-	if (!isNodeOfType(node, "Property")) return null;
-	if (node.computed) {
-		if (options.allowComputedString && isNodeOfType(node.key, "Literal") && typeof node.key.value === "string") return node.key.value;
-		return null;
-	}
-	if (isNodeOfType(node.key, "Identifier")) return node.key.name;
-	if (isNodeOfType(node.key, "Literal")) {
-		if (typeof node.key.value === "string") return node.key.value;
-		if (options.stringifyNonStringLiterals) return String(node.key.value);
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/read-static-boolean.ts
 const readStaticBoolean = (node) => {
 	if (!node) return null;
@@ -7676,31 +8215,16 @@ const readStaticBoolean = (node) => {
 	return unwrappedNode.value;
 };
 //#endregion
-//#region src/plugin/utils/resolve-const-identifier-alias.ts
-const resolveConstIdentifierAlias = (identifier, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return null;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	let symbol = scopes.symbolFor(identifier);
-	while (symbol?.kind === "const") {
-		if (visitedSymbolIds.has(symbol.id) || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
-		visitedSymbolIds.add(symbol.id);
-		const initializer = stripParenExpression(symbol.initializer);
-		if (!isNodeOfType(initializer, "Identifier")) return symbol;
-		symbol = scopes.symbolFor(initializer);
-	}
-	return symbol;
-};
-//#endregion
 //#region src/plugin/utils/is-react-api-call.ts
 const includesApiName = (apiNames, apiName) => typeof apiNames === "string" ? apiNames === apiName : apiNames.has(apiName);
 const isImportedFromReact = (symbol) => {
 	if (symbol.kind !== "import") return false;
 	const importDeclaration = symbol.declarationNode.parent;
-	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react");
+	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && typeof importDeclaration.source.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(importDeclaration.source.value));
 };
-const isNamedReactApiImport = (identifier, apiNames, scopes) => {
+const isNamedReactApiImport = (identifier, apiNames, scopes, resolveAliases) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const symbol = scopes.symbolFor(identifier);
+	const symbol = resolveAliases ? resolveConstIdentifierAlias(identifier, scopes) : scopes.symbolFor(identifier);
 	if (!symbol || !isImportedFromReact(symbol)) return false;
 	const importedName = getImportedName(symbol.declarationNode);
 	return Boolean(importedName && includesApiName(apiNames, importedName));
@@ -7714,7 +8238,7 @@ const isReactApiCall = (node, apiNames, scopes, options = {}) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	const callee = stripParenExpression(node.callee);
 	if (isNodeOfType(callee, "Identifier")) {
-		if (isNamedReactApiImport(callee, apiNames, scopes)) return true;
+		if (isNamedReactApiImport(callee, apiNames, scopes, Boolean(options.resolveNamedAliases))) return true;
 		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
 	}
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || !includesApiName(apiNames, callee.property.name)) return false;
@@ -8817,6 +9341,30 @@ const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, conte
 	}
 	return matchingBlocks.size > 0;
 };
+const doMatchingNodesCoverEveryPathFromFunctionEntry = (owner, matchingNodes, context) => {
+	const functionCfg = context.cfg.cfgFor(owner);
+	if (!functionCfg) return false;
+	const matchingBlocks = new Set(matchingNodes.flatMap((matchingNode) => {
+		if (context.cfg.enclosingFunction(matchingNode) !== owner) return [];
+		const matchingBlock = functionCfg.blockOf(matchingNode);
+		return matchingBlock ? [matchingBlock] : [];
+	}));
+	if (matchingBlocks.size === 0) return false;
+	const visitedBlocks = new Set([functionCfg.entry]);
+	const pendingBlocks = [functionCfg.entry];
+	while (pendingBlocks.length > 0) {
+		const currentBlock = pendingBlocks.pop();
+		if (!currentBlock) break;
+		if (matchingBlocks.has(currentBlock)) continue;
+		for (const edge of currentBlock.successors) {
+			if (edge.to === functionCfg.exit) return false;
+			if (visitedBlocks.has(edge.to)) continue;
+			visitedBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return true;
+};
 const removeSynchronouslyReleasedUsages = (callback, usages, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
@@ -9017,6 +9565,83 @@ const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visite
 	});
 	return didCleanupFunctionMatch;
 };
+const doesBoundCleanupReleaseUsage = (expression, usage, context) => {
+	const callExpression = stripParenExpression(expression);
+	if (!isNodeOfType(callExpression, "CallExpression")) return false;
+	const bindCallee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(bindCallee, "MemberExpression") || bindCallee.computed || !isNodeOfType(bindCallee.property, "Identifier") || bindCallee.property.name !== "bind") return false;
+	const releaseMember = stripParenExpression(bindCallee.object);
+	if (!isNodeOfType(releaseMember, "MemberExpression") || releaseMember.computed || !isNodeOfType(releaseMember.property, "Identifier")) return false;
+	const releaseReceiverKey = resolveExpressionKey$1(releaseMember.object, context);
+	if (releaseReceiverKey === null || releaseReceiverKey !== resolveExpressionKey$1(callExpression.arguments?.[0], context)) return false;
+	const releaseVerbName = releaseMember.property.name;
+	if (usage.kind === "socket") return usage.handleKey === releaseReceiverKey && (SOCKET_RELEASE_VERB_NAMES.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName));
+	return usage.kind === "subscribe" && usage.handleKey === releaseReceiverKey && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub" || releaseVerbName === "close" || releaseVerbName === "unwatch" || releaseVerbName === "unlisten" || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(releaseVerbName));
+};
+const callbackReturnsCleanupForUsage = (callback, usage, context) => {
+	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
+	const doesReturnedValueReleaseUsage = (returnedValue) => {
+		if (doesBoundCleanupReleaseUsage(returnedValue, usage, context)) return true;
+		const cleanupFunction = resolveStableValue(returnedValue, context);
+		if (cleanupFunction && doesBoundCleanupReleaseUsage(cleanupFunction, usage, context)) return true;
+		return Boolean(cleanupFunction && isFunctionLike$1(cleanupFunction) && doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context));
+	};
+	if (!isNodeOfType(callback.body, "BlockStatement")) return doesReturnedValueReleaseUsage(stripParenExpression(callback.body));
+	const matchingCleanupReturns = [];
+	walkInsideStatementBlocks(callback.body, (child) => {
+		if (isNodeOfType(child, "ReturnStatement") && child.argument && doesReturnedValueReleaseUsage(stripParenExpression(child.argument))) matchingCleanupReturns.push(child);
+	});
+	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
+};
+const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
+	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") || !isNodeOfType(callback.body, "BlockStatement")) return false;
+	const functionCfg = context.cfg.cfgFor(callback);
+	const usageBlock = functionCfg?.blockOf(usage.node);
+	const usageStart = getRangeStart(usage.node);
+	if (!functionCfg || !usageBlock || usageStart === null) return false;
+	const findHandleGuard = (releaseCall) => {
+		if (usage.handleKey === null) return null;
+		let ancestor = releaseCall.parent;
+		while (ancestor && ancestor !== callback.body) {
+			if (isNodeOfType(ancestor, "IfStatement")) return ancestor.alternate === null && resolveExpressionKey$1(ancestor.test, context) === usage.handleKey && getRangeStart(ancestor) !== null && (getRangeStart(ancestor) ?? usageStart) < usageStart ? ancestor : null;
+			ancestor = ancestor.parent;
+		}
+		return null;
+	};
+	const matchingReleaseAnchors = [];
+	walkInsideStatementBlocks(callback.body, (child) => {
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const releaseStart = getRangeStart(child);
+		const handleGuard = findHandleGuard(child);
+		if (releaseStart === null || releaseStart >= usageStart || functionCfg.blockOf(child) !== usageBlock && !handleGuard) return;
+		if (doesReleaseCallMatchUsage(child, usage, context)) {
+			matchingReleaseAnchors.push(handleGuard ?? child);
+			return;
+		}
+		const helperFunction = resolveStableValue(child.callee, context);
+		if (helperFunction && isFunctionLike$1(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context)) matchingReleaseAnchors.push(handleGuard ?? child);
+	});
+	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
+};
+const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
+	const componentFunction = findEnclosingFunction(callback);
+	if (!componentFunction || !isNodeOfType(componentFunction, "ArrowFunctionExpression") && !isNodeOfType(componentFunction, "FunctionExpression") && !isNodeOfType(componentFunction, "FunctionDeclaration")) return false;
+	let didFindUnmountCleanup = false;
+	walkAst(componentFunction.body, (child) => {
+		if (didFindUnmountCleanup) return false;
+		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction(child) !== componentFunction) return;
+		if (!isHookCall$2(child, CLEANUP_EFFECT_HOOK_NAMES)) return;
+		const dependencyList = child.arguments?.[1];
+		if (!isNodeOfType(dependencyList, "ArrayExpression") || dependencyList.elements.length > 0) return;
+		const cleanupCallback = getEffectCallback(child);
+		if (cleanupCallback && cleanupCallback !== callback && callbackReturnsCleanupForUsage(cleanupCallback, usage, context)) {
+			didFindUnmountCleanup = true;
+			return false;
+		}
+	});
+	return didFindUnmountCleanup;
+};
+const hasSplitLifecycleCleanup = (callback, usage, context) => usage.handleKey !== null && hasRerunReleaseBeforeUsage(callback, usage, context) && hasStableUnmountCleanupForUsage(callback, usage, context);
 const effectHasCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
 	if (usage.kind === "subscribe" && findEnclosingFunction(usage.node) === callback && doesResourceResultEscape(usage.node, true) && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
@@ -9029,6 +9654,10 @@ const effectHasCleanupForUsage = (callback, usage, context) => {
 		if (returnStart !== null && usageStart !== null && returnStart < usageStart) return;
 		const returnedValue = child.argument ? stripParenExpression(child.argument) : null;
 		if (!returnedValue) return;
+		if (doesBoundCleanupReleaseUsage(returnedValue, usage, context)) {
+			matchingCleanupReturns.push(child);
+			return;
+		}
 		if (usage.kind === "subscribe" && (returnedValue === usage.node || getRangeStart(returnedValue) !== null && getRangeStart(returnedValue) === getRangeStart(usage.node)) && isCleanupReturningSubscribeLikeCallExpression(returnedValue)) {
 			matchingCleanupReturns.push(child);
 			return;
@@ -9044,13 +9673,17 @@ const effectHasCleanupForUsage = (callback, usage, context) => {
 			if (!context.scopes.symbolFor(returnedValue)?.initializer) return;
 		}
 		const cleanupFunction = resolveStableValue(returnedValue, context);
+		if (cleanupFunction && doesBoundCleanupReleaseUsage(cleanupFunction, usage, context)) {
+			matchingCleanupReturns.push(child);
+			return;
+		}
 		if (!cleanupFunction || !isFunctionLike$1(cleanupFunction)) return;
 		if (doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context)) matchingCleanupReturns.push(child);
 	});
 	return doMatchingNodesCoverEveryPathAfterUsage(resolveCleanupPathAnchor(usage.node, callback, context), matchingCleanupReturns, context);
 };
 const findFirstUsageWithoutCleanup = (callback, usages, context) => {
-	for (const usage of usages) if (!effectHasCleanupForUsage(callback, usage, context)) return usage;
+	for (const usage of usages) if (!effectHasCleanupForUsage(callback, usage, context) && !hasSplitLifecycleCleanup(callback, usage, context)) return usage;
 	return null;
 };
 const isLocalAbortControllerExpression = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
@@ -9646,6 +10279,11 @@ const walkParameterReferences = (pattern, state) => {
 const walk = (node, state) => {
 	if (isFunctionLike$1(node)) {
 		if (isNodeOfType(node, "FunctionDeclaration") && node.id) handleFunctionDeclaration(node, state);
+		const functionParams = node.params ?? [];
+		for (const param of functionParams) {
+			if (!("decorators" in param) || !Array.isArray(param.decorators)) continue;
+			for (const decorator of param.decorators) if (isAstNode(decorator)) walk(decorator, state);
+		}
 		setNodeScope(node, state);
 		const fnScope = pushScope(node.type === "ArrowFunctionExpression" ? "arrow-function" : "function", node, state);
 		if ((isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && node.id) {
@@ -9658,7 +10296,6 @@ const walk = (node, state) => {
 			});
 			tagAsBinding(state, node.id);
 		}
-		const functionParams = node.params ?? [];
 		handleFunctionParameters(functionParams, fnScope, state);
 		for (const param of functionParams) walkParameterReferences(param, state);
 		const body = node.body;
@@ -9668,6 +10305,9 @@ const walk = (node, state) => {
 	}
 	if (isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression")) {
 		if (isNodeOfType(node, "ClassDeclaration") && node.id) handleClassDeclaration(node, state);
+		if (Array.isArray(node.decorators)) {
+			for (const decorator of node.decorators) if (isAstNode(decorator)) walk(decorator, state);
+		}
 		const classScope = pushScope("class", node, state);
 		setNodeScope(node, state);
 		if (isNodeOfType(node, "ClassExpression") && node.id) {
@@ -9870,7 +10510,7 @@ const computeClosureCaptures = (functionNode, scopes) => {
 	const functionScope = scopes.ownScopeFor(functionNode) ?? scopes.scopeFor(functionNode);
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
-	const visit = (node) => {
+	walkAst(functionNode, (node) => {
 		if (node !== functionNode && isFunctionLike$1(node)) {
 			const innerCaptures = closureCaptures(node, scopes);
 			for (const reference of innerCaptures) if (reference.resolvedSymbol && !isDescendantScope(reference.resolvedSymbol.scope, functionScope)) {
@@ -9879,7 +10519,7 @@ const computeClosureCaptures = (functionNode, scopes) => {
 					seen.add(reference.id);
 				}
 			}
-			return;
+			return false;
 		}
 		const reference = scopes.referenceFor(node);
 		if (reference && reference.resolvedSymbol) {
@@ -9890,17 +10530,7 @@ const computeClosureCaptures = (functionNode, scopes) => {
 				}
 			}
 		}
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			if (TYPE_POSITION_CHILD_KEYS.has(key)) continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-		}
-	};
-	visit(functionNode);
+	});
 	return out;
 };
 const capturesByAnalysis = /* @__PURE__ */ new WeakMap();
@@ -10926,6 +11556,11 @@ If the missing value is recreated every render, move it inside the hook or stabi
 		return { CallExpression(node) {
 			const hookName = getHookName(node.callee, context.scopes);
 			if (!hookName || !isHookOfInterest(hookName, node.callee)) return;
+			if (HOOKS_REQUIRING_DEPS_MATCH.has(hookName) && !isReactApiCall(node, HOOKS_REQUIRING_DEPS_MATCH, context.scopes, {
+				allowGlobalReactNamespace: true,
+				allowUnboundBareCalls: true,
+				resolveNamedAliases: true
+			})) return;
 			const callbackArgumentIndex = getCallbackArgumentIndex(hookName);
 			const depsArgumentIndex = getDepsArgumentIndex(hookName);
 			const callbackArgument = node.arguments[callbackArgumentIndex];
@@ -11446,7 +12081,7 @@ const forbidDomProps = defineRule({
 		return { JSXOpeningElement(node) {
 			if (forbidMap.size === 0) return;
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const elementName = node.name.name;
+			const elementName = resolveJsxElementType(node);
 			if (isReactComponentName(elementName)) return;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -11524,7 +12159,7 @@ const forbidElements = defineRule({
 		return {
 			JSXOpeningElement(node) {
 				if (forbidMap.size === 0) return;
-				const fullName = flattenJsxName$1(node.name);
+				const fullName = resolveJsxElementType(node);
 				if (!fullName || !forbidMap.has(fullName)) return;
 				context.report({
 					node: node.name,
@@ -11886,8 +12521,7 @@ const buildMessage$22 = (childTagName) => `Your users get reshuffled HTML becaus
 const isParagraphElement = (candidate) => {
 	if (!isNodeOfType(candidate, "JSXElement")) return false;
 	const opening = candidate.openingElement;
-	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
-	return opening.name.name === "p";
+	return resolveJsxElementType(opening) === "p";
 };
 const findEnclosingParagraph = (openingElement) => {
 	const owningElement = openingElement.parent;
@@ -11908,8 +12542,7 @@ const htmlNoInvalidParagraphChild = defineRule({
 	severity: "warn",
 	recommendation: "Swap the `<p>` for a `<div>`, or move the child outside the paragraph.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const childTagName = node.name.name;
+		const childTagName = resolveJsxElementType(node);
 		if (!BLOCK_LEVEL_ELEMENTS.has(childTagName)) return;
 		if (!findEnclosingParagraph(node)) return;
 		context.report({
@@ -11940,7 +12573,7 @@ const getHostTagName = (jsxElement) => {
 	if (!isNodeOfType(jsxElement, "JSXElement")) return null;
 	const opening = jsxElement.openingElement;
 	if (!isNodeOfType(opening.name, "JSXIdentifier")) return null;
-	const tagName = opening.name.name;
+	const tagName = resolveJsxElementType(opening);
 	if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return null;
 	return tagName;
 };
@@ -11970,7 +12603,7 @@ const findClosestHostAncestor = (jsxElement) => {
 		if (isNodeOfType(ancestor, "JSXElement")) {
 			const opening = ancestor.openingElement;
 			if (isNodeOfType(opening.name, "JSXIdentifier")) {
-				const ancestorTag = opening.name.name;
+				const ancestorTag = resolveJsxElementType(opening);
 				if (ancestorTag.length === 0) {
 					previous = ancestor;
 					ancestor = ancestor.parent ?? null;
@@ -12052,8 +12685,7 @@ const buildMessage$20 = (tagName) => `Your users get broken clicks, focus & scre
 const isJsxElementWithTagName = (candidate, tagName) => {
 	if (!isNodeOfType(candidate, "JSXElement")) return false;
 	const opening = candidate.openingElement;
-	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
-	return opening.name.name === tagName;
+	return resolveJsxElementType(opening) === tagName;
 };
 const findEnclosingSameTag = (openingElement, tagName) => {
 	const owningElement = openingElement.parent;
@@ -12074,8 +12706,7 @@ const htmlNoNestedInteractive = defineRule({
 	severity: "warn",
 	recommendation: "Move the inner `<a>` or `<button>` so it's a sibling, or change the outer one to a plain `<div>` or `<span>`.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const tagName = node.name.name;
+		const tagName = resolveJsxElementType(node);
 		if (tagName !== "a" && tagName !== "button") return;
 		if (!findEnclosingSameTag(node, tagName)) return;
 		context.report({
@@ -12190,7 +12821,7 @@ const iframeMissingSandbox = defineRule({
 	matchByOccurrence: true,
 	create: skipNonProductionFiles((context) => ({
 		JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "iframe") return;
+			if (resolveJsxElementType(node) !== "iframe") return;
 			const sandboxAttr = hasJsxPropIgnoreCase(node.attributes, "sandbox");
 			if (!sandboxAttr) {
 				const hasExplicitSrc = Boolean(hasJsxPropIgnoreCase(node.attributes, "src"));
@@ -12426,30 +13057,6 @@ const insecureCryptoRisk = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/security-scan/utils/find-matching-bracket.ts
-const findMatchingBracket = (content, openIndex) => {
-	const open = content[openIndex];
-	const close = open === "(" ? ")" : open === "{" ? "}" : open === "[" ? "]" : "";
-	if (close === "") return -1;
-	let depth = 0;
-	let stringDelimiter = null;
-	for (let index = openIndex; index < content.length; index += 1) {
-		const character = content[index];
-		if (stringDelimiter !== null) {
-			if (character === "\\") index += 1;
-			else if (character === stringDelimiter) stringDelimiter = null;
-			continue;
-		}
-		if (character === "\"" || character === "'" || character === "`") stringDelimiter = character;
-		else if (character === open) depth += 1;
-		else if (character === close) {
-			depth -= 1;
-			if (depth === 0) return index;
-		}
-	}
-	return -1;
-};
-//#endregion
 //#region src/plugin/rules/security-scan/insecure-session-cookie.ts
 const AUTH_COOKIE_NAME_TOKEN = `(?<![A-Za-z0-9])(?:session|sess|sid|connect\\.sid|auth|jwt|access[_-]?token|refresh[_-]?token|id[_-]?token)(?![A-Za-z0-9])`;
 const AUTH_COOKIE_NAME_LITERAL = `[\`"'][^\`"']*?${AUTH_COOKIE_NAME_TOKEN}[^\`"']*[\`"']`;
@@ -13206,6 +13813,28 @@ const jsAsyncReduceWithoutAwaitedAcc = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/unwrap-discarded-expression.ts
+const unwrapDiscardedExpression = (node) => {
+	let expression = isNodeOfType(node, "ExpressionStatement") ? node.expression : node;
+	for (;;) {
+		expression = stripParenExpression(expression);
+		if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") {
+			expression = expression.argument;
+			continue;
+		}
+		if (isNodeOfType(expression, "SequenceExpression")) {
+			const expressions = expression.expressions ?? [];
+			const finalExpression = expressions.at(-1);
+			const prefixExpressions = expressions.slice(0, -1);
+			if (finalExpression && prefixExpressions.length > 0 && prefixExpressions.every((prefixExpression) => isNodeOfType(stripParenExpression(prefixExpression), "Literal"))) {
+				expression = finalExpression;
+				continue;
+			}
+		}
+		return expression;
+	}
+};
+//#endregion
 //#region src/plugin/rules/js-performance/js-batch-dom-css.ts
 const ITERATOR_METHOD_NAMES$2 = new Set([
 	"forEach",
@@ -13390,9 +14019,19 @@ const hasAttachmentBefore = (scopeOwner, elementName, beforeStart) => {
 	});
 	return foundAttachment;
 };
+const getStyleAssignment = (node) => {
+	if (!isNodeOfType(node, "ExpressionStatement")) return null;
+	const expression = unwrapDiscardedExpression(node);
+	if (!isNodeOfType(expression, "AssignmentExpression")) return null;
+	if (!isNodeOfType(expression.left, "MemberExpression")) return null;
+	if (!isNodeOfType(expression.left.object, "MemberExpression")) return null;
+	if (!isNodeOfType(expression.left.object.property, "Identifier")) return null;
+	return expression.left.object.property.name === "style" ? expression : null;
+};
 const isProvablyDetachedAtWrite = (styleWriteStatement) => {
-	if (!isNodeOfType(styleWriteStatement, "ExpressionStatement") || !isNodeOfType(styleWriteStatement.expression, "AssignmentExpression") || !isNodeOfType(styleWriteStatement.expression.left, "MemberExpression") || !isNodeOfType(styleWriteStatement.expression.left.object, "MemberExpression")) return false;
-	const elementExpression = styleWriteStatement.expression.left.object.object;
+	const assignment = getStyleAssignment(styleWriteStatement);
+	if (!assignment || !isNodeOfType(assignment.left, "MemberExpression") || !isNodeOfType(assignment.left.object, "MemberExpression")) return false;
+	const elementExpression = assignment.left.object.object;
 	const creationRoot = resolveDetachedCreationRoot(elementExpression, 0);
 	if (!creationRoot) return false;
 	return !hasAttachmentBefore(creationRoot.scopeOwner, creationRoot.rootName, getNodeStart$1(styleWriteStatement));
@@ -13404,15 +14043,17 @@ const jsBatchDomCss = defineRule({
 	severity: "warn",
 	recommendation: "Do all your reads first, then all your writes. Mixing them inside a loop makes the browser recalculate the layout again and again, which is slow",
 	create: (context) => {
-		const isStyleAssignment = (node) => isNodeOfType(node, "ExpressionStatement") && isNodeOfType(node.expression, "AssignmentExpression") && isNodeOfType(node.expression.left, "MemberExpression") && isNodeOfType(node.expression.left.object, "MemberExpression") && isNodeOfType(node.expression.left.object.property, "Identifier") && node.expression.left.object.property.name === "style";
-		const writesLayoutAffectingProperty = (node) => isNodeOfType(node, "ExpressionStatement") && isNodeOfType(node.expression, "AssignmentExpression") && isNodeOfType(node.expression.left, "MemberExpression") && isNodeOfType(node.expression.left.property, "Identifier") && !LAYOUT_NEUTRAL_STYLE_PROPERTY_NAMES.has(node.expression.left.property.name);
+		const writesLayoutAffectingProperty = (node) => {
+			const assignment = getStyleAssignment(node);
+			return assignment !== null && isNodeOfType(assignment.left, "MemberExpression") && isNodeOfType(assignment.left.property, "Identifier") && !LAYOUT_NEUTRAL_STYLE_PROPERTY_NAMES.has(assignment.left.property.name);
+		};
 		return { BlockStatement(node) {
 			const perIterationBody = findEnclosingPerIterationBody(node);
 			if (!perIterationBody) return;
 			const statements = node.body ?? [];
 			let layoutReads = null;
 			for (let statementIndex = 1; statementIndex < statements.length; statementIndex++) {
-				if (!isStyleAssignment(statements[statementIndex]) || !isStyleAssignment(statements[statementIndex - 1])) continue;
+				if (getStyleAssignment(statements[statementIndex]) === null || getStyleAssignment(statements[statementIndex - 1]) === null) continue;
 				if (!writesLayoutAffectingProperty(statements[statementIndex]) && !writesLayoutAffectingProperty(statements[statementIndex - 1])) continue;
 				layoutReads ??= scanPerIterationLayoutReads(perIterationBody);
 				if (!layoutReads.hasUsedLayoutRead || layoutReads.hasDeliberateForcedReflow) return;
@@ -14108,6 +14749,18 @@ const jsHoistRegexp = defineRule({
 	}, { treatIteratorCallbacksAsLoops: true })
 });
 //#endregion
+//#region src/plugin/utils/resolve-first-argument-binding.ts
+const resolveFirstArgumentBinding = (firstParameter) => {
+	if (!firstParameter) return null;
+	if (!isNodeOfType(firstParameter, "RestElement")) return firstParameter;
+	if (!isNodeOfType(firstParameter.argument, "ArrayPattern")) return null;
+	const elements = firstParameter.argument.elements ?? [];
+	if (elements.length !== 1) return null;
+	const firstBinding = elements[0];
+	if (!firstBinding || isNodeOfType(firstBinding, "RestElement")) return null;
+	return firstBinding;
+};
+//#endregion
 //#region src/plugin/rules/js-performance/js-index-maps.ts
 const referencesParameter = (expression, parameterName) => {
 	if (!expression) return false;
@@ -14118,7 +14771,7 @@ const referencesParameter = (expression, parameterName) => {
 const isSingleFieldEqualityPredicate = (node) => {
 	const callback = node.arguments?.[0];
 	if (!isInlineFunctionExpression(callback)) return false;
-	const firstParameter = callback.params?.[0];
+	const firstParameter = resolveFirstArgumentBinding(callback.params?.[0]);
 	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
 	let predicate = null;
 	const body = callback.body;
@@ -14220,7 +14873,11 @@ const jsIndexMaps = defineRule({
 //#region src/plugin/utils/are-expressions-structurally-equal.ts
 const areExpressionsStructurallyEqual = (a, b) => {
 	if (!a || !b) return a === b;
+	const unwrappedA = stripParenExpression(a);
+	const unwrappedB = stripParenExpression(b);
+	if (unwrappedA !== a || unwrappedB !== b) return areExpressionsStructurallyEqual(unwrappedA, unwrappedB);
 	if (a.type !== b.type) return false;
+	if (isNodeOfType(a, "ThisExpression")) return true;
 	if (isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier")) return a.name === b.name;
 	if (isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal")) return a.value === b.value;
 	if (isNodeOfType(a, "MemberExpression") && isNodeOfType(b, "MemberExpression")) {
@@ -14806,9 +15463,21 @@ const isSmallFixedListMember = (receiver) => {
 };
 const getResolvedInitializer = (receiver) => {
 	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const initializer = findVariableInitializer(receiver, receiver.name)?.initializer ?? null;
-	if (initializer && isNodeOfType(initializer, "Identifier")) return findVariableInitializer(initializer, initializer.name)?.initializer ?? initializer;
-	return initializer;
+	const binding = findVariableInitializer(receiver, receiver.name);
+	const initializer = binding?.initializer ?? null;
+	if (!binding || !initializer) return null;
+	const isDefault = isNodeOfType(binding.bindingIdentifier.parent, "AssignmentPattern");
+	if (isNodeOfType(initializer, "Identifier")) {
+		const aliased = findVariableInitializer(initializer, initializer.name);
+		if (aliased?.initializer) return {
+			initializer: aliased.initializer,
+			isDefault: isDefault || isNodeOfType(aliased.bindingIdentifier.parent, "AssignmentPattern")
+		};
+	}
+	return {
+		initializer,
+		isDefault
+	};
 };
 const isSplitCall = (expression) => {
 	if (!expression) return false;
@@ -14974,8 +15643,8 @@ const isBoundedConstantCollection = (collection) => {
 	if (isScreamingSnakeCaseConstantReceiver(stripped)) return true;
 	if (isSmallInlineLiteralArray(stripped)) return true;
 	if (isNodeOfType(stripped, "Identifier")) {
-		const initializer = getResolvedInitializer(stripped);
-		if (initializer && isSmallInlineLiteralArray(initializer)) return true;
+		const resolved = getResolvedInitializer(stripped);
+		if (resolved && !resolved.isDefault && isSmallInlineLiteralArray(resolved.initializer)) return true;
 	}
 	return false;
 };
@@ -15027,8 +15696,8 @@ const jsSetMapLookups = defineRule({
 			if (isIndexedArrayElementWithStringArgument(receiver, node.arguments?.[0])) return;
 			const resolvedInitializer = getResolvedInitializer(receiver);
 			if (resolvedInitializer) {
-				if (isLikelyStringReceiver(resolvedInitializer)) return;
-				if (isSmallInlineLiteralArray(resolvedInitializer)) return;
+				if (isLikelyStringReceiver(resolvedInitializer.initializer)) return;
+				if (!resolvedInitializer.isDefault && isSmallInlineLiteralArray(resolvedInitializer.initializer)) return;
 			}
 			if (isStringElementOfSplitIteration(receiver)) return;
 			if (isReceiverDeclaredInNearestLoop(receiver, node)) return;
@@ -15441,14 +16110,21 @@ const jsxFilenameExtension = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/is-jsx-fragment-element.ts
-const isJsxFragmentElement = (node) => {
+const isJsxFragmentElement = (node, scopes) => {
 	if (!isNodeOfType(node, "JSXOpeningElement")) return false;
 	const elementName = node.name;
-	if (isNodeOfType(elementName, "JSXIdentifier")) return elementName.name === "Fragment";
+	if (isNodeOfType(elementName, "JSXIdentifier")) {
+		if (!scopes) return elementName.name === "Fragment";
+		const symbol = resolveConstIdentifierAlias(elementName, scopes);
+		if (!symbol) return elementName.name === "Fragment" && scopes.isGlobalReference(elementName);
+		return isImportedFromReact(symbol) && getImportedName(symbol.declarationNode) === "Fragment";
+	}
 	if (isNodeOfType(elementName, "JSXMemberExpression")) {
 		if (!isNodeOfType(elementName.object, "JSXIdentifier")) return false;
-		if (elementName.object.name !== "React") return false;
-		return elementName.property.name === "Fragment";
+		if (elementName.property.name !== "Fragment") return false;
+		if (!scopes) return elementName.object.name === "React";
+		if (isReactNamespaceImport(elementName.object, scopes)) return true;
+		return elementName.object.name === "React" && scopes.isGlobalReference(elementName.object);
 	}
 	return false;
 };
@@ -15474,7 +16150,7 @@ const jsxFragments = defineRule({
 				if (mode !== "syntax") return;
 				if (!node.closingElement) return;
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement)) return;
+				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
 				if (openingElement.attributes.length > 0) return;
 				context.report({
 					node: openingElement,
@@ -18155,10 +18831,6 @@ const resolveSettings$29 = (settings) => {
 	if (typeof reactDoctor !== "object" || reactDoctor === null) return {};
 	return reactDoctor.jsxNoScriptUrl ?? {};
 };
-const getElementName = (node) => {
-	if (isNodeOfType(node.name, "JSXIdentifier")) return node.name.name;
-	return null;
-};
 const isLinkPropForElement = (elementName, attributeName, options) => {
 	if (elementName === "a" && attributeName === "href") return true;
 	const explicit = options.components?.[elementName];
@@ -18178,7 +18850,8 @@ const jsxNoScriptUrl = defineRule({
 	create: (context) => {
 		const options = resolveSettings$29(context.settings);
 		return { JSXOpeningElement(node) {
-			const elementName = getElementName(node);
+			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+			const elementName = resolveJsxElementType(node);
 			if (!elementName) return;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -18365,11 +19038,6 @@ const checkTarget = (attributeValue) => {
 		alternate: false
 	};
 };
-const getOpeningElementName = (node) => {
-	const name = node.name;
-	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
-	return null;
-};
 const jsxNoTargetBlank = defineRule({
 	id: "jsx-no-target-blank",
 	title: "Unsafe target=_blank link",
@@ -18389,7 +19057,8 @@ const jsxNoTargetBlank = defineRule({
 			return settings.formComponents.has(tagName);
 		};
 		return { JSXOpeningElement(node) {
-			const tagName = getOpeningElementName(node);
+			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+			const tagName = resolveJsxElementType(node);
 			if (!tagName) return;
 			if (!isLink(tagName) && !isForm(tagName)) return;
 			const linkAttributeNames = settings.linkComponents.get(tagName) ?? ["href"];
@@ -18622,7 +19291,7 @@ const jsxNoUselessFragment = defineRule({
 		return {
 			JSXElement(node) {
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement)) return;
+				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
 				if (hasJsxKeyAttribute(openingElement)) return;
 				if (checkChildren(node, openingElement, node.children)) return;
 				if (isChildOfHtmlElement(node)) context.report({
@@ -18924,6 +19593,7 @@ const jwtInsecureVerification = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/security-scan/key-lifecycle-risk.ts
+const KEY_MATERIAL_MARKER_PATTERN = /PRIVATE KEY|SSH_PRIVATE_KEY|GPG_PRIVATE_KEY|DEPLOY_KEY|SIGNING_KEY/i;
 const keyLifecycleRisk = defineRule({
 	id: "key-lifecycle-risk",
 	title: "Long-lived key material in repository",
@@ -18931,7 +19601,7 @@ const keyLifecycleRisk = defineRule({
 	committedFilesOnly: true,
 	recommendation: "Remove private keys from source, rotate exposed credentials, prefer short-lived deploy credentials, and document revocation/expiry for release keys.",
 	scan: scanByPattern({
-		shouldScan: (file) => !TEST_CONTEXT_PATTERN.test(file.relativePath) && !DOCUMENTATION_CONTEXT_PATTERN.test(file.relativePath),
+		shouldScan: (file) => !TEST_CONTEXT_PATTERN.test(file.relativePath) && !DOCUMENTATION_CONTEXT_PATTERN.test(file.relativePath) && KEY_MATERIAL_MARKER_PATTERN.test(file.content),
 		pattern: /(?<!(?:placeholder|example|sample|dummy|fake)[\s\S]{0,40})-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----(?:\s|\\r|\\n)*[A-Za-z0-9+/=][A-Za-z0-9+/=\s]{38,}(?![^-]{0,160}\.\.\.)|\b(?:SSH_PRIVATE_KEY|GPG_PRIVATE_KEY|DEPLOY_KEY|SIGNING_KEY)\b\s*[:=]\s*["'][^"'\n]{16,}["']/i,
 		message: "Private or long-lived release key material appears in the repository."
 	})
@@ -19637,15 +20307,21 @@ const localRpcNativeBridgeRisk = defineRule({
 		message: "Code appears to bridge browser code to localhost/native capabilities with weak origin or update/install checks."
 	})
 });
+//#endregion
+//#region src/plugin/rules/security-scan/mcp-tool-capability-risk.ts
+const MCP_IMPORT_PATTERN = /\bfrom\s+["']@modelcontextprotocol\/sdk[^"']*["']|\bMcpServer\b|\bMcpAgent\b/;
+const MCP_IMPORT_PREFILTER_PATTERN = /@modelcontextprotocol\/sdk|\bMcpServer\b|\bMcpAgent\b/;
+const MCP_TOOL_SURFACE_PATTERN = /\bserver\.\s*tool\s*\(|\bregisterTool\s*\(|\bsetRequestHandler\s*\(\s*CallToolRequestSchema/;
+const MCP_TOOL_SURFACE_PREFILTER_PATTERN = /\b(?:tool|registerTool|setRequestHandler)\b/;
 const mcpToolCapabilityRisk = defineRule({
 	id: "mcp-tool-capability-risk",
 	title: "MCP tool exposes dangerous capability",
 	severity: "warn",
 	recommendation: "MCP tool calls run with the connecting client's authority. Validate inputs, enforce per-tool authorization, and avoid raw filesystem/shell/network access where possible.",
 	scan: scanByPattern({
-		shouldScan: (file) => isProductionSourcePath(file.relativePath),
-		pattern: /\bserver\.\s*tool\s*\(|\bregisterTool\s*\(|\bsetRequestHandler\s*\(\s*CallToolRequestSchema/,
-		requireAll: [/\bfrom\s+["']@modelcontextprotocol\/sdk[^"']*["']|\bMcpServer\b|\bMcpAgent\b/, AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN],
+		shouldScan: (file) => isProductionSourcePath(file.relativePath) && MCP_IMPORT_PREFILTER_PATTERN.test(file.content) && MCP_TOOL_SURFACE_PREFILTER_PATTERN.test(file.content) && AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN.test(file.content),
+		pattern: MCP_TOOL_SURFACE_PATTERN,
+		requireAll: [MCP_IMPORT_PATTERN, AGENT_TOOL_DANGEROUS_CAPABILITY_PATTERN],
 		ignoreStringLiterals: true,
 		message: "An MCP tool/resource/prompt handler appears to expose file, shell, network, or code-execution capability."
 	})
@@ -19857,11 +20533,24 @@ const hasDirective = (programNode, directive) => {
 	return Boolean(programNode.body?.some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === directive));
 };
 //#endregion
-//#region src/plugin/utils/is-uppercase-name.ts
-const isUppercaseName = (name) => UPPERCASE_PATTERN.test(name);
-//#endregion
-//#region src/plugin/utils/is-component-assignment.ts
-const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
+//#region src/plugin/utils/unwrap-object-integrity-expression.ts
+const OBJECT_INTEGRITY_METHOD_NAMES = new Set([
+	"freeze",
+	"seal",
+	"preventExtensions"
+]);
+const OBJECT_FREEZE_OR_SEAL_METHOD_NAMES = new Set(["freeze", "seal"]);
+const unwrapObjectIntegrityExpression = (node, scopes, methodNames = OBJECT_INTEGRITY_METHOD_NAMES) => {
+	let expression = stripParenExpression(node);
+	while (isNodeOfType(expression, "CallExpression")) {
+		const callee = stripParenExpression(expression.callee);
+		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || callee.object.name !== "Object" || !scopes.isGlobalReference(callee.object) || !isNodeOfType(callee.property, "Identifier") || !methodNames.has(callee.property.name)) break;
+		const wrappedExpression = expression.arguments[0];
+		if (!wrappedExpression || isNodeOfType(wrappedExpression, "SpreadElement")) break;
+		expression = stripParenExpression(wrappedExpression);
+	}
+	return expression;
+};
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-async-client-component.ts
 const nextjsAsyncClientComponent = defineRule({
@@ -19887,10 +20576,10 @@ const nextjsAsyncClientComponent = defineRule({
 			},
 			VariableDeclarator(node) {
 				if (!fileHasUseClient) return;
-				if (!isComponentAssignment(node)) return;
-				if (!isInlineFunctionExpression(node.init)) return;
-				if (!node.init.async) return;
 				if (!isNodeOfType(node.id, "Identifier")) return;
+				if (!isUppercaseName(node.id.name) || !node.init) return;
+				const componentFunction = unwrapObjectIntegrityExpression(node.init, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES);
+				if (!isInlineFunctionExpression(componentFunction) || !componentFunction.async) return;
 				context.report({
 					node,
 					message: `Async client component "${node.id.name}" fails to render because client components can't be async.`
@@ -20192,7 +20881,7 @@ const nextjsNoAElement = defineRule({
 	severity: "warn",
 	recommendation: "`import Link from 'next/link'` for client-side navigation, prefetching, and preserved scroll position",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
+		if (resolveJsxElementType(node) !== "a") return;
 		const attributes = node.attributes ?? [];
 		const downloadAttribute = findJsxAttribute(attributes, "download");
 		if (downloadAttribute) {
@@ -20388,7 +21077,7 @@ const nextjsNoCssLink = defineRule({
 	severity: "warn",
 	recommendation: "Import CSS directly or use CSS Modules so Next.js can bundle, order, and optimize the stylesheet.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "link") return;
+		if (resolveJsxElementType(node) !== "link") return;
 		const attributes = node.attributes ?? [];
 		const relAttribute = findJsxAttribute(attributes, "rel");
 		if (!relAttribute?.value) return;
@@ -20496,7 +21185,7 @@ const nextjsNoFontLink = defineRule({
 	severity: "warn",
 	recommendation: "`import { Inter } from \"next/font/google\"` for self-hosting, zero layout shift, and no render-blocking requests",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "link") return;
+		if (resolveJsxElementType(node) !== "link") return;
 		const attributes = node.attributes ?? [];
 		const hrefAttribute = findJsxAttribute(attributes, "href");
 		if (!hrefAttribute?.value) return;
@@ -20671,7 +21360,7 @@ const nextjsNoImgElement = defineRule({
 	create: (context) => {
 		if (isGeneratedImageRenderContext(context)) return {};
 		return { JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "img") return;
+			if (resolveJsxElementType(node) !== "img") return;
 			if (isGeneratedImageRenderContext(context, node)) return;
 			const programRoot = findProgramRoot(node);
 			if (programRoot && hasEmailTemplateImport(programRoot)) return;
@@ -20718,8 +21407,8 @@ const nextjsNoPolyfillScript = defineRule({
 	severity: "warn",
 	recommendation: "Next.js includes polyfills for fetch, Promise, Object.assign, Array.from, and 50+ others automatically",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		if (node.name.name !== "script" && node.name.name !== "Script") return;
+		const elementName = resolveJsxElementType(node);
+		if (elementName !== "script" && elementName !== "Script") return;
 		const srcAttribute = findJsxAttribute(node.attributes ?? [], "src");
 		if (!srcAttribute?.value) return;
 		const srcValue = isNodeOfType(srcAttribute.value, "Literal") ? srcAttribute.value.value : null;
@@ -20756,8 +21445,8 @@ const catchClauseRethrowsCaught = (handler) => {
 	return didRethrow;
 };
 //#endregion
-//#region src/plugin/utils/find-guarding-try-statement.ts
-const isImmediatelyInvokedFunctionCallee = (functionNode) => {
+//#region src/plugin/utils/is-immediately-invoked-function.ts
+const isImmediatelyInvokedFunction = (functionNode) => {
 	let wrappedCallee = functionNode;
 	let enclosing = functionNode.parent;
 	while (enclosing && stripParenExpression(enclosing) === functionNode) {
@@ -20766,11 +21455,13 @@ const isImmediatelyInvokedFunctionCallee = (functionNode) => {
 	}
 	return Boolean(enclosing && isNodeOfType(enclosing, "CallExpression") && enclosing.callee === wrappedCallee);
 };
+//#endregion
+//#region src/plugin/utils/find-guarding-try-statement.ts
 const findGuardingTryStatement = (node) => {
 	let child = node;
 	let ancestor = node.parent;
 	while (ancestor) {
-		if (isFunctionLike$1(ancestor) && !isImmediatelyInvokedFunctionCallee(ancestor)) return null;
+		if (isFunctionLike$1(ancestor) && !isImmediatelyInvokedFunction(ancestor)) return null;
 		if (isNodeOfType(ancestor, "TryStatement") && ancestor.block === child && ancestor.handler && !catchClauseRethrowsCaught(ancestor.handler)) return ancestor;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
@@ -21322,7 +22013,7 @@ const FILENAME_TO_LANG = {
 const resolveLang = (filename) => {
 	return FILENAME_TO_LANG[path.extname(filename).toLowerCase()] ?? "tsx";
 };
-const parseSourceText = (filename, sourceText) => {
+const parseSourceText = ({ filename, sourceText, shouldAttachParentReferences = true }) => {
 	try {
 		const result = parseSync(filename, sourceText, {
 			astType: "ts",
@@ -21330,7 +22021,7 @@ const parseSourceText = (filename, sourceText) => {
 		});
 		if (result.errors.some((parseError) => parseError.severity === "Error")) return null;
 		const parsedProgram = result.program;
-		attachParentReferences(parsedProgram);
+		if (shouldAttachParentReferences) attachParentReferences(parsedProgram);
 		return parsedProgram;
 	} catch {
 		return null;
@@ -21368,7 +22059,10 @@ const parseSourceFile = (absoluteFilePath) => {
 		});
 		return null;
 	}
-	const parsedProgram = parseSourceText(absoluteFilePath, sourceText);
+	const parsedProgram = parseSourceText({
+		filename: absoluteFilePath,
+		sourceText
+	});
 	parseCache.set(absoluteFilePath, {
 		mtimeMs: fileStat.mtimeMs,
 		size: fileStat.size,
@@ -21900,6 +22594,8 @@ const DOM_QUERY_MEMBER_NAMES = new Set([
 ]);
 const LAYOUT_MEASUREMENT_MEMBER_NAMES = new Set([
 	"current",
+	"textContent",
+	"innerText",
 	"scrollWidth",
 	"clientWidth",
 	"offsetWidth",
@@ -21921,7 +22617,7 @@ const POST_MOUNT_GLOBAL_NAMES = new Set([
 	"navigator"
 ]);
 const REF_FACTORY_CALLEE_NAMES = new Set(["useRef", "createRef"]);
-const hasRefLikeName = (name) => name === "ref" || name.endsWith("Ref") || name.endsWith("ref");
+const hasRefLikeName = (name) => name === "ref" || name.endsWith("Ref") || name.endsWith("ref") || name.endsWith("Node") || name.endsWith("node") || name.endsWith("Element") || name.endsWith("element");
 const isRefFactoryInitializer = (init) => {
 	if (!init || !isNodeOfType(init, "CallExpression")) return false;
 	const callee = init.callee;
@@ -22004,88 +22700,37 @@ const readsPostMountValue = (root) => {
 	return found;
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/effect/constants.ts
-const TYPESCRIPT_VISITOR_KEYS = {
-	TSAsExpression: ["expression", "typeAnnotation"],
-	TSNonNullExpression: ["expression"],
-	TSSatisfiesExpression: ["expression", "typeAnnotation"],
-	TSTypeAssertion: ["typeAnnotation", "expression"],
-	TSInstantiationExpression: ["expression", "typeArguments"]
-};
-const VISITOR_KEYS = {
-	...eslintVisitorKeys.KEYS,
-	...TYPESCRIPT_VISITOR_KEYS
-};
+//#region src/plugin/rules/state-and-effects/utils/effect/get-ast-child-keys.ts
+const getAstChildKeys = (node) => visitorKeys[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/get-program-analysis.ts
 const programToAnalysis = /* @__PURE__ */ new WeakMap();
-const stripAndRecordParents = (root) => {
-	const restorations = [];
-	const seen = /* @__PURE__ */ new WeakSet();
-	const visit = (value) => {
-		if (!value || typeof value !== "object") return;
-		if (seen.has(value)) return;
-		seen.add(value);
-		if (Array.isArray(value)) {
-			for (const item of value) visit(item);
-			return;
-		}
-		const record = value;
-		if (!("type" in record)) return;
-		if ("parent" in record) {
-			restorations.push({
-				node: record,
-				originalParent: record.parent
-			});
-			record.parent = null;
-		}
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			visit(record[key]);
-		}
-	};
-	visit(root);
-	return restorations;
-};
-const restoreParents = (restorations) => {
-	for (const restoration of restorations) restoration.node.parent = restoration.originalParent;
-};
 const getProgramAnalysis = (anyNode) => {
 	const programNode = findProgramRoot(anyNode);
 	if (!programNode) return null;
 	const cached = programToAnalysis.get(programNode);
 	if (cached) return cached;
-	const restorations = stripAndRecordParents(programNode);
-	let scopeManager;
-	try {
-		scopeManager = analyze(programNode, {
-			ecmaVersion: 2024,
-			sourceType: "module",
-			childVisitorKeys: VISITOR_KEYS,
-			fallback: "iteration"
-		});
-	} finally {
-		restoreParents(restorations);
-	}
 	const analysis = {
 		programNode,
-		scopeManager
+		scopeManager: analyze(programNode, {
+			ecmaVersion: 2024,
+			sourceType: "module",
+			childVisitorKeys: RUNTIME_VISITOR_KEYS,
+			fallback: getAstChildKeys
+		}),
+		scopeByNode: /* @__PURE__ */ new WeakMap(),
+		referenceByIdentifier: /* @__PURE__ */ new WeakMap()
 	};
 	programToAnalysis.set(programNode, analysis);
 	return analysis;
 };
-const scopeByNodeCache = /* @__PURE__ */ new WeakMap();
-const getScopeForNode = (node, manager) => {
+const getScopeForNode = (node, analysis) => {
 	if (!node.range) return null;
-	let scopeByNode = scopeByNodeCache.get(manager);
-	if (!scopeByNode) {
-		scopeByNode = /* @__PURE__ */ new WeakMap();
-		scopeByNodeCache.set(manager, scopeByNode);
-	}
+	const scopeByNode = analysis.scopeByNode;
 	if (scopeByNode.has(node)) return scopeByNode.get(node) ?? null;
 	let bestScope = null;
 	let bestSize = Infinity;
-	for (const scope of manager.scopes) {
+	for (const scope of analysis.scopeManager.scopes) {
 		const block = scope.block;
 		if (!block?.range) continue;
 		if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
@@ -22100,7 +22745,6 @@ const getScopeForNode = (node, manager) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/ast.ts
-const getChildKeys = (node) => VISITOR_KEYS[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
 const HOOK_NAME_PATTERN$2 = /^use[A-Z0-9]/;
 const isInsideCallbackArgumentOf = (identifier, initializer) => {
 	if (!isNodeOfType(initializer, "CallExpression") && !isNodeOfType(initializer, "NewExpression")) return false;
@@ -22136,7 +22780,7 @@ const descend = (node, visit, visited = /* @__PURE__ */ new Set()) => {
 	if (visited.has(node)) return;
 	visit(node);
 	visited.add(node);
-	const keys = getChildKeys(node);
+	const keys = getAstChildKeys(node);
 	const record = node;
 	for (const key of keys) {
 		const child = record[key];
@@ -22169,16 +22813,11 @@ const findDownstreamNodes = (topNode, type) => {
 	});
 	return nodes;
 };
-const refByIdentifierCache = /* @__PURE__ */ new WeakMap();
 const getRef = (analysis, identifier) => {
-	let refByIdentifier = refByIdentifierCache.get(analysis);
-	if (!refByIdentifier) {
-		refByIdentifier = /* @__PURE__ */ new WeakMap();
-		refByIdentifierCache.set(analysis, refByIdentifier);
-	}
+	const refByIdentifier = analysis.referenceByIdentifier;
 	if (refByIdentifier.has(identifier)) return refByIdentifier.get(identifier) ?? null;
 	let resolvedReference = null;
-	const scope = getScopeForNode(identifier, analysis.scopeManager);
+	const scope = getScopeForNode(identifier, analysis);
 	if (scope) {
 		for (const reference of scope.references) if (reference.identifier === identifier) {
 			resolvedReference = reference;
@@ -22426,7 +23065,7 @@ const isReactFunctionalHOC = (analysis, node) => {
 	const isWrappedSeparately = () => {
 		if (!isNodeOfType(node.id, "Identifier")) return false;
 		const bindingName = node.id.name;
-		const containingScope = getScopeForNode(node, analysis.scopeManager);
+		const containingScope = getScopeForNode(node, analysis);
 		if (!containingScope) return false;
 		const variable = containingScope.variables.find((v) => v.name === bindingName);
 		if (!variable) return false;
@@ -22577,10 +23216,15 @@ const isProp = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	if (!declaringNode) return false;
 	return isReactFunctionalComponent(declaringNode) && !isReactFunctionalHOC(analysis, declaringNode) || isCustomHook(declaringNode);
 }));
+const isWholePropsParameterBinding = (bindingNode) => {
+	if (isFunctionLike$1(bindingNode.parent)) return true;
+	let declaringFunction = bindingNode.parent;
+	while (declaringFunction && !isFunctionLike$1(declaringFunction)) declaringFunction = declaringFunction.parent;
+	return Boolean(declaringFunction && resolveFirstArgumentBinding(declaringFunction.params?.[0]) === bindingNode);
+};
 const isWholePropsObjectReference = (analysis, ref) => isProp(analysis, ref) && Boolean(ref.resolved?.defs.some((def) => {
 	if (def.type !== "Parameter") return false;
-	const bindingParent = def.name.parent;
-	return isFunctionLike$1(bindingParent);
+	return isWholePropsParameterBinding(def.name);
 }));
 const isIdentifierOrMemberExpression = (node) => isNodeOfType(node, "Identifier") || isNodeOfType(node, "MemberExpression");
 const isPropAlias = (analysis, ref) => {
@@ -22657,11 +23301,14 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 	if (isNodeOfType(node, "ReturnStatement") && node.argument != null) return isCleanupReturnArgument(analysis, node.argument);
 	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$1(node)) return false;
 	const record = node;
-	for (const [key, value] of Object.entries(record)) {
-		if (key === "parent") continue;
-		if (Array.isArray(value)) {
-			if (value.some((item) => isAstNode(item) && hasCleanupReturn(analysis, item, visited))) return true;
-		} else if (isAstNode(value) && hasCleanupReturn(analysis, value, visited)) return true;
+	const childKeys = getAstChildKeys(node);
+	for (let keyIndex = 0; keyIndex < childKeys.length; keyIndex += 1) {
+		const value = record[childKeys[keyIndex]];
+		if (Array.isArray(value)) for (let itemIndex = 0; itemIndex < value.length; itemIndex += 1) {
+			const item = value[itemIndex];
+			if (isAstNode(item) && hasCleanupReturn(analysis, item, visited)) return true;
+		}
+		else if (isAstNode(value) && hasCleanupReturn(analysis, value, visited)) return true;
 	}
 	return false;
 };
@@ -22889,61 +23536,73 @@ const PURE_GLOBAL_CALLEE_NAMES = new Set([
 	"Array",
 	"BigInt",
 	"Boolean",
+	"encodeURIComponent",
 	"Number",
 	"Object",
 	"String",
 	"parseFloat",
-	"parseInt"
+	"parseInt",
+	"structuredClone"
+]);
+const PURE_GLOBAL_CONSTRUCTOR_NAMES = new Set(["Date", "Set"]);
+const PURE_HELPER_NAMESPACE_MEMBER_NAMES = new Map([
+	["Array", new Set(["from"])],
+	["JSON", new Set([
+		"isRawJSON",
+		"parse",
+		"rawJSON",
+		"stringify"
+	])],
+	["Math", new Set([
+		"abs",
+		"acos",
+		"acosh",
+		"asin",
+		"asinh",
+		"atan",
+		"atan2",
+		"atanh",
+		"cbrt",
+		"ceil",
+		"clz32",
+		"cos",
+		"cosh",
+		"exp",
+		"floor",
+		"fround",
+		"hypot",
+		"imul",
+		"log",
+		"log10",
+		"log1p",
+		"log2",
+		"max",
+		"min",
+		"pow",
+		"round",
+		"sign",
+		"sin",
+		"sinh",
+		"sqrt",
+		"tan",
+		"tanh",
+		"trunc"
+	])],
+	["Object", new Set(["assign"])]
 ]);
-const PURE_GLOBAL_NAMESPACE_NAMES = new Set(["JSON", "Math"]);
-const PURE_HELPER_NAMESPACE_MEMBER_NAMES = new Map([["JSON", new Set([
-	"isRawJSON",
-	"parse",
-	"rawJSON",
-	"stringify"
-])], ["Math", new Set([
-	"abs",
-	"acos",
-	"acosh",
-	"asin",
-	"asinh",
-	"atan",
-	"atan2",
-	"atanh",
-	"cbrt",
-	"ceil",
-	"clz32",
-	"cos",
-	"cosh",
-	"exp",
-	"floor",
-	"fround",
-	"hypot",
-	"imul",
-	"log",
-	"log10",
-	"log1p",
-	"log2",
-	"max",
-	"min",
-	"pow",
-	"round",
-	"sign",
-	"sin",
-	"sinh",
-	"sqrt",
-	"tan",
-	"tanh",
-	"trunc"
-])]]);
 const PURE_MEMBER_TRANSFORM_NAMES = new Set([
 	"concat",
 	"filter",
+	"flatMap",
 	"join",
 	"map",
+	"reduce",
+	"replace",
+	"slice",
 	"split",
 	"toLowerCase",
 	"toString",
+	"toSorted",
 	"toUpperCase",
 	"trim"
 ]);
@@ -22952,7 +23611,7 @@ const STORAGE_GLOBAL_NAMES$1 = new Set([
 	"localStorage",
 	"sessionStorage"
 ]);
-const getStaticMemberName = (node) => {
+const getStaticMemberName$1 = (node) => {
 	if (!isNodeOfType(node, "MemberExpression")) return null;
 	if (!node.computed && isNodeOfType(node.property, "Identifier")) return node.property.name;
 	if (node.computed && isNodeOfType(node.property, "Literal")) return typeof node.property.value === "string" ? node.property.value : null;
@@ -22967,7 +23626,7 @@ const getCallCalleeName$1 = (callExpression) => {
 	if (!isNodeOfType(callExpression, "CallExpression")) return null;
 	const callee = stripParenExpression(callExpression.callee);
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	return getStaticMemberName(callee);
+	return getStaticMemberName$1(callee);
 };
 const getFunctionParameters = (functionNode) => isFunctionLike$1(functionNode) ? functionNode.params ?? [] : [];
 const getIdentifierBindingIdentity = (analysis, identifier) => {
@@ -23083,14 +23742,14 @@ const localUseEventPreservesCallback = (analysis, callee) => {
 			if (!isNodeOfType(child, "CallExpression")) return;
 			const forwardedCallee = stripParenExpression(child.callee);
 			if (!isNodeOfType(forwardedCallee, "MemberExpression")) return;
-			if (getStaticMemberName(forwardedCallee) !== "current") return;
+			if (getStaticMemberName$1(forwardedCallee) !== "current") return;
 			if (!isNodeOfType(forwardedCallee.object, "Identifier")) return;
 			const refReference = getRef(analysis, forwardedCallee.object);
 			if (!callbackRefDeclarators.find((declarator) => refReference?.resolved?.defs.some((definition) => definition.node === declarator)) || !refReference?.resolved) return;
 			if (!refReference.resolved.references.some((candidateReference) => {
 				const memberExpression = candidateReference.identifier.parent;
 				const assignmentExpression = memberExpression?.parent;
-				if (!memberExpression || !isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName(memberExpression) !== "current" || !assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression") || assignmentExpression.left !== memberExpression) return false;
+				if (!memberExpression || !isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName$1(memberExpression) !== "current" || !assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression") || assignmentExpression.left !== memberExpression) return false;
 				return getIdentifierBindingIdentity(analysis, assignmentExpression.right) !== callbackBinding;
 			})) forwardsCallback = true;
 		});
@@ -23115,7 +23774,7 @@ const resolveWrappedCallable = (analysis, node) => {
 		return callback && isFunctionLike$1(callback) ? callback : null;
 	}
 	if (!isNodeOfType(candidate, "MemberExpression")) return null;
-	if (getStaticMemberName(candidate) !== "current") return null;
+	if (getStaticMemberName$1(candidate) !== "current") return null;
 	if (!isNodeOfType(candidate.object, "Identifier")) return null;
 	const reference = getRef(analysis, candidate.object);
 	const declarator = reference?.resolved?.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
@@ -23127,7 +23786,7 @@ const resolveWrappedCallable = (analysis, node) => {
 	return Boolean(reference?.resolved?.references.some((candidateReference) => {
 		const member = candidateReference.identifier.parent;
 		const assignment = member?.parent;
-		return Boolean(member && isNodeOfType(member, "MemberExpression") && getStaticMemberName(member) === "current" && assignment && isNodeOfType(assignment, "AssignmentExpression") && assignment.left === member);
+		return Boolean(member && isNodeOfType(member, "MemberExpression") && getStaticMemberName$1(member) === "current" && assignment && isNodeOfType(assignment, "AssignmentExpression") && assignment.left === member);
 	})) ? null : initializer;
 };
 const functionInvokesItself = (analysis, functionNode) => {
@@ -23166,7 +23825,7 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilena
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const callee = stripParenExpression(child.callee);
 		const calleeName = getCallCalleeName$1(child);
-		const memberName = getStaticMemberName(callee);
+		const memberName = getStaticMemberName$1(callee);
 		const isDeferringCall = calleeName !== null && DEFERRING_CALLEE_NAMES.has(calleeName) || memberName !== null && DEFERRING_MEMBER_NAMES.has(memberName);
 		const isIteratorCall = memberName !== null && SYNCHRONOUS_ITERATOR_METHOD_NAMES$1.has(memberName) && isNodeOfType(callee, "MemberExpression");
 		const enqueueFrame = (callableNode, argumentsForCallable, isDeferred, introducedBindings, allowWithoutInvocationEvidence = false) => {
@@ -23325,14 +23984,19 @@ const analyzeHelperExpression = (expression, environment, usedParameterIndices)
 		const callbackSummary = analyzeHelperStatements(node.body.body ?? [], callbackEnvironment, usedParameterIndices, analyzeHelperExpression);
 		return callbackSummary.isValid && !callbackSummary.canContinue;
 	}
+	if (isNodeOfType(node, "NewExpression")) {
+		const callee = stripParenExpression(node.callee);
+		if (!isNodeOfType(callee, "Identifier") || !PURE_GLOBAL_CONSTRUCTOR_NAMES.has(callee.name) || environment.parameterIndices.has(callee.name) || environment.recursiveNames.has(callee.name) || environment.shadowedGlobalNames.has(callee.name)) return false;
+		return (node.arguments ?? []).every((argument) => analyzeHelperExpression(argument, environment, usedParameterIndices));
+	}
 	if (isNodeOfType(node, "CallExpression")) {
 		const callee = stripParenExpression(node.callee);
 		const calleeRoot = getMemberRoot(callee);
 		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && !environment.parameterIndices.has(callee.name) && !environment.recursiveNames.has(callee.name) && !environment.shadowedGlobalNames.has(callee.name);
 		const namespaceName = isNodeOfType(calleeRoot, "Identifier") && !environment.parameterIndices.has(calleeRoot.name) && !environment.recursiveNames.has(calleeRoot.name) && !environment.shadowedGlobalNames.has(calleeRoot.name) ? calleeRoot.name : null;
-		const namespaceMemberName = getStaticMemberName(callee);
+		const namespaceMemberName = getStaticMemberName$1(callee);
 		const isPureNamespaceCall = isNodeOfType(callee, "MemberExpression") && namespaceName !== null && namespaceMemberName !== null && PURE_HELPER_NAMESPACE_MEMBER_NAMES.get(namespaceName)?.has(namespaceMemberName) === true;
-		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
+		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName$1(callee) ?? "");
 		if (!isPureGlobalCall && !isPureNamespaceCall && !isPureMemberTransform) return false;
 		if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression") && !analyzeHelperExpression(callee.object, environment, usedParameterIndices)) return false;
 		return (node.arguments ?? []).every((argument) => analyzeHelperExpression(argument, environment, usedParameterIndices));
@@ -23406,7 +24070,7 @@ const isLocallyConstructedObjectMember = (reference, memberExpression) => isNode
 	return isNodeOfType(definitionNode, "VariableDeclarator") && Boolean(definitionNode.init) && (isNodeOfType(definitionNode.init, "ObjectExpression") || isNodeOfType(definitionNode.init, "ArrayExpression"));
 }) === true;
 const getUseRefDeclarator = (analysis, memberExpression) => {
-	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName(memberExpression) !== "current" || !isNodeOfType(memberExpression.object, "Identifier")) return null;
+	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName$1(memberExpression) !== "current" || !isNodeOfType(memberExpression.object, "Identifier")) return null;
 	return getRef(analysis, memberExpression.object)?.resolved?.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator") && isNodeOfType(definitionNode.init, "CallExpression") && getCallCalleeName$1(definitionNode.init) === "useRef") ?? null;
 };
 const collectValueEvidence = (analysis, expression, frame, remainingCallFrames, visitedBindings = /* @__PURE__ */ new Set()) => {
@@ -23475,7 +24139,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		return collectValueEvidence(analysis, initializer.init, frame, remainingCallFrames, visitedBindings);
 	}
 	if (isNodeOfType(node, "MemberExpression")) {
-		if (getStaticMemberName(node) === "current" && isNodeOfType(node.object, "Identifier")) {
+		if (getStaticMemberName$1(node) === "current" && isNodeOfType(node.object, "Identifier")) {
 			const refBinding = getRef(analysis, node.object)?.resolved;
 			const refDeclarator = useRefDeclarator;
 			if (refBinding && refDeclarator && isNodeOfType(refDeclarator, "VariableDeclarator") && isNodeOfType(refDeclarator.init, "CallExpression")) {
@@ -23491,7 +24155,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 					if (candidateReference.init) continue;
 					const identifier = candidateReference.identifier;
 					const member = identifier.parent;
-					if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== identifier || getStaticMemberName(member) !== "current") {
+					if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== identifier || getStaticMemberName$1(member) !== "current") {
 						evidence.hasUnknownSource = true;
 						continue;
 					}
@@ -23527,8 +24191,8 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		}
 		const callee = stripParenExpression(node.callee);
 		const calleeRoot = getMemberRoot(callee);
-		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && getIdentifierBindingIdentity(analysis, callee) === null || isNodeOfType(calleeRoot, "Identifier") && PURE_GLOBAL_NAMESPACE_NAMES.has(calleeRoot.name) && getIdentifierBindingIdentity(analysis, calleeRoot) === null;
-		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
+		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && getIdentifierBindingIdentity(analysis, callee) === null || isNodeOfType(callee, "MemberExpression") && isNodeOfType(calleeRoot, "Identifier") && getIdentifierBindingIdentity(analysis, calleeRoot) === null && PURE_HELPER_NAMESPACE_MEMBER_NAMES.get(calleeRoot.name)?.has(getStaticMemberName$1(callee) ?? "") === true;
+		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName$1(callee) ?? "");
 		if (isPureGlobalCall || isPureMemberTransform) {
 			if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression")) mergeEvidence(evidence, collectValueEvidence(analysis, callee.object, frame, remainingCallFrames, new Set(visitedBindings)));
 			for (const argument of node.arguments ?? []) {
@@ -23580,6 +24244,15 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		}
 		return evidence;
 	}
+	if (isNodeOfType(node, "NewExpression")) {
+		const callee = stripParenExpression(node.callee);
+		if (!isNodeOfType(callee, "Identifier") || !PURE_GLOBAL_CONSTRUCTOR_NAMES.has(callee.name) || getIdentifierBindingIdentity(analysis, callee) !== null) {
+			evidence.hasUnknownSource = true;
+			return evidence;
+		}
+		for (const argument of node.arguments ?? []) mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames, new Set(visitedBindings)));
+		return evidence;
+	}
 	if (isFunctionLike$1(node) || isNodeOfType(node, "AwaitExpression")) {
 		evidence.hasUnknownSource = true;
 		return evidence;
@@ -23998,6 +24671,26 @@ 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;
@@ -24015,7 +24708,8 @@ const containsStatefulDescendant = (jsxElement, options = {}) => {
 		budget -= 1;
 		const node = stack.pop();
 		if (isNodeOfType(node, "JSXElement")) {
-			const name = node.openingElement.name;
+			const opening = node.openingElement;
+			const name = opening.name;
 			if (name && isNodeOfType(name, "JSXIdentifier")) {
 				const tagName = name.name;
 				const firstChar = tagName.charCodeAt(0);
@@ -24023,6 +24717,7 @@ 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;
@@ -24116,6 +24811,7 @@ const ARITHMETIC_KEY_OPERATORS = new Set([
 	"/",
 	"%"
 ]);
+const bindingMutationResultsByProgram = /* @__PURE__ */ new WeakMap();
 const extractCandidateIdentifiers = (expression) => {
 	const node = stripParenExpression(expression);
 	if (isNodeOfType(node, "Identifier")) return [node];
@@ -24156,6 +24852,13 @@ const isArrayFromCall = (node) => {
 const isBindingReassignedOrMutated = (referenceNode, bindingName) => {
 	const programRoot = findProgramRoot(referenceNode);
 	if (!programRoot) return false;
+	let mutationResultsByBindingName = bindingMutationResultsByProgram.get(programRoot);
+	if (!mutationResultsByBindingName) {
+		mutationResultsByBindingName = /* @__PURE__ */ new Map();
+		bindingMutationResultsByProgram.set(programRoot, mutationResultsByBindingName);
+	}
+	const cachedResult = mutationResultsByBindingName.get(bindingName);
+	if (cachedResult !== void 0) return cachedResult;
 	let didFindWrite = false;
 	walkAst(programRoot, (child) => {
 		if (didFindWrite) return false;
@@ -24172,6 +24875,7 @@ const isBindingReassignedOrMutated = (referenceNode, bindingName) => {
 			return false;
 		}
 	});
+	mutationResultsByBindingName.set(bindingName, didFindWrite);
 	return didFindWrite;
 };
 /**
@@ -24573,6 +25277,14 @@ 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) => {
@@ -24709,9 +25421,11 @@ 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: INLINE_TEXT_LEAF_TAGS.has(elementName.name) ? itemNames : EMPTY_NAME_SET,
-							bareIdentifierNames: derivedNames
+							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET,
+							bareIdentifierNames: primitiveItemNames.size > 0 ? new Set([...derivedNames, ...primitiveItemNames]) : derivedNames
 						})) return;
 					}
 				}
@@ -24879,7 +25593,11 @@ const noAsyncEffectCallback = defineRule({
 	severity: "warn",
 	recommendation: "Don't make the effect callback `async`. Define an async function inside the effect and call it, then return a real cleanup function if you need one.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
+		if (!isReactApiCall(node, EFFECT_HOOK_NAMES$1, context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveNamedAliases: true
+		})) return;
 		const callback = getEffectCallback(node);
 		if (!callback) return;
 		if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
@@ -25272,10 +25990,10 @@ const declaresAnyDependency = (manifest) => DEPENDENCY_SECTION_NAMES.some((secti
 	const section = manifest[sectionName];
 	return typeof section === "object" && section !== null && Object.keys(section).length > 0;
 });
-const declaresDependency = (manifest, dependencyName) => {
-	for (const declaredName of iterateDependencyNames(manifest)) if (declaredName === dependencyName) return true;
-	return false;
-};
+const declaresDependency = (manifest, dependencyName) => DEPENDENCY_SECTION_NAMES.some((sectionName) => {
+	const section = manifest[sectionName];
+	return typeof section === "object" && section !== null && Object.prototype.propertyIsEnumerable.call(section, dependencyName);
+});
 const cachedPlatformByManifest = /* @__PURE__ */ new WeakMap();
 const classifyPackagePlatform = (filename) => {
 	const manifest = readNearestPackageManifest(filename);
@@ -25503,6 +26221,56 @@ const noBarrelImport = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/function-returns-matching-expression.ts
+const collectReturnedExpressions = (functionNode) => {
+	if (!isFunctionLike$1(functionNode)) return [];
+	const body = functionNode.body;
+	if (!body) return [];
+	if (!isNodeOfType(body, "BlockStatement")) return [body];
+	const returnedExpressions = [];
+	walkAst(body, (node) => {
+		if (node !== body && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (isNodeOfType(node, "ReturnStatement") && node.argument) returnedExpressions.push(node.argument);
+	});
+	return returnedExpressions;
+};
+const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpression) => {
+	const visitedExpressions = /* @__PURE__ */ new Set();
+	const visitedFunctions = /* @__PURE__ */ new Set();
+	const functionMatches = (candidateFunction) => {
+		if (visitedFunctions.has(candidateFunction)) return false;
+		visitedFunctions.add(candidateFunction);
+		return collectReturnedExpressions(candidateFunction).some(expressionMatches);
+	};
+	const expressionMatches = (expression) => {
+		const unwrappedExpression = stripParenExpression(expression);
+		if (visitedExpressions.has(unwrappedExpression)) return false;
+		visitedExpressions.add(unwrappedExpression);
+		if (matchesExpression(unwrappedExpression)) return true;
+		if (isNodeOfType(unwrappedExpression, "Identifier")) {
+			const symbol = scopes.symbolFor(unwrappedExpression);
+			if (!symbol || symbol.kind !== "const" || !symbol.initializer) return false;
+			const initializer = stripParenExpression(symbol.initializer);
+			if (isFunctionLike$1(initializer)) return false;
+			return expressionMatches(initializer);
+		}
+		if (isNodeOfType(unwrappedExpression, "CallExpression")) {
+			if (unwrappedExpression.arguments.length !== 0) return false;
+			if (!isNodeOfType(unwrappedExpression.callee, "Identifier")) return false;
+			const symbol = scopes.symbolFor(unwrappedExpression.callee);
+			if (!symbol || symbol.kind !== "const" && symbol.kind !== "function") return false;
+			const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
+			const candidateFunction = isFunctionLike$1(initializer) ? initializer : isFunctionLike$1(symbol.declarationNode) ? symbol.declarationNode : null;
+			if (!candidateFunction || candidateFunction.async || candidateFunction.generator || candidateFunction.params.length !== 0) return false;
+			return functionMatches(candidateFunction);
+		}
+		if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) return expressionMatches(unwrappedExpression.consequent) || expressionMatches(unwrappedExpression.alternate);
+		if (isNodeOfType(unwrappedExpression, "LogicalExpression")) return expressionMatches(unwrappedExpression.left) || expressionMatches(unwrappedExpression.right);
+		return false;
+	};
+	return functionMatches(functionNode);
+};
+//#endregion
 //#region src/plugin/utils/function-contains-react-render-output.ts
 const NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES = new Set([
 	"FunctionDeclaration",
@@ -25522,25 +26290,24 @@ const isCallArgumentFunctionExpression = (node) => {
 	return parent.arguments.some((argumentNode) => argumentNode === node);
 };
 const isNestedRenderEvidenceBoundary = (node) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isCallArgumentFunctionExpression(node);
-const containsRenderOutput$1 = (node, rootNode, scopes) => {
-	if (node !== rootNode && isNestedRenderEvidenceBoundary(node)) return false;
-	if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
-	if (isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS)) return true;
-	const nodeRecord = node;
-	for (const key of Object.keys(nodeRecord)) {
-		if (key === "parent") continue;
-		const child = nodeRecord[key];
-		if (Array.isArray(child)) {
-			for (const innerChild of child) if (isAstNode(innerChild) && containsRenderOutput$1(innerChild, rootNode, scopes)) return true;
-		} else if (isAstNode(child) && containsRenderOutput$1(child, rootNode, scopes)) return true;
-	}
-	return false;
+const isRenderOutputExpression = (node, scopes) => node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS);
+const containsRenderOutput$1 = (rootNode, scopes) => {
+	let hasRenderOutput = false;
+	walkAst(rootNode, (node) => {
+		if (hasRenderOutput) return false;
+		if (node !== rootNode && isNestedRenderEvidenceBoundary(node)) return false;
+		if (isRenderOutputExpression(node, scopes)) {
+			hasRenderOutput = true;
+			return false;
+		}
+	});
+	return hasRenderOutput;
 };
 const renderOutputCache = /* @__PURE__ */ new WeakMap();
 const functionContainsReactRenderOutput = (functionNode, scopes) => {
 	const cachedEntry = renderOutputCache.get(functionNode);
 	if (cachedEntry && cachedEntry.scopes === scopes) return cachedEntry.hasRenderOutput;
-	const hasRenderOutput = containsRenderOutput$1(functionNode, functionNode, scopes);
+	const hasRenderOutput = containsRenderOutput$1(functionNode, scopes) || functionReturnsMatchingExpression(functionNode, scopes, (expression) => isRenderOutputExpression(expression, scopes));
 	renderOutputCache.set(functionNode, {
 		scopes,
 		hasRenderOutput
@@ -25548,6 +26315,9 @@ const functionContainsReactRenderOutput = (functionNode, scopes) => {
 	return hasRenderOutput;
 };
 //#endregion
+//#region src/plugin/utils/is-component-assignment.ts
+const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
+//#endregion
 //#region src/plugin/utils/is-component-declaration.ts
 const isComponentDeclaration = (node) => isNodeOfType(node, "FunctionDeclaration") && node.id !== null && Boolean(node.id?.name) && isUppercaseName(node.id.name);
 //#endregion
@@ -26079,6 +26849,19 @@ const noCloneElement = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/get-call-method-name.ts
+/**
+* Returns the static method name of a call's callee when it's a
+* non-computed MemberExpression (`obj.method` → `"method"`), or
+* `null` otherwise. Used by `no-pass-data-to-parent` and
+* `no-pass-live-state-to-parent` to match the receiver-bound
+* method-call shape against an allow/block list.
+*/
+const getCallMethodName = (callee) => {
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-create-context-in-render.ts
 const MESSAGE$31 = "createContext() builds a new context every render, so every consumer gets cut off & resets.";
 const CONTEXT_MODULES = [
@@ -26086,23 +26869,35 @@ const CONTEXT_MODULES = [
 	"use-context-selector",
 	"react-tracked"
 ];
-const isCreateContextCallee = (callee) => {
+const getSupportedContextImportSource = (symbol) => {
+	if (symbol?.kind !== "import") return null;
+	const importDeclaration = symbol.declarationNode.parent;
+	if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration") || typeof importDeclaration.source.value !== "string" || !CONTEXT_MODULES.includes(importDeclaration.source.value)) return null;
+	return importDeclaration.source.value;
+};
+const isSupportedNamespaceSymbol = (symbol) => getSupportedContextImportSource(symbol) !== null && Boolean(symbol && (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")));
+const isDestructuredCreateContextBinding = (identifier, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const symbol = scopes.symbolFor(identifier);
+	if (symbol?.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "ObjectPattern")) return false;
+	const property = symbol.bindingIdentifier.parent;
+	if (!property || !isNodeOfType(property, "Property") || getStaticPropertyKeyName(property, { allowComputedString: true }) !== "createContext") return false;
+	const initializer = stripParenExpression(symbol.initializer);
+	return isNodeOfType(initializer, "Identifier") && isSupportedNamespaceSymbol(resolveConstIdentifierAlias(initializer, scopes));
+};
+const isCreateContextCall = (node, scopes) => {
+	const callee = stripParenExpression(node.callee);
 	if (isNodeOfType(callee, "Identifier")) {
-		const binding = getImportBindingForName(callee, callee.name);
-		return binding !== null && binding.exportedName === "createContext" && CONTEXT_MODULES.includes(binding.source);
+		if (isDestructuredCreateContextBinding(callee, scopes)) return true;
+		const symbol = resolveConstIdentifierAlias(callee, scopes);
+		return getSupportedContextImportSource(symbol) !== null && Boolean(symbol && getImportedName(symbol.declarationNode) === "createContext");
 	}
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
-		const namespaceIdentifier = callee.object;
-		const propertyIdentifier = callee.property;
-		if (!isNodeOfType(namespaceIdentifier, "Identifier")) return false;
-		if (!isNodeOfType(propertyIdentifier, "Identifier")) return false;
-		if (propertyIdentifier.name !== "createContext") return false;
-		const namespaceName = namespaceIdentifier.name;
-		if (isCanonicalReactNamespaceName(namespaceName)) return true;
-		const importSource = getImportSourceForName(namespaceIdentifier, namespaceName);
-		return importSource !== null && CONTEXT_MODULES.includes(importSource);
-	}
-	return false;
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	if ((getCallMethodName(callee) ?? (callee.computed && isNodeOfType(callee.property, "Literal") && typeof callee.property.value === "string" ? callee.property.value : null)) !== "createContext") return false;
+	const receiver = stripParenExpression(callee.object);
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	if (receiver.name === "React" && scopes.isGlobalReference(receiver)) return true;
+	return isSupportedNamespaceSymbol(resolveConstIdentifierAlias(receiver, scopes));
 };
 const noCreateContextInRender = defineRule({
 	id: "no-create-context-in-render",
@@ -26111,7 +26906,7 @@ const noCreateContextInRender = defineRule({
 	category: "Correctness",
 	recommendation: "Move `createContext(...)` outside the component, to the top level of the file, so it stays the same on every render.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isCreateContextCallee(node.callee)) return;
+		if (!isCreateContextCall(node, context.scopes)) return;
 		const componentOrHookName = enclosingComponentOrHookName(node);
 		if (!componentOrHookName) return;
 		context.report({
@@ -27346,7 +28141,7 @@ const isSetStateCallInLifecycle = (setStateCall, lifecycleNames, options = {}) =
 	let ancestor = setStateCall.parent;
 	while (ancestor) {
 		if (!lifecycleMember) {
-			if (FUNCTION_NODE_TYPES$1.has(ancestor.type)) nestedFunctionCount += 1;
+			if (FUNCTION_NODE_TYPES$1.has(ancestor.type) && (!isImmediatelyInvokedFunction(ancestor) || !("async" in ancestor) || ancestor.async === true)) nestedFunctionCount += 1;
 			if (isLifecycleMember(ancestor, lifecycleNames)) lifecycleMember = ancestor;
 		} else if (isEs5Component(ancestor) || isEs6Component(ancestor)) {
 			if (nestedFunctionCount > 1 && !options.disallowInNestedFunctions) return false;
@@ -27548,7 +28343,7 @@ const collectDiffSourceLocalNames = (lifecycleFunction, paramNames) => {
 	const body = lifecycleFunction.body;
 	if (!body) return derivedNames;
 	walkAst(body, (node) => {
-		if (FUNCTION_NODE_TYPES.has(node.type)) return false;
+		if (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node)) return false;
 		if (!isNodeOfType(node, "VariableDeclarator")) return;
 		const init = node.init;
 		if (!init) return;
@@ -27558,6 +28353,67 @@ const collectDiffSourceLocalNames = (lifecycleFunction, paramNames) => {
 	return derivedNames;
 };
 const isStatefulOperand = (node, paramNames, derivedNames) => referencesAnyName(node, paramNames) || referencesAnyName(node, derivedNames) || containsThisStateOrProps(node);
+const getStaticMemberName = (node) => {
+	if (!isNodeOfType(node, "MemberExpression") || node.computed === true) return null;
+	return isNodeOfType(node.property, "Identifier") ? node.property.name : null;
+};
+const getThisStateFieldName = (node) => {
+	const unwrappedNode = stripParenExpression(node);
+	if (!isNodeOfType(unwrappedNode, "MemberExpression")) return null;
+	const object = stripParenExpression(unwrappedNode.object);
+	if (!isNodeOfType(object, "MemberExpression") || !isNodeOfType(stripParenExpression(object.object), "ThisExpression") || getStaticMemberName(object) !== "state") return null;
+	return getStaticMemberName(unwrappedNode);
+};
+const collectLocalInitializers = (lifecycleFunction) => {
+	const initializers = /* @__PURE__ */ new Map();
+	const body = lifecycleFunction.body;
+	if (!body) return initializers;
+	walkAst(body, (node) => {
+		if (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node)) return false;
+		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.init) initializers.set(node.id.name, node.init);
+	});
+	return initializers;
+};
+const derivesFromPostMountValue = (node, localInitializers, visitedNames = /* @__PURE__ */ new Set()) => {
+	if (readsPostMountValue(node)) return true;
+	const referencedNames = /* @__PURE__ */ new Set();
+	collectReferenceIdentifierNames(node, referencedNames);
+	for (const referencedName of referencedNames) {
+		if (visitedNames.has(referencedName)) continue;
+		const initializer = localInitializers.get(referencedName);
+		if (!initializer) continue;
+		if (derivesFromPostMountValue(initializer, localInitializers, new Set([...visitedNames, referencedName]))) return true;
+	}
+	return false;
+};
+const getSetStateFieldValue = (setStateCall, fieldName) => {
+	if (!isNodeOfType(setStateCall, "CallExpression")) return null;
+	const argument = setStateCall.arguments?.[0];
+	if (!argument || !isNodeOfType(argument, "ObjectExpression")) return null;
+	for (const property of argument.properties ?? []) {
+		if (!isNodeOfType(property, "Property") || property.computed === true) continue;
+		if ((isNodeOfType(property.key, "Identifier") && property.key.name || isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" && property.key.value || null) === fieldName) return property.value;
+	}
+	return null;
+};
+const isConvergentPostMountGuard = (test, setStateCall, localInitializers) => {
+	let qualifies = false;
+	walkAst(test, (node) => {
+		if (qualifies) return false;
+		if (!isNodeOfType(node, "BinaryExpression") || !EQUALITY_OPERATORS.has(node.operator)) return;
+		const leftFieldName = getThisStateFieldName(node.left);
+		const rightFieldName = getThisStateFieldName(node.right);
+		const fieldName = leftFieldName ?? rightFieldName;
+		const comparedValue = leftFieldName ? node.right : node.left;
+		if (!fieldName || !leftFieldName && !rightFieldName) return;
+		const assignedValue = getSetStateFieldValue(setStateCall, fieldName);
+		if (!assignedValue || !areExpressionsStructurallyEqual(comparedValue, assignedValue)) return;
+		if (!derivesFromPostMountValue(comparedValue, localInitializers)) return;
+		qualifies = true;
+		return false;
+	});
+	return qualifies;
+};
 const isDiffGuardTest = (test, paramNames, derivedNames) => {
 	if (referencesAnyName(test, paramNames)) return true;
 	let qualifies = false;
@@ -27565,7 +28421,7 @@ const isDiffGuardTest = (test, paramNames, derivedNames) => {
 		if (qualifies) return false;
 		if (!isNodeOfType(node, "BinaryExpression")) return;
 		if (!EQUALITY_OPERATORS.has(node.operator)) return;
-		if (isStatefulOperand(node.left, paramNames, derivedNames) && isStatefulOperand(node.right, paramNames, derivedNames)) {
+		if (isStatefulOperand(node.left, paramNames, derivedNames) && isStatefulOperand(node.right, paramNames, derivedNames) && (referencesAnyName(node.left, derivedNames) || referencesAnyName(node.right, derivedNames))) {
 			qualifies = true;
 			return false;
 		}
@@ -27578,11 +28434,12 @@ const isInsideDiffGuard = (setStateCall) => {
 	const paramNames = /* @__PURE__ */ new Set();
 	for (const param of lifecycleFunction.params ?? []) collectPatternNames(param, paramNames);
 	const derivedNames = collectDiffSourceLocalNames(lifecycleFunction, paramNames);
+	const localInitializers = collectLocalInitializers(lifecycleFunction);
 	let child = setStateCall;
 	let ancestor = setStateCall.parent;
 	while (ancestor && ancestor !== lifecycleFunction) {
 		const guardTest = isNodeOfType(ancestor, "IfStatement") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "ConditionalExpression") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "LogicalExpression") && ancestor.operator === "&&" && child === ancestor.right && ancestor.left || null;
-		if (guardTest && isDiffGuardTest(guardTest, paramNames, derivedNames)) return true;
+		if (guardTest && (isDiffGuardTest(guardTest, paramNames, derivedNames) || isConvergentPostMountGuard(guardTest, setStateCall, localInitializers))) return true;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
 	}
@@ -27763,7 +28620,16 @@ const producesOpaqueInstanceValue = (expression) => {
 const collectSetterValueObservations = (componentBody, setterNames) => {
 	const plainFedSetterNames = /* @__PURE__ */ new Set();
 	const opaqueFedSetterNames = /* @__PURE__ */ new Set();
+	const callbackRefSetterNames = /* @__PURE__ */ new Set();
 	walkComponentRespectingShadows(componentBody, /* @__PURE__ */ new Set(), (node, currentlyShadowed) => {
+		if (isNodeOfType(node, "JSXAttribute")) {
+			const attributeName = node.name;
+			if (isNodeOfType(attributeName, "JSXIdentifier") && attributeName.name === "ref" && node.value && isNodeOfType(node.value, "JSXExpressionContainer")) {
+				const expression = stripParenExpression(node.value.expression);
+				if (isNodeOfType(expression, "Identifier") && setterNames.has(expression.name)) callbackRefSetterNames.add(expression.name);
+			}
+			return;
+		}
 		if (!isNodeOfType(node, "CallExpression")) return;
 		if (!isNodeOfType(node.callee, "Identifier")) return;
 		const setterName = node.callee.name;
@@ -27780,21 +28646,10 @@ const collectSetterValueObservations = (componentBody, setterNames) => {
 	}, true);
 	return {
 		plainFedSetterNames,
-		opaqueFedSetterNames
+		opaqueFedSetterNames,
+		callbackRefSetterNames
 	};
 };
-const collectCallbackRefSetterNames = (componentBody) => {
-	const callbackRefSetterNames = /* @__PURE__ */ new Set();
-	walkAst(componentBody, (node) => {
-		if (!isNodeOfType(node, "JSXAttribute")) return;
-		const attributeName = node.name;
-		if (isNodeOfType(attributeName, "JSXIdentifier") && attributeName.name === "ref" && node.value && isNodeOfType(node.value, "JSXExpressionContainer")) {
-			const expression = stripParenExpression(node.value.expression);
-			if (isNodeOfType(expression, "Identifier")) callbackRefSetterNames.add(expression.name);
-		}
-	});
-	return callbackRefSetterNames;
-};
 const collectFunctionLocalBindings = (functionNode) => {
 	const localBindings = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return localBindings;
@@ -27806,8 +28661,8 @@ const collectFunctionLocalBindings = (functionNode) => {
 	return localBindings;
 };
 const collectBlockScopedBindings = (node) => {
-	const blockBindings = /* @__PURE__ */ new Set();
 	if (isNodeOfType(node, "BlockStatement")) {
+		const blockBindings = /* @__PURE__ */ new Set();
 		for (const statement of node.body ?? []) {
 			if (!isNodeOfType(statement, "VariableDeclaration")) continue;
 			for (const declarator of statement.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
@@ -27815,17 +28670,22 @@ const collectBlockScopedBindings = (node) => {
 		return blockBindings;
 	}
 	if (isNodeOfType(node, "ForStatement") && isNodeOfType(node.init, "VariableDeclaration")) {
+		const blockBindings = /* @__PURE__ */ new Set();
 		for (const declarator of node.init.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
 		return blockBindings;
 	}
-	if ((isNodeOfType(node, "ForOfStatement") || isNodeOfType(node, "ForInStatement")) && isNodeOfType(node.left, "VariableDeclaration")) for (const declarator of node.left.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
-	return blockBindings;
+	if ((isNodeOfType(node, "ForOfStatement") || isNodeOfType(node, "ForInStatement")) && isNodeOfType(node.left, "VariableDeclaration")) {
+		const blockBindings = /* @__PURE__ */ new Set();
+		for (const declarator of node.left.declarations ?? []) collectPatternNames(declarator.id, blockBindings);
+		return blockBindings;
+	}
+	return null;
 };
 const walkComponentRespectingShadows = (node, shadowedStateNames, visit, isComponentBodyRoot = false) => {
 	if (!node || typeof node !== "object") return;
 	let nextShadowedStateNames = shadowedStateNames;
-	const localBindings = isComponentBodyRoot ? /* @__PURE__ */ new Set() : isFunctionLike$1(node) ? collectFunctionLocalBindings(node) : collectBlockScopedBindings(node);
-	if (localBindings.size > 0) {
+	const localBindings = isComponentBodyRoot ? null : isFunctionLike$1(node) ? collectFunctionLocalBindings(node) : collectBlockScopedBindings(node);
+	if (localBindings && localBindings.size > 0) {
 		const merged = new Set(shadowedStateNames);
 		for (const localName of localBindings) merged.add(localName);
 		nextShadowedStateNames = merged;
@@ -27851,11 +28711,10 @@ const noDirectStateMutation = defineRule({
 			const bindings = collectUseStateBindings(componentBody);
 			if (bindings.length === 0) return;
 			const stateValueToSetter = new Map(bindings.map((binding) => [binding.valueName, binding.setterName]));
-			const callbackRefSetterNames = collectCallbackRefSetterNames(componentBody);
 			const setterValueObservations = collectSetterValueObservations(componentBody, new Set(bindings.map((binding) => binding.setterName)));
 			const plainObjectStateValueNames = /* @__PURE__ */ new Set();
 			for (const binding of bindings) {
-				if (callbackRefSetterNames.has(binding.setterName)) continue;
+				if (setterValueObservations.callbackRefSetterNames.has(binding.setterName)) continue;
 				if (!isNodeOfType(binding.declarator.init, "CallExpression")) continue;
 				const initializerArgument = binding.declarator.init.arguments?.[0];
 				if (!initializerMarksPlainState(initializerArgument)) continue;
@@ -27916,7 +28775,7 @@ const noDisabledZoom = defineRule({
 	category: "Accessibility",
 	recommendation: "Remove `user-scalable=no` and `maximum-scale` from the viewport meta tag. If the layout breaks at 200% zoom, fix the layout instead.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "meta") return;
+		if (resolveJsxElementType(node) !== "meta") return;
 		const nameAttr = findJsxAttribute(node.attributes ?? [], "name");
 		if (!nameAttr?.value) return;
 		if ((isNodeOfType(nameAttr.value, "Literal") ? nameAttr.value.value : null) !== "viewport") return;
@@ -27997,20 +28856,31 @@ const noDocumentStartViewTransition = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/get-static-property-name.ts
+const getStaticPropertyName = (memberExpression) => {
+	const property = memberExpression.property;
+	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
+	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
+	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
+	return null;
+};
+//#endregion
 //#region src/plugin/rules/js-performance/no-document-write.ts
 const MESSAGE$24 = "`document.write()` blocks parsing, is ignored (or wipes the page) after load, and is flagged by browsers as a performance anti-pattern. Build DOM nodes or set `innerHTML`/`textContent` on a target element instead.";
 const WRITE_METHODS = new Set(["write", "writeln"]);
+const isGlobalDocumentReference = (node, context) => node.name === "document" && context.scopes.isGlobalReference(node);
 const noDocumentWrite = defineRule({
 	id: "no-document-write",
 	title: "document.write/writeln",
 	severity: "warn",
 	recommendation: "Don't use `document.write()`/`document.writeln()`. Append DOM nodes or set `innerHTML`/`textContent` on a specific element instead.",
 	create: (context) => ({ CallExpression(node) {
-		const callee = node.callee;
-		if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return;
+		const callee = stripParenExpression(node.callee);
+		if (!isNodeOfType(callee, "MemberExpression")) return;
 		const receiver = stripParenExpression(callee.object);
-		if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "document") return;
-		if (!isNodeOfType(callee.property, "Identifier") || !WRITE_METHODS.has(callee.property.name)) return;
+		if (!isNodeOfType(receiver, "Identifier") || !isGlobalDocumentReference(receiver, context)) return;
+		const methodName = getStaticPropertyName(callee);
+		if (methodName === null || !WRITE_METHODS.has(methodName)) return;
 		context.report({
 			node,
 			message: MESSAGE$24
@@ -28295,7 +29165,7 @@ const findTopLevelEffectCalls = (componentBody) => {
 	if (!isNodeOfType(componentBody, "BlockStatement")) return effectCalls;
 	for (const statement of componentBody.body ?? []) {
 		if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-		const expression = statement.expression;
+		const expression = unwrapDiscardedExpression(statement);
 		if (!isNodeOfType(expression, "CallExpression")) continue;
 		if (!isHookCall$2(expression, EFFECT_HOOK_NAMES$1)) continue;
 		effectCalls.push(expression);
@@ -28817,6 +29687,14 @@ const noEffectWithFreshDeps = defineRule({
 //#endregion
 //#region src/plugin/rules/security/no-eval.ts
 const SANDBOX_SURFACE_PATH_PATTERN = /(?:^|[/-])sandbox(?:$|[/-])|(?:^|\/)[\w.]+-sandbox(?:\/|\.[cm]?[jt]sx?$)/i;
+const getExecutableGlobalName = (node, context) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "Identifier")) return context.scopes.isGlobalReference(expression) ? expression.name : null;
+	if (!isNodeOfType(expression, "MemberExpression")) return null;
+	const receiver = stripParenExpression(expression.object);
+	if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "globalThis" || !context.scopes.isGlobalReference(receiver)) return null;
+	return getStaticPropertyName(expression);
+};
 const noEval = defineRule({
 	id: "no-eval",
 	title: "eval() runs untrusted code strings",
@@ -28826,20 +29704,21 @@ const noEval = defineRule({
 		if (SANDBOX_SURFACE_PATH_PATTERN.test(normalizeFilename(context.filename ?? ""))) return {};
 		return {
 			CallExpression(node) {
-				if (isNodeOfType(node.callee, "Identifier") && node.callee.name === "eval") {
+				const executableGlobalName = getExecutableGlobalName(node.callee, context);
+				if (executableGlobalName === "eval") {
 					context.report({
 						node,
 						message: "eval() is a code-injection vulnerability: it runs any string as code."
 					});
 					return;
 				}
-				if (isNodeOfType(node.callee, "Identifier") && (node.callee.name === "setTimeout" || node.callee.name === "setInterval") && isNodeOfType(node.arguments?.[0], "Literal") && typeof node.arguments[0].value === "string") context.report({
+				if ((executableGlobalName === "setTimeout" || executableGlobalName === "setInterval") && isNodeOfType(node.arguments?.[0], "Literal") && typeof node.arguments[0].value === "string") context.report({
 					node,
-					message: `Passing a string to ${node.callee.name}() is a code-injection vulnerability, since it runs that string as code.`
+					message: `Passing a string to ${executableGlobalName}() is a code-injection vulnerability, since it runs that string as code.`
 				});
 			},
 			NewExpression(node) {
-				if (isNodeOfType(node.callee, "Identifier") && node.callee.name === "Function") {
+				if (getExecutableGlobalName(node.callee, context) === "Function") {
 					const onlyArgument = node.arguments.length === 1 ? node.arguments[0] : void 0;
 					if (isNodeOfType(onlyArgument, "Literal") && typeof onlyArgument.value === "string" && onlyArgument.value.trim() === "return this") return;
 					context.report({
@@ -30098,7 +30977,11 @@ const noFetchInEffect = defineRule({
 	severity: "warn",
 	recommendation: "Use a data-fetching layer or Server Component so fetches do not race, double-fire, or leak from `useEffect`.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
+		if (!isReactApiCall(node, EFFECT_HOOK_NAMES$1, context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveNamedAliases: true
+		})) return;
 		const callback = getEffectCallback(node);
 		if (!callback) return;
 		const analysisFunctions = collectEffectAnalysisFunctions(callback, context);
@@ -31064,7 +31947,7 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	severity: "warn",
 	recommendation: "Don't combine `loading=\"lazy\"` with `fetchPriority=\"high\"`. A high-priority image (usually the LCP) should load eagerly; a lazy image is by definition not high priority.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "img") return;
+		if (resolveJsxElementType(node) !== "img") return;
 		const loadingAttribute = hasJsxPropIgnoreCase(node.attributes, "loading");
 		if (!loadingAttribute || getJsxPropStringValue(loadingAttribute)?.toLowerCase() !== "lazy") return;
 		const fetchPriorityAttribute = hasJsxPropIgnoreCase(node.attributes, "fetchPriority");
@@ -31305,7 +32188,7 @@ const noIndeterminateAttribute = defineRule({
 		if (classifyReactNativeFileTarget(context) === "react-native") return {};
 		return {
 			JSXOpeningElement(node) {
-				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "input") return;
+				if (resolveJsxElementType(node) !== "input") return;
 				let typeAttribute = null;
 				let typeAttributeIndex = null;
 				let indeterminateAttribute = null;
@@ -31484,11 +32367,12 @@ const isMemoCall = (node) => {
 };
 const isDefaultEquivalentComparator = (comparator) => isNodeOfType(comparator, "Identifier") && (comparator.name === "undefined" || comparator.name === "shallowEqual");
 const hasCustomComparator = (node) => isNodeOfType(node, "CallExpression") && (node.arguments?.length ?? 0) >= 2 && !isDefaultEquivalentComparator(node.arguments?.[1]);
-const isInlineReference = (node) => {
-	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "bind") return "functions";
-	if (isNodeOfType(node, "ObjectExpression")) return "objects";
-	if (isNodeOfType(node, "ArrayExpression")) return "Arrays";
-	if (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")) return "JSX";
+const isInlineReference = (node, scopes) => {
+	const referenceNode = unwrapObjectIntegrityExpression(node, scopes);
+	if (isNodeOfType(referenceNode, "ArrowFunctionExpression") || isNodeOfType(referenceNode, "FunctionExpression") || isNodeOfType(referenceNode, "CallExpression") && isNodeOfType(referenceNode.callee, "MemberExpression") && isNodeOfType(referenceNode.callee.property, "Identifier") && referenceNode.callee.property.name === "bind") return "functions";
+	if (isNodeOfType(referenceNode, "ObjectExpression")) return "objects";
+	if (isNodeOfType(referenceNode, "ArrayExpression")) return "Arrays";
+	if (isNodeOfType(referenceNode, "JSXElement") || isNodeOfType(referenceNode, "JSXFragment")) return "JSX";
 	return null;
 };
 const noInlinePropOnMemoComponent = defineRule({
@@ -31518,7 +32402,7 @@ const noInlinePropOnMemoComponent = defineRule({
 				let elementName = null;
 				if (isNodeOfType(openingElement.name, "JSXIdentifier")) elementName = openingElement.name.name;
 				if (!elementName || !memoizedComponentNames.has(elementName)) return;
-				const propType = isInlineReference(node.value.expression);
+				const propType = isInlineReference(node.value.expression, context.scopes);
 				if (propType) context.report({
 					node: node.value.expression,
 					message: `This redraws ${elementName} on every render because the prop is ${propType} built right here, so memo() can't skip it. Move it to a stable value with useMemo, useCallback, or module scope`
@@ -32377,11 +33261,13 @@ const noManyBooleanProps = defineRule({
 		};
 		const checkComponent = (functionNode, param, body, componentName, reportNode) => {
 			if (!param) return;
+			const propsBinding = resolveFirstArgumentBinding(param);
+			if (!propsBinding) return;
 			if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
-			if (isNodeOfType(param, "ObjectPattern")) {
+			if (isNodeOfType(propsBinding, "ObjectPattern")) {
 				const callbackUsedNames = collectCallbackUsedNames(body, param, context.scopes);
 				const booleanLikePropNames = [];
-				for (const property of param.properties ?? []) {
+				for (const property of propsBinding.properties ?? []) {
 					if (!isNodeOfType(property, "Property")) continue;
 					const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : null;
 					if (!keyName) continue;
@@ -32392,7 +33278,7 @@ const noManyBooleanProps = defineRule({
 				reportIfMany(booleanLikePropNames, componentName, reportNode);
 				return;
 			}
-			if (isNodeOfType(param, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, param.name)], componentName, reportNode);
+			if (isNodeOfType(propsBinding, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, propsBinding.name)], componentName, reportNode);
 		};
 		return {
 			FunctionDeclaration(node) {
@@ -32514,7 +33400,7 @@ const noMirrorPropEffect = defineRule({
 			if (mirrorBindings.length === 0) return;
 			for (const statement of componentBody.body ?? []) {
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-				const effectCall = statement.expression;
+				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
@@ -32528,7 +33414,7 @@ const noMirrorPropEffect = defineRule({
 				const bodyStatements = getCallbackStatements(callback);
 				if (bodyStatements.length !== 1) continue;
 				const onlyStatement = bodyStatements[0];
-				const expression = isNodeOfType(onlyStatement, "ExpressionStatement") ? onlyStatement.expression : onlyStatement;
+				const expression = unwrapDiscardedExpression(onlyStatement);
 				if (!isNodeOfType(expression, "CallExpression")) continue;
 				if (!isNodeOfType(expression.callee, "Identifier")) continue;
 				if (!isSetterIdentifier(expression.callee.name)) continue;
@@ -32573,25 +33459,60 @@ const resolveSettings$16 = (settings) => {
 };
 const isHocCall = (call, scopes) => {
 	if (!isNodeOfType(call, "CallExpression")) return false;
-	const calleeName = flattenCalleeName(call.callee);
-	if (calleeName && REACT_HOC_NAMES.has(calleeName)) return true;
+	if (isReactApiCall(call, REACT_HOC_NAMES, scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: true
+	})) return true;
+	if (isReactHocMemberReference(call.callee, scopes)) return true;
 	if (!isNodeOfType(call.callee, "Identifier")) return false;
 	const symbol = scopes.symbolFor(call.callee);
 	if (!symbol) return false;
-	return symbolMapsToHoc(symbol);
+	return symbolMapsToHoc(symbol, scopes, /* @__PURE__ */ new Set());
+};
+const isReactImportEquals = (symbol) => {
+	if (symbol.kind !== "ts-import-equals" || !isNodeOfType(symbol.declarationNode, "TSImportEqualsDeclaration")) return false;
+	const moduleReference = symbol.declarationNode.moduleReference;
+	return Boolean(isNodeOfType(moduleReference, "TSExternalModuleReference") && isNodeOfType(moduleReference.expression, "Literal") && typeof moduleReference.expression.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(moduleReference.expression.value));
 };
-const symbolMapsToHoc = (symbol) => {
-	if (REACT_HOC_NAMES.has(symbol.name)) {
-		if (symbol.kind === "import") return true;
+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 init = symbol.initializer;
 	if (!init) return false;
-	if (isNodeOfType(init, "MemberExpression")) {
-		const flat = flattenCalleeName(init);
-		if (flat && REACT_HOC_NAMES.has(flat)) return true;
+	const destructuredPropertyName = getDestructuredPropertyName$1(symbol);
+	if (destructuredPropertyName && REACT_HOC_NAMES.has(destructuredPropertyName) && isReactNamespaceExpression(init, scopes)) return true;
+	if (isReactHocMemberReference(init, scopes)) return true;
+	if (isNodeOfType(init, "Identifier")) {
+		const initializedFromSymbol = scopes.symbolFor(init);
+		if (initializedFromSymbol) return symbolMapsToHoc(initializedFromSymbol, scopes, visitedSymbolIds);
+		return REACT_HOC_NAMES.has(init.name) && scopes.isGlobalReference(init);
 	}
-	if (isNodeOfType(init, "Identifier") && REACT_HOC_NAMES.has(init.name)) return true;
-	if (REACT_HOC_NAMES.has(symbol.name) && isNodeOfType(init, "Identifier") && init.name === "React") return true;
 	return false;
 };
 const isTrivialPassthroughChild = (child) => {
@@ -32649,26 +33570,14 @@ const isHocComponent = (call, scopes) => {
 };
 const containsJsx = (root) => {
 	let found = false;
-	const visit = (node) => {
-		if (found) return;
+	walkAst(root, (node) => {
+		if (found) return false;
 		if (node.type === "JSXElement" || node.type === "JSXFragment") {
 			found = true;
-			return;
-		}
-		if (node !== root) {
-			if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ClassDeclaration" || node.type === "ClassExpression") return;
-		}
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-			if (found) return;
+			return false;
 		}
-	};
-	visit(root);
+		if (node !== root && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ClassDeclaration" || node.type === "ClassExpression")) return false;
+	});
 	return found;
 };
 const expressionContainsJsx = (expression) => {
@@ -32692,7 +33601,7 @@ const unwrapTsCast = (expression) => {
 	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression") current = stripParenExpression(current.expression);
 	return current;
 };
-const collectReExportedNames = (program) => {
+const collectReExportedNames = (program, scopes) => {
 	const names = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(program, "Program")) return names;
 	for (const statement of program.body) {
@@ -32716,8 +33625,7 @@ const collectReExportedNames = (program) => {
 			if (!declarator.init) continue;
 			const init = unwrapTsCast(declarator.init);
 			if (isNodeOfType(init, "CallExpression")) {
-				const calleeName = flattenCalleeName(init.callee);
-				if (calleeName && REACT_HOC_NAMES.has(calleeName)) {
+				if (isHocCall(init, scopes)) {
 					const wrappedArg = init.arguments[0];
 					if (wrappedArg && isNodeOfType(wrappedArg, "Identifier")) names.add(wrappedArg.name);
 				}
@@ -32786,16 +33694,7 @@ const recordComponent = (context, name, reportNode, isStateless) => {
 		isStateless
 	});
 };
-const walkChildren = (node, context) => {
-	const record = node;
-	for (const key of Object.keys(record)) {
-		if (key === "parent") continue;
-		const child = record[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (isAstNode(item)) walkComponentSearch(item, context);
-		} else if (isAstNode(child)) walkComponentSearch(child, context);
-	}
-};
+const walkChildren = (node, context) => forEachChildNode(node, context.visitChild);
 const walkComponentSearch = (node, context) => {
 	if (isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression")) {
 		if (isEs6Component(node)) {
@@ -32897,12 +33796,13 @@ const noMultiComp = defineRule({
 				components: [],
 				componentDepth: 0,
 				currentVarName: null,
-				scopes: context.scopes
+				scopes: context.scopes,
+				visitChild: (child) => walkComponentSearch(child, visitContext)
 			};
 			for (const statement of node.body) walkComponentSearch(statement, visitContext);
 			const flagged = settings.ignoreStateless ? visitContext.components.filter((component) => !component.isStateless) : visitContext.components;
 			if (flagged.length <= 2) return;
-			const reExportedNames = collectReExportedNames(node);
+			const reExportedNames = collectReExportedNames(node, context.scopes);
 			const exportedCount = flagged.filter((component) => isExportedDeclaration(component.reportNode, reExportedNames)).length;
 			if (exportedCount >= flagged.length || flagged.length >= 4 && exportedCount >= Math.floor(flagged.length * .7) || flagged.length >= 8 && exportedCount >= Math.floor(flagged.length * .5)) return;
 			const isSmallFeatureModule = exportedCount > 0 && exportedCount <= 2 && exportedCount < flagged.length;
@@ -34294,19 +35194,6 @@ const DATA_SINK_METHOD_NAMES = new Set([
 	"deserialize"
 ]);
 //#endregion
-//#region src/plugin/utils/get-call-method-name.ts
-/**
-* Returns the static method name of a call's callee when it's a
-* non-computed MemberExpression (`obj.method` → `"method"`), or
-* `null` otherwise. Used by `no-pass-data-to-parent` and
-* `no-pass-live-state-to-parent` to match the receiver-bound
-* method-call shape against an allow/block list.
-*/
-const getCallMethodName = (callee) => {
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-pass-data-to-parent.ts
 const isUseStateIdentifier = (identifier) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
@@ -34551,6 +35438,14 @@ const isHandlerBagArgument = (analysis, argument) => {
 };
 const getFunctionalUpdaterDataRefs = (analysis, updater) => getDownstreamRefs(analysis, updater).filter((updaterRef) => !updaterRef.resolved?.defs.some((def) => def.type === "Parameter" && def.node === updater));
 const HOOK_NAME_PATTERN$1 = /^use[A-Z0-9]/;
+const EXTERNAL_SUBSCRIPTION_HOOK_NAMES = new Set([
+	"useIntersectionObserver",
+	"useMatchMedia",
+	"useMediaQuery",
+	"useResizeObserver",
+	"useVisibility",
+	"useWindowSize"
+]);
 const isParentWiredHookResultRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
@@ -34573,6 +35468,19 @@ const isParentWiredHookCalleeRef = (analysis, ref) => {
 	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier) return false;
 	return (parent.arguments ?? []).some((hookArgument) => getDownstreamRefs(analysis, hookArgument).some((downstreamRef) => isProp(analysis, downstreamRef)));
 };
+const isExternalSubscriptionHookRef = (ref) => {
+	const identifier = ref.identifier;
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	if (EXTERNAL_SUBSCRIPTION_HOOK_NAMES.has(identifier.name) && isCalleePosition(identifier)) return true;
+	return Boolean(ref.resolved?.defs.some((def) => {
+		const node = def.node;
+		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
+		const initializer = stripParenExpression(node.init);
+		if (!isNodeOfType(initializer, "CallExpression")) return false;
+		const callee = stripParenExpression(initializer.callee);
+		return isNodeOfType(callee, "Identifier") && EXTERNAL_SUBSCRIPTION_HOOK_NAMES.has(callee.name);
+	}));
+};
 const isImportBindingRef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "ImportBinding"));
 const isCalleePosition = (identifier) => {
 	const parent = identifier.parent;
@@ -34634,10 +35542,11 @@ const noPassDataToParent = defineRule({
 						if (argumentRef && resolveToFunction(argumentRef)) return [];
 					}
 					return getDownstreamRefs(analysis, argument);
-				}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
+				}).flatMap((argumentRef) => isExternallyDrivenState(analysis, argumentRef) ? [] : getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
 				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
 				if (!argsUpstreamRefs.some((argRef) => {
 					if (isUseStateIdentifier(argRef.identifier)) return false;
+					if (isExternalSubscriptionHookRef(argRef)) return false;
 					if (isProp(analysis, argRef)) return false;
 					if (isUseRefIdentifier(argRef.identifier)) return false;
 					if (isRefCurrent(argRef)) return false;
@@ -34932,6 +35841,30 @@ 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",
@@ -34945,6 +35878,7 @@ 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."
@@ -35096,7 +36030,7 @@ const noPreventDefault = defineRule({
 		const isServerActionsFramework = hasCapability(context.settings, "server-actions");
 		const formMessage = isServerActionsFramework ? FORM_MESSAGE_SERVER_CAPABLE : FORM_MESSAGE_GENERIC;
 		return { JSXOpeningElement(node) {
-			const elementName = isNodeOfType(node.name, "JSXIdentifier") ? node.name.name : null;
+			const elementName = resolveJsxElementType(node);
 			if (!elementName) return;
 			const targetEventProps = PREVENT_DEFAULT_ELEMENTS.get(elementName);
 			if (!targetEventProps) return;
@@ -35162,6 +36096,27 @@ 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",
@@ -35178,11 +36133,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 stateLikeDeps = (depsNode.elements ?? []).filter((element) => isNodeOfType(element, "Identifier") && !propStackTracker.isPropName(element.name));
+				const analysis = getProgramAnalysis(node);
+				const stateLikeDeps = (depsNode.elements ?? []).filter((element) => element && isStateLikeDependency(analysis, element, propStackTracker.isPropName));
 				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) {
@@ -35194,9 +36149,9 @@ const noPropCallbackInEffect = defineRule({
 				const reportedNodes = /* @__PURE__ */ new Set();
 				walkInsideStatementBlocks(callback.body, (child) => {
 					if (!isNodeOfType(child, "CallExpression")) return;
-					if (!isNodeOfType(child.callee, "Identifier")) return;
-					const calleeName = child.callee.name;
-					if (!propStackTracker.isPropName(calleeName)) 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 (!isResultDiscardedCall(child)) return;
 					if (reportedNodes.has(child)) return;
 					reportedNodes.add(child);
@@ -36560,7 +37515,7 @@ const isNonSettlingSetterArgument = (setterCall, stateName) => {
 	return expressionReadsStateValue(argument, stateName);
 };
 const getUnconditionalSetterCall = (statement, setterNames) => {
-	const expression = stripParenExpression(isNodeOfType(statement, "ExpressionStatement") ? statement.expression : statement);
+	const expression = unwrapDiscardedExpression(statement);
 	if (!isNodeOfType(expression, "CallExpression")) return null;
 	if (!isNodeOfType(expression.callee, "Identifier")) return null;
 	if (!setterNames.has(expression.callee.name)) return null;
@@ -36909,7 +37864,7 @@ const noSelfUpdatingEffect = defineRule({
 			const setterNames = new Set(setterNameToStateName.keys());
 			for (const statement of functionBody.body ?? []) {
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-				const effectCall = statement.expression;
+				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
@@ -37539,9 +38494,10 @@ const noStringFalseOnBooleanAttribute = defineRule({
 	recommendation: "Use the boolean form on boolean attributes: `disabled` / `disabled={true}` / `disabled={false}`, not `disabled=\"false\"`. A non-empty string is truthy, so `=\"false\"` actually turns the attribute ON.",
 	create: (context) => ({ JSXOpeningElement(node) {
 		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const firstCharacter = node.name.name.charCodeAt(0);
+		const elementName = resolveJsxElementType(node);
+		const firstCharacter = elementName.charCodeAt(0);
 		if (firstCharacter < 97 || firstCharacter > 122) return;
-		if (node.name.name.includes("-")) return;
+		if (elementName.includes("-")) return;
 		for (const attribute of node.attributes) {
 			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
 			if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
@@ -37929,8 +38885,7 @@ const noUncontrolledInput = defineRule({
 			const undefinedInitialStateNames = isNodeOfType(componentBody, "BlockStatement") ? collectUndefinedInitialStateNames(componentBody) : /* @__PURE__ */ new Set();
 			walkAst(componentBody, (child) => {
 				if (!isNodeOfType(child, "JSXOpeningElement")) return;
-				if (!isNodeOfType(child.name, "JSXIdentifier")) return;
-				const tagName = child.name.name;
+				const tagName = resolveJsxElementType(child);
 				if (!UNCONTROLLED_INPUT_TAGS.has(tagName)) return;
 				const attributes = child.attributes ?? [];
 				if (hasJsxSpreadAttribute(attributes)) return;
@@ -37991,7 +38946,7 @@ const noUndeferredThirdParty = defineRule({
 	severity: "warn",
 	recommendation: "Use `next/script` with `strategy=\"lazyOnload\"`, or add the `defer` attribute.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "script") return;
+		if (resolveJsxElementType(node) !== "script") return;
 		const attributes = node.attributes ?? [];
 		const srcAttribute = findJsxAttribute(attributes, "src");
 		if (!srcAttribute) return;
@@ -39206,7 +40161,7 @@ const noUnknownProperty = defineRule({
 				}
 				if (fileIsNonReactJsx) return;
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const elementType = node.name.name;
+				const elementType = resolveJsxElementType(node);
 				const firstCharacter = elementType.charCodeAt(0);
 				if (!(firstCharacter >= 97 && firstCharacter <= 122) || elementType === "fbt" || elementType === "fbs") return;
 				let isValidHtmlTag = isKnownDomTag(elementType);
@@ -39370,50 +40325,35 @@ const resolveSettings$8 = (settings) => {
 };
 const expressionContainsJsxOrCreateElement = (root) => {
 	let found = false;
-	const visit = (node) => {
-		if (found) return;
+	walkAst(root, (node) => {
+		if (found) return false;
+		if (node !== root && NESTED_FUNCTION_TYPES.has(node.type)) return false;
 		if (node.type === "JSXElement" || node.type === "JSXFragment") {
 			found = true;
-			return;
+			return false;
 		}
 		if (isNodeOfType(node, "CallExpression") && isCreateElementCall(node)) {
 			found = true;
-			return;
-		}
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) for (const item of child) {
-				if (!isAstNode(item)) continue;
-				if (NESTED_FUNCTION_TYPES.has(item.type)) continue;
-				visit(item);
-				if (found) return;
-			}
-			else if (isAstNode(child)) {
-				if (NESTED_FUNCTION_TYPES.has(child.type)) continue;
-				visit(child);
-			}
-			if (found) return;
+			return false;
 		}
-	};
-	visit(root);
+	});
 	return found;
 };
+const functionContainsJsxOrCreateElement = (functionNode, scopes) => expressionContainsJsxOrCreateElement(functionNode) || functionReturnsMatchingExpression(functionNode, scopes, expressionContainsJsxOrCreateElement);
 const isReactClassComponent = (classNode) => {
 	if (isEs6Component(classNode)) return true;
 	return expressionContainsJsxOrCreateElement(classNode);
 };
-const findEnclosingComponent = (node) => {
+const findEnclosingComponent = (node, scopes) => {
 	let walker = node.parent;
 	while (walker) {
 		if (isFunctionLike$1(walker)) {
 			const componentName = inferFunctionLikeName(walker);
-			if (componentName && isReactComponentName(componentName) && expressionContainsJsxOrCreateElement(walker)) return {
+			if (componentName && isReactComponentName(componentName) && functionContainsJsxOrCreateElement(walker, scopes)) return {
 				component: walker,
 				name: componentName
 			};
-			if (!componentName && expressionContainsJsxOrCreateElement(walker) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
+			if (!componentName && functionContainsJsxOrCreateElement(walker, scopes) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
 				component: walker,
 				name: null
 			};
@@ -39652,7 +40592,7 @@ const noUnstableNestedComponents = defineRule({
 				if (renderPropRegex.test(propInfo.propName)) return;
 				if (settings.allowAsProps) return;
 			}
-			const enclosing = findEnclosingComponent(candidateNode);
+			const enclosing = findEnclosingComponent(candidateNode, context.scopes);
 			if (!enclosing) return;
 			const gatedName = propInfo ? null : requiredInstantiationName;
 			queuedReports.push({
@@ -39663,7 +40603,7 @@ const noUnstableNestedComponents = defineRule({
 			});
 		};
 		const checkFunctionLike = (node) => {
-			if (!expressionContainsJsxOrCreateElement(node)) return;
+			if (!functionContainsJsxOrCreateElement(node, context.scopes)) return;
 			const inferredName = inferFunctionLikeName(node);
 			const propInfo = isComponentDeclaredInProp(node);
 			const isObjectCallback = isObjectCallbackCandidate(node);
@@ -40323,19 +41263,6 @@ const classifyExport = (name, reportNode, isFunction, initializer, state) => {
 		reportNode
 	};
 };
-const collectRelevantNodes = (programRoot) => {
-	const exportNodes = [];
-	const componentCandidates = [];
-	walkAst(programRoot, (child) => {
-		const childType = child.type;
-		if (childType === "ExportAllDeclaration" || childType === "ExportDefaultDeclaration" || childType === "ExportNamedDeclaration") exportNodes.push(child);
-		else if (childType === "FunctionDeclaration" || childType === "VariableDeclarator" || childType === "ClassDeclaration") componentCandidates.push(child);
-	});
-	return {
-		exportNodes,
-		componentCandidates
-	};
-};
 const isEntryPointFile = (filename) => {
 	const lastSlash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
 	const basename = lastSlash === -1 ? filename : filename.slice(lastSlash + 1);
@@ -40374,197 +41301,212 @@ const onlyExportComponents = defineRule({
 	category: "Architecture",
 	create: (context) => {
 		const settings = resolveSettings$6(context.settings);
-		return { Program(node) {
-			if (!isFileNameAllowed(normalizeFilename(context.filename ?? ""), settings.checkJS)) return;
-			const { exportNodes, componentCandidates } = collectRelevantNodes(node);
-			const localComponentNames = /* @__PURE__ */ new Set();
-			const state = {
-				customHocs: new Set([...DEFAULT_REACT_HOCS, ...settings.customHOCs]),
-				allowExportNames: new Set(settings.allowExportNames),
-				allowConstantExport: settings.allowConstantExport,
-				localComponentNames,
-				scopes: context.scopes
-			};
-			for (const child of componentCandidates) {
-				if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-					if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes)) localComponentNames.add(child.id.name);
-				}
-				if (isNodeOfType(child, "ClassDeclaration") && child.id) {
-					if (isReactComponentName(child.id.name) && isEs6Component(child) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
-				}
-				if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
-					const initializer = child.init;
-					if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) {
-						const expression = initializer ? skipTsExpression(initializer) : null;
-						if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes)) localComponentNames.add(child.id.name);
+		if (!isFileNameAllowed(normalizeFilename(context.filename ?? ""), settings.checkJS)) return {};
+		const exportNodes = [];
+		const componentCandidates = [];
+		const pushExportNode = (node) => {
+			exportNodes.push(node);
+		};
+		const pushComponentCandidate = (node) => {
+			componentCandidates.push(node);
+		};
+		return {
+			ExportAllDeclaration: pushExportNode,
+			ExportDefaultDeclaration: pushExportNode,
+			ExportNamedDeclaration: pushExportNode,
+			FunctionDeclaration: pushComponentCandidate,
+			VariableDeclarator: pushComponentCandidate,
+			ClassDeclaration: pushComponentCandidate,
+			"Program:exit"() {
+				const localComponentNames = /* @__PURE__ */ new Set();
+				const state = {
+					customHocs: new Set([...DEFAULT_REACT_HOCS, ...settings.customHOCs]),
+					allowExportNames: new Set(settings.allowExportNames),
+					allowConstantExport: settings.allowConstantExport,
+					localComponentNames,
+					scopes: context.scopes
+				};
+				for (const child of componentCandidates) {
+					if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
+						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes)) localComponentNames.add(child.id.name);
+					}
+					if (isNodeOfType(child, "ClassDeclaration") && child.id) {
+						if (isReactComponentName(child.id.name) && isEs6Component(child) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
+					}
+					if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
+						const initializer = child.init;
+						if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) {
+							const expression = initializer ? skipTsExpression(initializer) : null;
+							if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes)) localComponentNames.add(child.id.name);
+						}
 					}
 				}
-			}
-			const exports = [];
-			let hasReactExport = false;
-			let hasAnyExports = false;
-			const isExportedNodeIds = /* @__PURE__ */ new WeakSet();
-			for (const child of exportNodes) {
-				if (isNodeOfType(child, "ExportAllDeclaration")) {
-					if (child.exportKind === "type") continue;
-					hasAnyExports = true;
-					context.report({
-						node: child,
-						message: EXPORT_ALL_MESSAGE
-					});
-					continue;
-				}
-				if (isNodeOfType(child, "ExportDefaultDeclaration")) {
-					hasAnyExports = true;
-					const declaration = child.declaration;
-					const stripped = skipTsExpression(declaration);
-					if (isNodeOfType(stripped, "FunctionDeclaration") || isNodeOfType(stripped, "FunctionExpression")) {
-						if (stripped.id) {
-							const idNode = stripped.id;
-							isExportedNodeIds.add(stripped);
-							exports.push(classifyExport(idNode.name, idNode, true, null, state));
-						} else {
-							context.report({
+				const exports = [];
+				let hasReactExport = false;
+				let hasAnyExports = false;
+				const isExportedNodeIds = /* @__PURE__ */ new WeakSet();
+				for (const child of exportNodes) {
+					if (isNodeOfType(child, "ExportAllDeclaration")) {
+						if (child.exportKind === "type") continue;
+						hasAnyExports = true;
+						context.report({
+							node: child,
+							message: EXPORT_ALL_MESSAGE
+						});
+						continue;
+					}
+					if (isNodeOfType(child, "ExportDefaultDeclaration")) {
+						hasAnyExports = true;
+						const declaration = child.declaration;
+						const stripped = skipTsExpression(declaration);
+						if (isNodeOfType(stripped, "FunctionDeclaration") || isNodeOfType(stripped, "FunctionExpression")) {
+							if (stripped.id) {
+								const idNode = stripped.id;
+								isExportedNodeIds.add(stripped);
+								exports.push(classifyExport(idNode.name, idNode, true, null, state));
+							} else {
+								context.report({
+									node: stripped,
+									message: ANONYMOUS_MESSAGE
+								});
+								hasReactExport = true;
+							}
+							continue;
+						}
+						if (isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "ClassExpression")) {
+							if (stripped.id) {
+								const idNode = stripped.id;
+								isExportedNodeIds.add(stripped);
+								if (isReactComponentName(idNode.name) && isEs6Component(stripped)) hasReactExport = true;
+								else exports.push({
+									kind: "non-component",
+									reportNode: idNode
+								});
+							} else context.report({
 								node: stripped,
 								message: ANONYMOUS_MESSAGE
 							});
-							hasReactExport = true;
+							continue;
 						}
-						continue;
-					}
-					if (isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "ClassExpression")) {
-						if (stripped.id) {
-							const idNode = stripped.id;
-							isExportedNodeIds.add(stripped);
-							if (isReactComponentName(idNode.name) && isEs6Component(stripped)) hasReactExport = true;
-							else exports.push({
+						if (isNodeOfType(stripped, "Identifier")) {
+							exports.push(classifyExport(stripped.name, stripped, false, null, state));
+							continue;
+						}
+						if (isNodeOfType(stripped, "CallExpression")) {
+							if (isRouteFactoryCall(stripped)) {
+								hasReactExport = true;
+								continue;
+							}
+							const isHoc = isHocCallee(stripped.callee, state);
+							const firstArg = stripped.arguments[0];
+							const firstArgIsValid = Boolean(firstArg) && (() => {
+								if (!firstArg) return false;
+								const expression = skipTsExpression(firstArg);
+								if (isNodeOfType(expression, "Identifier")) return true;
+								if (isNodeOfType(expression, "FunctionExpression") && expression.id) return true;
+								if (isNodeOfType(expression, "CallExpression") && isHocCallee(expression.callee, state)) return true;
+								return false;
+							})();
+							if (isHoc && firstArgIsValid) hasReactExport = true;
+							else if (!isHoc && isConfigOnlyFactoryCall(stripped)) exports.push({
 								kind: "non-component",
-								reportNode: idNode
+								reportNode: stripped
+							});
+							else context.report({
+								node: stripped,
+								message: ANONYMOUS_MESSAGE
+							});
+							continue;
+						}
+						if (isNodeOfType(stripped, "ObjectExpression")) {
+							context.report({
+								node: stripped,
+								message: objectExpressionBundlesComponents(stripped, state) ? NAMESPACE_OBJECT_MESSAGE : ANONYMOUS_MESSAGE
+							});
+							continue;
+						}
+						if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "Literal")) {
+							context.report({
+								node: stripped,
+								message: ANONYMOUS_MESSAGE
 							});
-						} else context.report({
-							node: stripped,
-							message: ANONYMOUS_MESSAGE
-						});
-						continue;
-					}
-					if (isNodeOfType(stripped, "Identifier")) {
-						exports.push(classifyExport(stripped.name, stripped, false, null, state));
-						continue;
-					}
-					if (isNodeOfType(stripped, "CallExpression")) {
-						if (isRouteFactoryCall(stripped)) {
-							hasReactExport = true;
 							continue;
 						}
-						const isHoc = isHocCallee(stripped.callee, state);
-						const firstArg = stripped.arguments[0];
-						const firstArgIsValid = Boolean(firstArg) && (() => {
-							if (!firstArg) return false;
-							const expression = skipTsExpression(firstArg);
-							if (isNodeOfType(expression, "Identifier")) return true;
-							if (isNodeOfType(expression, "FunctionExpression") && expression.id) return true;
-							if (isNodeOfType(expression, "CallExpression") && isHocCallee(expression.callee, state)) return true;
-							return false;
-						})();
-						if (isHoc && firstArgIsValid) hasReactExport = true;
-						else if (!isHoc && isConfigOnlyFactoryCall(stripped)) exports.push({
-							kind: "non-component",
-							reportNode: stripped
-						});
-						else context.report({
-							node: stripped,
-							message: ANONYMOUS_MESSAGE
-						});
-						continue;
-					}
-					if (isNodeOfType(stripped, "ObjectExpression")) {
-						context.report({
-							node: stripped,
-							message: objectExpressionBundlesComponents(stripped, state) ? NAMESPACE_OBJECT_MESSAGE : ANONYMOUS_MESSAGE
-						});
-						continue;
-					}
-					if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "Literal")) {
 						context.report({
-							node: stripped,
+							node: child,
 							message: ANONYMOUS_MESSAGE
 						});
 						continue;
 					}
-					context.report({
-						node: child,
-						message: ANONYMOUS_MESSAGE
-					});
-					continue;
-				}
-				if (isNodeOfType(child, "ExportNamedDeclaration")) {
-					if (child.exportKind === "type") continue;
-					hasAnyExports = true;
-					if (child.declaration) {
-						const declaration = child.declaration;
-						if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
-							isExportedNodeIds.add(declaration);
-							exports.push(classifyExport(declaration.id.name, declaration.id, true, null, state));
-						} else if (isNodeOfType(declaration, "ClassDeclaration") && declaration.id) {
-							isExportedNodeIds.add(declaration);
-							if (isReactComponentName(declaration.id.name) && isEs6Component(declaration)) exports.push({ kind: "react-component" });
-							else exports.push({
-								kind: "non-component",
-								reportNode: declaration.id
-							});
-						} else if (isNodeOfType(declaration, "VariableDeclaration")) for (const declarator of declaration.declarations) {
-							if (!isNodeOfType(declarator.id, "Identifier")) continue;
-							isExportedNodeIds.add(declarator);
-							const isFunction = canBeReactFunctionComponent(declarator.init ?? null, state);
-							exports.push(classifyExport(declarator.id.name, declarator.id, isFunction, declarator.init, state));
-						}
-						else if (declaration.type === "TSEnumDeclaration" || declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration") {
-							if (declaration.type === "TSEnumDeclaration") exports.push({
-								kind: "non-component",
-								reportNode: declaration
-							});
+					if (isNodeOfType(child, "ExportNamedDeclaration")) {
+						if (child.exportKind === "type") continue;
+						hasAnyExports = true;
+						if (child.declaration) {
+							const declaration = child.declaration;
+							if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
+								isExportedNodeIds.add(declaration);
+								exports.push(classifyExport(declaration.id.name, declaration.id, true, null, state));
+							} else if (isNodeOfType(declaration, "ClassDeclaration") && declaration.id) {
+								isExportedNodeIds.add(declaration);
+								if (isReactComponentName(declaration.id.name) && isEs6Component(declaration)) exports.push({ kind: "react-component" });
+								else exports.push({
+									kind: "non-component",
+									reportNode: declaration.id
+								});
+							} else if (isNodeOfType(declaration, "VariableDeclaration")) for (const declarator of declaration.declarations) {
+								if (!isNodeOfType(declarator.id, "Identifier")) continue;
+								isExportedNodeIds.add(declarator);
+								const isFunction = canBeReactFunctionComponent(declarator.init ?? null, state);
+								exports.push(classifyExport(declarator.id.name, declarator.id, isFunction, declarator.init, state));
+							}
+							else if (declaration.type === "TSEnumDeclaration" || declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration") {
+								if (declaration.type === "TSEnumDeclaration") exports.push({
+									kind: "non-component",
+									reportNode: declaration
+								});
+							}
 						}
-					}
-					const isReExportFromSource = Boolean(child.source);
-					for (const specifier of child.specifiers ?? []) {
-						if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-						const exported = specifier.exported;
-						const local = specifier.local;
-						let exportedName = null;
-						if (exported && isNodeOfType(exported, "Identifier")) exportedName = exported.name;
-						const localName = local && isNodeOfType(local, "Identifier") ? local.name : null;
-						const reportNode = specifier;
-						let entry;
-						if (exportedName === "default" && localName) entry = classifyExport(localName, reportNode, false, null, state);
-						else if (exportedName) entry = classifyExport(exportedName, reportNode, false, null, state);
-						else {
-							entry = {
-								kind: "non-component",
-								reportNode
-							};
-							if (localName && isReactComponentName(localName)) exports.push({ kind: "react-component" });
+						const isReExportFromSource = Boolean(child.source);
+						for (const specifier of child.specifiers ?? []) {
+							if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+							const exported = specifier.exported;
+							const local = specifier.local;
+							let exportedName = null;
+							if (exported && isNodeOfType(exported, "Identifier")) exportedName = exported.name;
+							const localName = local && isNodeOfType(local, "Identifier") ? local.name : null;
+							const reportNode = specifier;
+							let entry;
+							if (exportedName === "default" && localName) entry = classifyExport(localName, reportNode, false, null, state);
+							else if (exportedName) entry = classifyExport(exportedName, reportNode, false, null, state);
+							else {
+								entry = {
+									kind: "non-component",
+									reportNode
+								};
+								if (localName && isReactComponentName(localName)) exports.push({ kind: "react-component" });
+							}
+							if (isReExportFromSource && entry.kind !== "react-component") continue;
+							exports.push(entry);
 						}
-						if (isReExportFromSource && entry.kind !== "react-component") continue;
-						exports.push(entry);
 					}
 				}
-			}
-			for (const entry of exports) if (entry.kind === "react-component") hasReactExport = true;
-			for (const entry of exports) if (entry.kind === "namespace-object") context.report({
-				node: entry.reportNode,
-				message: NAMESPACE_OBJECT_MESSAGE
-			});
-			if (hasAnyExports && hasReactExport) for (const entry of exports) {
-				if (entry.kind === "non-component") context.report({
-					node: entry.reportNode,
-					message: NAMED_EXPORT_MESSAGE
-				});
-				if (entry.kind === "react-context") context.report({
+				for (const entry of exports) if (entry.kind === "react-component") hasReactExport = true;
+				for (const entry of exports) if (entry.kind === "namespace-object") context.report({
 					node: entry.reportNode,
-					message: REACT_CONTEXT_MESSAGE
+					message: NAMESPACE_OBJECT_MESSAGE
 				});
+				if (hasAnyExports && hasReactExport) for (const entry of exports) {
+					if (entry.kind === "non-component") context.report({
+						node: entry.reportNode,
+						message: NAMED_EXPORT_MESSAGE
+					});
+					if (entry.kind === "react-context") context.report({
+						node: entry.reportNode,
+						message: REACT_CONTEXT_MESSAGE
+					});
+				}
 			}
-		} };
+		};
 	}
 });
 //#endregion
@@ -40666,7 +41608,12 @@ const postmessageOriginRisk = defineRule({
 	scan: (file) => {
 		if (!isProductionSourcePath(file.relativePath)) return [];
 		if (WORKER_FILE_PATH_PATTERN.test(file.relativePath)) return [];
-		const ast = parseSourceText(file.absolutePath, file.content);
+		if (!file.content.includes("addEventListener") && !file.content.includes("onmessage")) return [];
+		const ast = parseSourceText({
+			filename: file.absolutePath,
+			sourceText: file.content,
+			shouldAttachParentReferences: false
+		});
 		if (ast === null) return [];
 		const findings = [];
 		walkAst(ast, (node) => {
@@ -40916,7 +41863,7 @@ const preactPreferOndblclick = defineRule({
 	recommendation: "Rename `onDoubleClick` to `onDblClick` because Preact core listens for the DOM `dblclick` event name and `onDoubleClick` never fires.",
 	create: (context) => ({ JSXOpeningElement(node) {
 		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const tagName = node.name.name;
+		const tagName = resolveJsxElementType(node);
 		if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
 		const onDoubleClickAttribute = findJsxAttribute(node.attributes, "onDoubleClick");
 		if (!onDoubleClickAttribute) return;
@@ -40936,7 +41883,7 @@ const COMPAT_EXEMPT_INPUT_TYPES = new Set([
 ]);
 const isTextLikeInput = (openingElement) => {
 	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
-	const tagName = openingElement.name.name;
+	const tagName = resolveJsxElementType(openingElement);
 	if (tagName === "textarea") return true;
 	if (tagName !== "input") return false;
 	const typeAttribute = findJsxAttribute(openingElement.attributes, "type");
@@ -41093,8 +42040,9 @@ const CROSS_CUTTING_STATE_BOOLEAN_NAMES = new Set([
 ]);
 const collectBooleanPropBindings = (param) => {
 	const bindings = /* @__PURE__ */ new Set();
-	if (!param || !isNodeOfType(param, "ObjectPattern")) return bindings;
-	for (const property of param.properties ?? []) {
+	const propsBinding = resolveFirstArgumentBinding(param);
+	if (!isNodeOfType(propsBinding, "ObjectPattern")) return bindings;
+	for (const property of propsBinding.properties ?? []) {
 		if (!isNodeOfType(property, "Property")) continue;
 		if (property.computed) continue;
 		if (!isNodeOfType(property.key, "Identifier")) continue;
@@ -41355,7 +42303,7 @@ const preferHtmlDialog = defineRule({
 			},
 			JSXOpeningElement(node) {
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const tagName = node.name.name;
+				const tagName = resolveJsxElementType(node);
 				if (tagName === "dialog") return;
 				if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
 				if (!HTML_TAGS.has(tagName)) return;
@@ -42902,13 +43850,13 @@ const resolveTanstackQueryHookName = (callExpression) => {
 	}
 	return null;
 };
-const resolveHookNameFromInitializer = (initializer) => {
+const resolveHookNameFromInitializer = (initializer, scopes) => {
 	if (isNodeOfType(initializer, "CallExpression")) return resolveTanstackQueryHookName(initializer);
 	if (!isNodeOfType(initializer, "Identifier")) return null;
-	const binding = findVariableInitializer(initializer, initializer.name);
-	if (!binding?.initializer || !isConstDeclaredBinding(binding)) return null;
-	if (!isNodeOfType(binding.initializer, "CallExpression")) return null;
-	return resolveTanstackQueryHookName(binding.initializer);
+	const resolvedSymbol = resolveConstIdentifierAlias(initializer, scopes);
+	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
+	if (!isNodeOfType(resolvedSymbol.initializer, "CallExpression")) return null;
+	return resolveTanstackQueryHookName(resolvedSymbol.initializer);
 };
 const queryNoRestDestructuring = defineRule({
 	id: "query-no-rest-destructuring",
@@ -42921,7 +43869,7 @@ const queryNoRestDestructuring = defineRule({
 		if (!isNodeOfType(node.id, "ObjectPattern")) return;
 		if (!node.init) return;
 		if (!node.id.properties?.some((property) => isNodeOfType(property, "RestElement"))) return;
-		const hookName = resolveHookNameFromInitializer(node.init);
+		const hookName = resolveHookNameFromInitializer(node.init, context.scopes);
 		if (!hookName) return;
 		context.report({
 			node: node.id,
@@ -43046,15 +43994,6 @@ const isStableHookWrapperArgument = (node) => {
 	const parent = node.parent;
 	return isNodeOfType(parent, "CallExpression") && isNodeOfType(parent.callee, "Identifier") && STABLE_HOOK_WRAPPERS.has(parent.callee.name) && Boolean(parent.arguments?.some((argument) => argument === node));
 };
-const isImmediatelyInvokedFunction = (functionNode) => {
-	let wrappedCallee = functionNode;
-	let enclosing = functionNode.parent;
-	while (enclosing && stripParenExpression(enclosing) === functionNode) {
-		wrappedCallee = enclosing;
-		enclosing = enclosing.parent ?? null;
-	}
-	return Boolean(enclosing && isNodeOfType(enclosing, "CallExpression") && enclosing.callee === wrappedCallee);
-};
 const queryStableQueryClient = defineRule({
 	id: "query-stable-query-client",
 	title: "Unstable QueryClient in component",
@@ -43401,7 +44340,7 @@ const renderingAnimateSvgWrapper = defineRule({
 	severity: "warn",
 	recommendation: "Wrap the SVG in a motion element so animation props apply to a stable wrapper instead of the SVG node itself.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "svg") return;
+		if (resolveJsxElementType(node) !== "svg") return;
 		if (node.attributes?.some((attribute) => isNodeOfType(attribute, "JSXAttribute") && isNodeOfType(attribute.name, "JSXIdentifier") && MOTION_ANIMATE_PROPS.has(attribute.name.name))) context.report({
 			node,
 			message: "This is slow to render because you animate <svg> directly, so wrap it in a <div> or <motion.div> & animate that instead"
@@ -44694,14 +45633,10 @@ const rerenderLazyStateInit = defineRule({
 //#endregion
 //#region src/plugin/rules/performance/rerender-memo-before-early-return.ts
 const isJsxExpression = (node) => Boolean(node && isJsxElementOrFragment(stripParenExpression(node)));
-const callbackReturnsJsx = (callback) => {
+const callbackReturnsJsx = (callback, scopes) => {
 	if (!callback) return false;
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	const body = callback.body;
-	if (isJsxExpression(body)) return true;
-	if (!isNodeOfType(body, "BlockStatement")) return false;
-	for (const stmt of body.body ?? []) if (isNodeOfType(stmt, "ReturnStatement") && isJsxExpression(stmt.argument)) return true;
-	return false;
+	return functionReturnsMatchingExpression(callback, scopes, isJsxExpression);
 };
 const returnArgumentUsesAnyName = (returnStatement, names) => {
 	if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return false;
@@ -44779,7 +45714,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 					if (!isNodeOfType(stmt, "VariableDeclaration")) continue;
 					for (const declarator of stmt.declarations ?? []) {
 						const init = declarator.init;
-						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0])) {
+						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0], context.scopes)) {
 							memoNode = declarator;
 							callbackGuardTests = collectLeadingCallbackGuardTests(init.arguments?.[0]);
 							if (isNodeOfType(declarator.id, "Identifier")) memoConsumerNames.add(declarator.id.name);
@@ -44845,8 +45780,11 @@ const collectFromObjectPattern = (pattern, bindings) => {
 const collectDefaultedEmptyBindings = (functionNode) => {
 	const bindings = /* @__PURE__ */ new Map();
 	const params = functionNode.params ?? [];
-	for (const param of params) collectFromObjectPattern(param, bindings);
-	const propsParam = params[0];
+	for (const [parameterIndex, param] of params.entries()) {
+		const parameterBinding = parameterIndex === 0 ? resolveFirstArgumentBinding(param) : param;
+		if (parameterBinding) collectFromObjectPattern(parameterBinding, bindings);
+	}
+	const propsParam = resolveFirstArgumentBinding(params[0]);
 	const body = functionNode.body;
 	if (!propsParam || !isNodeOfType(propsParam, "Identifier") || !body) return bindings;
 	if (!isNodeOfType(body, "BlockStatement")) return bindings;
@@ -45352,8 +46290,8 @@ const rnAnimationReactionAsDerived = defineRule({
 			if (statements.length !== 1) return;
 			const onlyStatement = statements[0];
 			if (!isNodeOfType(onlyStatement, "ExpressionStatement")) return;
-			singleAssignment = onlyStatement.expression;
-		} else if (body) singleAssignment = body;
+			singleAssignment = unwrapDiscardedExpression(onlyStatement);
+		} else if (body) singleAssignment = unwrapDiscardedExpression(body);
 		if (!singleAssignment) return;
 		const isValueAssignment = isNodeOfType(singleAssignment, "AssignmentExpression") && isNodeOfType(singleAssignment.left, "MemberExpression") && isNodeOfType(singleAssignment.left.object, "Identifier") && isNodeOfType(singleAssignment.left.property, "Identifier") && singleAssignment.left.property.name === "value";
 		const isSetCall = isNodeOfType(singleAssignment, "CallExpression") && isNodeOfType(singleAssignment.callee, "MemberExpression") && isNodeOfType(singleAssignment.callee.property, "Identifier") && singleAssignment.callee.property.name === "set" && (singleAssignment.arguments?.length ?? 0) === 1;
@@ -52273,7 +53211,8 @@ const serverCacheWithObjectLiteral = defineRule({
 				if (!isNodeOfType(node.callee, "Identifier")) return;
 				if (!cachedFunctionNames.has(node.callee.name)) return;
 				const firstArg = node.arguments?.[0];
-				if (!isNodeOfType(firstArg, "ObjectExpression")) return;
+				if (!firstArg || isNodeOfType(firstArg, "SpreadElement")) return;
+				if (!isNodeOfType(unwrapObjectIntegrityExpression(firstArg, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES), "ObjectExpression")) return;
 				context.report({
 					node,
 					message: `Passing a new object to React.cache() each render misses the cache, so it refetches every request.`
@@ -52960,10 +53899,6 @@ const isInvalidStyleExpression = (expression) => {
 	}
 	return false;
 };
-const getJsxOpeningElementName = (node) => {
-	if (isNodeOfType(node.name, "JSXIdentifier")) return node.name.name;
-	return null;
-};
 const stylePropObject = defineRule({
 	id: "style-prop-object",
 	title: "Style prop is not an object",
@@ -52975,7 +53910,8 @@ const stylePropObject = defineRule({
 		const allowSet = new Set(allow);
 		return {
 			JSXOpeningElement(node) {
-				const elementName = getJsxOpeningElementName(node);
+				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+				const elementName = resolveJsxElementType(node);
 				if (elementName && allowSet.has(elementName)) return;
 				if (elementName) {
 					const firstCharCode = elementName.charCodeAt(0);
@@ -53680,7 +54616,7 @@ const tanstackStartNoAnchorElement = defineRule({
 	create: (context) => {
 		if (!isInProjectDirectory(context, "routes")) return {};
 		return { JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
+			if (resolveJsxElementType(node) !== "a") return;
 			const attributes = node.attributes ?? [];
 			const hrefAttribute = findJsxAttribute(attributes, "href");
 			if (!hrefAttribute?.value) return;
@@ -54301,8 +55237,7 @@ const voidDomElementsNoChildren = defineRule({
 	create: (context) => ({
 		JSXElement(node) {
 			const openingElement = node.openingElement;
-			if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return;
-			const tagName = openingElement.name.name;
+			const tagName = resolveJsxElementType(openingElement);
 			if (!VOID_DOM_ELEMENTS.has(tagName)) return;
 			const hasChildrenContent = node.children.some(isMeaningfulJsxChild);
 			const hasChildrenLikeProp = findChildrenLikePropName(openingElement.attributes);
@@ -54367,12 +55302,6 @@ const webhookSignatureRisk = defineRule({
 //#region src/plugin/rules/zod/utils/zod-ast.ts
 const ZOD_MODULE = "zod";
 const ZOD_MODULE_SOURCES = [ZOD_MODULE];
-const getStaticPropertyName = (member) => {
-	const property = member.property;
-	if (!member.computed && isNodeOfType(property, "Identifier")) return property.name;
-	if (member.computed && isNodeOfType(property, "Literal") && typeof property.value === "string") return property.value;
-	return null;
-};
 const importInfoCache = /* @__PURE__ */ new WeakMap();
 const getImportInfoForIdentifier = (identifier) => {
 	if (importInfoCache.has(identifier)) return importInfoCache.get(identifier) ?? null;
@@ -59553,7 +60482,10 @@ const appendNode = (builder, block, node) => {
 };
 const mapDescendantsToBlock = (builder, node, block) => {
 	builder.nodeBlock.set(node, block);
-	if (isFunctionLike$1(node)) return;
+	if (isFunctionLike$1(node)) {
+		builder.nestedFunctions.push(node);
+		return;
+	}
 	const record = node;
 	for (const key of Object.keys(record)) {
 		if (key === "parent") continue;
@@ -59787,11 +60719,12 @@ const buildStatement = (builder, statement, current) => {
 	mapDescendantsToBlock(builder, statement, current);
 	return current;
 };
-const buildFunctionCfg = (functionNode, body) => {
+const buildFunctionCfg = (functionNode, body, nestedFunctionSink) => {
 	const builder = {
 		blocks: [],
 		entry: null,
 		exit: null,
+		nestedFunctions: nestedFunctionSink,
 		nodeBlock: /* @__PURE__ */ new Map(),
 		loopStack: [],
 		switchStack: [],
@@ -59809,13 +60742,12 @@ const buildFunctionCfg = (functionNode, body) => {
 		bodyEnd = entry;
 	}
 	addEdge(bodyEnd, exit, "uncond");
-	const blockOf = (node) => builder.nodeBlock.get(node) ?? null;
 	return {
 		owner: functionNode,
 		entry,
 		exit,
 		blocks: builder.blocks,
-		blockOf
+		blockOf: (node) => builder.nodeBlock.get(node) ?? null
 	};
 };
 const computeUnconditionalSet = (cfg) => {
@@ -59852,8 +60784,9 @@ const computeUnconditionalSet = (cfg) => {
 const analyzeControlFlow = (program) => {
 	nextBlockId = 0;
 	const functionCfgs = /* @__PURE__ */ new Map();
+	const pendingFunctions = [];
 	const buildFor = (functionNode, body) => {
-		const cfg = buildFunctionCfg(functionNode, body);
+		const cfg = buildFunctionCfg(functionNode, body, pendingFunctions);
 		functionCfgs.set(functionNode, {
 			cfg,
 			unconditionalSet: computeUnconditionalSet(cfg)
@@ -59863,21 +60796,18 @@ const analyzeControlFlow = (program) => {
 		type: "BlockStatement",
 		body: program.body
 	});
-	const visit = (node) => {
-		if (isFunctionLike$1(node)) {
-			const body = node.body;
-			if (body) buildFor(node, body);
-		}
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-		}
+	for (let functionIndex = 0; functionIndex < pendingFunctions.length; functionIndex += 1) {
+		const functionNode = pendingFunctions[functionIndex];
+		if (!isFunctionLike$1(functionNode) || !functionNode.body || functionCfgs.has(functionNode)) continue;
+		buildFor(functionNode, functionNode.body);
+	}
+	const getFunctionEntry = (functionNode) => {
+		const existingEntry = functionCfgs.get(functionNode);
+		if (existingEntry) return existingEntry;
+		if (!isFunctionLike$1(functionNode) || !functionNode.body) return null;
+		buildFor(functionNode, functionNode.body);
+		return functionCfgs.get(functionNode) ?? null;
 	};
-	visit(program);
 	const enclosingFunction = (node) => {
 		let current = node;
 		while (current) {
@@ -59888,12 +60818,12 @@ const analyzeControlFlow = (program) => {
 		return null;
 	};
 	const cfgFor = (functionLike) => {
-		return functionCfgs.get(functionLike)?.cfg ?? null;
+		return getFunctionEntry(functionLike)?.cfg ?? null;
 	};
 	const isUnconditionalFromEntry = (node) => {
 		const owner = enclosingFunction(node);
 		if (!owner) return true;
-		const entry = functionCfgs.get(owner);
+		const entry = getFunctionEntry(owner);
 		if (!entry) return true;
 		const block = entry.cfg.blockOf(node);
 		if (!block) return true;
@@ -59967,17 +60897,14 @@ const wrapWithSemanticContext = (rule) => ({
 			}
 		};
 		const visitors = rule.create(enrichedContext);
-		const passthroughVisitors = {};
-		for (const [nodeType, handler] of Object.entries(visitors)) {
-			if (typeof handler !== "function") continue;
-			passthroughVisitors[nodeType] = handler;
-		}
-		const innerProgramHandler = passthroughVisitors.Program;
-		passthroughVisitors.Program = ((node) => {
-			programRoot = node;
-			if (innerProgramHandler) innerProgramHandler(node);
-		});
-		return passthroughVisitors;
+		const innerProgramHandler = visitors.Program;
+		return {
+			...visitors,
+			Program: ((node) => {
+				programRoot = node;
+				if (innerProgramHandler) innerProgramHandler(node);
+			})
+		};
 	}
 });
 //#endregion