eslint-plugin-react-x 3.0.0-next.2 → 3.0.0-next.20

package/dist/index.js

@@ -5,7 +5,7 @@ import { ESLintUtils } from "@typescript-eslint/utils";
 import { P, isMatching, match } from "ts-pattern";
 import ts from "typescript";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
-import { findEnclosingAssignmentTarget, findVariable, getChildScopes, getObjectType, getVariableDefinitionNode, isAssignmentTargetEqual } from "@eslint-react/var";
+import { findEnclosingAssignmentTarget, findVariable, getChildScopes, getObjectType, getVariableInitializer, isAssignmentTargetEqual } from "@eslint-react/var";
 import { DefinitionType } from "@typescript-eslint/scope-manager";
 import { constFalse, constTrue, constVoid, flow, getOrElseUpdate, identity, not, unit } from "@eslint-react/eff";
 import { compare } from "compare-versions";
@@ -13,6 +13,7 @@ import { getConstrainedTypeAtLocation, isTypeReadonly } from "@typescript-eslint
 import { isPropertyReadonlyInType, unionConstituents } from "ts-api-utils";
 import { getStaticValue, isIdentifier, isVariableDeclarator } from "@typescript-eslint/utils/ast-utils";
 import { getTypeImmutability, isImmutable, isReadonlyDeep, isReadonlyShallow, isUnknown } from "is-immutable-type";
+import { snakeCase } from "string-ts";
 
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -38,15 +39,18 @@ var disable_experimental_exports = /* @__PURE__ */ __exportAll({
 });
 const name$8 = "react-x/disable-experimental";
 const rules$8 = {
+	"react-x/exhaustive-deps": "off",
 	"react-x/jsx-key-before-spread": "off",
-	"react-x/jsx-no-iife": "off",
 	"react-x/no-duplicate-key": "off",
 	"react-x/no-implicit-key": "off",
 	"react-x/no-misused-capture-owner-stack": "off",
 	"react-x/no-unnecessary-use-callback": "off",
 	"react-x/no-unnecessary-use-memo": "off",
 	"react-x/no-unused-props": "off",
-	"react-x/prefer-read-only-props": "off"
+	"react-x/prefer-read-only-props": "off",
+	"react-x/refs": "off",
+	"react-x/rules-of-hooks": "off",
+	"react-x/set-state-in-render": "off"
 };
 
 //#endregion
@@ -66,7 +70,7 @@ const rules$7 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "3.0.0-next.2";
+var version = "3.0.0-next.20";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -136,7 +140,6 @@ function getFullyQualifiedNameEx(checker, symbol) {
 	let name = symbol.name;
 	let parent = symbol.declarations?.at(0)?.parent;
 	if (parent == null) return checker.getFullyQualifiedName(symbol);
-	const namespace = parent.getSourceFile().statements.find((n) => ts.isNamespaceExportDeclaration(n));
 	while (parent.kind !== ts.SyntaxKind.SourceFile) {
 		switch (true) {
 			case ts.isInterfaceDeclaration(parent):
@@ -168,11 +171,14 @@ function getFullyQualifiedNameEx(checker, symbol) {
 			case ts.isObjectLiteralExpression(parent):
 			case ts.isIntersectionTypeNode(parent):
 			case ts.isUnionTypeNode(parent): break;
+			default: break;
 		}
 		parent = parent.parent;
 	}
-	if (namespace != null) return `${namespace.name.text}.${name}`;
-	return name;
+	const namespace = parent.getSourceFile().statements.find((n) => ts.isNamespaceExportDeclaration(n))?.name.text;
+	if (namespace == null) return name;
+	if (name.startsWith(`${namespace}.`)) return name;
+	return `${namespace}.${name}`;
 }
 
 //#endregion
@@ -221,7 +227,7 @@ function getTypeVariants(types) {
 
 //#endregion
 //#region src/rules/component-hook-factories.ts
-const RULE_NAME$64 = "component-hook-factories";
+const RULE_NAME$66 = "component-hook-factories";
 var component_hook_factories_default = createRule({
 	meta: {
 		type: "problem",
@@ -232,11 +238,11 @@ var component_hook_factories_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$64,
-	create: create$64,
+	name: RULE_NAME$66,
+	create: create$66,
 	defaultOptions: []
 });
-function create$64(context) {
+function create$66(context) {
 	const hint = core.ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.ComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.ComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
 	const fCollector = core.useComponentCollector(context, { hint });
 	const cCollector = core.useComponentCollectorLegacy(context);
@@ -280,7 +286,7 @@ function create$64(context) {
 
 //#endregion
 //#region src/rules/error-boundaries.ts
-const RULE_NAME$63 = "error-boundaries";
+const RULE_NAME$65 = "error-boundaries";
 var error_boundaries_default = createRule({
 	meta: {
 		type: "problem",
@@ -291,11 +297,11 @@ var error_boundaries_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$63,
-	create: create$63,
+	name: RULE_NAME$65,
+	create: create$65,
 	defaultOptions: []
 });
-function create$63(context) {
+function create$65(context) {
 	if (!context.sourceCode.text.includes("try")) return {};
 	const { ctx, visitor } = core.useComponentCollector(context);
 	const reported = /* @__PURE__ */ new Set();
@@ -329,7 +335,7 @@ function create$63(context) {
 
 //#endregion
 //#region src/rules/exhaustive-deps.ts
-const RULE_NAME$62 = "exhaustive-deps";
+const RULE_NAME$64 = "exhaustive-deps";
 /**
 * Built-in hooks that accept dependency arrays.
 * Maps hook name to the index of the callback argument.
@@ -508,11 +514,11 @@ var exhaustive_deps_default = createRule({
 			properties: { additionalHooks: { type: "string" } }
 		}]
 	},
-	name: RULE_NAME$62,
-	create: create$62,
+	name: RULE_NAME$64,
+	create: create$64,
 	defaultOptions: [{}]
 });
-function create$62(context) {
+function create$64(context) {
 	const additionalHooks = context.options[0]?.additionalHooks;
 	const additionalHooksRegex = additionalHooks != null && additionalHooks.length > 0 ? new RegExp(additionalHooks) : null;
 	/** Collected hook calls for later analysis. */
@@ -692,7 +698,7 @@ function create$62(context) {
 			});
 		}
 	}
-	return {
+	return defineRuleListener({
 		CallExpression(node) {
 			if (!isHookWithDeps(node)) return;
 			const hookName = getHookName$1(node);
@@ -719,12 +725,12 @@ function create$62(context) {
 		"Program:exit"() {
 			for (const hookCall of collectedHookCalls) analyzeHookCall(hookCall);
 		}
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/jsx-dollar.ts
-const RULE_NAME$61 = "jsx-dollar";
+const RULE_NAME$63 = "jsx-dollar";
 var jsx_dollar_default = createRule({
 	meta: {
 		type: "problem",
@@ -737,11 +743,11 @@ var jsx_dollar_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$61,
-	create: create$61,
+	name: RULE_NAME$63,
+	create: create$63,
 	defaultOptions: []
 });
-function create$61(context) {
+function create$63(context) {
 	/**
 	* Visitor function for JSXElement and JSXFragment nodes
 	* @param node The JSXElement or JSXFragment node to be checked
@@ -774,15 +780,15 @@ function create$61(context) {
 			});
 		}
 	};
-	return {
+	return defineRuleListener({
 		JSXElement: visitorFunction,
 		JSXFragment: visitorFunction
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/jsx-key-before-spread.ts
-const RULE_NAME$60 = "jsx-key-before-spread";
+const RULE_NAME$62 = "jsx-key-before-spread";
 var jsx_key_before_spread_default = createRule({
 	meta: {
 		type: "problem",
@@ -790,17 +796,17 @@ var jsx_key_before_spread_default = createRule({
 		messages: { default: "The 'key' prop must be placed before any spread props when using the new JSX transform." },
 		schema: []
 	},
-	name: RULE_NAME$60,
-	create: create$60,
+	name: RULE_NAME$62,
+	create: create$62,
 	defaultOptions: []
 });
-function create$60(context) {
+function create$62(context) {
 	const { jsx } = {
 		...core.getJsxConfigFromContext(context),
 		...core.getJsxConfigFromAnnotation(context)
 	};
 	if (jsx !== core.JsxEmit.ReactJSX && jsx !== core.JsxEmit.ReactJSXDev) return {};
-	return { JSXOpeningElement(node) {
+	return defineRuleListener({ JSXOpeningElement(node) {
 		let firstSpreadPropIndex = null;
 		for (const [index, prop] of node.attributes.entries()) {
 			if (prop.type === AST_NODE_TYPES.JSXSpreadAttribute) {
@@ -813,12 +819,12 @@ function create$60(context) {
 				node: prop
 			});
 		}
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/jsx-no-comment-textnodes.ts
-const RULE_NAME$59 = "jsx-no-comment-textnodes";
+const RULE_NAME$61 = "jsx-no-comment-textnodes";
 var jsx_no_comment_textnodes_default = createRule({
 	meta: {
 		type: "problem",
@@ -826,11 +832,11 @@ var jsx_no_comment_textnodes_default = createRule({
 		messages: { default: "Possible misused comment in text node. Comments inside children section of tag should be placed inside braces." },
 		schema: []
 	},
-	name: RULE_NAME$59,
-	create: create$59,
+	name: RULE_NAME$61,
+	create: create$61,
 	defaultOptions: []
 });
-function create$59(context) {
+function create$61(context) {
 	function hasCommentLike(node) {
 		if (ast.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) return false;
 		return /^\s*\/(?:\/|\*)/mu.test(context.sourceCode.getText(node));
@@ -843,15 +849,15 @@ function create$59(context) {
 			node
 		});
 	};
-	return {
+	return defineRuleListener({
 		JSXText: visitorFunction,
 		Literal: visitorFunction
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/jsx-no-duplicate-props.ts
-const RULE_NAME$58 = "jsx-no-duplicate-props";
+const RULE_NAME$60 = "jsx-no-duplicate-props";
 var jsx_no_duplicate_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -859,12 +865,12 @@ var jsx_no_duplicate_props_default = createRule({
 		messages: { default: "This JSX property is assigned multiple times." },
 		schema: []
 	},
-	name: RULE_NAME$58,
-	create: create$58,
+	name: RULE_NAME$60,
+	create: create$60,
 	defaultOptions: []
 });
-function create$58(context) {
-	return { JSXOpeningElement(node) {
+function create$60(context) {
+	return defineRuleListener({ JSXOpeningElement(node) {
 		const props = [];
 		for (const attr of node.attributes) {
 			if (attr.type === AST_NODE_TYPES.JSXSpreadAttribute) continue;
@@ -879,43 +885,12 @@ function create$58(context) {
 				node: attr
 			});
 		}
-	} };
-}
-
-//#endregion
-//#region src/rules/jsx-no-iife.ts
-const RULE_NAME$57 = "jsx-no-iife";
-var jsx_no_iife_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallows immediately-invoked function expressions in JSX." },
-		messages: { default: "Avoid using immediately-invoked function expressions in JSX." },
-		schema: []
-	},
-	name: RULE_NAME$57,
-	create: create$57,
-	defaultOptions: []
-});
-function create$57(context) {
-	return {
-		"JSXElement :function"(node) {
-			if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) context.report({
-				messageId: "default",
-				node: node.parent
-			});
-		},
-		"JSXFragment :function"(node) {
-			if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) context.report({
-				messageId: "default",
-				node: node.parent
-			});
-		}
-	};
+	} });
 }
 
 //#endregion
 //#region src/rules/jsx-no-undef.ts
-const RULE_NAME$56 = "jsx-no-undef";
+const RULE_NAME$59 = "jsx-no-undef";
 var jsx_no_undef_default = createRule({
 	meta: {
 		type: "problem",
@@ -923,12 +898,12 @@ var jsx_no_undef_default = createRule({
 		messages: { default: "JSX variable '{{name}}' is not defined." },
 		schema: []
 	},
-	name: RULE_NAME$56,
-	create: create$56,
+	name: RULE_NAME$59,
+	create: create$59,
 	defaultOptions: []
 });
-function create$56(context) {
-	return { JSXOpeningElement(node) {
+function create$59(context) {
+	return defineRuleListener({ JSXOpeningElement(node) {
 		const name = match(node.name).with({ type: AST_NODE_TYPES.JSXIdentifier }, (n) => n.name).with({
 			type: AST_NODE_TYPES.JSXMemberExpression,
 			object: { type: AST_NODE_TYPES.JSXIdentifier }
@@ -941,14 +916,14 @@ function create$56(context) {
 			node,
 			data: { name }
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/jsx-shorthand-boolean.ts
-const RULE_NAME$55 = "jsx-shorthand-boolean";
-const defaultOptions$3 = [1];
-const schema$3 = [{
+const RULE_NAME$58 = "jsx-shorthand-boolean";
+const defaultOptions$4 = [1];
+const schema$4 = [{
 	type: "integer",
 	enum: [-1, 1]
 }];
@@ -958,15 +933,15 @@ var jsx_shorthand_boolean_default = createRule({
 		docs: { description: "Enforces shorthand syntax for boolean props." },
 		fixable: "code",
 		messages: { default: "{{message}}" },
-		schema: schema$3
+		schema: schema$4
 	},
-	name: RULE_NAME$55,
-	create: create$55,
-	defaultOptions: defaultOptions$3
+	name: RULE_NAME$58,
+	create: create$58,
+	defaultOptions: defaultOptions$4
 });
-function create$55(context) {
-	const policy = context.options[0] ?? defaultOptions$3[0];
-	return { JSXAttribute(node) {
+function create$58(context) {
+	const policy = context.options[0] ?? defaultOptions$4[0];
+	return defineRuleListener({ JSXAttribute(node) {
 		const { value } = node;
 		const propName = core.getJsxAttributeName(context, node);
 		switch (true) {
@@ -987,14 +962,14 @@ function create$55(context) {
 				});
 				break;
 		}
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/jsx-shorthand-fragment.ts
-const RULE_NAME$54 = "jsx-shorthand-fragment";
-const defaultOptions$2 = [1];
-const schema$2 = [{
+const RULE_NAME$57 = "jsx-shorthand-fragment";
+const defaultOptions$3 = [1];
+const schema$3 = [{
 	type: "integer",
 	enum: [-1, 1]
 }];
@@ -1004,20 +979,20 @@ var jsx_shorthand_fragment_default = createRule({
 		docs: { description: "Enforces shorthand syntax for fragment elements." },
 		fixable: "code",
 		messages: { default: "{{message}}" },
-		schema: schema$2
+		schema: schema$3
 	},
-	name: RULE_NAME$54,
-	create: create$54,
-	defaultOptions: defaultOptions$2
+	name: RULE_NAME$57,
+	create: create$57,
+	defaultOptions: defaultOptions$3
 });
-function create$54(context) {
-	const policy = context.options[0] ?? defaultOptions$2[0];
+function create$57(context) {
+	const policy = context.options[0] ?? defaultOptions$3[0];
 	const jsxConfig = {
 		...core.getJsxConfigFromContext(context),
 		...core.getJsxConfigFromAnnotation(context)
 	};
 	const { jsxFragmentFactory } = jsxConfig;
-	return match(policy).with(1, () => ({ JSXElement(node) {
+	return match(policy).with(1, () => defineRuleListener({ JSXElement(node) {
 		if (!core.isJsxFragmentElement(context, node, jsxConfig)) return;
 		if (node.openingElement.attributes.length > 0) return;
 		context.report({
@@ -1030,7 +1005,7 @@ function create$54(context) {
 				return [fixer.replaceTextRange([openingElement.range[0], openingElement.range[1]], "<>"), fixer.replaceTextRange([closingElement.range[0], closingElement.range[1]], "</>")];
 			}
 		});
-	} })).with(-1, () => ({ JSXFragment(node) {
+	} })).with(-1, () => defineRuleListener({ JSXFragment(node) {
 		context.report({
 			messageId: "default",
 			node,
@@ -1045,7 +1020,7 @@ function create$54(context) {
 
 //#endregion
 //#region src/rules/jsx-uses-react.ts
-const RULE_NAME$53 = "jsx-uses-react";
+const RULE_NAME$56 = "jsx-uses-react";
 var jsx_uses_react_default = createRule({
 	meta: {
 		type: "problem",
@@ -1053,11 +1028,11 @@ var jsx_uses_react_default = createRule({
 		messages: { default: "Marked {{name}} as used." },
 		schema: []
 	},
-	name: RULE_NAME$53,
-	create: create$53,
+	name: RULE_NAME$56,
+	create: create$56,
 	defaultOptions: []
 });
-function create$53(context) {
+function create$56(context) {
 	const { jsx, jsxFactory, jsxFragmentFactory } = {
 		...core.getJsxConfigFromContext(context),
 		...core.getJsxConfigFromAnnotation(context)
@@ -1071,11 +1046,11 @@ function create$53(context) {
 		context.sourceCode.markVariableAsUsed(jsxFragmentFactory, node);
 		debugReport(context, node, jsxFragmentFactory);
 	}
-	return {
+	return defineRuleListener({
 		JSXFragment: handleJsxFragment,
 		JSXOpeningElement: handleJsxElement,
 		JSXOpeningFragment: handleJsxElement
-	};
+	});
 }
 function debugReport(context, node, name) {
 	if (process.env["ESLINT_REACT_DEBUG"] !== "1") return;
@@ -1088,7 +1063,7 @@ function debugReport(context, node, name) {
 
 //#endregion
 //#region src/rules/jsx-uses-vars.ts
-const RULE_NAME$52 = "jsx-uses-vars";
+const RULE_NAME$55 = "jsx-uses-vars";
 var jsx_uses_vars_default = createRule({
 	meta: {
 		type: "problem",
@@ -1096,12 +1071,12 @@ var jsx_uses_vars_default = createRule({
 		messages: { default: "An identifier in JSX is marked as used." },
 		schema: []
 	},
-	name: RULE_NAME$52,
-	create: create$52,
+	name: RULE_NAME$55,
+	create: create$55,
 	defaultOptions: []
 });
-function create$52(context) {
-	return { JSXOpeningElement(node) {
+function create$55(context) {
+	return defineRuleListener({ JSXOpeningElement(node) {
 		switch (node.name.type) {
 			case AST_NODE_TYPES.JSXIdentifier:
 				if (/^[a-z]/u.test(node.name.name)) return;
@@ -1113,12 +1088,12 @@ function create$52(context) {
 				break;
 			}
 		}
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-access-state-in-setstate.ts
-const RULE_NAME$51 = "no-access-state-in-setstate";
+const RULE_NAME$54 = "no-access-state-in-setstate";
 function isKeyLiteral$2(node, key) {
 	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
 		type: AST_NODE_TYPES.TemplateLiteral,
@@ -1132,16 +1107,16 @@ var no_access_state_in_setstate_default = createRule({
 		messages: { default: "Do not access 'this.state' within 'setState'. Use the update function instead." },
 		schema: []
 	},
-	name: RULE_NAME$51,
-	create: create$51,
+	name: RULE_NAME$54,
+	create: create$54,
 	defaultOptions: []
 });
-function create$51(context) {
+function create$54(context) {
 	if (!context.sourceCode.text.includes("setState")) return {};
 	const classStack = [];
 	const methodStack = [];
 	const setStateStack = [];
-	return {
+	return defineRuleListener({
 		CallExpression(node) {
 			if (!core.isThisSetState(node)) return;
 			setStateStack.push([node, false]);
@@ -1202,12 +1177,12 @@ function create$51(context) {
 				node
 			});
 		}
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/no-array-index-key.ts
-const RULE_NAME$50 = "no-array-index-key";
+const RULE_NAME$53 = "no-array-index-key";
 const REACT_CHILDREN_METHOD = ["forEach", "map"];
 function getIndexParamPosition(methodName) {
 	switch (methodName) {
@@ -1266,11 +1241,11 @@ var no_array_index_key_default = createRule({
 		messages: { default: "Do not use item index in the array as its key." },
 		schema: []
 	},
-	name: RULE_NAME$50,
-	create: create$50,
+	name: RULE_NAME$53,
+	create: create$53,
 	defaultOptions: []
 });
-function create$50(context) {
+function create$53(context) {
 	const indexParamNames = [];
 	function isArrayIndex(node) {
 		return node.type === AST_NODE_TYPES.Identifier && indexParamNames.some((name) => name != null && name === node.name);
@@ -1309,7 +1284,7 @@ function create$50(context) {
 		}
 		return [];
 	}
-	return {
+	return defineRuleListener({
 		CallExpression(node) {
 			indexParamNames.push(getMapIndexParamName(context, node));
 			if (node.arguments.length === 0) return;
@@ -1331,12 +1306,12 @@ function create$50(context) {
 			if (node.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
 			for (const descriptor of getReportDescriptors(node.value.expression)) report(context)(descriptor);
 		}
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/no-children-count.ts
-const RULE_NAME$49 = "no-children-count";
+const RULE_NAME$52 = "no-children-count";
 var no_children_count_default = createRule({
 	meta: {
 		type: "problem",
@@ -1344,22 +1319,22 @@ var no_children_count_default = createRule({
 		messages: { default: "Using 'Children.count' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$49,
-	create: create$49,
+	name: RULE_NAME$52,
+	create: create$52,
 	defaultOptions: []
 });
-function create$49(context) {
-	return { MemberExpression(node) {
+function create$52(context) {
+	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenCount(context, node)) context.report({
 			messageId: "default",
 			node: node.property
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-children-for-each.ts
-const RULE_NAME$48 = "no-children-for-each";
+const RULE_NAME$51 = "no-children-for-each";
 var no_children_for_each_default = createRule({
 	meta: {
 		type: "problem",
@@ -1367,22 +1342,22 @@ var no_children_for_each_default = createRule({
 		messages: { default: "Using 'Children.forEach' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$48,
-	create: create$48,
+	name: RULE_NAME$51,
+	create: create$51,
 	defaultOptions: []
 });
-function create$48(context) {
-	return { MemberExpression(node) {
+function create$51(context) {
+	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenForEach(context, node)) context.report({
 			messageId: "default",
 			node: node.property
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-children-map.ts
-const RULE_NAME$47 = "no-children-map";
+const RULE_NAME$50 = "no-children-map";
 var no_children_map_default = createRule({
 	meta: {
 		type: "problem",
@@ -1390,22 +1365,22 @@ var no_children_map_default = createRule({
 		messages: { default: "Using 'Children.map' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$47,
-	create: create$47,
+	name: RULE_NAME$50,
+	create: create$50,
 	defaultOptions: []
 });
-function create$47(context) {
-	return { MemberExpression(node) {
+function create$50(context) {
+	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenMap(context, node)) context.report({
 			messageId: "default",
 			node: node.property
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-children-only.ts
-const RULE_NAME$46 = "no-children-only";
+const RULE_NAME$49 = "no-children-only";
 var no_children_only_default = createRule({
 	meta: {
 		type: "problem",
@@ -1413,22 +1388,22 @@ var no_children_only_default = createRule({
 		messages: { default: "Using 'Children.only' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$46,
-	create: create$46,
+	name: RULE_NAME$49,
+	create: create$49,
 	defaultOptions: []
 });
-function create$46(context) {
-	return { MemberExpression(node) {
+function create$49(context) {
+	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenOnly(context, node)) context.report({
 			messageId: "default",
 			node: node.property
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-children-prop.ts
-const RULE_NAME$45 = "no-children-prop";
+const RULE_NAME$48 = "no-children-prop";
 var no_children_prop_default = createRule({
 	meta: {
 		type: "problem",
@@ -1436,23 +1411,23 @@ var no_children_prop_default = createRule({
 		messages: { default: "Do not pass 'children' as props." },
 		schema: []
 	},
-	name: RULE_NAME$45,
-	create: create$45,
+	name: RULE_NAME$48,
+	create: create$48,
 	defaultOptions: []
 });
-function create$45(context) {
-	return { JSXElement(node) {
+function create$48(context) {
+	return defineRuleListener({ JSXElement(node) {
 		const childrenProp = core.getJsxAttribute(context, node)("children");
 		if (childrenProp != null) context.report({
 			messageId: "default",
 			node: childrenProp
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-children-to-array.ts
-const RULE_NAME$44 = "no-children-to-array";
+const RULE_NAME$47 = "no-children-to-array";
 var no_children_to_array_default = createRule({
 	meta: {
 		type: "problem",
@@ -1460,22 +1435,22 @@ var no_children_to_array_default = createRule({
 		messages: { default: "Using 'Children.toArray' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$44,
-	create: create$44,
+	name: RULE_NAME$47,
+	create: create$47,
 	defaultOptions: []
 });
-function create$44(context) {
-	return { MemberExpression(node) {
+function create$47(context) {
+	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenToArray(context, node)) context.report({
 			messageId: "default",
 			node: node.property
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-class-component.ts
-const RULE_NAME$43 = "no-class-component";
+const RULE_NAME$46 = "no-class-component";
 var no_class_component_default = createRule({
 	meta: {
 		type: "problem",
@@ -1483,11 +1458,11 @@ var no_class_component_default = createRule({
 		messages: { default: "Avoid using class components. Use function components instead." },
 		schema: []
 	},
-	name: RULE_NAME$43,
-	create: create$43,
+	name: RULE_NAME$46,
+	create: create$46,
 	defaultOptions: []
 });
-function create$43(context) {
+function create$46(context) {
 	if (!context.sourceCode.text.includes("Component")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1504,7 +1479,7 @@ function create$43(context) {
 
 //#endregion
 //#region src/rules/no-clone-element.ts
-const RULE_NAME$42 = "no-clone-element";
+const RULE_NAME$45 = "no-clone-element";
 var no_clone_element_default = createRule({
 	meta: {
 		type: "problem",
@@ -1512,22 +1487,22 @@ var no_clone_element_default = createRule({
 		messages: { default: "Using 'cloneElement' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$42,
-	create: create$42,
+	name: RULE_NAME$45,
+	create: create$45,
 	defaultOptions: []
 });
-function create$42(context) {
-	return { CallExpression(node) {
+function create$45(context) {
+	return defineRuleListener({ CallExpression(node) {
 		if (core.isCloneElementCall(context, node)) context.report({
 			messageId: "default",
 			node
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-component-will-mount.ts
-const RULE_NAME$41 = "no-component-will-mount";
+const RULE_NAME$44 = "no-component-will-mount";
 var no_component_will_mount_default = createRule({
 	meta: {
 		type: "problem",
@@ -1536,11 +1511,11 @@ var no_component_will_mount_default = createRule({
 		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillMount' instead." },
 		schema: []
 	},
-	name: RULE_NAME$41,
-	create: create$41,
+	name: RULE_NAME$44,
+	create: create$44,
 	defaultOptions: []
 });
-function create$41(context) {
+function create$44(context) {
 	if (!context.sourceCode.text.includes("componentWillMount")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1560,7 +1535,7 @@ function create$41(context) {
 
 //#endregion
 //#region src/rules/no-component-will-receive-props.ts
-const RULE_NAME$40 = "no-component-will-receive-props";
+const RULE_NAME$43 = "no-component-will-receive-props";
 var no_component_will_receive_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -1569,11 +1544,11 @@ var no_component_will_receive_props_default = createRule({
 		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillReceiveProps' instead." },
 		schema: []
 	},
-	name: RULE_NAME$40,
-	create: create$40,
+	name: RULE_NAME$43,
+	create: create$43,
 	defaultOptions: []
 });
-function create$40(context) {
+function create$43(context) {
 	if (!context.sourceCode.text.includes("componentWillReceiveProps")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1593,7 +1568,7 @@ function create$40(context) {
 
 //#endregion
 //#region src/rules/no-component-will-update.ts
-const RULE_NAME$39 = "no-component-will-update";
+const RULE_NAME$42 = "no-component-will-update";
 var no_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -1602,11 +1577,11 @@ var no_component_will_update_default = createRule({
 		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillUpdate' instead." },
 		schema: []
 	},
-	name: RULE_NAME$39,
-	create: create$39,
+	name: RULE_NAME$42,
+	create: create$42,
 	defaultOptions: []
 });
-function create$39(context) {
+function create$42(context) {
 	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1626,7 +1601,7 @@ function create$39(context) {
 
 //#endregion
 //#region src/rules/no-context-provider.ts
-const RULE_NAME$38 = "no-context-provider";
+const RULE_NAME$41 = "no-context-provider";
 var no_context_provider_default = createRule({
 	meta: {
 		type: "problem",
@@ -1635,15 +1610,15 @@ var no_context_provider_default = createRule({
 		messages: { default: "In React 19, you can render '<Context>' as a provider instead of '<Context.Provider>'." },
 		schema: []
 	},
-	name: RULE_NAME$38,
-	create: create$38,
+	name: RULE_NAME$41,
+	create: create$41,
 	defaultOptions: []
 });
-function create$38(context) {
+function create$41(context) {
 	if (!context.sourceCode.text.includes("Provider")) return {};
 	const { version } = getSettingsFromContext(context);
 	if (compare(version, "19.0.0", "<")) return {};
-	return { JSXElement(node) {
+	return defineRuleListener({ JSXElement(node) {
 		const parts = core.getJsxElementType(context, node).split(".");
 		const selfName = parts.pop();
 		const contextFullName = parts.join(".");
@@ -1661,12 +1636,12 @@ function create$38(context) {
 				return [fixer.replaceText(openingElement.name, contextFullName), fixer.replaceText(closingElement.name, contextFullName)];
 			}
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-create-ref.ts
-const RULE_NAME$37 = "no-create-ref";
+const RULE_NAME$40 = "no-create-ref";
 var no_create_ref_default = createRule({
 	meta: {
 		type: "problem",
@@ -1674,22 +1649,22 @@ var no_create_ref_default = createRule({
 		messages: { default: "[Deprecated] Use 'useRef' instead." },
 		schema: []
 	},
-	name: RULE_NAME$37,
-	create: create$37,
+	name: RULE_NAME$40,
+	create: create$40,
 	defaultOptions: []
 });
-function create$37(context) {
-	return { CallExpression(node) {
+function create$40(context) {
+	return defineRuleListener({ CallExpression(node) {
 		if (core.isCreateRefCall(context, node) && ast.findParentNode(node, core.isClassComponent) == null) context.report({
 			messageId: "default",
 			node
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-direct-mutation-state.ts
-const RULE_NAME$36 = "no-direct-mutation-state";
+const RULE_NAME$39 = "no-direct-mutation-state";
 function isConstructorFunction(node) {
 	return ast.isOneOf([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.FunctionExpression])(node) && ast.isMethodOrProperty(node.parent) && node.parent.key.type === AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
 }
@@ -1700,12 +1675,12 @@ var no_direct_mutation_state_default = createRule({
 		messages: { default: "Do not mutate state directly. Use 'setState()' instead." },
 		schema: []
 	},
-	name: RULE_NAME$36,
-	create: create$36,
+	name: RULE_NAME$39,
+	create: create$39,
 	defaultOptions: []
 });
-function create$36(context) {
-	return { AssignmentExpression(node) {
+function create$39(context) {
+	return defineRuleListener({ AssignmentExpression(node) {
 		if (!core.isAssignmentToThisState(node)) return;
 		const parentClass = ast.findParentNode(node, ast.isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression]));
 		if (parentClass == null) return;
@@ -1713,12 +1688,12 @@ function create$36(context) {
 			messageId: "default",
 			node
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-duplicate-key.ts
-const RULE_NAME$35 = "no-duplicate-key";
+const RULE_NAME$38 = "no-duplicate-key";
 var no_duplicate_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -1726,11 +1701,11 @@ var no_duplicate_key_default = createRule({
 		messages: { default: "The 'key' prop must be unique to its sibling elements." },
 		schema: []
 	},
-	name: RULE_NAME$35,
-	create: create$35,
+	name: RULE_NAME$38,
+	create: create$38,
 	defaultOptions: []
 });
-function create$35(context) {
+function create$38(context) {
 	if (!context.sourceCode.text.includes("key=")) return {};
 	const keyedEntries = /* @__PURE__ */ new Map();
 	function isKeyValueEqual(a, b) {
@@ -1739,7 +1714,7 @@ function create$35(context) {
 		if (aValue == null || bValue == null) return false;
 		return ast.isNodeEqual(aValue, bValue);
 	}
-	return {
+	return defineRuleListener({
 		"JSXAttribute[name.name='key']"(node) {
 			const jsxElement = node.parent.parent;
 			switch (jsxElement.parent.type) {
@@ -1780,12 +1755,12 @@ function create$35(context) {
 				});
 			}
 		}
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/no-forward-ref.ts
-const RULE_NAME$34 = "no-forward-ref";
+const RULE_NAME$37 = "no-forward-ref";
 var no_forward_ref_default = createRule({
 	meta: {
 		type: "problem",
@@ -1794,15 +1769,15 @@ var no_forward_ref_default = createRule({
 		messages: { default: "In React 19, 'forwardRef' is no longer necessary. Pass 'ref' as a prop instead." },
 		schema: []
 	},
-	name: RULE_NAME$34,
-	create: create$34,
+	name: RULE_NAME$37,
+	create: create$37,
 	defaultOptions: []
 });
-function create$34(context) {
+function create$37(context) {
 	if (!context.sourceCode.text.includes("forwardRef")) return {};
 	const { version } = getSettingsFromContext(context);
 	if (compare(version, "19.0.0", "<")) return {};
-	return { CallExpression(node) {
+	return defineRuleListener({ CallExpression(node) {
 		if (!core.isForwardRefCall(context, node)) return;
 		const id = ast.getFunctionId(node);
 		const fix = canFix(context, node) ? getFix(context, node) : null;
@@ -1811,7 +1786,7 @@ function create$34(context) {
 			node: id ?? node,
 			fix
 		});
-	} };
+	} });
 }
 /**
 * Determine whether the given CallExpression can be safely auto-fixed by replacing
@@ -1893,7 +1868,7 @@ function getComponentPropsFixes(context, fixer, node, typeArguments) {
 
 //#endregion
 //#region src/rules/no-implicit-key.ts
-const RULE_NAME$33 = "no-implicit-key";
+const RULE_NAME$36 = "no-implicit-key";
 var no_implicit_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -1901,14 +1876,14 @@ var no_implicit_key_default = createRule({
 		messages: { default: "This spread attribute implicitly passes the 'key' prop to a component, this could lead to unexpected behavior. If you intend to pass the 'key' prop, use 'key={value}'." },
 		schema: []
 	},
-	name: RULE_NAME$33,
-	create: create$33,
+	name: RULE_NAME$36,
+	create: create$36,
 	defaultOptions: []
 });
-function create$33(context) {
+function create$36(context) {
 	const services = ESLintUtils.getParserServices(context, false);
 	const checker = services.program.getTypeChecker();
-	return { JSXSpreadAttribute(node) {
+	return defineRuleListener({ JSXSpreadAttribute(node) {
 		for (const type of unionConstituents(getConstrainedTypeAtLocation(services, node.argument))) {
 			const key = type.getProperty("key");
 			if (key == null) continue;
@@ -1918,12 +1893,12 @@ function create$33(context) {
 				node
 			});
 		}
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-leaked-conditional-rendering.ts
-const RULE_NAME$32 = "no-leaked-conditional-rendering";
+const RULE_NAME$35 = "no-leaked-conditional-rendering";
 var no_leaked_conditional_rendering_default = createRule({
 	meta: {
 		type: "problem",
@@ -1931,11 +1906,11 @@ var no_leaked_conditional_rendering_default = createRule({
 		messages: { default: "Potential leaked value {{value}} that might cause unintentionally rendered values or rendering crashes." },
 		schema: []
 	},
-	name: RULE_NAME$32,
-	create: create$32,
+	name: RULE_NAME$35,
+	create: create$35,
 	defaultOptions: []
 });
-function create$32(context) {
+function create$35(context) {
 	if (!context.sourceCode.text.includes("&&")) return {};
 	const { version } = getSettingsFromContext(context);
 	const allowedVariants = [
@@ -1987,12 +1962,12 @@ function create$32(context) {
 			return match(variableDefNode).with({ init: P.select({ type: P.not(AST_NODE_TYPES.VariableDeclaration) }) }, getReportDescriptor).otherwise(() => unit);
 		}).otherwise(() => unit);
 	}
-	return { JSXExpressionContainer: flow(getReportDescriptor, report(context)) };
+	return defineRuleListener({ JSXExpressionContainer: flow(getReportDescriptor, report(context)) });
 }
 
 //#endregion
 //#region src/rules/no-missing-component-display-name.ts
-const RULE_NAME$31 = "no-missing-component-display-name";
+const RULE_NAME$34 = "no-missing-component-display-name";
 var no_missing_component_display_name_default = createRule({
 	meta: {
 		type: "problem",
@@ -2000,11 +1975,11 @@ var no_missing_component_display_name_default = createRule({
 		messages: { default: "Add missing 'displayName' for component." },
 		schema: []
 	},
-	name: RULE_NAME$31,
-	create: create$31,
+	name: RULE_NAME$34,
+	create: create$34,
 	defaultOptions: []
 });
-function create$31(context) {
+function create$34(context) {
 	if (!context.sourceCode.text.includes("memo") && !context.sourceCode.text.includes("forwardRef")) return {};
 	const { ctx, visitor } = core.useComponentCollector(context, {
 		collectDisplayName: true,
@@ -2026,7 +2001,7 @@ function create$31(context) {
 
 //#endregion
 //#region src/rules/no-missing-context-display-name.ts
-const RULE_NAME$30 = "no-missing-context-display-name";
+const RULE_NAME$33 = "no-missing-context-display-name";
 var no_missing_context_display_name_default = createRule({
 	meta: {
 		type: "problem",
@@ -2035,15 +2010,15 @@ var no_missing_context_display_name_default = createRule({
 		messages: { default: "Add missing 'displayName' for context." },
 		schema: []
 	},
-	name: RULE_NAME$30,
-	create: create$30,
+	name: RULE_NAME$33,
+	create: create$33,
 	defaultOptions: []
 });
-function create$30(context) {
+function create$33(context) {
 	if (!context.sourceCode.text.includes("createContext")) return {};
 	const createCalls = [];
 	const displayNameAssignments = [];
-	return {
+	return defineRuleListener({
 		[ast.SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION](node) {
 			displayNameAssignments.push(node);
 		},
@@ -2086,12 +2061,12 @@ function create$30(context) {
 				});
 			}
 		}
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/no-missing-key.ts
-const RULE_NAME$29 = "no-missing-key";
+const RULE_NAME$32 = "no-missing-key";
 var no_missing_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -2102,11 +2077,11 @@ var no_missing_key_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$29,
-	create: create$29,
+	name: RULE_NAME$32,
+	create: create$32,
 	defaultOptions: []
 });
-function create$29(ctx) {
+function create$32(ctx) {
 	let inChildrenToArray = false;
 	function check(node) {
 		if (node.type === AST_NODE_TYPES.JSXElement) return core.getJsxAttribute(ctx, node)("key") == null ? {
@@ -2131,7 +2106,7 @@ function create$29(ctx) {
 	function checkBlock(node) {
 		return ast.getNestedReturnStatements(node).filter((stmt) => stmt.argument != null).map((stmt) => check(stmt.argument)).filter((d) => d != null);
 	}
-	return {
+	return defineRuleListener({
 		ArrayExpression(node) {
 			if (inChildrenToArray) return;
 			const elements = node.elements.filter(ast.is(AST_NODE_TYPES.JSXElement));
@@ -2165,12 +2140,12 @@ function create$29(ctx) {
 				node
 			});
 		}
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/no-misused-capture-owner-stack.ts
-const RULE_NAME$28 = "no-misused-capture-owner-stack";
+const RULE_NAME$31 = "no-misused-capture-owner-stack";
 var no_misused_capture_owner_stack_default = createRule({
 	meta: {
 		type: "problem",
@@ -2181,14 +2156,14 @@ var no_misused_capture_owner_stack_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$28,
-	create: create$28,
+	name: RULE_NAME$31,
+	create: create$31,
 	defaultOptions: []
 });
-function create$28(context) {
+function create$31(context) {
 	if (!context.sourceCode.text.includes("captureOwnerStack")) return {};
 	const { importSource } = getSettingsFromContext(context);
-	return {
+	return defineRuleListener({
 		CallExpression(node) {
 			if (!core.isCaptureOwnerStackCall(context, node)) return;
 			if (ast.findParentNode(node, isDevelopmentOnlyCheck) == null) context.report({
@@ -2207,7 +2182,7 @@ function create$28(context) {
 				});
 			}
 		}
-	};
+	});
 }
 function isDevelopmentOnlyCheck(node) {
 	if (node.type !== AST_NODE_TYPES.IfStatement) return false;
@@ -2216,7 +2191,7 @@ function isDevelopmentOnlyCheck(node) {
 
 //#endregion
 //#region src/rules/no-nested-component-definitions.ts
-const RULE_NAME$27 = "no-nested-component-definitions";
+const RULE_NAME$30 = "no-nested-component-definitions";
 var no_nested_component_definitions_default = createRule({
 	meta: {
 		type: "problem",
@@ -2224,11 +2199,11 @@ var no_nested_component_definitions_default = createRule({
 		messages: { default: "Do not nest component definitions inside other components or props. {{suggestion}}" },
 		schema: []
 	},
-	name: RULE_NAME$27,
-	create: create$27,
+	name: RULE_NAME$30,
+	create: create$30,
 	defaultOptions: []
 });
-function create$27(context) {
+function create$30(context) {
 	const hint = core.ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.ComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.ComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
 	const fCollector = core.useComponentCollector(context, { hint });
 	const cCollector = core.useComponentCollectorLegacy(context);
@@ -2333,7 +2308,7 @@ function isInsideCreateElementProps(context, node) {
 
 //#endregion
 //#region src/rules/no-nested-lazy-component-declarations.ts
-const RULE_NAME$26 = "no-nested-lazy-component-declarations";
+const RULE_NAME$29 = "no-nested-lazy-component-declarations";
 var no_nested_lazy_component_declarations_default = createRule({
 	meta: {
 		type: "problem",
@@ -2341,11 +2316,11 @@ var no_nested_lazy_component_declarations_default = createRule({
 		messages: { default: "Do not declare lazy components inside other components. Instead, always declare them at the top level of your module." },
 		schema: []
 	},
-	name: RULE_NAME$26,
-	create: create$26,
+	name: RULE_NAME$29,
+	create: create$29,
 	defaultOptions: []
 });
-function create$26(context) {
+function create$29(context) {
 	const hint = core.ComponentDetectionHint.None;
 	const collector = core.useComponentCollector(context, { hint });
 	const collectorLegacy = core.useComponentCollectorLegacy(context);
@@ -2374,7 +2349,7 @@ function create$26(context) {
 
 //#endregion
 //#region src/rules/no-redundant-should-component-update.ts
-const RULE_NAME$25 = "no-redundant-should-component-update";
+const RULE_NAME$28 = "no-redundant-should-component-update";
 function isShouldComponentUpdate(node) {
 	return ast.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
@@ -2385,11 +2360,11 @@ var no_redundant_should_component_update_default = createRule({
 		messages: { default: "'{{componentName}}' does not need 'shouldComponentUpdate' when extending 'React.PureComponent'." },
 		schema: []
 	},
-	name: RULE_NAME$25,
-	create: create$25,
+	name: RULE_NAME$28,
+	create: create$28,
 	defaultOptions: []
 });
-function create$25(context) {
+function create$28(context) {
 	if (!context.sourceCode.text.includes("shouldComponentUpdate")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2407,7 +2382,7 @@ function create$25(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-did-mount.ts
-const RULE_NAME$24 = "no-set-state-in-component-did-mount";
+const RULE_NAME$27 = "no-set-state-in-component-did-mount";
 var no_set_state_in_component_did_mount_default = createRule({
 	meta: {
 		type: "problem",
@@ -2415,13 +2390,13 @@ var no_set_state_in_component_did_mount_default = createRule({
 		messages: { default: "Do not call `this.setState` in `componentDidMount` outside functions such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$24,
-	create: create$24,
+	name: RULE_NAME$27,
+	create: create$27,
 	defaultOptions: []
 });
-function create$24(context) {
+function create$27(context) {
 	if (!context.sourceCode.text.includes("componentDidMount")) return {};
-	return { CallExpression(node) {
+	return defineRuleListener({ CallExpression(node) {
 		if (!core.isThisSetState(node)) return;
 		const enclosingClassNode = ast.findParentNode(node, core.isClassComponent);
 		const enclosingMethodNode = ast.findParentNode(node, (n) => n === enclosingClassNode || core.isComponentDidMount(n));
@@ -2432,12 +2407,12 @@ function create$24(context) {
 			messageId: "default",
 			node
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-set-state-in-component-did-update.ts
-const RULE_NAME$23 = "no-set-state-in-component-did-update";
+const RULE_NAME$26 = "no-set-state-in-component-did-update";
 var no_set_state_in_component_did_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -2445,13 +2420,13 @@ var no_set_state_in_component_did_update_default = createRule({
 		messages: { default: "Do not call `this.setState` in `componentDidUpdate` outside functions such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$23,
-	create: create$23,
+	name: RULE_NAME$26,
+	create: create$26,
 	defaultOptions: []
 });
-function create$23(context) {
+function create$26(context) {
 	if (!context.sourceCode.text.includes("componentDidUpdate")) return {};
-	return { CallExpression(node) {
+	return defineRuleListener({ CallExpression(node) {
 		if (!core.isThisSetState(node)) return;
 		const enclosingClassNode = ast.findParentNode(node, core.isClassComponent);
 		const enclosingMethodNode = ast.findParentNode(node, (n) => n === enclosingClassNode || core.isComponentDidUpdate(n));
@@ -2462,12 +2437,12 @@ function create$23(context) {
 			messageId: "default",
 			node
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-set-state-in-component-will-update.ts
-const RULE_NAME$22 = "no-set-state-in-component-will-update";
+const RULE_NAME$25 = "no-set-state-in-component-will-update";
 var no_set_state_in_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -2475,13 +2450,13 @@ var no_set_state_in_component_will_update_default = createRule({
 		messages: { default: "Do not call `this.setState` in `componentWillUpdate` outside functions such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$22,
-	create: create$22,
+	name: RULE_NAME$25,
+	create: create$25,
 	defaultOptions: []
 });
-function create$22(context) {
+function create$25(context) {
 	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
-	return { CallExpression(node) {
+	return defineRuleListener({ CallExpression(node) {
 		if (!core.isThisSetState(node)) return;
 		const enclosingClassNode = ast.findParentNode(node, core.isClassComponent);
 		const enclosingMethodNode = ast.findParentNode(node, (n) => n === enclosingClassNode || core.isComponentWillUpdate(n));
@@ -2492,12 +2467,12 @@ function create$22(context) {
 			messageId: "default",
 			node
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-unnecessary-use-callback.ts
-const RULE_NAME$21 = "no-unnecessary-use-callback";
+const RULE_NAME$24 = "no-unnecessary-use-callback";
 var no_unnecessary_use_callback_default = createRule({
 	meta: {
 		type: "problem",
@@ -2508,13 +2483,13 @@ var no_unnecessary_use_callback_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$21,
-	create: create$21,
+	name: RULE_NAME$24,
+	create: create$24,
 	defaultOptions: []
 });
-function create$21(context) {
+function create$24(context) {
 	if (!context.sourceCode.text.includes("useCallback")) return {};
-	return { VariableDeclarator(node) {
+	return defineRuleListener({ VariableDeclarator(node) {
 		const { id, init } = node;
 		if (id.type !== AST_NODE_TYPES.Identifier || init?.type !== AST_NODE_TYPES.CallExpression || !core.isUseCallbackCall(init)) return;
 		const [cbk, ...rest] = context.sourceCode.getDeclaredVariables(node);
@@ -2526,7 +2501,7 @@ function create$21(context) {
 		const [arg0, arg1] = init.arguments;
 		if (arg0 == null || arg1 == null) return;
 		if (!match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variableNode = getVariableDefinitionNode(findVariable(n.name, scope), 0);
+			const variableNode = getVariableInitializer(findVariable(n.name, scope), 0);
 			if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) return false;
 			return variableNode.elements.length === 0;
 		}).otherwise(() => false)) {
@@ -2537,7 +2512,7 @@ function create$21(context) {
 			if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) return n.body;
 			return n;
 		}).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variableNode = getVariableDefinitionNode(findVariable(n.name, scope), 0);
+			const variableNode = getVariableInitializer(findVariable(n.name, scope), 0);
 			if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) return null;
 			return variableNode;
 		}).otherwise(() => null);
@@ -2550,7 +2525,7 @@ function create$21(context) {
 			return;
 		}
 		report(context)(checkForUsageInsideUseEffectReport);
-	} };
+	} });
 }
 function checkForUsageInsideUseEffect$1(sourceCode, node) {
 	if (!/use\w*Effect/u.test(sourceCode.text)) return;
@@ -2574,7 +2549,7 @@ function checkForUsageInsideUseEffect$1(sourceCode, node) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-memo.ts
-const RULE_NAME$20 = "no-unnecessary-use-memo";
+const RULE_NAME$23 = "no-unnecessary-use-memo";
 var no_unnecessary_use_memo_default = createRule({
 	meta: {
 		type: "problem",
@@ -2585,13 +2560,13 @@ var no_unnecessary_use_memo_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$20,
-	create: create$20,
+	name: RULE_NAME$23,
+	create: create$23,
 	defaultOptions: []
 });
-function create$20(context) {
+function create$23(context) {
 	if (!context.sourceCode.text.includes("useMemo")) return {};
-	return { VariableDeclarator(node) {
+	return defineRuleListener({ VariableDeclarator(node) {
 		const { id, init } = node;
 		if (id.type !== AST_NODE_TYPES.Identifier || init?.type !== AST_NODE_TYPES.CallExpression || !core.isUseMemoCall(init)) return;
 		const [mem, ...rest] = context.sourceCode.getDeclaredVariables(node);
@@ -2607,7 +2582,7 @@ function create$20(context) {
 			return;
 		}
 		if (!match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variableNode = getVariableDefinitionNode(findVariable(n.name, scope), 0);
+			const variableNode = getVariableInitializer(findVariable(n.name, scope), 0);
 			if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) return false;
 			return variableNode.elements.length === 0;
 		}).otherwise(() => false)) {
@@ -2618,7 +2593,7 @@ function create$20(context) {
 			if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) return n.body;
 			return n;
 		}).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variableNode = getVariableDefinitionNode(findVariable(n.name, scope), 0);
+			const variableNode = getVariableInitializer(findVariable(n.name, scope), 0);
 			if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) return null;
 			return variableNode;
 		}).otherwise(() => null);
@@ -2631,7 +2606,7 @@ function create$20(context) {
 			return;
 		}
 		report(context)(checkForUsageInsideUseEffectReport);
-	} };
+	} });
 }
 function checkForUsageInsideUseEffect(sourceCode, node) {
 	if (!/use\w*Effect/u.test(sourceCode.text)) return;
@@ -2655,7 +2630,7 @@ function checkForUsageInsideUseEffect(sourceCode, node) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-prefix.ts
-const RULE_NAME$19 = "no-unnecessary-use-prefix";
+const RULE_NAME$22 = "no-unnecessary-use-prefix";
 const WELL_KNOWN_HOOKS = ["useMDXComponents"];
 function containsUseComments(context, node) {
 	return context.sourceCode.getCommentsInside(node).some(({ value }) => /use\([\s\S]*?\)/u.test(value) || /use[A-Z0-9]\w*\([\s\S]*?\)/u.test(value));
@@ -2667,11 +2642,11 @@ var no_unnecessary_use_prefix_default = createRule({
 		messages: { default: "If your function doesn't call any Hooks, avoid the 'use' prefix. Instead, write it as a regular function without the 'use' prefix." },
 		schema: []
 	},
-	name: RULE_NAME$19,
-	create: create$19,
+	name: RULE_NAME$22,
+	create: create$22,
 	defaultOptions: []
 });
-function create$19(context) {
+function create$22(context) {
 	const { ctx, visitor } = core.useHookCollector(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
 		for (const { id, name, node, hookCalls } of ctx.getAllHooks(program)) {
@@ -2691,7 +2666,7 @@ function create$19(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-mount.ts
-const RULE_NAME$18 = "no-unsafe-component-will-mount";
+const RULE_NAME$21 = "no-unsafe-component-will-mount";
 var no_unsafe_component_will_mount_default = createRule({
 	meta: {
 		type: "problem",
@@ -2699,11 +2674,11 @@ var no_unsafe_component_will_mount_default = createRule({
 		messages: { default: "Do not use 'UNSAFE_componentWillMount'." },
 		schema: []
 	},
-	name: RULE_NAME$18,
-	create: create$18,
+	name: RULE_NAME$21,
+	create: create$21,
 	defaultOptions: []
 });
-function create$18(context) {
+function create$21(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillMount")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2719,7 +2694,7 @@ function create$18(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-receive-props.ts
-const RULE_NAME$17 = "no-unsafe-component-will-receive-props";
+const RULE_NAME$20 = "no-unsafe-component-will-receive-props";
 var no_unsafe_component_will_receive_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -2727,11 +2702,11 @@ var no_unsafe_component_will_receive_props_default = createRule({
 		messages: { default: "Do not use 'UNSAFE_componentWillReceiveProps'." },
 		schema: []
 	},
-	name: RULE_NAME$17,
-	create: create$17,
+	name: RULE_NAME$20,
+	create: create$20,
 	defaultOptions: []
 });
-function create$17(context) {
+function create$20(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillReceiveProps")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2747,7 +2722,7 @@ function create$17(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-update.ts
-const RULE_NAME$16 = "no-unsafe-component-will-update";
+const RULE_NAME$19 = "no-unsafe-component-will-update";
 var no_unsafe_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -2755,11 +2730,11 @@ var no_unsafe_component_will_update_default = createRule({
 		messages: { default: "Do not use 'UNSAFE_componentWillUpdate'." },
 		schema: []
 	},
-	name: RULE_NAME$16,
-	create: create$16,
+	name: RULE_NAME$19,
+	create: create$19,
 	defaultOptions: []
 });
-function create$16(context) {
+function create$19(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillUpdate")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2775,7 +2750,7 @@ function create$16(context) {
 
 //#endregion
 //#region src/rules/no-unstable-context-value.ts
-const RULE_NAME$15 = "no-unstable-context-value";
+const RULE_NAME$18 = "no-unstable-context-value";
 var no_unstable_context_value_default = createRule({
 	meta: {
 		type: "problem",
@@ -2783,13 +2758,14 @@ var no_unstable_context_value_default = createRule({
 		messages: { unstableContextValue: "A/an '{{kind}}' passed as the value prop to the context provider should not be constructed. It will change on every render. {{suggestion}}" },
 		schema: []
 	},
-	name: RULE_NAME$15,
-	create: create$15,
+	name: RULE_NAME$18,
+	create: create$18,
 	defaultOptions: []
 });
-function create$15(context) {
-	const { isCompilerEnabled, version } = getSettingsFromContext(context);
-	if (isCompilerEnabled && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
+function create$18(context) {
+	const { compilationMode, version } = getSettingsFromContext(context);
+	if (compilationMode === "infer" || compilationMode === "all") return {};
+	if (compilationMode === "annotation" && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
 	const isReact18OrBelow = compare(version, "19.0.0", "<");
 	const { ctx, visitor } = core.useComponentCollector(context);
 	const constructions = /* @__PURE__ */ new WeakMap();
@@ -2800,7 +2776,7 @@ function create$15(context) {
 			if (!isContextName(selfName, isReact18OrBelow)) return;
 			const functionEntry = ctx.getCurrentEntry();
 			if (functionEntry == null) return;
-			if (isCompilerEnabled && ast.isDirectiveInFunction(functionEntry.node, "use memo")) return;
+			if (compilationMode === "annotation" && ast.isDirectiveInFunction(functionEntry.node, "use memo")) return;
 			const attribute = node.attributes.find((attribute) => attribute.type === AST_NODE_TYPES.JSXAttribute && attribute.name.name === "value");
 			if (attribute == null || !("value" in attribute)) return;
 			const value = attribute.value;
@@ -2812,18 +2788,20 @@ function create$15(context) {
 			getOrElseUpdate(constructions, functionEntry.node, () => []).push(construction);
 		},
 		"Program:exit"(program) {
-			for (const { node: component, directives } of ctx.getAllComponents(program)) for (const construction of constructions.get(component) ?? []) {
-				if (directives.some((d) => d.directive === "use memo")) return;
-				const { kind, node: constructionNode } = construction;
-				const suggestion = kind === "function" ? "Consider wrapping it in a useCallback hook." : "Consider wrapping it in a useMemo hook.";
-				context.report({
-					messageId: "unstableContextValue",
-					node: constructionNode,
-					data: {
-						kind: ast.getHumanReadableKind(constructionNode),
-						suggestion
-					}
-				});
+			for (const { node: component, directives } of ctx.getAllComponents(program)) {
+				if (compilationMode === "annotation" && directives.some((d) => d.directive === "use memo")) continue;
+				for (const construction of constructions.get(component) ?? []) {
+					const { kind, node: constructionNode } = construction;
+					const suggestion = kind === "function" ? "Consider wrapping it in a useCallback hook." : "Consider wrapping it in a useMemo hook.";
+					context.report({
+						messageId: "unstableContextValue",
+						node: constructionNode,
+						data: {
+							kind: ast.getHumanReadableKind(constructionNode),
+							suggestion
+						}
+					});
+				}
 			}
 		}
 	});
@@ -2836,9 +2814,9 @@ function isContextName(name, isReact18OrBelow) {
 
 //#endregion
 //#region src/rules/no-unstable-default-props.ts
-const RULE_NAME$14 = "no-unstable-default-props";
-const defaultOptions$1 = [{ safeDefaultProps: [] }];
-const schema$1 = [{
+const RULE_NAME$17 = "no-unstable-default-props";
+const defaultOptions$2 = [{ safeDefaultProps: [] }];
+const schema$2 = [{
 	type: "object",
 	additionalProperties: false,
 	properties: { safeDefaultProps: {
@@ -2851,11 +2829,11 @@ var no_unstable_default_props_default = createRule({
 		type: "problem",
 		docs: { description: "Prevents using referential-type values as default props in object destructuring." },
 		messages: { default: "A/an '{{kind}}' as default prop. This could lead to potential infinite render loop in React. Use a variable instead of '{{kind}}'." },
-		schema: schema$1
+		schema: schema$2
 	},
-	name: RULE_NAME$14,
-	create: create$14,
-	defaultOptions: defaultOptions$1
+	name: RULE_NAME$17,
+	create: create$17,
+	defaultOptions: defaultOptions$2
 });
 function extractIdentifier(node) {
 	if (node.type === AST_NODE_TYPES.NewExpression && node.callee.type === AST_NODE_TYPES.Identifier) return node.callee.name;
@@ -2865,9 +2843,10 @@ function extractIdentifier(node) {
 	}
 	return null;
 }
-function create$14(context, [options]) {
-	const { isCompilerEnabled } = getSettingsFromContext(context);
-	if (isCompilerEnabled && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
+function create$17(context, [options]) {
+	const { compilationMode } = getSettingsFromContext(context);
+	if (compilationMode === "infer" || compilationMode === "all") return {};
+	if (compilationMode === "annotation" && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
 	const { ctx, visitor } = core.useComponentCollector(context);
 	const declarators = /* @__PURE__ */ new WeakMap();
 	const { safeDefaultProps = [] } = options;
@@ -2910,7 +2889,7 @@ function create$14(context, [options]) {
 
 //#endregion
 //#region src/rules/no-unused-class-component-members.ts
-const RULE_NAME$13 = "no-unused-class-component-members";
+const RULE_NAME$16 = "no-unused-class-component-members";
 const LIFECYCLE_METHODS = new Set([
 	"componentDidCatch",
 	"componentDidMount",
@@ -2941,11 +2920,11 @@ var no_unused_class_component_members_default = createRule({
 		messages: { default: "Unused method or property '{{methodName}}'' of class '{{className}}'." },
 		schema: []
 	},
-	name: RULE_NAME$13,
-	create: create$13,
+	name: RULE_NAME$16,
+	create: create$16,
 	defaultOptions: []
 });
-function create$13(context) {
+function create$16(context) {
 	const classStack = [];
 	const methodStack = [];
 	const propertyDefs = /* @__PURE__ */ new WeakMap();
@@ -2987,7 +2966,7 @@ function create$13(context) {
 	function methodExit() {
 		methodStack.pop();
 	}
-	return {
+	return defineRuleListener({
 		ClassDeclaration: classEnter,
 		"ClassDeclaration:exit": classExit,
 		ClassExpression: classEnter,
@@ -3021,12 +3000,12 @@ function create$13(context) {
 				}
 			}
 		}
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/no-unused-props.ts
-const RULE_NAME$12 = "no-unused-props";
+const RULE_NAME$15 = "no-unused-props";
 var no_unused_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -3034,15 +3013,15 @@ var no_unused_props_default = createRule({
 		messages: { default: "Prop `{{name}}` is declared but never used" },
 		schema: []
 	},
-	name: RULE_NAME$12,
-	create: create$12,
+	name: RULE_NAME$15,
+	create: create$15,
 	defaultOptions: []
 });
-function create$12(context) {
+function create$15(context) {
 	const services = ESLintUtils.getParserServices(context, false);
+	const checker = services.program.getTypeChecker();
 	const { ctx, visitor } = core.useComponentCollector(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
-		const checker = services.program.getTypeChecker();
 		const totalDeclaredProps = /* @__PURE__ */ new Set();
 		const totalUsedProps = /* @__PURE__ */ new Set();
 		for (const component of ctx.getAllComponents(program)) {
@@ -3117,7 +3096,9 @@ function collectUsedPropKeysOfReference(context, usedPropKeys, identifier, ref)
 function getKeyOfExpression(expr) {
 	switch (expr.type) {
 		case AST_NODE_TYPES.Identifier: return expr.name;
-		case AST_NODE_TYPES.Literal: if (typeof expr.value === "string") return expr.value;
+		case AST_NODE_TYPES.Literal:
+			if (typeof expr.value === "string") return expr.value;
+			break;
 	}
 	return null;
 }
@@ -3136,7 +3117,7 @@ function reportUnusedProp(context, services, prop) {
 
 //#endregion
 //#region src/rules/no-unused-state.ts
-const RULE_NAME$11 = "no-unused-state";
+const RULE_NAME$14 = "no-unused-state";
 function isKeyLiteral(node, key) {
 	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
 		type: AST_NODE_TYPES.TemplateLiteral,
@@ -3150,11 +3131,11 @@ var no_unused_state_default = createRule({
 		messages: { default: "Unused class component state in '{{className}}'" },
 		schema: []
 	},
-	name: RULE_NAME$11,
-	create: create$11,
+	name: RULE_NAME$14,
+	create: create$14,
 	defaultOptions: []
 });
-function create$11(context) {
+function create$14(context) {
 	const classStack = [];
 	const methodStack = [];
 	const constructorStack = [];
@@ -3202,7 +3183,7 @@ function create$11(context) {
 	function constructorExit() {
 		constructorStack.pop();
 	}
-	return {
+	return defineRuleListener({
 		AssignmentExpression(node) {
 			if (!core.isAssignmentToThisState(node)) return;
 			const currentClass = classStack.at(-1);
@@ -3258,12 +3239,12 @@ function create$11(context) {
 				isUsed: true
 			});
 		}
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/no-use-context.ts
-const RULE_NAME$10 = "no-use-context";
+const RULE_NAME$13 = "no-use-context";
 var no_use_context_default = createRule({
 	meta: {
 		type: "problem",
@@ -3272,16 +3253,16 @@ var no_use_context_default = createRule({
 		messages: { default: "In React 19, 'use' is preferred over 'useContext' because it is more flexible." },
 		schema: []
 	},
-	name: RULE_NAME$10,
-	create: create$10,
+	name: RULE_NAME$13,
+	create: create$13,
 	defaultOptions: []
 });
-function create$10(context) {
+function create$13(context) {
 	if (!context.sourceCode.text.includes("useContext")) return {};
 	const settings = getSettingsFromContext(context);
 	if (compare(settings.version, "19.0.0", "<")) return {};
 	const hookCalls = /* @__PURE__ */ new Set();
-	return {
+	return defineRuleListener({
 		CallExpression(node) {
 			if (!core.isHookCall(node)) return;
 			hookCalls.add(node);
@@ -3328,7 +3309,7 @@ function create$10(context) {
 				});
 			}
 		}
-	};
+	});
 }
 function getCorrelativeTokens(context, node) {
 	const tokenBefore = context.sourceCode.getTokenBefore(node);
@@ -3341,7 +3322,7 @@ function getCorrelativeTokens(context, node) {
 
 //#endregion
 //#region src/rules/no-useless-forward-ref.ts
-const RULE_NAME$9 = "no-useless-forward-ref";
+const RULE_NAME$12 = "no-useless-forward-ref";
 var no_useless_forward_ref_default = createRule({
 	meta: {
 		type: "problem",
@@ -3349,12 +3330,12 @@ var no_useless_forward_ref_default = createRule({
 		messages: { default: "A 'forwardRef' is used with this component but no 'ref' parameter is set." },
 		schema: []
 	},
-	name: RULE_NAME$9,
-	create: create$9,
+	name: RULE_NAME$12,
+	create: create$12,
 	defaultOptions: []
 });
-function create$9(context) {
-	return { CallExpression(node) {
+function create$12(context) {
+	return defineRuleListener({ CallExpression(node) {
 		if (!core.isForwardRefCall(context, node)) return;
 		const [component] = node.arguments;
 		if (component == null || !ast.isFunction(component)) return;
@@ -3363,17 +3344,17 @@ function create$9(context) {
 			messageId: "default",
 			node: node.callee
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/no-useless-fragment.ts
-const RULE_NAME$8 = "no-useless-fragment";
-const defaultOptions = [{
+const RULE_NAME$11 = "no-useless-fragment";
+const defaultOptions$1 = [{
 	allowEmptyFragment: false,
 	allowExpressions: true
 }];
-const schema = [{
+const schema$1 = [{
 	type: "object",
 	additionalProperties: false,
 	properties: {
@@ -3390,17 +3371,17 @@ const schema = [{
 var no_useless_fragment_default = createRule({
 	meta: {
 		type: "problem",
-		defaultOptions: [...defaultOptions],
+		defaultOptions: [...defaultOptions$1],
 		docs: { description: "Disallows useless fragment elements." },
 		fixable: "code",
 		messages: { default: "A fragment {{reason}} is useless." },
-		schema
+		schema: schema$1
 	},
-	name: RULE_NAME$8,
-	create: create$8,
-	defaultOptions
+	name: RULE_NAME$11,
+	create: create$11,
+	defaultOptions: defaultOptions$1
 });
-function create$8(context, [option]) {
+function create$11(context, [option]) {
 	const { allowEmptyFragment = false, allowExpressions = true } = option;
 	const jsxConfig = {
 		...core.getJsxConfigFromContext(context),
@@ -3473,7 +3454,7 @@ function create$8(context, [option]) {
 		if (node.children.length === 0) return false;
 		return !node.children.some((child) => core.isJsxText(child) && !isWhiteSpace(child) || ast.is(AST_NODE_TYPES.JSXExpressionContainer)(child));
 	}
-	return {
+	return defineRuleListener({
 		JSXElement(node) {
 			if (!core.isJsxFragmentElement(context, node, jsxConfig)) return;
 			checkNode(context, node);
@@ -3481,7 +3462,7 @@ function create$8(context, [option]) {
 		JSXFragment(node) {
 			checkNode(context, node);
 		}
-	};
+	});
 }
 /**
 * Check if a Literal or JSXText node is whitespace
@@ -3508,7 +3489,7 @@ function trimLikeReact(text) {
 
 //#endregion
 //#region src/rules/prefer-destructuring-assignment.ts
-const RULE_NAME$7 = "prefer-destructuring-assignment";
+const RULE_NAME$10 = "prefer-destructuring-assignment";
 var prefer_destructuring_assignment_default = createRule({
 	meta: {
 		type: "problem",
@@ -3516,11 +3497,11 @@ var prefer_destructuring_assignment_default = createRule({
 		messages: { default: "Use destructuring assignment for component props." },
 		schema: []
 	},
-	name: RULE_NAME$7,
-	create: create$7,
+	name: RULE_NAME$10,
+	create: create$10,
 	defaultOptions: []
 });
-function create$7(context) {
+function create$10(context) {
 	const { ctx, visitor } = core.useComponentCollector(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
 		for (const component of ctx.getAllComponents(program)) {
@@ -3544,7 +3525,7 @@ function create$7(context) {
 
 //#endregion
 //#region src/rules/prefer-namespace-import.ts
-const RULE_NAME$6 = "prefer-namespace-import";
+const RULE_NAME$9 = "prefer-namespace-import";
 var prefer_namespace_import_default = createRule({
 	meta: {
 		type: "problem",
@@ -3553,13 +3534,13 @@ var prefer_namespace_import_default = createRule({
 		messages: { default: "Prefer importing React as 'import * as React from \"{{importSource}}\"';" },
 		schema: []
 	},
-	name: RULE_NAME$6,
-	create: create$6,
+	name: RULE_NAME$9,
+	create: create$9,
 	defaultOptions: []
 });
-function create$6(context) {
+function create$9(context) {
 	const { importSource } = getSettingsFromContext(context);
-	return { [`ImportDeclaration[source.value="${importSource}"] ImportDefaultSpecifier`](node) {
+	return defineRuleListener({ [`ImportDeclaration[source.value="${importSource}"] ImportDefaultSpecifier`](node) {
 		const hasOtherSpecifiers = node.parent.specifiers.length > 1;
 		context.report({
 			messageId: "default",
@@ -3576,12 +3557,12 @@ function create$6(context) {
 				return fixer.replaceText(node.parent, [`${importStringPrefix} * as ${node.local.name} from ${importSourceQuoted}${semi}`, `${importStringPrefix} ${specifiers} from ${importSourceQuoted}${semi}`].join("\n"));
 			}
 		});
-	} };
+	} });
 }
 
 //#endregion
 //#region src/rules/prefer-read-only-props.ts
-const RULE_NAME$5 = "prefer-read-only-props";
+const RULE_NAME$8 = "prefer-read-only-props";
 var prefer_read_only_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -3589,11 +3570,11 @@ var prefer_read_only_props_default = createRule({
 		messages: { default: "A function component's props should be read-only." },
 		schema: []
 	},
-	name: RULE_NAME$5,
-	create: create$5,
+	name: RULE_NAME$8,
+	create: create$8,
 	defaultOptions: []
 });
-function create$5(context) {
+function create$8(context) {
 	const services = ESLintUtils.getParserServices(context, false);
 	const checker = services.program.getTypeChecker();
 	const { ctx, visitor } = core.useComponentCollector(context);
@@ -3632,55 +3613,9 @@ function isClassOrInterfaceReadonlyLoose(checker, type) {
 	});
 }
 
-//#endregion
-//#region src/rules/prefer-use-state-lazy-initialization.ts
-const RULE_NAME$4 = "prefer-use-state-lazy-initialization";
-const ALLOW_LIST = [
-	"Boolean",
-	"String",
-	"Number"
-];
-var prefer_use_state_lazy_initialization_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Enforces wrapping function calls made inside 'useState' in an 'initializer function'." },
-		messages: { default: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'." },
-		schema: []
-	},
-	name: RULE_NAME$4,
-	create: create$4,
-	defaultOptions: []
-});
-function create$4(context) {
-	return { CallExpression(node) {
-		if (!core.isUseStateCall(node)) return;
-		const [useStateInput] = node.arguments;
-		if (useStateInput == null) return;
-		for (const expr of ast.getNestedNewExpressions(useStateInput)) {
-			if (!("name" in expr.callee)) continue;
-			if (ALLOW_LIST.includes(expr.callee.name)) continue;
-			if (ast.findParentNode(expr, core.isUseCall) != null) continue;
-			context.report({
-				messageId: "default",
-				node: expr
-			});
-		}
-		for (const expr of ast.getNestedCallExpressions(useStateInput)) {
-			if (!("name" in expr.callee)) continue;
-			if (core.isHookName(expr.callee.name)) continue;
-			if (ALLOW_LIST.includes(expr.callee.name)) continue;
-			if (ast.findParentNode(expr, core.isUseCall) != null) continue;
-			context.report({
-				messageId: "default",
-				node: expr
-			});
-		}
-	} };
-}
-
 //#endregion
 //#region src/rules/purity.ts
-const RULE_NAME$3 = "purity";
+const RULE_NAME$7 = "purity";
 function isImpureMemberCall(node) {
 	if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return false;
 	const { object, property } = node.callee;
@@ -3712,11 +3647,11 @@ var purity_default = createRule({
 		messages: { default: "Do not call '{{name}}' during render. Components and hooks must be pure. Move this call into an event handler, effect, or state initializer." },
 		schema: []
 	},
-	name: RULE_NAME$3,
-	create: create$3,
+	name: RULE_NAME$7,
+	create: create$7,
 	defaultOptions: []
 });
-function create$3(context) {
+function create$7(context) {
 	const hCollector = core.useHookCollector(context);
 	const cCollector = core.useComponentCollector(context);
 	const cExprs = [];
@@ -3762,9 +3697,188 @@ function create$3(context) {
 	});
 }
 
+//#endregion
+//#region src/rules/refs.ts
+const RULE_NAME$6 = "refs";
+function isWriteAccess(node) {
+	const { parent } = node;
+	if (parent.type === AST_NODE_TYPES.AssignmentExpression && parent.left === node) return true;
+	if (parent.type === AST_NODE_TYPES.UpdateExpression && parent.argument === node) return true;
+	return false;
+}
+function isInsideNestedFunction(node, boundary) {
+	let current = node.parent;
+	while (current != null && current !== boundary) {
+		if (ast.isFunction(current)) return true;
+		current = current.parent;
+	}
+	return false;
+}
+/**
+* Check if a ref.current access is part of a lazy initialization pattern.
+*
+* Standard:
+*   if (ref.current === null) { ref.current = value; }
+*
+* Inverted (with early return):
+*   if (ref.current !== null) { return ...; }
+*   ref.current = computeValue();
+* @param node The MemberExpression node for ref.current
+* @param isWrite Whether this access is a write (assignment/update) or a read
+* @returns true if this access is part of a lazy initialization pattern and should be allowed during render
+*/
+function isPartOfLazyInitialization(node, isWrite) {
+	if (node.object.type !== AST_NODE_TYPES.Identifier) return false;
+	const refName = node.object.name;
+	if (isInNullCheckTest(node)) return true;
+	if (findEnclosingRefNullCheckIf(node, refName) != null) return true;
+	if (isWrite && isWriteAfterNullCheckIf(node, refName)) return true;
+	return false;
+}
+function isNullCheckOperator(operator) {
+	return operator === "===" || operator === "==" || operator === "!==" || operator === "!=";
+}
+/**
+* Check if a test expression is a null check on `ref.current` for a given ref name.
+* @param test The test expression to check
+* @param refName The name of the ref variable (e.g. "myRef") to check against
+* @returns true if the test is of the form `ref.current === null` or `null === ref.current`
+*/
+function isRefCurrentNullCheck(test, refName) {
+	if (test.type !== AST_NODE_TYPES.BinaryExpression) return false;
+	if (!isNullCheckOperator(test.operator)) return false;
+	const { left, right } = test;
+	const isRefSide = (side) => side.type === AST_NODE_TYPES.MemberExpression && side.object.type === AST_NODE_TYPES.Identifier && side.object.name === refName && side.property.type === AST_NODE_TYPES.Identifier && side.property.name === "current";
+	const isNullSide = (side) => side.type === AST_NODE_TYPES.Literal && side.value == null;
+	return isRefSide(left) && isNullSide(right) || isRefSide(right) && isNullSide(left);
+}
+/**
+* Check if the node is the operand of a `ref.current === null` test inside an IfStatement.
+* @param node The MemberExpression node for ref.current
+* @returns true if the node is part of a null check test in an if statement
+*/
+function isInNullCheckTest(node) {
+	const { parent } = node;
+	if (parent.type !== AST_NODE_TYPES.BinaryExpression) return false;
+	if (!isNullCheckOperator(parent.operator)) return false;
+	const otherSide = parent.left === node ? parent.right : parent.left;
+	if (otherSide.type !== AST_NODE_TYPES.Literal || otherSide.value != null) return false;
+	return parent.parent.type === AST_NODE_TYPES.IfStatement && parent.parent.test === parent;
+}
+/**
+* Walk up from the node to find a containing IfStatement whose test is a null-check
+* on `ref.current` with the given ref name.
+* @param node The MemberExpression node for ref.current
+* @param refName The name of the ref variable (e.g. "myRef") to check against
+* @returns the enclosing IfStatement node if found, or null if not found
+*/
+function findEnclosingRefNullCheckIf(node, refName) {
+	let current = node.parent;
+	while (current != null) {
+		if (current.type === AST_NODE_TYPES.IfStatement) return isRefCurrentNullCheck(current.test, refName) ? current : null;
+		switch (current.type) {
+			case AST_NODE_TYPES.ExpressionStatement:
+			case AST_NODE_TYPES.BlockStatement:
+			case AST_NODE_TYPES.ReturnStatement:
+			case AST_NODE_TYPES.JSXExpressionContainer:
+			case AST_NODE_TYPES.JSXElement:
+			case AST_NODE_TYPES.JSXOpeningElement:
+			case AST_NODE_TYPES.JSXClosingElement:
+			case AST_NODE_TYPES.AssignmentExpression:
+			case AST_NODE_TYPES.VariableDeclaration:
+			case AST_NODE_TYPES.VariableDeclarator:
+			case AST_NODE_TYPES.MemberExpression:
+			case AST_NODE_TYPES.ChainExpression:
+			case AST_NODE_TYPES.CallExpression: break;
+			default: return null;
+		}
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Check if a write to `ref.current` comes after a sibling if-statement that null-checks
+* the same ref (inverted lazy init with early return pattern):
+*
+*   if (ref.current !== null) { return ...; }
+*   ref.current = value; // ← this write
+* @param node The MemberExpression node for ref.current being written to
+* @param refName The name of the ref variable (e.g. "myRef") to check against
+* @returns true if there is a preceding sibling if-statement that null-checks the same ref
+*/
+function isWriteAfterNullCheckIf(node, refName) {
+	let stmt = node;
+	while (stmt.parent != null && stmt.parent.type !== AST_NODE_TYPES.BlockStatement) stmt = stmt.parent;
+	if (stmt.parent?.type !== AST_NODE_TYPES.BlockStatement) return false;
+	const block = stmt.parent;
+	const stmtIdx = block.body.indexOf(stmt);
+	if (stmtIdx < 0) return false;
+	for (let i = stmtIdx - 1; i >= 0; i--) {
+		const sibling = block.body[i];
+		if (sibling == null) continue;
+		if (sibling.type === AST_NODE_TYPES.IfStatement && isRefCurrentNullCheck(sibling.test, refName)) return true;
+	}
+	return false;
+}
+var refs_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Validates correct usage of refs by checking that 'ref.current' is not read or written during render." },
+		messages: {
+			readDuringRender: "Do not read 'ref.current' during render. Refs are not available during rendering and their values may be stale or inconsistent. Move this read into an effect or event handler.",
+			writeDuringRender: "Do not write to 'ref.current' during render. Refs should only be mutated in effects or event handlers. Move this write into an effect or event handler."
+		},
+		schema: []
+	},
+	name: RULE_NAME$6,
+	create: create$6,
+	defaultOptions: []
+});
+function create$6(context) {
+	const hCollector = core.useHookCollector(context);
+	const cCollector = core.useComponentCollector(context);
+	const refAccesses = [];
+	const jsxRefIdentifiers = /* @__PURE__ */ new Set();
+	function isRefIdentifier(node) {
+		if (node.type !== AST_NODE_TYPES.Identifier) return false;
+		if (core.isRefLikeName(node.name)) return true;
+		if (jsxRefIdentifiers.has(node.name)) return true;
+		return core.isInitializedFromRef(node.name, context.sourceCode.getScope(node));
+	}
+	return defineRuleListener(hCollector.visitor, cCollector.visitor, {
+		JSXAttribute(node) {
+			if (node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === "ref" && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.Identifier) jsxRefIdentifiers.add(node.value.expression.name);
+		},
+		MemberExpression(node) {
+			if (node.property.type !== AST_NODE_TYPES.Identifier || node.property.name !== "current") return;
+			refAccesses.push({
+				node,
+				isWrite: isWriteAccess(node)
+			});
+		},
+		"Program:exit"(program) {
+			const components = cCollector.ctx.getAllComponents(program);
+			const hooks = hCollector.ctx.getAllHooks(program);
+			const componentAndHookFns = new Set([...components.map((c) => c.node), ...hooks.map((h) => h.node)]);
+			const isComponentOrHookFn = (n) => ast.isFunction(n) && componentAndHookFns.has(n);
+			for (const { node, isWrite } of refAccesses) {
+				if (!isRefIdentifier(node.object)) continue;
+				const boundary = ast.findParentNode(node, isComponentOrHookFn);
+				if (boundary == null) continue;
+				if (isInsideNestedFunction(node, boundary)) continue;
+				if (isPartOfLazyInitialization(node, isWrite)) continue;
+				context.report({
+					messageId: isWrite ? "writeDuringRender" : "readDuringRender",
+					node
+				});
+			}
+		}
+	});
+}
+
 //#endregion
 //#region src/rules/rules-of-hooks.ts
-const RULE_NAME$2 = "rules-of-hooks";
+const RULE_NAME$5 = "rules-of-hooks";
 var rules_of_hooks_default = createRule({
 	meta: {
 		type: "problem",
@@ -3782,8 +3896,8 @@ var rules_of_hooks_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$2,
-	create: create$2,
+	name: RULE_NAME$5,
+	create: create$5,
 	defaultOptions: []
 });
 function getHookName(node) {
@@ -3818,7 +3932,7 @@ function isLoopNode(node) {
 function isTryCatchNode(node) {
 	return node.type === AST_NODE_TYPES.TryStatement;
 }
-function create$2(context) {
+function create$5(context) {
 	const functionStack = [];
 	function findEnclosingComponentOrHook() {
 		for (let i = functionStack.length - 1; i >= 0; i--) {
@@ -3934,7 +4048,7 @@ function create$2(context) {
 			return;
 		}
 	}
-	return {
+	return defineRuleListener({
 		":function"(node) {
 			const kind = getFunctionEntryKind(node);
 			functionStack.push({
@@ -3966,24 +4080,24 @@ function create$2(context) {
 			const idx = body.indexOf(stmt);
 			if (idx !== -1 && idx < body.length - 1) entry.hasEarlyReturn = true;
 		}
-	};
+	});
 }
 
 //#endregion
 //#region src/rules/set-state-in-effect.ts
-const RULE_NAME$1 = "set-state-in-effect";
+const RULE_NAME$4 = "set-state-in-effect";
 var set_state_in_effect_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Validates against calling ['setState'](https://react.dev/reference/react/useState#setstate) synchronously in an effect, which can lead to re-renders that degrade performance." },
+		docs: { description: "Validates against setting state synchronously in an effect, which can lead to re-renders that degrade performance." },
 		messages: { default: "Do not call the 'set' function '{{name}}' of 'useState' synchronously in an effect. This can lead to unnecessary re-renders and performance issues." },
 		schema: []
 	},
-	name: RULE_NAME$1,
-	create: create$1,
+	name: RULE_NAME$4,
+	create: create$4,
 	defaultOptions: []
 });
-function create$1(context) {
+function create$4(context) {
 	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
 	const { additionalStateHooks } = getSettingsFromContext(context);
 	const functionEntries = [];
@@ -4028,7 +4142,7 @@ function create$1(context) {
 		}
 	}
 	function isIdFromUseStateCall(topLevelId, at) {
-		const variableNode = getVariableDefinitionNode(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
+		const variableNode = getVariableInitializer(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
 		if (variableNode == null) return false;
 		if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
 		if (!isUseStateCall(variableNode)) return false;
@@ -4056,7 +4170,18 @@ function create$1(context) {
 			default: return false;
 		}
 	}
-	return {
+	function isHookDecl(node) {
+		if (node.type !== AST_NODE_TYPES.VariableDeclarator) return false;
+		if (node.id.type !== AST_NODE_TYPES.Identifier) return false;
+		const init = node.init;
+		if (init == null || init.type !== AST_NODE_TYPES.CallExpression) return false;
+		switch (init.callee.type) {
+			case AST_NODE_TYPES.Identifier: return core.isHookName(init.callee.name);
+			case AST_NODE_TYPES.MemberExpression: return init.callee.property.type === AST_NODE_TYPES.Identifier && core.isHookName(init.callee.property.name);
+			default: return false;
+		}
+	}
+	return defineRuleListener({
 		":function"(node) {
 			const kind = getFunctionKind(node);
 			functionEntries.push({
@@ -4079,15 +4204,31 @@ function create$1(context) {
 					case entry.kind === "deferred":
 					case entry.node.async: break;
 					case entry.node === setupFunction:
-					case entry.kind === "immediate" && ast.findParentNode(entry.node, ast.isFunction) === setupFunction:
+					case entry.kind === "immediate" && ast.findParentNode(entry.node, ast.isFunction) === setupFunction: {
+						const args0 = node.arguments.at(0);
+						if (args0 == null) return;
+						function isArgumentUsingRefValue(context, node) {
+							const isUsingRefValue = (n) => {
+								switch (n.type) {
+									case AST_NODE_TYPES.Identifier: return core.isInitializedFromRef(n.name, context.sourceCode.getScope(n));
+									case AST_NODE_TYPES.MemberExpression: return isUsingRefValue(n.object);
+									case AST_NODE_TYPES.CallExpression: return isUsingRefValue(n.callee) || ast.getNestedIdentifiers(n).some(isUsingRefValue);
+									default: return false;
+								}
+							};
+							if (isUsingRefValue(node)) return true;
+							return ast.isFunction(node) && context.sourceCode.getScope(node.body).references.some((r) => isUsingRefValue(r.identifier));
+						}
+						if (isArgumentUsingRefValue(context, args0)) return;
 						context.report({
 							messageId: "default",
 							node,
 							data: { name: context.sourceCode.getText(node.callee) }
 						});
 						return;
+					}
 					default: {
-						const init = ast.findParentNode(node, isVariableDeclaratorFromHookCall)?.init;
+						const init = ast.findParentNode(node, isHookDecl)?.init;
 						if (init == null) getOrElseUpdate(setStateCallsByFn, entry.node, () => []).push(node);
 						else getOrElseUpdate(setStateInHookCallbacks, init, () => []).push(node);
 					}
@@ -4108,14 +4249,14 @@ function create$1(context) {
 					const parent = node.parent.parent;
 					if (parent.type !== AST_NODE_TYPES.CallExpression) break;
 					if (!core.isUseMemoCall(parent)) break;
-					const init = ast.findParentNode(parent, isVariableDeclaratorFromHookCall)?.init;
+					const init = ast.findParentNode(parent, isHookDecl)?.init;
 					if (init != null) getOrElseUpdate(setStateInEffectArg, init, () => []).push(node);
 					break;
 				}
 				case AST_NODE_TYPES.CallExpression:
 					if (node !== node.parent.arguments.at(0)) break;
 					if (core.isUseCallbackCall(node.parent)) {
-						const init = ast.findParentNode(node.parent, isVariableDeclaratorFromHookCall)?.init;
+						const init = ast.findParentNode(node.parent, isHookDecl)?.init;
 						if (init != null) getOrElseUpdate(setStateInEffectArg, init, () => []).push(node);
 						break;
 					}
@@ -4124,7 +4265,7 @@ function create$1(context) {
 		},
 		"Program:exit"() {
 			const getSetStateCalls = (id, initialScope) => {
-				const node = getVariableDefinitionNode(findVariable(id, initialScope), 0);
+				const node = getVariableInitializer(findVariable(id, initialScope), 0);
 				switch (node?.type) {
 					case AST_NODE_TYPES.ArrowFunctionExpression:
 					case AST_NODE_TYPES.FunctionDeclaration:
@@ -4157,25 +4298,12 @@ function create$1(context) {
 				});
 			}
 		}
-	};
-}
-function isInitFromHookCall(init) {
-	if (init?.type !== AST_NODE_TYPES.CallExpression) return false;
-	switch (init.callee.type) {
-		case AST_NODE_TYPES.Identifier: return core.isHookName(init.callee.name);
-		case AST_NODE_TYPES.MemberExpression: return init.callee.property.type === AST_NODE_TYPES.Identifier && core.isHookName(init.callee.property.name);
-		default: return false;
-	}
-}
-function isVariableDeclaratorFromHookCall(node) {
-	if (node.type !== AST_NODE_TYPES.VariableDeclarator) return false;
-	if (node.id.type !== AST_NODE_TYPES.Identifier) return false;
-	return isInitFromHookCall(node.init);
+	});
 }
 
 //#endregion
 //#region src/rules/set-state-in-render.ts
-const RULE_NAME = "set-state-in-render";
+const RULE_NAME$3 = "set-state-in-render";
 var set_state_in_render_default = createRule({
 	meta: {
 		type: "problem",
@@ -4183,11 +4311,11 @@ var set_state_in_render_default = createRule({
 		messages: { default: "Do not call the 'set' function '{{name}}' unconditionally during render. This will trigger an infinite render loop." },
 		schema: []
 	},
-	name: RULE_NAME,
-	create,
+	name: RULE_NAME$3,
+	create: create$3,
 	defaultOptions: []
 });
-function create(context) {
+function create$3(context) {
 	const { additionalStateHooks } = getSettingsFromContext(context);
 	const functionEntries = [];
 	const componentFnRef = { current: null };
@@ -4196,7 +4324,7 @@ function create(context) {
 		return core.isUseStateLikeCall(node, additionalStateHooks);
 	}
 	function isIdFromUseStateCall(topLevelId, at) {
-		const variableNode = getVariableDefinitionNode(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
+		const variableNode = getVariableInitializer(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
 		if (variableNode == null) return false;
 		if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
 		if (!isUseStateCall(variableNode)) return false;
@@ -4247,20 +4375,20 @@ function create(context) {
 		}
 		return false;
 	}
-	function isComponentLikeFunction(node) {
+	function isComponentOrHookLikeFunction(node) {
 		const id = ast.getFunctionId(node);
 		if (id == null) return false;
-		if (id.type === AST_NODE_TYPES.Identifier) return core.isComponentName(id.name);
-		if (id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) return core.isComponentName(id.property.name);
+		if (id.type === AST_NODE_TYPES.Identifier) return core.isComponentName(id.name) || core.isHookName(id.name);
+		if (id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) return core.isComponentName(id.property.name) || core.isHookName(id.property.name);
 		return false;
 	}
 	function getFunctionKind(node) {
-		if (isComponentLikeFunction(node)) return "component";
+		if (isComponentOrHookLikeFunction(node)) return "component";
 		const parent = ast.findParentNode(node, not(ast.isTypeExpression)) ?? node.parent;
 		if (parent.type === AST_NODE_TYPES.CallExpression && parent.callee !== node) return "callback";
 		return "other";
 	}
-	return {
+	return defineRuleListener({
 		":function"(node) {
 			const kind = getFunctionKind(node);
 			functionEntries.push({
@@ -4307,7 +4435,260 @@ function create(context) {
 			const idx = body.indexOf(stmt);
 			if (idx !== -1 && idx < body.length - 1) componentHasEarlyReturn.current = true;
 		}
-	};
+	});
+}
+
+//#endregion
+//#region src/rules/unsupported-syntax.ts
+const RULE_NAME$2 = "unsupported-syntax";
+var unsupported_syntax_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Validates against syntax that React Compiler does not support." },
+		messages: {
+			eval: "Do not use 'eval' inside components or hooks. 'eval' cannot be statically analyzed and is not supported by React Compiler.",
+			iife: "Do not use immediately-invoked function expressions in JSX. IIFEs will not be optimized by React Compiler.",
+			with: "Do not use 'with' statements inside components or hooks. 'with' changes scope dynamically and is not supported by React Compiler."
+		},
+		schema: []
+	},
+	name: RULE_NAME$2,
+	create: create$2,
+	defaultOptions: []
+});
+function isEvalCall(node) {
+	return node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === "eval";
+}
+function isIifeCall(node) {
+	return node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node;
+}
+function create$2(context) {
+	const hCollector = core.useHookCollector(context);
+	const cCollector = core.useComponentCollector(context);
+	const evalCalls = [];
+	const withStmts = [];
+	return defineRuleListener(hCollector.visitor, cCollector.visitor, {
+		CallExpression(node) {
+			if (!isEvalCall(node)) return;
+			const func = ast.findParentNode(node, ast.isFunction);
+			if (func == null) return;
+			evalCalls.push({
+				node,
+				func
+			});
+		},
+		"JSXElement :function"(node) {
+			if (isIifeCall(node)) context.report({
+				messageId: "iife",
+				node: node.parent
+			});
+		},
+		"JSXFragment :function"(node) {
+			if (isIifeCall(node)) context.report({
+				messageId: "iife",
+				node: node.parent
+			});
+		},
+		"Program:exit"(node) {
+			const components = cCollector.ctx.getAllComponents(node);
+			const hooks = hCollector.ctx.getAllHooks(node);
+			const funcs = [...components, ...hooks];
+			for (const { node, func } of evalCalls) {
+				if (!funcs.some((f) => f.node === func)) continue;
+				context.report({
+					messageId: "eval",
+					node
+				});
+			}
+			for (const { node, func } of withStmts) {
+				if (!funcs.some((f) => f.node === func)) continue;
+				context.report({
+					messageId: "with",
+					node
+				});
+			}
+		},
+		WithStatement(node) {
+			const func = ast.findParentNode(node, ast.isFunction);
+			if (func == null) return;
+			withStmts.push({
+				node,
+				func
+			});
+		}
+	});
+}
+
+//#endregion
+//#region src/rules/use-memo.ts
+const RULE_NAME$1 = "use-memo";
+var use_memo_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Validates that 'useMemo' is called with a callback that returns a value." },
+		messages: {
+			missingReturnValue: "The callback passed to 'useMemo' must return a value. Without a return value, 'useMemo' always returns 'undefined', which defeats its purpose.",
+			notAssignedToVariable: "The return value of 'useMemo' must be assigned to a variable. Calling 'useMemo' without capturing its return value is likely a mistake — use 'useEffect' for side effects instead."
+		},
+		schema: []
+	},
+	name: RULE_NAME$1,
+	create: create$1,
+	defaultOptions: []
+});
+function create$1(context) {
+	if (!context.sourceCode.text.includes("useMemo")) return {};
+	return defineRuleListener({ CallExpression(node) {
+		if (!core.isUseMemoCall(node)) return;
+		const parent = node.parent;
+		if (!(parent.type === AST_NODE_TYPES.VariableDeclarator || parent.type === AST_NODE_TYPES.AssignmentExpression || parent.type === AST_NODE_TYPES.AssignmentPattern || parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.ReturnStatement || parent.type === AST_NODE_TYPES.JSXExpressionContainer || parent.type === AST_NODE_TYPES.CallExpression || parent.type === AST_NODE_TYPES.NewExpression || parent.type === AST_NODE_TYPES.ArrayExpression || parent.type === AST_NODE_TYPES.ConditionalExpression || parent.type === AST_NODE_TYPES.LogicalExpression || parent.type === AST_NODE_TYPES.SequenceExpression || parent.type === AST_NODE_TYPES.SpreadElement || parent.type === AST_NODE_TYPES.TemplateLiteral || parent.type === AST_NODE_TYPES.BinaryExpression || parent.type === AST_NODE_TYPES.UnaryExpression || parent.type === AST_NODE_TYPES.MemberExpression || parent.type === AST_NODE_TYPES.TaggedTemplateExpression || parent.type === AST_NODE_TYPES.ChainExpression)) {
+			context.report({
+				messageId: "notAssignedToVariable",
+				node
+			});
+			return;
+		}
+		const [callbackArg] = node.arguments;
+		if (callbackArg == null) return;
+		if (!ast.isFunction(callbackArg)) return;
+		if (callbackArg.type === AST_NODE_TYPES.ArrowFunctionExpression && callbackArg.body.type !== AST_NODE_TYPES.BlockStatement) return;
+		if (callbackArg.body.type !== AST_NODE_TYPES.BlockStatement) return;
+		const returnStatements = ast.getNestedReturnStatements(callbackArg);
+		if (returnStatements.length === 0) {
+			context.report({
+				messageId: "missingReturnValue",
+				node: callbackArg
+			});
+			return;
+		}
+		if (!returnStatements.some((stmt) => stmt.argument != null)) context.report({
+			messageId: "missingReturnValue",
+			node: callbackArg
+		});
+	} });
+}
+
+//#endregion
+//#region src/rules/use-state.ts
+const RULE_NAME = "use-state";
+const defaultOptions = [{
+	enforceAssignment: true,
+	enforceLazyInitialization: true,
+	enforceSetterName: true
+}];
+const schema = [{
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		enforceAssignment: {
+			type: "boolean",
+			default: true
+		},
+		enforceLazyInitialization: {
+			type: "boolean",
+			default: true
+		},
+		enforceSetterName: {
+			type: "boolean",
+			default: true
+		}
+	}
+}];
+const LAZY_INIT_ALLOW_LIST = [
+	"Boolean",
+	"String",
+	"Number"
+];
+var use_state_default = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforces correct usage of 'useState', including destructuring, symmetric naming of the value and setter, and wrapping expensive initializers in a lazy initializer function." },
+		messages: {
+			invalidAssignment: "useState should be destructured into a value and setter pair, e.g., const [state, setState] = useState(...).",
+			invalidInitialization: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'.",
+			invalidSetterName: "The setter should be named 'set' followed by the capitalized state variable name, e.g., 'setState' for 'state'."
+		},
+		schema
+	},
+	name: RULE_NAME,
+	create,
+	defaultOptions
+});
+function create(context) {
+	if (!context.sourceCode.text.includes("useState")) return {};
+	const { enforceAssignment = true, enforceLazyInitialization = true, enforceSetterName = true } = context.options[0] ?? defaultOptions[0];
+	return defineRuleListener({ CallExpression(node) {
+		if (!core.isUseStateCall(node)) return;
+		if (enforceLazyInitialization) {
+			const [useStateInput] = node.arguments;
+			if (useStateInput != null) {
+				for (const expr of ast.getNestedNewExpressions(useStateInput)) {
+					if (!("name" in expr.callee)) continue;
+					if (LAZY_INIT_ALLOW_LIST.includes(expr.callee.name)) continue;
+					if (ast.findParentNode(expr, core.isUseCall) != null) continue;
+					context.report({
+						messageId: "invalidInitialization",
+						node: expr
+					});
+				}
+				for (const expr of ast.getNestedCallExpressions(useStateInput)) {
+					if (!("name" in expr.callee)) continue;
+					if (core.isHookName(expr.callee.name)) continue;
+					if (LAZY_INIT_ALLOW_LIST.includes(expr.callee.name)) continue;
+					if (ast.findParentNode(expr, core.isUseCall) != null) continue;
+					context.report({
+						messageId: "invalidInitialization",
+						node: expr
+					});
+				}
+			}
+		}
+		if (node.parent.type !== AST_NODE_TYPES.VariableDeclarator) {
+			if (!enforceAssignment) return;
+			context.report({
+				messageId: "invalidAssignment",
+				node
+			});
+			return;
+		}
+		const id = findEnclosingAssignmentTarget(node);
+		if (id?.type !== AST_NODE_TYPES.ArrayPattern) {
+			if (!enforceAssignment) return;
+			context.report({
+				messageId: "invalidAssignment",
+				node: id ?? node
+			});
+			return;
+		}
+		const [value, setter] = id.elements;
+		if (value == null) {
+			if (!enforceAssignment) return;
+			context.report({
+				messageId: "invalidAssignment",
+				node: id
+			});
+			return;
+		}
+		if (setter == null || !enforceSetterName) return;
+		if (value.type !== AST_NODE_TYPES.Identifier) {
+			context.report({
+				messageId: "invalidAssignment",
+				node: value
+			});
+			return;
+		}
+		if (setter.type !== AST_NODE_TYPES.Identifier || !setter.name.startsWith("set")) {
+			context.report({
+				messageId: "invalidSetterName",
+				node: setter
+			});
+			return;
+		}
+		if (snakeCase(setter.name) !== `set_${snakeCase(value.name)}`) context.report({
+			messageId: "invalidSetterName",
+			node: setter
+		});
+	} });
 }
 
 //#endregion
@@ -4325,7 +4706,6 @@ const plugin = {
 		"jsx-key-before-spread": jsx_key_before_spread_default,
 		"jsx-no-comment-textnodes": jsx_no_comment_textnodes_default,
 		"jsx-no-duplicate-props": jsx_no_duplicate_props_default,
-		"jsx-no-iife": jsx_no_iife_default,
 		"jsx-no-undef": jsx_no_undef_default,
 		"jsx-shorthand-boolean": jsx_shorthand_boolean_default,
 		"jsx-shorthand-fragment": jsx_shorthand_fragment_default,
@@ -4354,6 +4734,7 @@ const plugin = {
 		"no-missing-component-display-name": no_missing_component_display_name_default,
 		"no-missing-context-display-name": no_missing_context_display_name_default,
 		"no-missing-key": no_missing_key_default,
+		"use-memo": use_memo_default,
 		"no-misused-capture-owner-stack": no_misused_capture_owner_stack_default,
 		"no-nested-component-definitions": no_nested_component_definitions_default,
 		"no-nested-lazy-component-declarations": no_nested_lazy_component_declarations_default,
@@ -4378,11 +4759,13 @@ const plugin = {
 		"prefer-destructuring-assignment": prefer_destructuring_assignment_default,
 		"prefer-namespace-import": prefer_namespace_import_default,
 		"prefer-read-only-props": prefer_read_only_props_default,
-		"prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default,
 		purity: purity_default,
+		refs: refs_default,
 		"rules-of-hooks": rules_of_hooks_default,
 		"set-state-in-effect": set_state_in_effect_default,
-		"set-state-in-render": set_state_in_render_default
+		"set-state-in-render": set_state_in_render_default,
+		"unsupported-syntax": unsupported_syntax_default,
+		"use-state": use_state_default
 	}
 };
 
@@ -4420,6 +4803,8 @@ const rules$6 = {
 	"react-x/no-direct-mutation-state": "error",
 	"react-x/no-forward-ref": "warn",
 	"react-x/no-missing-key": "error",
+	"react-x/use-memo": "error",
+	"react-x/use-state": "warn",
 	"react-x/no-nested-component-definitions": "error",
 	"react-x/no-nested-lazy-component-declarations": "error",
 	"react-x/no-redundant-should-component-update": "error",
@@ -4432,11 +4817,11 @@ const rules$6 = {
 	"react-x/no-unsafe-component-will-update": "warn",
 	"react-x/no-use-context": "warn",
 	"react-x/no-useless-forward-ref": "warn",
-	"react-x/prefer-use-state-lazy-initialization": "warn",
 	"react-x/purity": "warn",
 	"react-x/rules-of-hooks": "error",
 	"react-x/set-state-in-effect": "warn",
-	"react-x/set-state-in-render": "error"
+	"react-x/set-state-in-render": "error",
+	"react-x/unsupported-syntax": "error"
 };
 const plugins$5 = { "react-x": plugin };
 const settings$5 = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };
@@ -4497,7 +4882,6 @@ var strict_exports = /* @__PURE__ */ __exportAll({
 const name$2 = "react-x/strict";
 const rules$2 = {
 	...rules$6,
-	"react-x/jsx-no-iife": "error",
 	"react-x/no-children-prop": "error",
 	"react-x/no-class-component": "error",
 	"react-x/no-misused-capture-owner-stack": "error",