oxlint-plugin-react-doctor 0.7.4-dev.b686594 → 0.7.4-dev.dfccac4

package/dist/index.js

@@ -614,11 +614,24 @@ const TRIVIAL_CONSTRUCTOR_NAMES = new Set([
 	"URLSearchParams",
 	"AbortController"
 ]);
+const TRIVIAL_DERIVATION_CALLEE_NAMES = new Set([
+	"Boolean",
+	"String",
+	"Number",
+	"Array",
+	"Object",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"BigInt",
+	"Symbol"
+]);
 const SETTER_PATTERN = /^set[A-Z]/;
 const RENDER_FUNCTION_PATTERN = /^render[A-Z]/;
 const UPPERCASE_PATTERN = /^[A-Z]/;
 const REACT_HANDLER_PROP_PATTERN = /^on[A-Z]/;
-const HOOK_NAME_PATTERN$3 = /^use[A-Z]/;
+const HOOK_NAME_PATTERN$4 = /^use[A-Z]/;
 const HANDLER_FUNCTION_NAME_PATTERN = /^(?:on|handle)[A-Z]/;
 const EFFECT_HOOK_NAMES$1 = new Set(["useEffect", "useLayoutEffect"]);
 const HOOKS_WITH_DEPS = new Set([
@@ -7394,7 +7407,7 @@ const containsJsx$1 = (root) => {
 	containsJsxCache.set(root, found);
 	return found;
 };
-const getStaticMemberName$1 = (node) => {
+const getStaticMemberName = (node) => {
 	if (!isNodeOfType(node, "MemberExpression")) return null;
 	if (!node.computed && isNodeOfType(node.property, "Identifier")) return node.property.name;
 	if (node.computed && isNodeOfType(node.property, "Literal") && typeof node.property.value === "string") return node.property.value;
@@ -7408,7 +7421,7 @@ const getAssignedName = (node) => {
 	if (isNodeOfType(parent, "AssignmentExpression")) {
 		const left = parent.left;
 		if (isNodeOfType(left, "Identifier")) return left.name;
-		if (isNodeOfType(left, "MemberExpression")) return getStaticMemberName$1(left);
+		if (isNodeOfType(left, "MemberExpression")) return getStaticMemberName(left);
 	}
 	return null;
 };
@@ -7416,20 +7429,20 @@ const isModuleExportsAssignment = (node) => {
 	const parent = node.parent;
 	if (!parent || !isNodeOfType(parent, "AssignmentExpression")) return false;
 	const left = parent.left;
-	return isNodeOfType(left, "MemberExpression") && isNodeOfType(left.object, "Identifier") && left.object.name === "module" && getStaticMemberName$1(left) === "exports";
+	return isNodeOfType(left, "MemberExpression") && isNodeOfType(left.object, "Identifier") && left.object.name === "module" && getStaticMemberName(left) === "exports";
 };
 const isCreateClassLikeCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	if (isEs5Component(node)) return true;
 	const callee = node.callee;
-	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName$1(callee) === "createClass";
+	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName(callee) === "createClass";
 	return false;
 };
 const isCreateContextCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	const callee = node.callee;
 	if (isNodeOfType(callee, "Identifier")) return callee.name === "createContext";
-	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName$1(callee) === "createContext";
+	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName(callee) === "createContext";
 };
 const isNamedFunctionLike = (node) => (isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && Boolean(node.id?.name);
 const firstCallArgument = (node) => {
@@ -7487,7 +7500,7 @@ const memberExpressionPath = (node) => {
 	if (isNodeOfType(node, "Identifier")) return [node.name];
 	if (!isNodeOfType(node, "MemberExpression")) return [];
 	const objectPath = memberExpressionPath(node.object);
-	const propertyName = getStaticMemberName$1(node);
+	const propertyName = getStaticMemberName(node);
 	return propertyName ? [...objectPath, propertyName] : objectPath;
 };
 const displayNameAssignmentIndexCache = /* @__PURE__ */ new WeakMap();
@@ -7497,7 +7510,7 @@ const getDisplayNameAssignmentIndex = (programRoot) => {
 	const identifierTargets = /* @__PURE__ */ new Set();
 	const memberPathSegments = /* @__PURE__ */ new Set();
 	const visit = (node) => {
-		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName$1(node.left) === "displayName") {
+		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName(node.left) === "displayName") {
 			if (isNodeOfType(node.left.object, "Identifier")) identifierTargets.add(node.left.object.name);
 			for (const segment of memberExpressionPath(node.left.object)) memberPathSegments.add(segment);
 		}
@@ -12171,7 +12184,7 @@ const isAtomFromJotai = (callExpression) => {
 	if (!isImportedFromModule(callExpression, localName, "jotai")) return false;
 	return getImportedNameFromModule(callExpression, localName, "jotai") === "atom";
 };
-const isFunctionExpressionLike$2 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
+const isFunctionExpressionLike$3 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
 const getFirstParameterName = (fn) => {
 	const parameters = fn.params ?? [];
 	if (parameters.length !== 1) return null;
@@ -12304,7 +12317,7 @@ const jotaiDerivedAtomReturnsFreshObject = defineRule({
 		const args = node.arguments ?? [];
 		if (args.length === 0) return;
 		const reader = args[0];
-		if (!isFunctionExpressionLike$2(reader)) return;
+		if (!isFunctionExpressionLike$3(reader)) return;
 		const getParameterName = getFirstParameterName(reader);
 		if (!getParameterName) return;
 		const freshReturn = getFreshReturnForFunction(reader);
@@ -12396,14 +12409,14 @@ const getHandlerNamedBindingName = (functionNode) => {
 const containingFunctionIsComponentOrHook = (functionNode) => {
 	if (isNodeOfType(functionNode, "FunctionDeclaration") && functionNode.id) {
 		const declaredName = functionNode.id.name;
-		return COMPONENT_NAME_PATTERN.test(declaredName) || HOOK_NAME_PATTERN$3.test(declaredName);
+		return COMPONENT_NAME_PATTERN.test(declaredName) || HOOK_NAME_PATTERN$4.test(declaredName);
 	}
 	let cursor = functionNode.parent ?? null;
 	while (cursor && isNodeOfType(cursor, "CallExpression")) cursor = cursor.parent ?? null;
 	if (!cursor) return false;
 	if (!isNodeOfType(cursor, "VariableDeclarator")) return false;
 	if (!isNodeOfType(cursor.id, "Identifier")) return false;
-	return COMPONENT_NAME_PATTERN.test(cursor.id.name) || HOOK_NAME_PATTERN$3.test(cursor.id.name);
+	return COMPONENT_NAME_PATTERN.test(cursor.id.name) || HOOK_NAME_PATTERN$4.test(cursor.id.name);
 };
 const isBindingInvokedOnRenderPath = (root, bindingName) => {
 	let didFindRenderPathInvocation = false;
@@ -21325,6 +21338,19 @@ const noAccessKey = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-call-method-name.ts
+/**
+* Returns the static method name of a call's callee when it's a
+* non-computed MemberExpression (`obj.method` → `"method"`), or
+* `null` otherwise. Used by `no-pass-data-to-parent` and
+* `no-pass-live-state-to-parent` to match the receiver-bound
+* method-call shape against an allow/block list.
+*/
+const getCallMethodName = (callee) => {
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+//#endregion
 //#region src/plugin/utils/reads-post-mount-value.ts
 const DOM_QUERY_MEMBER_NAMES = new Set([
 	"getBoundingClientRect",
@@ -21422,6 +21448,13 @@ const isPostMountMemberRead = (node) => {
 	if (!LAYOUT_MEASUREMENT_MEMBER_NAMES.has(memberName)) return false;
 	return isRefLikeReceiver(node.object);
 };
+const isMeasurementMemberRead = (node) => {
+	if (!isPostMountMemberRead(node)) return false;
+	if (!isNodeOfType(node, "MemberExpression") || !isNodeOfType(node.property, "Identifier")) return false;
+	if (!DOM_QUERY_MEMBER_NAMES.has(node.property.name)) return true;
+	const parent = node.parent;
+	return Boolean(parent && isNodeOfType(parent, "CallExpression") && parent.callee === node);
+};
 const isPropertyNamePosition$1 = (identifier) => {
 	const parent = identifier.parent;
 	if (!parent) return false;
@@ -21539,10 +21572,10 @@ const getScopeForNode = (node, manager) => {
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/ast.ts
 const getChildKeys = (node) => VISITOR_KEYS[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
-const HOOK_NAME_PATTERN$2 = /^use[A-Z0-9]/;
+const HOOK_NAME_PATTERN$3 = /^use[A-Z0-9]/;
 const isInsideCallbackArgumentOf = (identifier, initializer) => {
 	if (!isNodeOfType(initializer, "CallExpression") && !isNodeOfType(initializer, "NewExpression")) return false;
-	if (isNodeOfType(initializer, "CallExpression") && isNodeOfType(initializer.callee, "Identifier") && HOOK_NAME_PATTERN$2.test(initializer.callee.name)) return false;
+	if (isNodeOfType(initializer, "CallExpression") && isNodeOfType(initializer.callee, "Identifier") && HOOK_NAME_PATTERN$3.test(initializer.callee.name)) return false;
 	const callbackArguments = (initializer.arguments ?? []).filter((argument) => isFunctionLike$1(argument));
 	if (callbackArguments.length === 0) return false;
 	let node = identifier;
@@ -21706,133 +21739,6 @@ const getEventualCallRefsTo = (analysis, ref, predicate) => {
 	return callExprRefs.filter(predicate);
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/effect/external-state.ts
-const DEFERRING_CALLEE_NAMES$1 = new Set([
-	"setTimeout",
-	"setInterval",
-	"setImmediate",
-	"requestAnimationFrame",
-	"requestIdleCallback",
-	"queueMicrotask",
-	"addEventListener",
-	"addListener",
-	"subscribe",
-	"observe",
-	"watch",
-	"watchPosition",
-	"then",
-	"catch",
-	"finally",
-	"on",
-	"once"
-]);
-const getCalleeName$1 = (callee) => {
-	if (!callee) return null;
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
-	return null;
-};
-const parentOf = (node) => node.parent ?? null;
-const argumentsInclude = (args, target) => (args ?? []).some((argument) => argument === target);
-const isDeferredCallbackPosition = (expression) => {
-	const parent = parentOf(expression);
-	if (!parent) return false;
-	if (isNodeOfType(parent, "CallExpression") && argumentsInclude(parent.arguments, expression)) {
-		const name = getCalleeName$1(parent.callee);
-		if (name && DEFERRING_CALLEE_NAMES$1.has(name)) return true;
-	}
-	if (isNodeOfType(parent, "NewExpression") && argumentsInclude(parent.arguments, expression)) {
-		const name = getCalleeName$1(parent.callee);
-		if (name && (name.endsWith("Observer") || name === "Promise")) return true;
-	}
-	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === expression && isNodeOfType(parent.left, "MemberExpression") && isNodeOfType(parent.left.property, "Identifier") && parent.left.property.name.startsWith("on")) return true;
-	return false;
-};
-const getHandlerDeclarator = (fn) => {
-	let current = fn;
-	let parent = parentOf(current);
-	while (parent && isNodeOfType(parent, "CallExpression") && argumentsInclude(parent.arguments, current)) {
-		current = parent;
-		parent = parentOf(current);
-	}
-	if (parent && isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent;
-	return null;
-};
-const isNamedHandlerUsedAsDeferredCallback = (analysis, fn) => {
-	const declarator = getHandlerDeclarator(fn);
-	if (!declarator || !isNodeOfType(declarator.id, "Identifier")) return false;
-	const name = declarator.id.name;
-	for (const scope of analysis.scopeManager.scopes) {
-		const variable = scope.variables.find((candidate) => candidate.name === name && candidate.defs.some((def) => def.node === declarator));
-		if (!variable) continue;
-		return variable.references.some((reference) => isDeferredCallbackPosition(reference.identifier));
-	}
-	return false;
-};
-const isDeferredCallbackFunction = (analysis, fn) => {
-	if (isDeferredCallbackPosition(fn)) return true;
-	return isNamedHandlerUsedAsDeferredCallback(analysis, fn);
-};
-const isInsideDeferredCallback$1 = (analysis, node, boundary) => {
-	let current = parentOf(node);
-	while (current && current !== boundary) {
-		if (isFunctionLike$1(current) && isDeferredCallbackFunction(analysis, current)) return true;
-		current = parentOf(current);
-	}
-	return false;
-};
-const findUseStateDeclarator = (ref) => {
-	for (const def of ref.resolved?.defs ?? []) {
-		const node = def.node;
-		if (!isNodeOfType(node, "VariableDeclarator")) continue;
-		if (!isNodeOfType(node.init, "CallExpression")) continue;
-		if (!isNodeOfType(node.id, "ArrayPattern")) continue;
-		return node;
-	}
-	return null;
-};
-const declaratorToExternallyDriven = /* @__PURE__ */ new WeakMap();
-const isExternallyDrivenState = (analysis, ref) => {
-	const declarator = findUseStateDeclarator(ref);
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
-	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
-	const cached = declaratorToExternallyDriven.get(declarator);
-	if (cached !== void 0) return cached;
-	const result = computeExternallyDriven(analysis, declarator);
-	declaratorToExternallyDriven.set(declarator, result);
-	return result;
-};
-const computeExternallyDriven = (analysis, declarator) => {
-	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
-	const setterElement = declarator.id.elements?.[1];
-	if (!setterElement || !isNodeOfType(setterElement, "Identifier")) return false;
-	const setterName = setterElement.name;
-	let setterVariable = null;
-	for (const scope of analysis.scopeManager.scopes) {
-		const match = scope.variables.find((variable) => variable.name === setterName && variable.defs.some((def) => def.node === declarator));
-		if (match) {
-			setterVariable = match;
-			break;
-		}
-	}
-	if (!setterVariable) return false;
-	let hasDeferredCallSite = false;
-	for (const setterReference of setterVariable.references) {
-		const identifier = setterReference.identifier;
-		const parent = parentOf(identifier);
-		if (!parent) continue;
-		if (isDeferredCallbackPosition(identifier)) {
-			hasDeferredCallSite = true;
-			continue;
-		}
-		if (!isNodeOfType(parent, "CallExpression")) continue;
-		if (parent.callee !== identifier) continue;
-		if (!isInsideDeferredCallback$1(analysis, parent, declarator)) return false;
-		hasDeferredCallSite = true;
-	}
-	return hasDeferredCallSite;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/react.ts
 const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
@@ -22096,736 +22002,167 @@ const findContainingNode = (analysis, node) => {
 	return findContainingNode(analysis, parent);
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/event-handler-reference.ts
-const isEventHandlerName = (name) => /^on[A-Z]/.test(name);
-const getStaticMemberReferenceName = (node, resolveName = (name) => name) => {
-	if (!isNodeOfType(node, "MemberExpression")) return null;
-	if (!isNodeOfType(node.object, "Identifier")) return null;
-	const propertyName = getStaticMemberPropertyName(node);
-	return propertyName ? `${resolveName(node.object.name)}.${propertyName}` : null;
-};
-const isEventHandlerValue = (node, eventHandlerReferenceNames, resolveName = (name) => name) => {
-	if (isInlineFunctionExpression(node)) return true;
-	if (isNodeOfType(node, "Identifier")) return eventHandlerReferenceNames.has(resolveName(node.name));
-	const memberReferenceName = getStaticMemberReferenceName(node, resolveName);
-	return Boolean(memberReferenceName && eventHandlerReferenceNames.has(memberReferenceName));
-};
-const isIntrinsicJsxAttribute = (node) => {
-	if (!isNodeOfType(node, "JSXAttribute")) return false;
-	const openingElement = node.parent;
-	if (!isNodeOfType(openingElement, "JSXOpeningElement")) return false;
-	const elementName = openingElement.name;
-	if (!isNodeOfType(elementName, "JSXIdentifier")) return false;
-	return /^[a-z]/.test(elementName.name);
-};
-//#endregion
-//#region src/plugin/rules/state-and-effects/utils/is-controlled-prop-mirror.ts
-const ownScopeBoundNamesCache = /* @__PURE__ */ new WeakMap();
-const getOwnScopeBoundNames = (functionNode) => {
-	const cached = ownScopeBoundNamesCache.get(functionNode);
-	if (cached) return cached;
-	const boundNames = /* @__PURE__ */ new Set();
-	if (isFunctionLike$1(functionNode)) for (const param of functionNode.params ?? []) collectPatternNames(param, boundNames);
-	walkAst(functionNode, (child) => {
-		if (child !== functionNode && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "VariableDeclarator")) collectPatternNames(child.id, boundNames);
-	});
-	ownScopeBoundNamesCache.set(functionNode, boundNames);
-	return boundNames;
-};
-const declaresBindingNamed = (functionNode, bindingName) => getOwnScopeBoundNames(functionNode).has(bindingName);
-const isPropertyNamePosition = (identifier) => {
-	const parent = identifier.parent;
-	if (!parent) return false;
-	if (isNodeOfType(parent, "MemberExpression")) return parent.property === identifier && !parent.computed;
-	if (isNodeOfType(parent, "Property")) return parent.key === identifier && !parent.computed;
-	return false;
-};
-const referencesIdentifierNamed = (root, identifierName) => {
-	let isReferenced = false;
-	walkAst(root, (child) => {
-		if (isReferenced) return false;
-		if (child !== root && isFunctionLike$1(child) && declaresBindingNamed(child, identifierName)) return false;
-		if (isNodeOfType(child, "Identifier") && child.name === identifierName && !isPropertyNamePosition(child)) {
-			isReferenced = true;
-			return false;
-		}
-	});
-	return isReferenced;
-};
-const isSetterWiredToJsxHandler = (componentFunction, setterName) => {
-	let isWired = false;
-	walkAst(componentFunction, (child) => {
-		if (isWired) return false;
-		if (child !== componentFunction && isFunctionLike$1(child) && declaresBindingNamed(child, setterName)) return false;
-		if (!isNodeOfType(child, "JSXAttribute") || !child.value) return;
-		const attributeName = getJsxAttributeName(child.name);
-		if (!attributeName || !isEventHandlerName(attributeName)) return;
-		if (referencesIdentifierNamed(child.value, setterName)) {
-			isWired = true;
-			return false;
-		}
-	});
-	return isWired;
-};
-//#endregion
-//#region src/plugin/rules/state-and-effects/utils/has-user-input-setter-writer.ts
-const HANDLER_BINDING_NAME_PATTERN = /^(on|handle)[A-Z_]/;
-const isEventHandlerPropertyKey = (property) => isNodeOfType(property, "Property") && !property.computed && isNodeOfType(property.key, "Identifier") && isEventHandlerName(property.key.name);
-const DEFERRED_CALLBACK_MEMBER_NAMES = new Set([
-	"then",
-	"catch",
-	"finally",
-	"subscribe"
-]);
-const DEFERRED_CALLBACK_CALLEE_NAMES = new Set([
-	"setTimeout",
-	"setInterval",
-	"requestAnimationFrame",
-	"addEventListener",
-	"addListener"
-]);
-const isDeferredCallbackArgumentOf = (callExpr, child) => {
-	if (!isNodeOfType(callExpr, "CallExpression")) return false;
-	if (!(callExpr.arguments ?? []).includes(child)) return false;
-	const callee = callExpr.callee;
-	if (isNodeOfType(callee, "Identifier")) return DEFERRED_CALLBACK_CALLEE_NAMES.has(callee.name);
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return DEFERRED_CALLBACK_MEMBER_NAMES.has(callee.property.name) || DEFERRED_CALLBACK_CALLEE_NAMES.has(callee.property.name);
+//#region src/plugin/rules/state-and-effects/no-adjust-state-on-prop-change.ts
+const isLiteralOnlyExpression$1 = (node) => {
+	if (!node) return false;
+	if (isNodeOfType(node, "Literal")) return true;
+	if (isNodeOfType(node, "Identifier") && node.name === "undefined") return true;
+	if (isNodeOfType(node, "UnaryExpression")) return isLiteralOnlyExpression$1(node.argument);
+	if (isNodeOfType(node, "ObjectExpression")) return (node.properties ?? []).every((property) => isNodeOfType(property, "Property") && !property.computed && isLiteralOnlyExpression$1(property.value));
+	if (isNodeOfType(node, "ArrayExpression")) return (node.elements ?? []).every((element) => isLiteralOnlyExpression$1(element));
+	if (isNodeOfType(node, "NewExpression")) {
+		const callee = node.callee;
+		return isNodeOfType(callee, "Identifier") && (callee.name === "Map" || callee.name === "Set") && (node.arguments ?? []).length === 0;
+	}
 	return false;
 };
-const isIndependentWriterIdentifier = (componentFunction, identifier, includeDeferredWriters) => {
-	let outermostFunctionBelowComponent = null;
-	let previous = identifier;
-	let cursor = identifier.parent;
-	while (cursor && cursor !== componentFunction) {
-		if (isNodeOfType(cursor, "JSXAttribute")) {
-			const attributeName = getJsxAttributeName(cursor.name);
-			if (attributeName && isEventHandlerName(attributeName)) return true;
-		}
-		if (isEventHandlerPropertyKey(cursor)) return true;
-		if (includeDeferredWriters && isDeferredCallbackArgumentOf(cursor, previous)) return true;
-		if (isFunctionLike$1(cursor)) {
-			outermostFunctionBelowComponent = cursor;
-			if (includeDeferredWriters && cursor.async === true) return true;
+const isSpreadMergeOfLiterals = (body) => {
+	if (!body || !isNodeOfType(body, "ObjectExpression")) return false;
+	const properties = body.properties ?? [];
+	let sawSpread = false;
+	for (const property of properties) {
+		if (isNodeOfType(property, "SpreadElement")) {
+			sawSpread = true;
+			continue;
 		}
-		previous = cursor;
-		cursor = cursor.parent ?? null;
+		if (!isNodeOfType(property, "Property")) return false;
+		if (!isLiteralOnlyExpression$1(property.value)) return false;
 	}
-	if (!outermostFunctionBelowComponent) return false;
-	const bindingName = getFunctionBindingName$1(outermostFunctionBelowComponent);
-	if (!bindingName) return false;
-	if (HANDLER_BINDING_NAME_PATTERN.test(bindingName)) return true;
-	return isSetterWiredToJsxHandler(componentFunction, bindingName);
+	return sawSpread;
 };
-const hasUserInputSetterWriter = (setterRef, effectNode, includeDeferredWriters = false) => {
-	if (!setterRef.resolved) return false;
-	const componentFunction = findEnclosingFunction(effectNode);
-	if (!componentFunction) return false;
-	for (const reference of setterRef.resolved.references) {
-		if (reference.init) continue;
-		const identifier = reference.identifier;
-		if (isAstDescendant(identifier, effectNode)) continue;
-		if (isIndependentWriterIdentifier(componentFunction, identifier, includeDeferredWriters)) return true;
+const isConstantSetterArgument = (analysis, callExpr) => {
+	const argument = callExpr.arguments?.[0];
+	if (!argument) return true;
+	if (isLiteralOnlyExpression$1(argument)) return true;
+	if (isNodeOfType(argument, "Identifier")) {
+		const argumentRef = getRef(analysis, argument);
+		if (argumentRef && isConstant(argumentRef)) return true;
 	}
+	if (isNodeOfType(argument, "ArrowFunctionExpression")) return isSpreadMergeOfLiterals(argument.body);
 	return false;
 };
-//#endregion
-//#region src/plugin/rules/state-and-effects/utils/reads-post-mount-through-locals.ts
-const isBareRefCurrentRead = (node) => isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && node.property.name === "current";
-const matchesPostMountRead = (node, options) => {
-	if (isPostMountGlobalRead(node)) return true;
-	if (!isPostMountMemberRead(node)) return false;
-	return !(options.ignoreBareRefCurrent === true && isBareRefCurrentRead(node));
-};
-const objectPatternBindsName = (pattern, name) => {
-	if (!isNodeOfType(pattern, "ObjectPattern")) return false;
-	return (pattern.properties ?? []).some((property) => {
-		if (!isNodeOfType(property, "Property")) return false;
-		const bound = property.value;
-		return Boolean(bound && isNodeOfType(bound, "Identifier") && bound.name === name);
-	});
-};
-const findEffectLocalInitializer = (effectFn, name) => {
-	let initializer = null;
-	walkAst(effectFn, (child) => {
-		if (initializer) return false;
-		if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
-		if (isNodeOfType(child.id, "Identifier") && child.id.name === name || objectPatternBindsName(child.id, name)) {
-			initializer = child.init;
-			return false;
-		}
-	});
-	return initializer;
-};
-const readsPostMountValueThroughLocals = (root, effectFn, options = {}, visitedLocalNames = /* @__PURE__ */ new Set()) => {
-	let found = false;
-	walkAst(root, (child) => {
-		if (found) return false;
-		if (matchesPostMountRead(child, options)) {
-			found = true;
-			return false;
-		}
-		if (!isNodeOfType(child, "Identifier")) return;
-		if (visitedLocalNames.has(child.name)) return;
-		visitedLocalNames.add(child.name);
-		const localInitializer = findEffectLocalInitializer(effectFn, child.name);
-		if (localInitializer && readsPostMountValueThroughLocals(localInitializer, effectFn, options, visitedLocalNames)) {
-			found = true;
-			return false;
-		}
-	});
-	return found;
-};
-//#endregion
-//#region src/plugin/rules/state-and-effects/utils/collect-effect-state-write-facts.ts
-const SYNCHRONOUS_ITERATOR_METHOD_NAMES = new Set([
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"flatMap",
-	"forEach",
-	"map",
-	"reduce",
-	"reduceRight",
-	"some"
-]);
-const DEFERRING_CALLEE_NAMES = new Set([
-	"queueMicrotask",
-	"requestAnimationFrame",
-	"requestIdleCallback",
-	"setImmediate",
-	"setInterval",
-	"setTimeout"
-]);
-const DEFERRING_MEMBER_NAMES = new Set([
-	"catch",
-	"finally",
-	"then"
-]);
-const PURE_GLOBAL_CALLEE_NAMES = new Set([
-	"Array",
-	"BigInt",
-	"Boolean",
-	"Number",
-	"Object",
-	"String",
-	"parseFloat",
-	"parseInt"
-]);
-const PURE_GLOBAL_NAMESPACE_NAMES = new Set(["JSON", "Math"]);
-const PURE_MEMBER_TRANSFORM_NAMES = new Set([
-	"concat",
-	"filter",
-	"join",
-	"map",
-	"split",
-	"toLowerCase",
-	"toString",
-	"toUpperCase",
-	"trim"
-]);
-const STORAGE_GLOBAL_NAMES$1 = new Set([
-	"indexedDB",
-	"localStorage",
-	"sessionStorage"
+const SUBSCRIPTION_REGISTRATION_METHOD_NAMES = new Set([
+	"addEventListener",
+	"addListener",
+	"on",
+	"once",
+	"subscribe",
+	"observe",
+	"observeDeep",
+	"watch"
 ]);
-const getStaticMemberName = (node) => {
-	if (!isNodeOfType(node, "MemberExpression")) return null;
-	if (!node.computed && isNodeOfType(node.property, "Identifier")) return node.property.name;
-	if (node.computed && isNodeOfType(node.property, "Literal")) return typeof node.property.value === "string" ? node.property.value : null;
-	return null;
-};
-const getMemberRoot = (node) => {
-	let current = stripParenExpression(node);
-	while (isNodeOfType(current, "MemberExpression")) current = stripParenExpression(current.object);
-	return current;
-};
-const getCallCalleeName$1 = (callExpression) => {
-	if (!isNodeOfType(callExpression, "CallExpression")) return null;
-	const callee = stripParenExpression(callExpression.callee);
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	return getStaticMemberName(callee);
-};
-const getFunctionParameters = (functionNode) => isFunctionLike$1(functionNode) ? functionNode.params ?? [] : [];
-const getIdentifierBindingIdentity = (analysis, identifier) => {
-	if (!isNodeOfType(identifier, "Identifier")) return null;
-	return getRef(analysis, identifier)?.resolved ?? null;
-};
-const getParameterBindingIdentity = (analysis, functionNode, parameter) => {
-	if (!isNodeOfType(parameter, "Identifier")) return parameter;
-	for (const scope of analysis.scopeManager.scopes) {
-		const variable = scope.variables.find((candidate) => candidate.name === parameter.name && candidate.defs.some((definition) => definition.type === "Parameter" && definition.node === functionNode));
-		if (variable) return variable;
-	}
-	return parameter;
-};
-const buildSubstitutions = (analysis, functionNode, argumentExpressions, parentFrame) => {
-	const substitutions = /* @__PURE__ */ new Map();
-	const parameters = getFunctionParameters(functionNode);
-	for (let parameterIndex = 0; parameterIndex < parameters.length; parameterIndex += 1) {
-		const parameter = parameters[parameterIndex];
-		const argument = argumentExpressions[parameterIndex];
-		if (!parameter || !argument || !isNodeOfType(parameter, "Identifier")) continue;
-		substitutions.set(getParameterBindingIdentity(analysis, functionNode, parameter), {
-			expression: argument,
-			frame: parentFrame
-		});
+const isSubscriptionRegistrationCall = (node) => {
+	if (isNodeOfType(node, "NewExpression")) {
+		const callee = node.callee;
+		return isNodeOfType(callee, "Identifier") && callee.name.endsWith("Observer");
 	}
-	return substitutions;
-};
-const isReactUseEffectEventCallee = (analysis, callee) => {
-	if (isNodeOfType(callee, "MemberExpression")) return !callee.computed && isNodeOfType(callee.object, "Identifier") && callee.object.name === "React" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useEffectEvent";
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	const calleeReference = getRef(analysis, callee);
-	if (!calleeReference?.resolved) return callee.name === "useEffectEvent";
-	return calleeReference.resolved.defs.some((definition) => {
-		if (definition.type !== "ImportBinding") return false;
-		const definitionNode = definition.node;
-		if (!isNodeOfType(definitionNode, "ImportSpecifier")) return false;
-		if (!isNodeOfType(definitionNode.imported, "Identifier")) return false;
-		if (definitionNode.imported.name !== "useEffectEvent") return false;
-		const declaration = definitionNode.parent;
-		return Boolean(declaration && isNodeOfType(declaration, "ImportDeclaration") && isNodeOfType(declaration.source, "Literal") && declaration.source.value === "react");
-	});
-};
-const localUseEventPreservesCallback = (analysis, callee) => {
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	if (!/^useEvent(?:Callback)?$/.test(callee.name)) return false;
-	const calleeReference = getRef(analysis, callee);
-	if (!calleeReference?.resolved) return false;
-	const implementation = resolveToFunction(calleeReference);
-	if (!implementation) return false;
-	const callbackParameter = getFunctionParameters(implementation)[0];
-	if (!callbackParameter || !isNodeOfType(callbackParameter, "Identifier")) return false;
-	const callbackBinding = getParameterBindingIdentity(analysis, implementation, callbackParameter);
-	const callbackRefDeclarators = [];
-	walkAst(implementation, (child) => {
-		if (child !== implementation && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "VariableDeclarator")) return;
-		if (!isNodeOfType(child.id, "Identifier")) return;
-		if (!isNodeOfType(child.init, "CallExpression")) return;
-		if (getCallCalleeName$1(child.init) !== "useRef") return;
-		const refInitializer = child.init.arguments?.[0];
-		if (!refInitializer || getIdentifierBindingIdentity(analysis, refInitializer) !== callbackBinding) return;
-		callbackRefDeclarators.push(child);
-	});
-	if (callbackRefDeclarators.length === 0) return false;
-	return getReturnedExpressions(implementation).some((returnedExpression) => {
-		const returnedCall = stripParenExpression(returnedExpression);
-		if (!isNodeOfType(returnedCall, "CallExpression")) return false;
-		const returnedCalleeName = getCallCalleeName$1(returnedCall);
-		if (returnedCalleeName !== "useCallback" && returnedCalleeName !== "useEffectEvent") return false;
-		const stableCallback = returnedCall.arguments?.[0];
-		if (!stableCallback || !isFunctionLike$1(stableCallback)) return false;
-		let forwardsCallback = false;
-		walkAst(stableCallback, (child) => {
-			if (forwardsCallback) return false;
-			if (child !== stableCallback && isFunctionLike$1(child)) return false;
-			if (!isNodeOfType(child, "CallExpression")) return;
-			const forwardedCallee = stripParenExpression(child.callee);
-			if (!isNodeOfType(forwardedCallee, "MemberExpression")) return;
-			if (getStaticMemberName(forwardedCallee) !== "current") return;
-			if (!isNodeOfType(forwardedCallee.object, "Identifier")) return;
-			const refReference = getRef(analysis, forwardedCallee.object);
-			if (!callbackRefDeclarators.find((declarator) => refReference?.resolved?.defs.some((definition) => definition.node === declarator)) || !refReference?.resolved) return;
-			if (!refReference.resolved.references.some((candidateReference) => {
-				const memberExpression = candidateReference.identifier.parent;
-				const assignmentExpression = memberExpression?.parent;
-				if (!memberExpression || !isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName(memberExpression) !== "current" || !assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression") || assignmentExpression.left !== memberExpression) return false;
-				return getIdentifierBindingIdentity(analysis, assignmentExpression.right) !== callbackBinding;
-			})) forwardsCallback = true;
-		});
-		return forwardsCallback;
-	});
-};
-const resolveWrappedCallable = (analysis, node) => {
-	const candidate = stripParenExpression(node);
-	if (isFunctionLike$1(candidate)) return candidate;
-	if (isNodeOfType(candidate, "Identifier")) {
-		const reference = getRef(analysis, candidate);
-		if (!reference) return null;
-		if (reference.resolved?.defs.some((definition) => definition.type === "Parameter" || definition.type === "ImportBinding")) return null;
-		const resolved = resolveToFunction(reference);
-		if (resolved) return resolved;
-		const definitionNode = reference.resolved?.defs[0]?.node;
-		if (!definitionNode || !isNodeOfType(definitionNode, "VariableDeclarator")) return null;
-		const initializer = definitionNode.init;
-		if (!initializer || !isNodeOfType(initializer, "CallExpression")) return null;
-		if (!isReactUseEffectEventCallee(analysis, initializer.callee) && !localUseEventPreservesCallback(analysis, initializer.callee)) return null;
-		const callback = initializer.arguments?.[0];
-		return callback && isFunctionLike$1(callback) ? callback : null;
-	}
-	if (!isNodeOfType(candidate, "MemberExpression")) return null;
-	if (getStaticMemberName(candidate) !== "current") return null;
-	if (!isNodeOfType(candidate.object, "Identifier")) return null;
-	const reference = getRef(analysis, candidate.object);
-	const declarator = reference?.resolved?.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return null;
-	if (!isNodeOfType(declarator.init, "CallExpression")) return null;
-	if (getCallCalleeName$1(declarator.init) !== "useRef") return null;
-	const initializer = declarator.init.arguments?.[0];
-	if (!initializer || !isFunctionLike$1(initializer)) return null;
-	return Boolean(reference?.resolved?.references.some((candidateReference) => {
-		const member = candidateReference.identifier.parent;
-		const assignment = member?.parent;
-		return Boolean(member && isNodeOfType(member, "MemberExpression") && getStaticMemberName(member) === "current" && assignment && isNodeOfType(assignment, "AssignmentExpression") && assignment.left === member);
-	})) ? null : initializer;
-};
-const functionInvokesItself = (analysis, functionNode) => {
-	let invokesItself = false;
-	walkAst(functionNode, (child) => {
-		if (invokesItself) return false;
-		if (child !== functionNode && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		if (resolveWrappedCallable(analysis, child.callee) === functionNode) {
-			invokesItself = true;
-			return false;
-		}
-	});
-	return invokesItself;
-};
-const collectIntroducedBindings = (analysis, functionNode) => {
-	const introducedBindings = /* @__PURE__ */ new Set();
-	for (const parameter of getFunctionParameters(functionNode)) if (isNodeOfType(parameter, "Identifier")) introducedBindings.add(getParameterBindingIdentity(analysis, functionNode, parameter));
-	return introducedBindings;
-};
-const collectBoundedEffectExecutionFrames = (analysis, effectNode) => {
-	const effectFunction = getEffectFn(analysis, effectNode);
-	if (!effectFunction || !isFunctionLike$1(effectFunction) || effectFunction.async === true) return [];
-	const invokedFunctionEvidence = collectEffectInvokedFunctions(effectFunction);
-	const rootFrame = {
-		functionNode: effectFunction,
-		invocation: null,
-		isDeferred: false,
-		introducedBindings: /* @__PURE__ */ new Set(),
-		substitutions: /* @__PURE__ */ new Map()
-	};
-	const frames = [rootFrame];
-	walkAst(effectFunction, (child) => {
-		if (child !== effectFunction && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = stripParenExpression(child.callee);
-		const calleeName = getCallCalleeName$1(child);
-		const memberName = getStaticMemberName(callee);
-		const isDeferringCall = calleeName !== null && DEFERRING_CALLEE_NAMES.has(calleeName) || memberName !== null && DEFERRING_MEMBER_NAMES.has(memberName);
-		const isIteratorCall = memberName !== null && SYNCHRONOUS_ITERATOR_METHOD_NAMES.has(memberName) && isNodeOfType(callee, "MemberExpression");
-		const enqueueFrame = (callableNode, argumentsForCallable, isDeferred, introducedBindings, allowWithoutInvocationEvidence = false) => {
-			const callable = resolveWrappedCallable(analysis, callableNode);
-			if (!callable || callable.async === true || callable === effectFunction) return;
-			if (functionInvokesItself(analysis, callable)) return;
-			if (!allowWithoutInvocationEvidence && !invokedFunctionEvidence.has(callable) && !isNodeOfType(callableNode, "Identifier") && !isNodeOfType(callableNode, "MemberExpression")) return;
-			frames.push({
-				functionNode: callable,
-				invocation: child,
-				isDeferred,
-				introducedBindings,
-				substitutions: buildSubstitutions(analysis, callable, argumentsForCallable, rootFrame)
-			});
-		};
-		if (isFunctionLike$1(callee)) {
-			enqueueFrame(callee, child.arguments ?? [], false, /* @__PURE__ */ new Set());
-			return;
-		}
-		if (isIteratorCall && isNodeOfType(callee, "MemberExpression")) {
-			const collectionExpression = callee.object;
-			for (const argument of child.arguments ?? []) {
-				if (!resolveWrappedCallable(analysis, argument)) continue;
-				enqueueFrame(argument, [collectionExpression], false, /* @__PURE__ */ new Set(), true);
-			}
-			return;
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = node.callee;
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SUBSCRIPTION_REGISTRATION_METHOD_NAMES.has(callee.property.name);
+};
+const isCallArgumentOf = (parent, node) => {
+	if (!isNodeOfType(parent, "CallExpression") && !isNodeOfType(parent, "NewExpression")) return false;
+	return (parent.arguments ?? []).some((argument) => argument === node);
+};
+const EVENT_HANDLER_PROPERTY_PATTERN = /^on[a-z]/;
+const collectEventPropertyHandlerFunctions = (analysis, effectFn) => {
+	const handlerFunctions = [];
+	for (const assignment of findDownstreamNodes(effectFn, "AssignmentExpression")) {
+		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=") continue;
+		const target = assignment.left;
+		if (!isNodeOfType(target, "MemberExpression") || !isNodeOfType(target.property, "Identifier") || !EVENT_HANDLER_PROPERTY_PATTERN.test(target.property.name)) continue;
+		const assigned = assignment.right;
+		if (isFunctionLike$1(assigned)) {
+			handlerFunctions.push(assigned);
+			continue;
 		}
-		if (isDeferringCall) {
-			for (const argument of child.arguments ?? []) {
-				const callable = resolveWrappedCallable(analysis, argument);
-				if (!callable) continue;
-				enqueueFrame(argument, [], true, memberName !== null && DEFERRING_MEMBER_NAMES.has(memberName) ? collectIntroducedBindings(analysis, callable) : /* @__PURE__ */ new Set(), true);
-			}
-			return;
+		if (isNodeOfType(assigned, "Identifier")) {
+			const assignedRef = getRef(analysis, assigned);
+			const resolvedFunction = assignedRef ? resolveToFunction(assignedRef) : null;
+			if (resolvedFunction) handlerFunctions.push(resolvedFunction);
 		}
-		enqueueFrame(callee, child.arguments ?? [], false, /* @__PURE__ */ new Set());
-	});
-	return frames;
-};
-const emptyEvidence = () => ({
-	sourceReferences: /* @__PURE__ */ new Set(),
-	hasUnknownSource: false,
-	hasDeferredIntroducedValue: false,
-	readsExternalValue: false
-});
-const mergeEvidence = (target, source) => {
-	for (const reference of source.sourceReferences) target.sourceReferences.add(reference);
-	target.hasUnknownSource ||= source.hasUnknownSource;
-	target.hasDeferredIntroducedValue ||= source.hasDeferredIntroducedValue;
-	target.readsExternalValue ||= source.readsExternalValue;
-};
-const getReturnedExpressions = (functionNode) => {
-	if (!isFunctionLike$1(functionNode)) return [];
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) return [functionNode.body];
-	const returnedExpressions = [];
-	walkAst(functionNode.body, (child) => {
-		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "ReturnStatement") && child.argument) returnedExpressions.push(child.argument);
-	});
-	return returnedExpressions;
-};
-const isOpaqueHookCall = (callExpression) => {
-	const calleeName = getCallCalleeName$1(callExpression);
-	return Boolean(calleeName && /^use[A-Z0-9]/.test(calleeName) && calleeName !== "useMemo" && calleeName !== "useCallback" && calleeName !== "useEffectEvent");
-};
-const isLocallyConstructedObjectMember = (reference, memberExpression) => isNodeOfType(memberExpression, "MemberExpression") && reference.resolved?.defs.some((definition) => {
-	const definitionNode = definition.node;
-	return isNodeOfType(definitionNode, "VariableDeclarator") && Boolean(definitionNode.init) && (isNodeOfType(definitionNode.init, "ObjectExpression") || isNodeOfType(definitionNode.init, "ArrayExpression"));
-}) === true;
-const collectValueEvidence = (analysis, expression, frame, remainingCallFrames, visitedBindings = /* @__PURE__ */ new Set()) => {
-	const node = stripParenExpression(expression);
-	const evidence = emptyEvidence();
-	if (readsPostMountValue(node) || readsPostMountValueThroughLocals(node, frame.functionNode)) {
-		evidence.readsExternalValue = true;
-		return evidence;
-	}
-	const root = getMemberRoot(node);
-	if (isNodeOfType(root, "Identifier") && STORAGE_GLOBAL_NAMES$1.has(root.name)) {
-		evidence.readsExternalValue = true;
-		return evidence;
 	}
-	if (isNodeOfType(node, "Literal") || isNodeOfType(node, "TemplateElement") || isNodeOfType(node, "ThisExpression")) return evidence;
-	if (isNodeOfType(node, "Identifier")) {
-		if (node.name === "undefined" || node.name === "NaN" || node.name === "Infinity") return evidence;
-		const reference = getRef(analysis, node);
-		if (!reference) {
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		const bindingIdentity = reference.resolved ?? node;
-		if (frame.introducedBindings.has(bindingIdentity)) {
-			const parent = node.parent;
-			if (parent && isNodeOfType(parent, "SpreadElement") && parent.parent && isNodeOfType(parent.parent, "ObjectExpression")) return evidence;
-			evidence.hasDeferredIntroducedValue = true;
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		const substitution = frame.substitutions.get(bindingIdentity);
-		if (substitution) return collectValueEvidence(analysis, substitution.expression, substitution.frame, remainingCallFrames, visitedBindings);
-		if (isProp(analysis, reference) || isState(analysis, reference)) {
-			evidence.sourceReferences.add(reference);
-			if (isState(analysis, reference) && isExternallyDrivenState(analysis, reference)) evidence.readsExternalValue = true;
-			return evidence;
-		}
-		if (!reference.resolved || visitedBindings.has(reference.resolved)) {
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		visitedBindings.add(reference.resolved);
-		const definitions = reference.resolved.defs;
-		if (definitions.some((definition) => definition.type === "ImportBinding")) {
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		if (reference.resolved.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init)) {
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		const initializer = definitions.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator") && Boolean(definitionNode.init));
-		if (!initializer || !isNodeOfType(initializer, "VariableDeclarator") || !initializer.init) {
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		if (isNodeOfType(initializer.init, "CallExpression") && isOpaqueHookCall(initializer.init)) {
-			evidence.readsExternalValue = true;
-			return evidence;
-		}
-		return collectValueEvidence(analysis, initializer.init, frame, remainingCallFrames, visitedBindings);
-	}
-	if (isNodeOfType(node, "MemberExpression")) {
-		if (isNodeOfType(node.object, "Identifier")) {
-			const objectReference = getRef(analysis, node.object);
-			if (objectReference && isLocallyConstructedObjectMember(objectReference, node)) {
-				evidence.hasUnknownSource = true;
-				return evidence;
+	return handlerFunctions;
+};
+const collectSubscriptionCallbackFunctions = (analysis, effectFn) => {
+	const registrationCalls = [...findDownstreamNodes(effectFn, "CallExpression"), ...findDownstreamNodes(effectFn, "NewExpression")].filter((call) => isSubscriptionRegistrationCall(call));
+	const callbackFunctions = collectEventPropertyHandlerFunctions(analysis, effectFn);
+	for (const registrationCall of registrationCalls) {
+		if (!isNodeOfType(registrationCall, "CallExpression") && !isNodeOfType(registrationCall, "NewExpression")) continue;
+		for (const argument of registrationCall.arguments ?? []) {
+			const argumentNode = argument;
+			if (isFunctionLike$1(argumentNode)) {
+				callbackFunctions.push(argumentNode);
+				continue;
+			}
+			if (isNodeOfType(argumentNode, "Identifier")) {
+				const argumentRef = getRef(analysis, argumentNode);
+				const resolvedFunction = argumentRef ? resolveToFunction(argumentRef) : null;
+				if (resolvedFunction) callbackFunctions.push(resolvedFunction);
 			}
 		}
-		mergeEvidence(evidence, collectValueEvidence(analysis, node.object, frame, remainingCallFrames, new Set(visitedBindings)));
-		if (node.computed) mergeEvidence(evidence, collectValueEvidence(analysis, node.property, frame, remainingCallFrames, new Set(visitedBindings)));
-		return evidence;
-	}
-	if (isNodeOfType(node, "CallExpression")) {
-		if (isOpaqueHookCall(node)) {
-			evidence.readsExternalValue = true;
-			return evidence;
-		}
-		const callee = stripParenExpression(node.callee);
-		const calleeRoot = getMemberRoot(callee);
-		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && getIdentifierBindingIdentity(analysis, callee) === null || isNodeOfType(calleeRoot, "Identifier") && PURE_GLOBAL_NAMESPACE_NAMES.has(calleeRoot.name) && getIdentifierBindingIdentity(analysis, calleeRoot) === null;
-		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
-		if (isPureMemberTransform) mergeEvidence(evidence, collectValueEvidence(analysis, callee.object, frame, remainingCallFrames, new Set(visitedBindings)));
-		for (const argument of node.arguments ?? []) {
-			if (isFunctionLike$1(argument)) continue;
-			mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames, new Set(visitedBindings)));
-		}
-		if (isPureGlobalCall || isPureMemberTransform) return evidence;
-		if (isNodeOfType(callee, "MemberExpression")) {
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		if (remainingCallFrames <= 0) {
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		const callable = resolveWrappedCallable(analysis, callee);
-		if (!callable || callable.async === true || functionInvokesItself(analysis, callable)) {
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		const valueFrame = {
-			functionNode: callable,
-			invocation: node,
-			isDeferred: false,
-			introducedBindings: /* @__PURE__ */ new Set(),
-			substitutions: buildSubstitutions(analysis, callable, node.arguments ?? [], frame)
-		};
-		const returnedExpressions = getReturnedExpressions(callable);
-		if (returnedExpressions.length === 0) {
-			evidence.hasUnknownSource = true;
-			return evidence;
-		}
-		for (const returnedExpression of returnedExpressions) mergeEvidence(evidence, collectValueEvidence(analysis, returnedExpression, valueFrame, remainingCallFrames - 1, new Set(visitedBindings)));
-		return evidence;
-	}
-	if (isFunctionLike$1(node) || isNodeOfType(node, "AwaitExpression")) {
-		evidence.hasUnknownSource = true;
-		return evidence;
-	}
-	const nodeRecord = node;
-	for (const [key, value] of Object.entries(nodeRecord)) {
-		if (key === "parent" || key === "type" || key === "key") continue;
-		if (Array.isArray(value)) for (const child of value) {
-			if (!child || typeof child !== "object" || !("type" in child)) continue;
-			mergeEvidence(evidence, collectValueEvidence(analysis, child, frame, remainingCallFrames, new Set(visitedBindings)));
-		}
-		else if (value && typeof value === "object" && "type" in value) mergeEvidence(evidence, collectValueEvidence(analysis, value, frame, remainingCallFrames, new Set(visitedBindings)));
 	}
-	return evidence;
+	return callbackFunctions;
 };
-const findStateSetterReference = (analysis, callExpression) => {
-	if (!isNodeOfType(callExpression, "CallExpression")) return null;
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "Identifier")) return null;
-	const reference = getRef(analysis, callee);
-	if (!reference) return null;
-	if (resolveToFunction(reference)) return null;
-	if (isStateSetter(analysis, reference)) return reference;
-	return getUpstreamRefs(analysis, reference).find((upstreamReference) => isStateSetter(analysis, upstreamReference)) ?? null;
-};
-const isSameSimpleValue = (analysis, leftExpression, rightExpression) => {
-	const left = stripParenExpression(leftExpression);
-	const right = stripParenExpression(rightExpression);
-	if (left.type !== right.type) return false;
-	if (isNodeOfType(left, "Identifier") && isNodeOfType(right, "Identifier")) {
-		const leftBinding = getIdentifierBindingIdentity(analysis, left);
-		const rightBinding = getIdentifierBindingIdentity(analysis, right);
-		if (leftBinding || rightBinding) return leftBinding !== null && leftBinding === rightBinding;
-		return left.name === right.name;
+const isInsideAnyFunction = (identifier, functions) => {
+	let current = identifier;
+	while (current) {
+		if (functions.includes(current)) return true;
+		current = current.parent;
 	}
-	if (isNodeOfType(left, "Literal") && isNodeOfType(right, "Literal")) return left.value === right.value;
-	if (isNodeOfType(left, "MemberExpression") && isNodeOfType(right, "MemberExpression")) return left.computed === right.computed && isSameSimpleValue(analysis, left.object, right.object) && isSameSimpleValue(analysis, left.property, right.property);
 	return false;
 };
-const matchesStateInitializer = (analysis, callExpression, stateDeclarator) => {
-	if (!isNodeOfType(callExpression, "CallExpression")) return false;
-	if (!isNodeOfType(stateDeclarator, "VariableDeclarator")) return false;
-	if (!isNodeOfType(stateDeclarator.init, "CallExpression")) return false;
-	const writtenValue = callExpression.arguments?.[0];
-	const initializerValue = stateDeclarator.init.arguments?.[0];
-	if (!writtenValue || !initializerValue) return false;
-	const unwrappedInitializer = stripParenExpression(initializerValue);
-	if (isNodeOfType(unwrappedInitializer, "LogicalExpression") && (unwrappedInitializer.operator === "??" || unwrappedInitializer.operator === "||")) return isSameSimpleValue(analysis, writtenValue, unwrappedInitializer.left) || isSameSimpleValue(analysis, writtenValue, unwrappedInitializer.right);
-	return isSameSimpleValue(analysis, writtenValue, unwrappedInitializer);
-};
-const collectFrameSetterCalls = (analysis, frame) => {
-	const calls = [];
-	walkAst(frame.functionNode, (child) => {
-		if (child !== frame.functionNode && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const setterReference = findStateSetterReference(analysis, child);
-		if (setterReference) calls.push({
-			callExpression: child,
-			setterReference
-		});
+const isSubscriptionRegistrationArgument = (identifier) => {
+	const parent = identifier.parent;
+	if (!parent || !isSubscriptionRegistrationCall(parent)) return false;
+	return isCallArgumentOf(parent, identifier);
+};
+const hasSubscriptionCallbackCallToSameSetter = (analysis, setterRef, effectFnRefs, effectFn) => {
+	const callbackFunctions = collectSubscriptionCallbackFunctions(analysis, effectFn);
+	return effectFnRefs.some((otherRef) => {
+		if (otherRef === setterRef) return false;
+		if (otherRef.resolved !== setterRef.resolved) return false;
+		const otherIdentifier = otherRef.identifier;
+		if (isSubscriptionRegistrationArgument(otherIdentifier)) return true;
+		if (!getCallExpr(otherRef)) return false;
+		return isInsideAnyFunction(otherIdentifier, callbackFunctions);
 	});
-	return calls;
 };
-const areInMutuallyExclusiveBranches = (leftNode, rightNode) => {
-	let ancestor = leftNode.parent;
-	while (ancestor) {
-		if ((isNodeOfType(ancestor, "IfStatement") || isNodeOfType(ancestor, "ConditionalExpression")) && ancestor.alternate) {
-			const leftIsConsequent = isAstDescendant(leftNode, ancestor.consequent);
-			const leftIsAlternate = isAstDescendant(leftNode, ancestor.alternate);
-			const rightIsConsequent = isAstDescendant(rightNode, ancestor.consequent);
-			const rightIsAlternate = isAstDescendant(rightNode, ancestor.alternate);
-			if (leftIsConsequent && rightIsAlternate || leftIsAlternate && rightIsConsequent) return true;
+const derivesFromPostMountRead = (ref) => Boolean(ref.resolved?.defs.some((def) => {
+	const node = def.node;
+	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
+	return readsPostMountValue(node.init);
+}));
+const PROMISE_CONTINUATION_METHOD_NAMES = new Set([
+	"then",
+	"catch",
+	"finally"
+]);
+const isPromiseFlowFunction = (fn) => {
+	if (isFunctionLike$1(fn) && fn.async) return true;
+	const parent = fn.parent;
+	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
+	if (!(parent.arguments ?? []).some((argument) => argument === fn)) return false;
+	const callee = parent.callee;
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CONTINUATION_METHOD_NAMES.has(callee.property.name);
+};
+const isPromiseFlowStateSetterCall = (analysis, ref, effectFn) => {
+	if (!isStateSetterCall(analysis, ref)) return false;
+	let current = ref.identifier.parent;
+	let sawPromiseFlowFunction = false;
+	while (current && current !== effectFn) {
+		if (isFunctionLike$1(current) && !sawPromiseFlowFunction) {
+			if (!isPromiseFlowFunction(current)) return false;
+			sawPromiseFlowFunction = true;
 		}
-		ancestor = ancestor.parent;
+		current = current.parent;
 	}
-	return false;
+	return sawPromiseFlowFunction;
 };
-const collectEffectStateWriteFacts = (analysis, effectNode) => {
-	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode);
-	if (frames.length === 0) return [];
-	const effectHasCleanup = hasCleanup(analysis, effectNode);
-	const cleanupManagedStateDeclarators = /* @__PURE__ */ new Set();
-	const facts = [];
-	for (const frame of frames) for (const { callExpression, setterReference } of collectFrameSetterCalls(analysis, frame)) {
-		if (!isNodeOfType(callExpression, "CallExpression")) continue;
-		if ((callExpression.arguments ?? []).length !== 1) continue;
-		const writtenValue = callExpression.arguments?.[0];
-		if (!writtenValue) continue;
-		const stateDeclarator = getUseStateDecl(analysis, setterReference);
-		if (!stateDeclarator) continue;
-		const remainingValueCallFrames = frame === frames[0] ? 1 : 0;
-		let valueEvidence;
-		if (isFunctionLike$1(writtenValue)) {
-			const updaterFrame = {
-				functionNode: writtenValue,
-				invocation: callExpression,
-				isDeferred: frame.isDeferred,
-				introducedBindings: collectIntroducedBindings(analysis, writtenValue),
-				substitutions: /* @__PURE__ */ new Map()
-			};
-			valueEvidence = emptyEvidence();
-			const returnedExpressions = getReturnedExpressions(writtenValue);
-			if (returnedExpressions.length === 0) valueEvidence.hasUnknownSource = true;
-			for (const returnedExpression of returnedExpressions) mergeEvidence(valueEvidence, collectValueEvidence(analysis, returnedExpression, updaterFrame, remainingValueCallFrames));
-		} else valueEvidence = collectValueEvidence(analysis, writtenValue, frame, remainingValueCallFrames);
-		const sourceReferences = [...valueEvidence.sourceReferences].filter((sourceReference) => getUseStateDecl(analysis, sourceReference) !== stateDeclarator);
-		const hasIndependentWriter = hasUserInputSetterWriter(setterReference, effectNode, true);
-		const doesMatchStateInitializer = matchesStateInitializer(analysis, callExpression, stateDeclarator);
-		if (effectHasCleanup && (frame.isDeferred || valueEvidence.hasUnknownSource || valueEvidence.hasDeferredIntroducedValue || valueEvidence.readsExternalValue)) cleanupManagedStateDeclarators.add(stateDeclarator);
-		const isRenderKnownCopy = sourceReferences.length > 0 && !frame.isDeferred && !valueEvidence.hasUnknownSource && !valueEvidence.hasDeferredIntroducedValue && !valueEvidence.readsExternalValue && !hasIndependentWriter;
-		facts.push({
-			callExpression,
-			executionNode: frame.invocation ?? callExpression,
-			setterReference,
-			stateDeclarator,
-			sourceReferences,
-			isDeferred: frame.isDeferred,
-			isRenderKnownCopy,
-			matchesStateInitializer: doesMatchStateInitializer,
-			resetsSourceState: false
-		});
-	}
-	return facts.map((fact) => {
-		const resetsSourceState = fact.sourceReferences.filter((sourceReference) => isState(analysis, sourceReference)).map((sourceReference) => getUseStateDecl(analysis, sourceReference)).filter((declarator) => Boolean(declarator)).some((sourceDeclarator) => facts.some((candidateFact) => !candidateFact.isDeferred && candidateFact.stateDeclarator === sourceDeclarator && !areInMutuallyExclusiveBranches(fact.executionNode, candidateFact.executionNode)));
-		const { executionNode: _executionNode, ...publicFact } = fact;
-		return {
-			...publicFact,
-			resetsSourceState,
-			isRenderKnownCopy: fact.isRenderKnownCopy && !cleanupManagedStateDeclarators.has(fact.stateDeclarator) && !resetsSourceState
-		};
-	});
+const isObjectUrlLifecycleEffect = (effectFn) => {
+	const callMethodNames = findDownstreamNodes(effectFn, "CallExpression").map((call) => getCallMethodName(call.callee)).filter((name) => Boolean(name));
+	return callMethodNames.includes("createObjectURL") && callMethodNames.includes("revokeObjectURL");
 };
-//#endregion
-//#region src/plugin/rules/state-and-effects/no-adjust-state-on-prop-change.ts
 const noAdjustStateOnPropChange = defineRule({
 	id: "no-adjust-state-on-prop-change",
 	title: "State synced to a prop inside an effect",
@@ -22836,13 +22173,25 @@ const noAdjustStateOnPropChange = defineRule({
 		if (!isUseEffect(node)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		const dependencyReferences = getEffectDepsRefs(analysis, node);
-		if (!dependencyReferences) return;
-		if (!dependencyReferences.flatMap((reference) => isState(analysis, reference) ? [] : getUpstreamRefs(analysis, reference)).some((reference) => isProp(analysis, reference))) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
-			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
+		const effectFnRefs = getEffectFnRefs(analysis, node);
+		const depsRefs = getEffectDepsRefs(analysis, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const effectFn = getEffectFn(analysis, node);
+		if (!effectFn) return;
+		if (!depsRefs.flatMap((ref) => isState(analysis, ref) ? [] : getUpstreamRefs(analysis, ref)).some((ref) => isProp(analysis, ref))) return;
+		if (isObjectUrlLifecycleEffect(effectFn)) return;
+		const hasAsyncStateSetter = effectFnRefs.some((ref) => isPromiseFlowStateSetterCall(analysis, ref, effectFn));
+		for (const ref of effectFnRefs) {
+			if (!isSyncStateSetterCall(analysis, ref, effectFn)) continue;
+			const callExpr = getCallExpr(ref);
+			if (!callExpr) continue;
+			if (readsPostMountValue(callExpr)) continue;
+			if (getArgsUpstreamRefs(analysis, ref).some((argRef) => derivesFromPostMountRead(argRef))) continue;
+			if (isNodeOfType(callExpr, "CallExpression") && isConstantSetterArgument(analysis, callExpr) && hasSubscriptionCallbackCallToSameSetter(analysis, ref, effectFnRefs, effectFn)) continue;
+			if (hasAsyncStateSetter && isNodeOfType(callExpr, "CallExpression") && isConstantSetterArgument(analysis, callExpr)) continue;
+			if (getArgsUpstreamRefs(analysis, ref).some((argRef) => isProp(analysis, argRef))) continue;
 			context.report({
-				node: fact.callExpression,
+				node: callExpr,
 				message: "This effect adjusts state after a prop changes, so users briefly see the stale value."
 			});
 		}
@@ -24856,6 +24205,180 @@ const noCascadingSetState = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/reads-post-mount-through-locals.ts
+const isBareRefCurrentRead = (node) => isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && node.property.name === "current";
+const matchesPostMountRead = (node, options) => {
+	if (isPostMountGlobalRead(node)) return true;
+	if (!isPostMountMemberRead(node)) return false;
+	return !(options.ignoreBareRefCurrent === true && isBareRefCurrentRead(node));
+};
+const objectPatternBindsName$1 = (pattern, name) => {
+	if (!isNodeOfType(pattern, "ObjectPattern")) return false;
+	return (pattern.properties ?? []).some((property) => {
+		if (!isNodeOfType(property, "Property")) return false;
+		const bound = property.value;
+		return Boolean(bound && isNodeOfType(bound, "Identifier") && bound.name === name);
+	});
+};
+const findEffectLocalInitializer$1 = (effectFn, name) => {
+	let initializer = null;
+	walkAst(effectFn, (child) => {
+		if (initializer) return false;
+		if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
+		if (isNodeOfType(child.id, "Identifier") && child.id.name === name || objectPatternBindsName$1(child.id, name)) {
+			initializer = child.init;
+			return false;
+		}
+	});
+	return initializer;
+};
+const readsPostMountValueThroughLocals = (root, effectFn, options = {}, visitedLocalNames = /* @__PURE__ */ new Set()) => {
+	let found = false;
+	walkAst(root, (child) => {
+		if (found) return false;
+		if (matchesPostMountRead(child, options)) {
+			found = true;
+			return false;
+		}
+		if (!isNodeOfType(child, "Identifier")) return;
+		if (visitedLocalNames.has(child.name)) return;
+		visitedLocalNames.add(child.name);
+		const localInitializer = findEffectLocalInitializer$1(effectFn, child.name);
+		if (localInitializer && readsPostMountValueThroughLocals(localInitializer, effectFn, options, visitedLocalNames)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/effect/external-state.ts
+const DEFERRING_CALLEE_NAMES = new Set([
+	"setTimeout",
+	"setInterval",
+	"setImmediate",
+	"requestAnimationFrame",
+	"requestIdleCallback",
+	"queueMicrotask",
+	"addEventListener",
+	"addListener",
+	"subscribe",
+	"observe",
+	"watch",
+	"watchPosition",
+	"then",
+	"catch",
+	"finally",
+	"on",
+	"once"
+]);
+const getCalleeName$1 = (callee) => {
+	if (!callee) return null;
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+const parentOf = (node) => node.parent ?? null;
+const argumentsInclude = (args, target) => (args ?? []).some((argument) => argument === target);
+const isDeferredCallbackPosition = (expression) => {
+	const parent = parentOf(expression);
+	if (!parent) return false;
+	if (isNodeOfType(parent, "CallExpression") && argumentsInclude(parent.arguments, expression)) {
+		const name = getCalleeName$1(parent.callee);
+		if (name && DEFERRING_CALLEE_NAMES.has(name)) return true;
+	}
+	if (isNodeOfType(parent, "NewExpression") && argumentsInclude(parent.arguments, expression)) {
+		const name = getCalleeName$1(parent.callee);
+		if (name && (name.endsWith("Observer") || name === "Promise")) return true;
+	}
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === expression && isNodeOfType(parent.left, "MemberExpression") && isNodeOfType(parent.left.property, "Identifier") && parent.left.property.name.startsWith("on")) return true;
+	return false;
+};
+const getHandlerDeclarator = (fn) => {
+	let current = fn;
+	let parent = parentOf(current);
+	while (parent && isNodeOfType(parent, "CallExpression") && argumentsInclude(parent.arguments, current)) {
+		current = parent;
+		parent = parentOf(current);
+	}
+	if (parent && isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent;
+	return null;
+};
+const isNamedHandlerUsedAsDeferredCallback = (analysis, fn) => {
+	const declarator = getHandlerDeclarator(fn);
+	if (!declarator || !isNodeOfType(declarator.id, "Identifier")) return false;
+	const name = declarator.id.name;
+	for (const scope of analysis.scopeManager.scopes) {
+		const variable = scope.variables.find((candidate) => candidate.name === name && candidate.defs.some((def) => def.node === declarator));
+		if (!variable) continue;
+		return variable.references.some((reference) => isDeferredCallbackPosition(reference.identifier));
+	}
+	return false;
+};
+const isDeferredCallbackFunction = (analysis, fn) => {
+	if (isDeferredCallbackPosition(fn)) return true;
+	return isNamedHandlerUsedAsDeferredCallback(analysis, fn);
+};
+const isInsideDeferredCallback$1 = (analysis, node, boundary) => {
+	let current = parentOf(node);
+	while (current && current !== boundary) {
+		if (isFunctionLike$1(current) && isDeferredCallbackFunction(analysis, current)) return true;
+		current = parentOf(current);
+	}
+	return false;
+};
+const findUseStateDeclarator = (ref) => {
+	for (const def of ref.resolved?.defs ?? []) {
+		const node = def.node;
+		if (!isNodeOfType(node, "VariableDeclarator")) continue;
+		if (!isNodeOfType(node.init, "CallExpression")) continue;
+		if (!isNodeOfType(node.id, "ArrayPattern")) continue;
+		return node;
+	}
+	return null;
+};
+const declaratorToExternallyDriven = /* @__PURE__ */ new WeakMap();
+const isExternallyDrivenState = (analysis, ref) => {
+	const declarator = findUseStateDeclarator(ref);
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
+	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
+	const cached = declaratorToExternallyDriven.get(declarator);
+	if (cached !== void 0) return cached;
+	const result = computeExternallyDriven(analysis, declarator);
+	declaratorToExternallyDriven.set(declarator, result);
+	return result;
+};
+const computeExternallyDriven = (analysis, declarator) => {
+	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
+	const setterElement = declarator.id.elements?.[1];
+	if (!setterElement || !isNodeOfType(setterElement, "Identifier")) return false;
+	const setterName = setterElement.name;
+	let setterVariable = null;
+	for (const scope of analysis.scopeManager.scopes) {
+		const match = scope.variables.find((variable) => variable.name === setterName && variable.defs.some((def) => def.node === declarator));
+		if (match) {
+			setterVariable = match;
+			break;
+		}
+	}
+	if (!setterVariable) return false;
+	let hasDeferredCallSite = false;
+	for (const setterReference of setterVariable.references) {
+		const identifier = setterReference.identifier;
+		const parent = parentOf(identifier);
+		if (!parent) continue;
+		if (isDeferredCallbackPosition(identifier)) {
+			hasDeferredCallSite = true;
+			continue;
+		}
+		if (!isNodeOfType(parent, "CallExpression")) continue;
+		if (parent.callee !== identifier) continue;
+		if (!isInsideDeferredCallback$1(analysis, parent, declarator)) return false;
+		hasDeferredCallSite = true;
+	}
+	return hasDeferredCallSite;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-chain-state-updates.ts
 const getUseStateDeclarator = (ref) => (ref.resolved?.defs ?? []).map((def) => def.node).find((node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "ArrayPattern")) ?? null;
 const isDeclaredWithin = (node, container) => {
@@ -25596,16 +25119,322 @@ const noDefaultProps = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-initial-only-prop-name.ts
+const isInitialOnlyPropName = (propName) => {
+	if (propName === "initialValue" || propName === "defaultValue" || propName === "seedValue") return true;
+	return /^initial[A-Z]/.test(propName) || /^default[A-Z]/.test(propName) || /^seed[A-Z]/.test(propName) || /^starting[A-Z]/.test(propName) || /^baseline[A-Z]/.test(propName) || /^preset[A-Z]/.test(propName);
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/event-handler-reference.ts
+const isEventHandlerName = (name) => /^on[A-Z]/.test(name);
+const getStaticMemberReferenceName = (node, resolveName = (name) => name) => {
+	if (!isNodeOfType(node, "MemberExpression")) return null;
+	if (!isNodeOfType(node.object, "Identifier")) return null;
+	const propertyName = getStaticMemberPropertyName(node);
+	return propertyName ? `${resolveName(node.object.name)}.${propertyName}` : null;
+};
+const isEventHandlerValue = (node, eventHandlerReferenceNames, resolveName = (name) => name) => {
+	if (isInlineFunctionExpression(node)) return true;
+	if (isNodeOfType(node, "Identifier")) return eventHandlerReferenceNames.has(resolveName(node.name));
+	const memberReferenceName = getStaticMemberReferenceName(node, resolveName);
+	return Boolean(memberReferenceName && eventHandlerReferenceNames.has(memberReferenceName));
+};
+const isIntrinsicJsxAttribute = (node) => {
+	if (!isNodeOfType(node, "JSXAttribute")) return false;
+	const openingElement = node.parent;
+	if (!isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	const elementName = openingElement.name;
+	if (!isNodeOfType(elementName, "JSXIdentifier")) return false;
+	return /^[a-z]/.test(elementName.name);
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/is-controlled-prop-mirror.ts
+const componentPropNamesCache = /* @__PURE__ */ new WeakMap();
+const collectComponentPropNames = (componentFunction) => {
+	const cached = componentPropNamesCache.get(componentFunction);
+	if (cached) return cached;
+	const propNames = /* @__PURE__ */ new Set();
+	if (!isFunctionLike$1(componentFunction)) return propNames;
+	const propsObjectParamNames = /* @__PURE__ */ new Set();
+	for (const param of componentFunction.params ?? []) {
+		collectPatternNames(param, propNames);
+		if (isNodeOfType(param, "Identifier")) propsObjectParamNames.add(param.name);
+	}
+	const componentBody = componentFunction.body;
+	if (!componentBody) return propNames;
+	walkAst(componentBody, (child) => {
+		if (child !== componentBody && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "ObjectPattern") && isNodeOfType(child.init, "Identifier") && propsObjectParamNames.has(child.init.name)) collectPatternNames(child.id, propNames);
+	});
+	componentPropNamesCache.set(componentFunction, propNames);
+	return propNames;
+};
+const ownScopeBoundNamesCache = /* @__PURE__ */ new WeakMap();
+const getOwnScopeBoundNames = (functionNode) => {
+	const cached = ownScopeBoundNamesCache.get(functionNode);
+	if (cached) return cached;
+	const boundNames = /* @__PURE__ */ new Set();
+	if (isFunctionLike$1(functionNode)) for (const param of functionNode.params ?? []) collectPatternNames(param, boundNames);
+	walkAst(functionNode, (child) => {
+		if (child !== functionNode && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "VariableDeclarator")) collectPatternNames(child.id, boundNames);
+	});
+	ownScopeBoundNamesCache.set(functionNode, boundNames);
+	return boundNames;
+};
+const declaresBindingNamed = (functionNode, bindingName) => getOwnScopeBoundNames(functionNode).has(bindingName);
+const isPropertyNamePosition = (identifier) => {
+	const parent = identifier.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "MemberExpression")) return parent.property === identifier && !parent.computed;
+	if (isNodeOfType(parent, "Property")) return parent.key === identifier && !parent.computed;
+	return false;
+};
+const referencesIdentifierNamed = (root, identifierName) => {
+	let isReferenced = false;
+	walkAst(root, (child) => {
+		if (isReferenced) return false;
+		if (child !== root && isFunctionLike$1(child) && declaresBindingNamed(child, identifierName)) return false;
+		if (isNodeOfType(child, "Identifier") && child.name === identifierName && !isPropertyNamePosition(child)) {
+			isReferenced = true;
+			return false;
+		}
+	});
+	return isReferenced;
+};
+const isSetterWiredToJsxHandler = (componentFunction, setterName) => {
+	let isWired = false;
+	walkAst(componentFunction, (child) => {
+		if (isWired) return false;
+		if (child !== componentFunction && isFunctionLike$1(child) && declaresBindingNamed(child, setterName)) return false;
+		if (!isNodeOfType(child, "JSXAttribute") || !child.value) return;
+		const attributeName = getJsxAttributeName(child.name);
+		if (!attributeName || !isEventHandlerName(attributeName)) return;
+		if (referencesIdentifierNamed(child.value, setterName)) {
+			isWired = true;
+			return false;
+		}
+	});
+	return isWired;
+};
+const isControlledPropMirror = (effectNode, setterCall) => {
+	if (!isNodeOfType(setterCall, "CallExpression")) return false;
+	if (!isNodeOfType(setterCall.callee, "Identifier")) return false;
+	const setterArguments = setterCall.arguments ?? [];
+	if (setterArguments.length !== 1) return false;
+	const mirroredArgument = setterArguments[0];
+	if (!isNodeOfType(mirroredArgument, "Identifier")) return false;
+	const componentFunction = findEnclosingFunction(effectNode);
+	if (!componentFunction) return false;
+	if (!collectComponentPropNames(componentFunction).has(mirroredArgument.name)) return false;
+	return isSetterWiredToJsxHandler(componentFunction, setterCall.callee.name);
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/has-user-input-setter-writer.ts
+const HANDLER_BINDING_NAME_PATTERN = /^(on|handle)[A-Z_]/;
+const isEventHandlerPropertyKey = (property) => isNodeOfType(property, "Property") && !property.computed && isNodeOfType(property.key, "Identifier") && isEventHandlerName(property.key.name);
+const DEFERRED_CALLBACK_MEMBER_NAMES = new Set([
+	"then",
+	"catch",
+	"finally",
+	"subscribe"
+]);
+const DEFERRED_CALLBACK_CALLEE_NAMES = new Set([
+	"setTimeout",
+	"setInterval",
+	"requestAnimationFrame",
+	"addEventListener",
+	"addListener"
+]);
+const isDeferredCallbackArgumentOf = (callExpr, child) => {
+	if (!isNodeOfType(callExpr, "CallExpression")) return false;
+	if (!(callExpr.arguments ?? []).includes(child)) return false;
+	const callee = callExpr.callee;
+	if (isNodeOfType(callee, "Identifier")) return DEFERRED_CALLBACK_CALLEE_NAMES.has(callee.name);
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return DEFERRED_CALLBACK_MEMBER_NAMES.has(callee.property.name) || DEFERRED_CALLBACK_CALLEE_NAMES.has(callee.property.name);
+	return false;
+};
+const isIndependentWriterIdentifier = (componentFunction, identifier, includeDeferredWriters) => {
+	let outermostFunctionBelowComponent = null;
+	let previous = identifier;
+	let cursor = identifier.parent;
+	while (cursor && cursor !== componentFunction) {
+		if (isNodeOfType(cursor, "JSXAttribute")) {
+			const attributeName = getJsxAttributeName(cursor.name);
+			if (attributeName && isEventHandlerName(attributeName)) return true;
+		}
+		if (isEventHandlerPropertyKey(cursor)) return true;
+		if (includeDeferredWriters && isDeferredCallbackArgumentOf(cursor, previous)) return true;
+		if (isFunctionLike$1(cursor)) {
+			outermostFunctionBelowComponent = cursor;
+			if (includeDeferredWriters && cursor.async === true) return true;
+		}
+		previous = cursor;
+		cursor = cursor.parent ?? null;
+	}
+	if (!outermostFunctionBelowComponent) return false;
+	const bindingName = getFunctionBindingName$1(outermostFunctionBelowComponent);
+	if (!bindingName) return false;
+	if (HANDLER_BINDING_NAME_PATTERN.test(bindingName)) return true;
+	return isSetterWiredToJsxHandler(componentFunction, bindingName);
+};
+const hasUserInputSetterWriter = (setterRef, effectNode, includeDeferredWriters = false) => {
+	if (!setterRef.resolved) return false;
+	const componentFunction = findEnclosingFunction(effectNode);
+	if (!componentFunction) return false;
+	for (const reference of setterRef.resolved.references) {
+		if (reference.init) continue;
+		const identifier = reference.identifier;
+		if (isAstDescendant(identifier, effectNode)) continue;
+		if (isIndependentWriterIdentifier(componentFunction, identifier, includeDeferredWriters)) return true;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-derived-state.ts
-const getStateName$1 = (stateDeclarator) => {
-	if (!isNodeOfType(stateDeclarator, "VariableDeclarator")) return "<state>";
-	if (!isNodeOfType(stateDeclarator.id, "ArrayPattern")) return "<state>";
-	const stateBinding = stateDeclarator.id.elements?.[0];
-	if (stateBinding && isNodeOfType(stateBinding, "Identifier")) return stateBinding.name;
-	const setterBinding = stateDeclarator.id.elements?.[1];
-	if (!setterBinding || !isNodeOfType(setterBinding, "Identifier")) return "<state>";
-	if (!setterBinding.name.startsWith("set") || setterBinding.name.length <= 3) return setterBinding.name;
-	return setterBinding.name[3].toLowerCase() + setterBinding.name.slice(4);
+const countSetterCallSites = (ref) => {
+	if (!ref.resolved) return 0;
+	let count = 0;
+	for (const reference of ref.resolved.references) {
+		const parent = reference.identifier.parent;
+		if (parent && isNodeOfType(parent, "CallExpression")) count += 1;
+	}
+	return count;
+};
+const collectUpdaterParameterReads = (analysis, updaterFn) => {
+	const reads = [];
+	for (const ref of getDownstreamRefs(analysis, updaterFn.body)) if (ref.resolved?.defs.some((def) => def.type === "Parameter" && def.node === updaterFn)) reads.push(ref.identifier);
+	return reads;
+};
+const readsParameterOnlyViaObjectSpread = (parameterReads) => parameterReads.every((read) => {
+	const spread = read.parent;
+	if (!spread || !isNodeOfType(spread, "SpreadElement")) return false;
+	const container = spread.parent;
+	return Boolean(container && isNodeOfType(container, "ObjectExpression"));
+});
+const isAccumulatingFunctionalUpdater = (analysis, callExpr) => {
+	if (!isNodeOfType(callExpr, "CallExpression")) return false;
+	const firstArgument = callExpr.arguments?.[0];
+	if (!firstArgument || !isFunctionLike$1(firstArgument)) return false;
+	const parameterReads = collectUpdaterParameterReads(analysis, firstArgument);
+	if (parameterReads.length === 0) return false;
+	return !readsParameterOnlyViaObjectSpread(parameterReads);
+};
+const deriveStateNameFromSetterName = (setterName) => {
+	if (setterName.length > 3 && setterName.startsWith("set")) return setterName[3].toLowerCase() + setterName.slice(4);
+	return setterName;
+};
+const getStateNameForUseStateDecl = (useStateNode) => {
+	if (!useStateNode || !isNodeOfType(useStateNode, "VariableDeclarator")) return null;
+	if (!isNodeOfType(useStateNode.id, "ArrayPattern")) return null;
+	const elements = useStateNode.id.elements ?? [];
+	const stateSlot = elements[0];
+	if (stateSlot && isNodeOfType(stateSlot, "Identifier")) return stateSlot.name;
+	const setterSlot = elements[1];
+	if (setterSlot && isNodeOfType(setterSlot, "Identifier")) return deriveStateNameFromSetterName(setterSlot.name);
+	return null;
+};
+const isUseStateCallExpression = (callExpr) => {
+	if (!isNodeOfType(callExpr, "CallExpression")) return false;
+	const callee = callExpr.callee;
+	if (isNodeOfType(callee, "Identifier")) return callee.name === "useState";
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useState";
+};
+const getSetterArgsUpstreamRefs = (analysis, ref) => {
+	const result = [];
+	for (const upRef of getUpstreamRefs(analysis, ref)) {
+		const callExpr = getCallExpr(upRef);
+		if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
+		if (isUseStateCallExpression(callExpr)) continue;
+		for (const argument of callExpr.arguments ?? []) for (const argRef of getDownstreamRefs(analysis, argument)) for (const innerRef of getUpstreamRefs(analysis, argRef)) result.push(innerRef);
+	}
+	return result;
+};
+const refResolvesToDeclarator = (ref, declarator) => Boolean(declarator && ref.resolved?.defs.some((def) => def.node === declarator));
+const isUseContextLocal = (ref) => Boolean(ref.resolved?.defs.some((def) => {
+	const node = def.node;
+	if (!isNodeOfType(node, "VariableDeclarator")) return false;
+	if (!isNodeOfType(node.init, "CallExpression")) return false;
+	const callee = node.init.callee;
+	if (isNodeOfType(callee, "Identifier")) return callee.name === "useContext";
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useContext";
+}));
+const isPlainValueReadExpression = (node) => {
+	if (isNodeOfType(node, "Identifier")) return true;
+	if (isNodeOfType(node, "MemberExpression")) {
+		if (node.computed && !isNodeOfType(node.property, "Literal")) return false;
+		return isPlainValueReadExpression(node.object);
+	}
+	return false;
+};
+const isWholeValueMirrorArgument = (callExpr) => {
+	if (!isNodeOfType(callExpr, "CallExpression")) return false;
+	const args = callExpr.arguments ?? [];
+	if (args.length !== 1) return false;
+	return isPlainValueReadExpression(args[0]);
+};
+const collectEarlyReturnGuardTests = (block, beforeStatement) => {
+	const tests = [];
+	if (!isNodeOfType(block, "BlockStatement")) return tests;
+	for (const statement of block.body ?? []) {
+		if (statement === beforeStatement) break;
+		if (!isNodeOfType(statement, "IfStatement")) continue;
+		const consequent = statement.consequent;
+		if (isNodeOfType(consequent, "ReturnStatement") || isNodeOfType(consequent, "BlockStatement") && (consequent.body ?? []).some((inner) => isNodeOfType(inner, "ReturnStatement"))) tests.push(statement.test);
+	}
+	return tests;
+};
+const collectGuardTestsOnPath = (callExpr, effectFn) => {
+	const guardTests = [];
+	let child = callExpr;
+	let parent = callExpr.parent;
+	while (parent && child !== effectFn) {
+		if (isNodeOfType(parent, "IfStatement") && parent.test !== child) guardTests.push(parent.test);
+		else if (isNodeOfType(parent, "ConditionalExpression") && parent.test !== child) guardTests.push(parent.test);
+		else if (isNodeOfType(parent, "LogicalExpression") && parent.right === child) guardTests.push(parent.left);
+		else if (isNodeOfType(parent, "BlockStatement")) guardTests.push(...collectEarlyReturnGuardTests(parent, child));
+		child = parent;
+		parent = parent.parent ?? null;
+	}
+	return guardTests;
+};
+const someGuardReadsWrittenState = (analysis, guardTests, writtenStateDecl) => guardTests.some((test) => getDownstreamRefs(analysis, test).some((testRef) => getUpstreamRefs(analysis, testRef).some((upRef) => isState(analysis, upRef) && refResolvesToDeclarator(upRef, writtenStateDecl))));
+const copiesOtherStateOrContextValue = (analysis, callExpr, writtenStateDecl) => {
+	if (!isNodeOfType(callExpr, "CallExpression")) return false;
+	const argument = callExpr.arguments?.[0];
+	if (!argument) return false;
+	for (const argRef of getDownstreamRefs(analysis, argument)) {
+		if (isState(analysis, argRef) && !refResolvesToDeclarator(argRef, writtenStateDecl)) return true;
+		for (const upRef of getUpstreamRefs(analysis, argRef)) if (isUseContextLocal(upRef)) return true;
+	}
+	return false;
+};
+const effectResetsArgumentSourceState = (analysis, effectFnRefs, effectFn, flaggedRef, argsUpstreamRefs) => {
+	const sourceStateDecls = /* @__PURE__ */ new Set();
+	for (const argRef of argsUpstreamRefs) {
+		if (!isState(analysis, argRef)) continue;
+		for (const def of argRef.resolved?.defs ?? []) sourceStateDecls.add(def.node);
+	}
+	if (sourceStateDecls.size === 0) return false;
+	for (const otherRef of effectFnRefs) {
+		if (otherRef === flaggedRef) continue;
+		if (!isSyncStateSetterCall(analysis, otherRef, effectFn)) continue;
+		const otherDecl = getUseStateDecl(analysis, otherRef);
+		if (otherDecl && sourceStateDecls.has(otherDecl)) return true;
+	}
+	return false;
+};
+const hasReferenceOutsideEffect = (ref, effectNode) => {
+	if (!ref.resolved) return false;
+	const effectRange = effectNode.range;
+	if (!effectRange) return false;
+	for (const reference of ref.resolved.references) {
+		if (reference.init) continue;
+		const identifier = reference.identifier;
+		if (!identifier.range) continue;
+		if (!(effectRange[0] <= identifier.range[0] && identifier.range[1] <= effectRange[1])) return true;
+	}
+	return false;
 };
 const noDerivedState = defineRule({
 	id: "no-derived-state",
@@ -25617,18 +25446,124 @@ const noDerivedState = defineRule({
 		if (!isUseEffect(node)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
-			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
-			const stateName = getStateName$1(fact.stateDeclarator);
-			context.report({
-				node: fact.callExpression,
+		if (hasCleanup(analysis, node)) return;
+		const effectFnRefs = getEffectFnRefs(analysis, node);
+		const depsRefs = getEffectDepsRefs(analysis, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const effectFn = getEffectFn(analysis, node);
+		if (!effectFn) return;
+		for (const ref of effectFnRefs) {
+			if (!isSyncStateSetterCall(analysis, ref, effectFn)) continue;
+			const callExpr = getCallExpr(ref);
+			if (!callExpr) continue;
+			if (readsPostMountValueThroughLocals(callExpr, effectFn)) continue;
+			const useStateNode = getUseStateDecl(analysis, ref);
+			const stateName = getStateNameForUseStateDecl(useStateNode) ?? "<state>";
+			const argsUpstreamRefs = getSetterArgsUpstreamRefs(analysis, ref);
+			const depsUpstreamRefs = depsRefs.flatMap((depRef) => getUpstreamRefs(analysis, depRef));
+			if (isInitialOnlySetterCall(callExpr)) continue;
+			if (isControlledPropMirror(node, callExpr)) continue;
+			if (isAccumulatingFunctionalUpdater(analysis, callExpr)) continue;
+			if (effectResetsArgumentSourceState(analysis, effectFnRefs, effectFn, ref, argsUpstreamRefs)) continue;
+			const guardTestsOnPath = collectGuardTestsOnPath(callExpr, effectFn);
+			const upstreamSetterRef = getUpstreamRefs(analysis, ref).find((upRef) => isStateSetter(analysis, upRef)) ?? null;
+			if (guardTestsOnPath.length > 0 && upstreamSetterRef !== null && hasUserInputSetterWriter(upstreamSetterRef, node, true) && (!isWholeValueMirrorArgument(callExpr) || copiesOtherStateOrContextValue(analysis, callExpr, useStateNode)) && !someGuardReadsWrittenState(analysis, guardTestsOnPath, useStateNode)) continue;
+			const isSomeArgsInternal = argsUpstreamRefs.some((argRef) => isState(analysis, argRef) || isProp(analysis, argRef));
+			const isValueAlwaysInSync = argsUpstreamRefs.length > 0 && argsUpstreamRefs.every((argRef) => depsUpstreamRefs.some((depRef) => argRef.resolved === depRef.resolved)) && countSetterCallSites(ref) === 1 && !hasReferenceOutsideEffect(ref, node);
+			if (isSomeArgsInternal) context.report({
+				node: callExpr,
 				message: `Storing "${stateName}" in state when you can derive it from other values costs an extra render.`
 			});
+			else if (isValueAlwaysInSync) context.report({
+				node: callExpr,
+				message: `"${stateName}" is only set here from other values, so storing it costs an extra render.`
+			});
 		}
 	} })
 });
+const isInitialOnlySetterCall = (callExpr) => {
+	if (!isNodeOfType(callExpr, "CallExpression")) return false;
+	const args = callExpr.arguments ?? [];
+	if (args.length !== 1) return false;
+	const arg = args[0];
+	if (!isNodeOfType(arg, "Identifier")) return false;
+	return isInitialOnlyPropName(arg.name);
+};
+//#endregion
+//#region src/plugin/utils/is-no-op-statement.ts
+const isNoOpStatement = (statement) => {
+	if (isNodeOfType(statement, "EmptyStatement")) return true;
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	const expression = stripParenExpression(statement.expression);
+	if (isNodeOfType(expression, "Literal")) return true;
+	if (isNodeOfType(expression, "Identifier")) return expression.name === "undefined";
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return isNodeOfType(stripParenExpression(expression.argument), "Literal");
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/get-callback-statements.ts
+const getCallbackStatements = (callback) => {
+	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") && !isNodeOfType(callback, "FunctionDeclaration")) return [];
+	return (isNodeOfType(callback.body, "BlockStatement") ? callback.body.body ?? [] : callback.body ? [callback.body] : []).filter((statement) => !isNoOpStatement(statement));
+};
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-derived-state-effect.ts
+const collectValueIdentifierNames = (node, into, localBindingNames = /* @__PURE__ */ new Set()) => {
+	if (!node || typeof node !== "object") return;
+	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")) {
+		const nestedBindingNames = new Set(localBindingNames);
+		for (const parameter of node.params ?? []) if (isNodeOfType(parameter, "Identifier")) nestedBindingNames.add(parameter.name);
+		collectValueIdentifierNames(node.body, into, nestedBindingNames);
+		return;
+	}
+	if (isNodeOfType(node, "CallExpression")) {
+		if (isNodeOfType(node.callee, "MemberExpression")) {
+			const rootName = getRootIdentifierName(node.callee);
+			if (!rootName || !BUILTIN_GLOBAL_NAMESPACE_NAMES.has(rootName)) collectValueIdentifierNames(node.callee.object, into, localBindingNames);
+		}
+		for (const argument of node.arguments ?? []) collectValueIdentifierNames(argument, into, localBindingNames);
+		return;
+	}
+	if (isNodeOfType(node, "MemberExpression")) {
+		const rootName = getRootIdentifierName(node);
+		if (!rootName || !BUILTIN_GLOBAL_NAMESPACE_NAMES.has(rootName)) collectValueIdentifierNames(node.object, into, localBindingNames);
+		if (node.computed) collectValueIdentifierNames(node.property, into, localBindingNames);
+		return;
+	}
+	if (isNodeOfType(node, "Identifier")) {
+		if (!localBindingNames.has(node.name)) into.push(node.name);
+		return;
+	}
+	const nodeRecord = node;
+	for (const key of Object.keys(nodeRecord)) {
+		if (key === "parent" || key === "type") continue;
+		const child = nodeRecord[key];
+		if (Array.isArray(child)) {
+			for (const item of child) if (item && typeof item === "object" && "type" in item) collectValueIdentifierNames(item, into, localBindingNames);
+		} else if (child && typeof child === "object" && "type" in child) collectValueIdentifierNames(child, into, localBindingNames);
+	}
+};
+const flattenGuardedStatements = (statements) => {
+	const flattened = [];
+	for (const statement of statements) {
+		if (isNoOpStatement(statement)) continue;
+		if (isNodeOfType(statement, "ExpressionStatement")) {
+			flattened.push(statement);
+			continue;
+		}
+		if (isNodeOfType(statement, "IfStatement")) {
+			for (const branch of [statement.consequent, statement.alternate]) {
+				if (!branch) continue;
+				const flattenedBranch = flattenGuardedStatements(isNodeOfType(branch, "BlockStatement") ? branch.body ?? [] : [branch]);
+				if (flattenedBranch === null) return null;
+				flattened.push(...flattenedBranch);
+			}
+			continue;
+		}
+		return null;
+	}
+	return flattened;
+};
 const noDerivedStateEffect = defineRule({
 	id: "no-derived-state-effect",
 	title: "Derived state stored in an effect",
@@ -25636,13 +25571,83 @@ const noDerivedStateEffect = defineRule({
 	tags: ["test-noise"],
 	recommendation: "Work out derived values while rendering: `const x = fn(dep)`. To reset a component's state when a prop changes, give it a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
 	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		if (!collectEffectStateWriteFacts(analysis, node).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
+		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1) || (node.arguments?.length ?? 0) < 2) return;
+		const callback = getEffectCallback(node);
+		if (!callback) return;
+		const depsNode = node.arguments[1];
+		if (!isNodeOfType(depsNode, "ArrayExpression") || !depsNode.elements?.length) return;
+		const dependencyNames = /* @__PURE__ */ new Set();
+		for (const element of depsNode.elements ?? []) {
+			if (isNodeOfType(element, "Identifier")) dependencyNames.add(element.name);
+			if (isNodeOfType(element, "MemberExpression")) {
+				const rootName = getRootIdentifierName(element);
+				if (rootName) dependencyNames.add(rootName);
+			}
+		}
+		if (dependencyNames.size === 0) return;
+		let allDepsAreInitialOnly = true;
+		let sawAnyDep = false;
+		for (const name of dependencyNames) {
+			sawAnyDep = true;
+			if (!isInitialOnlyPropName(name)) {
+				allDepsAreInitialOnly = false;
+				break;
+			}
+		}
+		if (sawAnyDep && allDepsAreInitialOnly) return;
+		const statements = flattenGuardedStatements(getCallbackStatements(callback));
+		if (statements === null || statements.length === 0) return;
+		if (!statements.every((statement) => {
+			if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+			const expression = statement.expression;
+			if (!isSetterCall(expression)) return false;
+			if (!isNodeOfType(expression, "CallExpression")) return false;
+			if (!isNodeOfType(expression.callee, "Identifier")) return false;
+			return isUseStateSetterInScope(expression, expression.callee.name);
+		})) return;
+		if (statements.some((statement) => {
+			if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+			return isControlledPropMirror(node, statement.expression);
+		})) return;
+		let allArgumentsDeriveFromDeps = true;
+		let hasAnyDependencyReference = false;
+		let hasExpensiveDerivation = false;
+		for (const statement of statements) {
+			if (!isNodeOfType(statement, "ExpressionStatement")) continue;
+			if (!isNodeOfType(statement.expression, "CallExpression")) continue;
+			const setStateArguments = statement.expression.arguments;
+			if (!setStateArguments?.length) continue;
+			const valueIdentifierNames = [];
+			collectValueIdentifierNames(setStateArguments[0], valueIdentifierNames);
+			walkAst(setStateArguments[0], (child) => {
+				if (!isNodeOfType(child, "CallExpression")) return;
+				if (isNodeOfType(child.callee, "MemberExpression")) {
+					const rootName = getRootIdentifierName(child.callee);
+					if (rootName && BUILTIN_GLOBAL_NAMESPACE_NAMES.has(rootName)) return;
+					hasExpensiveDerivation = true;
+					return;
+				}
+				if (isNodeOfType(child.callee, "Identifier")) {
+					const calleeName = child.callee.name;
+					if (!TRIVIAL_DERIVATION_CALLEE_NAMES.has(calleeName) && !isSetterIdentifier(calleeName)) hasExpensiveDerivation = true;
+				}
+			});
+			const nonSetterIdentifiers = valueIdentifierNames.filter((name) => !isSetterIdentifier(name));
+			if (nonSetterIdentifiers.some((name) => dependencyNames.has(name))) hasAnyDependencyReference = true;
+			if (nonSetterIdentifiers.some((name) => !dependencyNames.has(name))) {
+				allArgumentsDeriveFromDeps = false;
+				break;
+			}
+		}
+		if (!allArgumentsDeriveFromDeps) return;
+		if (hasExpensiveDerivation) hasAnyDependencyReference = true;
+		let message;
+		if (!hasAnyDependencyReference) message = "Your users briefly see stale state on every prop change.";
+		else if (hasExpensiveDerivation) message = "You pay an extra render for state derived from other values.";
+		else message = "You pay an extra render for state you can derive from other values.";
 		context.report({
 			node,
-			message: "You pay an extra render for state you can derive from other values."
+			message
 		});
 	} })
 });
@@ -25780,12 +25785,6 @@ const createComponentPropStackTracker = (callbacks) => {
 	};
 };
 //#endregion
-//#region src/plugin/utils/is-initial-only-prop-name.ts
-const isInitialOnlyPropName = (propName) => {
-	if (propName === "initialValue" || propName === "defaultValue" || propName === "seedValue") return true;
-	return /^initial[A-Z]/.test(propName) || /^default[A-Z]/.test(propName) || /^seed[A-Z]/.test(propName) || /^starting[A-Z]/.test(propName) || /^baseline[A-Z]/.test(propName) || /^preset[A-Z]/.test(propName);
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-derived-use-state.ts
 const isInitialOnlySeedName = (propName) => isInitialOnlyPropName(propName) || propName === "initial" || propName === "autoFocus" || propName === "autoPlay" || propName === "startOpen" || /^initially[A-Z]/.test(propName) || /Initial([A-Z]|$)/.test(propName);
 const SNAPSHOT_STATE_NAME_PATTERN = /^(initial|previous|prev|preserved|saved|original|cached|snapshot|prior|debounced|deferred)([A-Z_]|$)/;
@@ -27219,23 +27218,6 @@ const noEffectChain = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-no-op-statement.ts
-const isNoOpStatement = (statement) => {
-	if (isNodeOfType(statement, "EmptyStatement")) return true;
-	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
-	const expression = stripParenExpression(statement.expression);
-	if (isNodeOfType(expression, "Literal")) return true;
-	if (isNodeOfType(expression, "Identifier")) return expression.name === "undefined";
-	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return isNodeOfType(stripParenExpression(expression.argument), "Literal");
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/get-callback-statements.ts
-const getCallbackStatements = (callback) => {
-	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") && !isNodeOfType(callback, "FunctionDeclaration")) return [];
-	return (isNodeOfType(callback.body, "BlockStatement") ? callback.body.body ?? [] : callback.body ? [callback.body] : []).filter((statement) => !isNoOpStatement(statement));
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/find-triggered-side-effect-callee-name.ts
 const findTriggeredSideEffectCalleeName = (consequentNode) => {
 	let foundCalleeName = null;
@@ -27590,186 +27572,397 @@ const noEval = defineRule({
 	})
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/is-state-written-only-from-event-handlers.ts
-const isEventAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
-const isEventProperty = (node) => isNodeOfType(node, "Property") && !node.computed && isNodeOfType(node.key, "Identifier") && /^on[A-Z]/.test(node.key.name);
-const findVariableForDefinition = (analysis, definitionNode) => {
-	for (const scope of analysis.scopeManager.scopes) {
-		const variable = scope.variables.find((candidate) => candidate.defs.some((definition) => definition.node === definitionNode));
-		if (variable) return variable;
+//#region src/plugin/rules/state-and-effects/no-event-handler.ts
+const SETTER_NAME_PATTERN = /^set[A-Z]/;
+const DISPATCH_NAME_PATTERN = /^dispatch$|Dispatch$/;
+const HOOK_NAME_PATTERN$2 = /^use[A-Z0-9]/;
+const isSetterLikeName = (name) => SETTER_NAME_PATTERN.test(name) || DISPATCH_NAME_PATTERN.test(name);
+const isSetterCallExpressionStatement = (node) => {
+	if (!isNodeOfType(node, "ExpressionStatement")) return false;
+	let expression = node.expression;
+	if (expression && isNodeOfType(expression, "ChainExpression")) expression = expression.expression;
+	if (!expression) return false;
+	if (isNodeOfType(expression, "CallExpression")) {
+		const callee = expression.callee;
+		if (isNodeOfType(callee, "Identifier")) return isSetterLikeName(callee.name);
+		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && isSetterLikeName(callee.property.name)) return true;
+		return false;
 	}
-	return null;
-};
-const findFunctionDefinitionNode = (functionNode) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration")) return functionNode;
-	let current = functionNode;
-	while (current) {
-		if (isNodeOfType(current, "VariableDeclarator")) return current;
-		if (isNodeOfType(current, "Program") || isFunctionLike$1(current) && current !== functionNode) return null;
-		current = current.parent;
+	if (isNodeOfType(expression, "AssignmentExpression")) {
+		const left = expression.left;
+		if (isNodeOfType(left, "MemberExpression") && !left.computed && isNodeOfType(left.property, "Identifier") && left.property.name === "current" && isNodeOfType(left.object, "Identifier")) return true;
 	}
-	return null;
+	return false;
 };
-const isInsideInlineEventHandler = (node, boundary) => {
-	let current = node;
-	while (current && current !== boundary) {
-		if (isEventAttribute(current) || isEventProperty(current)) return true;
-		current = current.parent;
+const REF_GUARD_SCAN_BUDGET = 50;
+const containsRefGuard = (testNode) => {
+	const stack = [testNode];
+	let budget = REF_GUARD_SCAN_BUDGET;
+	while (stack.length > 0 && budget-- > 0) {
+		const node = stack.pop();
+		if (isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.property, "Identifier") && node.property.name === "current" && isNodeOfType(node.object, "Identifier")) {
+			const name = node.object.name;
+			if (name === "ref" || name.endsWith("Ref") || name.endsWith("ref")) return true;
+		}
+		if (isNodeOfType(node, "LogicalExpression") || isNodeOfType(node, "BinaryExpression")) stack.push(node.left, node.right);
+		else if (isNodeOfType(node, "UnaryExpression")) stack.push(node.argument);
+		else if (isNodeOfType(node, "ConditionalExpression")) stack.push(node.test, node.consequent, node.alternate);
+		else if (isNodeOfType(node, "MemberExpression")) stack.push(node.object);
+		else if (isNodeOfType(node, "ChainExpression")) stack.push(node.expression);
 	}
 	return false;
 };
-const isFunctionWiredToEventAttribute = (analysis, functionNode) => {
-	const definitionNode = findFunctionDefinitionNode(functionNode);
-	if (!definitionNode) return false;
-	const variable = findVariableForDefinition(analysis, definitionNode);
-	if (!variable) return false;
-	return variable.references.some((reference) => {
-		let current = reference.identifier;
-		while (current && !isFunctionLike$1(current)) {
-			if (isEventAttribute(current) || isEventProperty(current)) return true;
-			current = current.parent;
+const COMPARISON_OPERATORS$1 = new Set([
+	"==",
+	"===",
+	"!=",
+	"!==",
+	"<",
+	"<=",
+	">",
+	">="
+]);
+const isLiteralLikeNode = (node) => isNodeOfType(node, "Literal") || isNodeOfType(node, "TemplateLiteral") || isNodeOfType(node, "UnaryExpression") && isNodeOfType(node.argument, "Literal");
+const isPreviousValueComparisonSide = (analysis, side) => {
+	let current = side;
+	for (;;) if (isNodeOfType(current, "ChainExpression")) current = current.expression;
+	else if (isNodeOfType(current, "TSNonNullExpression")) current = current.expression;
+	else if (isNodeOfType(current, "MemberExpression")) {
+		if (!current.computed && isNodeOfType(current.property, "Identifier") && current.property.name === "current" && isNodeOfType(current.object, "Identifier")) {
+			const objectRef = getRef(analysis, current.object);
+			if (objectRef && isUseRefBinding(objectRef)) return true;
 		}
-		return false;
-	});
+		current = current.object;
+	} else break;
+	if (!isNodeOfType(current, "Identifier")) return false;
+	const baseRef = getRef(analysis, current);
+	return Boolean(baseRef && isOpaqueHookResultBinding(baseRef));
+};
+const containsPreviousValueComparison = (analysis, testNode) => {
+	const stack = [testNode];
+	let budget = REF_GUARD_SCAN_BUDGET;
+	while (stack.length > 0 && budget-- > 0) {
+		const node = stack.pop();
+		if (isNodeOfType(node, "BinaryExpression")) {
+			if (COMPARISON_OPERATORS$1.has(node.operator)) {
+				const left = node.left;
+				const right = node.right;
+				if (isPreviousValueComparisonSide(analysis, left) && !isLiteralLikeNode(right)) return true;
+				if (isPreviousValueComparisonSide(analysis, right) && !isLiteralLikeNode(left)) return true;
+			}
+			stack.push(node.left, node.right);
+		} else if (isNodeOfType(node, "LogicalExpression")) stack.push(node.left, node.right);
+		else if (isNodeOfType(node, "UnaryExpression")) stack.push(node.argument);
+		else if (isNodeOfType(node, "ConditionalExpression")) stack.push(node.test, node.consequent, node.alternate);
+		else if (isNodeOfType(node, "ChainExpression")) stack.push(node.expression);
+	}
+	return false;
 };
-const isFunctionCalledOnlyFromHandlers = (analysis, functionNode, componentFunction) => {
-	const definitionNode = findFunctionDefinitionNode(functionNode);
-	if (!definitionNode) return false;
-	const variable = findVariableForDefinition(analysis, definitionNode);
-	if (!variable) return false;
-	let hasCall = false;
-	for (const reference of variable.references) {
-		const identifier = reference.identifier;
-		const parent = identifier.parent;
-		if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier) continue;
-		hasCall = true;
-		if (!isInsideProvenEventHandler(analysis, parent, componentFunction, false)) return false;
-	}
-	return hasCall;
-};
-const isFunctionUsedOutsideHandlers = (analysis, functionNode, componentFunction) => {
-	const definitionNode = findFunctionDefinitionNode(functionNode);
-	if (!definitionNode) return true;
-	const variable = findVariableForDefinition(analysis, definitionNode);
-	if (!variable) return true;
-	return variable.references.some((reference) => {
-		if (reference.init) return false;
-		const identifier = reference.identifier;
-		if (isInsideInlineEventHandler(identifier, componentFunction)) return false;
-		const parent = identifier.parent;
-		if (parent && isNodeOfType(parent, "CallExpression") && parent.callee === identifier) {
-			if (findEnclosingFunction(parent) === functionNode) return false;
-			if (isInsideProvenEventHandler(analysis, parent, componentFunction, false)) return false;
-		}
-		return true;
-	});
+const TRANSPARENT_HOOK_NAMES = new Set([
+	"useMemo",
+	"useCallback",
+	"useState",
+	"useRef",
+	"useDeferredValue"
+]);
+const getHookCalleeName = (node) => {
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	const callee = node.callee;
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
 };
-const isInsideProvenEventHandler = (analysis, node, componentFunction, allowOneCallFrame) => {
-	if (isInsideInlineEventHandler(node, componentFunction)) return true;
-	let current = node.parent;
-	while (current && current !== componentFunction) {
-		if (isFunctionLike$1(current)) {
-			if (isFunctionWiredToEventAttribute(analysis, current) && !isFunctionUsedOutsideHandlers(analysis, current, componentFunction)) return true;
-			return allowOneCallFrame && isFunctionCalledOnlyFromHandlers(analysis, current, componentFunction);
+const isOpaqueCustomHookInit = (init) => {
+	const calleeName = getHookCalleeName(init);
+	return calleeName !== null && HOOK_NAME_PATTERN$2.test(calleeName) && !TRANSPARENT_HOOK_NAMES.has(calleeName);
+};
+const getDeclaratorInit = (ref) => {
+	for (const def of ref.resolved?.defs ?? []) {
+		const node = def.node;
+		if (isNodeOfType(node, "VariableDeclarator") && node.init) return node.init;
+	}
+	return null;
+};
+const isOpaqueHookResultBinding = (ref) => {
+	const init = getDeclaratorInit(ref);
+	return Boolean(init && isOpaqueCustomHookInit(init));
+};
+const isUseRefBinding = (ref) => {
+	const init = getDeclaratorInit(ref);
+	return Boolean(init && getHookCalleeName(init) === "useRef");
+};
+const REACT_BUILTIN_HOOK_NAMES = new Set([
+	"useState",
+	"useReducer",
+	"useContext",
+	"useMemo",
+	"useCallback",
+	"useRef",
+	"useDeferredValue",
+	"useTransition",
+	"useSyncExternalStore",
+	"useImperativeHandle",
+	"useLayoutEffect",
+	"useEffect",
+	"useInsertionEffect",
+	"useId",
+	"useOptimistic",
+	"useActionState",
+	"useDebugValue"
+]);
+const isCustomHookReturnedBinding = (ref) => {
+	const init = getDeclaratorInit(ref);
+	if (!init) return false;
+	const calleeName = getHookCalleeName(init);
+	return calleeName !== null && HOOK_NAME_PATTERN$2.test(calleeName) && !REACT_BUILTIN_HOOK_NAMES.has(calleeName);
+};
+const collectGuardUpstreamRefs = (analysis, ref, refs, visited) => {
+	if (visited.has(ref)) return;
+	visited.add(ref);
+	refs.push(ref);
+	for (const def of ref.resolved?.defs ?? []) {
+		if (def.type === "ImportBinding" || def.type === "Parameter") continue;
+		const defNode = def.node;
+		const next = defNode.init ?? defNode.body;
+		if (!next) continue;
+		if (isOpaqueCustomHookInit(next)) continue;
+		for (const innerRef of getDownstreamRefs(analysis, next)) {
+			if (isInsideCallbackArgumentOf(innerRef.identifier, next)) continue;
+			collectGuardUpstreamRefs(analysis, innerRef, refs, visited);
 		}
-		current = current.parent;
 	}
+};
+const getGuardUpstreamRefs = (analysis, ref) => {
+	const refs = [];
+	collectGuardUpstreamRefs(analysis, ref, refs, /* @__PURE__ */ new Set());
+	return refs;
+};
+const isSideEffectFreeExit = (statement) => {
+	if (isNodeOfType(statement, "ContinueStatement")) return true;
+	if (isNodeOfType(statement, "BreakStatement")) return true;
+	if (!isNodeOfType(statement, "ReturnStatement")) return false;
+	const argument = statement.argument;
+	if (!argument) return true;
+	if (isNodeOfType(argument, "Literal")) return true;
+	if (isNodeOfType(argument, "Identifier")) return true;
+	if (isNodeOfType(argument, "UnaryExpression") && argument.operator === "void") return true;
 	return false;
 };
-const isSetterWriterUsage = (identifier) => {
-	const parent = identifier.parent;
-	if (!parent) return false;
-	if (isNodeOfType(parent, "CallExpression")) return parent.callee === identifier || (parent.arguments ?? []).includes(identifier);
-	let current = identifier;
-	while (current && !isFunctionLike$1(current)) {
-		if (isEventAttribute(current) || isEventProperty(current)) return true;
-		current = current.parent;
+const getConsequentStatements = (consequent) => {
+	if (isNodeOfType(consequent, "BlockStatement")) return consequent.body ?? [];
+	return [consequent];
+};
+const isControlledPropMirrorStatement = (analysis, statement, testedPropBindings) => {
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	let expression = statement.expression;
+	if (expression && isNodeOfType(expression, "ChainExpression")) expression = expression.expression;
+	if (!expression || !isNodeOfType(expression, "CallExpression")) return false;
+	const callee = expression.callee;
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const calleeRef = getRef(analysis, callee);
+	if (!calleeRef || !isStateSetter(analysis, calleeRef)) return false;
+	const callArguments = expression.arguments ?? [];
+	if (callArguments.length !== 1) return false;
+	const argument = callArguments[0];
+	if (!isNodeOfType(argument, "Identifier")) return false;
+	const argumentRef = getRef(analysis, argument);
+	if (!argumentRef?.resolved || !isProp(analysis, argumentRef)) return false;
+	return testedPropBindings.has(argumentRef.resolved);
+};
+const isControlledPropMirrorConsequent = (analysis, ifNode) => {
+	const statements = getConsequentStatements(ifNode.consequent);
+	if (statements.length === 0) return false;
+	const testRefs = getDownstreamRefs(analysis, ifNode.test);
+	if (testRefs.some((ref) => isState(analysis, ref))) return false;
+	const testedPropBindings = new Set(testRefs.filter((ref) => isProp(analysis, ref)).map((ref) => ref.resolved).filter(Boolean));
+	if (testedPropBindings.size === 0) return false;
+	return statements.every((statement) => isControlledPropMirrorStatement(analysis, statement, testedPropBindings));
+};
+const isPureEarlyExitConsequent = (consequent) => {
+	if (isNodeOfType(consequent, "ReturnStatement") || isNodeOfType(consequent, "ContinueStatement") || isNodeOfType(consequent, "BreakStatement")) return isSideEffectFreeExit(consequent);
+	if (isNodeOfType(consequent, "BlockStatement")) {
+		const body = consequent.body ?? [];
+		if (body.length === 0) return false;
+		const last = body[body.length - 1];
+		if (!isSideEffectFreeExit(last)) return false;
+		for (let i = 0; i < body.length - 1; i++) if (!isSetterCallExpressionStatement(body[i])) return false;
+		return true;
 	}
 	return false;
 };
-const findSetterVariable = (analysis, stateReference) => {
-	const stateDeclarator = getUseStateDecl(analysis, stateReference);
-	if (!stateDeclarator || !isNodeOfType(stateDeclarator, "VariableDeclarator")) return null;
-	if (!isNodeOfType(stateDeclarator.id, "ArrayPattern")) return null;
-	const setter = stateDeclarator.id.elements?.[1];
-	if (!setter || !isNodeOfType(setter, "Identifier")) return null;
-	for (const scope of analysis.scopeManager.scopes) {
-		const variable = scope.variables.find((candidate) => candidate.name === setter.name && candidate.defs.some((definition) => definition.node === stateDeclarator));
-		if (variable) return variable;
-	}
+const isEffectLocalBinding = (ref, effectFn) => Boolean(ref.resolved && ref.resolved.defs.length > 0 && ref.resolved.defs.every((def) => isAstDescendant(def.node, effectFn)));
+const isEffectLocalWriteStatement = (analysis, statement, effectFn) => {
+	if (isSideEffectFreeExit(statement)) return true;
+	if (isNodeOfType(statement, "VariableDeclaration")) return true;
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	const expression = statement.expression;
+	if (!isNodeOfType(expression, "AssignmentExpression")) return false;
+	const left = expression.left;
+	if (!isNodeOfType(left, "Identifier")) return false;
+	const leftRef = getRef(analysis, left);
+	return Boolean(leftRef && isEffectLocalBinding(leftRef, effectFn));
+};
+const isLocalComputationConsequent = (analysis, ifNode, effectFn) => {
+	const statements = getConsequentStatements(ifNode.consequent);
+	if (statements.length === 0) return false;
+	return statements.every((statement) => isEffectLocalWriteStatement(analysis, statement, effectFn));
+};
+const isEffectLocalOnlyTest = (analysis, ifNode, effectFn) => {
+	const testRefs = getDownstreamRefs(analysis, ifNode.test);
+	if (testRefs.length === 0) return false;
+	return testRefs.every((ref) => isEffectLocalBinding(ref, effectFn));
+};
+const isDepsListedCallbackInvocationConsequent = (analysis, ifNode, effectNode) => {
+	const statements = getConsequentStatements(ifNode.consequent);
+	if (statements.length !== 1) return false;
+	const statement = statements[0];
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	let expression = statement.expression;
+	if (isNodeOfType(expression, "ChainExpression")) expression = expression.expression;
+	if (!isNodeOfType(expression, "CallExpression")) return false;
+	if ((expression.arguments ?? []).length !== 0) return false;
+	const callee = expression.callee;
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const calleeRef = getRef(analysis, callee);
+	if (!calleeRef) return false;
+	const init = getDeclaratorInit(calleeRef);
+	if (!init || getHookCalleeName(init) !== "useCallback") return false;
+	const deps = effectNode.arguments?.[1];
+	if (!deps || !isNodeOfType(deps, "ArrayExpression")) return false;
+	return (deps.elements ?? []).some((element) => isNodeOfType(element, "Identifier") && element.name === callee.name);
+};
+const IMPERATIVE_ROOT_GLOBAL_NAMES = new Set([
+	"window",
+	"document",
+	"globalThis"
+]);
+const PARENT_CALLBACK_NAME_PATTERN = /^on[A-Z]/;
+const DATA_ITERATION_METHOD_NAMES = new Set([
+	"forEach",
+	"map",
+	"filter",
+	"reduce",
+	"flatMap",
+	"find",
+	"some",
+	"every",
+	"push",
+	"pop",
+	"shift",
+	"unshift",
+	"splice",
+	"sort",
+	"reverse",
+	"concat"
+]);
+const getImperativeTargetChain = (target) => {
+	let current = target;
+	let passesThroughRefCurrent = false;
+	let memberDepth = 0;
+	for (;;) if (isNodeOfType(current, "ChainExpression")) current = current.expression;
+	else if (isNodeOfType(current, "TSNonNullExpression")) current = current.expression;
+	else if (isNodeOfType(current, "MemberExpression")) {
+		if (!current.computed && isNodeOfType(current.property, "Identifier") && current.property.name === "current") passesThroughRefCurrent = true;
+		memberDepth += 1;
+		current = current.object;
+	} else if (isNodeOfType(current, "CallExpression")) current = current.callee;
+	else break;
+	return {
+		baseIdentifier: isNodeOfType(current, "Identifier") ? current : null,
+		passesThroughRefCurrent,
+		memberDepth
+	};
+};
+const getInvokedMemberName = (callee) => {
+	let current = callee;
+	if (isNodeOfType(current, "ChainExpression")) current = current.expression;
+	if (isNodeOfType(current, "MemberExpression") && isNodeOfType(current.property, "Identifier")) return current.property.name;
 	return null;
 };
-const isStateWrittenOnlyFromEventHandlers = (analysis, stateReference) => {
-	const setterVariable = findSetterVariable(analysis, stateReference);
-	if (!setterVariable) return false;
-	const stateDeclarator = getUseStateDecl(analysis, stateReference);
-	if (!stateDeclarator) return false;
-	const componentFunction = findEnclosingFunction(stateDeclarator);
-	if (!componentFunction) return false;
-	let hasWriter = false;
-	for (const reference of setterVariable.references) {
-		const identifier = reference.identifier;
-		if (!isSetterWriterUsage(identifier)) continue;
-		hasWriter = true;
-		if (!isInsideProvenEventHandler(analysis, identifier, componentFunction, true)) return false;
+const isCustomHookInstanceBinding = (ref) => Boolean(ref.resolved?.defs.some((def) => {
+	const node = def.node;
+	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
+	const calleeName = getHookCalleeName(node.init);
+	return calleeName !== null && HOOK_NAME_PATTERN$2.test(calleeName);
+}));
+const isImperativeSyncStatement = (analysis, statement, testedBindings) => {
+	if (isSideEffectFreeExit(statement)) return true;
+	if (isNodeOfType(statement, "IfStatement")) {
+		if (statement.alternate) return false;
+		const innerTestedBindings = new Set(testedBindings);
+		for (const testRef of getDownstreamRefs(analysis, statement.test)) if (testRef.resolved) innerTestedBindings.add(testRef.resolved);
+		const innerStatements = getConsequentStatements(statement.consequent);
+		if (innerStatements.length === 0) return false;
+		return innerStatements.every((innerStatement) => isImperativeSyncStatement(analysis, innerStatement, innerTestedBindings));
 	}
-	return hasWriter;
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	let expression = statement.expression;
+	if (isNodeOfType(expression, "ChainExpression")) expression = expression.expression;
+	let target;
+	let invokedName = null;
+	if (isNodeOfType(expression, "CallExpression")) {
+		target = expression.callee;
+		invokedName = getInvokedMemberName(target);
+	} else if (isNodeOfType(expression, "AssignmentExpression")) target = expression.left;
+	else return false;
+	const chain = getImperativeTargetChain(target);
+	if (!chain.baseIdentifier) return false;
+	if (chain.memberDepth === 0) {
+		if (!isNodeOfType(expression, "CallExpression")) return false;
+		const calleeRef = getRef(analysis, chain.baseIdentifier);
+		if (!calleeRef?.resolved) return false;
+		if (isState(analysis, calleeRef) || isStateSetter(analysis, calleeRef)) return false;
+		if (PARENT_CALLBACK_NAME_PATTERN.test(chain.baseIdentifier.name)) return false;
+		return isCustomHookReturnedBinding(calleeRef);
+	}
+	const baseName = chain.baseIdentifier.name;
+	if (IMPERATIVE_ROOT_GLOBAL_NAMES.has(baseName)) return true;
+	if (chain.passesThroughRefCurrent) return true;
+	if (baseName === "ref" || baseName.endsWith("Ref") || baseName.endsWith("ref")) return true;
+	const baseRef = getRef(analysis, chain.baseIdentifier);
+	if (!baseRef?.resolved) return false;
+	if (isState(analysis, baseRef) || isStateSetter(analysis, baseRef)) return false;
+	if (isCustomHookInstanceBinding(baseRef)) return true;
+	if (invokedName && PARENT_CALLBACK_NAME_PATTERN.test(invokedName)) return false;
+	if (invokedName && DATA_ITERATION_METHOD_NAMES.has(invokedName)) return false;
+	if (!testedBindings.has(baseRef.resolved)) return false;
+	if (!isCustomHookParameter(baseRef) && isWholePropsObjectReference(analysis, baseRef)) return false;
+	return true;
 };
-//#endregion
-//#region src/plugin/rules/state-and-effects/no-event-handler.ts
-const collectGuardStateReferences = (analysis, testExpression) => {
-	const stateReferences = [];
-	const seenBindings = /* @__PURE__ */ new Set();
-	for (const directReference of getDownstreamRefs(analysis, testExpression)) for (const reference of getUpstreamRefs(analysis, directReference)) {
-		if (!isState(analysis, reference)) continue;
-		const binding = reference.resolved ?? reference.identifier;
-		if (seenBindings.has(binding)) continue;
-		seenBindings.add(binding);
-		stateReferences.push(reference);
-	}
-	return stateReferences;
-};
-const consequentHasTransferableWork = (analysis, consequent) => {
-	if (findTriggeredSideEffectCalleeName(consequent)) return true;
-	if (getDownstreamRefs(analysis, consequent).some((reference) => isPropCallbackInvocationRef(analysis, reference))) return true;
-	let hasTransferableWork = false;
-	walkAst(consequent, (child) => {
-		if (hasTransferableWork) return false;
-		if (child !== consequent && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isNodeOfType(child.callee, "Identifier")) {
-			const calleeReference = getRef(analysis, child.callee);
-			if (calleeReference && isStateSetterCall(analysis, calleeReference)) return;
-			if (calleeReference?.resolved?.defs.some((definition) => {
-				const definitionNode = definition.node;
-				if (!isNodeOfType(definitionNode, "VariableDeclarator")) return false;
-				if (!isNodeOfType(definitionNode.init, "CallExpression")) return false;
-				const hookCallee = definitionNode.init.callee;
-				return isNodeOfType(hookCallee, "Identifier") && hookCallee.name !== "useReducer" && /^use[A-Z0-9]/.test(hookCallee.name);
-			})) return;
-		} else if (!isNodeOfType(child.callee, "MemberExpression") || !isNodeOfType(child.callee.property, "Identifier") || child.callee.property.name !== "setAttribute") return;
-		hasTransferableWork = true;
-		return false;
-	});
-	return hasTransferableWork;
+const isImperativeSyncConsequent = (analysis, ifNode) => {
+	const statements = getConsequentStatements(ifNode.consequent);
+	if (statements.length === 0) return false;
+	if (statements.every((statement) => isSideEffectFreeExit(statement))) return false;
+	const testedBindings = /* @__PURE__ */ new Set();
+	for (const testRef of getDownstreamRefs(analysis, ifNode.test)) if (testRef.resolved) testedBindings.add(testRef.resolved);
+	return statements.every((statement) => isImperativeSyncStatement(analysis, statement, testedBindings));
 };
-const guardHasOtherReactiveSource = (analysis, testExpression, handlerStateDeclarator) => getDownstreamRefs(analysis, testExpression).some((directReference) => getUpstreamRefs(analysis, directReference).some((reference) => {
-	if (isProp(analysis, reference)) return true;
-	if (!isState(analysis, reference)) return false;
-	return getUseStateDecl(analysis, reference) !== handlerStateDeclarator;
-}));
-const consequentHasAdditionalReactiveGuard = (analysis, consequent, handlerStateDeclarator) => {
-	let hasAdditionalGuard = false;
-	walkAst(consequent, (child) => {
-		if (hasAdditionalGuard) return false;
-		if (child !== consequent && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "IfStatement")) return;
-		if (guardHasOtherReactiveSource(analysis, child.test, handlerStateDeclarator)) {
-			hasAdditionalGuard = true;
-			return false;
-		}
-	});
-	return hasAdditionalGuard;
+const isSetterInvocationUsage = (identifier) => {
+	const parent = identifier.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "CallExpression")) {
+		if (parent.callee === identifier) return true;
+		return (parent.arguments ?? []).some((argument) => argument === identifier);
+	}
+	return isNodeOfType(parent, "JSXExpressionContainer");
+};
+const isStateSetterUsedOutsideEffect = (analysis, stateRef, effectNode) => {
+	const declarator = stateRef.resolved?.defs.map((def) => def.node).find((defNode) => isNodeOfType(defNode, "VariableDeclarator") && isNodeOfType(defNode.id, "ArrayPattern"));
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
+	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
+	const setterElement = declarator.id.elements?.[1];
+	if (!setterElement || !isNodeOfType(setterElement, "Identifier")) return false;
+	const setterName = setterElement.name;
+	for (const scope of analysis.scopeManager.scopes) {
+		const setterVariable = scope.variables.find((variable) => variable.name === setterName && variable.defs.some((def) => def.node === declarator));
+		if (!setterVariable) continue;
+		return setterVariable.references.some((reference) => {
+			const identifier = reference.identifier;
+			if (isAstDescendant(identifier, effectNode)) return false;
+			return isSetterInvocationUsage(identifier);
+		});
+	}
+	return false;
 };
 const noEventHandler = defineRule({
 	id: "no-event-handler",
@@ -27779,30 +27972,58 @@ const noEventHandler = defineRule({
 	recommendation: "Run the side effect in the event handler that triggers it, instead of watching its state from a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#sharing-logic-between-event-handlers",
 	create: (context) => ({ CallExpression(node) {
 		if (!isUseEffect(node)) return;
+		const depsArgument = node.arguments?.[1];
+		const isMountOnlyEffect = Boolean(depsArgument && isNodeOfType(depsArgument, "ArrayExpression") && (depsArgument.elements ?? []).length === 0);
 		const analysis = getProgramAnalysis(node);
-		if (!analysis || hasCleanup(analysis, node)) return;
-		const frames = collectBoundedEffectExecutionFrames(analysis, node);
-		for (const frame of frames) {
-			let reported = false;
-			walkAst(frame.functionNode, (child) => {
-				if (reported) return false;
-				if (child !== frame.functionNode && isFunctionLike$1(child)) return false;
-				if (!isNodeOfType(child, "IfStatement") || child.alternate) return;
-				if (!consequentHasTransferableWork(analysis, child.consequent)) return;
-				const stateReferences = collectGuardStateReferences(analysis, child.test);
-				const handlerStateDeclarators = new Set(stateReferences.filter((reference) => isStateWrittenOnlyFromEventHandlers(analysis, reference)).map((reference) => getUseStateDecl(analysis, reference)).filter((declarator) => Boolean(declarator)));
-				if (handlerStateDeclarators.size !== 1) return;
-				const handlerStateDeclarator = [...handlerStateDeclarators][0];
-				if (!handlerStateDeclarator) return;
-				if (guardHasOtherReactiveSource(analysis, child.test, handlerStateDeclarator) || consequentHasAdditionalReactiveGuard(analysis, child.consequent, handlerStateDeclarator)) return;
-				context.report({
-					node,
-					message: "Faking an event handler with state plus a useEffect costs an extra render & runs late."
-				});
-				reported = true;
-				return false;
+		if (!analysis) return;
+		if (hasCleanup(analysis, node)) return;
+		if (!getEffectFnRefs(analysis, node)) return;
+		const effectFn = getEffectFn(analysis, node);
+		if (!effectFn) return;
+		const ifTestRefEntries = findDownstreamNodes(node, "IfStatement").filter((ifNode) => isNodeOfType(ifNode, "IfStatement") && !ifNode.alternate && !isPureEarlyExitConsequent(ifNode.consequent) && !isControlledPropMirrorConsequent(analysis, ifNode) && !containsRefGuard(ifNode.test) && !containsPreviousValueComparison(analysis, ifNode.test) && !isLocalComputationConsequent(analysis, ifNode, effectFn) && !isEffectLocalOnlyTest(analysis, ifNode, effectFn) && !isDepsListedCallbackInvocationConsequent(analysis, ifNode, node) && !isImperativeSyncConsequent(analysis, ifNode)).flatMap((ifNode) => {
+			if (!isNodeOfType(ifNode, "IfStatement")) return [];
+			const directTestRefs = getDownstreamRefs(analysis, ifNode.test);
+			const isAsyncDataGated = directTestRefs.some((ref) => isOpaqueHookResultBinding(ref));
+			return directTestRefs.filter((ref) => !(isState(analysis, ref) && isExternallyDrivenState(analysis, ref))).flatMap((ref) => getGuardUpstreamRefs(analysis, ref)).map((ref) => ({
+				ref,
+				isAsyncDataGated
+			}));
+		});
+		const seenBindings = /* @__PURE__ */ new Map();
+		const seenIdentifiers = /* @__PURE__ */ new Set();
+		const dedupedEntries = [];
+		for (const entry of ifTestRefEntries) {
+			const identifier = entry.ref.identifier;
+			if (!identifier) continue;
+			const resolved = entry.ref.resolved;
+			if (resolved) {
+				const seen = seenBindings.get(resolved);
+				if (seen) {
+					if (!entry.isAsyncDataGated) seen.isAsyncDataGated = false;
+					continue;
+				}
+				seenBindings.set(resolved, entry);
+			}
+			if (seenIdentifiers.has(identifier)) continue;
+			seenIdentifiers.add(identifier);
+			dedupedEntries.push(entry);
+		}
+		const dedupedRefs = dedupedEntries.map((entry) => entry.ref);
+		for (const ref of dedupedRefs) if (isState(analysis, ref)) {
+			if (isExternallyDrivenState(analysis, ref)) continue;
+			if (isMountOnlyEffect && !isStateSetterUsedOutsideEffect(analysis, ref, node)) continue;
+			context.report({
+				node: ref.identifier,
+				message: "Faking an event handler with state plus a useEffect costs an extra render & runs late."
+			});
+		}
+		for (const entry of dedupedEntries) if (isProp(analysis, entry.ref)) {
+			if (isMountOnlyEffect) continue;
+			if (entry.isAsyncDataGated) continue;
+			context.report({
+				node: entry.ref.identifier,
+				message: "Faking an event handler with a prop plus a useEffect costs an extra render & runs late."
 			});
-			if (reported) return;
 		}
 	} })
 });
@@ -28410,6 +28631,46 @@ const collectFunctionLikeLocalNames = (componentBody) => {
 	return functionLikeLocalNames;
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/collect-handler-binding-names.ts
+const collectHandlerBindingNames = (componentBody) => {
+	const handlerNames = /* @__PURE__ */ new Set();
+	walkAst(componentBody, (child) => {
+		if (!isNodeOfType(child, "JSXAttribute")) return;
+		if (!isNodeOfType(child.name, "JSXIdentifier")) return;
+		if (!/^on[A-Z]/.test(child.name.name)) return;
+		if (!isNodeOfType(child.value, "JSXExpressionContainer")) return;
+		const expression = child.value.expression;
+		if (isNodeOfType(expression, "Identifier")) handlerNames.add(expression.name);
+	});
+	return handlerNames;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/is-inside-event-handler.ts
+const isInsideEventHandler = (node, handlerBindingNames) => {
+	let cursor = node.parent ?? null;
+	while (cursor) {
+		if (isNodeOfType(cursor, "ArrowFunctionExpression") || isNodeOfType(cursor, "FunctionExpression") || isNodeOfType(cursor, "FunctionDeclaration")) {
+			let outer = cursor.parent ?? null;
+			while (outer) {
+				if (isNodeOfType(outer, "JSXAttribute")) {
+					const attrName = isNodeOfType(outer.name, "JSXIdentifier") ? outer.name.name : null;
+					if (attrName && /^on[A-Z]/.test(attrName)) return true;
+					return false;
+				}
+				if (isNodeOfType(outer, "VariableDeclarator")) {
+					const declaredName = isNodeOfType(outer.id, "Identifier") ? outer.id.name : null;
+					return Boolean(declaredName && handlerBindingNames.has(declaredName));
+				}
+				if (isNodeOfType(outer, "Program")) return false;
+				outer = outer.parent ?? null;
+			}
+			return false;
+		}
+		cursor = cursor.parent ?? null;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-event-trigger-state.ts
 const SENTINEL_IDENTIFIER_NAMES = new Set([
 	"undefined",
@@ -28436,6 +28697,23 @@ const getTriggerGuardRootName = (testNode) => {
 	if (isNodeOfType(testNode, "UnaryExpression") && testNode.operator === "!") return getTriggerGuardRootName(testNode.argument);
 	return null;
 };
+const collectHandlerOnlyWriteStateNames = (componentBody, useStateBindings, handlerBindingNames) => {
+	const setterNames = new Set(useStateBindings.map((binding) => binding.setterName));
+	const settersWithAnyCall = /* @__PURE__ */ new Set();
+	const settersWithNonHandlerCall = /* @__PURE__ */ new Set();
+	walkAst(componentBody, (child) => {
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!isNodeOfType(child.callee, "Identifier")) return;
+		const setterName = child.callee.name;
+		if (!setterNames.has(setterName)) return;
+		settersWithAnyCall.add(setterName);
+		if (settersWithNonHandlerCall.has(setterName)) return;
+		if (!isInsideEventHandler(child, handlerBindingNames)) settersWithNonHandlerCall.add(setterName);
+	});
+	const handlerOnlyWriteStateNames = /* @__PURE__ */ new Set();
+	for (const binding of useStateBindings) if (settersWithAnyCall.has(binding.setterName) && !settersWithNonHandlerCall.has(binding.setterName)) handlerOnlyWriteStateNames.add(binding.valueName);
+	return handlerOnlyWriteStateNames;
+};
 const noEventTriggerState = defineRule({
 	id: "no-event-trigger-state",
 	title: "State exists only to trigger an effect",
@@ -28447,9 +28725,8 @@ const noEventTriggerState = defineRule({
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
 			const useStateBindings = collectUseStateBindings(componentBody);
 			if (useStateBindings.length === 0) return;
-			const analysis = getProgramAnalysis(componentBody);
-			if (!analysis) return;
-			const localStateNames = new Set(useStateBindings.map((binding) => binding.valueName));
+			const handlerOnlyWriteStateNames = collectHandlerOnlyWriteStateNames(componentBody, useStateBindings, collectHandlerBindingNames(componentBody));
+			if (handlerOnlyWriteStateNames.size === 0) return;
 			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody);
 			const dependencyGraph = buildLocalDependencyGraph(componentBody, eventHandlerReferenceNames);
 			const renderReachableNames = expandTransitiveDependencies(collectRenderReachableNames(componentBody, eventHandlerReferenceNames), dependencyGraph);
@@ -28462,9 +28739,7 @@ const noEventTriggerState = defineRule({
 				if ((depsNode.elements?.length ?? 0) !== 1) return;
 				const depElement = depsNode.elements[0];
 				if (!isNodeOfType(depElement, "Identifier")) return;
-				if (!localStateNames.has(depElement.name)) return;
-				const dependencyReference = getRef(analysis, depElement);
-				if (!dependencyReference || !isState(analysis, dependencyReference) || !isStateWrittenOnlyFromEventHandlers(analysis, dependencyReference)) return;
+				if (!handlerOnlyWriteStateNames.has(depElement.name)) return;
 				if (renderReachableNames.has(depElement.name)) return;
 				const callback = getEffectCallback(effectCall);
 				if (!callback) return;
@@ -29361,12 +29636,264 @@ const noIndeterminateAttribute = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/contains-non-deterministic-source.ts
+const NON_DETERMINISTIC_MEMBER_CALLS = new Set([
+	"Math.random",
+	"Date.now",
+	"performance.now",
+	"crypto.randomUUID",
+	"crypto.getRandomValues"
+]);
+const NON_DETERMINISTIC_ID_GENERATOR_NAMES = new Set([
+	"nanoid",
+	"uuid",
+	"cuid",
+	"ulid",
+	"createId"
+]);
+const isZeroArgDateConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Date" && (node.arguments?.length ?? 0) === 0;
+const containsNonDeterministicSource = (root) => {
+	let found = false;
+	walkAst(root, (child) => {
+		if (found) return false;
+		if (isFunctionLike$1(child)) return false;
+		if (isZeroArgDateConstruction(child)) {
+			found = true;
+			return false;
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = child.callee;
+		if (isNodeOfType(callee, "Identifier") && NON_DETERMINISTIC_ID_GENERATOR_NAMES.has(callee.name)) {
+			found = true;
+			return false;
+		}
+		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && NON_DETERMINISTIC_MEMBER_CALLS.has(`${callee.object.name}.${callee.property.name}`)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-initialize-state.ts
-const getStateName = (stateDeclarator) => {
-	if (!isNodeOfType(stateDeclarator, "VariableDeclarator")) return "<state>";
-	if (!isNodeOfType(stateDeclarator.id, "ArrayPattern")) return "<state>";
-	const stateBinding = stateDeclarator.id.elements?.[0] ?? stateDeclarator.id.elements?.[1];
-	return stateBinding && isNodeOfType(stateBinding, "Identifier") ? stateBinding.name : "<state>";
+const MEASUREMENT_GLOBAL_NAMES = new Set([
+	"window",
+	"document",
+	"navigator"
+]);
+const objectPatternBindsName = (pattern, name) => {
+	if (!isNodeOfType(pattern, "ObjectPattern")) return false;
+	return (pattern.properties ?? []).some((property) => {
+		if (!isNodeOfType(property, "Property")) return false;
+		const bound = property.value;
+		return Boolean(bound && isNodeOfType(bound, "Identifier") && bound.name === name);
+	});
+};
+const findEffectLocalInitializer = (effectFn, name) => {
+	let initializer = null;
+	walkAst(effectFn, (child) => {
+		if (initializer) return false;
+		if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
+		if (isNodeOfType(child.id, "Identifier") && child.id.name === name || objectPatternBindsName(child.id, name)) {
+			initializer = child.init;
+			return false;
+		}
+	});
+	return initializer;
+};
+const isMeasurementGlobalValueRead = (identifier) => {
+	const memberParent = identifier.parent;
+	if (!isNodeOfType(memberParent, "MemberExpression") || memberParent.object !== identifier) return false;
+	if (isNodeOfType(memberParent.property, "Identifier") && DOM_QUERY_MEMBER_NAMES.has(memberParent.property.name)) {
+		const callGrandparent = memberParent.parent;
+		return Boolean(callGrandparent && isNodeOfType(callGrandparent, "CallExpression") && callGrandparent.callee === memberParent);
+	}
+	return true;
+};
+const argumentReadsPostMountMeasurement = (argument, effectFn, visitedLocalNames = /* @__PURE__ */ new Set()) => {
+	let found = false;
+	walkAst(argument, (child) => {
+		if (found) return false;
+		if (isMeasurementMemberRead(child)) {
+			found = true;
+			return false;
+		}
+		if (!isNodeOfType(child, "Identifier")) return;
+		if (isPostMountGlobalRead(child) && MEASUREMENT_GLOBAL_NAMES.has(child.name) && isMeasurementGlobalValueRead(child)) {
+			found = true;
+			return false;
+		}
+		if (visitedLocalNames.has(child.name)) return;
+		visitedLocalNames.add(child.name);
+		const localInitializer = findEffectLocalInitializer(effectFn, child.name);
+		if (localInitializer && argumentReadsPostMountMeasurement(localInitializer, effectFn, visitedLocalNames)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+};
+const isResourceLikeInitializer = (initializer) => {
+	if (isNodeOfType(initializer, "AwaitExpression")) return isResourceLikeInitializer(initializer.argument);
+	return isNodeOfType(initializer, "NewExpression") || isNodeOfType(initializer, "CallExpression");
+};
+const collectArgumentSourceLocalNames = (argument, effectFn, sourceLocalNames = /* @__PURE__ */ new Set()) => {
+	walkAst(argument, (child) => {
+		if (!isNodeOfType(child, "Identifier")) return;
+		if (sourceLocalNames.has(child.name)) return;
+		const localInitializer = findEffectLocalInitializer(effectFn, child.name);
+		if (!localInitializer || !isResourceLikeInitializer(localInitializer)) return;
+		sourceLocalNames.add(child.name);
+		collectArgumentSourceLocalNames(localInitializer, effectFn, sourceLocalNames);
+	});
+	return sourceLocalNames;
+};
+const isFunctionExpressionLike$2 = (node) => isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression");
+const findCleanupFunction = (effectFn) => {
+	if (!isNodeOfType(effectFn, "ArrowFunctionExpression") && !isNodeOfType(effectFn, "FunctionExpression")) return null;
+	const body = effectFn.body;
+	if (!isNodeOfType(body, "BlockStatement")) return null;
+	let cleanupFunction = null;
+	walkAst(body, (child) => {
+		if (cleanupFunction) return false;
+		if (isNodeOfType(child, "ReturnStatement")) {
+			if (child.argument && isFunctionExpressionLike$2(child.argument)) cleanupFunction = child.argument;
+			return false;
+		}
+		if (child !== body && isFunctionExpressionLike$2(child)) return false;
+		if (isNodeOfType(child, "FunctionDeclaration")) return false;
+	});
+	return cleanupFunction;
+};
+const cleanupDisposesArgumentSource = (argument, effectFn) => {
+	const cleanupFunction = findCleanupFunction(effectFn);
+	if (!cleanupFunction) return false;
+	const sourceLocalNames = collectArgumentSourceLocalNames(argument, effectFn);
+	if (sourceLocalNames.size === 0) return false;
+	let referencesSource = false;
+	walkAst(cleanupFunction, (child) => {
+		if (referencesSource) return false;
+		if (isNodeOfType(child, "Identifier") && sourceLocalNames.has(child.name)) {
+			referencesSource = true;
+			return false;
+		}
+	});
+	return referencesSource;
+};
+const cleanupResetsSameSetter = (effectFn, setterName) => {
+	const cleanupFunction = findCleanupFunction(effectFn);
+	if (!cleanupFunction) return false;
+	let resets = false;
+	walkAst(cleanupFunction, (child) => {
+		if (resets) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName) {
+			resets = true;
+			return false;
+		}
+	});
+	return resets;
+};
+const TYPEOF_BROWSER_GLOBAL_NAMES = new Set(["window", "document"]);
+const initializerHasTypeofBrowserGlobalCheck = (useStateDecl) => {
+	if (!isNodeOfType(useStateDecl, "VariableDeclarator")) return false;
+	if (!isNodeOfType(useStateDecl.init, "CallExpression")) return false;
+	const initialArgument = useStateDecl.init.arguments?.[0];
+	if (!initialArgument) return false;
+	let found = false;
+	walkAst(initialArgument, (child) => {
+		if (found) return false;
+		if (isNodeOfType(child, "UnaryExpression") && child.operator === "typeof" && isNodeOfType(child.argument, "Identifier") && TYPEOF_BROWSER_GLOBAL_NAMES.has(child.argument.name)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+};
+const HANDLER_HELPER_NAME_PATTERN = /^(on|handle)[A-Z_]/;
+const isSameValueExpression = (leftNode, rightNode) => {
+	const left = stripParenExpression(leftNode);
+	const right = stripParenExpression(rightNode);
+	if (left.type !== right.type) return false;
+	if (isNodeOfType(left, "Identifier") && isNodeOfType(right, "Identifier")) return left.name === right.name;
+	if (isNodeOfType(left, "Literal") && isNodeOfType(right, "Literal")) return left.value === right.value;
+	if (isNodeOfType(left, "MemberExpression") && isNodeOfType(right, "MemberExpression")) {
+		if (left.computed !== right.computed) return false;
+		return isSameValueExpression(left.property, right.property) && isSameValueExpression(left.object, right.object);
+	}
+	if (isNodeOfType(left, "CallExpression") && isNodeOfType(right, "CallExpression")) {
+		const leftArguments = left.arguments ?? [];
+		const rightArguments = right.arguments ?? [];
+		if (leftArguments.length !== rightArguments.length) return false;
+		if (!isSameValueExpression(left.callee, right.callee)) return false;
+		return leftArguments.every((leftArgument, argumentIndex) => isSameValueExpression(leftArgument, rightArguments[argumentIndex]));
+	}
+	if (isNodeOfType(left, "UnaryExpression") && isNodeOfType(right, "UnaryExpression")) return left.operator === right.operator && isSameValueExpression(left.argument, right.argument);
+	return false;
+};
+const unwrapLazyInitializer = (initializer) => {
+	if (!isNodeOfType(initializer, "ArrowFunctionExpression")) return initializer;
+	const body = initializer.body;
+	if (!isNodeOfType(body, "BlockStatement")) return body;
+	const statements = body.body ?? [];
+	if (statements.length === 1 && isNodeOfType(statements[0], "ReturnStatement")) {
+		const returned = statements[0].argument;
+		if (returned) return returned;
+	}
+	return initializer;
+};
+const collectInitializerValueExpressions = (useStateDecl) => {
+	if (!isNodeOfType(useStateDecl, "VariableDeclarator")) return [];
+	if (!isNodeOfType(useStateDecl.init, "CallExpression")) return [];
+	const initialArgument = useStateDecl.init.arguments?.[0];
+	if (!initialArgument) return [];
+	const expressions = [];
+	const expand = (node) => {
+		expressions.push(node);
+		if (isNodeOfType(node, "LogicalExpression") && (node.operator === "??" || node.operator === "||")) {
+			expand(node.left);
+			expand(node.right);
+		}
+	};
+	expand(unwrapLazyInitializer(initialArgument));
+	return expressions;
+};
+const isUseStateWithoutArgument = (useStateDecl) => isNodeOfType(useStateDecl, "VariableDeclarator") && isNodeOfType(useStateDecl.init, "CallExpression") && (useStateDecl.init.arguments ?? []).length === 0;
+const isUndefinedExpression = (node) => {
+	const unwrapped = stripParenExpression(node);
+	if (isNodeOfType(unwrapped, "Identifier")) return unwrapped.name === "undefined";
+	return isNodeOfType(unwrapped, "UnaryExpression") && unwrapped.operator === "void";
+};
+const isSameValueAsInitializer = (callExpr, useStateDecl) => {
+	if (!isNodeOfType(callExpr, "CallExpression")) return false;
+	const args = callExpr.arguments ?? [];
+	if (args.length !== 1) return false;
+	const setterArgument = args[0];
+	if (isUseStateWithoutArgument(useStateDecl) && isUndefinedExpression(setterArgument)) return true;
+	return collectInitializerValueExpressions(useStateDecl).some((initializerValue) => isSameValueExpression(setterArgument, initializerValue));
+};
+const collectInnerStateSetterCalls = (analysis, helperFn) => {
+	const innerCalls = [];
+	const helperBody = helperFn.body;
+	if (!helperBody) return innerCalls;
+	walkAst(helperBody, (child) => {
+		if (!isNodeOfType(child, "Identifier")) return;
+		const innerRef = getRef(analysis, child);
+		if (!innerRef || !isStateSetter(analysis, innerRef)) return;
+		const innerCallExpr = getCallExpr(innerRef);
+		if (!innerCallExpr) return;
+		innerCalls.push({
+			ref: innerRef,
+			callExpr: innerCallExpr,
+			isSyncWithinFunction: isSynchronous(child, helperFn)
+		});
+	});
+	return innerCalls;
+};
+const isNodeWithinRange = (inner, outer) => {
+	const innerRange = inner.range;
+	const outerRange = outer.range;
+	if (!innerRange || !outerRange) return false;
+	return outerRange[0] <= innerRange[0] && innerRange[1] <= outerRange[1];
 };
 const noInitializeState = defineRule({
 	id: "no-initialize-state",
@@ -29376,15 +29903,53 @@ const noInitializeState = defineRule({
 	recommendation: "Pass the initial value directly to useState() instead of setting it from a mount-only useEffect. For SSR hydration, prefer useSyncExternalStore().",
 	create: (context) => ({ CallExpression(node) {
 		if (!isUseEffect(node)) return;
-		const dependencies = node.arguments?.[1];
-		if (!dependencies || !isNodeOfType(dependencies, "ArrayExpression") || (dependencies.elements ?? []).length !== 0) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
-			if (!fact.isRenderKnownCopy || fact.matchesStateInitializer || fact.resetsSourceState) continue;
-			const stateName = getStateName(fact.stateDeclarator);
+		const effectFnRefs = getEffectFnRefs(analysis, node);
+		const depsRefs = getEffectDepsRefs(analysis, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const effectFn = getEffectFn(analysis, node);
+		if (!effectFn) return;
+		if (!(depsRefs.filter((ref) => !isStateSetter(analysis, ref)).length === 0)) return;
+		for (const ref of effectFnRefs) {
+			if (!isSyncStateSetterCall(analysis, ref, effectFn)) continue;
+			const callExpr = getCallExpr(ref);
+			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
+			if (callExpr.arguments?.some((argument) => Boolean(argument) && containsNonDeterministicSource(argument))) continue;
+			if (callExpr.arguments?.some((argument) => Boolean(argument) && argumentReadsPostMountMeasurement(argument, effectFn))) continue;
+			if (callExpr.arguments?.some((argument) => Boolean(argument) && cleanupDisposesArgumentSource(argument, effectFn))) continue;
+			if (!isStateSetter(analysis, ref)) {
+				const helperFn = resolveToFunction(ref);
+				if (helperFn) {
+					const helperName = getFunctionBindingName$1(helperFn);
+					if (helperName && HANDLER_HELPER_NAME_PATTERN.test(helperName)) continue;
+				}
+				if (helperFn) {
+					const innerSetterCalls = collectInnerStateSetterCalls(analysis, helperFn);
+					if (innerSetterCalls.length > 0) {
+						const syncInnerCalls = innerSetterCalls.filter((innerCall) => innerCall.isSyncWithinFunction);
+						if (syncInnerCalls.length === 0) continue;
+						const measurementLookupFn = isNodeWithinRange(helperFn, effectFn) ? effectFn : helperFn;
+						if (syncInnerCalls.every((innerCall) => {
+							if (!isNodeOfType(innerCall.callExpr, "CallExpression")) return false;
+							const innerUseStateDecl = getUseStateDecl(analysis, innerCall.ref);
+							if (innerUseStateDecl && isSameValueAsInitializer(innerCall.callExpr, innerUseStateDecl)) return true;
+							return (innerCall.callExpr.arguments ?? []).some((argument) => Boolean(argument) && (containsNonDeterministicSource(argument) || argumentReadsPostMountMeasurement(argument, measurementLookupFn)));
+						})) continue;
+					}
+				}
+			}
+			const useStateDecl = getUseStateDecl(analysis, ref);
+			if (!useStateDecl || !isNodeOfType(useStateDecl, "VariableDeclarator")) continue;
+			if (isSameValueAsInitializer(callExpr, useStateDecl)) continue;
+			if (initializerHasTypeofBrowserGlobalCheck(useStateDecl)) continue;
+			if (isNodeOfType(callExpr.callee, "Identifier") && cleanupResetsSameSetter(effectFn, callExpr.callee.name)) continue;
+			if (!isNodeOfType(useStateDecl.id, "ArrayPattern")) continue;
+			const elements = useStateDecl.id.elements ?? [];
+			const stateBinding = elements[0] ?? elements[1];
+			const stateName = stateBinding && isNodeOfType(stateBinding, "Identifier") ? stateBinding.name : "<state>";
 			context.report({
-				node: fact.callExpression,
+				node: callExpr,
 				message: `Your users see an extra render with empty "${stateName}" because a useEffect sets its starting value.`
 			});
 		}
@@ -32445,19 +33010,6 @@ const DATA_SINK_METHOD_NAMES = new Set([
 	"deserialize"
 ]);
 //#endregion
-//#region src/plugin/utils/get-call-method-name.ts
-/**
-* Returns the static method name of a call's callee when it's a
-* non-computed MemberExpression (`obj.method` → `"method"`), or
-* `null` otherwise. Used by `no-pass-data-to-parent` and
-* `no-pass-live-state-to-parent` to match the receiver-bound
-* method-call shape against an allow/block list.
-*/
-const getCallMethodName = (callee) => {
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-pass-data-to-parent.ts
 const isUseStateIdentifier = (identifier) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
@@ -38448,7 +39000,7 @@ const containsVnodeFactoryCall = (root) => {
 };
 const isComponentLikeFunction = (functionNode) => {
 	const bindingName = getFunctionBindingName$1(functionNode);
-	if (bindingName && (isReactComponentName(bindingName) || HOOK_NAME_PATTERN$3.test(bindingName))) return true;
+	if (bindingName && (isReactComponentName(bindingName) || HOOK_NAME_PATTERN$4.test(bindingName))) return true;
 	const body = "body" in functionNode ? functionNode.body : null;
 	if (!body || !isAstNode(body)) return false;
 	return containsJsxElement(body) || containsVnodeFactoryCall(body);
@@ -41864,46 +42416,6 @@ const requireRenderReturn = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/collect-handler-binding-names.ts
-const collectHandlerBindingNames = (componentBody) => {
-	const handlerNames = /* @__PURE__ */ new Set();
-	walkAst(componentBody, (child) => {
-		if (!isNodeOfType(child, "JSXAttribute")) return;
-		if (!isNodeOfType(child.name, "JSXIdentifier")) return;
-		if (!/^on[A-Z]/.test(child.name.name)) return;
-		if (!isNodeOfType(child.value, "JSXExpressionContainer")) return;
-		const expression = child.value.expression;
-		if (isNodeOfType(expression, "Identifier")) handlerNames.add(expression.name);
-	});
-	return handlerNames;
-};
-//#endregion
-//#region src/plugin/rules/state-and-effects/utils/is-inside-event-handler.ts
-const isInsideEventHandler = (node, handlerBindingNames) => {
-	let cursor = node.parent ?? null;
-	while (cursor) {
-		if (isNodeOfType(cursor, "ArrowFunctionExpression") || isNodeOfType(cursor, "FunctionExpression") || isNodeOfType(cursor, "FunctionDeclaration")) {
-			let outer = cursor.parent ?? null;
-			while (outer) {
-				if (isNodeOfType(outer, "JSXAttribute")) {
-					const attrName = isNodeOfType(outer.name, "JSXIdentifier") ? outer.name.name : null;
-					if (attrName && /^on[A-Z]/.test(attrName)) return true;
-					return false;
-				}
-				if (isNodeOfType(outer, "VariableDeclarator")) {
-					const declaredName = isNodeOfType(outer.id, "Identifier") ? outer.id.name : null;
-					return Boolean(declaredName && handlerBindingNames.has(declaredName));
-				}
-				if (isNodeOfType(outer, "Program")) return false;
-				outer = outer.parent ?? null;
-			}
-			return false;
-		}
-		cursor = cursor.parent ?? null;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/rerender-defer-reads-hook.ts
 const DEFERRABLE_HOOK_NAMES = new Set([
 	"useSearchParams",
@@ -51397,7 +51909,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 			if (!isNodeOfType(callParent, "CallExpression")) return false;
 			if (callParent.callee === functionNode) return false;
 			if (isNodeOfType(callParent.callee, "MemberExpression") && !callParent.callee.computed && isNodeOfType(callParent.callee.property, "Identifier") && PROMISE_CONTINUATION_METHODS.has(callParent.callee.property.name)) return true;
-			return isNodeOfType(callParent.callee, "Identifier") && HOOK_NAME_PATTERN$3.test(callParent.callee.name) && !RENDER_SYNCHRONOUS_HOOK_NAMES.has(callParent.callee.name) && callParent.arguments?.[0] === functionNode;
+			return isNodeOfType(callParent.callee, "Identifier") && HOOK_NAME_PATTERN$4.test(callParent.callee.name) && !RENDER_SYNCHRONOUS_HOOK_NAMES.has(callParent.callee.name) && callParent.arguments?.[0] === functionNode;
 		};
 		const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && REACT_HANDLER_PROP_PATTERN.test(node.name.name);
 		const isEventHandlerNamedProperty = (node) => isNodeOfType(node, "Property") && (isNodeOfType(node.key, "Identifier") && typeof node.key.name === "string" && REACT_HANDLER_PROP_PATTERN.test(node.key.name) || isNodeOfType(node.key, "Literal") && typeof node.key.value === "string" && REACT_HANDLER_PROP_PATTERN.test(node.key.value));
@@ -51425,11 +51937,11 @@ const tanstackStartNoNavigateInRender = defineRule({
 			if (isNodeOfType(parent, "ReturnStatement")) {
 				const outerFunction = findEnclosingFunction(parent);
 				const hookName = outerFunction ? getFunctionBindingName$1(outerFunction) : null;
-				return Boolean(hookName && HOOK_NAME_PATTERN$3.test(hookName));
+				return Boolean(hookName && HOOK_NAME_PATTERN$4.test(hookName));
 			}
 			if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === functionNode) {
 				const hookName = getFunctionBindingName$1(parent);
-				return Boolean(hookName && HOOK_NAME_PATTERN$3.test(hookName));
+				return Boolean(hookName && HOOK_NAME_PATTERN$4.test(hookName));
 			}
 			return false;
 		};