oxlint-plugin-react-doctor 0.2.11-dev.f036b0f → 0.2.11-dev.f4035fc

package/dist/index.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { analyze } from "eslint-scope";
 import * as eslintVisitorKeys from "eslint-visitor-keys";
 import fs from "node:fs";
+import { parseSync } from "oxc-parser";
 //#region src/plugin/utils/is-testlike-filename.ts
 const NON_PRODUCTION_PATH_SEGMENTS = [
 	"/test/",
@@ -444,6 +445,13 @@ const REACT_HOC_NAMES = new Set([
 	"React.memo",
 	"React.forwardRef"
 ]);
+const MEMOIZING_HOOK_NAMES = new Set(["useMemo", "useCallback"]);
+const COMPONENT_HOC_WRAPPER_NAMES = new Set([
+	"memo",
+	"forwardRef",
+	"observer",
+	"lazy"
+]);
 const SUBSCRIPTION_METHOD_NAMES = new Set([
 	"subscribe",
 	"addEventListener",
@@ -1026,7 +1034,7 @@ const altText = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/anchor-ambiguous-text.ts
-const buildMessage$28 = (text) => `\`${text}\` is ambiguous link text — describe the destination instead (e.g. "View pricing details").`;
+const buildMessage$30 = (text) => `\`${text}\` is ambiguous link text — describe the destination instead (e.g. "View pricing details").`;
 const DEFAULT_AMBIGUOUS = [
 	"click here",
 	"here",
@@ -1083,14 +1091,14 @@ const anchorAmbiguousText = defineRule({
 			const normalized = normalizeText(accessibleText);
 			if (ambiguousSet.has(normalized)) context.report({
 				node: node.openingElement.name,
-				message: buildMessage$28(normalized)
+				message: buildMessage$30(normalized)
 			});
 		} };
 	}
 });
 //#endregion
 //#region src/plugin/rules/a11y/anchor-has-content.ts
-const MESSAGE$47 = "Anchor must have accessible content — provide visible text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$49 = "Anchor must have accessible content — provide visible text, `aria-label`, or `aria-labelledby`.";
 const anchorHasContent = defineRule({
 	id: "anchor-has-content",
 	tags: ["react-jsx-only"],
@@ -1105,7 +1113,7 @@ const anchorHasContent = defineRule({
 		for (const attribute of ["title", "aria-label"]) if (hasJsxPropIgnoreCase(opening.attributes, attribute)) return;
 		context.report({
 			node: opening.name,
-			message: MESSAGE$47
+			message: MESSAGE$49
 		});
 	} })
 });
@@ -1498,7 +1506,7 @@ const parseJsxValue = (value) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/aria-activedescendant-has-tabindex.ts
-const MESSAGE$46 = "An element with `aria-activedescendant` must be tabbable — add `tabIndex={0}` so it can receive focus.";
+const MESSAGE$48 = "An element with `aria-activedescendant` must be tabbable — add `tabIndex={0}` so it can receive focus.";
 const ariaActivedescendantHasTabindex = defineRule({
 	id: "aria-activedescendant-has-tabindex",
 	tags: ["react-jsx-only"],
@@ -1515,14 +1523,14 @@ const ariaActivedescendantHasTabindex = defineRule({
 			if (tabIndexValue === null || tabIndexValue >= -1) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$46
+				message: MESSAGE$48
 			});
 			return;
 		}
 		if (isInteractiveElement(tag, node)) return;
 		context.report({
 			node: node.name,
-			message: MESSAGE$46
+			message: MESSAGE$48
 		});
 	} })
 });
@@ -1662,7 +1670,7 @@ const ARIA_PROPERTIES = new Map([
 const isValidAriaProperty = (name) => ARIA_PROPERTIES.has(name);
 //#endregion
 //#region src/plugin/rules/a11y/aria-props.ts
-const buildMessage$27 = (name) => `\`${name}\` is not a valid ARIA property — check WAI-ARIA spec.`;
+const buildMessage$29 = (name) => `\`${name}\` is not a valid ARIA property — check WAI-ARIA spec.`;
 const ariaProps = defineRule({
 	id: "aria-props",
 	tags: ["react-jsx-only"],
@@ -1675,7 +1683,7 @@ const ariaProps = defineRule({
 		if (!name || !name.startsWith("aria-")) return;
 		if (!isValidAriaProperty(name)) context.report({
 			node: node.name,
-			message: buildMessage$27(name)
+			message: buildMessage$29(name)
 		});
 	} })
 });
@@ -1826,7 +1834,7 @@ const buildExpectedDescription = (propType) => {
 		case "token-list": return `a space-separated list of: ${propType.tokens.join(", ")}`;
 	}
 };
-const buildMessage$26 = (propName, propType) => `\`${propName}\` value must be ${buildExpectedDescription(propType)}.`;
+const buildMessage$28 = (propName, propType) => `\`${propName}\` value must be ${buildExpectedDescription(propType)}.`;
 const allowNoneValue = (propType) => {
 	switch (propType.kind) {
 		case "boolean":
@@ -1959,13 +1967,13 @@ const ariaProptypes = defineRule({
 		if (!node.value) {
 			if (!allowNoneValue(propType)) context.report({
 				node,
-				message: buildMessage$26(propName, propType)
+				message: buildMessage$28(propName, propType)
 			});
 			return;
 		}
 		if (!isValidValueForType(propType, node.value)) context.report({
 			node,
-			message: buildMessage$26(propName, propType)
+			message: buildMessage$28(propName, propType)
 		});
 	} })
 });
@@ -2277,7 +2285,7 @@ const ariaRole = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/aria-unsupported-elements.ts
-const buildMessage$25 = (tag, attribute) => `\`<${tag}>\` does not support \`${attribute}\` — reserved HTML elements don't accept ARIA attributes.`;
+const buildMessage$27 = (tag, attribute) => `\`<${tag}>\` does not support \`${attribute}\` — reserved HTML elements don't accept ARIA attributes.`;
 const ariaUnsupportedElements = defineRule({
 	id: "aria-unsupported-elements",
 	tags: ["react-jsx-only"],
@@ -2294,7 +2302,7 @@ const ariaUnsupportedElements = defineRule({
 			if (!attrName) continue;
 			if (attrName.startsWith("aria-") || attrName === "role") context.report({
 				node: attribute,
-				message: buildMessage$25(tag, attrName)
+				message: buildMessage$27(tag, attrName)
 			});
 		}
 	} })
@@ -2327,7 +2335,7 @@ const BUILTIN_GLOBAL_NAMESPACE_NAMES = new Set([
 	"BigInt",
 	"Reflect"
 ]);
-const MUTATING_ARRAY_METHODS$1 = new Set([
+const MUTATING_ARRAY_METHODS = new Set([
 	"push",
 	"pop",
 	"shift",
@@ -2338,6 +2346,12 @@ const MUTATING_ARRAY_METHODS$1 = new Set([
 	"fill",
 	"copyWithin"
 ]);
+const MUTATING_COLLECTION_METHODS = new Set([
+	"add",
+	"clear",
+	"delete",
+	"set"
+]);
 const CHAINABLE_ITERATION_METHODS = new Set([
 	"map",
 	"filter",
@@ -2549,7 +2563,7 @@ const INTENTIONAL_SEQUENCING_CALLEE_NAMES = new Set([
 * (`FUNCTION_LIKE_TYPES.has(node.type)`) and as a type-guard. The
 * type-guard form covers both shapes without callers paying a cast.
 */
-const isFunctionLike$1 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
+const isFunctionLike$2 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
 //#endregion
 //#region src/plugin/utils/is-inline-function-expression.ts
 /**
@@ -2572,7 +2586,7 @@ const findFirstAwaitOutsideNestedFunctions = (block) => {
 	let firstAwait = null;
 	walkAst(block, (child) => {
 		if (firstAwait) return false;
-		if (child !== block && isFunctionLike$1(child)) return false;
+		if (child !== block && isFunctionLike$2(child)) return false;
 		if (isNodeOfType(child, "AwaitExpression")) firstAwait = child;
 	});
 	return firstAwait;
@@ -3027,13 +3041,13 @@ const asyncDeferAwait = defineRule({
 		const inspectAllStatementBlocks = (functionBody) => {
 			if (!functionBody) return;
 			walkAst(functionBody, (descendant) => {
-				if (isFunctionLike$1(descendant)) return false;
+				if (isFunctionLike$2(descendant)) return false;
 				if (isNodeOfType(descendant, "BlockStatement")) inspectStatements(descendant.body ?? []);
 				else if (isNodeOfType(descendant, "SwitchCase")) inspectStatements(descendant.consequent ?? []);
 			});
 		};
 		const enterFunction = (node) => {
-			if (!isFunctionLike$1(node)) return;
+			if (!isFunctionLike$2(node)) return;
 			if (!node.async) return;
 			if (!isNodeOfType(node.body, "BlockStatement")) return;
 			inspectAllStatementBlocks(node.body);
@@ -3164,7 +3178,7 @@ const asyncParallel = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/autocomplete-valid.ts
-const buildMessage$24 = (value) => `\`autoComplete\` value \`${value}\` is not a known HTML autofill token.`;
+const buildMessage$26 = (value) => `\`autoComplete\` value \`${value}\` is not a known HTML autofill token.`;
 const AUTOFILL_TOKENS = new Set([
 	"off",
 	"on",
@@ -3252,7 +3266,7 @@ const autocompleteValid = defineRule({
 				if (!AUTOFILL_TOKENS.has(token)) {
 					context.report({
 						node: attribute,
-						message: buildMessage$24(value)
+						message: buildMessage$26(value)
 					});
 					return;
 				}
@@ -3527,7 +3541,7 @@ const isPureEventBlockerHandler = (attribute) => {
 //#endregion
 //#region src/plugin/rules/a11y/click-events-have-key-events.ts
 const PRESENTATION_ROLES$1 = new Set(["presentation", "none"]);
-const MESSAGE$45 = "Visible non-interactive elements with click handlers must have a corresponding keyboard listener (`onKeyUp`, `onKeyDown`, or `onKeyPress`).";
+const MESSAGE$47 = "Visible non-interactive elements with click handlers must have a corresponding keyboard listener (`onKeyUp`, `onKeyDown`, or `onKeyPress`).";
 const KEY_HANDLERS = [
 	"onKeyUp",
 	"onKeyDown",
@@ -3558,7 +3572,7 @@ const clickEventsHaveKeyEvents = defineRule({
 			if (KEY_HANDLERS.some((handler) => hasJsxPropIgnoreCase(node.attributes, handler))) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$45
+				message: MESSAGE$47
 			});
 		} };
 	}
@@ -3669,7 +3683,7 @@ const stripParenExpression = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/control-has-associated-label.ts
-const MESSAGE$44 = "A control must be associated with a text label — add visible text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$46 = "A control must be associated with a text label — add visible text, `aria-label`, or `aria-labelledby`.";
 const DEFAULT_IGNORE_ELEMENTS = ["link", "canvas"];
 const DEFAULT_LABELLING_PROPS = [
 	"alt",
@@ -3829,7 +3843,7 @@ const controlHasAssociatedLabel = defineRule({
 			for (const child of node.children) if (checkChildForLabel(child, 1, checkContext)) return;
 			context.report({
 				node: opening,
-				message: MESSAGE$44
+				message: MESSAGE$46
 			});
 		} };
 	}
@@ -4153,14 +4167,21 @@ const isEs6Component = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/display-name.ts
-const MESSAGE$43 = "Component is missing a `displayName` — assign one for easier debugging.";
+const MESSAGE$45 = "Component is missing a `displayName` — assign one for easier debugging.";
+const DEFAULT_ADDITIONAL_HOCS = [
+	"observer",
+	"lazy",
+	"withTracking"
+];
 const resolveSettings$45 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.displayName ?? {} : {};
+	const additionalHoCs = new Set(ruleSettings.additionalHoCs ?? DEFAULT_ADDITIONAL_HOCS);
 	return {
 		ignoreTranspilerName: ruleSettings.ignoreTranspilerName ?? false,
 		checkContextObjects: ruleSettings.checkContextObjects ?? false,
-		reactVersion: ruleSettings.reactVersion ?? ""
+		reactVersion: ruleSettings.reactVersion ?? "",
+		additionalHoCs
 	};
 };
 const isReactVersionAtLeast$1 = (version, major, minor) => {
@@ -4233,29 +4254,28 @@ const isCreateContextCall = (node) => {
 	if (isNodeOfType(callee, "Identifier")) return callee.name === "createContext";
 	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName(callee) === "createContext";
 };
-const isObserverCall = (node) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = node.callee;
-	if (isNodeOfType(callee, "Identifier")) return callee.name === "observer";
-	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName(callee) === "observer";
-};
-const getCallName = (node) => {
-	if (!isNodeOfType(node, "CallExpression")) return null;
-	const callee = node.callee;
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName(callee);
-	return null;
-};
 const isNamedFunctionLike = (node) => (isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && Boolean(node.id?.name);
 const firstCallArgument = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	const first = node.arguments[0];
 	return first ? first : null;
 };
-const isDisplayNameHoC = (node) => {
-	const callName = getCallName(node);
-	return callName === "memo" || callName === "forwardRef";
+const resolveHoCCalleeName = (node, additionalHoCs) => {
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	const callee = node.callee;
+	if (isNodeOfType(callee, "Identifier")) {
+		if (callee.name === "memo" || callee.name === "forwardRef") return callee.name;
+		if (additionalHoCs.has(callee.name)) return callee.name;
+		return null;
+	}
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) {
+		const propertyName = callee.property.name;
+		if (propertyName === "memo" || propertyName === "forwardRef") return propertyName;
+		if (additionalHoCs.has(propertyName)) return propertyName;
+	}
+	return null;
 };
+const isDisplayNameHoC = (node, additionalHoCs) => resolveHoCCalleeName(node, additionalHoCs) !== null;
 const supportsComposedForwardRefDisplayName = (version) => {
 	if (!version) return false;
 	if (isReactVersionAtLeast$1(version, 15, 7)) return true;
@@ -4263,17 +4283,17 @@ const supportsComposedForwardRefDisplayName = (version) => {
 	return Boolean(match && Number(match[1]) >= 11);
 };
 const shouldReportHoCDisplayName = (node, settings) => {
-	if (!isDisplayNameHoC(node)) return false;
+	if (!isDisplayNameHoC(node, settings.additionalHoCs)) return false;
 	if (!containsJsx$1(node)) return false;
 	const assignedName = getAssignedName(node);
 	const programRoot = findProgramRoot(node);
 	if (assignedName && programRoot && hasDisplayNameAssignment(assignedName, programRoot)) return false;
-	const callName = getCallName(node);
+	const callName = resolveHoCCalleeName(node, settings.additionalHoCs);
 	const firstArgument = firstCallArgument(node);
 	if (!firstArgument) return false;
-	if (callName === "forwardRef" && isNodeOfType(node.parent, "CallExpression") && getCallName(node.parent) === "memo" && firstCallArgument(node.parent) === node && supportsComposedForwardRefDisplayName(settings.reactVersion)) return false;
+	if (callName === "forwardRef" && isNodeOfType(node.parent, "CallExpression") && resolveHoCCalleeName(node.parent, settings.additionalHoCs) === "memo" && firstCallArgument(node.parent) === node && supportsComposedForwardRefDisplayName(settings.reactVersion)) return false;
 	if (callName === "memo" && isNodeOfType(firstArgument, "CallExpression")) {
-		if (getCallName(firstArgument) !== "forwardRef") return false;
+		if (resolveHoCCalleeName(firstArgument, settings.additionalHoCs) !== "forwardRef") return false;
 		return !supportsComposedForwardRefDisplayName(settings.reactVersion);
 	}
 	if (isNamedFunctionLike(firstArgument)) return false;
@@ -4349,7 +4369,7 @@ const displayName = defineRule({
 		const reportAt = (node) => {
 			context.report({
 				node,
-				message: MESSAGE$43
+				message: MESSAGE$45
 			});
 		};
 		return {
@@ -4427,10 +4447,6 @@ const displayName = defineRule({
 					reportAt(node);
 					return;
 				}
-				if (isObserverCall(node) && containsJsx$1(node)) {
-					reportAt(node);
-					return;
-				}
 				if (shouldReportHoCDisplayName(node, settings)) {
 					reportAt(node);
 					return;
@@ -4472,7 +4488,7 @@ const displayName = defineRule({
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
 	if (!node || typeof node !== "object") return;
-	if (isFunctionLike$1(node)) return;
+	if (isFunctionLike$2(node)) return;
 	visitor(node);
 	const nodeRecord = node;
 	for (const key of Object.keys(nodeRecord)) {
@@ -4560,7 +4576,7 @@ const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubs
 	let didFindRelease = false;
 	walkAst(node, (child) => {
 		if (didFindRelease) return false;
-		if (child !== node && isFunctionLike$1(child) && !isIteratorCallbackArgument(child)) return false;
+		if (child !== node && isFunctionLike$2(child) && !isIteratorCallbackArgument(child)) return false;
 		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
 			didFindRelease = true;
 			return false;
@@ -4569,7 +4585,7 @@ const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubs
 	return didFindRelease;
 };
 const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	if (!isFunctionLike$1(node)) return false;
+	if (!isFunctionLike$2(node)) return false;
 	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
 };
 const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
@@ -4811,7 +4827,7 @@ const recordReference = (state, identifier, flag) => {
 };
 const isFunctionBodyBlock = (block) => {
 	if (!block.parent) return false;
-	return isFunctionLike$1(block.parent);
+	return isFunctionLike$2(block.parent);
 };
 const isCatchClauseBlock = (block) => block.parent !== null && block.parent !== void 0 && block.parent.type === "CatchClause";
 const handleVariableDeclaration = (declaration, state) => {
@@ -4966,7 +4982,7 @@ const walkParameterReferences = (pattern, state) => {
 	if (isNodeOfType(pattern, "RestElement")) walkParameterReferences(pattern.argument, state);
 };
 const walk = (node, state) => {
-	if (isFunctionLike$1(node)) {
+	if (isFunctionLike$2(node)) {
 		if (isNodeOfType(node, "FunctionDeclaration") && node.id) handleFunctionDeclaration(node, state);
 		setNodeScope(node, state);
 		const fnScope = pushScope(node.type === "ArrowFunctionExpression" ? "arrow-function" : "function", node, state);
@@ -5212,7 +5228,7 @@ const closureCaptures = (functionNode, scopes) => {
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
 	const visit = (node) => {
-		if (node !== functionNode && isFunctionLike$1(node)) {
+		if (node !== functionNode && isFunctionLike$2(node)) {
 			const innerCaptures = closureCaptures(node, scopes);
 			for (const reference of innerCaptures) if (reference.resolvedSymbol && !isDescendantScope(reference.resolvedSymbol.scope, functionScope)) {
 				if (!seen.has(reference.id)) {
@@ -5284,7 +5300,7 @@ const TRANSPARENT_WRAPPER_TYPES = new Set([
 	"ParenthesizedExpression",
 	"ChainExpression"
 ]);
-const unwrapExpression = (node) => {
+const unwrapExpression$1 = (node) => {
 	let current = node;
 	while (TRANSPARENT_WRAPPER_TYPES.has(current.type)) {
 		const inner = current.expression;
@@ -5391,7 +5407,7 @@ const symbolHasStableHookOrigin = (symbol) => {
 	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
 	const initializerRaw = declarator.init;
 	if (!initializerRaw) return false;
-	const initializer = unwrapExpression(initializerRaw);
+	const initializer = unwrapExpression$1(initializerRaw);
 	if (symbol.kind === "const") {
 		if (isNodeOfType(initializer, "Literal") && (initializer.value === null || typeof initializer.value === "number" || typeof initializer.value === "string" || typeof initializer.value === "boolean")) return true;
 		if (isNodeOfType(initializer, "TemplateLiteral") && getStaticTemplateLiteralValue(initializer) !== null) return true;
@@ -5411,13 +5427,13 @@ const symbolHasStableHookOrigin = (symbol) => {
 	return false;
 };
 const symbolHasUseEffectEventOrigin = (symbol) => {
-	const initializer = symbol.initializer ? unwrapExpression(symbol.initializer) : null;
+	const initializer = symbol.initializer ? unwrapExpression$1(symbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
 	return getHookName(initializer.callee) === "useEffectEvent";
 };
 const getFunctionValueNode = (symbol) => {
 	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return symbol.declarationNode;
-	const initializer = symbol.initializer ? unwrapExpression(symbol.initializer) : null;
+	const initializer = symbol.initializer ? unwrapExpression$1(symbol.initializer) : null;
 	if (initializer && (isNodeOfType(initializer, "FunctionExpression") || isNodeOfType(initializer, "ArrowFunctionExpression"))) return initializer;
 	return null;
 };
@@ -5552,23 +5568,23 @@ const computeDepKey = (reference) => {
 	return fullName;
 };
 const computeDeclaredDepKey = (entry) => {
-	const stripped = unwrapExpression(entry);
+	const stripped = unwrapExpression$1(entry);
 	if (isNodeOfType(stripped, "Identifier")) return stripped.name;
 	if (isNodeOfType(stripped, "MemberExpression")) return stringifyMemberChain(stripped);
 	return null;
 };
 const depsArrayContainsIdentifier = (depsArgument, identifierName) => {
 	if (!depsArgument) return false;
-	const strippedDepsArgument = unwrapExpression(depsArgument);
+	const strippedDepsArgument = unwrapExpression$1(depsArgument);
 	if (!isNodeOfType(strippedDepsArgument, "ArrayExpression")) return false;
 	return strippedDepsArgument.elements.some((element) => {
 		if (!element) return false;
-		const strippedElement = unwrapExpression(element);
+		const strippedElement = unwrapExpression$1(element);
 		return isNodeOfType(strippedElement, "Identifier") && strippedElement.name === identifierName;
 	});
 };
 const stringifyMemberChain = (node) => {
-	const stripped = unwrapExpression(node);
+	const stripped = unwrapExpression$1(node);
 	if (isNodeOfType(stripped, "Identifier")) return stripped.name;
 	if (isNodeOfType(stripped, "ThisExpression")) return "this";
 	if (isNodeOfType(stripped, "MemberExpression")) {
@@ -5610,13 +5626,13 @@ const hasBroaderDeclaredDependency = (declaredKey, declaredKeys) => {
 	return false;
 };
 const getMemberRootIdentifier = (node) => {
-	const stripped = unwrapExpression(node);
+	const stripped = unwrapExpression$1(node);
 	if (isNodeOfType(stripped, "Identifier")) return stripped;
 	if (isNodeOfType(stripped, "MemberExpression")) return getMemberRootIdentifier(stripped.object);
 	return null;
 };
 const hasComputedMemberExpression = (node) => {
-	const stripped = unwrapExpression(node);
+	const stripped = unwrapExpression$1(node);
 	if (!isNodeOfType(stripped, "MemberExpression")) return false;
 	if (stripped.computed) return true;
 	return hasComputedMemberExpression(stripped.object);
@@ -5637,7 +5653,7 @@ const isRegExpLiteral = (node) => {
 };
 const isUnstableInitializer = (node) => {
 	if (!node) return false;
-	const stripped = unwrapExpression(node);
+	const stripped = unwrapExpression$1(node);
 	if (isRegExpLiteral(stripped)) return true;
 	if (isNodeOfType(stripped, "ConditionalExpression")) return isUnstableInitializer(stripped.consequent) || isUnstableInitializer(stripped.alternate);
 	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left) || isUnstableInitializer(stripped.right);
@@ -5793,7 +5809,7 @@ const hasMemberCallForRoot = (node, rootName) => {
 	const visit = (current) => {
 		if (didFindMemberCall) return;
 		if (isNodeOfType(current, "CallExpression")) {
-			if (getMemberRootIdentifier(unwrapExpression(current.callee))?.name === rootName) {
+			if (getMemberRootIdentifier(unwrapExpression$1(current.callee))?.name === rootName) {
 				didFindMemberCall = true;
 				return;
 			}
@@ -5855,7 +5871,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				return;
 			}
 			const depsArgumentRaw = node.arguments[depsArgumentIndex];
-			const callbackExpression = unwrapExpression(callbackArgument);
+			const callbackExpression = unwrapExpression$1(callbackArgument);
 			let callbackToAnalyze = null;
 			const forcedCaptureKeys = /* @__PURE__ */ new Set();
 			if (isNodeOfType(callbackExpression, "ArrowFunctionExpression") || isNodeOfType(callbackExpression, "FunctionExpression")) callbackToAnalyze = callbackExpression;
@@ -5863,7 +5879,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				const callbackSymbol = context.scopes.symbolFor(callbackExpression);
 				const functionValueNode = callbackSymbol ? getFunctionValueNode(callbackSymbol) : null;
 				if (functionValueNode) callbackToAnalyze = functionValueNode;
-				else if (callbackSymbol?.initializer && isNodeOfType(unwrapExpression(callbackSymbol.initializer), "CallExpression")) forcedCaptureKeys.add(callbackExpression.name);
+				else if (callbackSymbol?.initializer && isNodeOfType(unwrapExpression$1(callbackSymbol.initializer), "CallExpression")) forcedCaptureKeys.add(callbackExpression.name);
 				else if (depsArgumentRaw) {
 					if (depsArrayContainsIdentifier(depsArgumentRaw, callbackExpression.name)) return;
 					context.report({
@@ -5920,7 +5936,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				});
 				return;
 			}
-			const depsArgument = unwrapExpression(depsArgumentRaw);
+			const depsArgument = unwrapExpression$1(depsArgumentRaw);
 			if (isNodeOfType(depsArgument, "Literal") && depsArgument.value === null || isNodeOfType(depsArgument, "Identifier") && depsArgument.name === "undefined") {
 				if (isAutoDependenciesHook(hookName)) return;
 				if (HOOKS_REQUIRING_DEPS_ARRAY.has(hookName)) {
@@ -5961,11 +5977,11 @@ If the missing value is recreated every render, move it inside the hook or stabi
 			for (const forcedCaptureKey of forcedCaptureKeys) captureKeys.add(forcedCaptureKey);
 			const hasLiteralDepElement = depsArgument.elements.some((element) => {
 				if (!element) return false;
-				return isLiteralOrEmptyTemplate(unwrapExpression(element));
+				return isLiteralOrEmptyTemplate(unwrapExpression$1(element));
 			});
 			const hasNonStringLiteralDep = depsArgument.elements.some((element) => {
 				if (!element) return false;
-				return isNonStringLiteral(unwrapExpression(element));
+				return isNonStringLiteral(unwrapExpression$1(element));
 			});
 			if (hasNonStringLiteralDep) context.report({
 				node: depsArgument,
@@ -5986,7 +6002,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 					});
 					continue;
 				}
-				const stripped = unwrapExpression(elementNode);
+				const stripped = unwrapExpression$1(elementNode);
 				if (isLiteralOrEmptyTemplate(stripped)) continue;
 				if (isNodeOfType(stripped, "Identifier")) {
 					const depSymbol = context.scopes.symbolFor(stripped);
@@ -6206,7 +6222,7 @@ const flattenJsxName$1 = (name) => {
 	return "";
 };
 const isSupportedJsxName = (name) => isNodeOfType(name, "JSXIdentifier") || isNodeOfType(name, "JSXMemberExpression");
-const buildMessage$23 = (propName, message) => message ?? `Prop \`${propName}\` is forbidden on this component.`;
+const buildMessage$25 = (propName, message) => message ?? `Prop \`${propName}\` is forbidden on this component.`;
 const forbidComponentProps = defineRule({
 	id: "forbid-component-props",
 	severity: "warn",
@@ -6232,7 +6248,7 @@ const forbidComponentProps = defineRule({
 					if (!isForbiddenForTag(entry, tag)) continue;
 					context.report({
 						node: attribute,
-						message: buildMessage$23(propName, entry.message)
+						message: buildMessage$25(propName, entry.message)
 					});
 					break;
 				}
@@ -6242,7 +6258,7 @@ const forbidComponentProps = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-dom-props.ts
-const buildMessage$22 = (propName, customMessage) => customMessage ?? `Prop \`${propName}\` is forbidden on DOM nodes.`;
+const buildMessage$24 = (propName, customMessage) => customMessage ?? `Prop \`${propName}\` is forbidden on DOM nodes.`;
 const resolveSettings$43 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidDomProps ?? {} : {};
@@ -6280,7 +6296,7 @@ const forbidDomProps = defineRule({
 				if (disallowedFor && disallowedFor.size > 0 && !disallowedFor.has(elementName)) continue;
 				context.report({
 					node: attribute.name,
-					message: buildMessage$22(propName, descriptor.message)
+					message: buildMessage$24(propName, descriptor.message)
 				});
 			}
 		} };
@@ -6350,7 +6366,7 @@ const isReactFunctionCall = (node, expectedCall) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-elements.ts
-const buildMessage$21 = (element, customHelp) => customHelp ? `<${element}> is forbidden — ${customHelp}` : `<${element}> is forbidden.`;
+const buildMessage$23 = (element, customHelp) => customHelp ? `<${element}> is forbidden — ${customHelp}` : `<${element}> is forbidden.`;
 const resolveSettings$42 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidElements ?? {} : {};
@@ -6374,7 +6390,7 @@ const forbidElements = defineRule({
 				if (!fullName || !forbidMap.has(fullName)) return;
 				context.report({
 					node: node.name,
-					message: buildMessage$21(fullName, forbidMap.get(fullName))
+					message: buildMessage$23(fullName, forbidMap.get(fullName))
 				});
 			},
 			CallExpression(node) {
@@ -6394,7 +6410,7 @@ const forbidElements = defineRule({
 				if (!elementName || !forbidMap.has(elementName)) return;
 				context.report({
 					node: firstArgument,
-					message: buildMessage$21(elementName, forbidMap.get(elementName))
+					message: buildMessage$23(elementName, forbidMap.get(elementName))
 				});
 			}
 		};
@@ -6402,7 +6418,7 @@ const forbidElements = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/forward-ref-uses-ref.ts
-const MESSAGE$42 = "Components wrapped with `forwardRef` must accept a `ref` parameter — drop `forwardRef` if you don't need a ref.";
+const MESSAGE$44 = "Components wrapped with `forwardRef` must accept a `ref` parameter — drop `forwardRef` if you don't need a ref.";
 const forwardRefUsesRef = defineRule({
 	id: "forward-ref-uses-ref",
 	severity: "warn",
@@ -6421,13 +6437,13 @@ const forwardRefUsesRef = defineRule({
 		if (isNodeOfType(onlyParam, "RestElement")) return;
 		context.report({
 			node: inner,
-			message: MESSAGE$42
+			message: MESSAGE$44
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/a11y/heading-has-content.ts
-const MESSAGE$41 = "Heading elements must contain accessible text content (or `aria-label` / `aria-labelledby`).";
+const MESSAGE$43 = "Heading elements must contain accessible text content (or `aria-label` / `aria-labelledby`).";
 const DEFAULT_HEADING_TAGS = [
 	"h1",
 	"h2",
@@ -6459,7 +6475,7 @@ const headingHasContent = defineRule({
 			if (isHiddenFromScreenReader(node, context.settings)) return;
 			context.report({
 				node,
-				message: MESSAGE$41
+				message: MESSAGE$43
 			});
 		} };
 	}
@@ -6595,7 +6611,7 @@ const hooksNoNanInDeps = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/html-has-lang.ts
-const MESSAGE$40 = "`<html>` element must have a non-empty `lang` attribute.";
+const MESSAGE$42 = "`<html>` element must have a non-empty `lang` attribute.";
 const resolveSettings$39 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { htmlTags: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.htmlHasLang ?? {} : {}).htmlTags ?? ["html"] };
@@ -6642,7 +6658,7 @@ const htmlHasLang = defineRule({
 			if (!lang) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$40
+					message: MESSAGE$42
 				});
 				return;
 			}
@@ -6650,13 +6666,13 @@ const htmlHasLang = defineRule({
 			if (verdict === "missing" || verdict === "empty") {
 				context.report({
 					node: lang,
-					message: MESSAGE$40
+					message: MESSAGE$42
 				});
 				return;
 			}
 			if (hasSpread && !lang) context.report({
 				node: node.name,
-				message: MESSAGE$40
+				message: MESSAGE$42
 			});
 		} };
 	}
@@ -6696,7 +6712,7 @@ const BLOCK_LEVEL_ELEMENTS = new Set([
 	"table",
 	"ul"
 ]);
-const buildMessage$20 = (childTagName) => `Block-level \`<${childTagName}>\` cannot appear inside a \`<p>\` — the HTML parser auto-closes the paragraph at the start of \`<${childTagName}>\`, splitting your DOM in ways the renderer never expressed and triggering hydration mismatches.`;
+const buildMessage$22 = (childTagName) => `Block-level \`<${childTagName}>\` cannot appear inside a \`<p>\` — the HTML parser auto-closes the paragraph at the start of \`<${childTagName}>\`, splitting your DOM in ways the renderer never expressed and triggering hydration mismatches.`;
 const isParagraphElement = (candidate) => {
 	if (!isNodeOfType(candidate, "JSXElement")) return false;
 	const opening = candidate.openingElement;
@@ -6724,7 +6740,7 @@ const htmlNoInvalidParagraphChild = defineRule({
 		if (!findEnclosingParagraph(node)) return;
 		context.report({
 			node: node.name,
-			message: buildMessage$20(childTagName)
+			message: buildMessage$22(childTagName)
 		});
 	} })
 });
@@ -6744,7 +6760,7 @@ const ROW_GROUPS = new Set([
 	"tbody",
 	"tfoot"
 ]);
-const buildMessage$19 = (childTag, expectedParent, actualParent) => `Improper table nesting — \`<${childTag}>\` must be a direct child of ${expectedParent}, but its nearest host ancestor is \`<${actualParent}>\`. Browsers auto-rewrite invalid table structure, producing a DOM that doesn't match the JSX (broken hydration, broken \`>\` selectors, broken accessibility tree).`;
+const buildMessage$21 = (childTag, expectedParent, actualParent) => `Improper table nesting — \`<${childTag}>\` must be a direct child of ${expectedParent}, but its nearest host ancestor is \`<${actualParent}>\`. Browsers auto-rewrite invalid table structure, producing a DOM that doesn't match the JSX (broken hydration, broken \`>\` selectors, broken accessibility tree).`;
 const buildNestedTableMessage = () => "Improper table nesting — `<table>` cannot be a direct descendant of another table element. Tables can only nest inside a `<td>` or `<th>` cell of an outer table.";
 const getHostTagName = (jsxElement) => {
 	if (!isNodeOfType(jsxElement, "JSXElement")) return null;
@@ -6812,28 +6828,28 @@ const htmlNoInvalidTableNesting = defineRule({
 		if (ROW_GROUPS.has(tagName)) {
 			if (actualParent !== "table") context.report({
 				node: node.openingElement.name,
-				message: buildMessage$19(tagName, "`<table>`", actualParent)
+				message: buildMessage$21(tagName, "`<table>`", actualParent)
 			});
 			return;
 		}
 		if (tagName === "tr") {
 			if (!ROW_GROUPS.has(actualParent) && actualParent !== "table") context.report({
 				node: node.openingElement.name,
-				message: buildMessage$19(tagName, "`<thead>`, `<tbody>`, or `<tfoot>`", actualParent)
+				message: buildMessage$21(tagName, "`<thead>`, `<tbody>`, or `<tfoot>`", actualParent)
 			});
 			return;
 		}
 		if (tagName === "td" || tagName === "th") {
 			if (actualParent !== "tr") context.report({
 				node: node.openingElement.name,
-				message: buildMessage$19(tagName, "`<tr>`", actualParent)
+				message: buildMessage$21(tagName, "`<tr>`", actualParent)
 			});
 		}
 	} })
 });
 //#endregion
 //#region src/plugin/rules/correctness/html-no-nested-interactive.ts
-const buildMessage$18 = (tagName) => `Improper nesting of \`<${tagName}>\` inside another \`<${tagName}>\` — the HTML parser auto-closes the outer element, splitting your DOM in ways the renderer never expressed and breaking event delegation, focus, and accessibility.`;
+const buildMessage$20 = (tagName) => `Improper nesting of \`<${tagName}>\` inside another \`<${tagName}>\` — the HTML parser auto-closes the outer element, splitting your DOM in ways the renderer never expressed and breaking event delegation, focus, and accessibility.`;
 const isJsxElementWithTagName = (candidate, tagName) => {
 	if (!isNodeOfType(candidate, "JSXElement")) return false;
 	const opening = candidate.openingElement;
@@ -6861,13 +6877,13 @@ const htmlNoNestedInteractive = defineRule({
 		if (!findEnclosingSameTag(node, tagName)) return;
 		context.report({
 			node: node.name,
-			message: buildMessage$18(tagName)
+			message: buildMessage$20(tagName)
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/a11y/iframe-has-title.ts
-const MESSAGE$39 = "`<iframe>` element must have a non-empty `title` attribute for assistive technology.";
+const MESSAGE$41 = "`<iframe>` element must have a non-empty `title` attribute for assistive technology.";
 const evaluateTitleValue = (value) => {
 	if (!value) return "missing";
 	if (isNodeOfType(value, "Literal")) {
@@ -6906,14 +6922,14 @@ const iframeHasTitle = defineRule({
 		if (!titleAttr) {
 			if (hasSpread || tag === "iframe") context.report({
 				node: node.name,
-				message: MESSAGE$39
+				message: MESSAGE$41
 			});
 			return;
 		}
 		const verdict = evaluateTitleValue(titleAttr.value);
 		if (verdict === "missing" || verdict === "empty") context.report({
 			node: titleAttr,
-			message: MESSAGE$39
+			message: MESSAGE$41
 		});
 	} })
 });
@@ -7016,7 +7032,7 @@ const iframeMissingSandbox = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/img-redundant-alt.ts
-const MESSAGE$38 = "`alt` text contains redundant words like \"image\" / \"photo\" / \"picture\" — describe the content instead.";
+const MESSAGE$40 = "`alt` text contains redundant words like \"image\" / \"photo\" / \"picture\" — describe the content instead.";
 const DEFAULT_COMPONENTS = ["img"];
 const DEFAULT_REDUNDANT_WORDS = [
 	"image",
@@ -7078,7 +7094,7 @@ const imgRedundantAlt = defineRule({
 			if (!altAttribute) return;
 			if (altValueRedundant(altAttribute, settings.words)) context.report({
 				node: altAttribute,
-				message: MESSAGE$38
+				message: MESSAGE$40
 			});
 		} };
 	}
@@ -7273,7 +7289,7 @@ const isAtomFromJotai = (callExpression) => {
 	if (!isImportedFromModule(callExpression, localName, "jotai")) return false;
 	return getImportedNameFromModule(callExpression, localName, "jotai") === "atom";
 };
-const isFunctionLike = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
+const isFunctionLike$1 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
 const getFirstParameterName = (fn) => {
 	const parameters = fn.params ?? [];
 	if (parameters.length !== 1) return null;
@@ -7391,7 +7407,7 @@ const jotaiDerivedAtomReturnsFreshObject = defineRule({
 		const args = node.arguments ?? [];
 		if (args.length === 0) return;
 		const reader = args[0];
-		if (!isFunctionLike(reader)) return;
+		if (!isFunctionLike$1(reader)) return;
 		const getParameterName = getFirstParameterName(reader);
 		if (!getParameterName) return;
 		const freshReturn = getFreshReturnForFunction(reader);
@@ -7407,7 +7423,6 @@ const jotaiDerivedAtomReturnsFreshObject = defineRule({
 //#endregion
 //#region src/plugin/rules/jotai/jotai-select-atom-in-render-body.ts
 const JOTAI_SELECT_ATOM_SOURCES = ["jotai/utils", "jotai"];
-const MEMOIZING_HOOK_NAMES = new Set(["useMemo", "useCallback"]);
 const COMPONENT_NAME_PATTERN = /^[A-Z]/;
 const HOOK_NAME_PATTERN = /^use[A-Z]/;
 const isFunctionLikeNode = (node) => isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
@@ -7645,7 +7660,7 @@ const isInsideLoopContext = (node) => {
 	let current = node.parent;
 	while (current) {
 		if (isNodeOfType(current, "ForStatement") || isNodeOfType(current, "ForInStatement") || isNodeOfType(current, "ForOfStatement") || isNodeOfType(current, "WhileStatement") || isNodeOfType(current, "DoWhileStatement")) return true;
-		if (isFunctionLike$1(current)) {
+		if (isFunctionLike$2(current)) {
 			if (isIteratorCallback(current)) return true;
 			return false;
 		}
@@ -7999,7 +8014,7 @@ const jsHoistIntl = defineRule({
 		let cursor = node.parent ?? null;
 		let inFunctionBody = false;
 		while (cursor) {
-			if (isFunctionLike$1(cursor)) {
+			if (isFunctionLike$2(cursor)) {
 				inFunctionBody = true;
 				const fnParent = cursor.parent;
 				if (fnParent && isNodeOfType(fnParent, "CallExpression") && fnParent.arguments?.[0] === cursor) {
@@ -9344,7 +9359,7 @@ const findVariableInitializer = (referenceNode, bindingName) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-max-depth.ts
-const buildMessage$17 = (depth, max) => `JSX nesting depth ${depth} exceeds maximum ${max}.`;
+const buildMessage$19 = (depth, max) => `JSX nesting depth ${depth} exceeds maximum ${max}.`;
 const DEFAULT_MAX_DEPTH = 14;
 const resolveSettings$30 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
@@ -9411,7 +9426,7 @@ const jsxMaxDepth = defineRule({
 			const total = computeJsxAncestorDepth(node) + computeChildrenDepth(node.children ?? [], /* @__PURE__ */ new Set());
 			if (total > max) context.report({
 				node,
-				message: buildMessage$17(total, max)
+				message: buildMessage$19(total, max)
 			});
 		};
 		return {
@@ -9426,7 +9441,7 @@ const jsxMaxDepth = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-comment-textnodes.ts
-const MESSAGE$37 = "Comment-like text in JSX must live inside `{/* … */}` — bare `//` or `/*` becomes literal text.";
+const MESSAGE$39 = "Comment-like text in JSX must live inside `{/* … */}` — bare `//` or `/*` becomes literal text.";
 const LITERAL_TEXT_TAGS = new Set([
 	"code",
 	"pre",
@@ -9461,11 +9476,20 @@ const jsxNoCommentTextnodes = defineRule({
 		if (isInsideLiteralTextTag(node)) return;
 		context.report({
 			node,
-			message: MESSAGE$37
+			message: MESSAGE$39
 		});
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-canonical-react-namespace-name.ts
+const isCanonicalReactNamespaceName = (namespaceName) => {
+	if (namespaceName === "React") return true;
+	if (namespaceName === "react") return true;
+	if (namespaceName.startsWith("_react")) return true;
+	if (namespaceName.startsWith("_React")) return true;
+	return false;
+};
+//#endregion
 //#region src/plugin/utils/is-inside-function-scope.ts
 const FUNCTION_NODE_TYPES$1 = new Set([
 	"FunctionDeclaration",
@@ -9483,7 +9507,12 @@ const isInsideFunctionScope = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-constructed-context-values.ts
-const MESSAGE$36 = "Context `value` prop is constructed inline — wrap with `useMemo`/`useCallback` or hoist a constant to avoid re-renders.";
+const MESSAGE$38 = "Context `value` prop is constructed inline — wrap with `useMemo`/`useCallback` or hoist a constant to avoid re-renders.";
+const CONTEXT_MODULES$1 = [
+	"react",
+	"use-context-selector",
+	"react-tracked"
+];
 const isConstructedValue = (expression) => {
 	const stripped = stripParenExpression(expression);
 	if (isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "ArrayExpression") || isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "FunctionExpression") || isNodeOfType(stripped, "ClassExpression") || isNodeOfType(stripped, "NewExpression") || isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment")) return true;
@@ -9491,10 +9520,57 @@ const isConstructedValue = (expression) => {
 	if (isNodeOfType(stripped, "LogicalExpression")) return isConstructedValue(stripped.left) || isConstructedValue(stripped.right);
 	return false;
 };
-const isProviderName = (node) => {
+const isProviderMemberName = (node) => {
 	if (!isNodeOfType(node, "JSXMemberExpression")) return false;
 	return node.property.name === "Provider";
 };
+const isCreateContextCallExpression = (expression) => {
+	const stripped = stripParenExpression(expression);
+	if (!isNodeOfType(stripped, "CallExpression")) return false;
+	const callee = stripped.callee;
+	if (isNodeOfType(callee, "Identifier")) {
+		for (const moduleName of CONTEXT_MODULES$1) if (getImportedNameFromModule(callee, callee.name, moduleName) === "createContext") return true;
+		return false;
+	}
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
+		const namespaceIdentifier = callee.object;
+		const propertyIdentifier = callee.property;
+		if (!isNodeOfType(namespaceIdentifier, "Identifier")) return false;
+		if (!isNodeOfType(propertyIdentifier, "Identifier")) return false;
+		if (propertyIdentifier.name !== "createContext") return false;
+		if (isCanonicalReactNamespaceName(namespaceIdentifier.name)) return true;
+		for (const moduleName of CONTEXT_MODULES$1) {
+			if (getImportedNameFromModule(namespaceIdentifier, namespaceIdentifier.name, moduleName) === null) continue;
+			return true;
+		}
+	}
+	return false;
+};
+const collectContextBindings = (programRoot) => {
+	const bindings = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(programRoot, "Program")) return bindings;
+	for (const topLevel of programRoot.body ?? []) {
+		let declaration = topLevel;
+		if (isNodeOfType(topLevel, "ExportNamedDeclaration") && topLevel.declaration) declaration = topLevel.declaration;
+		if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) continue;
+		for (const declarator of declaration.declarations ?? []) {
+			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			if (!declarator.init) continue;
+			if (!isAstNode(declarator.init)) continue;
+			if (!isCreateContextCallExpression(declarator.init)) continue;
+			bindings.add(declarator.id.name);
+		}
+	}
+	return bindings;
+};
+const isCreateContextBindingJsxName = (node, contextBindings) => {
+	if (!isNodeOfType(node, "JSXIdentifier")) return false;
+	if (!contextBindings.has(node.name)) return false;
+	const binding = findVariableInitializer(node, node.name);
+	if (!binding) return false;
+	return binding.scopeOwner.type === "Program";
+};
 const jsxNoConstructedContextValues = defineRule({
 	id: "jsx-no-constructed-context-values",
 	tags: ["react-jsx-only"],
@@ -9503,26 +9579,35 @@ const jsxNoConstructedContextValues = defineRule({
 	category: "Performance",
 	create: (context) => {
 		const isTestlikeFile = isTestlikeFilename(context.filename);
-		return { JSXOpeningElement(node) {
-			if (isTestlikeFile) return;
-			if (!isProviderName(node.name)) return;
-			if (!isInsideFunctionScope(node)) return;
-			for (const attribute of node.attributes) {
-				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
-				if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
-				if (attribute.name.name !== "value") continue;
-				const attributeValue = attribute.value;
-				if (!attributeValue) continue;
-				if (!isNodeOfType(attributeValue, "JSXExpressionContainer")) continue;
-				const innerExpression = attributeValue.expression;
-				if (!innerExpression || innerExpression.type === "JSXEmptyExpression") continue;
-				if (!isConstructedValue(innerExpression)) continue;
-				context.report({
-					node: attribute,
-					message: MESSAGE$36
-				});
+		let contextBindings = /* @__PURE__ */ new Set();
+		return {
+			Program(node) {
+				contextBindings = collectContextBindings(node);
+			},
+			JSXOpeningElement(node) {
+				if (isTestlikeFile) return;
+				const nameNode = node.name;
+				const isLegacyProvider = isProviderMemberName(nameNode);
+				const isReact19Shorthand = isCreateContextBindingJsxName(nameNode, contextBindings);
+				if (!isLegacyProvider && !isReact19Shorthand) return;
+				if (!isInsideFunctionScope(node)) return;
+				for (const attribute of node.attributes) {
+					if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+					if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
+					if (attribute.name.name !== "value") continue;
+					const attributeValue = attribute.value;
+					if (!attributeValue) continue;
+					if (!isNodeOfType(attributeValue, "JSXExpressionContainer")) continue;
+					const innerExpression = attributeValue.expression;
+					if (!innerExpression || innerExpression.type === "JSXEmptyExpression") continue;
+					if (!isConstructedValue(innerExpression)) continue;
+					context.report({
+						node: attribute,
+						message: MESSAGE$38
+					});
+				}
 			}
-		} };
+		};
 	}
 });
 //#endregion
@@ -9548,7 +9633,8 @@ const jsxNoDuplicateProps = defineRule({
 //#endregion
 //#region src/plugin/utils/build-same-file-memo-registry.ts
 const HOC_NAMES_FOR_MEMOISATION = new Set([
-	...REACT_HOC_NAMES,
+	"memo",
+	"React.memo",
 	"observer",
 	"observable",
 	"lazy",
@@ -9602,7 +9688,7 @@ const isJsxAttributeOnIntrinsicHtmlElement = (attribute) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-jsx-as-prop.ts
-const MESSAGE$35 = "JSX prop receives JSX created on every render — extract it or memoize to avoid re-renders.";
+const MESSAGE$37 = "JSX prop receives JSX created on every render — extract it or memoize to avoid re-renders.";
 const KNOWN_SLOT_PROP_NAMES = new Set([
 	"icon",
 	"Icon",
@@ -9870,7 +9956,7 @@ const jsxNoJsxAsProp = defineRule({
 				if (!isJsxProducingExpression(expressionNode) && !followsRenderLocalJsxBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$35
+					message: MESSAGE$37
 				});
 			}
 		};
@@ -10158,7 +10244,7 @@ const DATA_ARRAY_PROP_SUFFIXES = [
 ];
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-array-as-prop.ts
-const MESSAGE$34 = "JSX prop receives a new Array on every render — extract it or memoize to avoid re-renders.";
+const MESSAGE$36 = "JSX prop receives a new Array on every render — extract it or memoize to avoid re-renders.";
 const isDataArrayPropName = (propName) => {
 	if (DATA_ARRAY_PROP_NAMES.has(propName)) return true;
 	for (const suffix of DATA_ARRAY_PROP_SUFFIXES) if (propName.length > suffix.length && propName.endsWith(suffix)) return true;
@@ -10241,7 +10327,7 @@ const jsxNoNewArrayAsProp = defineRule({
 				if (!isArrayProducingExpression(expressionNode) && !followsRenderLocalArrayBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$34
+					message: MESSAGE$36
 				});
 			}
 		};
@@ -10499,7 +10585,7 @@ const SAFE_RECEIVER_NAMES = new Set([
 ]);
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-function-as-prop.ts
-const MESSAGE$33 = "JSX prop receives a new Function on every render — extract it or memoize (`useCallback`) to avoid re-renders.";
+const MESSAGE$35 = "JSX prop receives a new Function on every render — extract it or memoize (`useCallback`) to avoid re-renders.";
 const isAccessorPredicateName = (propName) => {
 	for (const prefix of ACCESSOR_PREDICATE_PREFIXES) {
 		if (propName.length <= prefix.length) continue;
@@ -10704,7 +10790,7 @@ const jsxNoNewFunctionAsProp = defineRule({
 				if (!isFunctionProducingExpression(expressionNode) && !followsRenderLocalFunctionBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$33
+					message: MESSAGE$35
 				});
 			}
 		};
@@ -10924,7 +11010,7 @@ const CONFIG_OBJECT_PROP_SUFFIXES = [
 ];
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-object-as-prop.ts
-const MESSAGE$32 = "JSX prop receives a new Object on every render — extract it or memoize to avoid re-renders.";
+const MESSAGE$34 = "JSX prop receives a new Object on every render — extract it or memoize to avoid re-renders.";
 const isConfigObjectPropName = (propName) => {
 	if (CONFIG_OBJECT_PROP_NAMES.has(propName)) return true;
 	for (const suffix of CONFIG_OBJECT_PROP_SUFFIXES) if (propName.length > suffix.length && propName.endsWith(suffix)) return true;
@@ -11011,7 +11097,7 @@ const jsxNoNewObjectAsProp = defineRule({
 				if (!isObjectProducingExpression(expressionNode) && !followsRenderLocalObjectBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$32
+					message: MESSAGE$34
 				});
 			}
 		};
@@ -11019,7 +11105,7 @@ const jsxNoNewObjectAsProp = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-script-url.ts
-const MESSAGE$31 = "React 19 disallows `javascript:` URLs as a security precaution — use an event handler instead.";
+const MESSAGE$33 = "React 19 disallows `javascript:` URLs as a security precaution — use an event handler instead.";
 const JAVASCRIPT_URL_PATTERN = /j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
 const resolveSettings$29 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
@@ -11059,7 +11145,7 @@ const jsxNoScriptUrl = defineRule({
 				if (!value || !isNodeOfType(value, "Literal") || typeof value.value !== "string") continue;
 				if (JAVASCRIPT_URL_PATTERN.test(value.value)) context.report({
 					node: attribute,
-					message: MESSAGE$31
+					message: MESSAGE$33
 				});
 			}
 		} };
@@ -11347,7 +11433,7 @@ const jsxNoTargetBlank = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-undef.ts
-const buildMessage$16 = (name) => `\`${name}\` is not defined in this scope.`;
+const buildMessage$18 = (name) => `\`${name}\` is not defined in this scope.`;
 const KNOWN_GLOBALS = new Set([
 	"globalThis",
 	"window",
@@ -11382,7 +11468,7 @@ const jsxNoUndef = defineRule({
 		if (findVariableInitializer(node, rootIdentifier)) return;
 		context.report({
 			node: node.name,
-			message: buildMessage$16(rootIdentifier)
+			message: buildMessage$18(rootIdentifier)
 		});
 	} })
 });
@@ -11481,7 +11567,7 @@ const jsxNoUselessFragment = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-pascal-case.ts
-const buildMessage$15 = (componentName, allowAllCaps) => allowAllCaps ? `JSX component \`${componentName}\` must be in PascalCase or SCREAMING_SNAKE_CASE.` : `JSX component \`${componentName}\` must be in PascalCase.`;
+const buildMessage$17 = (componentName, allowAllCaps) => allowAllCaps ? `JSX component \`${componentName}\` must be in PascalCase or SCREAMING_SNAKE_CASE.` : `JSX component \`${componentName}\` must be in PascalCase.`;
 const resolveSettings$26 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxPascalCase ?? {} : {};
@@ -11597,7 +11683,7 @@ const jsxPascalCase = defineRule({
 				if (!isPascal && !isAllCaps) {
 					context.report({
 						node,
-						message: buildMessage$15(segment, settings.allowAllCaps)
+						message: buildMessage$17(segment, settings.allowAllCaps)
 					});
 					return;
 				}
@@ -11649,7 +11735,7 @@ const jsxPropsNoSpreadMulti = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-props-no-spreading.ts
-const MESSAGE$30 = "JSX prop spreading is forbidden — list each prop explicitly.";
+const MESSAGE$32 = "JSX prop spreading is forbidden — list each prop explicitly.";
 const resolveSettings$25 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxPropsNoSpreading ?? {} : {};
@@ -11689,7 +11775,7 @@ const jsxPropsNoSpreading = defineRule({
 				}
 				context.report({
 					node: attribute,
-					message: MESSAGE$30
+					message: MESSAGE$32
 				});
 			}
 		} };
@@ -11844,7 +11930,7 @@ const labelHasAssociatedControl = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/lang.ts
-const MESSAGE$29 = "`<html lang>` value must be a valid IANA / BCP-47 language tag (e.g. `en`, `en-US`).";
+const MESSAGE$31 = "`<html lang>` value must be a valid IANA / BCP-47 language tag (e.g. `en`, `en-US`).";
 const COMMON_LANGUAGE_PRIMARY_TAGS = new Set([
 	"aa",
 	"ab",
@@ -12055,7 +12141,7 @@ const lang = defineRule({
 			if (expression.type === "Identifier" && expression.name === "undefined" || expression.type === "Literal" && expression.value === null) {
 				context.report({
 					node: langAttr,
-					message: MESSAGE$29
+					message: MESSAGE$31
 				});
 				return;
 			}
@@ -12064,13 +12150,13 @@ const lang = defineRule({
 		if (value === null) return;
 		if (!isValidLangTag(value)) context.report({
 			node: langAttr,
-			message: MESSAGE$29
+			message: MESSAGE$31
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/a11y/media-has-caption.ts
-const MESSAGE$28 = "`<audio>` / `<video>` must have a `<track kind=\"captions\">` child for users who can't hear audio.";
+const MESSAGE$30 = "`<audio>` / `<video>` must have a `<track kind=\"captions\">` child for users who can't hear audio.";
 const DEFAULT_AUDIO = ["audio"];
 const DEFAULT_VIDEO = ["video"];
 const DEFAULT_TRACK = ["track"];
@@ -12110,7 +12196,7 @@ const mediaHasCaption = defineRule({
 			if (!parent || !isNodeOfType(parent, "JSXElement")) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$28
+					message: MESSAGE$30
 				});
 				return;
 			}
@@ -12127,7 +12213,7 @@ const mediaHasCaption = defineRule({
 				return kindValue.value.toLowerCase() === "captions";
 			})) context.report({
 				node: node.name,
-				message: MESSAGE$28
+				message: MESSAGE$30
 			});
 		} };
 	}
@@ -12818,7 +12904,7 @@ const collectChainedGetHandlerBodies = (initNode) => {
 };
 const resolveBodiesFromExpression = (expression, resolveBinding, remainingDepth) => {
 	if (remainingDepth <= 0) return [];
-	if (isFunctionLike$1(expression)) return expression.body ? [expression.body] : [];
+	if (isFunctionLike$2(expression)) return expression.body ? [expression.body] : [];
 	if (isNodeOfType(expression, "CallExpression")) {
 		for (const callArgument of expression.arguments ?? []) {
 			if (isNodeOfType(callArgument, "ArrowFunctionExpression") || isNodeOfType(callArgument, "FunctionExpression")) {
@@ -12941,7 +13027,7 @@ const nextjsNoUseSearchParamsWithoutSuspense = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-access-key.ts
-const MESSAGE$27 = "`accessKey` should not be used — accessKeys conflict with screen reader and OS-level shortcuts.";
+const MESSAGE$29 = "`accessKey` should not be used — accessKeys conflict with screen reader and OS-level shortcuts.";
 const isUndefinedIdentifier = (expression) => isNodeOfType(expression, "Identifier") && expression.name === "undefined";
 const noAccessKey = defineRule({
 	id: "no-access-key",
@@ -12957,7 +13043,7 @@ const noAccessKey = defineRule({
 		if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") {
 			context.report({
 				node: accessKey,
-				message: MESSAGE$27
+				message: MESSAGE$29
 			});
 			return;
 		}
@@ -12967,7 +13053,7 @@ const noAccessKey = defineRule({
 			if (isUndefinedIdentifier(expression)) return;
 			context.report({
 				node: accessKey,
-				message: MESSAGE$27
+				message: MESSAGE$29
 			});
 		}
 	} })
@@ -13276,7 +13362,7 @@ const getEffectFn = (analysis, node) => {
 	if (isNodeOfType(fn, "ArrowFunctionExpression") || isNodeOfType(fn, "FunctionExpression")) return fn;
 	if (isNodeOfType(fn, "Identifier")) {
 		const definitionNode = getRef(analysis, fn)?.resolved?.defs[0]?.node;
-		if (definitionNode && isFunctionLike$1(definitionNode)) return definitionNode;
+		if (definitionNode && isFunctionLike$2(definitionNode)) return definitionNode;
 		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
 			const initializer = definitionNode.init;
 			if (isNodeOfType(initializer, "ArrowFunctionExpression") || isNodeOfType(initializer, "FunctionExpression")) return initializer;
@@ -13369,14 +13455,14 @@ const getUseStateDecl = (analysis, ref) => {
 	return node ?? null;
 };
 const isCleanupReturnArgument = (analysis, node) => {
-	if (isFunctionLike$1(node)) return true;
+	if (isFunctionLike$2(node)) return true;
 	if (isNodeOfType(node, "MemberExpression")) return true;
 	if (isNodeOfType(node, "Identifier")) {
 		const definitionNode = getRef(analysis, node)?.resolved?.defs[0]?.node;
-		if (definitionNode && isFunctionLike$1(definitionNode)) return true;
+		if (definitionNode && isFunctionLike$2(definitionNode)) return true;
 		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
 			const initializer = definitionNode.init;
-			return isFunctionLike$1(initializer);
+			return isFunctionLike$2(initializer);
 		}
 	}
 	if (isNodeOfType(node, "ConditionalExpression")) return isCleanupReturnArgument(analysis, node.consequent) || isCleanupReturnArgument(analysis, node.alternate);
@@ -13386,7 +13472,7 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 	if (visited.has(node)) return false;
 	visited.add(node);
 	if (isNodeOfType(node, "ReturnStatement") && node.argument != null) return isCleanupReturnArgument(analysis, node.argument);
-	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$1(node)) return false;
+	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$2(node)) return false;
 	const record = node;
 	for (const [key, value] of Object.entries(record)) {
 		if (key === "parent") continue;
@@ -13398,7 +13484,7 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 };
 const hasCleanup = (analysis, node) => {
 	const fn = getEffectFn(analysis, node);
-	if (!isFunctionLike$1(fn)) return false;
+	if (!isFunctionLike$2(fn)) return false;
 	if (!isNodeOfType(fn.body, "BlockStatement")) return false;
 	return hasCleanupReturn(analysis, fn.body);
 };
@@ -13440,7 +13526,7 @@ const noAdjustStateOnPropChange = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-aria-hidden-on-focusable.ts
-const MESSAGE$26 = "Focusable elements must not have `aria-hidden=\"true\"` — focus would skip the hidden subtree, confusing keyboard users.";
+const MESSAGE$28 = "Focusable elements must not have `aria-hidden=\"true\"` — focus would skip the hidden subtree, confusing keyboard users.";
 const noAriaHiddenOnFocusable = defineRule({
 	id: "no-aria-hidden-on-focusable",
 	tags: ["react-jsx-only"],
@@ -13466,7 +13552,7 @@ const noAriaHiddenOnFocusable = defineRule({
 		const isImplicitlyFocusable = isInteractiveElement(tag, node);
 		if (isExplicitlyFocusable || isImplicitlyFocusable) context.report({
 			node: ariaHidden,
-			message: MESSAGE$26
+			message: MESSAGE$28
 		});
 	} })
 });
@@ -13746,7 +13832,7 @@ const isInsideStaticPlaceholderMap = (node) => {
 	let current = node;
 	while (current.parent) {
 		const parent = current.parent;
-		if (isFunctionLike$1(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+		if (isFunctionLike$2(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
 			const callee = parent.callee;
 			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach")) return isStaticPlaceholderReceiver(callee.object);
 			if (isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current) return isArrayFromLengthObjectCall(parent);
@@ -13765,7 +13851,7 @@ const findIteratorItemName$1 = (node) => {
 	let current = node;
 	while (current.parent) {
 		const parent = current.parent;
-		if (isFunctionLike$1(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+		if (isFunctionLike$2(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
 			const callee = parent.callee;
 			const isIteratorMethodCall = isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach");
 			const isArrayFromCallback = isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current;
@@ -13833,7 +13919,7 @@ const noArrayIndexAsKey = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-array-index-key.ts
-const MESSAGE$25 = "Array index in `key` doesn't uniquely identify the element — re-renders may use stale state.";
+const MESSAGE$27 = "Array index in `key` doesn't uniquely identify the element — re-renders may use stale state.";
 const SECOND_INDEX_METHODS = new Set([
 	"every",
 	"filter",
@@ -14035,7 +14121,7 @@ const noArrayIndexKey = defineRule({
 			}
 			context.report({
 				node: keyAttribute,
-				message: MESSAGE$25
+				message: MESSAGE$27
 			});
 		},
 		CallExpression(node) {
@@ -14055,7 +14141,7 @@ const noArrayIndexKey = defineRule({
 				if (propName !== "key") continue;
 				if (expressionUsesIndex(property.value, indexBinding.name)) context.report({
 					node: property,
-					message: MESSAGE$25
+					message: MESSAGE$27
 				});
 			}
 		}
@@ -14063,7 +14149,7 @@ const noArrayIndexKey = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-autofocus.ts
-const MESSAGE$24 = "`autoFocus` should not be used — it disrupts users who expect the page focus to remain at the top of the document on load.";
+const MESSAGE$26 = "`autoFocus` should not be used — it disrupts users who expect the page focus to remain at the top of the document on load.";
 const resolveSettings$21 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { ignoreNonDOM: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noAutofocus ?? {} : {}).ignoreNonDOM ?? true };
@@ -14118,7 +14204,7 @@ const noAutofocus = defineRule({
 			}
 			context.report({
 				node: autoFocusAttribute,
-				message: MESSAGE$24
+				message: MESSAGE$26
 			});
 		} };
 	}
@@ -14609,7 +14695,7 @@ const noChainStateUpdates = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-children-prop.ts
-const MESSAGE$23 = "Avoid passing children using a `children` prop — nest them between the JSX tags or pass them as additional `React.createElement` arguments instead.";
+const MESSAGE$25 = "Avoid passing children using a `children` prop — nest them between the JSX tags or pass them as additional `React.createElement` arguments instead.";
 const noChildrenProp = defineRule({
 	id: "no-children-prop",
 	severity: "warn",
@@ -14620,7 +14706,7 @@ const noChildrenProp = defineRule({
 			if (node.name.name !== "children") return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$23
+				message: MESSAGE$25
 			});
 		},
 		CallExpression(node) {
@@ -14633,7 +14719,7 @@ const noChildrenProp = defineRule({
 				const propertyKey = property.key;
 				if (isNodeOfType(propertyKey, "Identifier") && propertyKey.name === "children" || isNodeOfType(propertyKey, "Literal") && propertyKey.value === "children") context.report({
 					node: propertyKey,
-					message: MESSAGE$23
+					message: MESSAGE$25
 				});
 			}
 		}
@@ -14641,7 +14727,7 @@ const noChildrenProp = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-clone-element.ts
-const MESSAGE$22 = "`React.cloneElement` is uncommon and leads to fragile components.";
+const MESSAGE$24 = "`React.cloneElement` is uncommon and leads to fragile components.";
 const noCloneElement = defineRule({
 	id: "no-clone-element",
 	severity: "warn",
@@ -14653,7 +14739,7 @@ const noCloneElement = defineRule({
 		if (isNodeOfType(callee, "Identifier") && callee.name === "cloneElement") {
 			if (isImportedFromModule(node, "cloneElement", "react")) context.report({
 				node: callee,
-				message: MESSAGE$22
+				message: MESSAGE$24
 			});
 			return;
 		}
@@ -14666,14 +14752,231 @@ const noCloneElement = defineRule({
 			if (!isImportedFromModule(node, callee.object.name, "react")) return;
 			context.report({
 				node: callee,
-				message: MESSAGE$22
+				message: MESSAGE$24
 			});
 		}
 	} })
 });
 //#endregion
+//#region src/plugin/utils/component-or-hook-display-name.ts
+const hocWrapperCalleeName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+const displayNameFromFunctionBinding = (functionNode) => {
+	let current = functionNode;
+	for (;;) {
+		const parent = current.parent;
+		if (parent && isNodeOfType(parent, "CallExpression") && parent.arguments?.[0] === current) {
+			const calleeName = hocWrapperCalleeName(parent.callee);
+			if (calleeName && COMPONENT_HOC_WRAPPER_NAMES.has(calleeName)) {
+				current = parent;
+				continue;
+			}
+		}
+		break;
+	}
+	const binding = current.parent;
+	if (binding && isNodeOfType(binding, "VariableDeclarator") && isNodeOfType(binding.id, "Identifier") && binding.init === current) return isReactComponentOrHookName(binding.id.name) ? binding.id.name : null;
+	return null;
+};
+const componentOrHookDisplayNameForFunction = (functionNode) => {
+	if ((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id) return isReactComponentOrHookName(functionNode.id.name) ? functionNode.id.name : null;
+	return displayNameFromFunctionBinding(functionNode);
+};
+const nearestEnclosingFunction = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isFunctionLike$2(cursor)) return cursor;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/enclosing-component-or-hook-name.ts
+const enclosingComponentOrHookName = (node) => {
+	const functionNode = nearestEnclosingFunction(node);
+	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/no-create-context-in-render.ts
+const MESSAGE$23 = "createContext() called inside a component or hook — every render creates a brand new Context object, resetting every consumer and disconnecting Provider/Consumer pairs. Move createContext to module scope (outside the component) so the Context identity is stable across renders.";
+const CONTEXT_MODULES = [
+	"react",
+	"use-context-selector",
+	"react-tracked"
+];
+const isCreateContextCallee = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) {
+		for (const moduleName of CONTEXT_MODULES) if (getImportedNameFromModule(callee, callee.name, moduleName) === "createContext") return true;
+		return false;
+	}
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
+		const namespaceIdentifier = callee.object;
+		const propertyIdentifier = callee.property;
+		if (!isNodeOfType(namespaceIdentifier, "Identifier")) return false;
+		if (!isNodeOfType(propertyIdentifier, "Identifier")) return false;
+		if (propertyIdentifier.name !== "createContext") return false;
+		const namespaceName = namespaceIdentifier.name;
+		if (isCanonicalReactNamespaceName(namespaceName)) return true;
+		for (const moduleName of CONTEXT_MODULES) if (isImportedFromModule(namespaceIdentifier, namespaceName, moduleName)) return true;
+		return false;
+	}
+	return false;
+};
+const noCreateContextInRender = defineRule({
+	id: "no-create-context-in-render",
+	severity: "error",
+	category: "Correctness",
+	recommendation: "Move `createContext(...)` to module scope so its identity is stable across renders.",
+	create: (context) => ({ CallExpression(node) {
+		if (!isCreateContextCallee(node.callee)) return;
+		const componentOrHookName = enclosingComponentOrHookName(node);
+		if (!componentOrHookName) return;
+		context.report({
+			node,
+			message: `${MESSAGE$23} (called inside "${componentOrHookName}")`
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/state-and-effects/no-create-store-in-render.ts
+const STORE_FACTORIES = [
+	{
+		module: "zustand",
+		exportedName: "create",
+		humanLabel: "zustand.create"
+	},
+	{
+		module: "zustand",
+		exportedName: "createStore",
+		humanLabel: "zustand.createStore"
+	},
+	{
+		module: "zustand/vanilla",
+		exportedName: "createStore",
+		humanLabel: "zustand.createStore"
+	},
+	{
+		module: "zustand/vanilla",
+		exportedName: "create",
+		humanLabel: "zustand.create"
+	},
+	{
+		module: "redux",
+		exportedName: "createStore",
+		humanLabel: "redux.createStore"
+	},
+	{
+		module: "@reduxjs/toolkit",
+		exportedName: "configureStore",
+		humanLabel: "@reduxjs/toolkit.configureStore"
+	},
+	{
+		module: "@reduxjs/toolkit",
+		exportedName: "createSlice",
+		humanLabel: "createSlice"
+	},
+	{
+		module: "jotai",
+		exportedName: "atom",
+		humanLabel: "jotai.atom"
+	},
+	{
+		module: "jotai/vanilla",
+		exportedName: "atom",
+		humanLabel: "jotai.atom"
+	},
+	{
+		module: "jotai",
+		exportedName: "createStore",
+		humanLabel: "jotai.createStore"
+	},
+	{
+		module: "valtio",
+		exportedName: "proxy",
+		humanLabel: "valtio.proxy"
+	},
+	{
+		module: "valtio/vanilla",
+		exportedName: "proxy",
+		humanLabel: "valtio.proxy"
+	},
+	{
+		module: "mobx",
+		exportedName: "observable",
+		humanLabel: "mobx.observable"
+	},
+	{
+		module: "mobx",
+		exportedName: "makeAutoObservable",
+		humanLabel: "mobx.makeAutoObservable"
+	},
+	{
+		module: "mobx",
+		exportedName: "makeObservable",
+		humanLabel: "mobx.makeObservable"
+	},
+	{
+		module: "nanostores",
+		exportedName: "atom",
+		humanLabel: "nanostores.atom"
+	},
+	{
+		module: "nanostores",
+		exportedName: "map",
+		humanLabel: "nanostores.map"
+	},
+	{
+		module: "@xstate/store",
+		exportedName: "createStore",
+		humanLabel: "@xstate/store.createStore"
+	}
+];
+const STORE_FACTORY_LOOKUP = /* @__PURE__ */ new Map();
+for (const factory of STORE_FACTORIES) {
+	const bucket = STORE_FACTORY_LOOKUP.get(factory.exportedName) ?? [];
+	STORE_FACTORY_LOOKUP.set(factory.exportedName, [...bucket, factory]);
+}
+const resolveStoreFactoryForCallee = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) {
+		const localName = callee.name;
+		for (const factoryBucket of STORE_FACTORY_LOOKUP.values()) for (const factory of factoryBucket) if (getImportedNameFromModule(callee, localName, factory.module) === factory.exportedName) return factory;
+		return null;
+	}
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
+		const namespaceIdentifier = callee.object;
+		const propertyIdentifier = callee.property;
+		if (!isNodeOfType(namespaceIdentifier, "Identifier")) return null;
+		if (!isNodeOfType(propertyIdentifier, "Identifier")) return null;
+		const propertyName = propertyIdentifier.name;
+		const factoryBucket = STORE_FACTORY_LOOKUP.get(propertyName);
+		if (!factoryBucket) return null;
+		for (const factory of factoryBucket) if (isImportedFromModule(namespaceIdentifier, namespaceIdentifier.name, factory.module)) return factory;
+		return null;
+	}
+	return null;
+};
+const noCreateStoreInRender = defineRule({
+	id: "no-create-store-in-render",
+	severity: "error",
+	category: "Correctness",
+	recommendation: "Hoist the store/atom/observable construction to module scope — render functions and hooks must not allocate state containers.",
+	create: (context) => ({ CallExpression(node) {
+		const factory = resolveStoreFactoryForCallee(node.callee);
+		if (!factory) return;
+		const componentOrHookName = enclosingComponentOrHookName(node);
+		if (!componentOrHookName) return;
+		context.report({
+			node,
+			message: `\`${factory.humanLabel}(...)\` called inside "${componentOrHookName}" allocates a fresh state container on every render — subscribers disconnect, identities (action creators, reducer reference, store instance) churn, and persisted state resets. Hoist the call to module scope.`
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/react-builtins/no-danger.ts
-const MESSAGE$21 = "Do not use `dangerouslySetInnerHTML` — it injects raw HTML and is a common XSS vector.";
+const MESSAGE$22 = "Do not use `dangerouslySetInnerHTML` — it injects raw HTML and is a common XSS vector.";
 const noDanger = defineRule({
 	id: "no-danger",
 	severity: "warn",
@@ -14684,7 +14987,7 @@ const noDanger = defineRule({
 			if (!propAttribute) return;
 			context.report({
 				node: propAttribute.name,
-				message: MESSAGE$21
+				message: MESSAGE$22
 			});
 		},
 		CallExpression(node) {
@@ -14696,7 +14999,7 @@ const noDanger = defineRule({
 				const propertyKey = property.key;
 				if (isNodeOfType(propertyKey, "Identifier") && propertyKey.name === "dangerouslySetInnerHTML" || isNodeOfType(propertyKey, "Literal") && propertyKey.value === "dangerouslySetInnerHTML") context.report({
 					node: propertyKey,
-					message: MESSAGE$21
+					message: MESSAGE$22
 				});
 			}
 		}
@@ -14704,7 +15007,7 @@ const noDanger = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-danger-with-children.ts
-const MESSAGE$20 = "Only set one of `children` or `dangerouslySetInnerHTML` — React throws a runtime warning when both are present.";
+const MESSAGE$21 = "Only set one of `children` or `dangerouslySetInnerHTML` — React throws a runtime warning when both are present.";
 const isLineBreak = (child) => {
 	if (!isNodeOfType(child, "JSXText")) return false;
 	return child.value.trim().length === 0 && child.value.includes("\n");
@@ -14773,7 +15076,7 @@ const noDangerWithChildren = defineRule({
 			if (!hasChildrenProp && !hasNestedChildren) return;
 			if (hasJsxPropIgnoreCase(opening.attributes, "dangerouslySetInnerHTML") || spreadPropsShape.hasDangerously) context.report({
 				node: opening,
-				message: MESSAGE$20
+				message: MESSAGE$21
 			});
 		},
 		CallExpression(node) {
@@ -14785,7 +15088,7 @@ const noDangerWithChildren = defineRule({
 			if (!propsShape.hasDangerously) return;
 			if (node.arguments.length >= 3 || propsShape.hasChildren) context.report({
 				node,
-				message: MESSAGE$20
+				message: MESSAGE$21
 			});
 		}
 	})
@@ -15160,7 +15463,7 @@ const extractDestructuredPropNames = (params) => {
 };
 const getInlineFunctionNode = (node) => {
 	if (!node) return null;
-	if (isFunctionLike$1(node)) return node;
+	if (isFunctionLike$2(node)) return node;
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	for (const argument of node.arguments ?? []) {
 		const inlineFunctionNode = getInlineFunctionNode(argument);
@@ -15171,7 +15474,7 @@ const getInlineFunctionNode = (node) => {
 const getNearestComponentFunction = (node) => {
 	let cursor = node.parent ?? null;
 	while (cursor) {
-		if (isFunctionLike$1(cursor)) return cursor;
+		if (isFunctionLike$2(cursor)) return cursor;
 		cursor = cursor.parent ?? null;
 	}
 	return null;
@@ -15352,7 +15655,7 @@ const isSetStateCallInLifecycle = (setStateCall, lifecycleNames, options = {}) =
 //#endregion
 //#region src/plugin/rules/react-builtins/no-did-mount-set-state.ts
 const LIFECYCLE_NAMES$2 = new Set(["componentDidMount"]);
-const MESSAGE$19 = "Do not use `this.setState` in `componentDidMount`.";
+const MESSAGE$20 = "Do not use `this.setState` in `componentDidMount`.";
 const resolveSettings$20 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { mode: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noDidMountSetState ?? {} : {}).mode ?? "allowed" };
@@ -15370,7 +15673,7 @@ const noDidMountSetState = defineRule({
 			if (!isSetStateCallInLifecycle(node, LIFECYCLE_NAMES$2, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			context.report({
 				node: node.callee,
-				message: MESSAGE$19
+				message: MESSAGE$20
 			});
 		} };
 	}
@@ -15378,7 +15681,7 @@ const noDidMountSetState = defineRule({
 //#endregion
 //#region src/plugin/rules/react-builtins/no-did-update-set-state.ts
 const LIFECYCLE_NAMES$1 = new Set(["componentDidUpdate"]);
-const MESSAGE$18 = "Do not use `this.setState` in `componentDidUpdate` — it can cause infinite loops.";
+const MESSAGE$19 = "Do not use `this.setState` in `componentDidUpdate` — it can cause infinite loops.";
 const resolveSettings$19 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { mode: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noDidUpdateSetState ?? {} : {}).mode ?? "allowed" };
@@ -15396,7 +15699,7 @@ const noDidUpdateSetState = defineRule({
 			if (!isSetStateCallInLifecycle(node, LIFECYCLE_NAMES$1, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			context.report({
 				node: node.callee,
-				message: MESSAGE$18
+				message: MESSAGE$19
 			});
 		} };
 	}
@@ -15419,7 +15722,7 @@ const isStateMemberExpression = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/no-direct-mutation-state.ts
-const MESSAGE$17 = "Never mutate `this.state` directly.";
+const MESSAGE$18 = "Never mutate `this.state` directly.";
 const shouldIgnoreMutation = (node) => {
 	let isConstructor = false;
 	let isInsideCallExpression = false;
@@ -15441,7 +15744,7 @@ const reportIfStateMutation = (context, reportNode, target) => {
 	if (shouldIgnoreMutation(reportNode)) return;
 	context.report({
 		node: reportNode,
-		message: MESSAGE$17
+		message: MESSAGE$18
 	});
 };
 const noDirectMutationState = defineRule({
@@ -15497,7 +15800,7 @@ const collectFunctionLocalBindings = (functionNode) => {
 const walkComponentRespectingShadows = (node, shadowedStateNames, visit) => {
 	if (!node || typeof node !== "object") return;
 	let nextShadowedStateNames = shadowedStateNames;
-	if (isFunctionLike$1(node)) {
+	if (isFunctionLike$2(node)) {
 		const localBindings = collectFunctionLocalBindings(node);
 		if (localBindings.size > 0) {
 			const merged = new Set(shadowedStateNames);
@@ -15543,7 +15846,7 @@ const noDirectStateMutation = defineRule({
 					if (!isNodeOfType(callee, "MemberExpression")) return;
 					if (!isNodeOfType(callee.property, "Identifier")) return;
 					const methodName = callee.property.name;
-					if (!MUTATING_ARRAY_METHODS$1.has(methodName)) return;
+					if (!MUTATING_ARRAY_METHODS.has(methodName)) return;
 					const rootName = getRootIdentifierName(callee.object);
 					if (!rootName || !stateValueToSetter.has(rootName)) return;
 					if (currentlyShadowed.has(rootName)) return;
@@ -15604,7 +15907,7 @@ const noDisabledZoom = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-distracting-elements.ts
-const buildMessage$14 = (tag) => `\`<${tag}>\` is distracting and should not be used — replace with semantic, accessible markup.`;
+const buildMessage$16 = (tag) => `\`<${tag}>\` is distracting and should not be used — replace with semantic, accessible markup.`;
 const DEFAULT_DISTRACTING = ["marquee", "blink"];
 const resolveSettings$18 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
@@ -15624,7 +15927,7 @@ const noDistractingElements = defineRule({
 			const tag = getElementType(node, context.settings);
 			if (distractingTags.has(tag)) context.report({
 				node: node.name,
-				message: buildMessage$14(tag)
+				message: buildMessage$16(tag)
 			});
 		} };
 	}
@@ -16064,6 +16367,69 @@ const noEffectEventInDeps = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-effect-with-fresh-deps.ts
+const classifyFreshDependency = (expression) => {
+	const stripped = stripParenExpression(expression);
+	if (isNodeOfType(stripped, "ObjectExpression")) return "object";
+	if (isNodeOfType(stripped, "ArrayExpression")) return "array";
+	if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "FunctionExpression")) return "function";
+	if (isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment")) return "JSX";
+	if (isNodeOfType(stripped, "NewExpression")) return "instance";
+	return null;
+};
+const resolveDependencyFreshness = (dep) => {
+	const directKind = classifyFreshDependency(dep);
+	if (directKind) return {
+		kind: directKind,
+		viaBindingName: null
+	};
+	const stripped = stripParenExpression(dep);
+	if (!isNodeOfType(stripped, "Identifier")) return null;
+	const binding = findVariableInitializer(stripped, stripped.name);
+	if (!binding || !binding.initializer) return null;
+	if (binding.scopeOwner.type === "Program") return null;
+	const declarator = binding.bindingIdentifier.parent;
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== binding.initializer) return null;
+	const indirectKind = classifyFreshDependency(binding.initializer);
+	if (!indirectKind) return null;
+	return {
+		kind: indirectKind,
+		viaBindingName: stripped.name
+	};
+};
+const noEffectWithFreshDeps = defineRule({
+	id: "no-effect-with-fresh-deps",
+	severity: "error",
+	category: "State & Effects",
+	recommendation: "Move the constructed value into the hook body (so it's recomputed during render) and instead depend on its primitive inputs, or wrap the value in useMemo / useCallback so its reference is stable.",
+	create: (context) => ({ CallExpression(node) {
+		if (!isHookCall$1(node, HOOKS_WITH_DEPS)) return;
+		const args = node.arguments ?? [];
+		if (args.length < 2) return;
+		const depsNode = args[1];
+		if (!depsNode) return;
+		const stripped = stripParenExpression(depsNode);
+		if (!isNodeOfType(stripped, "ArrayExpression")) return;
+		const calleeNode = node.callee;
+		let hookName;
+		if (isNodeOfType(calleeNode, "Identifier")) hookName = calleeNode.name;
+		else if (isNodeOfType(calleeNode, "MemberExpression") && isNodeOfType(calleeNode.property, "Identifier")) hookName = calleeNode.property.name;
+		else hookName = "hook";
+		const elements = stripped.elements ?? [];
+		for (const element of elements) {
+			if (!element) continue;
+			if (isNodeOfType(element, "SpreadElement")) continue;
+			const freshness = resolveDependencyFreshness(element);
+			if (!freshness) continue;
+			const message = freshness.viaBindingName ? `${hookName} dep array element \`${freshness.viaBindingName}\` is a render-local ${freshness.kind} (declared in the same component scope); \`===\` will always fail because the binding is re-allocated each render. Hoist it to module scope or wrap it in useMemo/useCallback.` : `${hookName} dep array contains a freshly-allocated ${freshness.kind}; \`===\` will always fail on this element so the hook runs every render. Move the value into the hook body or memoize it with useMemo/useCallback so its reference is stable.`;
+			context.report({
+				node: element,
+				message
+			});
+		}
+	} })
+});
+//#endregion
 //#region src/plugin/rules/security/no-eval.ts
 const noEval = defineRule({
 	id: "no-eval",
@@ -16954,7 +17320,7 @@ const ALLOWED_NAMESPACES = new Set([
 	"ReactDOM",
 	"ReactDom"
 ]);
-const MESSAGE$16 = "Unexpected call to `findDOMNode` — removed in React 19.";
+const MESSAGE$17 = "Unexpected call to `findDOMNode` — removed in React 19.";
 const noFindDomNode = defineRule({
 	id: "no-find-dom-node",
 	severity: "warn",
@@ -16964,7 +17330,7 @@ const noFindDomNode = defineRule({
 		if (isNodeOfType(callee, "Identifier") && callee.name === "findDOMNode") {
 			context.report({
 				node: callee,
-				message: MESSAGE$16
+				message: MESSAGE$17
 			});
 			return;
 		}
@@ -16975,7 +17341,7 @@ const noFindDomNode = defineRule({
 			if (callee.property.name !== "findDOMNode") return;
 			context.report({
 				node: callee.property,
-				message: MESSAGE$16
+				message: MESSAGE$17
 			});
 		}
 	} })
@@ -17465,7 +17831,7 @@ const noInlinePropOnMemoComponent = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-interactive-element-to-noninteractive-role.ts
-const buildMessage$13 = (tag, role) => `Interactive element \`<${tag}>\` cannot have non-interactive role \`${role}\`.`;
+const buildMessage$15 = (tag, role) => `Interactive element \`<${tag}>\` cannot have non-interactive role \`${role}\`.`;
 const PRESENTATION_ROLES = ["presentation", "none"];
 const DEFAULT_ALLOWED_ROLES$1 = {
 	tr: ["none", "presentation"],
@@ -17509,7 +17875,7 @@ const noInteractiveElementToNoninteractiveRole = defineRule({
 			if (!isNonInteractiveRole(firstRole) && !PRESENTATION_ROLES.includes(firstRole)) return;
 			context.report({
 				node: roleAttribute,
-				message: buildMessage$13(elementType, firstRole)
+				message: buildMessage$15(elementType, firstRole)
 			});
 		} };
 	}
@@ -17710,7 +18076,7 @@ const isInsideClassBody = (node) => {
 	let current = node.parent;
 	while (current) {
 		if (isNodeOfType(current, "ClassBody")) return true;
-		if (isFunctionLike$1(current)) return false;
+		if (isFunctionLike$2(current)) return false;
 		current = current.parent;
 	}
 	return false;
@@ -17953,7 +18319,7 @@ const noMoment = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-multi-comp.ts
-const buildMessage$12 = (componentName) => `Declare only one React component per file. Found extra component: ${componentName}.`;
+const buildMessage$14 = (componentName) => `Declare only one React component per file. Found extra component: ${componentName}.`;
 const resolveSettings$16 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { ignoreStateless: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noMultiComp ?? {} : {}).ignoreStateless ?? false };
@@ -18274,7 +18640,7 @@ const noMultiComp = defineRule({
 			if (isSmallFeatureModule || isLargeFeatureModule || isVeryLargeFeatureModule) return;
 			for (const component of flagged.slice(1)) context.report({
 				node: component.reportNode,
-				message: buildMessage$12(component.name)
+				message: buildMessage$14(component.name)
 			});
 		} };
 	}
@@ -18351,25 +18717,315 @@ const noMutableInDeps = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-mutating-reducer-state.ts
-const MESSAGE$15 = "Reducer mutates its current state and returns the same reference. Return a copied object or array so React can observe the update.";
-const MUTATING_ARRAY_METHODS = new Set([
-	"copyWithin",
-	"fill",
-	"pop",
-	"push",
-	"reverse",
-	"shift",
-	"sort",
-	"splice",
-	"unshift"
-]);
-const MUTATING_COLLECTION_METHODS = new Set([
-	"add",
-	"clear",
-	"delete",
-	"set"
+//#region src/plugin/rules/state-and-effects/utils/lodash-mutator-call.ts
+const LODASH_MUTATOR_NAMES = new Set([
+	"set",
+	"unset",
+	"update",
+	"merge",
+	"defaults",
+	"defaultsDeep",
+	"assign",
+	"assignIn",
+	"pull",
+	"pullAll",
+	"pullAllBy",
+	"pullAt",
+	"remove",
+	"fill"
 ]);
+const LODASH_MUTATING_MODULES = new Set(["lodash", "lodash-es"]);
+const isLodashMutatingImport = (sourceValue) => {
+	if (LODASH_MUTATING_MODULES.has(sourceValue)) return true;
+	if (sourceValue.startsWith("lodash/fp") || sourceValue.startsWith("lodash-es/fp")) return false;
+	if (sourceValue.startsWith("lodash/") || sourceValue.startsWith("lodash-es/")) return true;
+	return false;
+};
+const isLodashMutatorCall = (callExpression) => {
+	if (!isNodeOfType(callExpression, "CallExpression")) return false;
+	const callee = callExpression.callee;
+	if (isNodeOfType(callee, "Identifier")) {
+		if (!LODASH_MUTATOR_NAMES.has(callee.name)) return false;
+		const initializer = findVariableInitializer(callee, callee.name)?.initializer;
+		if (!initializer) return false;
+		if (!isNodeOfType(initializer, "ImportSpecifier") && !isNodeOfType(initializer, "ImportDefaultSpecifier") && !isNodeOfType(initializer, "ImportNamespaceSpecifier")) return false;
+		const importDeclaration = initializer.parent;
+		if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return false;
+		const sourceValue = importDeclaration.source?.value;
+		if (typeof sourceValue !== "string") return false;
+		return isLodashMutatingImport(sourceValue);
+	}
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
+		const propertyName = getStaticMemberPropertyName(callee);
+		if (!propertyName || !LODASH_MUTATOR_NAMES.has(propertyName)) return false;
+		const receiver = callee.object;
+		if (!isNodeOfType(receiver, "Identifier")) return false;
+		const initializer = findVariableInitializer(receiver, receiver.name)?.initializer;
+		if (!initializer) return false;
+		if (!isNodeOfType(initializer, "ImportNamespaceSpecifier") && !isNodeOfType(initializer, "ImportDefaultSpecifier")) return false;
+		const importDeclaration = initializer.parent;
+		if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return false;
+		const sourceValue = importDeclaration.source?.value;
+		if (typeof sourceValue !== "string") return false;
+		return isLodashMutatingImport(sourceValue);
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/find-exported-function-body.ts
+const isFunctionLike = (node) => {
+	if (!node) return false;
+	return isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
+};
+const findExportedFunctionBody = (programRoot, exportedName) => {
+	if (!isNodeOfType(programRoot, "Program")) return null;
+	const localBindings = /* @__PURE__ */ new Map();
+	const namedExports = /* @__PURE__ */ new Map();
+	let defaultExport = null;
+	let defaultExportIdentifierName = null;
+	const recordVariableDeclaration = (declaration) => {
+		for (const declarator of declaration.declarations ?? []) {
+			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
+			if (initializer && isFunctionLike(initializer)) localBindings.set(declarator.id.name, initializer);
+		}
+	};
+	for (const statement of programRoot.body ?? []) {
+		if (isNodeOfType(statement, "VariableDeclaration")) {
+			recordVariableDeclaration(statement);
+			continue;
+		}
+		if (isNodeOfType(statement, "FunctionDeclaration") && statement.id) {
+			localBindings.set(statement.id.name, statement);
+			continue;
+		}
+		if (isNodeOfType(statement, "ExportNamedDeclaration")) {
+			const declaration = statement.declaration;
+			if (declaration && isNodeOfType(declaration, "VariableDeclaration")) {
+				recordVariableDeclaration(declaration);
+				for (const declarator of declaration.declarations ?? []) {
+					if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+					if (!isNodeOfType(declarator.id, "Identifier")) continue;
+					namedExports.set(declarator.id.name, declarator.id.name);
+				}
+			} else if (declaration && isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
+				localBindings.set(declaration.id.name, declaration);
+				namedExports.set(declaration.id.name, declaration.id.name);
+			}
+			for (const specifier of statement.specifiers ?? []) {
+				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+				const local = specifier.local;
+				const exported = specifier.exported;
+				if (!isNodeOfType(local, "Identifier")) continue;
+				const exportedNameSpec = isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null;
+				if (!exportedNameSpec) continue;
+				namedExports.set(exportedNameSpec, local.name);
+			}
+			continue;
+		}
+		if (isNodeOfType(statement, "ExportDefaultDeclaration")) {
+			const declaration = statement.declaration;
+			if (!declaration) continue;
+			if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
+				localBindings.set(declaration.id.name, declaration);
+				defaultExport = declaration;
+				continue;
+			}
+			if (isFunctionLike(declaration)) {
+				defaultExport = declaration;
+				continue;
+			}
+			if (isNodeOfType(declaration, "Identifier")) {
+				defaultExportIdentifierName = declaration.name;
+				continue;
+			}
+		}
+	}
+	if (exportedName === "default") {
+		if (defaultExport) return defaultExport;
+		if (defaultExportIdentifierName) {
+			const binding = localBindings.get(defaultExportIdentifierName);
+			if (binding) return binding;
+		}
+	}
+	const localName = namedExports.get(exportedName);
+	if (!localName) return null;
+	return localBindings.get(localName) ?? null;
+};
+const resolveImportedExportName = (importSpecifier) => {
+	if (isNodeOfType(importSpecifier, "ImportSpecifier")) {
+		const imported = importSpecifier.imported;
+		if (isNodeOfType(imported, "Identifier")) return imported.name;
+		if (isNodeOfType(imported, "Literal") && typeof imported.value === "string") return imported.value;
+		return null;
+	}
+	if (isNodeOfType(importSpecifier, "ImportDefaultSpecifier")) return "default";
+	return null;
+};
+const findReExportSourcesForName = (programRoot, exportedName) => {
+	if (!isNodeOfType(programRoot, "Program")) return [];
+	const exportAllSources = [];
+	for (const statement of programRoot.body ?? []) {
+		if (isNodeOfType(statement, "ExportNamedDeclaration") && statement.source) {
+			const sourceValue = statement.source.value;
+			if (typeof sourceValue !== "string") continue;
+			for (const specifier of statement.specifiers ?? []) {
+				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+				const exported = specifier.exported;
+				if ((isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null) === exportedName) return [sourceValue];
+			}
+		}
+		if (isNodeOfType(statement, "ExportAllDeclaration") && statement.source) {
+			const sourceValue = statement.source.value;
+			if (typeof sourceValue === "string") exportAllSources.push(sourceValue);
+		}
+	}
+	return exportAllSources;
+};
+//#endregion
+//#region src/plugin/utils/attach-parent-references.ts
+const attachParentReferences = (root) => {
+	const visit = (node, parent) => {
+		const writableNode = node;
+		writableNode.parent = parent;
+		const nodeRecord = node;
+		for (const key of Object.keys(nodeRecord)) {
+			if (key === "parent") continue;
+			const child = nodeRecord[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item, node);
+			} else if (isAstNode(child)) visit(child, node);
+		}
+	};
+	visit(root, null);
+};
+//#endregion
+//#region src/plugin/utils/parse-source-file.ts
+const FILENAME_TO_LANG = {
+	".ts": "ts",
+	".tsx": "tsx",
+	".js": "js",
+	".jsx": "jsx",
+	".mjs": "js",
+	".cjs": "js",
+	".mts": "ts",
+	".cts": "ts"
+};
+const resolveLang = (filename) => {
+	return FILENAME_TO_LANG[path.extname(filename).toLowerCase()] ?? "tsx";
+};
+const parseCache = /* @__PURE__ */ new Map();
+const parseSourceFile = (absoluteFilePath) => {
+	let fileStat;
+	try {
+		fileStat = fs.statSync(absoluteFilePath);
+	} catch {
+		return null;
+	}
+	if (!fileStat.isFile()) return null;
+	if (fileStat.size > 2e6) return null;
+	const cached = parseCache.get(absoluteFilePath);
+	if (cached && cached.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) return cached.program;
+	if (absoluteFilePath.endsWith(".d.ts") || absoluteFilePath.endsWith(".d.mts") || absoluteFilePath.endsWith(".d.cts")) {
+		parseCache.set(absoluteFilePath, {
+			mtimeMs: fileStat.mtimeMs,
+			size: fileStat.size,
+			program: null
+		});
+		return null;
+	}
+	let sourceText;
+	try {
+		sourceText = fs.readFileSync(absoluteFilePath, "utf8");
+	} catch {
+		parseCache.set(absoluteFilePath, {
+			mtimeMs: fileStat.mtimeMs,
+			size: fileStat.size,
+			program: null
+		});
+		return null;
+	}
+	let parsedProgram = null;
+	try {
+		const result = parseSync(absoluteFilePath, sourceText, {
+			astType: "ts",
+			lang: resolveLang(absoluteFilePath)
+		});
+		if (!result.errors.some((parseError) => parseError.severity === "Error")) {
+			parsedProgram = result.program;
+			attachParentReferences(parsedProgram);
+		}
+	} catch {
+		parsedProgram = null;
+	}
+	parseCache.set(absoluteFilePath, {
+		mtimeMs: fileStat.mtimeMs,
+		size: fileStat.size,
+		program: parsedProgram
+	});
+	return parsedProgram;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/resolve-reducer-function.ts
+const resolveFunctionExportInFile = (filePath, exportedName, visitedFilePaths) => {
+	if (visitedFilePaths.size >= 4) return null;
+	if (visitedFilePaths.has(filePath)) return null;
+	visitedFilePaths.add(filePath);
+	const actualFilePath = resolveBarrelExportFilePath(filePath, exportedName) ?? filePath;
+	const programRoot = parseSourceFile(actualFilePath);
+	if (!programRoot) return null;
+	const exported = findExportedFunctionBody(programRoot, exportedName);
+	if (exported) return exported;
+	for (const reExportSource of findReExportSourcesForName(programRoot, exportedName)) {
+		const nextFilePath = resolveRelativeImportPath(actualFilePath, reExportSource);
+		if (!nextFilePath) continue;
+		const resolved = resolveFunctionExportInFile(nextFilePath, exportedName, visitedFilePaths);
+		if (resolved) return resolved;
+	}
+	return null;
+};
+const resolveCrossFileFunctionExport = (fromFilename, source, exportedName) => {
+	const resolvedFilePath = resolveRelativeImportPath(fromFilename, source);
+	if (!resolvedFilePath) return null;
+	return resolveFunctionExportInFile(resolvedFilePath, exportedName, /* @__PURE__ */ new Set());
+};
+const resolveReducerFunction = (node, currentFilename) => {
+	if (!node) return null;
+	const unwrappedNode = stripParenExpression(node);
+	if (isFunctionLike$2(unwrappedNode)) return {
+		functionNode: unwrappedNode,
+		crossFileSourceDisplay: null
+	};
+	if (!isNodeOfType(unwrappedNode, "Identifier")) return null;
+	const initializer = findVariableInitializer(unwrappedNode, unwrappedNode.name)?.initializer;
+	if (!initializer) return null;
+	const unwrappedInitializer = stripParenExpression(initializer);
+	if (isFunctionLike$2(unwrappedInitializer)) return {
+		functionNode: unwrappedInitializer,
+		crossFileSourceDisplay: null
+	};
+	if (isNodeOfType(initializer, "ImportSpecifier") || isNodeOfType(initializer, "ImportDefaultSpecifier")) {
+		if (!currentFilename) return null;
+		const importDeclaration = initializer.parent;
+		if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return null;
+		const sourceValue = importDeclaration.source?.value;
+		if (typeof sourceValue !== "string") return null;
+		if (!sourceValue.startsWith(".") && !sourceValue.startsWith("/")) return null;
+		const exportedName = resolveImportedExportName(initializer);
+		if (!exportedName) return null;
+		const crossFileFunction = resolveCrossFileFunctionExport(currentFilename, sourceValue, exportedName);
+		if (!crossFileFunction) return null;
+		return {
+			functionNode: crossFileFunction,
+			crossFileSourceDisplay: sourceValue
+		};
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/no-mutating-reducer-state.ts
+const MESSAGE$16 = "Reducer mutates its current state and returns the same reference. Return a copied object or array so React can observe the update.";
 const SAME_REFERENCE_ARRAY_RETURN_METHODS = new Set([
 	"copyWithin",
 	"fill",
@@ -18388,7 +19044,6 @@ const cloneReducerPathState = (state) => ({
 	mutableStateSourceNames: new Set(state.mutableStateSourceNames),
 	mutations: [...state.mutations]
 });
-const isFunctionLikeAstNode = (node) => Boolean(node && (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")));
 const isSpecifierImportedFromReact = (node) => {
 	const parent = node.parent ?? null;
 	return parent !== null && isNodeOfType(parent, "ImportDeclaration") && parent.source.value === "react";
@@ -18415,19 +19070,16 @@ const isCallToImportedReactUseReducer = (node) => {
 	const binding = findVariableInitializer(callee.object, callee.object.name);
 	return Boolean(binding?.initializer && isReactNamespaceOrDefaultImportSpecifier(binding.initializer));
 };
-const resolveSameFileReducerFunction = (node) => {
-	if (!node) return null;
-	const unwrappedNode = stripParenExpression(node);
-	if (isFunctionLikeAstNode(unwrappedNode)) return unwrappedNode;
-	if (!isNodeOfType(unwrappedNode, "Identifier")) return null;
-	const initializer = findVariableInitializer(unwrappedNode, unwrappedNode.name)?.initializer;
-	if (!initializer) return null;
-	const unwrappedInitializer = stripParenExpression(initializer);
-	return isFunctionLikeAstNode(unwrappedInitializer) ? unwrappedInitializer : null;
-};
 const isStaticMethodCallOnNamedObject = (node, objectName, methodNames) => {
 	const unwrappedNode = stripParenExpression(node);
-	return Boolean(isNodeOfType(unwrappedNode, "CallExpression") && isNodeOfType(unwrappedNode.callee, "MemberExpression") && isNodeOfType(unwrappedNode.callee.object, "Identifier") && unwrappedNode.callee.object.name === objectName && methodNames.has(getStaticMemberPropertyName(unwrappedNode.callee) ?? ""));
+	if (!isNodeOfType(unwrappedNode, "CallExpression")) return false;
+	if (!isNodeOfType(unwrappedNode.callee, "MemberExpression")) return false;
+	const calleeObject = unwrappedNode.callee.object;
+	if (!isNodeOfType(calleeObject, "Identifier")) return false;
+	if (calleeObject.name !== objectName) return false;
+	if (!methodNames.has(getStaticMemberPropertyName(unwrappedNode.callee) ?? "")) return false;
+	if (findVariableInitializer(calleeObject, calleeObject.name)) return false;
+	return true;
 };
 const isExpressionRootedInMutableReducerStateSource = (node, state) => {
 	let current = stripParenExpression(node);
@@ -18463,11 +19115,11 @@ const canExpressionReturnOriginalReducerStateReference = (node, state) => {
 	return false;
 };
 const collectReducerStateMutationsInExpressionOrStatement = (node, state) => {
-	if (isFunctionLikeAstNode(node)) return [];
+	if (isFunctionLike$2(node)) return [];
 	const mutations = [];
 	walkAst(node, (child) => {
 		const unwrappedChild = stripParenExpression(child);
-		if (child !== node && isFunctionLikeAstNode(unwrappedChild)) return false;
+		if (child !== node && isFunctionLike$2(unwrappedChild)) return false;
 		if (isNodeOfType(unwrappedChild, "AssignmentExpression")) {
 			if (isNodeOfType(stripParenExpression(unwrappedChild.left), "MemberExpression") && isExpressionRootedInMutableReducerStateSource(unwrappedChild.left, state)) mutations.push({ node: unwrappedChild });
 			return;
@@ -18486,6 +19138,10 @@ const collectReducerStateMutationsInExpressionOrStatement = (node, state) => {
 			mutations.push({ node: unwrappedChild });
 			return;
 		}
+		if (firstArgument && isExpressionRootedInMutableReducerStateSource(firstArgument, state) && isLodashMutatorCall(unwrappedChild)) {
+			mutations.push({ node: unwrappedChild });
+			return;
+		}
 		if (!isNodeOfType(unwrappedChild.callee, "MemberExpression")) return;
 		const methodName = getStaticMemberPropertyName(unwrappedChild.callee);
 		if (!methodName || !MUTATING_ARRAY_METHODS.has(methodName) && !MUTATING_COLLECTION_METHODS.has(methodName)) return;
@@ -18512,18 +19168,47 @@ const restoreOuterIdentityForBlockScopedNames = (blockState, outerState, blockSc
 	}
 	return nextState;
 };
+const recordDestructuredAliasNames = (pattern, state) => {
+	if (isNodeOfType(pattern, "ObjectPattern")) {
+		for (const property of pattern.properties ?? []) {
+			if (!isNodeOfType(property, "Property")) continue;
+			const valueNode = property.value;
+			let leafIdentifier = null;
+			if (isNodeOfType(valueNode, "Identifier")) leafIdentifier = valueNode;
+			else if (isNodeOfType(valueNode, "AssignmentPattern") && isNodeOfType(valueNode.left, "Identifier")) leafIdentifier = valueNode.left;
+			if (!leafIdentifier) continue;
+			state.mutableStateSourceNames.add(leafIdentifier.name);
+		}
+		return;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) for (const element of pattern.elements ?? []) {
+		if (!element) continue;
+		if (isNodeOfType(element, "Identifier")) {
+			state.mutableStateSourceNames.add(element.name);
+			continue;
+		}
+		if (isNodeOfType(element, "AssignmentPattern") && isNodeOfType(element.left, "Identifier")) {
+			state.mutableStateSourceNames.add(element.left.name);
+			continue;
+		}
+		if (isNodeOfType(element, "RestElement") && isNodeOfType(element.argument, "Identifier")) {}
+	}
+};
 const updateReducerStateIdentityForVariableDeclaration = (declaration, state) => {
 	for (const declarator of declaration.declarations ?? []) {
-		if (!isNodeOfType(declarator.id, "Identifier")) continue;
-		const name = declarator.id.name;
-		state.originalStateReferenceNames.delete(name);
-		state.mutableStateSourceNames.delete(name);
-		if (isExpressionOriginalReducerStateReference(declarator.init, state)) {
-			state.originalStateReferenceNames.add(name);
-			state.mutableStateSourceNames.add(name);
+		if (isNodeOfType(declarator.id, "Identifier")) {
+			const name = declarator.id.name;
+			state.originalStateReferenceNames.delete(name);
+			state.mutableStateSourceNames.delete(name);
+			if (isExpressionOriginalReducerStateReference(declarator.init, state)) {
+				state.originalStateReferenceNames.add(name);
+				state.mutableStateSourceNames.add(name);
+				continue;
+			}
+			if (isExpressionReachableFromOriginalReducerState(declarator.init, state)) state.mutableStateSourceNames.add(name);
 			continue;
 		}
-		if (isExpressionReachableFromOriginalReducerState(declarator.init, state)) state.mutableStateSourceNames.add(name);
+		if ((isNodeOfType(declarator.id, "ObjectPattern") || isNodeOfType(declarator.id, "ArrayPattern")) && isExpressionReachableFromOriginalReducerState(declarator.init, state)) recordDestructuredAliasNames(declarator.id, state);
 	}
 };
 const updateReducerStateIdentityForIdentifierAssignment = (assignment, state) => {
@@ -18538,24 +19223,40 @@ const updateReducerStateIdentityForIdentifierAssignment = (assignment, state) =>
 	}
 	if (isExpressionReachableFromOriginalReducerState(assignment.right, state)) state.mutableStateSourceNames.add(name);
 };
-const analyzeReactUseReducerFunctionForStateMutation = (context, functionNode, reportedNodes) => {
-	if (!isFunctionLikeAstNode(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return;
+const analyzeReactUseReducerFunctionForStateMutation = (context, functionNode, reportedNodes, options) => {
+	if (!isFunctionLike$2(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return;
 	const firstParam = functionNode.params?.[0];
 	const stateName = isNodeOfType(firstParam, "Identifier") ? firstParam.name : isNodeOfType(firstParam, "AssignmentPattern") && isNodeOfType(firstParam.left, "Identifier") ? firstParam.left.name : null;
 	if (!stateName) return;
 	const reportReducerStateMutations = (mutations) => {
+		if (mutations.length === 0) return;
+		if (options.crossFileConsumerCallSite && options.crossFileSourceDisplay) {
+			if (reportedNodes.has(options.crossFileConsumerCallSite)) return;
+			reportedNodes.add(options.crossFileConsumerCallSite);
+			context.report({
+				node: options.crossFileConsumerCallSite,
+				message: `${MESSAGE$16} (mutation in imported reducer at \`${options.crossFileSourceDisplay}\`)`
+			});
+			return;
+		}
 		for (const mutation of mutations) {
 			if (reportedNodes.has(mutation.node)) continue;
 			reportedNodes.add(mutation.node);
 			context.report({
 				node: mutation.node,
-				message: MESSAGE$15
+				message: MESSAGE$16
 			});
 		}
 	};
+	let pathBudgetExceeded = false;
 	const analyzeReducerStatementListByPath = (statements, initialState) => {
+		if (pathBudgetExceeded) return [cloneReducerPathState(initialState)];
 		let activeStates = [cloneReducerPathState(initialState)];
 		for (const statement of statements) {
+			if (activeStates.length > 1e3) {
+				pathBudgetExceeded = true;
+				break;
+			}
 			const nextStates = [];
 			for (const activeState of activeStates) {
 				if (isNodeOfType(statement, "ReturnStatement")) {
@@ -18624,18 +19325,23 @@ const noMutatingReducerState = defineRule({
 	create: (context) => {
 		const analyzedReducers = /* @__PURE__ */ new WeakSet();
 		const reportedNodes = /* @__PURE__ */ new WeakSet();
+		const currentFilename = context.filename;
 		return { CallExpression(node) {
 			if (!isCallToImportedReactUseReducer(node)) return;
-			const reducerFunction = resolveSameFileReducerFunction(node.arguments?.[0]);
-			if (!reducerFunction || analyzedReducers.has(reducerFunction)) return;
-			analyzedReducers.add(reducerFunction);
-			analyzeReactUseReducerFunctionForStateMutation(context, reducerFunction, reportedNodes);
+			const resolved = resolveReducerFunction(node.arguments?.[0], currentFilename);
+			if (!resolved) return;
+			if (analyzedReducers.has(resolved.functionNode)) return;
+			analyzedReducers.add(resolved.functionNode);
+			analyzeReactUseReducerFunctionForStateMutation(context, resolved.functionNode, reportedNodes, {
+				crossFileConsumerCallSite: resolved.crossFileSourceDisplay ? node : null,
+				crossFileSourceDisplay: resolved.crossFileSourceDisplay
+			});
 		} };
 	}
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-namespace.ts
-const buildMessage$11 = (componentName) => `React component \`${componentName}\` must not be in a namespace — React doesn't support them.`;
+const buildMessage$13 = (componentName) => `React component \`${componentName}\` must not be in a namespace — React doesn't support them.`;
 const noNamespace = defineRule({
 	id: "no-namespace",
 	severity: "warn",
@@ -18647,7 +19353,7 @@ const noNamespace = defineRule({
 			const fullName = `${namespaced.namespace.name}:${namespaced.name.name}`;
 			context.report({
 				node: namespaced,
-				message: buildMessage$11(fullName)
+				message: buildMessage$13(fullName)
 			});
 		},
 		CallExpression(node) {
@@ -18658,7 +19364,7 @@ const noNamespace = defineRule({
 			if (!firstArgument.value.includes(":")) return;
 			context.report({
 				node: firstArgument,
-				message: buildMessage$11(firstArgument.value)
+				message: buildMessage$13(firstArgument.value)
 			});
 		}
 	})
@@ -18702,7 +19408,7 @@ const noNestedComponentDefinition = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-noninteractive-element-interactions.ts
-const buildMessage$10 = (tag) => `Non-interactive element \`<${tag}>\` should not have interactive event handlers — convert to a semantic interactive element or add an interactive role.`;
+const buildMessage$12 = (tag) => `Non-interactive element \`<${tag}>\` should not have interactive event handlers — convert to a semantic interactive element or add an interactive role.`;
 const INTERACTIVE_HANDLERS = [
 	"onClick",
 	"onMouseDown",
@@ -18728,13 +19434,13 @@ const noNoninteractiveElementInteractions = defineRule({
 		}
 		context.report({
 			node: node.name,
-			message: buildMessage$10(tag)
+			message: buildMessage$12(tag)
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-noninteractive-element-to-interactive-role.ts
-const buildMessage$9 = (tag, role) => `Non-interactive element \`<${tag}>\` cannot have interactive role \`${role}\` — use a semantic interactive element instead.`;
+const buildMessage$11 = (tag, role) => `Non-interactive element \`<${tag}>\` cannot have interactive role \`${role}\` — use a semantic interactive element instead.`;
 const DEFAULT_ALLOWED_ROLES = {
 	ul: [
 		"menu",
@@ -18798,14 +19504,14 @@ const noNoninteractiveElementToInteractiveRole = defineRule({
 			if (!isInteractiveRole(firstRole)) return;
 			context.report({
 				node: roleAttribute,
-				message: buildMessage$9(elementType, firstRole)
+				message: buildMessage$11(elementType, firstRole)
 			});
 		} };
 	}
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-noninteractive-tabindex.ts
-const MESSAGE$14 = "Don't add `tabIndex` to non-interactive elements — keyboard users would have no expected behavior on focus.";
+const MESSAGE$15 = "Don't add `tabIndex` to non-interactive elements — keyboard users would have no expected behavior on focus.";
 const resolveSettings$14 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noNoninteractiveTabindex ?? {} : {};
@@ -18832,7 +19538,7 @@ const noNoninteractiveTabindex = defineRule({
 			if (numeric === null) {
 				if (isNodeOfType(tabIndexValue, "JSXExpressionContainer") && !settings.allowExpressionValues) context.report({
 					node: tabIndex,
-					message: MESSAGE$14
+					message: MESSAGE$15
 				});
 				return;
 			}
@@ -18845,7 +19551,7 @@ const noNoninteractiveTabindex = defineRule({
 			if (!roleAttribute) {
 				context.report({
 					node: tabIndex,
-					message: MESSAGE$14
+					message: MESSAGE$15
 				});
 				return;
 			}
@@ -18859,7 +19565,7 @@ const noNoninteractiveTabindex = defineRule({
 			}
 			context.report({
 				node: tabIndex,
-				message: MESSAGE$14
+				message: MESSAGE$15
 			});
 		} };
 	}
@@ -19388,6 +20094,63 @@ const noPropCallbackInEffect = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/architecture/no-prop-types.ts
+const PROP_TYPES_PROPERTY = "propTypes";
+const isPropTypesKey = (key, computed) => {
+	if (!key) return false;
+	if (computed) return isNodeOfType(key, "Literal") && key.value === PROP_TYPES_PROPERTY;
+	return isNodeOfType(key, "Identifier") && key.name === PROP_TYPES_PROPERTY;
+};
+const getComponentNameFromPropTypesAssignment = (left) => {
+	if (!isNodeOfType(left, "MemberExpression")) return null;
+	if (!isPropTypesKey(left.property, Boolean(left.computed))) return null;
+	if (!isNodeOfType(left.object, "Identifier")) return null;
+	if (!isUppercaseName(left.object.name)) return null;
+	return left.object.name;
+};
+const getComponentNameFromClassProperty = (node) => {
+	if (!node.static) return null;
+	if (!isPropTypesKey(node.key, Boolean(node.computed))) return null;
+	const classBody = node.parent;
+	if (!isNodeOfType(classBody, "ClassBody")) return null;
+	const classNode = classBody.parent;
+	if (!classNode) return null;
+	if ((isNodeOfType(classNode, "ClassDeclaration") || isNodeOfType(classNode, "ClassExpression")) && classNode.id?.name && isUppercaseName(classNode.id.name)) return classNode.id.name;
+	if (!isNodeOfType(classNode, "ClassExpression")) return null;
+	const declarator = classNode.parent;
+	if (!isNodeOfType(declarator, "VariableDeclarator")) return null;
+	if (!isNodeOfType(declarator.id, "Identifier")) return null;
+	if (!isUppercaseName(declarator.id.name)) return null;
+	return declarator.id.name;
+};
+const buildMessage$10 = (componentName) => `${componentName}.propTypes — React 19 no longer runs \`propTypes\` checks, so invalid props pass silently. Move the prop contract to TypeScript types and add explicit runtime validation only where data can actually be invalid`;
+const noPropTypes = defineRule({
+	id: "no-prop-types",
+	requires: ["react:19"],
+	tags: ["test-noise"],
+	severity: "warn",
+	recommendation: "React 19 removed runtime `propTypes` validation — React no longer reads `Component.propTypes`, so invalid props pass silently. Describe props with TypeScript types and move any required runtime validation to explicit checks (or schema parsing) in component code. Only enabled on projects detected as React 19+.",
+	create: (context) => ({
+		AssignmentExpression(node) {
+			if (node.operator !== "=") return;
+			const componentName = getComponentNameFromPropTypesAssignment(node.left);
+			if (!componentName) return;
+			context.report({
+				node: node.left,
+				message: buildMessage$10(componentName)
+			});
+		},
+		PropertyDefinition(node) {
+			const componentName = getComponentNameFromClassProperty(node);
+			if (!componentName) return;
+			context.report({
+				node: node.key,
+				message: buildMessage$10(componentName)
+			});
+		}
+	})
+});
+//#endregion
 //#region src/plugin/rules/design/no-pure-black-background.ts
 const noPureBlackBackground = defineRule({
 	id: "no-pure-black-background",
@@ -19419,8 +20182,94 @@ const noPureBlackBackground = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/rules/correctness/no-random-key.ts
+const ALWAYS_FRESH_DIRECT_CALLEES = new Set([
+	"nanoid",
+	"uuid",
+	"uuidv4",
+	"uuidV4",
+	"v4",
+	"cuid",
+	"cuid2",
+	"createId",
+	"ulid",
+	"objectid",
+	"ObjectId",
+	"shortid"
+]);
+const ALWAYS_FRESH_MEMBER_RECEIVERS = new Map([
+	["Math", new Set(["random"])],
+	["Date", new Set(["now"])],
+	["performance", new Set(["now"])],
+	["crypto", new Set([
+		"randomUUID",
+		"getRandomValues",
+		"randomBytes"
+	])]
+]);
+const isAlwaysFreshExpression = (expression) => {
+	const stripped = stripParenExpression(expression);
+	if (isNodeOfType(stripped, "NewExpression")) {
+		if (isNodeOfType(stripped.callee, "Identifier") && stripped.callee.name === "Date") return "new Date()";
+	}
+	if (!isNodeOfType(stripped, "CallExpression")) return null;
+	const callee = stripped.callee;
+	if (isNodeOfType(callee, "Identifier")) {
+		if (!ALWAYS_FRESH_DIRECT_CALLEES.has(callee.name)) return null;
+		const binding = findVariableInitializer(callee, callee.name);
+		if (binding?.initializer && !isNodeOfType(binding.initializer, "ImportSpecifier") && !isNodeOfType(binding.initializer, "ImportDefaultSpecifier") && !isNodeOfType(binding.initializer, "ImportNamespaceSpecifier")) return null;
+		return `${callee.name}()`;
+	}
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
+		const receiver = callee.object;
+		const property = callee.property;
+		if (!isNodeOfType(property, "Identifier")) return null;
+		if (isNodeOfType(receiver, "Identifier")) {
+			if (ALWAYS_FRESH_MEMBER_RECEIVERS.get(receiver.name)?.has(property.name)) return `${receiver.name}.${property.name}()`;
+		}
+	}
+	return null;
+};
+const variableLabelForUpdateArgument = (argument) => {
+	if (!argument) return "counter";
+	const stripped = stripParenExpression(argument);
+	if (isNodeOfType(stripped, "Identifier")) return stripped.name;
+	if (isNodeOfType(stripped, "MemberExpression") && !stripped.computed && isNodeOfType(stripped.property, "Identifier")) return stripped.property.name;
+	return "counter";
+};
+const looksLikeFreshUpdateExpression = (expression) => {
+	const stripped = stripParenExpression(expression);
+	if (isNodeOfType(stripped, "UpdateExpression")) {
+		const label = variableLabelForUpdateArgument(stripped.argument);
+		return stripped.prefix ? `${stripped.operator}${label}` : `${label}${stripped.operator}`;
+	}
+	if (isNodeOfType(stripped, "AssignmentExpression") && (stripped.operator === "+=" || stripped.operator === "-=")) return `${stripped.operator} side-effect`;
+	return null;
+};
+const noRandomKey = defineRule({
+	id: "no-random-key",
+	severity: "error",
+	category: "Correctness",
+	recommendation: "Use a stable identifier from the item itself (`item.id`, a hash of the content, or the item's index when the list order is stable). Never derive the key from a fresh-each-call API.",
+	create: (context) => ({ JSXAttribute(node) {
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		if (node.name.name !== "key") return;
+		if (!node.value) return;
+		if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
+		const inner = node.value.expression;
+		if (!inner) return;
+		if (inner.type === "JSXEmptyExpression") return;
+		const freshDescription = isAlwaysFreshExpression(inner) ?? looksLikeFreshUpdateExpression(inner);
+		if (!freshDescription) return;
+		context.report({
+			node: node.value,
+			message: `\`key={${freshDescription}}\` produces a new value on every render. Every list item is treated as a brand-new component — React unmounts and remounts the entire subtree, resetting state/focus/scroll and defeating reconciliation. Use a stable id from the item itself.`
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/react-builtins/no-react-children.ts
-const MESSAGE$13 = "`React.Children` is uncommon and leads to fragile components.";
+const MESSAGE$14 = "`React.Children` is uncommon and leads to fragile components.";
 const isChildrenIdentifier = (node, contextNode) => {
 	if (!isNodeOfType(node, "Identifier") || node.name !== "Children") return false;
 	return isImportedFromModule(contextNode, "Children", "react");
@@ -19445,13 +20294,13 @@ const noReactChildren = defineRule({
 		if (isChildrenIdentifier(memberObject, node)) {
 			context.report({
 				node: calleeOuter,
-				message: MESSAGE$13
+				message: MESSAGE$14
 			});
 			return;
 		}
 		if (isReactNamespaceMember(memberObject, node)) context.report({
 			node: calleeOuter,
-			message: MESSAGE$13
+			message: MESSAGE$14
 		});
 	} })
 });
@@ -19647,7 +20496,7 @@ const getTagsForRole = (role) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/no-redundant-roles.ts
-const buildMessage$8 = (tag, role) => `\`<${tag}>\` already has implicit role \`${role}\` — remove the redundant \`role\` attribute.`;
+const buildMessage$9 = (tag, role) => `\`<${tag}>\` already has implicit role \`${role}\` — remove the redundant \`role\` attribute.`;
 const resolveSettings$13 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { exceptions: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noRedundantRoles ?? {} : {}).exceptions ?? {} };
@@ -19670,14 +20519,14 @@ const noRedundantRoles = defineRule({
 			const allowedHere = settings.exceptions[tag] ?? [];
 			if (implicitRoles.includes(role) && !allowedHere.includes(role)) context.report({
 				node: roleAttr,
-				message: buildMessage$8(tag, role)
+				message: buildMessage$9(tag, role)
 			});
 		} };
 	}
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-redundant-should-component-update.ts
-const buildMessage$7 = (className) => `${className} does not need \`shouldComponentUpdate\` when extending \`React.PureComponent\`.`;
+const buildMessage$8 = (className) => `${className} does not need \`shouldComponentUpdate\` when extending \`React.PureComponent\`.`;
 const isPureComponentSuper = (superClass) => {
 	if (!superClass) return false;
 	if (isNodeOfType(superClass, "Identifier")) return superClass.name === "PureComponent";
@@ -19709,7 +20558,7 @@ const noRedundantShouldComponentUpdate = defineRule({
 			const className = classNode.id?.name ?? "<anonymous class>";
 			context.report({
 				node: reportNode,
-				message: buildMessage$7(className)
+				message: buildMessage$8(className)
 			});
 		};
 		return {
@@ -19768,7 +20617,7 @@ const noRenderPropChildren = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-render-return-value.ts
-const MESSAGE$12 = "Do not use the return value from `ReactDOM.render`.";
+const MESSAGE$13 = "Do not use the return value from `ReactDOM.render`.";
 const isReactDomRenderCall = (node) => {
 	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
 	if (!isNodeOfType(node.callee.object, "Identifier")) return false;
@@ -19791,7 +20640,7 @@ const noRenderReturnValue = defineRule({
 		if (!isUsedAsReturnValue(node.parent)) return;
 		context.report({
 			node: node.callee,
-			message: MESSAGE$12
+			message: MESSAGE$13
 		});
 	} })
 });
@@ -20186,7 +21035,7 @@ const isTanStackServerFnHandler = (node) => {
 const isInsideServerOnlyScope = (node) => {
 	let currentNode = node.parent ?? null;
 	while (currentNode) {
-		if (isFunctionLike$1(currentNode)) {
+		if (isFunctionLike$2(currentNode)) {
 			if (hasUseServerDirective(currentNode) || isTanStackServerFnHandler(currentNode)) return true;
 		}
 		currentNode = currentNode.parent ?? null;
@@ -20240,6 +21089,363 @@ const noSecretsInClientCode = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-self-updating-effect.ts
+const doesConstructFreshReference = (node) => isNodeOfType(node, "ArrayExpression") || isNodeOfType(node, "ObjectExpression") || isNodeOfType(node, "NewExpression") || isNodeOfType(node, "Literal") && "regex" in node;
+const expressionReadsStateValue = (node, stateName) => {
+	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")) return false;
+	if (isNodeOfType(node, "Identifier")) return node.name === stateName;
+	if (isNodeOfType(node, "MemberExpression")) {
+		if (expressionReadsStateValue(node.object, stateName)) return true;
+		return node.computed ? expressionReadsStateValue(node.property, stateName) : false;
+	}
+	if (isNodeOfType(node, "Property")) {
+		if (node.computed && expressionReadsStateValue(node.key, stateName)) return true;
+		return expressionReadsStateValue(node.value, stateName);
+	}
+	const nodeRecord = node;
+	for (const childKey of Object.keys(nodeRecord)) {
+		if (childKey === "parent" || childKey === "type") continue;
+		const childValue = nodeRecord[childKey];
+		if (Array.isArray(childValue)) {
+			for (const childArrayItem of childValue) if (isAstNode(childArrayItem) && expressionReadsStateValue(childArrayItem, stateName)) return true;
+		} else if (isAstNode(childValue) && expressionReadsStateValue(childValue, stateName)) return true;
+	}
+	return false;
+};
+const isNonSettlingSetterArgument = (setterCall, stateName) => {
+	const firstArgument = setterCall.arguments?.[0];
+	if (!firstArgument) return false;
+	const argument = stripParenExpression(firstArgument);
+	if (isNodeOfType(argument, "Identifier") && argument.name === stateName) return false;
+	if (isNodeOfType(argument, "ArrowFunctionExpression") || isNodeOfType(argument, "FunctionExpression")) return true;
+	if (doesConstructFreshReference(argument)) return true;
+	return expressionReadsStateValue(argument, stateName);
+};
+const getUnconditionalSetterCall = (statement, setterNames) => {
+	const expression = stripParenExpression(isNodeOfType(statement, "ExpressionStatement") ? statement.expression : statement);
+	if (!isNodeOfType(expression, "CallExpression")) return null;
+	if (!isNodeOfType(expression.callee, "Identifier")) return null;
+	if (!setterNames.has(expression.callee.name)) return null;
+	return expression;
+};
+const collectDependencyStateNames = (depsNode) => {
+	const dependencyNames = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(depsNode, "ArrayExpression")) return dependencyNames;
+	for (const element of depsNode.elements ?? []) if (isNodeOfType(element, "Identifier")) dependencyNames.add(element.name);
+	return dependencyNames;
+};
+const isEarlyReturnGuard = (statement) => {
+	if (!isNodeOfType(statement, "IfStatement")) return false;
+	const consequent = statement.consequent;
+	if (isNodeOfType(consequent, "ReturnStatement")) return true;
+	if (isNodeOfType(consequent, "BlockStatement")) return (consequent.body ?? []).some((inner) => isNodeOfType(inner, "ReturnStatement"));
+	return false;
+};
+const numericLiteralValue = (node) => {
+	if (isNodeOfType(node, "Literal") && typeof node.value === "number") return node.value;
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "-" && isNodeOfType(node.argument, "Literal") && typeof node.argument.value === "number") return -node.argument.value;
+	return null;
+};
+const isStateLength = (node, stateName) => {
+	const member = isNodeOfType(node, "ChainExpression") ? node.expression : node;
+	return isNodeOfType(member, "MemberExpression") && !member.computed && isNodeOfType(member.property, "Identifier") && member.property.name === "length" && expressionReadsStateValue(member.object, stateName);
+};
+const isNullishLiteral = (node) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined";
+const numericComparisonHolds = (operator, left, right) => {
+	switch (operator) {
+		case "<": return left < right;
+		case "<=": return left <= right;
+		case ">": return left > right;
+		case ">=": return left >= right;
+		case "===":
+		case "==": return left === right;
+		case "!==":
+		case "!=": return left !== right;
+		default: return false;
+	}
+};
+const guardExitsWhenStateEmpty = (test, stateName) => {
+	const node = isNodeOfType(test, "ChainExpression") ? test.expression : test;
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "!") return isStateLength(node.argument, stateName);
+	if (isNodeOfType(node, "LogicalExpression")) {
+		if (node.operator === "||") return guardExitsWhenStateEmpty(node.left, stateName) || guardExitsWhenStateEmpty(node.right, stateName);
+		if (node.operator === "&&") return guardExitsWhenStateEmpty(node.left, stateName) && guardExitsWhenStateEmpty(node.right, stateName);
+		return false;
+	}
+	if (isNodeOfType(node, "BinaryExpression")) {
+		const leftIsLength = isStateLength(node.left, stateName);
+		const rightIsLength = isStateLength(node.right, stateName);
+		if (leftIsLength || rightIsLength) {
+			const other = numericLiteralValue(leftIsLength ? node.right : node.left);
+			if (other === null) return false;
+			return leftIsLength ? numericComparisonHolds(node.operator, 0, other) : numericComparisonHolds(node.operator, other, 0);
+		}
+		if (node.operator === "==" || node.operator === "===") {
+			if (expressionReadsStateValue(node.left, stateName) && isNullishLiteral(node.right)) return true;
+			if (expressionReadsStateValue(node.right, stateName) && isNullishLiteral(node.left)) return true;
+		}
+		return false;
+	}
+	return false;
+};
+const isEmptyOrFalsyValue = (node) => {
+	if (isNodeOfType(node, "ArrayExpression")) return (node.elements ?? []).length === 0;
+	if (isNodeOfType(node, "ObjectExpression")) return (node.properties ?? []).length === 0;
+	if (isNodeOfType(node, "Literal")) return node.value === null || node.value === "" || node.value === 0 || node.value === false;
+	if (isNodeOfType(node, "Identifier")) return node.name === "undefined";
+	return false;
+};
+const functionReturnExpression = (fn) => {
+	if (!isNodeOfType(fn, "ArrowFunctionExpression") && !isNodeOfType(fn, "FunctionExpression")) return null;
+	if (!isNodeOfType(fn.body, "BlockStatement")) return fn.body ? stripParenExpression(fn.body) : null;
+	for (const statement of fn.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument) return stripParenExpression(statement.argument);
+	return null;
+};
+const isLengthReducingUpdater = (node) => {
+	if (!isNodeOfType(node, "ArrowFunctionExpression") && !isNodeOfType(node, "FunctionExpression")) return false;
+	const firstParameter = node.params?.[0];
+	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
+	const returned = functionReturnExpression(node);
+	if (!returned || !isNodeOfType(returned, "CallExpression")) return false;
+	const callee = returned.callee;
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
+	if (!isNodeOfType(callee.object, "Identifier") || callee.object.name !== firstParameter.name) return false;
+	if (!isNodeOfType(callee.property, "Identifier") || callee.property.name !== "slice") return false;
+	const sliceStart = numericLiteralValue(returned.arguments?.[0]);
+	return sliceStart !== null && sliceStart >= 1;
+};
+const writeProvablyConverges = (setterArgument, stateName, earlyReturnGuardTests) => {
+	if (!isEmptyOrFalsyValue(setterArgument) && !isLengthReducingUpdater(setterArgument)) return false;
+	return earlyReturnGuardTests.some((test) => guardExitsWhenStateEmpty(test, stateName));
+};
+const SYMBOLIC_DEPTH_LIMIT = 16;
+const unwrapChain = (node) => {
+	let current = node;
+	for (;;) {
+		const withoutParens = stripParenExpression(current);
+		if (withoutParens !== current) {
+			current = withoutParens;
+			continue;
+		}
+		if (isNodeOfType(current, "ChainExpression")) {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+};
+const isUndefinedValue = (node) => isNodeOfType(node, "Identifier") && node.name === "undefined" || isNodeOfType(node, "Literal") && node.value === null;
+const literalsEqual = (a, b) => isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal") && a.value === b.value;
+const resolveValueNode = (node, writes, depth, seen) => {
+	if (depth > SYMBOLIC_DEPTH_LIMIT) return null;
+	const current = unwrapChain(node);
+	if (isNodeOfType(current, "Identifier")) {
+		if (seen.has(current.name)) return null;
+		const written = writes.get(current.name);
+		if (written) return resolveValueNode(written, writes, depth + 1, new Set(seen).add(current.name));
+		return current;
+	}
+	if (isNodeOfType(current, "Literal") || isNodeOfType(current, "ArrayExpression") || isNodeOfType(current, "ObjectExpression")) return current;
+	if (isNodeOfType(current, "MemberExpression") && !current.computed && isNodeOfType(current.property, "Identifier")) {
+		const objectValue = resolveValueNode(current.object, writes, depth + 1, seen);
+		if (objectValue && isNodeOfType(objectValue, "ObjectExpression")) {
+			const propertyKey = current.property.name;
+			const properties = objectValue.properties ?? [];
+			for (let index = properties.length - 1; index >= 0; index--) {
+				const property = properties[index];
+				if (isNodeOfType(property, "SpreadElement")) return null;
+				if (isNodeOfType(property, "Property") && !property.computed && (isNodeOfType(property.key, "Identifier") && property.key.name === propertyKey || isNodeOfType(property.key, "Literal") && property.key.value === propertyKey)) return resolveValueNode(property.value, writes, depth + 1, seen);
+			}
+		}
+		return null;
+	}
+	return null;
+};
+const resolveToNumber = (node, writes, depth, seen) => {
+	const value = resolveValueNode(node, writes, depth, seen);
+	if (value && isNodeOfType(value, "Literal") && typeof value.value === "number") return value.value;
+	const current = unwrapChain(node);
+	if (isNodeOfType(current, "MemberExpression") && !current.computed && isNodeOfType(current.property, "Identifier") && current.property.name === "length") {
+		const objectValue = resolveValueNode(current.object, writes, depth, seen);
+		if (objectValue && isNodeOfType(objectValue, "ArrayExpression")) {
+			const elements = objectValue.elements ?? [];
+			if (!elements.some((element) => element && isNodeOfType(element, "SpreadElement"))) return elements.length;
+		}
+	}
+	return null;
+};
+const provablyEqualAfterWrites = (left, right, writes, depth, seen) => {
+	const leftNumber = resolveToNumber(left, writes, depth, seen);
+	const rightNumber = resolveToNumber(right, writes, depth, seen);
+	if (leftNumber !== null && rightNumber !== null) return leftNumber === rightNumber;
+	const a = resolveValueNode(left, writes, depth, seen);
+	const b = resolveValueNode(right, writes, depth, seen);
+	if (!a || !b) return false;
+	if (literalsEqual(a, b)) return true;
+	if (isUndefinedValue(a) && isUndefinedValue(b)) return true;
+	return isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier") && a.name === b.name;
+};
+const provablyFalsyAfterWrites = (node, writes, depth, seen) => {
+	const value = resolveValueNode(node, writes, depth, seen);
+	if (value) {
+		if (isUndefinedValue(value)) return true;
+		if (isNodeOfType(value, "Literal")) return value.value === null || value.value === 0 || value.value === false || value.value === "";
+	}
+	return resolveToNumber(node, writes, depth, seen) === 0;
+};
+const guardProvenAfterWrites = (test, writes, depth, seen) => {
+	if (depth > SYMBOLIC_DEPTH_LIMIT) return false;
+	const node = unwrapChain(test);
+	if (isNodeOfType(node, "LogicalExpression")) {
+		if (node.operator === "&&") return guardProvenAfterWrites(node.left, writes, depth + 1, seen) && guardProvenAfterWrites(node.right, writes, depth + 1, seen);
+		if (node.operator === "||") return guardProvenAfterWrites(node.left, writes, depth + 1, seen) || guardProvenAfterWrites(node.right, writes, depth + 1, seen);
+		return false;
+	}
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "!") return provablyFalsyAfterWrites(node.argument, writes, depth + 1, seen);
+	if (isNodeOfType(node, "BinaryExpression")) {
+		if (node.operator === "===" || node.operator === "==") return provablyEqualAfterWrites(node.left, node.right, writes, depth + 1, seen);
+		const leftNumber = resolveToNumber(node.left, writes, depth + 1, seen);
+		const rightNumber = resolveToNumber(node.right, writes, depth + 1, seen);
+		if (leftNumber !== null && rightNumber !== null) return numericComparisonHolds(node.operator, leftNumber, rightNumber);
+		return false;
+	}
+	const value = resolveValueNode(node, writes, depth + 1, seen);
+	if (value) {
+		if (isNodeOfType(value, "ArrayExpression") || isNodeOfType(value, "ObjectExpression")) return true;
+		if (isNodeOfType(value, "Literal")) return Boolean(value.value);
+	}
+	return false;
+};
+const collectTopLevelWrites = (statements, setterNameToStateName, setterNames) => {
+	const writes = /* @__PURE__ */ new Map();
+	const setterCallNodes = /* @__PURE__ */ new Set();
+	for (const statement of statements) {
+		const setterCall = getUnconditionalSetterCall(statement, setterNames);
+		if (!setterCall || !isNodeOfType(setterCall.callee, "Identifier")) continue;
+		setterCallNodes.add(setterCall);
+		const stateName = setterNameToStateName.get(setterCall.callee.name);
+		if (!stateName) continue;
+		const argument = setterCall.arguments?.[0];
+		if (!argument) continue;
+		const newValue = isNodeOfType(argument, "ArrowFunctionExpression") || isNodeOfType(argument, "FunctionExpression") ? functionReturnExpression(argument) : stripParenExpression(argument);
+		if (newValue) writes.set(stateName, newValue);
+	}
+	return {
+		writes,
+		setterCallNodes
+	};
+};
+const everySetterCall = (root, setterName, inspect) => {
+	let ok = true;
+	const visit = (node) => {
+		if (!ok) return;
+		if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === setterName && !inspect(node)) {
+			ok = false;
+			return;
+		}
+		const record = node;
+		for (const key of Object.keys(record)) {
+			if (key === "parent" || key === "type") continue;
+			const child = record[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+			if (!ok) return;
+		}
+	};
+	visit(root);
+	return ok;
+};
+const everyWriteToStateDrivesTowardEmpty = (callbackBody, setterName) => everySetterCall(callbackBody, setterName, (call) => {
+	const argument = call.arguments?.[0];
+	if (!argument) return true;
+	const value = stripParenExpression(argument);
+	return isEmptyOrFalsyValue(value) || isLengthReducingUpdater(value);
+});
+const everySetterCallIsTopLevel = (callbackBody, setterNames, topLevelSetterCalls) => {
+	let safe = true;
+	const visit = (node) => {
+		if (!safe) return;
+		if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && setterNames.has(node.callee.name) && !topLevelSetterCalls.has(node)) {
+			safe = false;
+			return;
+		}
+		const record = node;
+		for (const key of Object.keys(record)) {
+			if (key === "parent" || key === "type") continue;
+			const child = record[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+			if (!safe) return;
+		}
+	};
+	visit(callbackBody);
+	return safe;
+};
+const noSelfUpdatingEffect = defineRule({
+	id: "no-self-updating-effect",
+	severity: "warn",
+	tags: ["test-noise"],
+	recommendation: "Remove the feedback loop: derive the value during render, move the write into an event handler, or guard the update so it reaches a fixed point. See https://react.dev/learn/you-might-not-need-an-effect",
+	create: (context) => {
+		const checkFunctionScope = (functionBody) => {
+			if (!functionBody || !isNodeOfType(functionBody, "BlockStatement")) return;
+			const useStateBindings = collectUseStateBindings(functionBody);
+			if (useStateBindings.length === 0) return;
+			const setterNameToStateName = /* @__PURE__ */ new Map();
+			for (const binding of useStateBindings) setterNameToStateName.set(binding.setterName, binding.valueName);
+			const setterNames = new Set(setterNameToStateName.keys());
+			for (const statement of functionBody.body ?? []) {
+				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
+				const effectCall = statement.expression;
+				if (!isNodeOfType(effectCall, "CallExpression")) continue;
+				if (!isHookCall$1(effectCall, EFFECT_HOOK_NAMES$1)) continue;
+				if ((effectCall.arguments?.length ?? 0) < 2) continue;
+				const dependencyStateNames = collectDependencyStateNames(effectCall.arguments[1]);
+				if (dependencyStateNames.size === 0) continue;
+				const callback = getEffectCallback(effectCall);
+				if (!callback) continue;
+				const callbackStatements = getCallbackStatements(callback);
+				const firstWriteIndex = callbackStatements.findIndex((candidate) => getUnconditionalSetterCall(candidate, setterNames) !== null);
+				const guardCutoff = firstWriteIndex < 0 ? callbackStatements.length : firstWriteIndex;
+				const earlyReturnGuardTests = callbackStatements.slice(0, guardCutoff).filter(isEarlyReturnGuard).map((guard) => guard.test);
+				const { writes: topLevelWrites, setterCallNodes } = collectTopLevelWrites(callbackStatements, setterNameToStateName, setterNames);
+				if (everySetterCallIsTopLevel(callback, setterNames, setterCallNodes) && earlyReturnGuardTests.some((test) => guardProvenAfterWrites(test, topLevelWrites, 0, /* @__PURE__ */ new Set()))) continue;
+				const reportedStateNames = /* @__PURE__ */ new Set();
+				for (const callbackStatement of callbackStatements) {
+					const setterCall = getUnconditionalSetterCall(callbackStatement, setterNames);
+					if (!setterCall || !isNodeOfType(setterCall.callee, "Identifier")) continue;
+					const stateName = setterNameToStateName.get(setterCall.callee.name);
+					if (!stateName || !dependencyStateNames.has(stateName)) continue;
+					if (reportedStateNames.has(stateName)) continue;
+					if (!isNonSettlingSetterArgument(setterCall, stateName)) continue;
+					const firstArgument = setterCall.arguments?.[0];
+					if (firstArgument && writeProvablyConverges(stripParenExpression(firstArgument), stateName, earlyReturnGuardTests) && everyWriteToStateDrivesTowardEmpty(callback, setterCall.callee.name)) continue;
+					reportedStateNames.add(stateName);
+					context.report({
+						node: setterCall,
+						message: `${setterCall.callee.name}() runs unconditionally inside this effect, which depends on \`${stateName}\` — setting the same state the effect reacts to re-runs the effect on every commit and causes a render loop. Derive the value during render, move the write into an event handler, or guard the update so it settles.`
+					});
+				}
+			}
+		};
+		return {
+			FunctionDeclaration(node) {
+				const functionName = node.id?.name;
+				if (!functionName || !isUppercaseName(functionName) && !isReactHookName(functionName)) return;
+				checkFunctionScope(node.body);
+			},
+			VariableDeclarator(node) {
+				const isHookAssignment = isNodeOfType(node.id, "Identifier") && isReactHookName(node.id.name) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
+				if (!isComponentAssignment(node) && !isHookAssignment) return;
+				if (!isNodeOfType(node.init, "ArrowFunctionExpression") && !isNodeOfType(node.init, "FunctionExpression")) return;
+				checkFunctionScope(node.init.body);
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/utils/get-parent-component.ts
 const getParentComponent = (node) => {
 	let ancestor = node.parent;
@@ -20251,7 +21457,7 @@ const getParentComponent = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/no-set-state.ts
-const MESSAGE$11 = "Do not use `this.setState` in components.";
+const MESSAGE$12 = "Do not use `this.setState` in components.";
 const noSetState = defineRule({
 	id: "no-set-state",
 	severity: "warn",
@@ -20265,7 +21471,7 @@ const noSetState = defineRule({
 		if (!getParentComponent(node)) return;
 		context.report({
 			node: node.callee,
-			message: MESSAGE$11
+			message: MESSAGE$12
 		});
 	} })
 });
@@ -20424,7 +21630,7 @@ const isAbstractRole = (openingElement, settings) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/no-static-element-interactions.ts
-const MESSAGE$10 = "Static HTML elements with event handlers require a role — add `role=\"…\"` or use a semantic HTML element instead.";
+const MESSAGE$11 = "Static HTML elements with event handlers require a role — add `role=\"…\"` or use a semantic HTML element instead.";
 const DEFAULT_HANDLERS = [
 	"onClick",
 	"onMouseDown",
@@ -20483,7 +21689,7 @@ const noStaticElementInteractions = defineRule({
 			if (!roleAttribute || !roleAttribute.value) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$10
+					message: MESSAGE$11
 				});
 				return;
 			}
@@ -20493,14 +21699,14 @@ const noStaticElementInteractions = defineRule({
 				if (firstRole && (isInteractiveRole(firstRole) || isNonInteractiveRole(firstRole))) return;
 				context.report({
 					node: node.name,
-					message: MESSAGE$10
+					message: MESSAGE$11
 				});
 				return;
 			}
 			if (isNodeOfType(attributeValue, "JSXExpressionContainer") && settings.allowExpressionValues) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$10
+				message: MESSAGE$11
 			});
 		} };
 	}
@@ -20556,7 +21762,7 @@ const noStringRefs = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-this-in-sfc.ts
-const MESSAGE$9 = "Stateless functional components shouldn't use `this` — read props/context from function parameters.";
+const MESSAGE$10 = "Stateless functional components shouldn't use `this` — read props/context from function parameters.";
 const isInsideClassMethod = (node, customClassFactoryNames) => {
 	let ancestor = node.parent;
 	while (ancestor) {
@@ -20624,7 +21830,7 @@ const noThisInSfc = defineRule({
 			if (!looksLikeFunctionComponent(enclosingFunction)) return;
 			context.report({
 				node,
-				message: MESSAGE$9
+				message: MESSAGE$10
 			});
 		} };
 	}
@@ -20806,7 +22012,7 @@ const ESCAPED_VERSIONS = {
 	">": "`&gt;` / `&#62;`",
 	"}": "`&#125;` (or wrap the literal in `{'}'}`)"
 };
-const buildMessage$6 = (character) => `\`${character}\` in JSX text can be confused with markup — escape with ${ESCAPED_VERSIONS[character]}.`;
+const buildMessage$7 = (character) => `\`${character}\` in JSX text can be confused with markup — escape with ${ESCAPED_VERSIONS[character]}.`;
 const noUnescapedEntities = defineRule({
 	id: "no-unescaped-entities",
 	severity: "warn",
@@ -20817,7 +22023,7 @@ const noUnescapedEntities = defineRule({
 		for (const character of value) if (character in ESCAPED_VERSIONS) {
 			context.report({
 				node,
-				message: buildMessage$6(character)
+				message: buildMessage$7(character)
 			});
 			return;
 		}
@@ -21838,7 +23044,7 @@ const SAFER_REPLACEMENT = {
 	componentWillUpdate: "componentDidUpdate",
 	UNSAFE_componentWillUpdate: "componentDidUpdate"
 };
-const buildMessage$5 = (methodName) => `Unsafe lifecycle method \`${methodName}\` — use \`${SAFER_REPLACEMENT[methodName] ?? "an alternative lifecycle method"}\` instead.`;
+const buildMessage$6 = (methodName) => `Unsafe lifecycle method \`${methodName}\` — use \`${SAFER_REPLACEMENT[methodName] ?? "an alternative lifecycle method"}\` instead.`;
 const resolveSettings$9 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { checkAliases: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noUnsafe ?? {} : {}).checkAliases ?? false };
@@ -21886,7 +23092,7 @@ const noUnsafe = defineRule({
 				if (!getParentComponent(node)) return;
 				context.report({
 					node: node.key,
-					message: buildMessage$5(name)
+					message: buildMessage$6(name)
 				});
 			},
 			Property(node) {
@@ -21897,7 +23103,7 @@ const noUnsafe = defineRule({
 					if (isEs5Component(ancestor)) {
 						context.report({
 							node: node.key,
-							message: buildMessage$5(name)
+							message: buildMessage$6(name)
 						});
 						return;
 					}
@@ -21909,7 +23115,7 @@ const noUnsafe = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-unstable-nested-components.ts
-const buildMessage$4 = (parentName, isInProp, allowAsProps) => {
+const buildMessage$5 = (parentName, isInProp, allowAsProps) => {
 	let message = "Don't define components inside another component";
 	if (parentName) message += ` (\`${parentName}\`)`;
 	message += " — extract it to module scope.";
@@ -21978,7 +23184,7 @@ const isReactClassComponent = (classNode) => {
 const findEnclosingComponent = (node) => {
 	let walker = node.parent;
 	while (walker) {
-		if (isFunctionLike$1(walker)) {
+		if (isFunctionLike$2(walker)) {
 			const componentName = inferFunctionLikeName(walker);
 			if (componentName && isReactComponentName(componentName) && expressionContainsJsxOrCreateElement(walker)) return {
 				component: walker,
@@ -22144,7 +23350,7 @@ const noUnstableNestedComponents = defineRule({
 			if (!enclosing) return;
 			context.report({
 				node: reportNode,
-				message: buildMessage$4(enclosing.name, propInfo !== null, settings.allowAsProps)
+				message: buildMessage$5(enclosing.name, propInfo !== null, settings.allowAsProps)
 			});
 		};
 		const checkFunctionLike = (node) => {
@@ -22179,15 +23385,6 @@ const noUnstableNestedComponents = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-canonical-react-namespace-name.ts
-const isCanonicalReactNamespaceName = (namespaceName) => {
-	if (namespaceName === "React") return true;
-	if (namespaceName === "react") return true;
-	if (namespaceName.startsWith("_react")) return true;
-	if (namespaceName.startsWith("_React")) return true;
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/performance/no-usememo-simple-expression.ts
 const isSimpleExpression = (node) => {
 	if (!node) return false;
@@ -22276,7 +23473,7 @@ const noWideLetterSpacing = defineRule({
 //#endregion
 //#region src/plugin/rules/react-builtins/no-will-update-set-state.ts
 const LIFECYCLE_NAMES = new Set(["componentWillUpdate", "UNSAFE_componentWillUpdate"]);
-const MESSAGE$8 = "Do not use `this.setState` in `componentWillUpdate` — schedule the update via `componentDidUpdate` instead.";
+const MESSAGE$9 = "Do not use `this.setState` in `componentWillUpdate` — schedule the update via `componentDidUpdate` instead.";
 const resolveSettings$7 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { mode: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noWillUpdateSetState ?? {} : {}).mode ?? "allowed" };
@@ -22309,7 +23506,7 @@ const noWillUpdateSetState = defineRule({
 			if (!isSetStateCallInLifecycle(node, activeLifecycleNames, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			context.report({
 				node: node.callee,
-				message: MESSAGE$8
+				message: MESSAGE$9
 			});
 		} };
 	}
@@ -22922,7 +24119,7 @@ const REACT_HOOK_NAMES = new Set([
 	"useSyncExternalStore",
 	"useTransition"
 ]);
-const buildMessage$3 = (importedNames) => `Import ${importedNames.map((innerName) => `\`${innerName}\``).join(", ")} from \`preact/hooks\` (or \`preact/compat\`) — importing hooks from \`react\` in a pure-Preact project loads a second copy of Preact's hook state and triggers \`__H\` undefined errors.`;
+const buildMessage$4 = (importedNames) => `Import ${importedNames.map((innerName) => `\`${innerName}\``).join(", ")} from \`preact/hooks\` (or \`preact/compat\`) — importing hooks from \`react\` in a pure-Preact project loads a second copy of Preact's hook state and triggers \`__H\` undefined errors.`;
 const preactNoReactHooksImport = defineRule({
 	id: "preact-no-react-hooks-import",
 	requires: ["pure-preact"],
@@ -22945,7 +24142,7 @@ const preactNoReactHooksImport = defineRule({
 		});
 		context.report({
 			node,
-			message: buildMessage$3(importedNames)
+			message: buildMessage$4(importedNames)
 		});
 	} })
 });
@@ -23002,7 +24199,7 @@ const preactNoRenderArguments = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/preact/preact-prefer-ondblclick.ts
-const MESSAGE$7 = "Preact follows DOM event naming — use `onDblClick` (lowercase second word). React's `onDoubleClick` handler never fires in Preact core.";
+const MESSAGE$8 = "Preact follows DOM event naming — use `onDblClick` (lowercase second word). React's `onDoubleClick` handler never fires in Preact core.";
 const preactPreferOndblclick = defineRule({
 	id: "preact-prefer-ondblclick",
 	requires: ["pure-preact"],
@@ -23016,7 +24213,7 @@ const preactPreferOndblclick = defineRule({
 		if (!onDoubleClickAttribute) return;
 		context.report({
 			node: onDoubleClickAttribute,
-			message: MESSAGE$7
+			message: MESSAGE$8
 		});
 	} })
 });
@@ -23124,7 +24321,7 @@ const preferEs6Class = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/prefer-function-component.ts
-const MESSAGE$6 = "Class component should be written as a function component — use hooks instead.";
+const MESSAGE$7 = "Class component should be written as a function component — use hooks instead.";
 const resolveSettings$4 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.preferFunctionComponent ?? {} : {};
@@ -23162,7 +24359,7 @@ const preferFunctionComponent = defineRule({
 			const reportNode = node.id ?? node;
 			context.report({
 				node: reportNode,
-				message: MESSAGE$6
+				message: MESSAGE$7
 			});
 		};
 		return {
@@ -23219,6 +24416,276 @@ const preferHtmlDialog = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/function-returns-object-literal.ts
+const unwrapExpression = (node) => {
+	let current = node;
+	for (;;) {
+		if ((current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression") && "expression" in current && isAstNode(current.expression)) {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+};
+const doesFunctionReturnsObjectLiteral = (functionNode) => {
+	if (functionNode.type === "ArrowFunctionExpression" && "body" in functionNode) {
+		const body = functionNode.body;
+		if (body && body.type !== "BlockStatement") return unwrapExpression(body).type === "ObjectExpression";
+	}
+	const body = functionNode.body;
+	if (!body || body.type !== "BlockStatement") return false;
+	let returnsObject = false;
+	const visit = (node) => {
+		if (returnsObject) return;
+		if (node.type === "ReturnStatement" && "argument" in node && node.argument != null) {
+			if (unwrapExpression(node.argument).type === "ObjectExpression") returnsObject = true;
+			return;
+		}
+		const nodeRecord = node;
+		for (const key of Object.keys(nodeRecord)) {
+			if (key === "parent") continue;
+			const child = nodeRecord[key];
+			if (Array.isArray(child)) for (const item of child) {
+				if (!isAstNode(item)) continue;
+				if (FUNCTION_LIKE_TYPES$1.has(item.type)) continue;
+				visit(item);
+				if (returnsObject) return;
+			}
+			else if (isAstNode(child)) {
+				if (FUNCTION_LIKE_TYPES$1.has(child.type)) continue;
+				visit(child);
+			}
+		}
+	};
+	visit(body);
+	return returnsObject;
+};
+//#endregion
+//#region src/plugin/utils/enclosing-component-or-hook-scope.ts
+const enclosingComponentOrHookScope = (startNode, ownScopeFor) => {
+	const functionNode = nearestEnclosingFunction(startNode);
+	if (!functionNode) return null;
+	const displayName = componentOrHookDisplayNameForFunction(functionNode);
+	if (!displayName) return null;
+	if (!isReactHookName(displayName) && doesFunctionReturnsObjectLiteral(functionNode)) return null;
+	const bodyScope = ownScopeFor(functionNode);
+	if (!bodyScope) return null;
+	return {
+		functionNode,
+		bodyScope,
+		displayName
+	};
+};
+//#endregion
+//#region src/plugin/rules/architecture/prefer-module-scope-pure-function.ts
+const isAssignedToComponentMember = (functionNode) => {
+	const parent = functionNode.parent;
+	if (!parent) return false;
+	return isNodeOfType(parent, "AssignmentExpression") && isNodeOfType(parent.left, "MemberExpression");
+};
+const hasComponentLocalCaptures = (functionNode, bodyScope, scopes) => {
+	const captures = closureCaptures(functionNode, scopes);
+	for (const capture of captures) {
+		const symbol = capture.resolvedSymbol;
+		if (!symbol) continue;
+		if (isDescendantScope(symbol.scope, bodyScope)) return true;
+	}
+	return false;
+};
+const preferModuleScopePureFunction = defineRule({
+	id: "prefer-module-scope-pure-function",
+	tags: ["test-noise"],
+	severity: "warn",
+	category: "Architecture",
+	recommendation: "Move the function to module scope (above the component). It doesn't reference any local state, so the per-render allocation is wasted.",
+	create: (context) => {
+		const report = (functionNode, name, componentName) => {
+			context.report({
+				node: functionNode,
+				message: `\`${name}\` inside \`${componentName}\` doesn't close over any local state. Move it to module scope so it isn't reallocated every render and the component file stays focused on rendering logic.`
+			});
+		};
+		const checkNamedFunction = (functionNode, bindingName) => {
+			if (isAssignedToComponentMember(functionNode)) return;
+			const component = enclosingComponentOrHookScope(functionNode, context.scopes.ownScopeFor);
+			if (!component) return;
+			const ownScope = context.scopes.ownScopeFor(functionNode);
+			if (!ownScope) return;
+			if (ownScope === component.bodyScope) return;
+			if (!isDescendantScope(ownScope, component.bodyScope)) return;
+			if (hasComponentLocalCaptures(functionNode, component.bodyScope, context.scopes)) return;
+			report(functionNode, bindingName, component.displayName);
+		};
+		return {
+			VariableDeclarator(node) {
+				if (!isNodeOfType(node.id, "Identifier")) return;
+				const initializer = node.init;
+				if (!initializer) return;
+				if (!isNodeOfType(initializer, "ArrowFunctionExpression") && !isNodeOfType(initializer, "FunctionExpression")) return;
+				const bindingName = node.id.name;
+				if (/^[A-Z]/.test(bindingName)) return;
+				checkNamedFunction(initializer, bindingName);
+			},
+			FunctionDeclaration(node) {
+				if (!node.id?.name) return;
+				const bindingName = node.id.name;
+				if (/^[A-Z]/.test(bindingName)) return;
+				checkNamedFunction(node, bindingName);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/architecture/prefer-module-scope-static-value.ts
+const MUTATING_RECEIVER_METHOD_NAMES = new Set([...MUTATING_ARRAY_METHODS, ...MUTATING_COLLECTION_METHODS]);
+const isMutationContext = (referenceIdentifier) => {
+	const parent = referenceIdentifier.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.left === referenceIdentifier) return true;
+	if (isNodeOfType(parent, "UpdateExpression") && parent.argument === referenceIdentifier) return true;
+	if (isNodeOfType(parent, "MemberExpression") && parent.object === referenceIdentifier) {
+		const grandparent = parent.parent;
+		if (!grandparent) return false;
+		if (isNodeOfType(grandparent, "AssignmentExpression") && grandparent.left === parent) return true;
+		if (isNodeOfType(grandparent, "UpdateExpression") && grandparent.argument === parent) return true;
+		if (isNodeOfType(grandparent, "UnaryExpression") && grandparent.operator === "delete" && grandparent.argument === parent) return true;
+		if (isNodeOfType(grandparent, "CallExpression") && grandparent.callee === parent && !parent.computed && isNodeOfType(parent.property, "Identifier") && MUTATING_RECEIVER_METHOD_NAMES.has(parent.property.name)) return true;
+	}
+	return false;
+};
+const isBindingMutatedAfterInit = (declaratorNode, bodyScope, scopes) => {
+	if (!isNodeOfType(declaratorNode.id, "Identifier")) return false;
+	const symbol = scopes.symbolFor(declaratorNode.id);
+	if (!symbol) return false;
+	for (const reference of symbol.references) {
+		if (reference.identifier === declaratorNode.id) continue;
+		if (reference.identifier === declaratorNode.init) continue;
+		if (!isDescendantScope(reference.scope, bodyScope) && reference.scope !== bodyScope) continue;
+		if (isMutationContext(reference.identifier)) return true;
+	}
+	return false;
+};
+const hasComponentLocalReferences = (expression, bodyScope, scopes) => {
+	let foundLocal = false;
+	walkAst(expression, (node) => {
+		if (foundLocal) return false;
+		if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")) {
+			foundLocal = true;
+			return false;
+		}
+		const reference = scopes.referenceFor(node);
+		if (reference?.resolvedSymbol && isDescendantScope(reference.resolvedSymbol.scope, bodyScope)) {
+			foundLocal = true;
+			return false;
+		}
+	});
+	return foundLocal;
+};
+const isHoistableValueExpression = (expression) => {
+	const stripped = stripParenExpression(expression);
+	return isNodeOfType(stripped, "ArrayExpression") || isNodeOfType(stripped, "ObjectExpression");
+};
+const preferModuleScopeStaticValue = defineRule({
+	id: "prefer-module-scope-static-value",
+	tags: ["test-noise"],
+	severity: "warn",
+	category: "Architecture",
+	recommendation: "Move the constant to module scope (above the component). It doesn't reference any local state, so the per-render allocation is wasted and any memoised consumer sees a fresh reference each render.",
+	create: (context) => ({ VariableDeclarator(node) {
+		if (!isNodeOfType(node.id, "Identifier")) return;
+		const initializer = node.init;
+		if (!initializer) return;
+		if (!isHoistableValueExpression(initializer)) return;
+		const component = enclosingComponentOrHookScope(node, context.scopes.ownScopeFor);
+		if (!component) return;
+		if (hasComponentLocalReferences(initializer, component.bodyScope, context.scopes)) return;
+		if (isBindingMutatedAfterInit(node, component.bodyScope, context.scopes)) return;
+		const bindingName = node.id.name;
+		context.report({
+			node,
+			message: `\`${bindingName}\` inside \`${component.displayName}\` doesn't depend on any local state. Move it to module scope so the allocation happens once and memoised consumers see a stable reference.`
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/performance/prefer-stable-empty-fallback.ts
+const isEmptyArrayLiteral$1 = (expression) => {
+	const stripped = stripParenExpression(expression);
+	return isNodeOfType(stripped, "ArrayExpression") && (stripped.elements ?? []).length === 0;
+};
+const isEmptyObjectLiteral = (expression) => {
+	const stripped = stripParenExpression(expression);
+	return isNodeOfType(stripped, "ObjectExpression") && (stripped.properties ?? []).length === 0;
+};
+const isStableNonEmptyExpression = (expression) => {
+	const stripped = stripParenExpression(expression);
+	if (isNodeOfType(stripped, "Identifier")) return true;
+	if (isNodeOfType(stripped, "ThisExpression")) return true;
+	if (isNodeOfType(stripped, "MemberExpression")) {
+		if (stripped.computed) return false;
+		const object = stripped.object;
+		if (!object) return false;
+		return isStableNonEmptyExpression(object);
+	}
+	return false;
+};
+const matchEmptyFallbackInLogicalExpression = (expression) => {
+	const stripped = stripParenExpression(expression);
+	if (!isNodeOfType(stripped, "LogicalExpression")) return null;
+	if (stripped.operator !== "||" && stripped.operator !== "??") return null;
+	const left = stripped.left;
+	const right = stripped.right;
+	if (!left || !right) return null;
+	if (isEmptyArrayLiteral$1(right) && isStableNonEmptyExpression(left)) return {
+		emptyKind: "array",
+		emptyNode: right,
+		nonEmptyExpression: left
+	};
+	if (isEmptyObjectLiteral(right) && isStableNonEmptyExpression(left)) return {
+		emptyKind: "object",
+		emptyNode: right,
+		nonEmptyExpression: left
+	};
+	return null;
+};
+const buildMessage$3 = (emptyKind) => {
+	return `Fallback \`${emptyKind === "array" ? "[]" : "{}"}\` allocates a fresh ${emptyKind} on every render where the left-hand value is falsy — the memoised child sees a different reference and re-renders. Hoist a module-level constant (e.g. \`${emptyKind === "array" ? "const EMPTY_ITEMS: Item[] = []" : "const EMPTY_CONFIG: Config = {}"}\`) and use it as the fallback.`;
+};
+const preferStableEmptyFallback = defineRule({
+	id: "prefer-stable-empty-fallback",
+	tags: ["react-jsx-only", "test-noise"],
+	severity: "warn",
+	category: "Performance",
+	disabledBy: ["react-compiler"],
+	recommendation: "Hoist a module-level `const EMPTY = []` (or `{}`) and use that as the `||` / `??` fallback so the consumer sees a stable reference.",
+	create: (context) => {
+		let memoRegistry = null;
+		return {
+			Program(node) {
+				memoRegistry = buildSameFileMemoRegistry(node);
+			},
+			JSXAttribute(node) {
+				if (!isInsideFunctionScope(node)) return;
+				if (isJsxAttributeOnIntrinsicHtmlElement(node)) return;
+				if (!node.value) return;
+				if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
+				const innerExpression = node.value.expression;
+				if (!innerExpression) return;
+				if (innerExpression.type === "JSXEmptyExpression") return;
+				const parentJsxOpening = node.parent;
+				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
+				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
+				const fallback = matchEmptyFallbackInLogicalExpression(innerExpression);
+				if (!fallback) return;
+				context.report({
+					node: fallback.emptyNode,
+					message: buildMessage$3(fallback.emptyKind)
+				});
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/rules/a11y/prefer-tag-over-role.ts
 const buildMessage$2 = (role, tag) => `Prefer the semantic \`<${tag}>\` element over \`role="${role}"\` on a generic tag.`;
 const preferTagOverRole = defineRule({
@@ -23769,91 +25236,216 @@ const reactCompilerNoManualMemoization = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/has-binding-named.ts
-const hasBindingNamed = (root, bindingName) => {
-	const collected = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		switch (node.type) {
-			case "VariableDeclarator":
-				if ("id" in node && node.id) collectPatternNames(node.id, collected);
-				break;
-			case "FunctionDeclaration":
-			case "FunctionExpression":
-			case "ClassDeclaration":
-			case "ClassExpression":
-				if ("id" in node && node.id && node.id.type === "Identifier") {
-					const idNode = node.id;
-					if (typeof idNode.name === "string") collected.add(idNode.name);
-				}
-				break;
-			case "ArrowFunctionExpression": break;
-			case "ImportDefaultSpecifier":
-			case "ImportNamespaceSpecifier":
-			case "ImportSpecifier":
-				if ("local" in node && node.local && node.local.type === "Identifier") {
-					const local = node.local;
-					if (typeof local.name === "string") collected.add(local.name);
-				}
-				break;
-			case "TSImportEqualsDeclaration":
-			case "TSEnumDeclaration":
-			case "TSTypeAliasDeclaration":
-			case "TSInterfaceDeclaration":
-			case "TSModuleDeclaration": {
-				const idNode = node.id;
-				if (idNode && idNode.type === "Identifier") {
-					const idObject = idNode;
-					if (typeof idObject.name === "string") collected.add(idObject.name);
-				}
-				break;
-			}
-			default: break;
-		}
-		if ("params" in node && Array.isArray(node.params)) for (const param of node.params) collectPatternNames(param, collected);
-		if (collected.has(bindingName)) return;
-		const nodeRecord = node;
-		for (const key of Object.keys(nodeRecord)) {
-			if (key === "parent") continue;
-			const child = nodeRecord[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-			if (collected.has(bindingName)) return;
-		}
-	};
-	visit(root);
-	return collected.has(bindingName);
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/react-in-jsx-scope.ts
-const MESSAGE$5 = "`React` must be in scope when using JSX (the classic JSX transform expands `<a/>` to `React.createElement('a')`).";
+const MESSAGE$6 = "`React` must be in scope when using JSX (the classic JSX transform expands `<a/>` to `React.createElement('a')`).";
 const reactInJsxScope = defineRule({
 	id: "react-in-jsx-scope",
 	severity: "warn",
 	defaultEnabled: false,
 	recommendation: "If you're on React 17+ with the new JSX transform, disable this rule. Otherwise import `React` at the top of the file.",
-	create: (context) => {
-		let didCheckBindingForFile = false;
-		let isReactBound = false;
-		const ensureBindingChecked = (jsxNode) => {
-			if (didCheckBindingForFile) return isReactBound;
-			didCheckBindingForFile = true;
-			const programRoot = findProgramRoot(jsxNode);
-			isReactBound = programRoot ? hasBindingNamed(programRoot, "React") : false;
-			return isReactBound;
+	create: (context) => ({
+		JSXOpeningElement(node) {
+			if (findVariableInitializer(node, "React")) return;
+			context.report({
+				node: node.name,
+				message: MESSAGE$6
+			});
+		},
+		JSXFragment(node) {
+			if (findVariableInitializer(node, "React")) return;
+			context.report({
+				node: node.openingFragment,
+				message: MESSAGE$6
+			});
+		}
+	})
+});
+//#endregion
+//#region src/plugin/utils/collect-react-redux-selector-aliases.ts
+const REACT_REDUX_MODULE = "react-redux";
+const collectReactReduxSelectorAliases = (programRoot) => {
+	const aliases = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(programRoot, "Program")) return aliases;
+	for (const topLevel of programRoot.body ?? []) {
+		if (!isNodeOfType(topLevel, "ImportDeclaration")) continue;
+		if (typeof topLevel.source?.value !== "string") continue;
+		if (topLevel.source.value !== REACT_REDUX_MODULE) continue;
+		for (const specifier of topLevel.specifiers ?? []) {
+			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
+			const imported = specifier.imported;
+			if ((imported && "name" in imported && typeof imported.name === "string" ? imported.name : imported && "value" in imported && typeof imported.value === "string" ? imported.value : null) !== "useSelector") continue;
+			const local = specifier.local;
+			if (isNodeOfType(local, "Identifier")) aliases.add(local.name);
+		}
+	}
+	const collectDeclarations = (node) => {
+		if (!isNodeOfType(node, "VariableDeclaration")) return;
+		for (const declarator of node.declarations ?? []) {
+			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			if (!declarator.init) continue;
+			const initialiser = stripParenExpression(declarator.init);
+			if (!isNodeOfType(initialiser, "Identifier")) continue;
+			if (!aliases.has(initialiser.name)) continue;
+			aliases.add(declarator.id.name);
+		}
+	};
+	for (const topLevel of programRoot.body ?? []) if (isNodeOfType(topLevel, "VariableDeclaration")) collectDeclarations(topLevel);
+	else if (isNodeOfType(topLevel, "ExportNamedDeclaration") && topLevel.declaration) collectDeclarations(topLevel.declaration);
+	return aliases;
+};
+const isUseSelectorIdentifier = (calleeNode, aliases) => {
+	if (!isNodeOfType(calleeNode, "Identifier")) return false;
+	if (aliases.has(calleeNode.name)) return true;
+	if (calleeNode.name !== "useSelector") return false;
+	return isImportedFromModule(calleeNode, calleeNode.name, REACT_REDUX_MODULE);
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/inline-use-selector-function.ts
+const inlineUseSelectorFunction = (callNode, aliases) => {
+	if (!isUseSelectorIdentifier(callNode.callee, aliases)) return null;
+	const args = callNode.arguments ?? [];
+	if (args.length === 0 || args.length >= 2) return null;
+	const selectorArgument = stripParenExpression(args[0]);
+	if (isNodeOfType(selectorArgument, "ArrowFunctionExpression") || isNodeOfType(selectorArgument, "FunctionExpression")) return selectorArgument;
+	return null;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/redux-useselector-inline-derivation.ts
+const ALLOCATING_ARRAY_METHODS = new Set([
+	"filter",
+	"map",
+	"flatMap",
+	"slice",
+	"concat",
+	"toSorted",
+	"toReversed",
+	"toSpliced",
+	"with"
+]);
+const ALLOCATING_NAMESPACE_CALLS = new Map([["Object", new Set([
+	"keys",
+	"values",
+	"entries",
+	"fromEntries",
+	"assign"
+])], ["Array", new Set(["from", "of"])]]);
+const MESSAGE_DERIVATION = (methodName) => `useSelector callback derives a new array via \`.${methodName}(...)\` on every store update — the default \`===\` equality check always fails on a fresh allocation, re-rendering the component on every dispatched action. Select the raw slice (\`useSelector(s => s.users)\`) and derive with \`useMemo\`, or hoist the derivation into a memoised \`createSelector\` from \`reselect\`.`;
+const MESSAGE_NAMESPACE = (namespace, methodName) => `useSelector callback returns a fresh collection from \`${namespace}.${methodName}(...)\` on every store update — the default \`===\` equality check always fails, re-rendering on every dispatched action. Select the raw slice and derive with \`useMemo\` or \`reselect\`.`;
+const getAllocatingCallSiteDescription = (expression) => {
+	const stripped = stripParenExpression(expression);
+	if (!isNodeOfType(stripped, "CallExpression")) return null;
+	const callee = stripped.callee;
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	if (callee.computed) return null;
+	if (!isNodeOfType(callee.property, "Identifier")) return null;
+	const methodName = callee.property.name;
+	if (isNodeOfType(callee.object, "Identifier")) {
+		const namespaceName = callee.object.name;
+		if (ALLOCATING_NAMESPACE_CALLS.get(namespaceName)?.has(methodName)) return {
+			kind: "namespace",
+			namespace: namespaceName,
+			method: methodName
 		};
+	}
+	if (ALLOCATING_ARRAY_METHODS.has(methodName)) return {
+		kind: "method",
+		method: methodName
+	};
+	return null;
+};
+const findReturnedAllocatingCall = (expression) => {
+	const stripped = stripParenExpression(expression);
+	const direct = getAllocatingCallSiteDescription(stripped);
+	if (direct) return {
+		...direct,
+		node: stripped
+	};
+	if (isNodeOfType(stripped, "ConditionalExpression")) return findReturnedAllocatingCall(stripped.consequent) ?? findReturnedAllocatingCall(stripped.alternate);
+	if (isNodeOfType(stripped, "LogicalExpression")) return findReturnedAllocatingCall(stripped.left) ?? findReturnedAllocatingCall(stripped.right);
+	if (isNodeOfType(stripped, "SequenceExpression")) {
+		const lastExpression = stripped.expressions[stripped.expressions.length - 1];
+		return lastExpression ? findReturnedAllocatingCall(lastExpression) : null;
+	}
+	return null;
+};
+const reduxUseselectorInlineDerivation = defineRule({
+	id: "redux-useselector-inline-derivation",
+	severity: "warn",
+	category: "Performance",
+	disabledBy: ["react-compiler"],
+	recommendation: "Select the raw slice and derive with `useMemo`, or use `createSelector` from `reselect`.",
+	create: (context) => {
+		let aliases = /* @__PURE__ */ new Set();
 		return {
-			JSXOpeningElement(node) {
-				if (ensureBindingChecked(node)) return;
-				context.report({
-					node: node.name,
-					message: MESSAGE$5
+			Program(node) {
+				aliases = collectReactReduxSelectorAliases(node);
+			},
+			CallExpression(node) {
+				const selectorArgument = inlineUseSelectorFunction(node, aliases);
+				if (!selectorArgument) return;
+				const body = selectorArgument.body;
+				if (!body) return;
+				const returnedExpressions = [];
+				if (isNodeOfType(body, "BlockStatement")) walkAst(body, (node) => {
+					if (node !== body && isFunctionLike$2(node)) return false;
+					if (isNodeOfType(node, "ReturnStatement")) {
+						if (node.argument) returnedExpressions.push(node.argument);
+						return false;
+					}
 				});
+				else returnedExpressions.push(body);
+				for (const returnedExpression of returnedExpressions) {
+					const allocatingCall = findReturnedAllocatingCall(returnedExpression);
+					if (!allocatingCall) continue;
+					const reportMessage = allocatingCall.kind === "method" ? MESSAGE_DERIVATION(allocatingCall.method) : MESSAGE_NAMESPACE(allocatingCall.namespace, allocatingCall.method);
+					context.report({
+						node: allocatingCall.node,
+						message: reportMessage
+					});
+					return;
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/state-and-effects/redux-useselector-returns-new-collection.ts
+const MESSAGE$5 = "useSelector returning a new object/array re-renders on every dispatched action — the default `===` equality check always fails on a fresh reference. Either return a primitive, split into multiple useSelector calls, or pass `shallowEqual` (or a custom equality fn) as the second argument.";
+const isConciseBodyReturningCollection = (functionNode) => {
+	if (!isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression")) return false;
+	const rawBody = functionNode.body;
+	if (!rawBody) return false;
+	if (!isNodeOfType(rawBody, "BlockStatement")) {
+		const conciseExpression = stripParenExpression(rawBody);
+		return isNodeOfType(conciseExpression, "ObjectExpression") || isNodeOfType(conciseExpression, "ArrayExpression");
+	}
+	const statements = rawBody.body ?? [];
+	if (statements.length === 0) return false;
+	const lastStatement = statements[statements.length - 1];
+	if (!isNodeOfType(lastStatement, "ReturnStatement")) return false;
+	if (!lastStatement.argument) return false;
+	const returnedExpression = stripParenExpression(lastStatement.argument);
+	return isNodeOfType(returnedExpression, "ObjectExpression") || isNodeOfType(returnedExpression, "ArrayExpression");
+};
+const reduxUseselectorReturnsNewCollection = defineRule({
+	id: "redux-useselector-returns-new-collection",
+	severity: "warn",
+	category: "Performance",
+	disabledBy: ["react-compiler"],
+	recommendation: "Return a primitive, split into multiple useSelector calls, or pass `shallowEqual` from `react-redux` as the second argument.",
+	create: (context) => {
+		let aliases = /* @__PURE__ */ new Set();
+		return {
+			Program(node) {
+				aliases = collectReactReduxSelectorAliases(node);
 			},
-			JSXFragment(node) {
-				if (ensureBindingChecked(node)) return;
+			CallExpression(node) {
+				const selectorArgument = inlineUseSelectorFunction(node, aliases);
+				if (!selectorArgument) return;
+				if (!isConciseBodyReturningCollection(selectorArgument)) return;
 				context.report({
-					node: node.openingFragment,
+					node,
 					message: MESSAGE$5
 				});
 			}
@@ -24131,7 +25723,7 @@ const hasOwnAwait = (functionBody) => {
 	let found = false;
 	walkAst(functionBody, (child) => {
 		if (found) return;
-		if (child !== functionBody && isFunctionLike$1(child)) return false;
+		if (child !== functionBody && isFunctionLike$2(child)) return false;
 		if (isNodeOfType(child, "AwaitExpression")) found = true;
 	});
 	return found;
@@ -24150,7 +25742,7 @@ const setterIsCalledInAsyncContext = (componentBody, setterName) => {
 	let found = false;
 	walkAst(componentBody, (child) => {
 		if (found) return;
-		if (!isFunctionLike$1(child)) return;
+		if (!isFunctionLike$2(child)) return;
 		const functionBody = child.body;
 		if (!(Boolean(child.async) || hasOwnAwait(functionBody))) return;
 		if (callsIdentifier(functionBody, setterName)) found = true;
@@ -24604,6 +26196,33 @@ const rerenderFunctionalSetstate = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/rerender-lazy-ref-init.ts
+const rerenderLazyRefInit = defineRule({
+	id: "rerender-lazy-ref-init",
+	tags: ["test-noise"],
+	severity: "warn",
+	category: "Performance",
+	recommendation: "Initialize lazily: `const ref = useRef<T | null>(null); if (ref.current === null) ref.current = expensiveCall();`",
+	create: (context) => ({ CallExpression(node) {
+		if (!isHookCall$1(node, "useRef") || !node.arguments?.length) return;
+		const initializer = node.arguments[0];
+		const isPlainCall = isNodeOfType(initializer, "CallExpression");
+		const isNewCall = isNodeOfType(initializer, "NewExpression");
+		if (!isPlainCall && !isNewCall) return;
+		const callee = initializer.callee;
+		const memberPropertyName = isNodeOfType(callee, "MemberExpression") && (isNodeOfType(callee.property, "Identifier") || isNodeOfType(callee.property, "PrivateIdentifier")) ? callee.property.name : null;
+		const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : memberPropertyName ?? "fn";
+		if (TRIVIAL_INITIALIZER_NAMES.has(calleeName)) return;
+		if (isPlainCall && isReactHookName(calleeName)) return;
+		const callShape = isNewCall ? `new ${calleeName}()` : `${calleeName}()`;
+		const lazyFix = isNewCall ? `ref.current = new ${calleeName}();` : `ref.current = ${calleeName}();`;
+		context.report({
+			node: initializer,
+			message: `useRef(${callShape}) allocates a fresh value on every render — useRef has no lazy-init form, so the allocation is discarded after the first render. Use \`const ref = useRef(null); if (ref.current === null) ${lazyFix}\` or \`useMemo\` instead.`
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/state-and-effects/rerender-lazy-state-init.ts
 const rerenderLazyStateInit = defineRule({
 	id: "rerender-lazy-state-init",
@@ -30053,7 +31672,7 @@ const isUseEffectEventSymbol = (symbol) => {
 const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$1(current)) {
+		if (isFunctionLike$2(current)) {
 			const resolvedName = inferFunctionName(current);
 			if (resolvedName !== null && isReactComponentOrHookName(resolvedName)) return current;
 		}
@@ -30074,7 +31693,7 @@ const isCallbackArgumentForAllowedEffectEventHook = (functionNode, additionalEff
 const isInsideAllowedEffectEventCallback = (node, additionalEffectHooksRegex) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$1(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
+		if (isFunctionLike$2(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
 		current = current.parent ?? null;
 	}
 	return false;
@@ -30408,7 +32027,7 @@ const containsAuthCheck = (rootNodes, allowedFunctionNames, genericMethodNames)
 	let foundAuthCall = false;
 	for (const rootNode of rootNodes) walkAst(rootNode, (child) => {
 		if (foundAuthCall) return;
-		if (isFunctionLike$1(child)) return false;
+		if (isFunctionLike$2(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (getAuthCallName(child, allowedFunctionNames, genericMethodNames)) foundAuthCall = true;
 	});
@@ -32995,6 +34614,28 @@ const reactDoctorRules = [
 			category: "Architecture"
 		}
 	},
+	{
+		key: "react-doctor/no-create-context-in-render",
+		id: "no-create-context-in-render",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noCreateContextInRender,
+			framework: "global",
+			category: "Correctness"
+		}
+	},
+	{
+		key: "react-doctor/no-create-store-in-render",
+		id: "no-create-store-in-render",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noCreateStoreInRender,
+			framework: "global",
+			category: "Correctness"
+		}
+	},
 	{
 		key: "react-doctor/no-danger",
 		id: "no-danger",
@@ -33193,6 +34834,17 @@ const reactDoctorRules = [
 			category: "State & Effects"
 		}
 	},
+	{
+		key: "react-doctor/no-effect-with-fresh-deps",
+		id: "no-effect-with-fresh-deps",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noEffectWithFreshDeps,
+			framework: "global",
+			category: "State & Effects"
+		}
+	},
 	{
 		key: "react-doctor/no-eval",
 		id: "no-eval",
@@ -33666,6 +35318,17 @@ const reactDoctorRules = [
 			category: "State & Effects"
 		}
 	},
+	{
+		key: "react-doctor/no-prop-types",
+		id: "no-prop-types",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noPropTypes,
+			framework: "global",
+			category: "Architecture"
+		}
+	},
 	{
 		key: "react-doctor/no-pure-black-background",
 		id: "no-pure-black-background",
@@ -33677,6 +35340,17 @@ const reactDoctorRules = [
 			category: "Architecture"
 		}
 	},
+	{
+		key: "react-doctor/no-random-key",
+		id: "no-random-key",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noRandomKey,
+			framework: "global",
+			category: "Correctness"
+		}
+	},
 	{
 		key: "react-doctor/no-react-children",
 		id: "no-react-children",
@@ -33798,6 +35472,17 @@ const reactDoctorRules = [
 			category: "Security"
 		}
 	},
+	{
+		key: "react-doctor/no-self-updating-effect",
+		id: "no-self-updating-effect",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noSelfUpdatingEffect,
+			framework: "global",
+			category: "State & Effects"
+		}
+	},
 	{
 		key: "react-doctor/no-set-state",
 		id: "no-set-state",
@@ -34106,6 +35791,39 @@ const reactDoctorRules = [
 			category: "Accessibility"
 		}
 	},
+	{
+		key: "react-doctor/prefer-module-scope-pure-function",
+		id: "prefer-module-scope-pure-function",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preferModuleScopePureFunction,
+			framework: "global",
+			category: "Architecture"
+		}
+	},
+	{
+		key: "react-doctor/prefer-module-scope-static-value",
+		id: "prefer-module-scope-static-value",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preferModuleScopeStaticValue,
+			framework: "global",
+			category: "Architecture"
+		}
+	},
+	{
+		key: "react-doctor/prefer-stable-empty-fallback",
+		id: "prefer-stable-empty-fallback",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preferStableEmptyFallback,
+			framework: "global",
+			category: "Performance"
+		}
+	},
 	{
 		key: "react-doctor/prefer-tag-over-role",
 		id: "prefer-tag-over-role",
@@ -34238,6 +35956,28 @@ const reactDoctorRules = [
 			category: "Correctness"
 		}
 	},
+	{
+		key: "react-doctor/redux-useselector-inline-derivation",
+		id: "redux-useselector-inline-derivation",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...reduxUseselectorInlineDerivation,
+			framework: "global",
+			category: "Performance"
+		}
+	},
+	{
+		key: "react-doctor/redux-useselector-returns-new-collection",
+		id: "redux-useselector-returns-new-collection",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...reduxUseselectorReturnsNewCollection,
+			framework: "global",
+			category: "Performance"
+		}
+	},
 	{
 		key: "react-doctor/rendering-animate-svg-wrapper",
 		id: "rendering-animate-svg-wrapper",
@@ -34381,6 +36121,17 @@ const reactDoctorRules = [
 			category: "Performance"
 		}
 	},
+	{
+		key: "react-doctor/rerender-lazy-ref-init",
+		id: "rerender-lazy-ref-init",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rerenderLazyRefInit,
+			framework: "global",
+			category: "Performance"
+		}
+	},
 	{
 		key: "react-doctor/rerender-lazy-state-init",
 		id: "rerender-lazy-state-init",
@@ -35205,7 +36956,7 @@ const appendNode = (builder, block, node) => {
 };
 const mapDescendantsToBlock = (builder, node, block) => {
 	builder.nodeBlock.set(node, block);
-	if (isFunctionLike$1(node)) return;
+	if (isFunctionLike$2(node)) return;
 	const record = node;
 	for (const key of Object.keys(record)) {
 		if (key === "parent") continue;
@@ -35543,7 +37294,7 @@ const analyzeControlFlow = (program) => {
 		body: program.body
 	});
 	const visit = (node) => {
-		if (isFunctionLike$1(node)) {
+		if (isFunctionLike$2(node)) {
 			const body = node.body;
 			if (body) buildFor(node, body);
 		}
@@ -35560,7 +37311,7 @@ const analyzeControlFlow = (program) => {
 	const enclosingFunction = (node) => {
 		let current = node;
 		while (current) {
-			if (isFunctionLike$1(current)) return current;
+			if (isFunctionLike$2(current)) return current;
 			if (isNodeOfType(current, "Program")) return current;
 			current = current.parent ?? null;
 		}