react-doctor 0.0.47 → 0.1.1

package/dist/react-doctor-plugin.js

@@ -245,10 +245,38 @@ const TRIVIAL_INITIALIZER_NAMES = new Set([
 	"parseInt",
 	"parseFloat"
 ]);
+const TRIVIAL_DERIVATION_CALLEE_NAMES = new Set([
+	"Boolean",
+	"String",
+	"Number",
+	"Array",
+	"Object",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"BigInt",
+	"Symbol"
+]);
+const BUILTIN_GLOBAL_NAMESPACE_NAMES = new Set([
+	"Math",
+	"Date",
+	"JSON",
+	"Object",
+	"Array",
+	"Number",
+	"String",
+	"Boolean",
+	"RegExp",
+	"Symbol",
+	"BigInt",
+	"Reflect"
+]);
 const SETTER_PATTERN = /^set[A-Z]/;
 const RENDER_FUNCTION_PATTERN = /^render[A-Z]/;
 const UPPERCASE_PATTERN = /^[A-Z]/;
 const PAGE_FILE_PATTERN = /\/page\.(tsx?|jsx?)$/;
+const REACT_HANDLER_PROP_PATTERN = /^on[A-Z]/;
 const PAGE_OR_LAYOUT_FILE_PATTERN = /\/(page|layout)\.(tsx?|jsx?)$/;
 const INTERNAL_PAGE_PATH_PATTERN = /\/(?:(?:\((?:dashboard|admin|settings|account|internal|manage|console|portal|auth|onboarding|app|ee|protected)\))|(?:dashboard|admin|settings|account|internal|manage|console|portal))\//i;
 const TEST_FILE_PATTERN = /\.(?:test|spec|stories)\.[tj]sx?$/;
@@ -282,6 +310,17 @@ const MUTATION_METHOD_NAMES = new Set([
 	"set",
 	"append"
 ]);
+const MUTATING_ARRAY_METHODS = new Set([
+	"push",
+	"pop",
+	"shift",
+	"unshift",
+	"splice",
+	"sort",
+	"reverse",
+	"fill",
+	"copyWithin"
+]);
 const MUTATING_HTTP_METHODS = new Set([
 	"POST",
 	"PUT",
@@ -307,6 +346,112 @@ const HOOKS_WITH_DEPS = new Set([
 	"useMemo",
 	"useCallback"
 ]);
+const TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES = new Set([
+	"setTimeout",
+	"setInterval",
+	"requestAnimationFrame",
+	"requestIdleCallback",
+	"queueMicrotask"
+]);
+const TIMER_CALLEE_NAMES_REQUIRING_CLEANUP = new Set(["setInterval", "setTimeout"]);
+const TIMER_CLEANUP_CALLEE_NAMES = new Set(["clearInterval", "clearTimeout"]);
+const MUTABLE_GLOBAL_ROOTS = new Set([
+	"location",
+	"window",
+	"document",
+	"navigator",
+	"history",
+	"screen",
+	"performance"
+]);
+const SUBSCRIPTION_METHOD_NAMES = new Set([
+	"subscribe",
+	"addEventListener",
+	"addListener",
+	"on",
+	"watch",
+	"listen",
+	"sub"
+]);
+const UNSUBSCRIPTION_METHOD_NAMES = new Set([
+	"unsubscribe",
+	"removeEventListener",
+	"removeListener",
+	"off",
+	"unwatch",
+	"unlisten",
+	"unsub"
+]);
+const CLEANUP_LIKE_RELEASE_CALLEE_NAMES = new Set([
+	...UNSUBSCRIPTION_METHOD_NAMES,
+	"cleanup",
+	"dispose",
+	"destroy",
+	"teardown"
+]);
+const EXTERNAL_SYNC_MEMBER_METHOD_NAMES = new Set([
+	...SUBSCRIPTION_METHOD_NAMES,
+	"connect",
+	"disconnect",
+	"open",
+	"close",
+	"fetch",
+	"post",
+	"put",
+	"patch"
+]);
+const EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS = new Set([
+	...FETCH_MEMBER_OBJECTS,
+	"api",
+	"client",
+	"http",
+	"fetcher"
+]);
+const EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES = new Set([
+	"get",
+	"head",
+	"options",
+	"delete"
+]);
+const EXTERNAL_SYNC_DIRECT_CALLEE_NAMES = new Set([...FETCH_CALLEE_NAMES, ...TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES]);
+const EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS = new Set([
+	"IntersectionObserver",
+	"MutationObserver",
+	"ResizeObserver",
+	"PerformanceObserver"
+]);
+const EVENT_TRIGGERED_SIDE_EFFECT_CALLEES = new Set([
+	...FETCH_CALLEE_NAMES,
+	"post",
+	"put",
+	"patch",
+	"navigate",
+	"navigateTo",
+	"showNotification",
+	"toast",
+	"alert",
+	"confirm",
+	"logVisit",
+	"captureEvent"
+]);
+const EVENT_TRIGGERED_SIDE_EFFECT_MEMBER_METHODS = new Set([
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"navigate",
+	"capture",
+	"track",
+	"logEvent"
+]);
+const EVENT_TRIGGERED_NAVIGATION_METHOD_NAMES = new Set(["push", "replace"]);
+const NAVIGATION_RECEIVER_NAMES = new Set([
+	"router",
+	"navigation",
+	"navigator",
+	"history",
+	"location"
+]);
 const CHAINABLE_ITERATION_METHODS = new Set([
 	"map",
 	"filter",
@@ -341,29 +486,29 @@ const REACT_NATIVE_TEXT_COMPONENT_KEYWORDS = new Set([
 	"Description",
 	"Body"
 ]);
-const DEPRECATED_RN_MODULE_REPLACEMENTS = {
-	AsyncStorage: "@react-native-async-storage/async-storage",
-	Picker: "@react-native-picker/picker",
-	PickerIOS: "@react-native-picker/picker",
-	DatePickerIOS: "@react-native-community/datetimepicker",
-	DatePickerAndroid: "@react-native-community/datetimepicker",
-	ProgressBarAndroid: "a community alternative",
-	ProgressViewIOS: "a community alternative",
-	SafeAreaView: "react-native-safe-area-context",
-	Slider: "@react-native-community/slider",
-	ViewPagerAndroid: "react-native-pager-view",
-	WebView: "react-native-webview",
-	NetInfo: "@react-native-community/netinfo",
-	CameraRoll: "@react-native-camera-roll/camera-roll",
-	Clipboard: "@react-native-clipboard/clipboard",
-	ImageEditor: "@react-native-community/image-editor",
-	MaskedViewIOS: "@react-native-masked-view/masked-view"
-};
-const LEGACY_EXPO_PACKAGE_REPLACEMENTS = {
-	"expo-av": "expo-audio for audio and expo-video for video",
-	"expo-permissions": "the permissions API in each module (e.g. Camera.requestPermissionsAsync())",
-	"@expo/vector-icons": "expo-symbols or expo-image (see https://docs.expo.dev/versions/latest/sdk/symbols/)"
-};
+const DEPRECATED_RN_MODULE_REPLACEMENTS = new Map([
+	["AsyncStorage", "@react-native-async-storage/async-storage"],
+	["Picker", "@react-native-picker/picker"],
+	["PickerIOS", "@react-native-picker/picker"],
+	["DatePickerIOS", "@react-native-community/datetimepicker"],
+	["DatePickerAndroid", "@react-native-community/datetimepicker"],
+	["ProgressBarAndroid", "a community alternative"],
+	["ProgressViewIOS", "a community alternative"],
+	["SafeAreaView", "react-native-safe-area-context"],
+	["Slider", "@react-native-community/slider"],
+	["ViewPagerAndroid", "react-native-pager-view"],
+	["WebView", "react-native-webview"],
+	["NetInfo", "@react-native-community/netinfo"],
+	["CameraRoll", "@react-native-camera-roll/camera-roll"],
+	["Clipboard", "@react-native-clipboard/clipboard"],
+	["ImageEditor", "@react-native-community/image-editor"],
+	["MaskedViewIOS", "@react-native-masked-view/masked-view"]
+]);
+const LEGACY_EXPO_PACKAGE_REPLACEMENTS = new Map([
+	["expo-av", "expo-audio for audio and expo-video for video"],
+	["expo-permissions", "the permissions API in each module (e.g. Camera.requestPermissionsAsync())"],
+	["@expo/vector-icons", "expo-symbols or expo-image (see https://docs.expo.dev/versions/latest/sdk/symbols/)"]
+]);
 const REACT_NATIVE_LIST_COMPONENTS = new Set([
 	"FlatList",
 	"SectionList",
@@ -385,6 +530,87 @@ const BOUNCE_ANIMATION_NAMES = new Set([
 	"spring"
 ]);
 const LONG_TRANSITION_DURATION_THRESHOLD_MS = 1e3;
+const HEADING_TAG_NAMES = new Set([
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]);
+const HEAVY_HEADING_TAILWIND_WEIGHTS = new Set([
+	"font-bold",
+	"font-extrabold",
+	"font-black"
+]);
+const TAILWIND_DEFAULT_PALETTE_NAMES = [
+	"indigo",
+	"gray",
+	"slate"
+];
+const TAILWIND_DEFAULT_PALETTE_STOPS = [
+	"50",
+	"100",
+	"200",
+	"300",
+	"400",
+	"500",
+	"600",
+	"700",
+	"800",
+	"900",
+	"950"
+];
+const TAILWIND_PALETTE_UTILITY_PREFIXES = [
+	"text",
+	"bg",
+	"border",
+	"ring",
+	"fill",
+	"stroke",
+	"from",
+	"to",
+	"via",
+	"decoration",
+	"divide",
+	"outline",
+	"placeholder",
+	"caret",
+	"accent",
+	"shadow"
+];
+const VAGUE_BUTTON_LABELS = new Set([
+	"continue",
+	"submit",
+	"ok",
+	"okay",
+	"click here",
+	"here",
+	"yes",
+	"no",
+	"go",
+	"done"
+]);
+const ELLIPSIS_EXCLUDED_TAG_NAMES = new Set([
+	"code",
+	"pre",
+	"kbd",
+	"samp",
+	"var",
+	"tt"
+]);
+const PADDING_HORIZONTAL_AXIS_PATTERN = /(?:^|\s)(-?)px-(\d+(?:\.\d+)?|\[[^\]]+\])(?=$|[\s:])/g;
+const PADDING_VERTICAL_AXIS_PATTERN = /(?:^|\s)(-?)py-(\d+(?:\.\d+)?|\[[^\]]+\])(?=$|[\s:])/g;
+const SIZE_WIDTH_AXIS_PATTERN = /(?:^|\s)(-?)w-(\d+(?:\.\d+)?|\[[^\]]+\])(?=$|[\s:])/g;
+const SIZE_HEIGHT_AXIS_PATTERN = /(?:^|\s)(-?)h-(\d+(?:\.\d+)?|\[[^\]]+\])(?=$|[\s:])/g;
+const FLEX_OR_GRID_DISPLAY_TOKENS = new Set([
+	"flex",
+	"inline-flex",
+	"grid",
+	"inline-grid"
+]);
+const SPACE_AXIS_PATTERN = /(?:^|\s)(?:-)?space-(x|y)-(\d+(?:\.\d+)?|\[[^\]]+\])(?=$|[\s:])/;
+const TRAILING_THREE_PERIOD_ELLIPSIS_PATTERN = /[A-Za-z]\.\.\./;
 //#endregion
 //#region src/plugin/helpers.ts
 const walkAst = (node, visitor) => {
@@ -398,10 +624,60 @@ const walkAst = (node, visitor) => {
 		} else if (child && typeof child === "object" && child.type) walkAst(child, visitor);
 	}
 };
+const walkInsideStatementBlocks = (node, visitor) => {
+	if (!node || typeof node !== "object") return;
+	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return;
+	visitor(node);
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const item of child) if (item && typeof item === "object" && item.type) walkInsideStatementBlocks(item, visitor);
+		} else if (child && typeof child === "object" && child.type) walkInsideStatementBlocks(child, visitor);
+	}
+};
 const isSetterIdentifier = (name) => SETTER_PATTERN.test(name);
 const isSetterCall = (node) => node.type === "CallExpression" && node.callee?.type === "Identifier" && isSetterIdentifier(node.callee.name);
 const isUppercaseName = (name) => UPPERCASE_PATTERN.test(name);
 const isMemberProperty = (node, propertyName) => node.type === "MemberExpression" && node.property?.type === "Identifier" && node.property.name === propertyName;
+const getRootIdentifierName = (node, options) => {
+	if (!node) return null;
+	if (node.type === "Identifier") return node.name;
+	const followCallChains = options?.followCallChains === true;
+	let cursor = node;
+	while (cursor) {
+		if (cursor.type === "MemberExpression") {
+			cursor = cursor.object;
+			continue;
+		}
+		if (followCallChains && cursor.type === "CallExpression") {
+			const callee = cursor.callee;
+			if (callee?.type !== "MemberExpression") return null;
+			cursor = callee.object;
+			continue;
+		}
+		break;
+	}
+	return cursor?.type === "Identifier" ? cursor.name : null;
+};
+const areExpressionsStructurallyEqual = (a, b) => {
+	if (!a || !b) return a === b;
+	if (a.type !== b.type) return false;
+	if (a.type === "Identifier") return a.name === b.name;
+	if (a.type === "Literal") return a.value === b.value;
+	if (a.type === "MemberExpression") {
+		if (a.computed !== b.computed) return false;
+		return areExpressionsStructurallyEqual(a.object, b.object) && areExpressionsStructurallyEqual(a.property, b.property);
+	}
+	if (a.type === "CallExpression") {
+		if (!areExpressionsStructurallyEqual(a.callee, b.callee)) return false;
+		const argumentsA = a.arguments ?? [];
+		const argumentsB = b.arguments ?? [];
+		if (argumentsA.length !== argumentsB.length) return false;
+		return argumentsA.every((argument, index) => areExpressionsStructurallyEqual(argument, argumentsB[index]));
+	}
+	return false;
+};
 const getEffectCallback = (node) => {
 	if (!node.arguments?.length) return null;
 	const callback = node.arguments[0];
@@ -545,6 +821,94 @@ const extractDestructuredPropNames = (params) => {
 	for (const param of params) collectPatternNames(param, propNames);
 	return propNames;
 };
+const isFunctionLikeVariableDeclarator = (node) => {
+	if (node.type !== "VariableDeclarator") return false;
+	return node.init?.type === "ArrowFunctionExpression" || node.init?.type === "FunctionExpression";
+};
+const createComponentPropStackTracker = (callbacks) => {
+	const propParamStack = [];
+	const isPropName = (name) => {
+		for (let frameIndex = propParamStack.length - 1; frameIndex >= 0; frameIndex--) {
+			const frame = propParamStack[frameIndex];
+			if (frame.size === 0) return false;
+			if (frame.has(name)) return true;
+		}
+		return false;
+	};
+	const getCurrentPropNames = () => {
+		for (let frameIndex = propParamStack.length - 1; frameIndex >= 0; frameIndex--) {
+			const frame = propParamStack[frameIndex];
+			if (frame.size === 0) return /* @__PURE__ */ new Set();
+			return frame;
+		}
+		return /* @__PURE__ */ new Set();
+	};
+	return {
+		isPropName,
+		getCurrentPropNames,
+		visitors: {
+			FunctionDeclaration(node) {
+				if (!node.id?.name || !isUppercaseName(node.id.name)) {
+					propParamStack.push(/* @__PURE__ */ new Set());
+					return;
+				}
+				propParamStack.push(extractDestructuredPropNames(node.params ?? []));
+				callbacks?.onComponentEnter?.(node.body);
+			},
+			"FunctionDeclaration:exit"() {
+				propParamStack.pop();
+			},
+			VariableDeclarator(node) {
+				if (isComponentAssignment(node)) {
+					propParamStack.push(extractDestructuredPropNames(node.init?.params ?? []));
+					callbacks?.onComponentEnter?.(node.init?.body);
+					return;
+				}
+				if (isFunctionLikeVariableDeclarator(node)) propParamStack.push(/* @__PURE__ */ new Set());
+			},
+			"VariableDeclarator:exit"(node) {
+				if (isComponentAssignment(node) || isFunctionLikeVariableDeclarator(node)) propParamStack.pop();
+			}
+		}
+	};
+};
+const createComponentBindingStackTracker = (callbacks) => {
+	const componentBindingStack = [];
+	const isInsideComponent = () => componentBindingStack.length > 0;
+	const isBoundName = (name) => {
+		for (let frameIndex = componentBindingStack.length - 1; frameIndex >= 0; frameIndex--) if (componentBindingStack[frameIndex].has(name)) return true;
+		return false;
+	};
+	const addBindingToCurrentFrame = (name) => {
+		if (componentBindingStack.length === 0) return;
+		componentBindingStack[componentBindingStack.length - 1].add(name);
+	};
+	return {
+		isInsideComponent,
+		isBoundName,
+		addBindingToCurrentFrame,
+		visitors: {
+			FunctionDeclaration(node) {
+				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+				componentBindingStack.push(/* @__PURE__ */ new Set());
+			},
+			"FunctionDeclaration:exit"(node) {
+				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+				componentBindingStack.pop();
+			},
+			VariableDeclarator(node) {
+				if (isComponentAssignment(node)) {
+					componentBindingStack.push(/* @__PURE__ */ new Set());
+					return;
+				}
+				callbacks?.onVariableDeclarator?.(node);
+			},
+			"VariableDeclarator:exit"(node) {
+				if (isComponentAssignment(node)) componentBindingStack.pop();
+			}
+		}
+	};
+};
 //#endregion
 //#region src/plugin/rules/architecture.ts
 const noGenericHandlerNames = { create: (context) => ({ JSXAttribute(node) {
@@ -665,20 +1029,20 @@ const noManyBooleanProps = { create: (context) => {
 		}
 	};
 } };
-const REACT_19_DEPRECATED_MESSAGES = {
-	forwardRef: "forwardRef is no longer needed on React 19+ — refs are regular props on function components; remove forwardRef and pass ref directly",
-	useContext: "useContext is superseded by `use()` on React 19+ — `use()` reads context conditionally inside hooks, branches, and loops; switch to `import { use } from 'react'`"
-};
-const noReact19DeprecatedApis = { create: (context) => {
-	const reactNamespaceBindings = /* @__PURE__ */ new Set();
+const REACT_19_DEPRECATED_MESSAGES = new Map([["forwardRef", "forwardRef is no longer needed on React 19+ — refs are regular props on function components; remove forwardRef and pass ref directly"], ["useContext", "useContext is superseded by `use()` on React 19+ — `use()` reads context conditionally inside hooks, branches, and loops; switch to `import { use } from 'react'`"]]);
+const createDeprecatedReactImportRule = ({ source, messages, handleExtraSource }) => ({ create: (context) => {
+	const namespaceBindings = /* @__PURE__ */ new Set();
 	return {
 		ImportDeclaration(node) {
-			if (node.source?.value !== "react") return;
+			const sourceValue = node.source?.value;
+			if (typeof sourceValue !== "string") return;
+			if (handleExtraSource?.(node, context)) return;
+			if (sourceValue !== source) return;
 			for (const specifier of node.specifiers ?? []) {
 				if (specifier.type === "ImportSpecifier") {
 					const importedName = specifier.imported?.name;
 					if (!importedName) continue;
-					const message = REACT_19_DEPRECATED_MESSAGES[importedName];
+					const message = messages.get(importedName);
 					if (message) context.report({
 						node: specifier,
 						message
@@ -687,24 +1051,28 @@ const noReact19DeprecatedApis = { create: (context) => {
 				}
 				if (specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") {
 					const localName = specifier.local?.name;
-					if (localName) reactNamespaceBindings.add(localName);
+					if (localName) namespaceBindings.add(localName);
 				}
 			}
 		},
 		MemberExpression(node) {
-			if (reactNamespaceBindings.size === 0) return;
+			if (namespaceBindings.size === 0) return;
 			if (node.computed) return;
 			if (node.object?.type !== "Identifier") return;
-			if (!reactNamespaceBindings.has(node.object.name)) return;
+			if (!namespaceBindings.has(node.object.name)) return;
 			if (node.property?.type !== "Identifier") return;
-			const message = REACT_19_DEPRECATED_MESSAGES[node.property.name];
+			const message = messages.get(node.property.name);
 			if (message) context.report({
 				node,
 				message
 			});
 		}
 	};
-} };
+} });
+const noReact19DeprecatedApis = createDeprecatedReactImportRule({
+	source: "react",
+	messages: REACT_19_DEPRECATED_MESSAGES
+});
 const RENDER_PROP_PATTERN = /^render[A-Z]/;
 const noRenderPropChildren = { create: (context) => ({ JSXOpeningElement(node) {
 	const renderPropAttrs = [];
@@ -804,6 +1172,148 @@ const reactCompilerDestructureMethod = { create: (context) => {
 		}
 	};
 } };
+const LEGACY_LIFECYCLE_REPLACEMENTS = new Map([
+	["componentWillMount", "Move side effects to `componentDidMount`; move initial state to `constructor`"],
+	["componentWillReceiveProps", "Move side effects to `componentDidUpdate` (compare prevProps); move pure state derivation to the static `getDerivedStateFromProps`"],
+	["componentWillUpdate", "Move DOM reads to `getSnapshotBeforeUpdate` (passes the value to `componentDidUpdate`); move other work to `componentDidUpdate`"]
+]);
+const stripUnsafePrefix = (name) => {
+	if (name.startsWith("UNSAFE_")) return {
+		baseName: name.slice(7),
+		hasUnsafePrefix: true
+	};
+	return {
+		baseName: name,
+		hasUnsafePrefix: false
+	};
+};
+const buildLegacyLifecycleMessage = (originalName) => {
+	const { baseName, hasUnsafePrefix } = stripUnsafePrefix(originalName);
+	const replacement = LEGACY_LIFECYCLE_REPLACEMENTS.get(baseName);
+	if (!replacement) return null;
+	return `${hasUnsafePrefix ? `\`${originalName}\` is removed in React 19 (the UNSAFE_ prefix only silences the React 18 warning, it doesn't fix the concurrent-mode hazard).` : `\`${originalName}\` is removed in React 19 and warns in React 18.3.1.`} ${replacement}.`;
+};
+const noLegacyClassLifecycles = { create: (context) => {
+	const checkMember = (memberNode) => {
+		if (!memberNode) return;
+		if (memberNode.type !== "MethodDefinition" && memberNode.type !== "PropertyDefinition") return;
+		if (memberNode.key?.type !== "Identifier") return;
+		const message = buildLegacyLifecycleMessage(memberNode.key.name);
+		if (message) context.report({
+			node: memberNode.key,
+			message
+		});
+	};
+	return { ClassBody(node) {
+		for (const member of node.body ?? []) checkMember(member);
+	} };
+} };
+const LEGACY_CONTEXT_NAMES = new Set([
+	"childContextTypes",
+	"contextTypes",
+	"getChildContext"
+]);
+const buildLegacyContextMessage = (memberName) => {
+	if (memberName === "childContextTypes" || memberName === "getChildContext") return `${memberName} is part of the legacy context API (REMOVED in React 19). Replace the provider with \`createContext\` + \`<MyContext.Provider value={...}>\` and consume via \`useContext()\` (or \`use()\` on React 19+) — every consumer must migrate together`;
+	return "contextTypes is part of the legacy context API (REMOVED in React 19). Replace with `static contextType = MyContext` (single context) or read the modern context with `useContext()` / `use()` from a function component — coordinate with the provider's migration";
+};
+const isInsideClassBody = (node) => {
+	let current = node.parent;
+	while (current) {
+		if (current.type === "ClassBody") return true;
+		if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") return false;
+		current = current.parent;
+	}
+	return false;
+};
+const noLegacyContextApi = { create: (context) => {
+	const checkMember = (memberNode) => {
+		if (!memberNode) return;
+		if (memberNode.type !== "MethodDefinition" && memberNode.type !== "PropertyDefinition") return;
+		if (memberNode.key?.type !== "Identifier") return;
+		if (!LEGACY_CONTEXT_NAMES.has(memberNode.key.name)) return;
+		context.report({
+			node: memberNode.key,
+			message: buildLegacyContextMessage(memberNode.key.name)
+		});
+	};
+	return {
+		ClassBody(node) {
+			for (const member of node.body ?? []) checkMember(member);
+		},
+		AssignmentExpression(node) {
+			if (node.operator !== "=") return;
+			const left = node.left;
+			if (left?.type !== "MemberExpression") return;
+			if (left.computed) return;
+			if (left.property?.type !== "Identifier") return;
+			if (!LEGACY_CONTEXT_NAMES.has(left.property.name)) return;
+			if (left.object?.type !== "Identifier") return;
+			if (!isUppercaseName(left.object.name)) return;
+			if (isInsideClassBody(node)) return;
+			context.report({
+				node: left,
+				message: buildLegacyContextMessage(left.property.name)
+			});
+		}
+	};
+} };
+const noDefaultProps = { create: (context) => ({ AssignmentExpression(node) {
+	if (node.operator !== "=") return;
+	const left = node.left;
+	if (left?.type !== "MemberExpression") return;
+	if (left.computed) return;
+	if (left.property?.type !== "Identifier" || left.property.name !== "defaultProps") return;
+	if (left.object?.type !== "Identifier") return;
+	if (!isUppercaseName(left.object.name)) return;
+	context.report({
+		node: left,
+		message: `${left.object.name}.defaultProps — React 19 removes \`defaultProps\` for function components and discourages it for class components. Move defaults into the destructured props parameter (e.g. \`function ${left.object.name}({ size = "md", ...rest })\`) so the rule applies cleanly to both shapes`
+	});
+} }) };
+const REACT_DOM_DEPRECATED_MESSAGES = new Map([
+	["render", "ReactDOM.render is the legacy root API — switch to `import { createRoot } from 'react-dom/client'` and call `createRoot(container).render(...)` (REMOVED in React 19)"],
+	["hydrate", "ReactDOM.hydrate is the legacy SSR API — switch to `import { hydrateRoot } from 'react-dom/client'` and call `hydrateRoot(container, <App />)` (REMOVED in React 19)"],
+	["unmountComponentAtNode", "ReactDOM.unmountComponentAtNode no longer works on roots created with `createRoot` — keep a reference to the root and call `root.unmount()` instead (REMOVED in React 19)"],
+	["findDOMNode", "ReactDOM.findDOMNode crawls the rendered tree and breaks composition — accept a ref directly and read `ref.current` (REMOVED in React 19)"]
+]);
+const REACT_DOM_TEST_UTILS_REPLACEMENTS = new Map([
+	["act", "`import { act } from 'react'` instead"],
+	["Simulate", "`fireEvent` from `@testing-library/react` instead"],
+	["renderIntoDocument", "`render` from `@testing-library/react` instead"],
+	["findRenderedDOMComponentWithTag", "`getByRole` / `getByTestId` from `@testing-library/react`"],
+	["findRenderedDOMComponentWithClass", "`getByRole` or `container.querySelector` from RTL"],
+	["scryRenderedDOMComponentsWithTag", "`getAllByRole` from `@testing-library/react`"]
+]);
+const buildTestUtilsMessage = (importedName) => {
+	const replacement = REACT_DOM_TEST_UTILS_REPLACEMENTS.get(importedName);
+	return `react-dom/test-utils is removed in React 19. ${replacement ? `Use ${replacement}.` : "Switch to `act` from `react` or the equivalent in `@testing-library/react`."}`;
+};
+const reportTestUtilsImports = (node, context) => {
+	for (const specifier of node.specifiers ?? []) {
+		if (specifier.type === "ImportSpecifier") {
+			const importedName = specifier.imported?.name ?? "default";
+			context.report({
+				node: specifier,
+				message: buildTestUtilsMessage(importedName)
+			});
+			continue;
+		}
+		context.report({
+			node: specifier,
+			message: "react-dom/test-utils is removed in React 19. Use `act` from `react` and `fireEvent` / `render` from `@testing-library/react` instead"
+		});
+	}
+};
+const noReactDomDeprecatedApis = createDeprecatedReactImportRule({
+	source: "react-dom",
+	messages: REACT_DOM_DEPRECATED_MESSAGES,
+	handleExtraSource: (node, context) => {
+		if (node.source?.value !== "react-dom/test-utils") return false;
+		reportTestUtilsImports(node, context);
+		return true;
+	}
+});
 //#endregion
 //#region src/plugin/rules/bundle-size.ts
 const noBarrelImport = { create: (context) => {
@@ -1076,12 +1586,12 @@ const isBackgroundDark = (bgValue) => {
 	if (!parsed) return false;
 	return parsed.red <= 35 && parsed.green <= 35 && parsed.blue <= 35;
 };
-const BORDER_SIDE_KEYS = {
-	borderLeft: "left",
-	borderRight: "right",
-	borderInlineStart: "left",
-	borderInlineEnd: "right"
-};
+const BORDER_SIDE_KEYS = new Map([
+	["borderLeft", "left"],
+	["borderRight", "right"],
+	["borderInlineStart", "left"],
+	["borderInlineEnd", "right"]
+]);
 const BORDER_SIDE_WIDTH_KEYS = new Set([
 	"borderLeftWidth",
 	"borderRightWidth",
@@ -1171,7 +1681,8 @@ const noSideTabBorder = { create: (context) => ({
 		for (const property of expression.properties ?? []) {
 			const key = getStylePropertyKey(property);
 			if (!key) continue;
-			if (key in BORDER_SIDE_KEYS) {
+			const sideLabel = BORDER_SIDE_KEYS.get(key);
+			if (sideLabel !== void 0) {
 				const value = getStylePropertyStringValue(property);
 				if (!value) continue;
 				const widthMatch = value.match(/^(\d+)px\s+solid/);
@@ -1181,7 +1692,7 @@ const noSideTabBorder = { create: (context) => ({
 				const width = parseInt(widthMatch[1], 10);
 				if (width >= threshold) context.report({
 					node: property,
-					message: `Thick one-sided border (${BORDER_SIDE_KEYS[key]}: ${width}px) — the most recognizable tell of AI-generated UIs. Use a subtler accent or remove it`
+					message: `Thick one-sided border (${sideLabel}: ${width}px) — the most recognizable tell of AI-generated UIs. Use a subtler accent or remove it`
 				});
 			}
 			if (BORDER_SIDE_WIDTH_KEYS.has(key)) {
@@ -1507,10 +2018,7 @@ const noArrayIndexAsKey = { create: (context) => ({ JSXAttribute(node) {
 		message: `Array index "${indexName}" used as key — causes bugs when list is reordered or filtered`
 	});
 } }) };
-const PREVENT_DEFAULT_ELEMENTS = {
-	form: ["onSubmit"],
-	a: ["onClick"]
-};
+const PREVENT_DEFAULT_ELEMENTS = new Map([["form", ["onSubmit"]], ["a", ["onClick"]]]);
 const containsPreventDefaultCall = (node) => {
 	let didFindPreventDefault = false;
 	walkAst(node, (child) => {
@@ -1526,7 +2034,7 @@ const buildPreventDefaultMessage = (elementName) => {
 const noPreventDefault = { create: (context) => ({ JSXOpeningElement(node) {
 	const elementName = node.name?.type === "JSXIdentifier" ? node.name.name : null;
 	if (!elementName) return;
-	const targetEventProps = PREVENT_DEFAULT_ELEMENTS[elementName];
+	const targetEventProps = PREVENT_DEFAULT_ELEMENTS.get(elementName);
 	if (!targetEventProps) return;
 	for (const targetEventProp of targetEventProps) {
 		const eventAttribute = findJsxAttribute(node.attributes ?? [], targetEventProp);
@@ -1599,6 +2107,98 @@ const renderingSvgPrecision = { create: (context) => ({ JSXAttribute(node) {
 		message: `SVG ${node.name.name} attribute uses 4+ decimal precision — truncate to 1–2 decimals to shrink markup with no visible difference`
 	});
 } }) };
+const UNCONTROLLED_INPUT_TAGS = new Set([
+	"input",
+	"textarea",
+	"select"
+]);
+const VALUE_BYPASS_INPUT_TYPES = new Set([
+	"hidden",
+	"checkbox",
+	"radio"
+]);
+const VALUE_PARTNER_ATTRIBUTES = ["onChange", "readOnly"];
+const getInputTypeLiteral = (attributes) => {
+	const typeAttribute = findJsxAttribute(attributes, "type");
+	if (!typeAttribute || typeAttribute.value?.type !== "Literal") return null;
+	const value = typeAttribute.value.value;
+	return typeof value === "string" ? value : null;
+};
+const isUseStateUndefinedInitializer = (init) => {
+	if (!init || init.type !== "CallExpression") return false;
+	if (!isHookCall(init, "useState")) return false;
+	const args = init.arguments ?? [];
+	if (args.length === 0) return true;
+	const firstArgument = args[0];
+	return firstArgument?.type === "Identifier" && firstArgument.name === "undefined";
+};
+const collectUndefinedInitialStateNames = (componentBody) => {
+	const stateNames = /* @__PURE__ */ new Set();
+	if (componentBody?.type !== "BlockStatement") return stateNames;
+	for (const statement of componentBody.body ?? []) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations ?? []) {
+			if (declarator.id?.type !== "ArrayPattern") continue;
+			const valueElement = declarator.id.elements?.[0];
+			if (valueElement?.type !== "Identifier") continue;
+			if (!isUseStateUndefinedInitializer(declarator.init)) continue;
+			stateNames.add(valueElement.name);
+		}
+	}
+	return stateNames;
+};
+const hasJsxSpreadAttribute = (attributes) => attributes.some((attribute) => attribute.type === "JSXSpreadAttribute");
+const noUncontrolledInput = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody) return;
+		const undefinedInitialStateNames = componentBody.type === "BlockStatement" ? collectUndefinedInitialStateNames(componentBody) : /* @__PURE__ */ new Set();
+		walkAst(componentBody, (child) => {
+			if (child.type !== "JSXOpeningElement") return;
+			if (child.name?.type !== "JSXIdentifier") return;
+			const tagName = child.name.name;
+			if (!UNCONTROLLED_INPUT_TAGS.has(tagName)) return;
+			const attributes = child.attributes ?? [];
+			if (hasJsxSpreadAttribute(attributes)) return;
+			const valueAttribute = findJsxAttribute(attributes, "value");
+			if (!valueAttribute) return;
+			if (tagName === "input") {
+				const inputType = getInputTypeLiteral(attributes);
+				if (inputType !== null && VALUE_BYPASS_INPUT_TYPES.has(inputType)) return;
+			}
+			const hasAllowedPartner = VALUE_PARTNER_ATTRIBUTES.some((partnerAttributeName) => findJsxAttribute(attributes, partnerAttributeName));
+			if (valueAttribute.value?.type === "JSXExpressionContainer" && valueAttribute.value.expression?.type === "Identifier" && undefinedInitialStateNames.has(valueAttribute.value.expression.name)) {
+				const stateName = valueAttribute.value.expression.name;
+				const partnerHint = hasAllowedPartner ? "Initialize useState with an explicit value" : "Initialize useState with an explicit value AND add onChange (or readOnly)";
+				context.report({
+					node: child,
+					message: `<${tagName} value={${stateName}}> — "${stateName}" is initialized as undefined (uncontrolled), then becomes controlled on first set; React warns about this flip. ${partnerHint} (e.g. \`useState("")\`)`
+				});
+				return;
+			}
+			if (findJsxAttribute(attributes, "defaultValue")) {
+				context.report({
+					node: child,
+					message: `<${tagName}> sets both \`value\` and \`defaultValue\` — defaultValue is ignored on a controlled input; remove one`
+				});
+				return;
+			}
+			if (!hasAllowedPartner) context.report({
+				node: child,
+				message: `<${tagName} value={...}> with no \`onChange\` or \`readOnly\` — React renders this as a silently read-only field`
+			});
+		});
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+			checkComponent(node.body);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			checkComponent(node.init?.body);
+		}
+	};
+} };
 //#endregion
 //#region src/plugin/rules/js-performance.ts
 const jsCombineIterations = { create: (context) => ({ CallExpression(node) {
@@ -2565,23 +3165,23 @@ const rerenderMemoBeforeEarlyReturn = { create: (context) => {
 const NONDETERMINISTIC_RENDER_PATTERNS = [
 	{
 		display: "new Date()",
-		matches: (n) => n.type === "NewExpression" && n.callee?.type === "Identifier" && n.callee.name === "Date"
+		matches: (node) => node.type === "NewExpression" && node.callee?.type === "Identifier" && node.callee.name === "Date"
 	},
 	{
 		display: "Date.now()",
-		matches: (n) => n.type === "CallExpression" && n.callee?.type === "MemberExpression" && n.callee.object?.type === "Identifier" && n.callee.object.name === "Date" && n.callee.property?.type === "Identifier" && n.callee.property.name === "now"
+		matches: (node) => node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === "Date" && node.callee.property?.type === "Identifier" && node.callee.property.name === "now"
 	},
 	{
 		display: "Math.random()",
-		matches: (n) => n.type === "CallExpression" && n.callee?.type === "MemberExpression" && n.callee.object?.type === "Identifier" && n.callee.object.name === "Math" && n.callee.property?.type === "Identifier" && n.callee.property.name === "random"
+		matches: (node) => node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === "Math" && node.callee.property?.type === "Identifier" && node.callee.property.name === "random"
 	},
 	{
 		display: "performance.now()",
-		matches: (n) => n.type === "CallExpression" && n.callee?.type === "MemberExpression" && n.callee.object?.type === "Identifier" && n.callee.object.name === "performance" && n.callee.property?.type === "Identifier" && n.callee.property.name === "now"
+		matches: (node) => node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === "performance" && node.callee.property?.type === "Identifier" && node.callee.property.name === "now"
 	},
 	{
 		display: "crypto.randomUUID()",
-		matches: (n) => n.type === "CallExpression" && n.callee?.type === "MemberExpression" && n.callee.object?.type === "Identifier" && n.callee.object.name === "crypto" && n.callee.property?.type === "Identifier" && n.callee.property.name === "randomUUID"
+		matches: (node) => node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === "crypto" && node.callee.property?.type === "Identifier" && node.callee.property.name === "randomUUID"
 	}
 ];
 const findOpeningElementOfChild = (jsxNode) => {
@@ -2664,7 +3264,7 @@ const renderingHydrationMismatchTime = { create: (context) => ({ JSXExpressionCo
 		}
 	});
 } }) };
-const collectIdentifierNames = (node, into) => {
+const collectIdentifierNames$1 = (node, into) => {
 	if (!node) return;
 	walkAst(node, (child) => {
 		if (child.type === "Identifier") into.add(child.name);
@@ -2697,10 +3297,10 @@ const asyncDeferAwait = { create: (context) => {
 			const nextStatement = statements[statementIndex + 1];
 			if (!isEarlyReturnIfStatement(nextStatement)) continue;
 			const testIdentifiers = /* @__PURE__ */ new Set();
-			collectIdentifierNames(nextStatement.test, testIdentifiers);
+			collectIdentifierNames$1(nextStatement.test, testIdentifiers);
 			if ([...awaitedBindingNames].some((name) => testIdentifiers.has(name))) continue;
 			const consequentIdentifiers = /* @__PURE__ */ new Set();
-			collectIdentifierNames(nextStatement.consequent, consequentIdentifiers);
+			collectIdentifierNames$1(nextStatement.consequent, consequentIdentifiers);
 			if ([...awaitedBindingNames].some((name) => consequentIdentifiers.has(name))) continue;
 			context.report({
 				node: currentStatement,
@@ -2792,73 +3392,313 @@ const rerenderDerivedStateFromHook = { create: (context) => {
 	};
 } };
 //#endregion
-//#region src/plugin/rules/react-native.ts
-const resolveJsxElementName = (openingElement) => {
-	const elementName = openingElement?.name;
-	if (!elementName) return null;
-	if (elementName.type === "JSXIdentifier") return elementName.name;
-	if (elementName.type === "JSXMemberExpression") return elementName.property?.name ?? null;
+//#region src/plugin/rules/react-ui.ts
+const getOpeningElementTagName = (openingElement) => {
+	if (!openingElement) return null;
+	if (openingElement.name?.type === "JSXIdentifier") return openingElement.name.name;
+	if (openingElement.name?.type === "JSXMemberExpression") {
+		let cursor = openingElement.name;
+		while (cursor.type === "JSXMemberExpression") cursor = cursor.property;
+		if (cursor?.type === "JSXIdentifier") return cursor.name;
+	}
 	return null;
 };
-const truncateText = (text) => text.length > 30 ? `${text.slice(0, 30)}...` : text;
-const isRawTextContent = (child) => {
-	if (child.type === "JSXText") return Boolean(child.value?.trim());
-	if (child.type !== "JSXExpressionContainer" || !child.expression) return false;
-	const expression = child.expression;
-	return expression.type === "Literal" && (typeof expression.value === "string" || typeof expression.value === "number") || expression.type === "TemplateLiteral";
-};
-const getRawTextDescription = (child) => {
-	if (child.type === "JSXText") return `"${truncateText(child.value.trim())}"`;
-	if (child.type === "JSXExpressionContainer" && child.expression) {
-		const expression = child.expression;
-		if (expression.type === "Literal" && typeof expression.value === "string") return `"${truncateText(expression.value)}"`;
-		if (expression.type === "Literal" && typeof expression.value === "number") return `{${expression.value}}`;
-		if (expression.type === "TemplateLiteral") return "template literal";
+const getClassNameLiteral = (classAttribute) => {
+	if (!classAttribute.value) return null;
+	if (classAttribute.value.type === "Literal" && typeof classAttribute.value.value === "string") return classAttribute.value.value;
+	if (classAttribute.value.type === "JSXExpressionContainer") {
+		const expression = classAttribute.value.expression;
+		if (expression?.type === "Literal" && typeof expression.value === "string") return expression.value;
+		if (expression?.type === "TemplateLiteral" && expression.quasis?.length === 1) return expression.quasis[0].value?.raw ?? null;
 	}
-	return "text content";
+	return null;
 };
-const isTextHandlingComponent = (elementName) => {
-	if (REACT_NATIVE_TEXT_COMPONENTS.has(elementName)) return true;
-	return [...REACT_NATIVE_TEXT_COMPONENT_KEYWORDS].some((keyword) => elementName.includes(keyword));
+const tokenizeClassName = (classNameValue) => classNameValue.split(/\s+/).filter(Boolean);
+const getInlineStyleObjectExpression = (jsxAttribute) => {
+	if (jsxAttribute.name?.type !== "JSXIdentifier" || jsxAttribute.name.name !== "style") return null;
+	if (jsxAttribute.value?.type !== "JSXExpressionContainer") return null;
+	const expression = jsxAttribute.value.expression;
+	if (expression?.type !== "ObjectExpression") return null;
+	return expression;
 };
-const rnNoRawText = { create: (context) => {
-	let isDomComponentFile = false;
-	return {
-		Program(programNode) {
-			isDomComponentFile = hasDirective(programNode, "use dom");
-		},
-		JSXElement(node) {
-			if (isDomComponentFile) return;
-			const elementName = resolveJsxElementName(node.openingElement);
-			if (elementName && isTextHandlingComponent(elementName)) return;
-			for (const child of node.children ?? []) {
-				if (!isRawTextContent(child)) continue;
+const getStylePropertyKeyName = (objectProperty) => {
+	if (objectProperty.type !== "Property") return null;
+	if (objectProperty.key?.type === "Identifier") return objectProperty.key.name;
+	if (objectProperty.key?.type === "Literal" && typeof objectProperty.key.value === "string") return objectProperty.key.value;
+	return null;
+};
+const getStylePropertyNumericValue = (objectProperty) => {
+	const valueNode = objectProperty.value;
+	if (!valueNode) return null;
+	if (valueNode.type === "Literal" && typeof valueNode.value === "number") return valueNode.value;
+	if (valueNode.type === "Literal" && typeof valueNode.value === "string") {
+		const parsed = parseFloat(valueNode.value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+};
+const noBoldHeading = { create: (context) => ({ JSXOpeningElement(openingNode) {
+	const tagName = getOpeningElementTagName(openingNode);
+	if (!tagName || !HEADING_TAG_NAMES.has(tagName)) return;
+	const classAttribute = findJsxAttribute(openingNode.attributes ?? [], "className");
+	if (classAttribute) {
+		const classNameLiteral = getClassNameLiteral(classAttribute);
+		if (classNameLiteral) {
+			for (const tailwindWeightToken of HEAVY_HEADING_TAILWIND_WEIGHTS) if (new RegExp(`(?:^|\\s)${tailwindWeightToken}(?:$|\\s|:)`).test(classNameLiteral)) {
 				context.report({
-					node: child,
-					message: `Raw ${getRawTextDescription(child)} outside a <Text> component — this will crash on React Native`
+					node: classAttribute,
+					message: `${tailwindWeightToken} on <${tagName}> crushes counter shapes at display sizes — use font-semibold (600) or font-medium (500)`
 				});
+				return;
 			}
 		}
-	};
-} };
-const rnNoDeprecatedModules = { create: (context) => ({ ImportDeclaration(node) {
-	if (node.source?.value !== "react-native") return;
-	for (const specifier of node.specifiers ?? []) {
-		if (specifier.type !== "ImportSpecifier") continue;
-		const importedName = specifier.imported?.name;
-		if (!importedName) continue;
-		const replacement = DEPRECATED_RN_MODULE_REPLACEMENTS[importedName];
-		if (!replacement) continue;
-		context.report({
-			node: specifier,
-			message: `"${importedName}" was removed from react-native — use ${replacement} instead`
-		});
 	}
-} }) };
-const rnNoLegacyExpoPackages = { create: (context) => ({ ImportDeclaration(node) {
-	const source = node.source?.value;
-	if (typeof source !== "string") return;
-	for (const [packageName, replacement] of Object.entries(LEGACY_EXPO_PACKAGE_REPLACEMENTS)) if (source === packageName || source.startsWith(`${packageName}/`)) {
+	const styleAttribute = findJsxAttribute(openingNode.attributes ?? [], "style");
+	if (!styleAttribute) return;
+	const styleObject = getInlineStyleObjectExpression(styleAttribute);
+	if (!styleObject) return;
+	for (const objectProperty of styleObject.properties ?? []) {
+		if (getStylePropertyKeyName(objectProperty) !== "fontWeight") continue;
+		const numericWeight = getStylePropertyNumericValue(objectProperty);
+		if (numericWeight !== null && numericWeight >= 700) {
+			context.report({
+				node: objectProperty,
+				message: `fontWeight: ${numericWeight} on <${tagName}> crushes counter shapes at display sizes — use 500 or 600`
+			});
+			return;
+		}
+	}
+} }) };
+const collectAxisShorthandPairs = (classNameValue, horizontalPattern, verticalPattern) => {
+	const horizontalValues = /* @__PURE__ */ new Set();
+	for (const horizontalMatch of classNameValue.matchAll(horizontalPattern)) horizontalValues.add(`${horizontalMatch[1]}${horizontalMatch[2]}`);
+	const matchedPairs = [];
+	for (const verticalMatch of classNameValue.matchAll(verticalPattern)) {
+		const verticalValue = `${verticalMatch[1]}${verticalMatch[2]}`;
+		if (horizontalValues.has(verticalValue)) matchedPairs.push({ value: verticalValue });
+	}
+	return matchedPairs;
+};
+const hasResponsivePrefix = (classNameValue, axisPrefix) => new RegExp(`(?:^|\\s)\\w+:${axisPrefix}-`).test(classNameValue);
+const noRedundantPaddingAxes = { create: (context) => ({ JSXAttribute(jsxAttribute) {
+	if (jsxAttribute.name?.type !== "JSXIdentifier" || jsxAttribute.name.name !== "className") return;
+	const classNameLiteral = getClassNameLiteral(jsxAttribute);
+	if (!classNameLiteral) return;
+	if (hasResponsivePrefix(classNameLiteral, "px") || hasResponsivePrefix(classNameLiteral, "py")) return;
+	const matchedPairs = collectAxisShorthandPairs(classNameLiteral, PADDING_HORIZONTAL_AXIS_PATTERN, PADDING_VERTICAL_AXIS_PATTERN);
+	if (matchedPairs.length === 0) return;
+	for (const matchedPair of matchedPairs) context.report({
+		node: jsxAttribute,
+		message: `px-${matchedPair.value} py-${matchedPair.value} → use the shorthand p-${matchedPair.value}`
+	});
+} }) };
+const noRedundantSizeAxes = { create: (context) => ({ JSXAttribute(jsxAttribute) {
+	if (jsxAttribute.name?.type !== "JSXIdentifier" || jsxAttribute.name.name !== "className") return;
+	const classNameLiteral = getClassNameLiteral(jsxAttribute);
+	if (!classNameLiteral) return;
+	if (hasResponsivePrefix(classNameLiteral, "w") || hasResponsivePrefix(classNameLiteral, "h")) return;
+	const matchedPairs = collectAxisShorthandPairs(classNameLiteral, SIZE_WIDTH_AXIS_PATTERN, SIZE_HEIGHT_AXIS_PATTERN);
+	if (matchedPairs.length === 0) return;
+	for (const matchedPair of matchedPairs) context.report({
+		node: jsxAttribute,
+		message: `w-${matchedPair.value} h-${matchedPair.value} → use the shorthand size-${matchedPair.value} (Tailwind v3.4+)`
+	});
+} }) };
+const noSpaceOnFlexChildren = { create: (context) => ({ JSXAttribute(jsxAttribute) {
+	if (jsxAttribute.name?.type !== "JSXIdentifier" || jsxAttribute.name.name !== "className") return;
+	const classNameLiteral = getClassNameLiteral(jsxAttribute);
+	if (!classNameLiteral) return;
+	const tokens = tokenizeClassName(classNameLiteral);
+	let hasFlexOrGridLayout = false;
+	for (const token of tokens) {
+		const lastSegment = token.includes(":") ? token.slice(token.lastIndexOf(":") + 1) : token;
+		if (FLEX_OR_GRID_DISPLAY_TOKENS.has(lastSegment)) {
+			hasFlexOrGridLayout = true;
+			break;
+		}
+	}
+	if (!hasFlexOrGridLayout) return;
+	const spaceMatch = classNameLiteral.match(SPACE_AXIS_PATTERN);
+	if (!spaceMatch) return;
+	const spaceAxis = spaceMatch[1];
+	const spaceValue = spaceMatch[2];
+	context.report({
+		node: jsxAttribute,
+		message: `space-${spaceAxis}-${spaceValue} on a flex/grid parent — use gap-${spaceAxis}-${spaceValue} instead. Per-sibling margins phantom-gap on conditional render and don't mirror in RTL`
+	});
+} }) };
+const isInsideExcludedAncestor = (jsxTextNode) => {
+	let cursor = jsxTextNode.parent;
+	while (cursor) {
+		if (cursor.type === "JSXElement") {
+			const tagName = getOpeningElementTagName(cursor.openingElement);
+			if (tagName && ELLIPSIS_EXCLUDED_TAG_NAMES.has(tagName.toLowerCase())) return true;
+			const translateAttribute = findJsxAttribute(cursor.openingElement?.attributes ?? [], "translate");
+			if (translateAttribute?.value?.type === "Literal" && translateAttribute.value.value === "no") return true;
+		}
+		cursor = cursor.parent;
+	}
+	return false;
+};
+const noEmDashInJsxText = { create: (context) => ({ JSXText(jsxTextNode) {
+	if (!(typeof jsxTextNode.value === "string" ? jsxTextNode.value : "").includes("—")) return;
+	if (isInsideExcludedAncestor(jsxTextNode)) return;
+	context.report({
+		node: jsxTextNode,
+		message: "Em dash (—) in JSX text reads as model output — replace with comma, colon, semicolon, or parentheses"
+	});
+} }) };
+const noThreePeriodEllipsis = { create: (context) => ({ JSXText(jsxTextNode) {
+	const textValue = typeof jsxTextNode.value === "string" ? jsxTextNode.value : "";
+	if (!TRAILING_THREE_PERIOD_ELLIPSIS_PATTERN.test(textValue)) return;
+	if (isInsideExcludedAncestor(jsxTextNode)) return;
+	context.report({
+		node: jsxTextNode,
+		message: "Three-period ellipsis (\"...\") in JSX text — use the actual ellipsis character \"…\" (or `&hellip;`)"
+	});
+} }) };
+const buildDefaultPaletteRegex = () => {
+	const utilityPrefixGroup = TAILWIND_PALETTE_UTILITY_PREFIXES.join("|");
+	const paletteNameGroup = TAILWIND_DEFAULT_PALETTE_NAMES.join("|");
+	const paletteStopGroup = TAILWIND_DEFAULT_PALETTE_STOPS.join("|");
+	return new RegExp(`(?:^|\\s|:)(${utilityPrefixGroup})-(${paletteNameGroup})-(${paletteStopGroup})(?=$|[\\s:/])`, "g");
+};
+const DEFAULT_PALETTE_REGEX = buildDefaultPaletteRegex();
+const noDefaultTailwindPalette = { create: (context) => ({ JSXAttribute(jsxAttribute) {
+	if (jsxAttribute.name?.type !== "JSXIdentifier" || jsxAttribute.name.name !== "className") return;
+	const classNameLiteral = getClassNameLiteral(jsxAttribute);
+	if (!classNameLiteral) return;
+	const reportedTokens = /* @__PURE__ */ new Set();
+	for (const paletteMatch of classNameLiteral.matchAll(DEFAULT_PALETTE_REGEX)) {
+		const matchedToken = `${paletteMatch[1]}-${paletteMatch[2]}-${paletteMatch[3]}`;
+		if (reportedTokens.has(matchedToken)) continue;
+		reportedTokens.add(matchedToken);
+		const replacementSuggestion = paletteMatch[2] === "indigo" ? "use your project's brand color or zinc/neutral/stone" : "use zinc (true neutral), neutral (warmer), or stone (warmest)";
+		context.report({
+			node: jsxAttribute,
+			message: `${matchedToken} reads as the Tailwind template default — ${replacementSuggestion}`
+		});
+	}
+} }) };
+const isButtonLikeTagName = (tagName) => {
+	if (tagName === "button") return true;
+	if (tagName === "Button") return true;
+	return false;
+};
+const collectJsxLabelText = (jsxElementNode) => {
+	const childList = jsxElementNode.children ?? [];
+	if (childList.length === 0) return null;
+	const collectedFragments = [];
+	for (const childNode of childList) {
+		if (childNode.type === "JSXText") {
+			collectedFragments.push(typeof childNode.value === "string" ? childNode.value : "");
+			continue;
+		}
+		if (childNode.type === "JSXExpressionContainer") {
+			const expression = childNode.expression;
+			if (expression?.type === "Literal" && typeof expression.value === "string") {
+				collectedFragments.push(expression.value);
+				continue;
+			}
+			if (expression?.type === "TemplateLiteral" && expression.quasis?.length === 1) {
+				const rawTemplate = expression.quasis[0].value?.raw;
+				if (typeof rawTemplate === "string" && expression.expressions.length === 0) {
+					collectedFragments.push(rawTemplate);
+					continue;
+				}
+			}
+			return null;
+		}
+		if (childNode.type === "JSXFragment") {
+			const fragmentLabel = collectJsxLabelText(childNode);
+			if (fragmentLabel === null) return null;
+			collectedFragments.push(fragmentLabel);
+			continue;
+		}
+		if (childNode.type === "JSXElement") return null;
+	}
+	return collectedFragments.join("").trim();
+};
+const noVagueButtonLabel = { create: (context) => ({ JSXElement(jsxElementNode) {
+	const tagName = getOpeningElementTagName(jsxElementNode.openingElement);
+	if (!tagName || !isButtonLikeTagName(tagName)) return;
+	const labelText = collectJsxLabelText(jsxElementNode);
+	if (!labelText) return;
+	const normalizedLabel = labelText.toLowerCase().replace(/[.!?…]+$/, "").trim();
+	if (!VAGUE_BUTTON_LABELS.has(normalizedLabel)) return;
+	context.report({
+		node: jsxElementNode.openingElement ?? jsxElementNode,
+		message: `Vague button label "${labelText}" — name the action ("Save changes", "Send invite", "Delete account") so screen readers and hesitant users know what happens`
+	});
+} }) };
+//#endregion
+//#region src/plugin/rules/react-native.ts
+const resolveJsxElementName = (openingElement) => {
+	const elementName = openingElement?.name;
+	if (!elementName) return null;
+	if (elementName.type === "JSXIdentifier") return elementName.name;
+	if (elementName.type === "JSXMemberExpression") return elementName.property?.name ?? null;
+	return null;
+};
+const truncateText = (text) => text.length > 30 ? `${text.slice(0, 30)}...` : text;
+const isRawTextContent = (child) => {
+	if (child.type === "JSXText") return Boolean(child.value?.trim());
+	if (child.type !== "JSXExpressionContainer" || !child.expression) return false;
+	const expression = child.expression;
+	return expression.type === "Literal" && (typeof expression.value === "string" || typeof expression.value === "number") || expression.type === "TemplateLiteral";
+};
+const getRawTextDescription = (child) => {
+	if (child.type === "JSXText") return `"${truncateText(child.value.trim())}"`;
+	if (child.type === "JSXExpressionContainer" && child.expression) {
+		const expression = child.expression;
+		if (expression.type === "Literal" && typeof expression.value === "string") return `"${truncateText(expression.value)}"`;
+		if (expression.type === "Literal" && typeof expression.value === "number") return `{${expression.value}}`;
+		if (expression.type === "TemplateLiteral") return "template literal";
+	}
+	return "text content";
+};
+const isTextHandlingComponent = (elementName) => {
+	if (REACT_NATIVE_TEXT_COMPONENTS.has(elementName)) return true;
+	return [...REACT_NATIVE_TEXT_COMPONENT_KEYWORDS].some((keyword) => elementName.includes(keyword));
+};
+const rnNoRawText = { create: (context) => {
+	let isDomComponentFile = false;
+	return {
+		Program(programNode) {
+			isDomComponentFile = hasDirective(programNode, "use dom");
+		},
+		JSXElement(node) {
+			if (isDomComponentFile) return;
+			const elementName = resolveJsxElementName(node.openingElement);
+			if (elementName && isTextHandlingComponent(elementName)) return;
+			for (const child of node.children ?? []) {
+				if (!isRawTextContent(child)) continue;
+				context.report({
+					node: child,
+					message: `Raw ${getRawTextDescription(child)} outside a <Text> component — this will crash on React Native`
+				});
+			}
+		}
+	};
+} };
+const rnNoDeprecatedModules = { create: (context) => ({ ImportDeclaration(node) {
+	if (node.source?.value !== "react-native") return;
+	for (const specifier of node.specifiers ?? []) {
+		if (specifier.type !== "ImportSpecifier") continue;
+		const importedName = specifier.imported?.name;
+		if (!importedName) continue;
+		const replacement = DEPRECATED_RN_MODULE_REPLACEMENTS.get(importedName);
+		if (!replacement) continue;
+		context.report({
+			node: specifier,
+			message: `"${importedName}" was removed from react-native — use ${replacement} instead`
+		});
+	}
+} }) };
+const rnNoLegacyExpoPackages = { create: (context) => ({ ImportDeclaration(node) {
+	const source = node.source?.value;
+	if (typeof source !== "string") return;
+	for (const [packageName, replacement] of LEGACY_EXPO_PACKAGE_REPLACEMENTS) if (source === packageName || source.startsWith(`${packageName}/`)) {
 		context.report({
 			node,
 			message: `"${packageName}" is deprecated — use ${replacement}`
@@ -3765,24 +4605,6 @@ const DERIVING_ARRAY_METHODS = new Set([
 	"map",
 	"slice"
 ]);
-const getRootIdentifierName = (node) => {
-	let cursor = node;
-	while (cursor && (cursor.type === "MemberExpression" || cursor.type === "CallExpression")) if (cursor.type === "MemberExpression") cursor = cursor.object;
-	else if (cursor.type === "CallExpression") {
-		const callee = cursor.callee;
-		if (callee?.type === "MemberExpression") cursor = callee.object;
-		else return null;
-	}
-	return cursor?.type === "Identifier" ? cursor.name : null;
-};
-const expressionDerivesFromIdentifier = (node, identifierName) => {
-	if (node.type !== "CallExpression") return false;
-	const callee = node.callee;
-	if (callee?.type !== "MemberExpression") return false;
-	if (callee.property?.type !== "Identifier") return false;
-	if (!DERIVING_ARRAY_METHODS.has(callee.property.name)) return false;
-	return getRootIdentifierName(callee) === identifierName;
-};
 const serverDedupProps = { create: (context) => ({ JSXOpeningElement(node) {
 	const identifierAttributes = /* @__PURE__ */ new Map();
 	const derivedAttributes = [];
@@ -3794,14 +4616,15 @@ const serverDedupProps = { create: (context) => ({ JSXOpeningElement(node) {
 		if (!expression) continue;
 		if (expression.type === "Identifier") identifierAttributes.set(expression.name, attr.name.name);
 		else if (expression.type === "CallExpression") {
-			const root = getRootIdentifierName(expression);
-			if (root && DERIVING_ARRAY_METHODS.has(getDerivingMethodName(expression) ?? "")) {
-				if (expressionDerivesFromIdentifier(expression, root)) derivedAttributes.push({
-					propName: attr.name.name,
-					rootName: root,
-					node: attr
-				});
-			}
+			const derivingMethod = getDerivingMethodName(expression);
+			if (!derivingMethod || !DERIVING_ARRAY_METHODS.has(derivingMethod)) continue;
+			const root = getRootIdentifierName(expression, { followCallChains: true });
+			if (!root) continue;
+			derivedAttributes.push({
+				propName: attr.name.name,
+				rootName: root,
+				node: attr
+			});
 		}
 	}
 	for (const derived of derivedAttributes) {
@@ -4311,6 +5134,34 @@ const tanstackStartLoaderParallelFetch = { create: (context) => ({ CallExpressio
 } }) };
 //#endregion
 //#region src/plugin/rules/state-and-effects.ts
+const collectValueIdentifierNames = (node, into) => {
+	if (!node || typeof node !== "object") return;
+	if (node.type === "CallExpression") {
+		if (node.callee?.type === "MemberExpression") {
+			const rootName = getRootIdentifierName(node.callee);
+			if (!rootName || !BUILTIN_GLOBAL_NAMESPACE_NAMES.has(rootName)) collectValueIdentifierNames(node.callee.object, into);
+		}
+		for (const argument of node.arguments ?? []) collectValueIdentifierNames(argument, into);
+		return;
+	}
+	if (node.type === "MemberExpression") {
+		const rootName = getRootIdentifierName(node);
+		if (!rootName || !BUILTIN_GLOBAL_NAMESPACE_NAMES.has(rootName)) collectValueIdentifierNames(node.object, into);
+		if (node.computed) collectValueIdentifierNames(node.property, into);
+		return;
+	}
+	if (node.type === "Identifier") {
+		into.push(node.name);
+		return;
+	}
+	for (const key of Object.keys(node)) {
+		if (key === "parent" || key === "type") continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const item of child) if (item && typeof item === "object" && item.type) collectValueIdentifierNames(item, into);
+		} else if (child && typeof child === "object" && child.type) collectValueIdentifierNames(child, into);
+	}
+};
 const noDerivedStateEffect = { create: (context) => ({ CallExpression(node) {
 	if (!isHookCall(node, EFFECT_HOOK_NAMES) || (node.arguments?.length ?? 0) < 2) return;
 	const callback = getEffectCallback(node);
@@ -4327,23 +5178,41 @@ const noDerivedStateEffect = { create: (context) => ({ CallExpression(node) {
 	})) return;
 	let allArgumentsDeriveFromDeps = true;
 	let hasAnyDependencyReference = false;
+	let hasExpensiveDerivation = false;
 	for (const statement of statements) {
 		const setStateArguments = statement.expression.arguments;
 		if (!setStateArguments?.length) continue;
-		const referencedIdentifiers = [];
+		const valueIdentifierNames = [];
+		collectValueIdentifierNames(setStateArguments[0], valueIdentifierNames);
 		walkAst(setStateArguments[0], (child) => {
-			if (child.type === "Identifier") referencedIdentifiers.push(child.name);
+			if (child.type !== "CallExpression") return;
+			if (child.callee?.type === "MemberExpression") {
+				const rootName = getRootIdentifierName(child.callee);
+				if (rootName && BUILTIN_GLOBAL_NAMESPACE_NAMES.has(rootName)) return;
+				hasExpensiveDerivation = true;
+				return;
+			}
+			if (child.callee?.type === "Identifier") {
+				const calleeName = child.callee.name;
+				if (!TRIVIAL_DERIVATION_CALLEE_NAMES.has(calleeName) && !isSetterIdentifier(calleeName)) hasExpensiveDerivation = true;
+			}
 		});
-		const nonSetterIdentifiers = referencedIdentifiers.filter((name) => !isSetterIdentifier(name));
+		const nonSetterIdentifiers = valueIdentifierNames.filter((name) => !isSetterIdentifier(name));
 		if (nonSetterIdentifiers.some((name) => dependencyNames.has(name))) hasAnyDependencyReference = true;
 		if (nonSetterIdentifiers.some((name) => !dependencyNames.has(name))) {
 			allArgumentsDeriveFromDeps = false;
 			break;
 		}
 	}
-	if (allArgumentsDeriveFromDeps) context.report({
+	if (!allArgumentsDeriveFromDeps) return;
+	if (hasExpensiveDerivation) hasAnyDependencyReference = true;
+	let message;
+	if (!hasAnyDependencyReference) message = "State reset in useEffect — use a key prop to reset component state when props change";
+	else if (hasExpensiveDerivation) message = "Derived state in useEffect — wrap the calculation in useMemo([deps]) (or compute it directly during render if it isn't expensive)";
+	else message = "Derived state in useEffect — compute during render instead";
+	context.report({
 		node,
-		message: hasAnyDependencyReference ? "Derived state in useEffect — compute during render instead" : "State reset in useEffect — use a key prop to reset component state when props change"
+		message
 	});
 } }) };
 const noFetchInEffect = { create: (context) => ({ CallExpression(node) {
@@ -4375,47 +5244,22 @@ const noEffectEventHandler = { create: (context) => ({ CallExpression(node) {
 	const statements = getCallbackStatements(callback);
 	if (statements.length !== 1) return;
 	const soleStatement = statements[0];
-	if (soleStatement.type === "IfStatement" && soleStatement.test?.type === "Identifier" && dependencyNames.has(soleStatement.test.name)) context.report({
+	if (soleStatement.type !== "IfStatement") return;
+	const rootIdentifierName = getRootIdentifierName(soleStatement.test);
+	if (!rootIdentifierName || !dependencyNames.has(rootIdentifierName)) return;
+	context.report({
 		node,
 		message: "useEffect simulating an event handler — move logic to an actual event handler instead"
 	});
 } }) };
 const noDerivedUseState = { create: (context) => {
-	const componentPropStack = [];
-	const isPropName = (name) => {
-		for (let stackIndex = componentPropStack.length - 1; stackIndex >= 0; stackIndex--) if (componentPropStack[stackIndex].has(name)) return true;
-		return false;
-	};
-	const isFunctionLikeVariableDeclarator = (node) => {
-		if (node.type !== "VariableDeclarator") return false;
-		return node.init?.type === "ArrowFunctionExpression" || node.init?.type === "FunctionExpression";
-	};
+	const propStackTracker = createComponentPropStackTracker();
 	return {
-		FunctionDeclaration(node) {
-			if (!node.id?.name || !isUppercaseName(node.id.name)) {
-				componentPropStack.push(/* @__PURE__ */ new Set());
-				return;
-			}
-			componentPropStack.push(extractDestructuredPropNames(node.params ?? []));
-		},
-		"FunctionDeclaration:exit"() {
-			componentPropStack.pop();
-		},
-		VariableDeclarator(node) {
-			if (isComponentAssignment(node)) {
-				componentPropStack.push(extractDestructuredPropNames(node.init?.params ?? []));
-				return;
-			}
-			if (isFunctionLikeVariableDeclarator(node)) componentPropStack.push(/* @__PURE__ */ new Set());
-		},
-		"VariableDeclarator:exit"(node) {
-			if (isComponentAssignment(node) || isFunctionLikeVariableDeclarator(node)) componentPropStack.pop();
-		},
+		...propStackTracker.visitors,
 		CallExpression(node) {
 			if (!isHookCall(node, "useState") || !node.arguments?.length) return;
-			if (componentPropStack.length === 0) return;
 			const initializer = node.arguments[0];
-			if (initializer.type === "Identifier" && isPropName(initializer.name)) {
+			if (initializer.type === "Identifier" && propStackTracker.isPropName(initializer.name)) {
 				context.report({
 					node,
 					message: `useState initialized from prop "${initializer.name}" — if this value should stay in sync with the prop, derive it during render instead`
@@ -4423,11 +5267,8 @@ const noDerivedUseState = { create: (context) => {
 				return;
 			}
 			if (initializer.type === "MemberExpression" && !initializer.computed) {
-				let rootIdentifierName = null;
-				let cursor = initializer;
-				while (cursor?.type === "MemberExpression") cursor = cursor.object;
-				if (cursor?.type === "Identifier") rootIdentifierName = cursor.name;
-				if (rootIdentifierName && isPropName(rootIdentifierName)) context.report({
+				const rootIdentifierName = getRootIdentifierName(initializer);
+				if (rootIdentifierName && propStackTracker.isPropName(rootIdentifierName)) context.report({
 					node,
 					message: `useState initialized from prop "${rootIdentifierName}" — if this value should stay in sync with the prop, derive it during render instead`
 				});
@@ -4505,6 +5346,25 @@ const rerenderFunctionalSetstate = { create: (context) => ({ CallExpression(node
 			node,
 			message: `${calleeName}(${display}) — use functional update to avoid stale closures (and reading the post-increment value bug)`
 		});
+		return;
+	}
+	if (expectedStateName && argument.type === "ArrayExpression") {
+		if ((argument.elements ?? []).some((element) => element?.type === "SpreadElement" && element.argument?.type === "Identifier" && element.argument.name === expectedStateName)) {
+			context.report({
+				node,
+				message: `${calleeName}([...${expectedStateName}, ...]) — use functional update \`${calleeName}(prev => [...prev, ...])\` to avoid stale closures`
+			});
+			return;
+		}
+	}
+	if (expectedStateName && argument.type === "ObjectExpression") {
+		if ((argument.properties ?? []).some((property) => property?.type === "SpreadElement" && property.argument?.type === "Identifier" && property.argument.name === expectedStateName)) {
+			context.report({
+				node,
+				message: `${calleeName}({ ...${expectedStateName}, ... }) — use functional update \`${calleeName}(prev => ({ ...prev, ... }))\` to avoid stale closures`
+			});
+			return;
+		}
 	}
 } }) };
 const rerenderDependencies = { create: (context) => ({ CallExpression(node) {
@@ -4521,108 +5381,57 @@ const rerenderDependencies = { create: (context) => ({ CallExpression(node) {
 			node: element,
 			message: "Array literal in useEffect deps — creates new reference every render, causing infinite re-runs"
 		});
+		if (element.type === "ArrowFunctionExpression" || element.type === "FunctionExpression") context.report({
+			node: element,
+			message: "Inline function in useEffect deps — creates a new function reference every render, causing infinite re-runs. Hoist it out of the component or wrap it with useCallback"
+		});
 	}
 } }) };
 const noPropCallbackInEffect = { create: (context) => {
-	const componentPropParamStack = [];
-	const enterComponentParams = (params) => {
-		const propNames = extractDestructuredPropNames(params ?? []);
-		componentPropParamStack.push(propNames);
-	};
-	const isPropName = (name) => {
-		for (let stackIndex = componentPropParamStack.length - 1; stackIndex >= 0; stackIndex--) if (componentPropParamStack[stackIndex].has(name)) return true;
-		return false;
-	};
-	const isFunctionLikeVariableDeclarator = (node) => {
-		if (node.type !== "VariableDeclarator") return false;
-		return node.init?.type === "ArrowFunctionExpression" || node.init?.type === "FunctionExpression";
-	};
+	const propStackTracker = createComponentPropStackTracker();
 	return {
-		FunctionDeclaration(node) {
-			if (!node.id?.name || !isUppercaseName(node.id.name)) {
-				componentPropParamStack.push(/* @__PURE__ */ new Set());
-				return;
-			}
-			enterComponentParams(node.params);
-		},
-		"FunctionDeclaration:exit"() {
-			componentPropParamStack.pop();
-		},
-		VariableDeclarator(node) {
-			if (isComponentAssignment(node)) {
-				enterComponentParams(node.init?.params);
-				return;
-			}
-			if (isFunctionLikeVariableDeclarator(node)) componentPropParamStack.push(/* @__PURE__ */ new Set());
-		},
-		"VariableDeclarator:exit"(node) {
-			if (isComponentAssignment(node) || isFunctionLikeVariableDeclarator(node)) componentPropParamStack.pop();
-		},
+		...propStackTracker.visitors,
 		CallExpression(node) {
 			if (!isHookCall(node, EFFECT_HOOK_NAMES) || (node.arguments?.length ?? 0) < 2) return;
-			if (componentPropParamStack.length === 0) return;
 			const callback = getEffectCallback(node);
 			if (!callback) return;
 			const depsNode = node.arguments[1];
 			if (depsNode.type !== "ArrayExpression" || !depsNode.elements?.length) return;
-			const bodyStatements = getCallbackStatements(callback);
-			for (const stmt of bodyStatements) {
-				let invokedPropName = null;
-				if (stmt.type === "ExpressionStatement" && stmt.expression?.type === "CallExpression" && stmt.expression.callee?.type === "Identifier" && isPropName(stmt.expression.callee.name)) invokedPropName = stmt.expression.callee.name;
-				if (!invokedPropName) continue;
-				if (!depsNode.elements.some((element) => element?.type === "Identifier" && !isPropName(element.name))) continue;
+			if (!depsNode.elements.some((element) => element?.type === "Identifier" && !propStackTracker.isPropName(element.name))) return;
+			const reportedNodes = /* @__PURE__ */ new Set();
+			walkInsideStatementBlocks(callback.body, (child) => {
+				if (child.type !== "CallExpression") return;
+				if (child.callee?.type !== "Identifier") return;
+				const calleeName = child.callee.name;
+				if (!propStackTracker.isPropName(calleeName)) return;
+				if (reportedNodes.has(child)) return;
+				reportedNodes.add(child);
 				context.report({
-					node: stmt,
-					message: `useEffect calls prop callback "${invokedPropName}" with local state in deps — this is the "lift state via callback" anti-pattern; lift state into a shared Provider so both sides read the same source`
+					node: child,
+					message: `useEffect calls prop callback "${calleeName}" with local state in deps — this is the "lift state via callback" anti-pattern; lift state into a shared Provider so both sides read the same source`
 				});
-			}
+			});
 		}
 	};
 } };
 const noEffectEventInDeps = { create: (context) => {
-	const componentBindingStack = [];
-	const isEffectEventBinding = (name) => {
-		for (let stackIndex = componentBindingStack.length - 1; stackIndex >= 0; stackIndex--) if (componentBindingStack[stackIndex].has(name)) return true;
-		return false;
-	};
-	const enterComponent = () => {
-		componentBindingStack.push(/* @__PURE__ */ new Set());
-	};
-	const exitComponent = () => {
-		componentBindingStack.pop();
-	};
+	const componentBindings = createComponentBindingStackTracker({ onVariableDeclarator: (declaratorNode) => {
+		if (declaratorNode.id?.type !== "Identifier") return;
+		const initializer = declaratorNode.init;
+		if (!initializer || initializer.type !== "CallExpression") return;
+		if (!isHookCall(initializer, "useEffectEvent")) return;
+		componentBindings.addBindingToCurrentFrame(declaratorNode.id.name);
+	} });
 	return {
-		FunctionDeclaration(node) {
-			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
-			enterComponent();
-		},
-		"FunctionDeclaration:exit"(node) {
-			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
-			exitComponent();
-		},
-		VariableDeclarator(node) {
-			if (isComponentAssignment(node)) {
-				enterComponent();
-				return;
-			}
-			if (componentBindingStack.length === 0) return;
-			if (node.id?.type !== "Identifier") return;
-			const init = node.init;
-			if (!init || init.type !== "CallExpression") return;
-			if (!isHookCall(init, "useEffectEvent")) return;
-			componentBindingStack[componentBindingStack.length - 1].add(node.id.name);
-		},
-		"VariableDeclarator:exit"(node) {
-			if (isComponentAssignment(node)) exitComponent();
-		},
+		...componentBindings.visitors,
 		CallExpression(node) {
 			if (!isHookCall(node, HOOKS_WITH_DEPS) || node.arguments.length < 2) return;
-			if (componentBindingStack.length === 0) return;
+			if (!componentBindings.isInsideComponent()) return;
 			const depsNode = node.arguments[1];
 			if (depsNode.type !== "ArrayExpression") return;
 			for (const element of depsNode.elements ?? []) {
 				if (element?.type !== "Identifier") continue;
-				if (isEffectEventBinding(element.name)) context.report({
+				if (componentBindings.isBoundName(element.name)) context.report({
 					node: element,
 					message: `"${element.name}" is from useEffectEvent and must not be in the deps array — its identity is intentionally unstable; call it inside the effect without listing it`
 				});
@@ -4667,25 +5476,55 @@ const collectReturnExpressions = (componentBody) => {
 	}
 	return returns;
 };
-const walkInsideStatementBlocks = (node, visitor) => {
-	if (!node || typeof node !== "object") return;
-	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return;
-	visitor(node);
-	for (const key of Object.keys(node)) {
-		if (key === "parent") continue;
-		const child = node[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (item && typeof item === "object" && item.type) walkInsideStatementBlocks(item, visitor);
-		} else if (child && typeof child === "object" && child.type) walkInsideStatementBlocks(child, visitor);
+const collectIdentifierNames = (expression) => {
+	const names = /* @__PURE__ */ new Set();
+	walkAst(expression, (child) => {
+		if (child.type === "Identifier") names.add(child.name);
+	});
+	return names;
+};
+const buildLocalDependencyGraph = (componentBody) => {
+	const graph = /* @__PURE__ */ new Map();
+	if (componentBody?.type !== "BlockStatement") return graph;
+	const declaredNames = /* @__PURE__ */ new Set();
+	for (const statement of componentBody.body ?? []) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations ?? []) {
+			if (!declarator.init) continue;
+			const dependencyNames = collectIdentifierNames(declarator.init);
+			declaredNames.clear();
+			collectPatternNames(declarator.id, declaredNames);
+			for (const declaredName of declaredNames) {
+				const existing = graph.get(declaredName);
+				if (existing === void 0) graph.set(declaredName, new Set(dependencyNames));
+				else for (const dependencyName of dependencyNames) existing.add(dependencyName);
+			}
+		}
 	}
+	return graph;
 };
-const expressionReadsName = (expression, name) => {
-	let didRead = false;
-	walkAst(expression, (child) => {
-		if (didRead) return;
-		if (child.type === "Identifier" && child.name === name) didRead = true;
+const collectRenderReachableNames = (returnExpressions) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const expression of returnExpressions) walkAst(expression, (child) => {
+		if (child.type === "Identifier") names.add(child.name);
 	});
-	return didRead;
+	return names;
+};
+const expandTransitiveDependencies = (seedNames, dependencyGraph) => {
+	const reachable = new Set(seedNames);
+	const queue = Array.from(seedNames);
+	while (queue.length > 0) {
+		const currentName = queue.pop();
+		if (currentName === void 0) continue;
+		const dependencyNames = dependencyGraph.get(currentName);
+		if (!dependencyNames) continue;
+		for (const dependencyName of dependencyNames) {
+			if (reachable.has(dependencyName)) continue;
+			reachable.add(dependencyName);
+			queue.push(dependencyName);
+		}
+	}
+	return reachable;
 };
 const rerenderStateOnlyInHandlers = { create: (context) => {
 	const checkComponent = (componentBody) => {
@@ -4694,8 +5533,10 @@ const rerenderStateOnlyInHandlers = { create: (context) => {
 		if (bindings.length === 0) return;
 		const returnExpressions = collectReturnExpressions(componentBody);
 		if (returnExpressions.length === 0) return;
+		const dependencyGraph = buildLocalDependencyGraph(componentBody);
+		const renderReachableNames = expandTransitiveDependencies(collectRenderReachableNames(returnExpressions), dependencyGraph);
 		for (const binding of bindings) {
-			if (returnExpressions.some((expression) => expressionReadsName(expression, binding.valueName))) continue;
+			if (renderReachableNames.has(binding.valueName)) continue;
 			let setterCalled = false;
 			walkAst(componentBody, (child) => {
 				if (setterCalled) return;
@@ -4719,12 +5560,6 @@ const rerenderStateOnlyInHandlers = { create: (context) => {
 		}
 	};
 } };
-const SUBSCRIPTION_METHOD_NAMES = new Set([
-	"addEventListener",
-	"subscribe",
-	"on",
-	"addListener"
-]);
 const advancedEventHandlerRefs = { create: (context) => ({ CallExpression(node) {
 	if (!isHookCall(node, EFFECT_HOOK_NAMES)) return;
 	if ((node.arguments?.length ?? 0) < 2) return;
@@ -4812,55 +5647,897 @@ const isInsideEventHandler = (node, handlerBindingNames) => {
 	}
 	return false;
 };
-//#endregion
-//#region src/plugin/index.ts
-const plugin = {
-	meta: { name: "react-doctor" },
+const rerenderDeferReadsHook = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const bindings = findHookCallBindings(componentBody);
+		if (bindings.length === 0) return;
+		const handlerBindingNames = collectHandlerBindingNames(componentBody);
+		for (const binding of bindings) {
+			const referenceLocations = [];
+			walkAst(componentBody, (child) => {
+				if (child === binding.declarator.id) return;
+				if (child.type === "Identifier" && child.name === binding.valueName) referenceLocations.push(child);
+			});
+			if (referenceLocations.length === 0) continue;
+			if (!referenceLocations.every((ref) => isInsideEventHandler(ref, handlerBindingNames))) continue;
+			context.report({
+				node: binding.declarator,
+				message: `${binding.hookName}() return is only read inside event handlers — defer the read into the handler (e.g. \`new URL(window.location.href).searchParams\`) so the component doesn't re-render on every URL change`
+			});
+		}
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+			checkComponent(node.body);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			checkComponent(node.init?.body);
+		}
+	};
+} };
+const collectFunctionLocalBindings = (functionNode) => {
+	const localBindings = /* @__PURE__ */ new Set();
+	for (const param of functionNode.params ?? []) collectPatternNames(param, localBindings);
+	if (functionNode.body?.type === "BlockStatement") for (const statement of functionNode.body.body ?? []) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations ?? []) collectPatternNames(declarator.id, localBindings);
+	}
+	return localBindings;
+};
+const isFunctionLikeNode = (node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+const walkComponentRespectingShadows = (node, shadowedStateNames, visit) => {
+	if (!node || typeof node !== "object") return;
+	let nextShadowedStateNames = shadowedStateNames;
+	if (isFunctionLikeNode(node)) {
+		const localBindings = collectFunctionLocalBindings(node);
+		if (localBindings.size > 0) {
+			const merged = new Set(shadowedStateNames);
+			for (const localName of localBindings) merged.add(localName);
+			nextShadowedStateNames = merged;
+		}
+	}
+	visit(node, shadowedStateNames);
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const item of child) if (item && typeof item === "object" && item.type) walkComponentRespectingShadows(item, nextShadowedStateNames, visit);
+		} else if (child && typeof child === "object" && child.type) walkComponentRespectingShadows(child, nextShadowedStateNames, visit);
+	}
+};
+const noDirectStateMutation = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const bindings = collectUseStateBindings(componentBody);
+		if (bindings.length === 0) return;
+		const stateValueToSetter = new Map(bindings.map((binding) => [binding.valueName, binding.setterName]));
+		walkComponentRespectingShadows(componentBody, /* @__PURE__ */ new Set(), (child, currentlyShadowed) => {
+			if (child.type === "AssignmentExpression") {
+				if (child.left?.type !== "MemberExpression") return;
+				const rootName = getRootIdentifierName(child.left);
+				if (!rootName || !stateValueToSetter.has(rootName)) return;
+				if (currentlyShadowed.has(rootName)) return;
+				const setterName = stateValueToSetter.get(rootName);
+				context.report({
+					node: child,
+					message: `Direct property assignment on useState value "${rootName}" — call ${setterName} with a new value; React only re-renders on a new reference`
+				});
+				return;
+			}
+			if (child.type === "CallExpression") {
+				const callee = child.callee;
+				if (callee?.type !== "MemberExpression") return;
+				if (callee.property?.type !== "Identifier") return;
+				const methodName = callee.property.name;
+				if (!MUTATING_ARRAY_METHODS.has(methodName)) return;
+				const rootName = getRootIdentifierName(callee.object);
+				if (!rootName || !stateValueToSetter.has(rootName)) return;
+				if (currentlyShadowed.has(rootName)) return;
+				const setterName = stateValueToSetter.get(rootName);
+				context.report({
+					node: child,
+					message: `In-place mutation of useState value "${rootName}" via .${methodName}() — call ${setterName} with a new array; React only re-renders on a new reference`
+				});
+			}
+		});
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+			checkComponent(node.body);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			checkComponent(node.init?.body);
+		}
+	};
+} };
+const isUnconditionalSetterCallStatement = (statement, setterNames) => {
+	if (statement.type !== "ExpressionStatement") return null;
+	const expression = statement.expression;
+	if (expression?.type !== "CallExpression") return null;
+	const callee = expression.callee;
+	if (callee?.type !== "Identifier") return null;
+	if (!setterNames.has(callee.name)) return null;
+	return expression;
+};
+const noSetStateInRender = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const setterNames = new Set(collectUseStateBindings(componentBody).map((binding) => binding.setterName));
+		if (setterNames.size === 0) return;
+		for (const statement of componentBody.body ?? []) {
+			const setterCall = isUnconditionalSetterCallStatement(statement, setterNames);
+			if (!setterCall) continue;
+			const setterIdentifierName = setterCall.callee.name;
+			context.report({
+				node: setterCall,
+				message: `${setterIdentifierName}() called unconditionally at the top of render — causes an infinite re-render loop. Move into a useEffect or an event handler. (To derive state from props, guard the call: \`if (prev !== prop) ${setterIdentifierName}(prop)\`)`
+			});
+		}
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+			checkComponent(node.body);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			checkComponent(node.init?.body);
+		}
+	};
+} };
+const findUseEffectsInComponent = (componentBody) => {
+	const effectCalls = [];
+	if (componentBody?.type !== "BlockStatement") return effectCalls;
+	for (const statement of componentBody.body ?? []) walkAst(statement, (child) => {
+		if (child.type === "CallExpression" && isHookCall(child, EFFECT_HOOK_NAMES)) effectCalls.push(child);
+	});
+	return effectCalls;
+};
+const findSubscriptionCall = (effectBodyStatements) => {
+	for (const statement of effectBodyStatements) {
+		if (statement.type === "VariableDeclaration") for (const declarator of statement.declarations ?? []) {
+			const init = declarator.init;
+			if (init?.type !== "CallExpression") continue;
+			if (init.callee?.type !== "MemberExpression") continue;
+			if (init.callee.property?.type !== "Identifier") continue;
+			if (!SUBSCRIPTION_METHOD_NAMES.has(init.callee.property.name)) continue;
+			return {
+				call: init,
+				boundUnsubscribeName: declarator.id?.type === "Identifier" ? declarator.id.name : null
+			};
+		}
+		if (statement.type === "ExpressionStatement") {
+			const expression = statement.expression;
+			if (expression?.type !== "CallExpression") continue;
+			if (expression.callee?.type !== "MemberExpression") continue;
+			if (expression.callee.property?.type !== "Identifier") continue;
+			if (!SUBSCRIPTION_METHOD_NAMES.has(expression.callee.property.name)) continue;
+			return {
+				call: expression,
+				boundUnsubscribeName: null
+			};
+		}
+	}
+	return null;
+};
+const getSubscriptionHandlerArgument = (subscribeCall, effectBodyStatements) => {
+	for (const argument of subscribeCall.arguments ?? []) {
+		if (argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression") return argument;
+		if (argument.type === "Identifier") for (const statement of effectBodyStatements) {
+			if (statement.type !== "VariableDeclaration") continue;
+			for (const declarator of statement.declarations ?? []) {
+				if (declarator.id?.type !== "Identifier") continue;
+				if (declarator.id.name !== argument.name) continue;
+				const init = declarator.init;
+				if (init?.type === "ArrowFunctionExpression" || init?.type === "FunctionExpression") return init;
+			}
+		}
+	}
+	return null;
+};
+const getSingleSetterCallFromHandler = (handler) => {
+	const handlerStatements = getCallbackStatements(handler);
+	if (handlerStatements.length !== 1) return null;
+	const onlyStatement = handlerStatements[0];
+	const expression = onlyStatement.type === "ExpressionStatement" ? onlyStatement.expression : onlyStatement;
+	if (expression?.type !== "CallExpression") return null;
+	if (expression.callee?.type !== "Identifier") return null;
+	if (!isSetterIdentifier(expression.callee.name)) return null;
+	if (!expression.arguments?.length) return null;
+	return {
+		setterName: expression.callee.name,
+		setterArgument: expression.arguments[0]
+	};
+};
+const cleanupReleasesSubscription = (effectBodyStatements, boundUnsubscribeName) => {
+	const lastStatement = effectBodyStatements[effectBodyStatements.length - 1];
+	if (lastStatement?.type !== "ReturnStatement") return false;
+	const knownBoundReleaseNames = /* @__PURE__ */ new Set();
+	if (boundUnsubscribeName) knownBoundReleaseNames.add(boundUnsubscribeName);
+	return isCleanupReturn(lastStatement.argument, knownBoundReleaseNames);
+};
+const preferUseSyncExternalStore = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const useStateBindings = collectUseStateBindings(componentBody);
+		if (useStateBindings.length === 0) return;
+		const useStateInitializerByValueName = /* @__PURE__ */ new Map();
+		for (const binding of useStateBindings) {
+			const initializerArgument = binding.declarator.init?.arguments?.[0];
+			if (!initializerArgument) continue;
+			if ((initializerArgument.type === "ArrowFunctionExpression" || initializerArgument.type === "FunctionExpression") && initializerArgument.body?.type !== "BlockStatement") useStateInitializerByValueName.set(binding.valueName, initializerArgument.body);
+			else useStateInitializerByValueName.set(binding.valueName, initializerArgument);
+		}
+		const setterNameToValueName = /* @__PURE__ */ new Map();
+		for (const binding of useStateBindings) setterNameToValueName.set(binding.setterName, binding.valueName);
+		for (const effectCall of findUseEffectsInComponent(componentBody)) {
+			if ((effectCall.arguments?.length ?? 0) < 2) continue;
+			const depsNode = effectCall.arguments[1];
+			if (depsNode.type !== "ArrayExpression") continue;
+			if ((depsNode.elements?.length ?? 0) !== 0) continue;
+			const callback = getEffectCallback(effectCall);
+			if (!callback || callback.body?.type !== "BlockStatement") continue;
+			const effectBodyStatements = callback.body.body ?? [];
+			if (effectBodyStatements.length < 2) continue;
+			const subscription = findSubscriptionCall(effectBodyStatements);
+			if (!subscription) continue;
+			const handler = getSubscriptionHandlerArgument(subscription.call, effectBodyStatements);
+			if (!handler) continue;
+			const setterPayload = getSingleSetterCallFromHandler(handler);
+			if (!setterPayload) continue;
+			const valueName = setterNameToValueName.get(setterPayload.setterName);
+			if (!valueName) continue;
+			const useStateInitializer = useStateInitializerByValueName.get(valueName);
+			if (!useStateInitializer) continue;
+			if (!areExpressionsStructurallyEqual(useStateInitializer, setterPayload.setterArgument)) continue;
+			if (!cleanupReleasesSubscription(effectBodyStatements, subscription.boundUnsubscribeName)) continue;
+			const matchingBinding = useStateBindings.find((binding) => binding.valueName === valueName);
+			context.report({
+				node: matchingBinding?.declarator ?? effectCall,
+				message: `useState "${valueName}" is synchronized with an external store via useEffect — replace this useState + useEffect pair with useSyncExternalStore(subscribe, getSnapshot) to avoid tearing during concurrent renders`
+			});
+		}
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+			checkComponent(node.body);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			checkComponent(node.init?.body);
+		}
+	};
+} };
+const SENTINEL_IDENTIFIER_NAMES = new Set([
+	"undefined",
+	"NaN",
+	"null"
+]);
+const isSentinelIdentifier = (node) => node?.type === "Identifier" && SENTINEL_IDENTIFIER_NAMES.has(node.name);
+const getTriggerGuardRootName = (testNode) => {
+	if (!testNode) return null;
+	if (testNode.type === "Identifier") return testNode.name;
+	if (testNode.type === "BinaryExpression") {
+		if (![
+			"!==",
+			"===",
+			"!=",
+			"=="
+		].includes(testNode.operator)) return null;
+		for (const side of [testNode.left, testNode.right]) if (side?.type === "Identifier" && !isSentinelIdentifier(side)) return side.name;
+		return null;
+	}
+	if (testNode.type === "MemberExpression" && testNode.property?.type === "Identifier" && testNode.property.name === "length") {
+		if (testNode.object?.type === "Identifier") return testNode.object.name;
+	}
+	if (testNode.type === "UnaryExpression" && testNode.operator === "!") return getTriggerGuardRootName(testNode.argument);
+	return null;
+};
+const findTriggeredSideEffectCalleeName = (consequentNode) => {
+	let foundCalleeName = null;
+	walkAst(consequentNode, (child) => {
+		if (foundCalleeName) return false;
+		if (child.type !== "CallExpression") return;
+		const callee = child.callee;
+		if (callee?.type === "Identifier" && EVENT_TRIGGERED_SIDE_EFFECT_CALLEES.has(callee.name)) {
+			foundCalleeName = callee.name;
+			return;
+		}
+		if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier") {
+			const propertyName = callee.property.name;
+			const isUnambiguousMethod = EVENT_TRIGGERED_SIDE_EFFECT_MEMBER_METHODS.has(propertyName);
+			const isNavigationMethod = EVENT_TRIGGERED_NAVIGATION_METHOD_NAMES.has(propertyName);
+			if (!isUnambiguousMethod && !isNavigationMethod) return;
+			const rootName = getRootIdentifierName(callee);
+			if (isNavigationMethod && (rootName === null || !NAVIGATION_RECEIVER_NAMES.has(rootName))) return;
+			foundCalleeName = rootName ? `${rootName}.${propertyName}` : propertyName;
+		}
+	});
+	return foundCalleeName;
+};
+const collectHandlerOnlyWriteStateNames = (componentBody, useStateBindings, handlerBindingNames) => {
+	const handlerOnlyWriteStateNames = /* @__PURE__ */ new Set();
+	for (const binding of useStateBindings) {
+		let didFindAnySetterCall = false;
+		let areAllSetterCallsInHandlers = true;
+		walkAst(componentBody, (child) => {
+			if (!areAllSetterCallsInHandlers) return false;
+			if (child.type !== "CallExpression") return;
+			if (child.callee?.type !== "Identifier") return;
+			if (child.callee.name !== binding.setterName) return;
+			didFindAnySetterCall = true;
+			if (!isInsideEventHandler(child, handlerBindingNames)) areAllSetterCallsInHandlers = false;
+		});
+		if (didFindAnySetterCall && areAllSetterCallsInHandlers) handlerOnlyWriteStateNames.add(binding.valueName);
+	}
+	return handlerOnlyWriteStateNames;
+};
+const noEventTriggerState = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const useStateBindings = collectUseStateBindings(componentBody);
+		if (useStateBindings.length === 0) return;
+		const handlerOnlyWriteStateNames = collectHandlerOnlyWriteStateNames(componentBody, useStateBindings, collectHandlerBindingNames(componentBody));
+		if (handlerOnlyWriteStateNames.size === 0) return;
+		const returnExpressions = collectReturnExpressions(componentBody);
+		const dependencyGraph = buildLocalDependencyGraph(componentBody);
+		const renderReachableNames = expandTransitiveDependencies(collectRenderReachableNames(returnExpressions), dependencyGraph);
+		walkAst(componentBody, (effectCall) => {
+			if (effectCall.type !== "CallExpression") return;
+			if (!isHookCall(effectCall, EFFECT_HOOK_NAMES)) return;
+			if ((effectCall.arguments?.length ?? 0) < 2) return;
+			const depsNode = effectCall.arguments[1];
+			if (depsNode.type !== "ArrayExpression") return;
+			if ((depsNode.elements?.length ?? 0) !== 1) return;
+			const depElement = depsNode.elements[0];
+			if (depElement?.type !== "Identifier") return;
+			if (!handlerOnlyWriteStateNames.has(depElement.name)) return;
+			if (renderReachableNames.has(depElement.name)) return;
+			const callback = getEffectCallback(effectCall);
+			if (!callback) return;
+			const bodyStatements = getCallbackStatements(callback);
+			if (bodyStatements.length !== 1) return;
+			const soleStatement = bodyStatements[0];
+			if (soleStatement.type !== "IfStatement") return;
+			if (getTriggerGuardRootName(soleStatement.test) !== depElement.name) return;
+			const sideEffectCalleeName = findTriggeredSideEffectCalleeName(soleStatement.consequent);
+			if (!sideEffectCalleeName) return;
+			context.report({
+				node: effectCall,
+				message: `useState "${depElement.name}" exists only to schedule "${sideEffectCalleeName}(...)" from a useEffect — call "${sideEffectCalleeName}(...)" directly inside the event handler that sets it, and delete the state`
+			});
+		});
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+			checkComponent(node.body);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			checkComponent(node.init?.body);
+		}
+	};
+} };
+const findTopLevelEffectCalls = (componentBody) => {
+	const effectCalls = [];
+	if (componentBody?.type !== "BlockStatement") return effectCalls;
+	for (const statement of componentBody.body ?? []) {
+		if (statement.type !== "ExpressionStatement") continue;
+		const expression = statement.expression;
+		if (expression?.type !== "CallExpression") continue;
+		if (!isHookCall(expression, EFFECT_HOOK_NAMES)) continue;
+		effectCalls.push(expression);
+	}
+	return effectCalls;
+};
+const collectDepIdentifierNames = (effectNode) => {
+	const depNames = /* @__PURE__ */ new Set();
+	const depsNode = effectNode.arguments?.[1];
+	if (depsNode?.type !== "ArrayExpression") return depNames;
+	for (const element of depsNode.elements ?? []) if (element?.type === "Identifier") depNames.add(element.name);
+	return depNames;
+};
+const collectWrittenStateNamesInEffect = (effectCallback, setterToStateName) => {
+	const writtenStateNames = /* @__PURE__ */ new Set();
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (child.type !== "CallExpression") return;
+		if (child.callee?.type !== "Identifier") return;
+		const stateName = setterToStateName.get(child.callee.name);
+		if (stateName) writtenStateNames.add(stateName);
+	});
+	return writtenStateNames;
+};
+const isFunctionShapedReturn = (returnedValue) => {
+	if (returnedValue.type === "ArrowFunctionExpression" || returnedValue.type === "FunctionExpression") return true;
+	if (returnedValue.type === "CallExpression") return true;
+	if (returnedValue.type === "Identifier") return true;
+	return false;
+};
+const isExternalSyncEffect = (effectCallback) => {
+	if (effectCallback.body?.type === "BlockStatement") {
+		const statements = effectCallback.body.body ?? [];
+		for (const statement of statements) if (statement.type === "ReturnStatement" && statement.argument && isFunctionShapedReturn(statement.argument)) return true;
+	}
+	let didFindExternalCall = false;
+	walkAst(effectCallback, (child) => {
+		if (didFindExternalCall) return false;
+		if (child.type === "NewExpression") {
+			const constructor = child.callee;
+			if (constructor?.type === "Identifier" && EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS.has(constructor.name)) didFindExternalCall = true;
+			return;
+		}
+		if (child.type === "AssignmentExpression") {
+			if (child.left?.type === "MemberExpression" && child.left.property?.type === "Identifier" && child.left.property.name === "current") didFindExternalCall = true;
+			return;
+		}
+		if (child.type !== "CallExpression") return;
+		if (child.callee?.type === "Identifier" && EXTERNAL_SYNC_DIRECT_CALLEE_NAMES.has(child.callee.name)) {
+			didFindExternalCall = true;
+			return;
+		}
+		if (child.callee?.type === "MemberExpression" && child.callee.property?.type === "Identifier") {
+			const propertyName = child.callee.property.name;
+			if (EXTERNAL_SYNC_MEMBER_METHOD_NAMES.has(propertyName)) {
+				didFindExternalCall = true;
+				return;
+			}
+			if (EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES.has(propertyName)) {
+				const receiverRootName = getRootIdentifierName(child.callee.object);
+				if (receiverRootName !== null && EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS.has(receiverRootName)) didFindExternalCall = true;
+			}
+		}
+	});
+	return didFindExternalCall;
+};
+const noEffectChain = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const useStateBindings = collectUseStateBindings(componentBody);
+		if (useStateBindings.length === 0) return;
+		const setterToStateName = /* @__PURE__ */ new Map();
+		for (const binding of useStateBindings) setterToStateName.set(binding.setterName, binding.valueName);
+		const effectInfos = [];
+		for (const effectCall of findTopLevelEffectCalls(componentBody)) {
+			const callback = getEffectCallback(effectCall);
+			if (!callback) continue;
+			effectInfos.push({
+				node: effectCall,
+				depNames: collectDepIdentifierNames(effectCall),
+				writtenStateNames: collectWrittenStateNamesInEffect(callback, setterToStateName),
+				isExternalSync: isExternalSyncEffect(callback)
+			});
+		}
+		if (effectInfos.length < 2) return;
+		const reportedNodes = /* @__PURE__ */ new Set();
+		for (const writerEffect of effectInfos) {
+			if (writerEffect.isExternalSync) continue;
+			if (writerEffect.writtenStateNames.size === 0) continue;
+			for (const readerEffect of effectInfos) {
+				if (readerEffect === writerEffect) continue;
+				if (readerEffect.isExternalSync) continue;
+				if (readerEffect.depNames.size === 0) continue;
+				let chainedStateName = null;
+				for (const writtenName of writerEffect.writtenStateNames) if (readerEffect.depNames.has(writtenName)) {
+					chainedStateName = writtenName;
+					break;
+				}
+				if (!chainedStateName) continue;
+				if (reportedNodes.has(readerEffect.node)) continue;
+				reportedNodes.add(readerEffect.node);
+				context.report({
+					node: readerEffect.node,
+					message: `useEffect reacts to "${chainedStateName}" which is set by another useEffect — chains of effects add an extra render per link and become rigid as code evolves. Compute what you can during render and write all related state inside the event handler that originally fires the chain`
+				});
+			}
+		}
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+			checkComponent(node.body);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			checkComponent(node.init?.body);
+		}
+	};
+} };
+const collectUseRefBindingNames = (componentBody) => {
+	const useRefBindings = /* @__PURE__ */ new Set();
+	if (componentBody?.type !== "BlockStatement") return useRefBindings;
+	for (const statement of componentBody.body ?? []) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations ?? []) {
+			if (declarator.id?.type !== "Identifier") continue;
+			if (declarator.init?.type !== "CallExpression") continue;
+			if (!isHookCall(declarator.init, "useRef")) continue;
+			useRefBindings.add(declarator.id.name);
+		}
+	}
+	return useRefBindings;
+};
+const findMutableDepIssue = (depElement, useRefBindingNames) => {
+	if (depElement.type !== "MemberExpression") return null;
+	if (depElement.property?.type === "Identifier" && depElement.property.name === "current" && !depElement.computed && depElement.object?.type === "Identifier" && useRefBindingNames.has(depElement.object.name)) return {
+		kind: "ref-current",
+		rootName: depElement.object.name
+	};
+	const rootName = getRootIdentifierName(depElement);
+	if (rootName !== null && MUTABLE_GLOBAL_ROOTS.has(rootName)) return {
+		kind: "global",
+		rootName
+	};
+	return null;
+};
+const getPropRootName = (expression, propNames) => {
+	const rootName = getRootIdentifierName(expression, { followCallChains: true });
+	return rootName !== null && propNames.has(rootName) ? rootName : null;
+};
+const findSubscribeLikeUsages = (callback) => {
+	const usages = [];
+	let cleanupArgument = null;
+	if (callback.body?.type === "BlockStatement") {
+		const callbackStatements = callback.body.body ?? [];
+		const lastCallbackStatement = callbackStatements[callbackStatements.length - 1];
+		if (lastCallbackStatement?.type === "ReturnStatement" && lastCallbackStatement.argument) cleanupArgument = lastCallbackStatement.argument;
+	}
+	walkAst(callback, (child) => {
+		if (child === cleanupArgument) return false;
+		if (child.type !== "CallExpression") return;
+		if (child.callee?.type === "Identifier" && TIMER_CALLEE_NAMES_REQUIRING_CLEANUP.has(child.callee.name)) {
+			usages.push({
+				kind: "timer",
+				resourceName: child.callee.name
+			});
+			return;
+		}
+		if (child.callee?.type === "MemberExpression" && child.callee.property?.type === "Identifier" && SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name)) usages.push({
+			kind: "subscribe",
+			resourceName: child.callee.property.name
+		});
+	});
+	return usages;
+};
+const isSubscribeLikeCallExpression = (node) => {
+	if (node?.type !== "CallExpression") return false;
+	if (node.callee?.type !== "MemberExpression") return false;
+	if (node.callee.property?.type !== "Identifier") return false;
+	return SUBSCRIPTION_METHOD_NAMES.has(node.callee.property.name);
+};
+const collectReleasableBindingNames = (effectCallback) => {
+	const releasableNames = /* @__PURE__ */ new Set();
+	if (effectCallback.body?.type !== "BlockStatement") return releasableNames;
+	for (const statement of effectCallback.body.body ?? []) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations ?? []) {
+			if (declarator.id?.type !== "Identifier") continue;
+			const init = declarator.init;
+			if (!init || init.type !== "CallExpression") continue;
+			if (isSubscribeLikeCallExpression(init)) {
+				releasableNames.add(declarator.id.name);
+				continue;
+			}
+			if (init.callee?.type === "Identifier" && TIMER_CALLEE_NAMES_REQUIRING_CLEANUP.has(init.callee.name)) releasableNames.add(declarator.id.name);
+		}
+	}
+	return releasableNames;
+};
+const isReleaseLikeCall = (callNode, knownBoundReleaseNames) => {
+	if (callNode?.type !== "CallExpression") return false;
+	const callee = callNode.callee;
+	if (callee?.type === "Identifier") {
+		if (TIMER_CLEANUP_CALLEE_NAMES.has(callee.name)) return true;
+		if (CLEANUP_LIKE_RELEASE_CALLEE_NAMES.has(callee.name)) return true;
+		if (knownBoundReleaseNames.has(callee.name)) return true;
+		return false;
+	}
+	if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier") return UNSUBSCRIPTION_METHOD_NAMES.has(callee.property.name);
+	return false;
+};
+const containsReleaseLikeCall = (node, knownBoundReleaseNames) => {
+	let didFindRelease = false;
+	walkAst(node, (child) => {
+		if (didFindRelease) return false;
+		if (isReleaseLikeCall(child, knownBoundReleaseNames)) {
+			didFindRelease = true;
+			return false;
+		}
+	});
+	return didFindRelease;
+};
+const isCleanupReturn = (returnedValue, knownBoundReleaseNames) => {
+	if (!returnedValue) return false;
+	if (returnedValue.type === "Identifier") return knownBoundReleaseNames.has(returnedValue.name);
+	if (isSubscribeLikeCallExpression(returnedValue)) return true;
+	if (returnedValue.type === "ArrowFunctionExpression" || returnedValue.type === "FunctionExpression") return containsReleaseLikeCall(returnedValue, knownBoundReleaseNames);
+	return false;
+};
+const effectHasCleanupRelease = (callback) => {
+	if (callback.body?.type !== "BlockStatement") return isSubscribeLikeCallExpression(callback.body);
+	const knownBoundReleaseNames = collectReleasableBindingNames(callback);
+	let didFindCleanupReturn = false;
+	walkInsideStatementBlocks(callback.body, (child) => {
+		if (didFindCleanupReturn) return;
+		if (child.type !== "ReturnStatement") return;
+		if (isCleanupReturn(child.argument, knownBoundReleaseNames)) didFindCleanupReturn = true;
+	});
+	return didFindCleanupReturn;
+};
+const effectNeedsCleanup = { create: (context) => ({ CallExpression(node) {
+	if (!isHookCall(node, EFFECT_HOOK_NAMES)) return;
+	const callback = getEffectCallback(node);
+	if (!callback) return;
+	const usages = findSubscribeLikeUsages(callback);
+	if (usages.length === 0) return;
+	if (effectHasCleanupRelease(callback)) return;
+	const firstUsage = usages[0];
+	const verb = firstUsage.kind === "timer" ? "schedules" : "subscribes via";
+	const release = firstUsage.kind === "timer" ? `clear${firstUsage.resourceName === "setInterval" ? "Interval" : "Timeout"}(...)` : "the matching remove/unsubscribe call";
+	context.report({
+		node,
+		message: `useEffect ${verb} \`${firstUsage.resourceName}(...)\` but never returns a cleanup — leaks the registration on every re-run and on unmount. Return a cleanup function that calls ${release}`
+	});
+} }) };
+const noMirrorPropEffect = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const propNames = propStackTracker.getCurrentPropNames();
+		if (propNames.size === 0) return;
+		const mirrorBindings = [];
+		for (const statement of componentBody.body ?? []) {
+			if (statement.type !== "VariableDeclaration") continue;
+			for (const declarator of statement.declarations ?? []) {
+				if (declarator.id?.type !== "ArrayPattern") continue;
+				const elements = declarator.id.elements ?? [];
+				if (elements.length < 2) continue;
+				const valueElement = elements[0];
+				const setterElement = elements[1];
+				if (valueElement?.type !== "Identifier" || setterElement?.type !== "Identifier" || !isSetterIdentifier(setterElement.name)) continue;
+				if (declarator.init?.type !== "CallExpression") continue;
+				if (!isHookCall(declarator.init, "useState")) continue;
+				const initializer = declarator.init.arguments?.[0];
+				if (!initializer) continue;
+				const propRootName = getPropRootName(initializer, propNames);
+				if (!propRootName) continue;
+				mirrorBindings.push({
+					valueName: valueElement.name,
+					setterName: setterElement.name,
+					initializer,
+					propRootName
+				});
+			}
+		}
+		if (mirrorBindings.length === 0) return;
+		for (const statement of componentBody.body ?? []) {
+			if (statement.type !== "ExpressionStatement") continue;
+			const effectCall = statement.expression;
+			if (effectCall?.type !== "CallExpression") continue;
+			if (!isHookCall(effectCall, EFFECT_HOOK_NAMES)) continue;
+			if ((effectCall.arguments?.length ?? 0) < 2) continue;
+			const depsNode = effectCall.arguments[1];
+			if (depsNode.type !== "ArrayExpression") continue;
+			const depIdentifierNames = /* @__PURE__ */ new Set();
+			for (const element of depsNode.elements ?? []) if (element?.type === "Identifier") depIdentifierNames.add(element.name);
+			if (depIdentifierNames.size === 0) continue;
+			const callback = getEffectCallback(effectCall);
+			if (!callback) continue;
+			const bodyStatements = getCallbackStatements(callback);
+			if (bodyStatements.length !== 1) continue;
+			const onlyStatement = bodyStatements[0];
+			const expression = onlyStatement.type === "ExpressionStatement" ? onlyStatement.expression : onlyStatement;
+			if (expression?.type !== "CallExpression") continue;
+			if (expression.callee?.type !== "Identifier") continue;
+			if (!isSetterIdentifier(expression.callee.name)) continue;
+			if (!expression.arguments?.length) continue;
+			const setterArgument = expression.arguments[0];
+			const matchedBinding = mirrorBindings.find((binding) => binding.setterName === expression.callee.name && depIdentifierNames.has(binding.propRootName) && areExpressionsStructurallyEqual(binding.initializer, setterArgument));
+			if (!matchedBinding) continue;
+			context.report({
+				node: effectCall,
+				message: `useState "${matchedBinding.valueName}" is mirrored from prop "${matchedBinding.propRootName}" via this effect — delete both the useState and the effect, and read the prop directly in render`
+			});
+		}
+	};
+	const propStackTracker = createComponentPropStackTracker({ onComponentEnter: checkComponent });
+	return propStackTracker.visitors;
+} };
+const noMutableInDeps = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const useRefBindingNames = collectUseRefBindingNames(componentBody);
+		walkAst(componentBody, (child) => {
+			if (child.type !== "CallExpression") return;
+			if (!isHookCall(child, HOOKS_WITH_DEPS)) return;
+			if ((child.arguments?.length ?? 0) < 2) return;
+			const depsNode = child.arguments[1];
+			if (depsNode.type !== "ArrayExpression") return;
+			for (const element of depsNode.elements ?? []) {
+				if (!element) continue;
+				const issue = findMutableDepIssue(element, useRefBindingNames);
+				if (!issue) continue;
+				if (issue.kind === "ref-current") context.report({
+					node: element,
+					message: `"${issue.rootName}.current" in deps — refs are mutable and don't trigger re-renders, so React won't re-run this effect when it changes. Read the ref inside the effect body instead`
+				});
+				else context.report({
+					node: element,
+					message: `Mutable global "${issue.rootName}.*" in deps — values like \`location.pathname\` can change without triggering a re-render, so they can't drive effect re-runs. Subscribe with useSyncExternalStore or read inside the effect`
+				});
+			}
+		});
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+			checkComponent(node.body);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			checkComponent(node.init?.body);
+		}
+	};
+} };
+const collectFunctionTypedLocalBindings = (componentBody) => {
+	const functionTypedLocals = /* @__PURE__ */ new Set();
+	if (componentBody?.type !== "BlockStatement") return functionTypedLocals;
+	for (const statement of componentBody.body ?? []) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations ?? []) {
+			if (declarator.id?.type !== "Identifier") continue;
+			if (declarator.init?.type !== "CallExpression") continue;
+			if (!isHookCall(declarator.init, "useCallback")) continue;
+			functionTypedLocals.add(declarator.id.name);
+		}
+	}
+	return functionTypedLocals;
+};
+const findEnclosingFunctionInsideEffect = (identifierNode, effectCallback) => {
+	let cursor = identifierNode.parent ?? null;
+	while (cursor && cursor !== effectCallback) {
+		if (cursor.type === "ArrowFunctionExpression" || cursor.type === "FunctionExpression" || cursor.type === "FunctionDeclaration") return cursor;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+const isCallExpressionWithSubHandlerCallee = (callExpression) => {
+	if (callExpression?.type !== "CallExpression") return false;
+	const callee = callExpression.callee;
+	if (callee?.type === "Identifier" && TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES.has(callee.name)) return true;
+	if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && SUBSCRIPTION_METHOD_NAMES.has(callee.property.name)) return true;
+	return false;
+};
+const getSubHandlerCalleeName = (callExpression) => {
+	if (callExpression?.type !== "CallExpression") return null;
+	const callee = callExpression.callee;
+	if (callee?.type === "Identifier") return callee.name;
+	if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier") return callee.property.name;
+	return null;
+};
+const getEnclosingFunctionBindingName = (enclosingFunction) => {
+	if (enclosingFunction.type === "FunctionDeclaration" && enclosingFunction.id?.type === "Identifier") return enclosingFunction.id.name;
+	const directParent = enclosingFunction.parent;
+	if (directParent?.type === "VariableDeclarator" && directParent.id?.type === "Identifier") return directParent.id.name;
+	if (directParent?.type === "AssignmentExpression" && directParent.right === enclosingFunction && directParent.left?.type === "Identifier") return directParent.left.name;
+	return null;
+};
+const findSubHandlerForEnclosingFunction = (enclosingFunction, effectCallback) => {
+	const directParent = enclosingFunction.parent;
+	if (directParent?.type === "CallExpression" && directParent.arguments?.includes(enclosingFunction) && isCallExpressionWithSubHandlerCallee(directParent)) return directParent;
+	const localName = getEnclosingFunctionBindingName(enclosingFunction);
+	if (localName === null) return null;
+	let matchingSubHandlerCall = null;
+	walkAst(effectCallback, (child) => {
+		if (matchingSubHandlerCall) return false;
+		if (child.type !== "CallExpression") return;
+		if (!isCallExpressionWithSubHandlerCallee(child)) return;
+		for (const argument of child.arguments ?? []) if (argument?.type === "Identifier" && argument.name === localName) {
+			matchingSubHandlerCall = child;
+			return false;
+		}
+	});
+	return matchingSubHandlerCall;
+};
+const classifyCallableReadsInsideEffect = (callableName, effectCallback) => {
+	let hasAnyRead = false;
+	let allReadsAreInSubHandlers = true;
+	let firstSubHandlerName = null;
+	walkAst(effectCallback, (child) => {
+		if (child.type !== "Identifier") return;
+		if (child.name !== callableName) return;
+		const parent = child.parent;
+		if (parent?.type === "ArrayExpression") return;
+		if (parent?.type === "MemberExpression" && !parent.computed && parent.property === child) return;
+		if (parent?.type === "Property" && !parent.computed && !parent.shorthand && parent.key === child) return;
+		hasAnyRead = true;
+		const enclosingFunction = findEnclosingFunctionInsideEffect(child, effectCallback);
+		if (!enclosingFunction) {
+			allReadsAreInSubHandlers = false;
+			return;
+		}
+		const subHandlerCall = findSubHandlerForEnclosingFunction(enclosingFunction, effectCallback);
+		if (!subHandlerCall) {
+			allReadsAreInSubHandlers = false;
+			return;
+		}
+		if (firstSubHandlerName === null) firstSubHandlerName = getSubHandlerCalleeName(subHandlerCall);
+	});
+	return {
+		hasAnyRead,
+		allReadsAreInSubHandlers,
+		firstSubHandlerName
+	};
+};
+//#endregion
+//#region src/plugin/index.ts
+const plugin = {
+	meta: { name: "react-doctor" },
 	rules: {
 		"no-derived-state-effect": noDerivedStateEffect,
 		"no-fetch-in-effect": noFetchInEffect,
+		"no-mirror-prop-effect": noMirrorPropEffect,
+		"no-mutable-in-deps": noMutableInDeps,
 		"no-cascading-set-state": noCascadingSetState,
+		"no-effect-chain": noEffectChain,
 		"no-effect-event-handler": noEffectEventHandler,
 		"no-effect-event-in-deps": noEffectEventInDeps,
+		"no-event-trigger-state": noEventTriggerState,
 		"no-prop-callback-in-effect": noPropCallbackInEffect,
 		"no-derived-useState": noDerivedUseState,
-		"prefer-useReducer": preferUseReducer,
-		"rerender-lazy-state-init": rerenderLazyStateInit,
-		"rerender-functional-setstate": rerenderFunctionalSetstate,
-		"rerender-dependencies": rerenderDependencies,
-		"rerender-state-only-in-handlers": rerenderStateOnlyInHandlers,
-		"rerender-defer-reads-hook": { create: (context) => {
+		"no-direct-state-mutation": noDirectStateMutation,
+		"no-set-state-in-render": noSetStateInRender,
+		"prefer-use-effect-event": { create: (context) => {
 			const checkComponent = (componentBody) => {
 				if (!componentBody || componentBody.type !== "BlockStatement") return;
-				const bindings = findHookCallBindings(componentBody);
-				if (bindings.length === 0) return;
-				const handlerBindingNames = collectHandlerBindingNames(componentBody);
-				for (const binding of bindings) {
-					const referenceLocations = [];
-					walkAst(componentBody, (child) => {
-						if (child === binding.declarator.id) return;
-						if (child.type === "Identifier" && child.name === binding.valueName) referenceLocations.push(child);
-					});
-					if (referenceLocations.length === 0) continue;
-					if (!referenceLocations.every((ref) => isInsideEventHandler(ref, handlerBindingNames))) continue;
-					context.report({
-						node: binding.declarator,
-						message: `${binding.hookName}() return is only read inside event handlers — defer the read into the handler (e.g. \`new URL(window.location.href).searchParams\`) so the component doesn't re-render on every URL change`
-					});
-				}
-			};
-			return {
-				FunctionDeclaration(node) {
-					if (!node.id?.name || !isUppercaseName(node.id.name)) return;
-					checkComponent(node.body);
-				},
-				VariableDeclarator(node) {
-					if (!isComponentAssignment(node)) return;
-					checkComponent(node.init?.body);
+				const functionTypedLocalBindings = collectFunctionTypedLocalBindings(componentBody);
+				for (const statement of componentBody.body ?? []) {
+					if (statement.type !== "ExpressionStatement") continue;
+					const effectCall = statement.expression;
+					if (effectCall?.type !== "CallExpression") continue;
+					if (!isHookCall(effectCall, EFFECT_HOOK_NAMES)) continue;
+					if ((effectCall.arguments?.length ?? 0) < 2) continue;
+					const depsNode = effectCall.arguments[1];
+					if (depsNode.type !== "ArrayExpression") continue;
+					const depElements = depsNode.elements ?? [];
+					if (depElements.length < 2) continue;
+					if (!depElements.every((element) => element?.type === "Identifier")) continue;
+					const callback = getEffectCallback(effectCall);
+					if (!callback) continue;
+					for (const depElement of depElements) {
+						if (!depElement) continue;
+						const depName = depElement.name;
+						const isFunctionTypedPropDep = propStackTracker.isPropName(depName) && REACT_HANDLER_PROP_PATTERN.test(depName);
+						const isFunctionTypedLocalDep = functionTypedLocalBindings.has(depName);
+						if (!isFunctionTypedPropDep && !isFunctionTypedLocalDep) continue;
+						const classification = classifyCallableReadsInsideEffect(depName, callback);
+						if (!classification.hasAnyRead) continue;
+						if (!classification.allReadsAreInSubHandlers) continue;
+						const subHandlerLabel = classification.firstSubHandlerName ? `\`${classification.firstSubHandlerName}\`` : "an async sub-handler";
+						context.report({
+							node: depElement,
+							message: `"${depName}" is read only inside ${subHandlerLabel} — wrap it with useEffectEvent and remove it from the dep array so the effect doesn't re-synchronize on every parent render`
+						});
+					}
 				}
 			};
+			const propStackTracker = createComponentPropStackTracker({ onComponentEnter: checkComponent });
+			return propStackTracker.visitors;
 		} },
+		"prefer-useReducer": preferUseReducer,
+		"prefer-use-sync-external-store": preferUseSyncExternalStore,
+		"rerender-lazy-state-init": rerenderLazyStateInit,
+		"rerender-functional-setstate": rerenderFunctionalSetstate,
+		"rerender-dependencies": rerenderDependencies,
+		"rerender-state-only-in-handlers": rerenderStateOnlyInHandlers,
+		"rerender-defer-reads-hook": rerenderDeferReadsHook,
 		"advanced-event-handler-refs": advancedEventHandlerRefs,
+		"effect-needs-cleanup": effectNeedsCleanup,
 		"no-generic-handler-names": noGenericHandlerNames,
 		"no-giant-component": noGiantComponent,
 		"no-many-boolean-props": noManyBooleanProps,
@@ -4869,6 +6546,10 @@ const plugin = {
 		"no-render-in-render": noRenderInRender,
 		"no-nested-component-definition": noNestedComponentDefinition,
 		"react-compiler-destructure-method": reactCompilerDestructureMethod,
+		"no-legacy-class-lifecycles": noLegacyClassLifecycles,
+		"no-legacy-context-api": noLegacyContextApi,
+		"no-default-props": noDefaultProps,
+		"no-react-dom-deprecated-apis": noReactDomDeprecatedApis,
 		"no-usememo-simple-expression": noUsememoSimpleExpression,
 		"no-layout-property-animation": noLayoutPropertyAnimation,
 		"rerender-memo-with-default-value": rerenderMemoWithDefaultValue,
@@ -4903,6 +6584,7 @@ const plugin = {
 		"rendering-conditional-render": renderingConditionalRender,
 		"rendering-svg-precision": renderingSvgPrecision,
 		"no-prevent-default": noPreventDefault,
+		"no-uncontrolled-input": noUncontrolledInput,
 		"no-document-start-view-transition": { create: (context) => ({ CallExpression(node) {
 			const callee = node.callee;
 			if (callee?.type !== "MemberExpression") return;
@@ -5021,7 +6703,15 @@ const plugin = {
 		"no-layout-transition-inline": noLayoutTransitionInline,
 		"no-disabled-zoom": noDisabledZoom,
 		"no-outline-none": noOutlineNone,
-		"no-long-transition-duration": noLongTransitionDuration
+		"no-long-transition-duration": noLongTransitionDuration,
+		"design-no-bold-heading": noBoldHeading,
+		"design-no-redundant-padding-axes": noRedundantPaddingAxes,
+		"design-no-redundant-size-axes": noRedundantSizeAxes,
+		"design-no-space-on-flex-children": noSpaceOnFlexChildren,
+		"design-no-em-dash-in-jsx-text": noEmDashInJsxText,
+		"design-no-three-period-ellipsis": noThreePeriodEllipsis,
+		"design-no-default-tailwind-palette": noDefaultTailwindPalette,
+		"design-no-vague-button-label": noVagueButtonLabel
 	}
 };
 //#endregion