react-doctor 0.0.42 → 0.0.44

package/dist/react-doctor-plugin.js

@@ -44,11 +44,20 @@ const HEAVY_LIBRARIES = new Set([
 	"@toast-ui/editor",
 	"draft-js"
 ]);
-const FETCH_CALLEE_NAMES = new Set(["fetch"]);
+const FETCH_CALLEE_NAMES = new Set([
+	"fetch",
+	"ky",
+	"got",
+	"wretch",
+	"ofetch"
+]);
 const FETCH_MEMBER_OBJECTS = new Set([
 	"axios",
 	"ky",
-	"got"
+	"got",
+	"ofetch",
+	"wretch",
+	"request"
 ]);
 const INDEX_PARAMETER_NAMES = new Set([
 	"index",
@@ -161,6 +170,7 @@ const SECRET_FALSE_POSITIVE_SUFFIXES = new Set([
 	"schema",
 	"constant"
 ]);
+const LOADING_STATE_PATTERN = /^(?:isLoading|isPending)$/;
 const TANSTACK_ROUTE_FILE_PATTERN = /\/routes\//;
 const TANSTACK_ROOT_ROUTE_FILE_PATTERN = /__root\.(tsx?|jsx?)$/;
 const TANSTACK_ROUTE_PROPERTY_ORDER = [
@@ -203,12 +213,29 @@ const TANSTACK_QUERY_HOOKS = new Set([
 	"useSuspenseInfiniteQuery"
 ]);
 const TANSTACK_MUTATION_HOOKS = new Set(["useMutation"]);
+const QUERY_CACHE_UPDATE_METHODS = new Set([
+	"invalidateQueries",
+	"setQueryData",
+	"setQueriesData",
+	"resetQueries",
+	"refetchQueries",
+	"removeQueries",
+	"cancelQueries",
+	"clear"
+]);
 const STABLE_HOOK_WRAPPERS = new Set([
 	"useState",
 	"useMemo",
 	"useRef"
 ]);
 const SCRIPT_LOADING_ATTRIBUTES = new Set(["defer", "async"]);
+const GENERIC_EVENT_SUFFIXES = new Set([
+	"Click",
+	"Change",
+	"Input",
+	"Blur",
+	"Focus"
+]);
 const TRIVIAL_INITIALIZER_NAMES = new Set([
 	"Boolean",
 	"String",
@@ -286,7 +313,7 @@ const CHAINABLE_ITERATION_METHODS = new Set([
 	"forEach",
 	"flatMap"
 ]);
-const STORAGE_OBJECTS = new Set(["localStorage", "sessionStorage"]);
+const STORAGE_OBJECTS$1 = new Set(["localStorage", "sessionStorage"]);
 const BLUR_VALUE_PATTERN = /blur\((\d+(?:\.\d+)?)px\)/;
 const ANIMATION_CALLBACK_NAMES = new Set(["requestAnimationFrame", "setInterval"]);
 const REACT_NATIVE_TEXT_COMPONENTS = new Set([
@@ -362,7 +389,7 @@ const LONG_TRANSITION_DURATION_THRESHOLD_MS = 1e3;
 //#region src/plugin/helpers.ts
 const walkAst = (node, visitor) => {
 	if (!node || typeof node !== "object") return;
-	visitor(node);
+	if (visitor(node) === false) return;
 	for (const key of Object.keys(node)) {
 		if (key === "parent") continue;
 		const child = node[key];
@@ -464,12 +491,13 @@ const isMutatingDbCall = (node) => {
 	const { property } = node.callee;
 	return property?.type === "Identifier" && MUTATION_METHOD_NAMES.has(property.name);
 };
+const isMutatingMethodProperty = (property) => property.type === "Property" && property.key?.type === "Identifier" && property.key.name === "method" && property.value?.type === "Literal" && typeof property.value.value === "string" && MUTATING_HTTP_METHODS.has(property.value.value.toUpperCase());
 const isMutatingFetchCall = (node) => {
 	if (node.type !== "CallExpression") return false;
 	if (node.callee?.type !== "Identifier" || node.callee.name !== "fetch") return false;
 	const optionsArgument = node.arguments?.[1];
 	if (!optionsArgument || optionsArgument.type !== "ObjectExpression") return false;
-	return optionsArgument.properties?.some((property) => property.type === "Property" && property.key?.type === "Identifier" && property.key.name === "method" && property.value?.type === "Literal" && typeof property.value.value === "string" && MUTATING_HTTP_METHODS.has(property.value.value.toUpperCase()));
+	return Boolean(optionsArgument.properties?.some(isMutatingMethodProperty));
 };
 const findSideEffect = (node) => {
 	let sideEffectDescription = null;
@@ -477,7 +505,7 @@ const findSideEffect = (node) => {
 		if (sideEffectDescription) return;
 		if (isCookiesOrHeadersCall(child, "cookies")) sideEffectDescription = `cookies().${child.callee.property.name}()`;
 		else if (isCookiesOrHeadersCall(child, "headers")) sideEffectDescription = `headers().${child.callee.property.name}()`;
-		else if (isMutatingFetchCall(child)) sideEffectDescription = `fetch() with method ${child.arguments[1].properties.find((property) => property.key?.type === "Identifier" && property.key.name === "method").value.value}`;
+		else if (isMutatingFetchCall(child)) sideEffectDescription = `fetch() with method ${child.arguments[1].properties.find(isMutatingMethodProperty).value.value}`;
 		else if (isMutatingDbCall(child)) {
 			const methodName = child.callee.property.name;
 			const objectName = child.callee.object?.type === "Identifier" ? child.callee.object.name : null;
@@ -486,15 +514,51 @@ const findSideEffect = (node) => {
 	});
 	return sideEffectDescription;
 };
+const collectPatternNames = (pattern, into) => {
+	if (!pattern) return;
+	if (pattern.type === "Identifier") {
+		into.add(pattern.name);
+		return;
+	}
+	if (pattern.type === "AssignmentPattern") {
+		collectPatternNames(pattern.left, into);
+		return;
+	}
+	if (pattern.type === "RestElement") {
+		collectPatternNames(pattern.argument, into);
+		return;
+	}
+	if (pattern.type === "ArrayPattern") {
+		for (const element of pattern.elements ?? []) collectPatternNames(element, into);
+		return;
+	}
+	if (pattern.type === "ObjectPattern") for (const property of pattern.properties ?? []) {
+		if (property.type === "RestElement") {
+			collectPatternNames(property.argument, into);
+			continue;
+		}
+		if (property.type === "Property") collectPatternNames(property.value, into);
+	}
+};
 const extractDestructuredPropNames = (params) => {
 	const propNames = /* @__PURE__ */ new Set();
-	for (const param of params) if (param.type === "ObjectPattern") {
-		for (const property of param.properties ?? []) if (property.type === "Property" && property.key?.type === "Identifier") propNames.add(property.key.name);
-	} else if (param.type === "Identifier") propNames.add(param.name);
+	for (const param of params) collectPatternNames(param, propNames);
 	return propNames;
 };
 //#endregion
 //#region src/plugin/rules/architecture.ts
+const noGenericHandlerNames = { create: (context) => ({ JSXAttribute(node) {
+	if (node.name?.type !== "JSXIdentifier" || !node.name.name.startsWith("on")) return;
+	if (!node.value || node.value.type !== "JSXExpressionContainer") return;
+	const eventSuffix = node.name.name.slice(2);
+	if (!GENERIC_EVENT_SUFFIXES.has(eventSuffix)) return;
+	const mirroredHandlerName = `handle${eventSuffix}`;
+	const expression = node.value.expression;
+	if (expression?.type === "Identifier" && expression.name === mirroredHandlerName) context.report({
+		node,
+		message: `Non-descriptive handler name "${expression.name}" — name should describe what it does, not when it runs`
+	});
+} }) };
 const noGiantComponent = { create: (context) => {
 	const reportOversizedComponent = (nameNode, componentName, bodyNode) => {
 		if (!bodyNode.loc) return;
@@ -553,6 +617,193 @@ const noNestedComponentDefinition = { create: (context) => {
 		}
 	};
 } };
+const BOOLEAN_PROP_PREFIX_PATTERN = /^(?:is|has|should|can|show|hide|enable|disable|with)[A-Z]/;
+const collectBooleanLikePropsFromBody = (componentBody, propsParamName) => {
+	const found = /* @__PURE__ */ new Set();
+	if (!componentBody) return found;
+	walkAst(componentBody, (child) => {
+		if (child.type !== "MemberExpression") return;
+		if (child.computed) return;
+		if (child.object?.type !== "Identifier") return;
+		if (child.object.name !== propsParamName) return;
+		if (child.property?.type !== "Identifier") return;
+		if (!BOOLEAN_PROP_PREFIX_PATTERN.test(child.property.name)) return;
+		found.add(child.property.name);
+	});
+	return found;
+};
+const noManyBooleanProps = { create: (context) => {
+	const reportIfMany = (booleanLikePropNames, componentName, reportNode) => {
+		if (booleanLikePropNames.length >= 4) context.report({
+			node: reportNode,
+			message: `Component "${componentName}" takes ${booleanLikePropNames.length} boolean-like props (${booleanLikePropNames.slice(0, 3).join(", ")}…) — consider compound components or explicit variants instead of stacking flags`
+		});
+	};
+	const checkComponent = (param, body, componentName, reportNode) => {
+		if (!param) return;
+		if (param.type === "ObjectPattern") {
+			const booleanLikePropNames = [];
+			for (const property of param.properties ?? []) {
+				if (property.type !== "Property") continue;
+				const keyName = property.key?.type === "Identifier" ? property.key.name : null;
+				if (!keyName) continue;
+				if (BOOLEAN_PROP_PREFIX_PATTERN.test(keyName)) booleanLikePropNames.push(keyName);
+			}
+			reportIfMany(booleanLikePropNames, componentName, reportNode);
+			return;
+		}
+		if (param.type === "Identifier") reportIfMany([...collectBooleanLikePropsFromBody(body, param.name)], componentName, reportNode);
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!isComponentDeclaration(node)) return;
+			checkComponent(node.params?.[0], node.body, node.id.name, node.id);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			checkComponent(node.init?.params?.[0], node.init?.body, node.id.name, node.id);
+		}
+	};
+} };
+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();
+	return {
+		ImportDeclaration(node) {
+			if (node.source?.value !== "react") 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];
+					if (message) context.report({
+						node: specifier,
+						message
+					});
+					continue;
+				}
+				if (specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") {
+					const localName = specifier.local?.name;
+					if (localName) reactNamespaceBindings.add(localName);
+				}
+			}
+		},
+		MemberExpression(node) {
+			if (reactNamespaceBindings.size === 0) return;
+			if (node.computed) return;
+			if (node.object?.type !== "Identifier") return;
+			if (!reactNamespaceBindings.has(node.object.name)) return;
+			if (node.property?.type !== "Identifier") return;
+			const message = REACT_19_DEPRECATED_MESSAGES[node.property.name];
+			if (message) context.report({
+				node,
+				message
+			});
+		}
+	};
+} };
+const RENDER_PROP_PATTERN = /^render[A-Z]/;
+const noRenderPropChildren = { create: (context) => ({ JSXOpeningElement(node) {
+	const renderPropAttrs = [];
+	for (const attr of node.attributes ?? []) {
+		if (attr.type !== "JSXAttribute") continue;
+		if (attr.name?.type !== "JSXIdentifier") continue;
+		const name = attr.name.name;
+		if (!RENDER_PROP_PATTERN.test(name)) continue;
+		renderPropAttrs.push({
+			name,
+			node: attr
+		});
+	}
+	if (renderPropAttrs.length < 3) return;
+	const propList = renderPropAttrs.slice(0, 3).map((entry) => entry.name).join(", ");
+	context.report({
+		node: renderPropAttrs[0].node,
+		message: `${renderPropAttrs.length} render-prop slots on the same element (${propList}…) — collapse into compound subcomponents or \`children\` so consumers don't need to know about every customization point`
+	});
+} }) };
+const HOOK_OBJECTS_WITH_METHODS = new Map([
+	["useRouter", new Set([
+		"push",
+		"replace",
+		"back",
+		"forward",
+		"refresh",
+		"prefetch"
+	])],
+	["useNavigation", new Set([
+		"navigate",
+		"push",
+		"goBack",
+		"popToTop",
+		"reset",
+		"replace",
+		"dispatch"
+	])],
+	["useSearchParams", new Set([
+		"get",
+		"getAll",
+		"has",
+		"set"
+	])]
+]);
+const buildHookBindingMap = (componentBody) => {
+	const result = /* @__PURE__ */ new Map();
+	if (componentBody?.type !== "BlockStatement") return result;
+	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;
+			const callee = declarator.init.callee;
+			if (callee?.type !== "Identifier") continue;
+			result.set(declarator.id.name, callee.name);
+		}
+	}
+	return result;
+};
+const reactCompilerDestructureMethod = { create: (context) => {
+	const hookBindingMapStack = [];
+	const isComponent = (node) => {
+		if (node.type === "FunctionDeclaration") return Boolean(node.id?.name && isUppercaseName(node.id.name));
+		if (node.type === "VariableDeclarator") return isComponentAssignment(node);
+		return false;
+	};
+	const enter = (node) => {
+		if (!isComponent(node)) return;
+		const body = node.type === "FunctionDeclaration" ? node.body : node.init?.body;
+		hookBindingMapStack.push(buildHookBindingMap(body));
+	};
+	const exit = (node) => {
+		if (isComponent(node)) hookBindingMapStack.pop();
+	};
+	return {
+		FunctionDeclaration: enter,
+		"FunctionDeclaration:exit": exit,
+		VariableDeclarator: enter,
+		"VariableDeclarator:exit": exit,
+		MemberExpression(node) {
+			if (hookBindingMapStack.length === 0) return;
+			if (node.computed) return;
+			if (node.object?.type !== "Identifier") return;
+			if (node.property?.type !== "Identifier") return;
+			const bindingName = node.object.name;
+			const methodName = node.property.name;
+			const hookSource = hookBindingMapStack[hookBindingMapStack.length - 1].get(bindingName);
+			if (!hookSource) return;
+			const allowedMethods = HOOK_OBJECTS_WITH_METHODS.get(hookSource);
+			if (!allowedMethods || !allowedMethods.has(methodName)) return;
+			if (node.parent?.type !== "CallExpression" || node.parent.callee !== node) return;
+			context.report({
+				node,
+				message: `Destructure for clarity: \`const { ${methodName} } = ${hookSource}()\` then call \`${methodName}(...)\` directly — easier for React Compiler to memoize and clearer about which methods this component depends on`
+			});
+		}
+	};
+} };
 //#endregion
 //#region src/plugin/rules/bundle-size.ts
 const noBarrelImport = { create: (context) => {
@@ -598,6 +849,38 @@ const useLazyMotion = { create: (context) => ({ ImportDeclaration(node) {
 		message: "Import \"m\" with LazyMotion instead of \"motion\" — saves ~30kb in bundle size"
 	});
 } }) };
+const noDynamicImportPath = { create: (context) => ({
+	ImportExpression(node) {
+		const source = node.source;
+		if (source && source.type !== "Literal" && source.type !== "TemplateLiteral") {
+			context.report({
+				node,
+				message: "Dynamic import path is not statically analyzable — use a string literal so the bundler can split this chunk"
+			});
+			return;
+		}
+		if (source?.type === "TemplateLiteral" && (source.expressions?.length ?? 0) > 0) context.report({
+			node,
+			message: "Template literal with interpolation in dynamic import — use a string literal so the bundler can split this chunk"
+		});
+	},
+	CallExpression(node) {
+		if (node.callee?.type !== "Identifier" || node.callee.name !== "require") return;
+		const arg = node.arguments?.[0];
+		if (!arg) return;
+		if (arg.type !== "Literal" && arg.type !== "TemplateLiteral") {
+			context.report({
+				node,
+				message: "Dynamic require() path is not statically analyzable — use a string literal so the bundler can trace this dependency"
+			});
+			return;
+		}
+		if (arg.type === "TemplateLiteral" && (arg.expressions?.length ?? 0) > 0) context.report({
+			node,
+			message: "Template literal with interpolation in require() — use a string literal so the bundler can trace this dependency"
+		});
+	}
+}) };
 const noUndeferredThirdParty = { create: (context) => ({ JSXOpeningElement(node) {
 	if (node.name?.type !== "JSXIdentifier" || node.name.name !== "script") return;
 	const attributes = node.attributes ?? [];
@@ -611,7 +894,7 @@ const noUndeferredThirdParty = { create: (context) => ({ JSXOpeningElement(node)
 //#region src/plugin/rules/client.ts
 const clientPassiveEventListeners = { create: (context) => ({ CallExpression(node) {
 	if (!isMemberProperty(node.callee, "addEventListener")) return;
-	if (node.arguments?.length < 2) return;
+	if ((node.arguments?.length ?? 0) < 2) return;
 	const eventNameNode = node.arguments[0];
 	if (eventNameNode.type !== "Literal" || !PASSIVE_EVENT_NAMES.has(eventNameNode.value)) return;
 	const eventName = eventNameNode.value;
@@ -619,14 +902,43 @@ const clientPassiveEventListeners = { create: (context) => ({ CallExpression(nod
 	if (!optionsArgument) {
 		context.report({
 			node,
-			message: `"${eventName}" listener without { passive: true } — blocks scrolling performance`
+			message: `"${eventName}" listener without { passive: true } — blocks scrolling performance. Only add { passive: true } if the handler does NOT call event.preventDefault() (passive listeners silently ignore preventDefault())`
 		});
 		return;
 	}
 	if (optionsArgument.type !== "ObjectExpression") return;
 	if (!optionsArgument.properties?.some((property) => property.type === "Property" && property.key?.type === "Identifier" && property.key.name === "passive" && property.value?.type === "Literal" && property.value.value === true)) context.report({
 		node,
-		message: `"${eventName}" listener without { passive: true } — blocks scrolling performance`
+		message: `"${eventName}" listener without { passive: true } — blocks scrolling performance. Only add { passive: true } if the handler does NOT call event.preventDefault() (passive listeners silently ignore preventDefault())`
+	});
+} }) };
+const VERSIONED_KEY_PATTERN = /(?:[._:-]v\d+|@\d+|\bv\d+\b)/i;
+const STORAGE_OBJECTS = new Set(["localStorage", "sessionStorage"]);
+const isJsonStringifyCall = (node) => {
+	if (node.type !== "CallExpression") return false;
+	if (node.callee?.type !== "MemberExpression") return false;
+	if (node.callee.object?.type !== "Identifier") return false;
+	if (node.callee.object.name !== "JSON") return false;
+	if (node.callee.property?.type !== "Identifier") return false;
+	return node.callee.property.name === "stringify";
+};
+const clientLocalstorageNoVersion = { create: (context) => ({ CallExpression(node) {
+	if (node.callee?.type !== "MemberExpression") return;
+	if (node.callee.object?.type !== "Identifier") return;
+	if (!STORAGE_OBJECTS.has(node.callee.object.name)) return;
+	if (node.callee.property?.type !== "Identifier") return;
+	if (node.callee.property.name !== "setItem") return;
+	const keyArg = node.arguments?.[0];
+	if (!keyArg) return;
+	if (keyArg.type !== "Literal") return;
+	if (typeof keyArg.value !== "string") return;
+	if (VERSIONED_KEY_PATTERN.test(keyArg.value)) return;
+	const valueArg = node.arguments?.[1];
+	if (!valueArg) return;
+	if (!isJsonStringifyCall(valueArg)) return;
+	context.report({
+		node: keyArg,
+		message: `${node.callee.object.name}.setItem("${keyArg.value}", JSON.stringify(...)) — bake a version into the key (e.g. "${keyArg.value}:v1") so a future schema change can ignore old data instead of crashing on it`
 	});
 } }) };
 //#endregion
@@ -675,12 +987,24 @@ const getStylePropertyKey = (property) => {
 };
 const parseColorToRgb = (value) => {
 	const trimmed = value.trim().toLowerCase();
+	const hex8Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})[0-9a-f]{2}$/);
+	if (hex8Match) return {
+		red: parseInt(hex8Match[1], 16),
+		green: parseInt(hex8Match[2], 16),
+		blue: parseInt(hex8Match[3], 16)
+	};
 	const hex6Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/);
 	if (hex6Match) return {
 		red: parseInt(hex6Match[1], 16),
 		green: parseInt(hex6Match[2], 16),
 		blue: parseInt(hex6Match[3], 16)
 	};
+	const hex4Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])[0-9a-f]$/);
+	if (hex4Match) return {
+		red: parseInt(hex4Match[1] + hex4Match[1], 16),
+		green: parseInt(hex4Match[2] + hex4Match[2], 16),
+		blue: parseInt(hex4Match[3] + hex4Match[3], 16)
+	};
 	const hex3Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/);
 	if (hex3Match) return {
 		red: parseInt(hex3Match[1] + hex3Match[1], 16),
@@ -1145,6 +1469,7 @@ const noLongTransitionDuration = { create: (context) => ({ JSXAttribute(node) {
 } }) };
 //#endregion
 //#region src/plugin/rules/correctness.ts
+const STRING_COERCION_FUNCTIONS = new Set(["String", "Number"]);
 const extractIndexName = (node) => {
 	if (node.type === "Identifier" && INDEX_PARAMETER_NAMES.has(node.name)) return node.name;
 	if (node.type === "TemplateLiteral") {
@@ -1152,7 +1477,8 @@ const extractIndexName = (node) => {
 		if (indexExpression) return indexExpression.name;
 	}
 	if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && INDEX_PARAMETER_NAMES.has(node.callee.object.name) && node.callee.property?.type === "Identifier" && node.callee.property.name === "toString") return node.callee.object.name;
-	if (node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "String" && node.arguments?.[0]?.type === "Identifier" && INDEX_PARAMETER_NAMES.has(node.arguments[0].name)) return node.arguments[0].name;
+	if (node.type === "CallExpression" && node.callee?.type === "Identifier" && STRING_COERCION_FUNCTIONS.has(node.callee.name) && node.arguments?.[0]?.type === "Identifier" && INDEX_PARAMETER_NAMES.has(node.arguments[0].name)) return node.arguments[0].name;
+	if (node.type === "BinaryExpression" && node.operator === "+" && (node.left?.type === "Identifier" && INDEX_PARAMETER_NAMES.has(node.left.name) && node.right?.type === "Literal" && node.right.value === "" || node.right?.type === "Identifier" && INDEX_PARAMETER_NAMES.has(node.right.name) && node.left?.type === "Literal" && node.left.value === "")) return node.left?.type === "Identifier" ? node.left.name : node.right.name;
 	return null;
 };
 const isInsideStaticPlaceholderMap = (node) => {
@@ -1182,8 +1508,8 @@ const noArrayIndexAsKey = { create: (context) => ({ JSXAttribute(node) {
 	});
 } }) };
 const PREVENT_DEFAULT_ELEMENTS = {
-	form: "onSubmit",
-	a: "onClick"
+	form: ["onSubmit"],
+	a: ["onClick"]
 };
 const containsPreventDefaultCall = (node) => {
 	let didFindPreventDefault = false;
@@ -1193,28 +1519,84 @@ const containsPreventDefaultCall = (node) => {
 	});
 	return didFindPreventDefault;
 };
+const buildPreventDefaultMessage = (elementName) => {
+	if (elementName === "form") return "preventDefault() on <form> onSubmit — form won't work without JavaScript. Consider using a server action for progressive enhancement";
+	return "preventDefault() on <a> onClick — use a <button> or routing component instead";
+};
 const noPreventDefault = { create: (context) => ({ JSXOpeningElement(node) {
 	const elementName = node.name?.type === "JSXIdentifier" ? node.name.name : null;
 	if (!elementName) return;
-	const targetEventProp = PREVENT_DEFAULT_ELEMENTS[elementName];
-	if (!targetEventProp) return;
-	const eventAttribute = findJsxAttribute(node.attributes ?? [], targetEventProp);
-	if (!eventAttribute?.value || eventAttribute.value.type !== "JSXExpressionContainer") return;
-	const expression = eventAttribute.value.expression;
-	if (expression?.type !== "ArrowFunctionExpression" && expression?.type !== "FunctionExpression") return;
-	if (!containsPreventDefaultCall(expression)) return;
-	const message = elementName === "form" ? "preventDefault() on <form> onSubmit — form won't work without JavaScript. Consider using a server action for progressive enhancement" : "preventDefault() on <a> onClick — use a <button> or routing component instead";
-	context.report({
-		node,
-		message
-	});
+	const targetEventProps = PREVENT_DEFAULT_ELEMENTS[elementName];
+	if (!targetEventProps) return;
+	for (const targetEventProp of targetEventProps) {
+		const eventAttribute = findJsxAttribute(node.attributes ?? [], targetEventProp);
+		if (!eventAttribute?.value || eventAttribute.value.type !== "JSXExpressionContainer") continue;
+		const expression = eventAttribute.value.expression;
+		if (expression?.type !== "ArrowFunctionExpression" && expression?.type !== "FunctionExpression") continue;
+		if (!containsPreventDefaultCall(expression)) continue;
+		context.report({
+			node,
+			message: buildPreventDefaultMessage(elementName)
+		});
+		return;
+	}
 } }) };
+const NUMERIC_NAME_HINTS = [
+	"count",
+	"length",
+	"total",
+	"size",
+	"num"
+];
+const isNumericName = (name) => {
+	for (const hint of NUMERIC_NAME_HINTS) {
+		if (name === hint) return true;
+		const camelSuffix = hint.charAt(0).toUpperCase() + hint.slice(1);
+		if (name.endsWith(camelSuffix)) return true;
+		if (name.endsWith(`_${hint}`)) return true;
+		if (name.endsWith(`_${hint.toUpperCase()}`)) return true;
+	}
+	return false;
+};
 const renderingConditionalRender = { create: (context) => ({ LogicalExpression(node) {
 	if (node.operator !== "&&") return;
 	if (!(node.right?.type === "JSXElement" || node.right?.type === "JSXFragment")) return;
-	if (node.left?.type === "MemberExpression" && node.left.property?.type === "Identifier" && node.left.property.name === "length") context.report({
+	const left = node.left;
+	if (!left) return;
+	const isLengthMemberAccess = left.type === "MemberExpression" && left.property?.type === "Identifier" && left.property.name === "length";
+	const isNumericIdentifier = left.type === "Identifier" && isNumericName(left.name);
+	if (isLengthMemberAccess || isNumericIdentifier) context.report({
+		node,
+		message: "Conditional rendering with a numeric value can render '0' — use `value > 0`, `Boolean(value)`, or a ternary"
+	});
+} }) };
+const noPolymorphicChildren = { create: (context) => ({ BinaryExpression(node) {
+	if (node.operator !== "===" && node.operator !== "==") return;
+	const isTypeofChildren = (operand) => operand?.type === "UnaryExpression" && operand.operator === "typeof" && operand.argument?.type === "Identifier" && operand.argument.name === "children";
+	if (!isTypeofChildren(node.left) && !isTypeofChildren(node.right)) return;
+	const isStringLiteral = (operand) => operand?.type === "Literal" && operand.value === "string";
+	if (!isStringLiteral(node.left) && !isStringLiteral(node.right)) return;
+	context.report({
+		node,
+		message: "Polymorphic `typeof children === \"string\"` check — expose explicit subcomponents (e.g. `<Button.Text>`) instead of branching on what the consumer passed"
+	});
+} }) };
+const SVG_PATH_HIGH_PRECISION_PATTERN = /\d+\.\d{4,}/;
+const SVG_PATH_ATTRIBUTES = new Set([
+	"d",
+	"points",
+	"transform"
+]);
+const renderingSvgPrecision = { create: (context) => ({ JSXAttribute(node) {
+	if (node.name?.type !== "JSXIdentifier") return;
+	if (!SVG_PATH_ATTRIBUTES.has(node.name.name)) return;
+	if (node.value?.type !== "Literal") return;
+	const value = node.value.value;
+	if (typeof value !== "string") return;
+	if (!SVG_PATH_HIGH_PRECISION_PATTERN.test(value)) return;
+	context.report({
 		node,
-		message: "Conditional rendering with .length can render '0' — use .length > 0 or Boolean(.length)"
+		message: `SVG ${node.name.name} attribute uses 4+ decimal precision — truncate to 1–2 decimals to shrink markup with no visible difference`
 	});
 } }) };
 //#endregion
@@ -1294,7 +1676,7 @@ const jsCacheStorage = { create: (context) => {
 	const storageReadCounts = /* @__PURE__ */ new Map();
 	return { CallExpression(node) {
 		if (!isMemberProperty(node.callee, "getItem")) return;
-		if (node.callee.object?.type !== "Identifier" || !STORAGE_OBJECTS.has(node.callee.object.name)) return;
+		if (node.callee.object?.type !== "Identifier" || !STORAGE_OBJECTS$1.has(node.callee.object.name)) return;
 		if (node.arguments?.[0]?.type !== "Literal") return;
 		const storageKey = String(node.arguments[0].value);
 		const readCount = (storageReadCounts.get(storageKey) ?? 0) + 1;
@@ -1371,6 +1753,193 @@ const jsFlatmapFilter = { create: (context) => ({ CallExpression(node) {
 		message: ".map().filter(Boolean) iterates twice — use .flatMap() to transform and filter in a single pass"
 	});
 } }) };
+const buildMemberAccessKey = (node) => {
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "ThisExpression") return "this";
+	if (node.type !== "MemberExpression" || node.computed) return null;
+	const objectKey = buildMemberAccessKey(node.object);
+	if (!objectKey) return null;
+	if (node.property?.type !== "Identifier") return null;
+	return `${objectKey}.${node.property.name}`;
+};
+const jsCachePropertyAccess = { create: (context) => {
+	const inspectLoopBody = (loopBody) => {
+		const counts = /* @__PURE__ */ new Map();
+		walkAst(loopBody, (child) => {
+			if (child.type !== "MemberExpression") return;
+			if (child.computed) return;
+			if (child.parent?.type === "MemberExpression" && child.parent.object === child) return;
+			const key = buildMemberAccessKey(child);
+			if (!key) return;
+			if (key.split(".").length < 3) return;
+			const existing = counts.get(key);
+			if (existing) existing.count++;
+			else counts.set(key, {
+				count: 1,
+				firstNode: child
+			});
+		});
+		for (const [key, { count, firstNode }] of counts) if (count >= 3) context.report({
+			node: firstNode,
+			message: `${key} is read ${count} times inside this loop — hoist into a const at the top of the loop body`
+		});
+	};
+	const handleLoop = (node) => {
+		if (node.body) inspectLoopBody(node.body);
+	};
+	return {
+		ForStatement: handleLoop,
+		ForInStatement: handleLoop,
+		ForOfStatement: handleLoop,
+		WhileStatement: handleLoop,
+		DoWhileStatement: handleLoop
+	};
+} };
+const jsLengthCheckFirst = { create: (context) => ({ CallExpression(node) {
+	if (node.callee?.type !== "MemberExpression") return;
+	if (node.callee.property?.type !== "Identifier") return;
+	if (node.callee.property.name !== "every") return;
+	const callback = node.arguments?.[0];
+	if (callback?.type !== "ArrowFunctionExpression" && callback?.type !== "FunctionExpression") return;
+	const params = callback.params ?? [];
+	if (params.length < 2) return;
+	let referencesOtherArrayByIndex = false;
+	walkAst(callback.body, (child) => {
+		if (referencesOtherArrayByIndex) return;
+		if (child.type === "MemberExpression" && child.computed && child.property?.type === "Identifier" && params[1]?.type === "Identifier" && child.property.name === params[1].name) referencesOtherArrayByIndex = true;
+	});
+	if (!referencesOtherArrayByIndex) return;
+	let guard = node.parent ?? null;
+	while (guard && guard.type !== "LogicalExpression" && guard.type !== "IfStatement") guard = guard.parent ?? null;
+	if (guard?.type === "LogicalExpression" && guard.operator === "&&") {
+		const left = guard.left;
+		if (left?.type === "BinaryExpression" && left.operator === "===" && (isMemberProperty(left.left, "length") || isMemberProperty(left.right, "length"))) return;
+	}
+	context.report({
+		node,
+		message: ".every() over an array compared to another array — short-circuit with `a.length === b.length && a.every(...)` so unequal-length arrays exit immediately"
+	});
+} }) };
+const INTL_CLASSES = new Set([
+	"NumberFormat",
+	"DateTimeFormat",
+	"Collator",
+	"RelativeTimeFormat",
+	"ListFormat",
+	"PluralRules",
+	"Segmenter",
+	"DisplayNames"
+]);
+const isIntlNewExpression = (node) => {
+	if (node.type !== "NewExpression") return false;
+	const callee = node.callee;
+	if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "Intl" && callee.property?.type === "Identifier" && INTL_CLASSES.has(callee.property.name)) return true;
+	return false;
+};
+const jsHoistIntl = { create: (context) => ({ NewExpression(node) {
+	if (!isIntlNewExpression(node)) return;
+	let cursor = node.parent ?? null;
+	let inFunctionBody = false;
+	while (cursor) {
+		if (cursor.type === "FunctionDeclaration" || cursor.type === "FunctionExpression" || cursor.type === "ArrowFunctionExpression") {
+			inFunctionBody = true;
+			break;
+		}
+		cursor = cursor.parent ?? null;
+	}
+	if (!inFunctionBody) return;
+	const className = node.callee.property?.name ?? "Intl";
+	context.report({
+		node,
+		message: `new Intl.${className}() inside a function — hoist to module scope or wrap in useMemo so it isn't recreated each call`
+	});
+} }) };
+const findFirstAwaitOutsideNestedFunctions = (block) => {
+	let firstAwait = null;
+	walkAst(block, (child) => {
+		if (firstAwait) return false;
+		if (child !== block && (child.type === "FunctionDeclaration" || child.type === "FunctionExpression" || child.type === "ArrowFunctionExpression")) return false;
+		if (child.type === "AwaitExpression") firstAwait = child;
+	});
+	return firstAwait;
+};
+const isFunctionishExpression = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+const ITERATION_METHOD_NAMES_WITH_CALLBACK = new Set([
+	"forEach",
+	"map",
+	"filter",
+	"reduce",
+	"reduceRight",
+	"find",
+	"findIndex",
+	"some",
+	"every",
+	"flatMap"
+]);
+const PROMISE_CONCURRENCY_METHODS = new Set([
+	"all",
+	"allSettled",
+	"race",
+	"any"
+]);
+const isWrappedInPromiseConcurrency = (mapCall) => {
+	const parent = mapCall.parent;
+	if (parent?.type !== "CallExpression") return false;
+	if (parent.arguments?.[0] !== mapCall) return false;
+	const callee = parent.callee;
+	if (callee?.type !== "MemberExpression" || callee.computed) return false;
+	if (callee.object?.type !== "Identifier" || callee.object.name !== "Promise") return false;
+	if (callee.property?.type !== "Identifier") return false;
+	return PROMISE_CONCURRENCY_METHODS.has(callee.property.name);
+};
+const asyncAwaitInLoop = { create: (context) => {
+	const inspectLoopBody = (loopBody, label) => {
+		if (!loopBody) return;
+		const firstAwait = findFirstAwaitOutsideNestedFunctions(loopBody);
+		if (firstAwait) context.report({
+			node: firstAwait,
+			message: `await inside a ${label} runs the calls sequentially — for independent operations, collect them and use \`await Promise.all(items.map(...))\` to run them concurrently`
+		});
+	};
+	return {
+		ForStatement(node) {
+			inspectLoopBody(node.body, "for-loop");
+		},
+		ForInStatement(node) {
+			inspectLoopBody(node.body, "for…in loop");
+		},
+		ForOfStatement(node) {
+			if (node.await) return;
+			inspectLoopBody(node.body, "for…of loop");
+		},
+		WhileStatement(node) {
+			inspectLoopBody(node.body, "while-loop");
+		},
+		DoWhileStatement(node) {
+			inspectLoopBody(node.body, "do-while loop");
+		},
+		CallExpression(node) {
+			if (node.callee?.type !== "MemberExpression") return;
+			if (node.callee.property?.type !== "Identifier") return;
+			const methodName = node.callee.property.name;
+			if (!ITERATION_METHOD_NAMES_WITH_CALLBACK.has(methodName)) return;
+			const callback = node.arguments?.[0];
+			if (!callback || !isFunctionishExpression(callback)) return;
+			if (!callback.async) return;
+			const body = callback.body;
+			if (!body) return;
+			if ((methodName === "map" || methodName === "flatMap") && isWrappedInPromiseConcurrency(node)) return;
+			const firstAwait = findFirstAwaitOutsideNestedFunctions(body);
+			if (firstAwait) {
+				const message = methodName === "forEach" ? "Async callback in .forEach — return values are dropped, so awaits don't actually wait. Use a `for…of` loop or `await Promise.all(items.map(async (item) => {...}))`" : `Async callback in .${methodName} — sequential awaits inside the callback waterfall. Use \`await Promise.all(items.map(async (item) => {...}))\` to run them concurrently`;
+				context.report({
+					node: firstAwait,
+					message
+				});
+			}
+		}
+	};
+} };
 //#endregion
 //#region src/plugin/rules/nextjs.ts
 const nextjsNoImgElement = { create: (context) => {
@@ -1420,13 +1989,39 @@ const nextjsNoAElement = { create: (context) => ({ JSXOpeningElement(node) {
 		message: "Use next/link instead of <a> for internal links — enables client-side navigation and prefetching"
 	});
 } }) };
-const nextjsNoUseSearchParamsWithoutSuspense = { create: (context) => ({ CallExpression(node) {
-	if (!isHookCall(node, "useSearchParams")) return;
-	context.report({
-		node,
-		message: "useSearchParams() requires a <Suspense> boundary — without one, the entire page bails out to client-side rendering"
+const fileMentionsSuspense = (programNode) => {
+	let didSee = false;
+	walkAst(programNode, (child) => {
+		if (didSee) return false;
+		if (child.type === "JSXOpeningElement" && child.name?.type === "JSXIdentifier" && child.name.name === "Suspense") {
+			didSee = true;
+			return false;
+		}
+		if (child.type === "ImportDeclaration" && child.source?.value === "react") {
+			if ((child.specifiers ?? []).some((specifier) => specifier.type === "ImportSpecifier" && specifier.imported?.name === "Suspense")) {
+				didSee = true;
+				return false;
+			}
+		}
 	});
-} }) };
+	return didSee;
+};
+const nextjsNoUseSearchParamsWithoutSuspense = { create: (context) => {
+	let hasSuspenseInFile = false;
+	return {
+		Program(programNode) {
+			hasSuspenseInFile = fileMentionsSuspense(programNode);
+		},
+		CallExpression(node) {
+			if (hasSuspenseInFile) return;
+			if (!isHookCall(node, "useSearchParams")) return;
+			context.report({
+				node,
+				message: "useSearchParams() requires a <Suspense> boundary — without one, the entire page bails out to client-side rendering"
+			});
+		}
+	};
+} };
 const nextjsNoClientFetchForServerData = { create: (context) => {
 	let fileHasUseClient = false;
 	return {
@@ -1600,8 +2195,7 @@ const getExportedGetHandlerBody = (node) => {
 	if (!declaration) return null;
 	if (declaration.type === "FunctionDeclaration" && declaration.id?.name === "GET") return declaration.body;
 	if (declaration.type === "VariableDeclaration") {
-		const declarator = declaration.declarations?.[0];
-		if (declarator?.id?.type === "Identifier" && declarator.id.name === "GET" && declarator.init && (declarator.init.type === "ArrowFunctionExpression" || declarator.init.type === "FunctionExpression")) return declarator.init.body;
+		for (const declarator of declaration.declarations ?? []) if (declarator?.id?.type === "Identifier" && declarator.id.name === "GET" && declarator.init && (declarator.init.type === "ArrowFunctionExpression" || declarator.init.type === "FunctionExpression")) return declarator.init.body;
 	}
 	return null;
 };
@@ -1667,6 +2261,13 @@ const noInlinePropOnMemoComponent = { create: (context) => {
 		}
 	};
 } };
+const isTriviallyCheapExpression = (node) => {
+	if (!node) return false;
+	if (!isSimpleExpression(node)) return false;
+	if (node.type === "Identifier") return false;
+	if (node.type === "MemberExpression") return false;
+	return true;
+};
 const noUsememoSimpleExpression = { create: (context) => ({ CallExpression(node) {
 	if (!isHookCall(node, "useMemo")) return;
 	const callback = node.arguments?.[0];
@@ -1675,7 +2276,7 @@ const noUsememoSimpleExpression = { create: (context) => ({ CallExpression(node)
 	let returnExpression = null;
 	if (callback.body?.type !== "BlockStatement") returnExpression = callback.body;
 	else if (callback.body.body?.length === 1 && callback.body.body[0].type === "ReturnStatement") returnExpression = callback.body.body[0].argument;
-	if (returnExpression && isSimpleExpression(returnExpression)) context.report({
+	if (returnExpression && isTriviallyCheapExpression(returnExpression)) context.report({
 		node,
 		message: "useMemo wrapping a trivially cheap expression — memo overhead exceeds the computation"
 	});
@@ -1822,8 +2423,21 @@ const renderingAnimateSvgWrapper = { create: (context) => ({ JSXOpeningElement(n
 		message: "Animation props directly on <svg> — wrap in a <div> or <motion.div> for better rendering performance"
 	});
 } }) };
+const renderingUsetransitionLoading = { create: (context) => ({ VariableDeclarator(node) {
+	if (node.id?.type !== "ArrayPattern" || !node.id.elements?.length) return;
+	if (!node.init || !isHookCall(node.init, "useState")) return;
+	if (!node.init.arguments?.length) return;
+	const initializer = node.init.arguments[0];
+	if (initializer.type !== "Literal" || initializer.value !== false) return;
+	const stateVariableName = node.id.elements[0]?.name;
+	if (!stateVariableName || !LOADING_STATE_PATTERN.test(stateVariableName)) return;
+	context.report({
+		node: node.init,
+		message: `useState for "${stateVariableName}" — if this guards a state transition (not an async fetch), consider useTransition instead`
+	});
+} }) };
 const renderingHydrationNoFlicker = { create: (context) => ({ CallExpression(node) {
-	if (!isHookCall(node, EFFECT_HOOK_NAMES) || node.arguments?.length < 2) return;
+	if (!isHookCall(node, EFFECT_HOOK_NAMES) || (node.arguments?.length ?? 0) < 2) return;
 	const depsNode = node.arguments[1];
 	if (depsNode.type !== "ArrayExpression" || depsNode.elements?.length !== 0) return;
 	const callback = getEffectCallback(node);
@@ -1849,60 +2463,388 @@ const renderingScriptDeferAsync = { create: (context) => ({ JSXOpeningElement(no
 		message: "<script src> without defer or async — blocks HTML parsing and delays First Contentful Paint. Add defer for DOM-dependent scripts or async for independent ones"
 	});
 } }) };
-//#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 jsxReferencesLocalScope = (jsxNode) => {
+	let referencesScope = false;
+	walkAst(jsxNode, (child) => {
+		if (referencesScope) return;
+		if (child.type === "JSXExpressionContainer" && child.expression?.type !== "JSXEmptyExpression") referencesScope = true;
+		if (child.type === "JSXSpreadAttribute") referencesScope = true;
+	});
+	return referencesScope;
 };
-const rnNoRawText = { create: (context) => {
-	let isDomComponentFile = false;
+const renderingHoistJsx = { create: (context) => {
+	let componentDepth = 0;
+	const isComponentLike = (node) => {
+		if (node.type === "FunctionDeclaration" && node.id?.name && isUppercaseName(node.id.name)) return true;
+		if (node.type === "VariableDeclarator" && isComponentAssignment(node)) return true;
+		return false;
+	};
+	const enter = (node) => {
+		if (isComponentLike(node)) componentDepth++;
+	};
+	const exit = (node) => {
+		if (isComponentLike(node)) componentDepth = Math.max(0, componentDepth - 1);
+	};
 	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;
+		FunctionDeclaration: enter,
+		"FunctionDeclaration:exit": exit,
+		VariableDeclarator: enter,
+		"VariableDeclarator:exit": exit,
+		VariableDeclaration(node) {
+			if (componentDepth === 0) return;
+			if (node.kind !== "const") return;
+			for (const declarator of node.declarations ?? []) {
+				const init = declarator.init;
+				if (!init) continue;
+				if (init.type !== "JSXElement" && init.type !== "JSXFragment") continue;
+				if (jsxReferencesLocalScope(init)) continue;
+				const name = declarator.id?.type === "Identifier" ? declarator.id.name : "<unnamed>";
 				context.report({
-					node: child,
-					message: `Raw ${getRawTextDescription(child)} outside a <Text> component — this will crash on React Native`
+					node: declarator,
+					message: `Static JSX "${name}" inside a component — hoist to module scope so it isn't recreated each render`
 				});
 			}
 		}
 	};
 } };
-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 callbackReturnsJsx = (callback) => {
+	if (!callback) return false;
+	if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") return false;
+	const body = callback.body;
+	if (body?.type === "JSXElement" || body?.type === "JSXFragment") return true;
+	if (body?.type !== "BlockStatement") return false;
+	for (const stmt of body.body ?? []) if (stmt.type === "ReturnStatement" && (stmt.argument?.type === "JSXElement" || stmt.argument?.type === "JSXFragment")) return true;
+	return false;
+};
+const containsEarlyReturn = (ifStatement) => {
+	const consequent = ifStatement.consequent;
+	if (!consequent) return false;
+	if (consequent.type === "ReturnStatement") return true;
+	if (consequent.type !== "BlockStatement") return false;
+	for (const stmt of consequent.body ?? []) if (stmt.type === "ReturnStatement") return true;
+	return false;
+};
+const rerenderMemoBeforeEarlyReturn = { create: (context) => {
+	const inspectFunctionBody = (statements) => {
+		let memoNode = null;
+		for (const stmt of statements) {
+			if (!memoNode) {
+				if (stmt.type !== "VariableDeclaration") continue;
+				for (const declarator of stmt.declarations ?? []) {
+					const init = declarator.init;
+					if (init?.type === "CallExpression" && isHookCall(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0])) {
+						memoNode = declarator;
+						break;
+					}
+				}
+				continue;
+			}
+			if (stmt.type === "IfStatement" && containsEarlyReturn(stmt)) {
+				context.report({
+					node: memoNode,
+					message: "useMemo returning JSX runs before an early return — extract the JSX into a memoized child component so the parent bails out before the subtree renders"
+				});
+				return;
+			}
+		}
+	};
+	return {
+		FunctionDeclaration(node) {
+			if (!isUppercaseName(node.id?.name ?? "")) return;
+			if (node.body?.type !== "BlockStatement") return;
+			inspectFunctionBody(node.body.body ?? []);
+		},
+		VariableDeclarator(node) {
+			if (!isComponentAssignment(node)) return;
+			const body = node.init?.body;
+			if (body?.type !== "BlockStatement") return;
+			inspectFunctionBody(body.body ?? []);
+		}
+	};
+} };
+const NONDETERMINISTIC_RENDER_PATTERNS = [
+	{
+		display: "new Date()",
+		matches: (n) => n.type === "NewExpression" && n.callee?.type === "Identifier" && n.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"
+	},
+	{
+		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"
+	},
+	{
+		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"
+	},
+	{
+		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"
+	}
+];
+const findOpeningElementOfChild = (jsxNode) => {
+	let cursor = jsxNode.parent ?? null;
+	while (cursor) {
+		if (cursor.type === "JSXElement") return cursor.openingElement;
+		if (cursor.type === "JSXFragment") return null;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+const hasSuppressHydrationWarningAttribute = (openingElement) => {
+	if (!openingElement) return false;
+	for (const attr of openingElement.attributes ?? []) if (attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "suppressHydrationWarning") return true;
+	return false;
+};
+const HIGH_FREQUENCY_DOM_EVENTS = new Set([
+	"scroll",
+	"mousemove",
+	"wheel",
+	"pointermove",
+	"touchmove",
+	"drag"
+]);
+const isAddEventListenerCall = (node) => {
+	if (node.type !== "CallExpression") return false;
+	if (node.callee?.type !== "MemberExpression") return false;
+	if (node.callee.property?.type !== "Identifier") return false;
+	if (node.callee.property.name !== "addEventListener") return false;
+	return true;
+};
+const handlerCallsSetState = (handler) => {
+	if (handler.type !== "ArrowFunctionExpression" && handler.type !== "FunctionExpression") return null;
+	let setStateCall = null;
+	walkAst(handler.body, (child) => {
+		if (setStateCall) return;
+		if (child.type === "CallExpression" && child.callee?.type === "Identifier" && /^set[A-Z]/.test(child.callee.name)) setStateCall = child;
+	});
+	return setStateCall;
+};
+const rerenderTransitionsScroll = { create: (context) => ({ CallExpression(node) {
+	if (!isAddEventListenerCall(node)) return;
+	const eventArg = node.arguments?.[0];
+	if (eventArg?.type !== "Literal") return;
+	const eventName = eventArg.value;
+	if (typeof eventName !== "string" || !HIGH_FREQUENCY_DOM_EVENTS.has(eventName)) return;
+	const handler = node.arguments?.[1];
+	if (!handler) return;
+	const setStateCall = handlerCallsSetState(handler);
+	if (!setStateCall) return;
+	let cursor = setStateCall.parent ?? null;
+	while (cursor && cursor !== handler) {
+		if (cursor.type === "CallExpression" && cursor.callee?.type === "Identifier" && (cursor.callee.name === "startTransition" || cursor.callee.name === "requestAnimationFrame" || cursor.callee.name === "requestIdleCallback")) return;
+		cursor = cursor.parent ?? null;
+	}
+	context.report({
+		node: setStateCall,
+		message: `setState in a "${eventName}" handler triggers re-renders at scroll/pointer frequency — wrap in startTransition (mark as non-urgent), use useDeferredValue, or stash in a ref + rAF throttle`
+	});
+} }) };
+const renderingHydrationMismatchTime = { create: (context) => ({ JSXExpressionContainer(node) {
+	if (!node.expression) return;
+	const matched = NONDETERMINISTIC_RENDER_PATTERNS.find((pattern) => pattern.matches(node.expression));
+	if (matched) {
+		if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
+		context.report({
+			node,
+			message: `${matched.display} in JSX renders differently on server vs client — wrap in useEffect+useState (client-only) or add suppressHydrationWarning to the parent if intentional`
+		});
+		return;
+	}
+	walkAst(node.expression, (child) => {
+		for (const pattern of NONDETERMINISTIC_RENDER_PATTERNS) if (pattern.matches(child)) {
+			if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
+			context.report({
+				node: child,
+				message: `${pattern.display} reachable from JSX renders differently on server vs client — wrap in useEffect+useState (client-only) or add suppressHydrationWarning to the parent if intentional`
+			});
+			return;
+		}
+	});
+} }) };
+const collectIdentifierNames = (node, into) => {
+	if (!node) return;
+	walkAst(node, (child) => {
+		if (child.type === "Identifier") into.add(child.name);
+	});
+};
+const isEarlyReturnIfStatement = (statement) => {
+	if (statement.type !== "IfStatement") return false;
+	const consequent = statement.consequent;
+	if (!consequent) return false;
+	if (consequent.type === "ReturnStatement") return true;
+	if (consequent.type !== "BlockStatement") return false;
+	for (const inner of consequent.body ?? []) if (inner.type === "ReturnStatement") return true;
+	return false;
+};
+const asyncDeferAwait = { create: (context) => {
+	const inspectStatements = (statements) => {
+		for (let statementIndex = 0; statementIndex < statements.length - 1; statementIndex++) {
+			const currentStatement = statements[statementIndex];
+			if (currentStatement.type !== "VariableDeclaration") continue;
+			const awaitedBindingNames = /* @__PURE__ */ new Set();
+			let didAwait = false;
+			for (const declarator of currentStatement.declarations ?? []) if (declarator.init?.type === "AwaitExpression") {
+				didAwait = true;
+				if (declarator.id?.type === "Identifier") awaitedBindingNames.add(declarator.id.name);
+				else if (declarator.id?.type === "ObjectPattern") {
+					for (const property of declarator.id.properties ?? []) if (property.type === "Property" && property.value?.type === "Identifier") awaitedBindingNames.add(property.value.name);
+				}
+			}
+			if (!didAwait) continue;
+			const nextStatement = statements[statementIndex + 1];
+			if (!isEarlyReturnIfStatement(nextStatement)) continue;
+			const testIdentifiers = /* @__PURE__ */ new Set();
+			collectIdentifierNames(nextStatement.test, testIdentifiers);
+			if ([...awaitedBindingNames].some((name) => testIdentifiers.has(name))) continue;
+			const consequentIdentifiers = /* @__PURE__ */ new Set();
+			collectIdentifierNames(nextStatement.consequent, consequentIdentifiers);
+			if ([...awaitedBindingNames].some((name) => consequentIdentifiers.has(name))) continue;
+			context.report({
+				node: currentStatement,
+				message: "await blocks the function before an early-return that doesn't use the awaited value — move the await after the synchronous guard so the skip path stays fast"
+			});
+		}
+	};
+	const enterFunction = (node) => {
+		if (!node.async) return;
+		if (node.body?.type !== "BlockStatement") return;
+		inspectStatements(node.body.body ?? []);
+	};
+	return {
+		FunctionDeclaration: enterFunction,
+		FunctionExpression: enterFunction,
+		ArrowFunctionExpression: enterFunction
+	};
+} };
+const CONTINUOUS_VALUE_HOOK_PATTERN = /^use(?:Window(?:Width|Height|Dimensions)|Scroll(?:Position|Y|X)|MousePosition|ResizeObserver|IntersectionObserver)/;
+const isThresholdComparison = (node, valueName) => {
+	if (node.type !== "BinaryExpression") return false;
+	if (![
+		"<",
+		"<=",
+		">",
+		">=",
+		"===",
+		"!==",
+		"==",
+		"!="
+	].includes(node.operator)) return false;
+	if (!(node.left?.type === "Identifier" && node.left.name === valueName || node.right?.type === "Identifier" && node.right.name === valueName)) return false;
+	return node.left?.type === "Literal" || node.right?.type === "Literal";
+};
+const findThresholdDerivedBindings = (componentBody) => {
+	const out = [];
+	if (componentBody?.type !== "BlockStatement") return out;
+	const statements = componentBody.body ?? [];
+	for (let outerIndex = 0; outerIndex < statements.length; outerIndex++) {
+		const outerStatement = statements[outerIndex];
+		if (outerStatement.type !== "VariableDeclaration") continue;
+		for (const declarator of outerStatement.declarations ?? []) {
+			if (declarator.id?.type !== "Identifier") continue;
+			const init = declarator.init;
+			if (init?.type !== "CallExpression") continue;
+			if (init.callee?.type !== "Identifier") continue;
+			if (!CONTINUOUS_VALUE_HOOK_PATTERN.test(init.callee.name)) continue;
+			const continuousName = declarator.id.name;
+			const hookName = init.callee.name;
+			for (let innerIndex = outerIndex + 1; innerIndex < statements.length; innerIndex++) {
+				const innerStatement = statements[innerIndex];
+				if (innerStatement.type !== "VariableDeclaration") break;
+				let foundThreshold = false;
+				for (const innerDecl of innerStatement.declarations ?? []) if (innerDecl.init && isThresholdComparison(innerDecl.init, continuousName)) {
+					foundThreshold = true;
+					break;
+				}
+				if (foundThreshold) {
+					out.push({
+						continuousName,
+						hookName,
+						declarator
+					});
+					break;
+				}
+			}
+		}
+	}
+	return out;
+};
+const rerenderDerivedStateFromHook = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const bindings = findThresholdDerivedBindings(componentBody);
+		for (const binding of bindings) context.report({
+			node: binding.declarator,
+			message: `${binding.hookName}() returns a continuously-changing value but you only compare it to a threshold — use a media-query / threshold hook (e.g. \`useMediaQuery("(max-width: 767px)")\`) so the component re-renders only when the threshold flips`
+		});
+	};
+	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/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[importedName];
@@ -2011,6 +2953,449 @@ const rnNoSingleElementStyleArray = { create: (context) => ({ JSXAttribute(node)
 		message: `Single-element style array on "${propName}" — use ${propName}={value} instead of ${propName}={[value]} to avoid unnecessary array allocation`
 	});
 } }) };
+const TOUCHABLE_COMPONENTS = new Set([
+	"TouchableOpacity",
+	"TouchableHighlight",
+	"TouchableWithoutFeedback",
+	"TouchableNativeFeedback"
+]);
+const rnPreferPressable = { 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 || !TOUCHABLE_COMPONENTS.has(importedName)) continue;
+		context.report({
+			node: specifier,
+			message: `${importedName} is legacy — use <Pressable> from react-native (or react-native-gesture-handler) for modern press handling`
+		});
+	}
+} }) };
+const rnPreferExpoImage = { create: (context) => ({ ImportDeclaration(node) {
+	if (node.source?.value !== "react-native") return;
+	for (const specifier of node.specifiers ?? []) {
+		if (specifier.type !== "ImportSpecifier") continue;
+		if (specifier.imported?.name !== "Image") continue;
+		context.report({
+			node: specifier,
+			message: "Importing Image from react-native — prefer expo-image for caching, placeholders, and progressive loading (drop-in API)"
+		});
+	}
+} }) };
+const NON_NATIVE_NAVIGATOR_PACKAGES = new Set(["@react-navigation/stack", "@react-navigation/drawer"]);
+const rnNoNonNativeNavigator = { create: (context) => ({ ImportDeclaration(node) {
+	const source = node.source?.value;
+	if (typeof source !== "string" || !NON_NATIVE_NAVIGATOR_PACKAGES.has(source)) return;
+	const replacement = source.replace("@react-navigation/", "@react-navigation/native-");
+	context.report({
+		node,
+		message: `${source} uses a JS-implemented navigator — use ${replacement} for native iOS/Android transitions and gestures`
+	});
+} }) };
+const rnNoScrollState = { create: (context) => ({ JSXAttribute(node) {
+	if (node.name?.type !== "JSXIdentifier") return;
+	if (node.name.name !== "onScroll") return;
+	if (node.value?.type !== "JSXExpressionContainer") return;
+	const expression = node.value.expression;
+	if (expression?.type !== "ArrowFunctionExpression" && expression?.type !== "FunctionExpression") return;
+	let setStateCallNode = null;
+	walkAst(expression.body, (child) => {
+		if (setStateCallNode) return;
+		if (child.type === "CallExpression" && child.callee?.type === "Identifier" && /^set[A-Z]/.test(child.callee.name)) setStateCallNode = child;
+	});
+	if (setStateCallNode) context.report({
+		node: setStateCallNode,
+		message: "setState in onScroll triggers re-renders on every scroll event — use a Reanimated shared value (useAnimatedScrollHandler) or a ref to track scroll position"
+	});
+} }) };
+const SCROLLVIEW_NAMES = new Set(["ScrollView"]);
+const rnNoScrollviewMappedList = { create: (context) => ({ JSXElement(node) {
+	const elementName = resolveJsxElementName(node.openingElement);
+	if (!elementName || !SCROLLVIEW_NAMES.has(elementName)) return;
+	for (const child of node.children ?? []) {
+		if (child.type !== "JSXExpressionContainer") continue;
+		const expression = child.expression;
+		if (expression?.type === "CallExpression" && expression.callee?.type === "MemberExpression" && expression.callee.property?.type === "Identifier" && expression.callee.property.name === "map") {
+			context.report({
+				node: child,
+				message: `<${elementName}> rendering items.map(...) — use FlashList, LegendList, or FlatList so only visible rows mount`
+			});
+			return;
+		}
+	}
+} }) };
+const RENDER_ITEM_PROP_NAMES = new Set([
+	"renderItem",
+	"renderSectionHeader",
+	"renderSectionFooter"
+]);
+const rnNoInlineObjectInListItem = { create: (context) => {
+	let renderItemDepth = 0;
+	const isRenderItemAttribute = (parent) => {
+		if (parent?.type !== "JSXAttribute") return false;
+		const attrName = parent.name?.type === "JSXIdentifier" ? parent.name.name : null;
+		return attrName ? RENDER_ITEM_PROP_NAMES.has(attrName) : false;
+	};
+	const isRenderItemFunction = (node) => {
+		if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return false;
+		const expressionContainer = node.parent;
+		if (expressionContainer?.type !== "JSXExpressionContainer") return false;
+		return isRenderItemAttribute(expressionContainer.parent);
+	};
+	const enter = (node) => {
+		if (isRenderItemFunction(node)) renderItemDepth++;
+	};
+	const exit = (node) => {
+		if (isRenderItemFunction(node)) renderItemDepth = Math.max(0, renderItemDepth - 1);
+	};
+	return {
+		ArrowFunctionExpression: enter,
+		"ArrowFunctionExpression:exit": exit,
+		FunctionExpression: enter,
+		"FunctionExpression:exit": exit,
+		JSXAttribute(node) {
+			if (renderItemDepth === 0) return;
+			if (node.value?.type !== "JSXExpressionContainer") return;
+			if (node.value.expression?.type !== "ObjectExpression") return;
+			const propName = node.name?.type === "JSXIdentifier" ? node.name.name : "<unknown>";
+			context.report({
+				node,
+				message: `Inline object literal on "${propName}" inside renderItem — allocates a fresh reference per row and breaks memo() on the row component. Hoist outside renderItem or pass primitives`
+			});
+		}
+	};
+} };
+const REANIMATED_LAYOUT_KEYS = new Set([
+	"width",
+	"height",
+	"top",
+	"left",
+	"right",
+	"bottom",
+	"minWidth",
+	"minHeight",
+	"maxWidth",
+	"maxHeight",
+	"marginTop",
+	"marginBottom",
+	"marginLeft",
+	"marginRight",
+	"paddingTop",
+	"paddingBottom",
+	"paddingLeft",
+	"paddingRight",
+	"flex",
+	"flexBasis",
+	"flexGrow",
+	"flexShrink"
+]);
+const findReturnedObject = (callback) => {
+	if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") return null;
+	const body = callback.body;
+	if (body?.type === "ObjectExpression") return body;
+	if (body?.type !== "BlockStatement") return null;
+	for (const stmt of body.body ?? []) if (stmt.type === "ReturnStatement" && stmt.argument?.type === "ObjectExpression") return stmt.argument;
+	return null;
+};
+const rnAnimateLayoutProperty = { create: (context) => ({ CallExpression(node) {
+	if (node.callee?.type !== "Identifier" || node.callee.name !== "useAnimatedStyle") return;
+	const callback = node.arguments?.[0];
+	if (!callback) return;
+	const returnedObject = findReturnedObject(callback);
+	if (!returnedObject) return;
+	for (const property of returnedObject.properties ?? []) {
+		if (property.type !== "Property") continue;
+		if (property.key?.type !== "Identifier") continue;
+		if (!REANIMATED_LAYOUT_KEYS.has(property.key.name)) continue;
+		context.report({
+			node: property,
+			message: `useAnimatedStyle animating "${property.key.name}" — layout properties run on the layout thread; use transform: [{ translateX/Y }, { scale }] or opacity for GPU-accelerated animation`
+		});
+	}
+} }) };
+const rnPreferContentInsetAdjustment = { create: (context) => ({ JSXElement(node) {
+	if (resolveJsxElementName(node.openingElement) !== "SafeAreaView") return;
+	for (const child of node.children ?? []) {
+		if (child.type !== "JSXElement") continue;
+		const childName = resolveJsxElementName(child.openingElement);
+		if (!childName || !SCROLLVIEW_NAMES.has(childName)) continue;
+		context.report({
+			node,
+			message: "<SafeAreaView> wrapping <ScrollView> — set `contentInsetAdjustmentBehavior=\"automatic\"` on the ScrollView and drop the SafeAreaView wrapper for native safe-area handling"
+		});
+		return;
+	}
+} }) };
+const PRESS_HANDLER_PROP_NAMES = new Set(["onPressIn", "onPressOut"]);
+const handlerMutatesIdentifier = (handler, sharedValueBindings) => {
+	if (handler.type !== "ArrowFunctionExpression" && handler.type !== "FunctionExpression") return false;
+	if (sharedValueBindings.size === 0) return false;
+	let didMutate = false;
+	walkAst(handler.body, (child) => {
+		if (didMutate) return;
+		if (child.type === "AssignmentExpression" && child.left?.type === "MemberExpression" && child.left.object?.type === "Identifier" && sharedValueBindings.has(child.left.object.name) && child.left.property?.type === "Identifier" && child.left.property.name === "value") didMutate = true;
+		if (child.type === "CallExpression" && child.callee?.type === "MemberExpression" && child.callee.object?.type === "Identifier" && sharedValueBindings.has(child.callee.object.name) && child.callee.property?.type === "Identifier" && (child.callee.property.name === "set" || child.callee.property.name === "value")) didMutate = true;
+	});
+	return didMutate;
+};
+const rnPressableSharedValueMutation = { create: (context) => {
+	const sharedValueBindingsByComponent = [];
+	const enterScope = () => {
+		sharedValueBindingsByComponent.push(/* @__PURE__ */ new Set());
+	};
+	const exitScope = () => {
+		sharedValueBindingsByComponent.pop();
+	};
+	const trackSharedValueBinding = (declarator) => {
+		if (sharedValueBindingsByComponent.length === 0) return;
+		if (declarator.id?.type !== "Identifier") return;
+		if (declarator.init?.type !== "CallExpression") return;
+		const callee = declarator.init.callee;
+		if (callee?.type !== "Identifier") return;
+		if (callee.name !== "useSharedValue") return;
+		sharedValueBindingsByComponent[sharedValueBindingsByComponent.length - 1].add(declarator.id.name);
+	};
+	return {
+		FunctionDeclaration: enterScope,
+		"FunctionDeclaration:exit": exitScope,
+		FunctionExpression: enterScope,
+		"FunctionExpression:exit": exitScope,
+		ArrowFunctionExpression: enterScope,
+		"ArrowFunctionExpression:exit": exitScope,
+		VariableDeclarator(node) {
+			trackSharedValueBinding(node);
+		},
+		JSXOpeningElement(node) {
+			if (resolveJsxElementName(node) !== "Pressable") return;
+			if (sharedValueBindingsByComponent.length === 0) return;
+			const activeBindings = /* @__PURE__ */ new Set();
+			for (const frame of sharedValueBindingsByComponent) for (const binding of frame) activeBindings.add(binding);
+			if (activeBindings.size === 0) return;
+			for (const attr of node.attributes ?? []) {
+				if (attr.type !== "JSXAttribute") continue;
+				if (attr.name?.type !== "JSXIdentifier") continue;
+				if (!PRESS_HANDLER_PROP_NAMES.has(attr.name.name)) continue;
+				if (attr.value?.type !== "JSXExpressionContainer") continue;
+				const handler = attr.value.expression;
+				if (!handler) continue;
+				if (!handlerMutatesIdentifier(handler, activeBindings)) continue;
+				context.report({
+					node: attr,
+					message: `<Pressable> ${attr.name.name} mutates a Reanimated shared value — use a Gesture.Tap() inside <GestureDetector> for press animations that stay on the UI thread`
+				});
+			}
+		}
+	};
+} };
+const VIRTUALIZED_LIST_NAMES = new Set([
+	"FlatList",
+	"FlashList",
+	"LegendList",
+	"SectionList",
+	"VirtualizedList"
+]);
+const rnListDataMapped = { create: (context) => ({ JSXOpeningElement(node) {
+	const elementName = resolveJsxElementName(node);
+	if (!elementName || !VIRTUALIZED_LIST_NAMES.has(elementName)) return;
+	for (const attr of node.attributes ?? []) {
+		if (attr.type !== "JSXAttribute") continue;
+		if (attr.name?.type !== "JSXIdentifier" || attr.name.name !== "data") continue;
+		if (attr.value?.type !== "JSXExpressionContainer") continue;
+		const expression = attr.value.expression;
+		if (expression?.type !== "CallExpression") continue;
+		if (expression.callee?.type !== "MemberExpression") continue;
+		if (expression.callee.property?.type !== "Identifier") continue;
+		const methodName = expression.callee.property.name;
+		if (methodName !== "map" && methodName !== "filter") continue;
+		context.report({
+			node: attr,
+			message: `<${elementName} data={items.${methodName}(...)}> allocates a fresh array per render — wrap in useMemo at list scope so the data reference stays stable across parent renders`
+		});
+		return;
+	}
+} }) };
+const rnAnimationReactionAsDerived = { create: (context) => ({ CallExpression(node) {
+	if (node.callee?.type !== "Identifier" || node.callee.name !== "useAnimatedReaction") return;
+	const reactionFn = node.arguments?.[1];
+	if (!reactionFn) return;
+	if (reactionFn.type !== "ArrowFunctionExpression" && reactionFn.type !== "FunctionExpression") return;
+	const body = reactionFn.body;
+	let singleAssignment = null;
+	if (body?.type === "BlockStatement") {
+		const statements = body.body ?? [];
+		if (statements.length !== 1) return;
+		const onlyStatement = statements[0];
+		if (onlyStatement.type !== "ExpressionStatement") return;
+		singleAssignment = onlyStatement.expression;
+	} else if (body) singleAssignment = body;
+	if (!singleAssignment) return;
+	if (singleAssignment.type !== "AssignmentExpression") return;
+	if (singleAssignment.left?.type !== "MemberExpression") return;
+	if (singleAssignment.left.property?.type !== "Identifier") return;
+	if (singleAssignment.left.property.name !== "value") return;
+	context.report({
+		node,
+		message: "useAnimatedReaction body is a single shared-value assignment — useDerivedValue is shorter and tracks dependencies natively"
+	});
+} }) };
+const JS_BOTTOM_SHEET_PACKAGES = new Set([
+	"@gorhom/bottom-sheet",
+	"react-native-bottom-sheet",
+	"react-native-modal-bottom-sheet",
+	"react-native-raw-bottom-sheet"
+]);
+const rnBottomSheetPreferNative = { create: (context) => ({ ImportDeclaration(node) {
+	const source = node.source?.value;
+	if (typeof source !== "string" || !JS_BOTTOM_SHEET_PACKAGES.has(source)) return;
+	context.report({
+		node,
+		message: `${source} is a JS-implemented bottom sheet — for v7+ RN, prefer <Modal presentationStyle="formSheet"> for native gesture handling and snap points`
+	});
+} }) };
+const rnScrollviewDynamicPadding = { create: (context) => ({ JSXOpeningElement(node) {
+	const elementName = resolveJsxElementName(node);
+	if (!elementName) return;
+	if (!SCROLLVIEW_NAMES.has(elementName) && elementName !== "FlatList" && elementName !== "FlashList") return;
+	for (const attr of node.attributes ?? []) {
+		if (attr.type !== "JSXAttribute") continue;
+		if (attr.name?.type !== "JSXIdentifier" || attr.name.name !== "contentContainerStyle") continue;
+		if (attr.value?.type !== "JSXExpressionContainer") continue;
+		const expression = attr.value.expression;
+		if (expression?.type !== "ObjectExpression") continue;
+		for (const property of expression.properties ?? []) {
+			if (property.type !== "Property") continue;
+			if (property.key?.type !== "Identifier") continue;
+			const key = property.key.name;
+			if (key !== "paddingBottom" && key !== "paddingTop") continue;
+			const value = property.value;
+			if (!value) continue;
+			if (value.type === "Literal") continue;
+			context.report({
+				node: property,
+				message: `Dynamic ${key} on contentContainerStyle reflows the scroll content — use \`contentInset\` (OS-level offset, no relayout) instead`
+			});
+			return;
+		}
+	}
+} }) };
+const LIST_ROW_PRESS_HANDLER_PROPS = new Set([
+	"onPress",
+	"onLongPress",
+	"onPressIn",
+	"onPressOut",
+	"onSelect",
+	"onClick"
+]);
+const detectInlineRowHandlers = (renderItemFn) => {
+	const inlineHandlers = [];
+	walkAst(renderItemFn.body, (child) => {
+		if (child.type !== "JSXAttribute") return;
+		if (child.name?.type !== "JSXIdentifier") return;
+		if (!LIST_ROW_PRESS_HANDLER_PROPS.has(child.name.name)) return;
+		if (child.value?.type !== "JSXExpressionContainer") return;
+		const expression = child.value.expression;
+		if (expression?.type === "ArrowFunctionExpression" || expression?.type === "FunctionExpression") inlineHandlers.push(child);
+	});
+	return inlineHandlers;
+};
+const isRenderItemJsxAttribute = (parent) => {
+	if (parent?.type !== "JSXAttribute") return false;
+	return (parent.name?.type === "JSXIdentifier" ? parent.name.name : null) === "renderItem";
+};
+const isRenderItemFunction = (node) => {
+	const parent = node.parent;
+	if (parent?.type !== "JSXExpressionContainer") return false;
+	return isRenderItemJsxAttribute(parent.parent);
+};
+const rnListCallbackPerRow = { create: (context) => {
+	const inspect = (node) => {
+		if (!isRenderItemFunction(node)) return;
+		const inlineHandlers = detectInlineRowHandlers(node);
+		for (const handler of inlineHandlers) {
+			const handlerName = handler.name?.type === "JSXIdentifier" ? handler.name.name : "<handler>";
+			context.report({
+				node: handler,
+				message: `Inline ${handlerName} arrow inside renderItem creates a fresh closure per row — hoist with useCallback at list scope and pass the row id as a primitive prop`
+			});
+		}
+	};
+	return {
+		ArrowFunctionExpression: inspect,
+		FunctionExpression: inspect
+	};
+} };
+const LEGACY_SHADOW_KEYS = new Set([
+	"shadowColor",
+	"shadowOffset",
+	"shadowOpacity",
+	"shadowRadius",
+	"elevation"
+]);
+const findLegacyShadowProperty = (objectExpression) => {
+	for (const property of objectExpression.properties ?? []) {
+		if (property.type !== "Property") continue;
+		if (property.key?.type !== "Identifier") continue;
+		if (LEGACY_SHADOW_KEYS.has(property.key.name)) return {
+			keyName: property.key.name,
+			node: property
+		};
+	}
+	return null;
+};
+const rnStylePreferBoxShadow = { create: (context) => ({
+	JSXAttribute(node) {
+		if (node.name?.type !== "JSXIdentifier") return;
+		const attrName = node.name.name;
+		if (attrName !== "style" && !attrName.endsWith("Style")) return;
+		if (node.value?.type !== "JSXExpressionContainer") return;
+		const expression = node.value.expression;
+		if (expression?.type !== "ObjectExpression") return;
+		const match = findLegacyShadowProperty(expression);
+		if (!match) return;
+		context.report({
+			node: match.node,
+			message: `${match.keyName} is iOS/Android-platform-specific — use the cross-platform CSS \`boxShadow\` string (e.g. \`boxShadow: "0 2px 8px rgba(0,0,0,0.1)"\`) on RN v7+`
+		});
+	},
+	CallExpression(node) {
+		if (node.callee?.type !== "MemberExpression") return;
+		if (node.callee.object?.type !== "Identifier") return;
+		if (node.callee.object.name !== "StyleSheet") return;
+		if (node.callee.property?.type !== "Identifier") return;
+		if (node.callee.property.name !== "create") return;
+		const arg = node.arguments?.[0];
+		if (arg?.type !== "ObjectExpression") return;
+		for (const property of arg.properties ?? []) {
+			if (property.type !== "Property") continue;
+			if (property.value?.type !== "ObjectExpression") continue;
+			const match = findLegacyShadowProperty(property.value);
+			if (!match) continue;
+			context.report({
+				node: match.node,
+				message: `${match.keyName} is iOS/Android-platform-specific — use the cross-platform CSS \`boxShadow\` string on RN v7+`
+			});
+		}
+	}
+}) };
+const RECYCLABLE_LIST_NAMES = new Set(["FlashList", "LegendList"]);
+const rnListRecyclableWithoutTypes = { create: (context) => ({ JSXOpeningElement(node) {
+	const elementName = resolveJsxElementName(node);
+	if (!elementName || !RECYCLABLE_LIST_NAMES.has(elementName)) return;
+	let hasRecycleItemsEnabled = false;
+	let hasGetItemType = false;
+	for (const attr of node.attributes ?? []) {
+		if (attr.type !== "JSXAttribute") continue;
+		if (attr.name?.type !== "JSXIdentifier") continue;
+		if (attr.name.name === "recycleItems") if (!attr.value) hasRecycleItemsEnabled = true;
+		else if (attr.value.type === "JSXExpressionContainer" && attr.value.expression?.type === "Literal") hasRecycleItemsEnabled = attr.value.expression.value === true;
+		else hasRecycleItemsEnabled = true;
+		if (attr.name.name === "getItemType") hasGetItemType = true;
+	}
+	if (hasRecycleItemsEnabled && !hasGetItemType) context.report({
+		node,
+		message: `<${elementName} recycleItems> without \`getItemType\` — heterogeneous rows mount into the wrong recycled cells. Add \`getItemType={item => item.kind}\` so FlashList keeps separate recycle pools per type`
+	});
+} }) };
 //#endregion
 //#region src/plugin/rules/tanstack-query.ts
 const queryStableQueryClient = { create: (context) => {
@@ -2030,10 +3415,10 @@ const queryStableQueryClient = { create: (context) => {
 			if (node.id?.type === "Identifier" && UPPERCASE_PATTERN.test(node.id.name) && (node.init?.type === "ArrowFunctionExpression" || node.init?.type === "FunctionExpression")) componentDepth--;
 		},
 		CallExpression(node) {
-			if (node.callee?.type === "Identifier" && STABLE_HOOK_WRAPPERS.has(node.callee.name)) stableHookDepth++;
+			if (isHookCall(node, STABLE_HOOK_WRAPPERS)) stableHookDepth++;
 		},
 		"CallExpression:exit"(node) {
-			if (node.callee?.type === "Identifier" && STABLE_HOOK_WRAPPERS.has(node.callee.name)) stableHookDepth--;
+			if (isHookCall(node, STABLE_HOOK_WRAPPERS)) stableHookDepth = Math.max(0, stableHookDepth - 1);
 		},
 		NewExpression(node) {
 			if (componentDepth <= 0) return;
@@ -2092,14 +3477,17 @@ const queryMutationMissingInvalidation = { create: (context) => ({ CallExpressio
 	const optionsArgument = node.arguments?.[0];
 	if (!optionsArgument || optionsArgument.type !== "ObjectExpression") return;
 	if (!optionsArgument.properties?.some((property) => property.type === "Property" && property.key?.type === "Identifier" && property.key.name === "mutationFn")) return;
-	let hasInvalidation = false;
+	let hasCacheUpdate = false;
 	walkAst(optionsArgument, (child) => {
-		if (hasInvalidation) return;
-		if (child.type === "CallExpression" && child.callee?.type === "MemberExpression" && child.callee.property?.type === "Identifier" && child.callee.property.name === "invalidateQueries") hasInvalidation = true;
+		if (hasCacheUpdate) return false;
+		if (child.type === "CallExpression" && child.callee?.type === "MemberExpression" && child.callee.property?.type === "Identifier" && QUERY_CACHE_UPDATE_METHODS.has(child.callee.property.name)) {
+			hasCacheUpdate = true;
+			return false;
+		}
 	});
-	if (!hasInvalidation) context.report({
+	if (!hasCacheUpdate) context.report({
 		node,
-		message: "useMutation without invalidateQueries — stale data may remain cached after the mutation. Add onSuccess with queryClient.invalidateQueries()"
+		message: "useMutation without a cache update — stale data may remain after the mutation. Call queryClient.invalidateQueries / setQueryData / resetQueries / refetchQueries inside onSuccess (or trigger a router refresh)"
 	});
 } }) };
 const queryNoUseQueryForMutation = { create: (context) => ({ CallExpression(node) {
@@ -2153,7 +3541,7 @@ const noSecretsInClientCode = { create: (context) => ({ VariableDeclarator(node)
 	const literalValue = node.init.value;
 	const trailingSuffix = variableName.split("_").pop()?.toLowerCase() ?? "";
 	const isUiConstant = SECRET_FALSE_POSITIVE_SUFFIXES.has(trailingSuffix);
-	if (SECRET_VARIABLE_PATTERN.test(variableName) && !isUiConstant && literalValue.length > 8) {
+	if (SECRET_VARIABLE_PATTERN.test(variableName) && !isUiConstant && literalValue.length > 24) {
 		context.report({
 			node,
 			message: `Possible hardcoded secret in "${variableName}" — use environment variables instead`
@@ -2188,7 +3576,7 @@ const serverAuthActions = { create: (context) => {
 			const declaration = node.declaration;
 			if (declaration?.type !== "FunctionDeclaration" || !declaration?.async) return;
 			if (!(fileHasUseServerDirective || hasUseServerDirective(declaration))) return;
-			if (!containsAuthCheck((declaration.body?.body ?? []).slice(0, 3))) {
+			if (!containsAuthCheck((declaration.body?.body ?? []).slice(0, 10))) {
 				const functionName = declaration.id?.name ?? "anonymous";
 				context.report({
 					node: declaration.id ?? node,
@@ -2198,23 +3586,380 @@ const serverAuthActions = { create: (context) => {
 		}
 	};
 } };
+const MUTABLE_CONTAINER_CONSTRUCTORS = new Set([
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet"
+]);
+const isMutableConstInitializer = (init) => {
+	if (!init) return null;
+	if (init.type === "ArrayExpression") return "[]";
+	if (init.type === "ObjectExpression") return "{}";
+	if (init.type === "NewExpression" && init.callee?.type === "Identifier" && MUTABLE_CONTAINER_CONSTRUCTORS.has(init.callee.name)) return `new ${init.callee.name}()`;
+	return null;
+};
+const serverNoMutableModuleState = { create: (context) => {
+	let fileHasUseServerDirective = false;
+	return {
+		Program(programNode) {
+			fileHasUseServerDirective = hasDirective(programNode, "use server");
+		},
+		VariableDeclaration(node) {
+			if (!fileHasUseServerDirective) return;
+			if (node.parent?.type !== "Program") return;
+			for (const declarator of node.declarations ?? []) {
+				const variableName = declarator.id?.type === "Identifier" ? declarator.id.name : "<unnamed>";
+				if (node.kind === "let" || node.kind === "var") {
+					context.report({
+						node: declarator,
+						message: `Module-scoped ${node.kind} "${variableName}" in a "use server" file — this is shared across requests; move per-request data into the action body`
+					});
+					continue;
+				}
+				const containerKind = isMutableConstInitializer(declarator.init);
+				if (containerKind) context.report({
+					node: declarator,
+					message: `Module-scoped const "${variableName} = ${containerKind}" in a "use server" file — the container itself is shared across requests; move per-request data into the action body`
+				});
+			}
+		}
+	};
+} };
+const serverCacheWithObjectLiteral = { create: (context) => {
+	const cachedFunctionNames = /* @__PURE__ */ new Set();
+	return {
+		VariableDeclarator(node) {
+			if (node.id?.type !== "Identifier") return;
+			const init = node.init;
+			if (init?.type !== "CallExpression") return;
+			const callee = init.callee;
+			if (!(callee?.type === "Identifier" && callee.name === "cache" || callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "React" && callee.property?.type === "Identifier" && callee.property.name === "cache")) return;
+			cachedFunctionNames.add(node.id.name);
+		},
+		CallExpression(node) {
+			if (node.callee?.type !== "Identifier") return;
+			if (!cachedFunctionNames.has(node.callee.name)) return;
+			if ((node.arguments?.[0])?.type !== "ObjectExpression") return;
+			context.report({
+				node,
+				message: `${node.callee.name} is React.cache()-wrapped, but you're passing an object literal — the cache keys on argument identity, so a fresh {} per render bypasses dedup. Pass primitives or hoist the object`
+			});
+		}
+	};
+} };
+const CONSOLE_DEFERRABLE_METHODS = new Set([
+	"log",
+	"info",
+	"warn"
+]);
+const ANALYTICS_DEFERRABLE_OBJECTS = new Set([
+	"analytics",
+	"posthog",
+	"mixpanel",
+	"segment",
+	"amplitude",
+	"datadog",
+	"sentry"
+]);
+const ANALYTICS_DEFERRABLE_METHODS = new Set([
+	"track",
+	"identify",
+	"page",
+	"capture",
+	"captureMessage",
+	"captureException",
+	"log"
+]);
+const isDeferrableSideEffectCall = (objectName, methodName) => {
+	if (objectName === "console") return CONSOLE_DEFERRABLE_METHODS.has(methodName);
+	if (ANALYTICS_DEFERRABLE_OBJECTS.has(objectName)) return ANALYTICS_DEFERRABLE_METHODS.has(methodName);
+	return false;
+};
 const serverAfterNonblocking = { create: (context) => {
 	let fileHasUseServerDirective = false;
+	let serverFunctionDepth = 0;
+	const enterIfServerFunction = (node) => {
+		if (hasUseServerDirective(node)) serverFunctionDepth++;
+	};
+	const leaveIfServerFunction = (node) => {
+		if (hasUseServerDirective(node)) serverFunctionDepth = Math.max(0, serverFunctionDepth - 1);
+	};
 	return {
 		Program(programNode) {
 			fileHasUseServerDirective = hasDirective(programNode, "use server");
 		},
+		FunctionDeclaration: enterIfServerFunction,
+		"FunctionDeclaration:exit": leaveIfServerFunction,
+		FunctionExpression: enterIfServerFunction,
+		"FunctionExpression:exit": leaveIfServerFunction,
+		ArrowFunctionExpression: enterIfServerFunction,
+		"ArrowFunctionExpression:exit": leaveIfServerFunction,
 		CallExpression(node) {
-			if (!fileHasUseServerDirective) return;
+			if (!fileHasUseServerDirective && serverFunctionDepth === 0) return;
 			if (node.callee?.type !== "MemberExpression") return;
 			if (node.callee.property?.type !== "Identifier") return;
 			const objectName = node.callee.object?.type === "Identifier" ? node.callee.object.name : null;
 			if (!objectName) return;
 			const methodName = node.callee.property.name;
-			if (!(objectName === "console" && (methodName === "log" || methodName === "info" || methodName === "warn") || objectName === "analytics" && (methodName === "track" || methodName === "identify" || methodName === "page"))) return;
+			if (!isDeferrableSideEffectCall(objectName, methodName)) return;
+			context.report({
+				node,
+				message: `${objectName}.${methodName}() in server action — wrap in \`after(() => ${objectName}.${methodName}(...))\` so it doesn't delay the user-visible response`
+			});
+		}
+	};
+} };
+const ROUTE_HANDLER_HTTP_METHODS = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"OPTIONS",
+	"HEAD"
+]);
+const STATIC_IO_FUNCTIONS = new Set([
+	"readFileSync",
+	"readFile",
+	"readdir",
+	"readdirSync",
+	"stat",
+	"statSync",
+	"access",
+	"accessSync"
+]);
+const isStaticIoCall = (call) => {
+	if (call.type !== "CallExpression") return false;
+	const callee = call.callee;
+	if (callee?.type === "Identifier" && STATIC_IO_FUNCTIONS.has(callee.name)) return true;
+	if (callee?.type !== "MemberExpression") return false;
+	const propertyName = callee.property?.type === "Identifier" ? callee.property.name : null;
+	if (!propertyName || !STATIC_IO_FUNCTIONS.has(propertyName)) return false;
+	return true;
+};
+const isFetchOfImportMetaUrl = (call) => {
+	if (call.type !== "CallExpression") return false;
+	if (call.callee?.type !== "Identifier" || call.callee.name !== "fetch") return false;
+	const arg = call.arguments?.[0];
+	if (!arg) return false;
+	if (arg.type !== "NewExpression") return false;
+	if (arg.callee?.type !== "Identifier" || arg.callee.name !== "URL") return false;
+	const secondArg = arg.arguments?.[1];
+	if (!secondArg) return false;
+	return secondArg.type === "MemberExpression" && secondArg.object?.type === "MetaProperty" && secondArg.property?.type === "Identifier" && secondArg.property.name === "url";
+};
+const callReadsHandlerArgs = (call, handlerParamNames) => {
+	if (handlerParamNames.size === 0) return false;
+	let referencesArg = false;
+	walkAst(call, (child) => {
+		if (referencesArg) return;
+		if (child.type === "Identifier" && handlerParamNames.has(child.name)) referencesArg = true;
+	});
+	return referencesArg;
+};
+const DERIVING_ARRAY_METHODS = new Set([
+	"toSorted",
+	"toReversed",
+	"filter",
+	"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 = [];
+	for (const attr of node.attributes ?? []) {
+		if (attr.type !== "JSXAttribute") continue;
+		if (attr.name?.type !== "JSXIdentifier") continue;
+		if (attr.value?.type !== "JSXExpressionContainer") continue;
+		const expression = attr.value.expression;
+		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
+				});
+			}
+		}
+	}
+	for (const derived of derivedAttributes) {
+		const sourcePropName = identifierAttributes.get(derived.rootName);
+		if (sourcePropName) context.report({
+			node: derived.node,
+			message: `"${derived.propName}" is derived from "${sourcePropName}" (same source: ${derived.rootName}) — passing both doubles RSC serialization. Pass the source once and derive on the client`
+		});
+	}
+} }) };
+const getDerivingMethodName = (node) => {
+	if (node.type !== "CallExpression") return null;
+	if (node.callee?.type !== "MemberExpression") return null;
+	if (node.callee.property?.type !== "Identifier") return null;
+	return node.callee.property.name;
+};
+const PAGES_ROUTER_API_PATH_PATTERN = /\/pages\/api\//;
+const inspectHandlerBody = (context, handlerBody, handlerLabel, handlerParamNames) => {
+	walkAst(handlerBody, (child) => {
+		let staticCall = null;
+		if (isStaticIoCall(child)) staticCall = child;
+		else if (isFetchOfImportMetaUrl(child)) staticCall = child;
+		else if (child.type === "AwaitExpression" && child.argument && (isStaticIoCall(child.argument) || isFetchOfImportMetaUrl(child.argument))) staticCall = child.argument;
+		if (!staticCall) return;
+		if (callReadsHandlerArgs(staticCall, handlerParamNames)) return;
+		const calleeText = staticCall.callee?.type === "MemberExpression" && staticCall.callee.property?.type === "Identifier" ? `${staticCall.callee.object?.type === "Identifier" ? staticCall.callee.object.name : "?"}.${staticCall.callee.property.name}` : staticCall.callee?.type === "Identifier" ? staticCall.callee.name : "io";
+		context.report({
+			node: staticCall,
+			message: `${calleeText}() in ${handlerLabel} reads the same static asset every request — hoist to module scope so the read happens once at module load`
+		});
+	});
+};
+const collectIdentifierParams = (params) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const param of params) if (param.type === "Identifier") names.add(param.name);
+	return names;
+};
+const serverHoistStaticIo = { create: (context) => ({
+	ExportNamedDeclaration(node) {
+		const declaration = node.declaration;
+		if (declaration?.type !== "FunctionDeclaration") return;
+		const handlerName = declaration.id?.name;
+		if (!handlerName || !ROUTE_HANDLER_HTTP_METHODS.has(handlerName)) return;
+		if (declaration.body?.type !== "BlockStatement") return;
+		inspectHandlerBody(context, declaration.body, `${handlerName} route handler`, collectIdentifierParams(declaration.params ?? []));
+	},
+	ExportDefaultDeclaration(node) {
+		const filename = context.getFilename?.() ?? "";
+		if (!PAGES_ROUTER_API_PATH_PATTERN.test(filename)) return;
+		const declaration = node.declaration;
+		if (!declaration || declaration.type !== "FunctionDeclaration" && declaration.type !== "FunctionExpression" && declaration.type !== "ArrowFunctionExpression") return;
+		if (!declaration.async) return;
+		const body = declaration.body;
+		if (body?.type !== "BlockStatement") return;
+		inspectHandlerBody(context, body, "pages/api handler", collectIdentifierParams(declaration.params ?? []));
+	}
+}) };
+const collectDeclaredNames = (declaration) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const declarator of declaration.declarations ?? []) if (declarator.id?.type === "Identifier") names.add(declarator.id.name);
+	else if (declarator.id?.type === "ObjectPattern") {
+		for (const property of declarator.id.properties ?? []) if (property.type === "Property" && property.value?.type === "Identifier") names.add(property.value.name);
+		else if (property.type === "RestElement" && property.argument?.type === "Identifier") names.add(property.argument.name);
+	} else if (declarator.id?.type === "ArrayPattern") {
+		for (const element of declarator.id.elements ?? []) if (element?.type === "Identifier") names.add(element.name);
+	}
+	return names;
+};
+const declarationStartsWithAwait = (declaration) => {
+	for (const declarator of declaration.declarations ?? []) if (declarator.init?.type === "AwaitExpression") return true;
+	return false;
+};
+const declarationReadsAnyName = (declaration, names) => {
+	if (names.size === 0) return false;
+	let didRead = false;
+	walkAst(declaration, (child) => {
+		if (didRead) return;
+		if (child.type === "Identifier" && names.has(child.name)) didRead = true;
+	});
+	return didRead;
+};
+const serverSequentialIndependentAwait = { create: (context) => {
+	const inspectStatements = (statements) => {
+		for (let statementIndex = 0; statementIndex < statements.length - 1; statementIndex++) {
+			const currentStatement = statements[statementIndex];
+			if (currentStatement.type !== "VariableDeclaration") continue;
+			if (!declarationStartsWithAwait(currentStatement)) continue;
+			const declaredNames = collectDeclaredNames(currentStatement);
+			const nextStatement = statements[statementIndex + 1];
+			if (nextStatement.type !== "VariableDeclaration") continue;
+			if (!declarationStartsWithAwait(nextStatement)) continue;
+			if (declarationReadsAnyName(nextStatement, declaredNames)) continue;
+			context.report({
+				node: nextStatement,
+				message: "Sequential `await` without a data dependency on the previous result — wrap the independent calls in `Promise.all([...])` so they race instead of waterfalling"
+			});
+			statementIndex++;
+		}
+	};
+	const visitFunctionBody = (node) => {
+		if (!node.async) return;
+		if (node.body?.type !== "BlockStatement") return;
+		inspectStatements(node.body.body ?? []);
+	};
+	return {
+		FunctionDeclaration: visitFunctionBody,
+		FunctionExpression: visitFunctionBody,
+		ArrowFunctionExpression: visitFunctionBody
+	};
+} };
+const isFetchCall = (node) => {
+	if (node.type !== "CallExpression") return false;
+	return node.callee?.type === "Identifier" && node.callee.name === "fetch";
+};
+const objectExpressionHasNextRevalidate = (objectExpression) => {
+	if (objectExpression.type !== "ObjectExpression") return false;
+	for (const property of objectExpression.properties ?? []) {
+		if (property.type !== "Property") continue;
+		if (property.key?.type !== "Identifier") continue;
+		if (property.key.name === "cache") return true;
+		if (property.key.name !== "next") continue;
+		if (property.value?.type !== "ObjectExpression") return true;
+		for (const innerProperty of property.value.properties ?? []) {
+			if (innerProperty.type !== "Property") continue;
+			if (innerProperty.key?.type !== "Identifier") continue;
+			if (innerProperty.key.name === "revalidate" || innerProperty.key.name === "tags") return true;
+		}
+		return true;
+	}
+	return false;
+};
+const APP_ROUTER_FILE_PATTERN = /\/app\/(?:[^/]+\/)*(?:route|page|layout|template|loading|error|default)\.(?:tsx?|jsx?)$/;
+const NON_PROJECT_PATH_PATTERN = /\/(?:node_modules|dist|build|\.next)\//;
+const serverFetchWithoutRevalidate = { create: (context) => {
+	let isServerSideFile = false;
+	return {
+		Program(node) {
+			const filename = context.getFilename?.() ?? "";
+			if (!APP_ROUTER_FILE_PATTERN.test(filename)) {
+				isServerSideFile = false;
+				return;
+			}
+			if (NON_PROJECT_PATH_PATTERN.test(filename)) {
+				isServerSideFile = false;
+				return;
+			}
+			isServerSideFile = !(node.body ?? []).some((statement) => statement.type === "ExpressionStatement" && statement.expression?.type === "Literal" && statement.expression.value === "use client");
+		},
+		CallExpression(node) {
+			if (!isServerSideFile) return;
+			if (!isFetchCall(node)) return;
+			const optionsArg = node.arguments?.[1];
+			if (optionsArg && objectExpressionHasNextRevalidate(optionsArg)) return;
+			const urlArg = node.arguments?.[0];
+			const urlText = urlArg?.type === "Literal" && typeof urlArg.value === "string" ? `"${urlArg.value}"` : "url";
 			context.report({
 				node,
-				message: `${objectName}.${methodName}() in server action — use after() for non-blocking logging/analytics`
+				message: `fetch(${urlText}) in a Server Component / route handler defaults to forever-caching — pass { next: { revalidate: <seconds> } } / { next: { tags: [...] } } / { cache: "no-store" } so stale data doesn't quietly persist`
 			});
 		}
 	};
@@ -2326,8 +4071,7 @@ const tanstackStartServerFnValidateInput = { create: (context) => ({ CallExpress
 const tanstackStartNoUseEffectFetch = { create: (context) => ({ CallExpression(node) {
 	const filename = context.getFilename?.() ?? "";
 	if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
-	if (node.callee?.type !== "Identifier") return;
-	if (node.callee.name !== "useEffect" && node.callee.name !== "useLayoutEffect") return;
+	if (!isHookCall(node, EFFECT_HOOK_NAMES)) return;
 	const callback = node.arguments?.[0];
 	if (!callback) return;
 	let hasFetchCall = false;
@@ -2402,15 +4146,17 @@ const tanstackStartServerFnMethodOrder = { create: (context) => ({ CallExpressio
 	}
 } }) };
 const tanstackStartNoNavigateInRender = { create: (context) => {
-	let effectDepth = 0;
+	let deferredCallbackDepth = 0;
 	let eventHandlerDepth = 0;
+	const isDeferredHookCall = (node) => isHookCall(node, EFFECT_HOOK_NAMES) || isHookCall(node, "useCallback") || isHookCall(node, "useMemo");
+	const isEventHandlerAttribute = (node) => node.name?.type === "JSXIdentifier" && typeof node.name.name === "string" && node.name.name.startsWith("on") && UPPERCASE_PATTERN.test(node.name.name.charAt(2));
 	return {
 		CallExpression(node) {
 			const filename = context.getFilename?.() ?? "";
 			if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
-			if (node.callee?.type === "Identifier" && (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect")) effectDepth++;
-			if (effectDepth > 0 || eventHandlerDepth > 0) return;
-			if (node.callee?.type === "Identifier" && node.callee.name === "navigate" && node.arguments?.length > 0) context.report({
+			if (isDeferredHookCall(node)) deferredCallbackDepth++;
+			if (deferredCallbackDepth > 0 || eventHandlerDepth > 0) return;
+			if (node.callee?.type === "Identifier" && node.callee.name === "navigate" && (node.arguments?.length ?? 0) > 0) context.report({
 				node,
 				message: "navigate() called during render — use redirect() in beforeLoad/loader for route-level redirects"
 			});
@@ -2418,17 +4164,17 @@ const tanstackStartNoNavigateInRender = { create: (context) => {
 		"CallExpression:exit"(node) {
 			const filename = context.getFilename?.() ?? "";
 			if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
-			if (node.callee?.type === "Identifier" && (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect")) effectDepth--;
+			if (isDeferredHookCall(node)) deferredCallbackDepth = Math.max(0, deferredCallbackDepth - 1);
 		},
 		JSXAttribute(node) {
 			const filename = context.getFilename?.() ?? "";
 			if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
-			if (node.name?.type === "JSXIdentifier" && node.name.name.startsWith("on") && UPPERCASE_PATTERN.test(node.name.name.charAt(2))) eventHandlerDepth++;
+			if (isEventHandlerAttribute(node)) eventHandlerDepth++;
 		},
 		"JSXAttribute:exit"(node) {
 			const filename = context.getFilename?.() ?? "";
 			if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
-			if (node.name?.type === "JSXIdentifier" && node.name.name.startsWith("on") && UPPERCASE_PATTERN.test(node.name.name.charAt(2))) eventHandlerDepth--;
+			if (isEventHandlerAttribute(node)) eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
 		}
 	};
 } };
@@ -2455,6 +4201,17 @@ const tanstackStartNoUseServerInHandler = { create: (context) => ({ CallExpressi
 		message: "\"use server\" inside createServerFn handler — TanStack Start handles this automatically, remove the directive"
 	});
 } }) };
+const SAFE_BUILD_ENV_VARS = new Set([
+	"NODE_ENV",
+	"MODE",
+	"DEV",
+	"PROD"
+]);
+const SECRET_KEYWORD_PATTERN = /(?:secret|token|api[_]?key|password|private)/i;
+const isLikelySecret = (envVarName) => {
+	if (SAFE_BUILD_ENV_VARS.has(envVarName)) return false;
+	return SECRET_KEYWORD_PATTERN.test(envVarName);
+};
 const tanstackStartNoSecretsInLoader = { create: (context) => ({ CallExpression(node) {
 	const optionsObject = getRouteOptionsObject(node);
 	if (!optionsObject) return;
@@ -2464,11 +4221,15 @@ const tanstackStartNoSecretsInLoader = { create: (context) => ({ CallExpression(
 		if (keyName !== "loader" && keyName !== "beforeLoad") continue;
 		walkAst(property.value ?? property, (child) => {
 			if (child.type !== "MemberExpression") return;
-			if (child.object?.type === "MemberExpression" && child.object.object?.type === "Identifier" && child.object.object.name === "process" && child.object.property?.type === "Identifier" && child.object.property.name === "env") {
-				const envVarName = child.property?.type === "Identifier" ? child.property.name : null;
-				if (envVarName && !envVarName.startsWith("VITE_")) context.report({
+			const isProcessEnvAccess = child.object?.type === "MemberExpression" && child.object.object?.type === "Identifier" && child.object.object.name === "process" && child.object.property?.type === "Identifier" && child.object.property.name === "env";
+			const isImportMetaEnvAccess = child.object?.type === "MemberExpression" && child.object.object?.type === "MetaProperty" && child.object.property?.type === "Identifier" && child.object.property.name === "env";
+			if (!isProcessEnvAccess && !isImportMetaEnvAccess) return;
+			const envVarName = child.property?.type === "Identifier" ? child.property.name : null;
+			if (envVarName && isLikelySecret(envVarName)) {
+				const envSource = isImportMetaEnvAccess ? "import.meta.env" : "process.env";
+				context.report({
 					node: child,
-					message: `process.env.${envVarName} in ${keyName} — loaders are isomorphic and may leak secrets to the client. Move to a createServerFn()`
+					message: `${envSource}.${envVarName} in ${keyName} — loaders are isomorphic and may leak secrets to the client. Move to a createServerFn()`
 				});
 			}
 		});
@@ -2522,6 +4283,7 @@ const hasTopLevelAwait = (statement) => {
 	if (statement.type === "VariableDeclaration") return statement.declarations?.some((declarator) => declarator.init?.type === "AwaitExpression");
 	if (statement.type === "ExpressionStatement") return statement.expression?.type === "AwaitExpression" || statement.expression?.type === "AssignmentExpression" && statement.expression.right?.type === "AwaitExpression";
 	if (statement.type === "ReturnStatement") return statement.argument?.type === "AwaitExpression";
+	if (statement.type === "ForOfStatement" && statement.await) return true;
 	return false;
 };
 const tanstackStartLoaderParallelFetch = { create: (context) => ({ CallExpression(node) {
@@ -2550,7 +4312,7 @@ const tanstackStartLoaderParallelFetch = { create: (context) => ({ CallExpressio
 //#endregion
 //#region src/plugin/rules/state-and-effects.ts
 const noDerivedStateEffect = { create: (context) => ({ CallExpression(node) {
-	if (!isHookCall(node, EFFECT_HOOK_NAMES) || node.arguments.length < 2) return;
+	if (!isHookCall(node, EFFECT_HOOK_NAMES) || (node.arguments?.length ?? 0) < 2) return;
 	const callback = getEffectCallback(node);
 	if (!callback) return;
 	const depsNode = node.arguments[1];
@@ -2604,7 +4366,7 @@ const noCascadingSetState = { create: (context) => ({ CallExpression(node) {
 	});
 } }) };
 const noEffectEventHandler = { create: (context) => ({ CallExpression(node) {
-	if (!isHookCall(node, EFFECT_HOOK_NAMES) || node.arguments.length < 2) return;
+	if (!isHookCall(node, EFFECT_HOOK_NAMES) || (node.arguments?.length ?? 0) < 2) return;
 	const callback = getEffectCallback(node);
 	if (!callback) return;
 	const depsNode = node.arguments[1];
@@ -2619,24 +4381,57 @@ const noEffectEventHandler = { create: (context) => ({ CallExpression(node) {
 	});
 } }) };
 const noDerivedUseState = { create: (context) => {
-	const componentPropNames = /* @__PURE__ */ new Set();
+	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";
+	};
 	return {
 		FunctionDeclaration(node) {
-			if (!node.id?.name || !isUppercaseName(node.id.name)) return;
-			for (const name of extractDestructuredPropNames(node.params ?? [])) componentPropNames.add(name);
+			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)) return;
-			for (const name of extractDestructuredPropNames(node.init?.params ?? [])) componentPropNames.add(name);
+			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();
 		},
 		CallExpression(node) {
 			if (!isHookCall(node, "useState") || !node.arguments?.length) return;
+			if (componentPropStack.length === 0) return;
 			const initializer = node.arguments[0];
-			if (initializer.type !== "Identifier") return;
-			if (componentPropNames.has(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`
-			});
+			if (initializer.type === "Identifier" && 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`
+				});
+				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({
+					node,
+					message: `useState initialized from prop "${rootIdentifierName}" — if this value should stay in sync with the prop, derive it during render instead`
+				});
+			}
 		}
 	};
 } };
@@ -2675,15 +4470,42 @@ const rerenderLazyStateInit = { create: (context) => ({ CallExpression(node) {
 		message: `useState(${calleeName}()) calls initializer on every render — use useState(() => ${calleeName}()) for lazy initialization`
 	});
 } }) };
+const STATE_ARITHMETIC_OPERATORS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"**"
+]);
+const deriveStateVariableName = (setterName) => {
+	if (!setterName.startsWith("set") || setterName.length < 4) return null;
+	return setterName.charAt(3).toLowerCase() + setterName.slice(4);
+};
 const rerenderFunctionalSetstate = { create: (context) => ({ CallExpression(node) {
 	if (!isSetterCall(node)) return;
 	if (!node.arguments?.length) return;
 	const calleeName = node.callee.name;
 	const argument = node.arguments[0];
-	if (argument.type === "BinaryExpression" && (argument.operator === "+" || argument.operator === "-") && argument.left?.type === "Identifier") context.report({
-		node,
-		message: `${calleeName}(${argument.left.name} ${argument.operator} ...) — use functional update to avoid stale closures`
-	});
+	const expectedStateName = deriveStateVariableName(calleeName);
+	if (argument.type === "BinaryExpression" && STATE_ARITHMETIC_OPERATORS.has(argument.operator) && expectedStateName) {
+		const matchesExpected = (operand) => operand?.type === "Identifier" && operand.name === expectedStateName;
+		const stateIdentifier = matchesExpected(argument.left) ? argument.left : matchesExpected(argument.right) ? argument.right : null;
+		if (stateIdentifier) {
+			context.report({
+				node,
+				message: `${calleeName}(${stateIdentifier.name} ${argument.operator} ...) — use functional update to avoid stale closures`
+			});
+			return;
+		}
+	}
+	if (argument.type === "UpdateExpression" && (argument.operator === "++" || argument.operator === "--") && argument.argument?.type === "Identifier" && argument.argument.name === expectedStateName) {
+		const display = argument.prefix ? `${argument.operator}${argument.argument.name}` : `${argument.argument.name}${argument.operator}`;
+		context.report({
+			node,
+			message: `${calleeName}(${display}) — use functional update to avoid stale closures (and reading the post-increment value bug)`
+		});
+	}
 } }) };
 const rerenderDependencies = { create: (context) => ({ CallExpression(node) {
 	if (!isHookCall(node, HOOKS_WITH_DEPS) || node.arguments.length < 2) return;
@@ -2701,6 +4523,295 @@ const rerenderDependencies = { create: (context) => ({ CallExpression(node) {
 		});
 	}
 } }) };
+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";
+	};
+	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();
+		},
+		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;
+				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`
+				});
+			}
+		}
+	};
+} };
+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();
+	};
+	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();
+		},
+		CallExpression(node) {
+			if (!isHookCall(node, HOOKS_WITH_DEPS) || node.arguments.length < 2) return;
+			if (componentBindingStack.length === 0) 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({
+					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`
+				});
+			}
+		}
+	};
+} };
+const collectUseStateBindings = (componentBody) => {
+	const bindings = [];
+	if (componentBody?.type !== "BlockStatement") return bindings;
+	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;
+			bindings.push({
+				valueName: valueElement.name,
+				setterName: setterElement.name,
+				declarator
+			});
+		}
+	}
+	return bindings;
+};
+const collectReturnExpressions = (componentBody) => {
+	if (componentBody?.type !== "BlockStatement") return [];
+	const returns = [];
+	for (const statement of componentBody.body ?? []) {
+		if (statement.type === "ReturnStatement" && statement.argument) {
+			returns.push(statement.argument);
+			continue;
+		}
+		walkInsideStatementBlocks(statement, (child) => {
+			if (child.type === "ReturnStatement" && child.argument) returns.push(child.argument);
+		});
+	}
+	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 expressionReadsName = (expression, name) => {
+	let didRead = false;
+	walkAst(expression, (child) => {
+		if (didRead) return;
+		if (child.type === "Identifier" && child.name === name) didRead = true;
+	});
+	return didRead;
+};
+const rerenderStateOnlyInHandlers = { create: (context) => {
+	const checkComponent = (componentBody) => {
+		if (!componentBody || componentBody.type !== "BlockStatement") return;
+		const bindings = collectUseStateBindings(componentBody);
+		if (bindings.length === 0) return;
+		const returnExpressions = collectReturnExpressions(componentBody);
+		if (returnExpressions.length === 0) return;
+		for (const binding of bindings) {
+			if (returnExpressions.some((expression) => expressionReadsName(expression, binding.valueName))) continue;
+			let setterCalled = false;
+			walkAst(componentBody, (child) => {
+				if (setterCalled) return;
+				if (child.type === "CallExpression" && child.callee?.type === "Identifier" && child.callee.name === binding.setterName) setterCalled = true;
+			});
+			if (!setterCalled) continue;
+			context.report({
+				node: binding.declarator,
+				message: `useState "${binding.valueName}" is updated but never read in the component's return — use useRef so updates don't trigger re-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 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;
+	const callback = getEffectCallback(node);
+	if (!callback) return;
+	const depsNode = node.arguments[1];
+	if (depsNode.type !== "ArrayExpression" || !depsNode.elements?.length) return;
+	const depIdentifierNames = /* @__PURE__ */ new Set();
+	for (const element of depsNode.elements) if (element?.type === "Identifier") depIdentifierNames.add(element.name);
+	if (depIdentifierNames.size === 0) return;
+	let registeredHandlerName = null;
+	walkAst(callback.body, (child) => {
+		if (registeredHandlerName) return;
+		if (child.type !== "CallExpression") return;
+		if (child.callee?.type !== "MemberExpression") return;
+		if (child.callee.property?.type !== "Identifier") return;
+		if (!SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name)) return;
+		const handlerArg = child.arguments?.[1];
+		if (handlerArg?.type !== "Identifier") return;
+		if (depIdentifierNames.has(handlerArg.name)) registeredHandlerName = handlerArg.name;
+	});
+	if (registeredHandlerName) context.report({
+		node,
+		message: `useEffect re-subscribes a "${registeredHandlerName}" listener every time the handler identity changes — store the handler in a ref and have the listener read \`handlerRef.current()\`, then drop it from the deps`
+	});
+} }) };
+const DEFERRABLE_HOOK_NAMES = new Set([
+	"useSearchParams",
+	"useParams",
+	"usePathname"
+]);
+const findHookCallBindings = (componentBody) => {
+	const bindings = [];
+	if (componentBody?.type !== "BlockStatement") return bindings;
+	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;
+			const callee = declarator.init.callee;
+			if (callee?.type !== "Identifier") continue;
+			if (!DEFERRABLE_HOOK_NAMES.has(callee.name)) continue;
+			bindings.push({
+				valueName: declarator.id.name,
+				hookName: callee.name,
+				declarator
+			});
+		}
+	}
+	return bindings;
+};
+const collectHandlerBindingNames = (componentBody) => {
+	const handlerNames = /* @__PURE__ */ new Set();
+	walkAst(componentBody, (child) => {
+		if (child.type !== "JSXAttribute") return;
+		if (child.name?.type !== "JSXIdentifier") return;
+		if (!/^on[A-Z]/.test(child.name.name)) return;
+		if (child.value?.type !== "JSXExpressionContainer") return;
+		const expression = child.value.expression;
+		if (expression?.type === "Identifier") handlerNames.add(expression.name);
+	});
+	return handlerNames;
+};
+const isInsideEventHandler = (node, handlerBindingNames) => {
+	let cursor = node.parent ?? null;
+	while (cursor) {
+		if (cursor.type === "ArrowFunctionExpression" || cursor.type === "FunctionExpression" || cursor.type === "FunctionDeclaration") {
+			let outer = cursor.parent ?? null;
+			while (outer) {
+				if (outer.type === "JSXAttribute") {
+					const attrName = outer.name?.type === "JSXIdentifier" ? outer.name.name : null;
+					if (attrName && /^on[A-Z]/.test(attrName)) return true;
+					return false;
+				}
+				if (outer.type === "VariableDeclarator") {
+					const declaredName = outer.id?.type === "Identifier" ? outer.id.name : null;
+					return Boolean(declaredName && handlerBindingNames.has(declaredName));
+				}
+				if (outer.type === "Program") return false;
+				outer = outer.parent ?? null;
+			}
+			return false;
+		}
+		cursor = cursor.parent ?? null;
+	}
+	return false;
+};
 //#endregion
 //#region src/plugin/index.ts
 const plugin = {
@@ -2710,21 +4821,69 @@ const plugin = {
 		"no-fetch-in-effect": noFetchInEffect,
 		"no-cascading-set-state": noCascadingSetState,
 		"no-effect-event-handler": noEffectEventHandler,
+		"no-effect-event-in-deps": noEffectEventInDeps,
+		"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) => {
+			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);
+				}
+			};
+		} },
+		"advanced-event-handler-refs": advancedEventHandlerRefs,
+		"no-generic-handler-names": noGenericHandlerNames,
 		"no-giant-component": noGiantComponent,
+		"no-many-boolean-props": noManyBooleanProps,
+		"no-react19-deprecated-apis": noReact19DeprecatedApis,
+		"no-render-prop-children": noRenderPropChildren,
 		"no-render-in-render": noRenderInRender,
 		"no-nested-component-definition": noNestedComponentDefinition,
+		"react-compiler-destructure-method": reactCompilerDestructureMethod,
 		"no-usememo-simple-expression": noUsememoSimpleExpression,
 		"no-layout-property-animation": noLayoutPropertyAnimation,
 		"rerender-memo-with-default-value": rerenderMemoWithDefaultValue,
+		"rerender-memo-before-early-return": rerenderMemoBeforeEarlyReturn,
+		"rerender-transitions-scroll": rerenderTransitionsScroll,
+		"rerender-derived-state-from-hook": rerenderDerivedStateFromHook,
+		"async-defer-await": asyncDeferAwait,
+		"async-await-in-loop": asyncAwaitInLoop,
 		"rendering-animate-svg-wrapper": renderingAnimateSvgWrapper,
+		"rendering-hoist-jsx": renderingHoistJsx,
+		"rendering-hydration-mismatch-time": renderingHydrationMismatchTime,
 		"no-inline-prop-on-memo-component": noInlinePropOnMemoComponent,
 		"rendering-hydration-no-flicker": renderingHydrationNoFlicker,
 		"rendering-script-defer-async": renderingScriptDeferAsync,
+		"rendering-usetransition-loading": renderingUsetransitionLoading,
 		"no-transition-all": noTransitionAll,
 		"no-global-css-variable-animation": noGlobalCssVariableAnimation,
 		"no-large-animated-blur": noLargeAnimatedBlur,
@@ -2733,14 +4892,37 @@ const plugin = {
 		"no-eval": noEval,
 		"no-secrets-in-client-code": noSecretsInClientCode,
 		"no-barrel-import": noBarrelImport,
+		"no-dynamic-import-path": noDynamicImportPath,
 		"no-full-lodash-import": noFullLodashImport,
 		"no-moment": noMoment,
 		"prefer-dynamic-import": preferDynamicImport,
 		"use-lazy-motion": useLazyMotion,
 		"no-undeferred-third-party": noUndeferredThirdParty,
 		"no-array-index-as-key": noArrayIndexAsKey,
+		"no-polymorphic-children": noPolymorphicChildren,
 		"rendering-conditional-render": renderingConditionalRender,
+		"rendering-svg-precision": renderingSvgPrecision,
 		"no-prevent-default": noPreventDefault,
+		"no-document-start-view-transition": { create: (context) => ({ CallExpression(node) {
+			const callee = node.callee;
+			if (callee?.type !== "MemberExpression") return;
+			if (callee.object?.type !== "Identifier" || callee.object.name !== "document") return;
+			if (callee.property?.type !== "Identifier" || callee.property.name !== "startViewTransition") return;
+			context.report({
+				node,
+				message: "document.startViewTransition() bypasses React's <ViewTransition> integration — render a <ViewTransition> component and let React drive the transition (around startTransition / useDeferredValue / Suspense)"
+			});
+		} }) },
+		"no-flush-sync": { create: (context) => ({ ImportDeclaration(node) {
+			if (node.source?.value !== "react-dom") return;
+			for (const specifier of node.specifiers ?? []) {
+				if (specifier.type !== "ImportSpecifier") continue;
+				if (specifier.imported?.name === "flushSync") context.report({
+					node: specifier,
+					message: "flushSync from react-dom skips View Transition snapshots and concurrent rendering — prefer startTransition for non-urgent updates"
+				});
+			}
+		} }) },
 		"nextjs-no-img-element": nextjsNoImgElement,
 		"nextjs-async-client-component": nextjsAsyncClientComponent,
 		"nextjs-no-a-element": nextjsNoAElement,
@@ -2759,10 +4941,20 @@ const plugin = {
 		"nextjs-no-side-effect-in-get-handler": nextjsNoSideEffectInGetHandler,
 		"server-auth-actions": serverAuthActions,
 		"server-after-nonblocking": serverAfterNonblocking,
+		"server-no-mutable-module-state": serverNoMutableModuleState,
+		"server-cache-with-object-literal": serverCacheWithObjectLiteral,
+		"server-hoist-static-io": serverHoistStaticIo,
+		"server-dedup-props": serverDedupProps,
+		"server-sequential-independent-await": serverSequentialIndependentAwait,
+		"server-fetch-without-revalidate": serverFetchWithoutRevalidate,
 		"client-passive-event-listeners": clientPassiveEventListeners,
+		"client-localstorage-no-version": clientLocalstorageNoVersion,
 		"js-combine-iterations": jsCombineIterations,
 		"js-tosorted-immutable": jsTosortedImmutable,
 		"js-hoist-regexp": jsHoistRegexp,
+		"js-hoist-intl": jsHoistIntl,
+		"js-cache-property-access": jsCachePropertyAccess,
+		"js-length-check-first": jsLengthCheckFirst,
 		"js-min-max-loop": jsMinMaxLoop,
 		"js-set-map-lookups": jsSetMapLookups,
 		"js-batch-dom-css": jsBatchDomCss,
@@ -2779,6 +4971,22 @@ const plugin = {
 		"rn-no-legacy-shadow-styles": rnNoLegacyShadowStyles,
 		"rn-prefer-reanimated": rnPreferReanimated,
 		"rn-no-single-element-style-array": rnNoSingleElementStyleArray,
+		"rn-prefer-pressable": rnPreferPressable,
+		"rn-prefer-expo-image": rnPreferExpoImage,
+		"rn-no-non-native-navigator": rnNoNonNativeNavigator,
+		"rn-no-scroll-state": rnNoScrollState,
+		"rn-no-scrollview-mapped-list": rnNoScrollviewMappedList,
+		"rn-no-inline-object-in-list-item": rnNoInlineObjectInListItem,
+		"rn-animate-layout-property": rnAnimateLayoutProperty,
+		"rn-prefer-content-inset-adjustment": rnPreferContentInsetAdjustment,
+		"rn-pressable-shared-value-mutation": rnPressableSharedValueMutation,
+		"rn-list-data-mapped": rnListDataMapped,
+		"rn-list-callback-per-row": rnListCallbackPerRow,
+		"rn-list-recyclable-without-types": rnListRecyclableWithoutTypes,
+		"rn-animation-reaction-as-derived": rnAnimationReactionAsDerived,
+		"rn-bottom-sheet-prefer-native": rnBottomSheetPreferNative,
+		"rn-scrollview-dynamic-padding": rnScrollviewDynamicPadding,
+		"rn-style-prefer-boxshadow": rnStylePreferBoxShadow,
 		"tanstack-start-route-property-order": tanstackStartRoutePropertyOrder,
 		"tanstack-start-no-direct-fetch-in-loader": tanstackStartNoDirectFetchInLoader,
 		"tanstack-start-server-fn-validate-input": tanstackStartServerFnValidateInput,