oxlint-plugin-react-doctor 0.8.1-dev.1839566 → 0.8.1-dev.26b4a0c

package/dist/index.d.ts

@@ -9437,7 +9437,7 @@ declare const EXTERNAL_RULES: readonly [{
 }, {
   readonly key: "react-hooks-js/set-state-in-effect";
   readonly source: "react-compiler";
-  readonly severity: "error";
+  readonly severity: "warn";
 }, {
   readonly key: "react-hooks-js/globals";
   readonly source: "react-compiler";
@@ -18748,7 +18748,7 @@ declare const RULES: readonly [{
 }, {
   readonly key: "react-hooks-js/set-state-in-effect";
   readonly source: "react-compiler";
-  readonly severity: "error";
+  readonly severity: "warn";
 }, {
   readonly key: "react-hooks-js/globals";
   readonly source: "react-compiler";

package/dist/index.js

@@ -13961,6 +13961,18 @@ const isNodeReachableWithinFunction = (node, context) => {
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
 const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
 const REPLAYABLE_ITERATOR_COLLECTION_CACHE = /* @__PURE__ */ new WeakMap();
+const REPLAY_ENTRY_DROPPING_ARRAY_METHOD_NAMES = new Set([
+	"pop",
+	"shift",
+	"splice",
+	"fill",
+	"copyWithin"
+]);
+const REPLAY_ENTRY_DROPPING_COLLECTION_METHOD_NAMES = new Set([
+	"clear",
+	"delete",
+	"set"
+]);
 const REACT_REF_EFFECT_ANALYSIS_CACHE = /* @__PURE__ */ new WeakMap();
 const RESOURCE_NOUN_BY_KIND = {
 	subscribe: "subscription",
@@ -14001,6 +14013,92 @@ const resolveExpressionKey = (expression, context, visitedSymbolIds = /* @__PURE
 	}
 	return null;
 };
+const resolveForEachProjection = (expression, context) => {
+	if (!expression) return null;
+	let currentExpression = stripParenExpression(expression);
+	const memberNames = [];
+	while (isNodeOfType(currentExpression, "MemberExpression") && !currentExpression.computed) {
+		if (!isNodeOfType(currentExpression.property, "Identifier")) return null;
+		memberNames.unshift(currentExpression.property.name);
+		currentExpression = stripParenExpression(currentExpression.object);
+	}
+	if (!isNodeOfType(currentExpression, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(currentExpression);
+	if (!symbol || symbol.kind !== "parameter") return null;
+	let callbackNode = symbol.bindingIdentifier.parent;
+	while (callbackNode && !isFunctionLike$1(callbackNode)) callbackNode = callbackNode.parent;
+	if (!callbackNode || !isFunctionLike$1(callbackNode)) return null;
+	const forEachCall = findEnclosingForEachCall(callbackNode);
+	if (!forEachCall) return null;
+	const forEachCallee = stripParenExpression(forEachCall.callee);
+	if (!isNodeOfType(forEachCallee, "MemberExpression")) return null;
+	const collectionKey = resolveExpressionKey(forEachCallee.object, context);
+	if (!collectionKey) return null;
+	const firstParameter = callbackNode.params[0];
+	const bindingProperty = symbol.bindingIdentifier.parent;
+	const propertyName = isNodeOfType(firstParameter, "ObjectPattern") && isNodeOfType(bindingProperty, "Property") && bindingProperty.parent === firstParameter && bindingProperty.value === symbol.bindingIdentifier ? getStaticPropertyKeyName(bindingProperty) : null;
+	const parameterProjection = firstParameter === symbol.bindingIdentifier ? "value" : propertyName;
+	if (!parameterProjection) return null;
+	return {
+		collectionKey,
+		projectionKey: [parameterProjection, ...memberNames].join(".")
+	};
+};
+const resolveForEachProjectionKey = (expression, context) => {
+	const projection = resolveForEachProjection(expression, context);
+	return projection ? `forEach:${projection.collectionKey}:${projection.projectionKey}` : null;
+};
+const resolveResourceIdentityKey = (expression, context) => resolveForEachProjectionKey(expression, context) ?? resolveExpressionKey(expression, context);
+const resolveEventListenerCaptureIdentityKey = (optionsNode, context, allowOpaqueOptionsIdentity) => {
+	const capture = resolveEventListenerCapture(optionsNode, { allowIndeterminateEntries: true });
+	if (capture !== null) return `capture:${String(capture)}`;
+	if (!optionsNode) return null;
+	const unwrappedOptions = stripParenExpression(optionsNode);
+	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) {
+		const optionsKey = allowOpaqueOptionsIdentity ? resolveResourceIdentityKey(unwrappedOptions, context) : null;
+		return optionsKey ? `options:${optionsKey}` : null;
+	}
+	let captureKey = "capture:false";
+	for (const property of unwrappedOptions.properties ?? []) {
+		if (!isNodeOfType(property, "Property")) {
+			captureKey = null;
+			continue;
+		}
+		const propertyName = getStaticPropertyKeyName(property);
+		if (propertyName === null || !property.computed && propertyName === "__proto__") {
+			captureKey = null;
+			continue;
+		}
+		if (propertyName === "capture") {
+			const propertyValueKey = resolveResourceIdentityKey(property.value, context);
+			captureKey = propertyValueKey ? `capture-value:${propertyValueKey}` : null;
+		}
+	}
+	return captureKey;
+};
+const resolveEventListenerCaptureProjection = (optionsNode, context) => {
+	if (!optionsNode) return null;
+	const unwrappedOptions = stripParenExpression(optionsNode);
+	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) return resolveForEachProjection(unwrappedOptions, context);
+	let captureProjection = null;
+	for (const property of unwrappedOptions.properties ?? []) {
+		if (!isNodeOfType(property, "Property")) {
+			captureProjection = null;
+			continue;
+		}
+		const propertyName = getStaticPropertyKeyName(property);
+		if (propertyName === null || !property.computed && propertyName === "__proto__") {
+			captureProjection = null;
+			continue;
+		}
+		if (propertyName === "capture") captureProjection = resolveForEachProjection(property.value, context);
+	}
+	return captureProjection;
+};
+const doEventListenerCapturesMatch = (registrationOptions, releaseOptions, context, allowOpaqueOptionsIdentity = false) => {
+	const registrationCaptureKey = resolveEventListenerCaptureIdentityKey(registrationOptions, context, allowOpaqueOptionsIdentity);
+	return registrationCaptureKey !== null && registrationCaptureKey === resolveEventListenerCaptureIdentityKey(releaseOptions, context, allowOpaqueOptionsIdentity);
+};
 const findAssignedResourceKey = (resourceNode, context) => {
 	let currentNode = resourceNode;
 	let parentNode = currentNode.parent;
@@ -14021,10 +14119,10 @@ const getCallRegistrationDetails = (callNode, context) => {
 		handlerKey: null
 	};
 	return {
-		receiverKey: resolveExpressionKey(callee.object, context),
+		receiverKey: resolveResourceIdentityKey(callee.object, context),
 		registrationVerbName: callee.property.name,
-		eventKey: resolveExpressionKey(callNode.arguments?.[0], context),
-		handlerKey: resolveExpressionKey(callNode.arguments?.[1], context)
+		eventKey: resolveResourceIdentityKey(callNode.arguments?.[0], context),
+		handlerKey: resolveResourceIdentityKey(callNode.arguments?.[1], context)
 	};
 };
 const findSubscribeLikeUsages = (callback, context) => {
@@ -14449,8 +14547,8 @@ const isSynchronousIteratorCallback = (functionNode) => {
 	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$2.has(callee.property.name) && callNode.arguments?.[0] === functionNode;
 };
 const findEnclosingForEachCall = (node) => {
-	const callbackNode = findEnclosingFunction$1(node);
-	if (!callbackNode) return null;
+	const callbackNode = isFunctionLike$1(node) ? node : findEnclosingFunction$1(node);
+	if (!callbackNode || !isFunctionLike$1(callbackNode) || callbackNode.async || callbackNode.generator) return null;
 	const callNode = callbackNode.parent;
 	if (!isNodeOfType(callNode, "CallExpression") || callNode.arguments?.[0] !== callbackNode) return null;
 	const callee = stripParenExpression(callNode.callee);
@@ -15099,9 +15197,7 @@ const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
 	const nodeParameterKey = resolveExpressionKey(usageFunction.params?.[0], context);
 	const releaseReceiverKey = resolveExpressionKey(releaseCallee.object, context);
 	if (registrationReceiverKey === null || registrationReceiverKey !== nodeParameterKey || releaseReceiverKey === null || usage.eventKey === null || usage.eventKey !== resolveExpressionKey(releaseCall.arguments?.[0], context) || usage.handlerKey === null || usage.handlerKey !== resolveExpressionKey(releaseCall.arguments?.[1], context)) return false;
-	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
-	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
-	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
+	if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], releaseCall.arguments?.[2], context)) return false;
 	const releaseStart = getRangeStart(releaseCall);
 	const matchingOwnershipAssignments = [];
 	const usageFunctionBody = usageFunction.body;
@@ -15113,6 +15209,126 @@ const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
 	const safeOwnershipAssignments = matchingOwnershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, [releaseAnchor], usageFunction, context));
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
 };
+const findDirectExhaustiveForEachCleanupFunction = (releaseNode, requiredCollectionKeys, context) => {
+	let currentNode = findTransparentExpressionRoot(releaseNode);
+	const visitedFunctions = /* @__PURE__ */ new Set();
+	const replayedCollectionKeys = /* @__PURE__ */ new Set();
+	while (true) {
+		const ownerFunction = findEnclosingFunction$1(currentNode);
+		if (!ownerFunction || !isFunctionLike$1(ownerFunction) || visitedFunctions.has(ownerFunction)) return null;
+		visitedFunctions.add(ownerFunction);
+		const isDirectConciseBody = ownerFunction.body === currentNode;
+		const statementNode = currentNode.parent;
+		const isDirectBlockStatement = isNodeOfType(ownerFunction.body, "BlockStatement") && isNodeOfType(statementNode, "ExpressionStatement") && statementNode.parent === ownerFunction.body;
+		if (!isDirectConciseBody && !isDirectBlockStatement || !doMatchingNodesCoverEveryPathFromFunctionEntry(ownerFunction, [isDirectBlockStatement ? statementNode : currentNode], context)) return null;
+		const forEachCall = findEnclosingForEachCall(ownerFunction);
+		if (!forEachCall) return replayedCollectionKeys.size === requiredCollectionKeys.size && isReturnedEffectCleanupFunction(ownerFunction, context) ? ownerFunction : null;
+		const forEachCallee = stripParenExpression(forEachCall.callee);
+		if (!isNodeOfType(forEachCallee, "MemberExpression")) return null;
+		const collectionKey = resolveExpressionKey(forEachCallee.object, context);
+		if (!collectionKey || !requiredCollectionKeys.has(collectionKey)) return null;
+		replayedCollectionKeys.add(collectionKey);
+		currentNode = findTransparentExpressionRoot(forEachCall);
+	}
+};
+const collectReplayOwnerFunctions = (usageNode) => {
+	const ownerFunctions = /* @__PURE__ */ new Set();
+	let currentNode = usageNode;
+	while (true) {
+		const ownerFunction = findEnclosingFunction$1(currentNode);
+		if (!ownerFunction || !isFunctionLike$1(ownerFunction) || ownerFunctions.has(ownerFunction)) break;
+		ownerFunctions.add(ownerFunction);
+		const forEachCall = findEnclosingForEachCall(ownerFunction);
+		if (!forEachCall) break;
+		currentNode = forEachCall;
+	}
+	return ownerFunctions;
+};
+const hasCollectionMutationBeforeRelease = (usageNode, releaseNode, collectionKeys, context) => {
+	const usageStart = getRangeStart(usageNode);
+	const releaseStart = getRangeStart(releaseNode);
+	if (usageStart === null || releaseStart === null) return true;
+	const setupOwnerFunctions = collectReplayOwnerFunctions(usageNode);
+	const cleanupOwnerFunctions = collectReplayOwnerFunctions(releaseNode);
+	let programNode = usageNode;
+	while (programNode.parent) programNode = programNode.parent;
+	let didFindMutation = false;
+	walkAst(programNode, (child) => {
+		if (didFindMutation) return false;
+		const childStart = getRangeStart(child);
+		if (childStart === null) return;
+		const ownerFunction = context.cfg.enclosingFunction(child);
+		if (!ownerFunction) return;
+		const isAfterRegistration = setupOwnerFunctions.has(ownerFunction) && childStart > usageStart;
+		const isBeforeRelease = cleanupOwnerFunctions.has(ownerFunction) && childStart < releaseStart;
+		if (!isAfterRegistration && !isBeforeRelease) return;
+		if (isNodeOfType(child, "AssignmentExpression")) {
+			const assignmentKey = resolveExpressionKey(child.left, context);
+			const assignmentTarget = stripParenExpression(child.left);
+			if (assignmentKey && [...collectionKeys].some((collectionKey) => assignmentKey === collectionKey || assignmentKey === `${collectionKey}.length`) || isNodeOfType(assignmentTarget, "MemberExpression") && assignmentTarget.computed && collectionKeys.has(resolveExpressionKey(assignmentTarget.object, context) ?? "")) {
+				didFindMutation = true;
+				return false;
+			}
+			return;
+		}
+		if (isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
+			const deletedMember = stripParenExpression(child.argument);
+			if (!isNodeOfType(deletedMember, "MemberExpression")) return;
+			if (collectionKeys.has(resolveExpressionKey(deletedMember.object, context) ?? "")) {
+				didFindMutation = true;
+				return false;
+			}
+			return;
+		}
+		if (isNodeOfType(child, "UpdateExpression")) {
+			const updatedKey = resolveExpressionKey(child.argument, context);
+			if (updatedKey && [...collectionKeys].some((collectionKey) => updatedKey === `${collectionKey}.length`)) {
+				didFindMutation = true;
+				return false;
+			}
+			return;
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = stripParenExpression(child.callee);
+		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || !REPLAY_ENTRY_DROPPING_ARRAY_METHOD_NAMES.has(callee.property.name) && !REPLAY_ENTRY_DROPPING_COLLECTION_METHOD_NAMES.has(callee.property.name) || !collectionKeys.has(resolveExpressionKey(callee.object, context) ?? "")) return;
+		didFindMutation = true;
+		return false;
+	});
+	return didFindMutation;
+};
+const usesUnaryListenerSignature = (registrationCall, releaseCall) => getCalleeName$1(registrationCall) === "addListener" && registrationCall.arguments?.length === 1 && releaseCall.arguments?.length === 1;
+const hasSafeForEachProjectionCleanup = (registrationCall, releaseCall, context) => {
+	const registrationCallee = stripParenExpression(registrationCall.callee);
+	const releaseCallee = stripParenExpression(releaseCall.callee);
+	if (!isNodeOfType(registrationCallee, "MemberExpression") || !isNodeOfType(releaseCallee, "MemberExpression")) return true;
+	const registrationVerbName = getCalleeName$1(registrationCall);
+	const releaseVerbName = getCalleeName$1(releaseCall);
+	const releaseHandler = releaseCall.arguments?.[usesUnaryListenerSignature(registrationCall, releaseCall) ? 0 : 1];
+	const releaseFunction = findEnclosingFunction$1(releaseCall);
+	const registrationEventKey = resolveResourceIdentityKey(registrationCall.arguments?.[0], context);
+	const releaseEventKey = resolveResourceIdentityKey(releaseCall.arguments?.[0], context);
+	const doesHandlerlessOffReleaseEveryRegistration = releaseVerbName === "off" && !releaseHandler && (releaseCall.arguments?.length === 0 || registrationEventKey !== null && registrationEventKey === releaseEventKey);
+	if (Boolean(releaseFunction && isFunctionLike$1(releaseFunction) && isReturnedEffectCleanupFunction(releaseFunction, context) && doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseCall], context)) && (releaseVerbName !== null && UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName) || doesHandlerlessOffReleaseEveryRegistration)) return true;
+	const projections = [
+		registrationCallee.object,
+		registrationCall.arguments?.[0],
+		registrationCall.arguments?.[1],
+		releaseCallee.object,
+		releaseCall.arguments?.[0],
+		releaseCall.arguments?.[1]
+	].flatMap((expression) => {
+		const projection = resolveForEachProjection(expression, context);
+		return projection ? [projection] : [];
+	});
+	if (registrationVerbName === "addEventListener" && releaseVerbName === "removeEventListener") for (const optionsNode of [registrationCall.arguments?.[2], releaseCall.arguments?.[2]]) {
+		const captureProjection = resolveEventListenerCaptureProjection(optionsNode, context);
+		if (captureProjection) projections.push(captureProjection);
+	}
+	if (projections.length === 0) return true;
+	const collectionKeys = new Set(projections.map((projection) => projection.collectionKey));
+	if (!findDirectExhaustiveForEachCleanupFunction(releaseCall, collectionKeys, context)) return false;
+	return !hasCollectionMutationBeforeRelease(registrationCall, releaseCall, collectionKeys, context);
+};
 const doesReleaseCallMatchUsage = (node, usage, context) => {
 	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
 	if (!isNodeOfType(callNode, "CallExpression")) return false;
@@ -15128,8 +15344,8 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	const releaseVerbName = getReleaseVerbName(callNode);
 	if (!releaseVerbName) return false;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
-	const releaseReceiverKey = resolveExpressionKey(callee.object, context);
-	const releaseEventKey = resolveExpressionKey(callNode.arguments?.[0], context);
+	const releaseReceiverKey = resolveResourceIdentityKey(callee.object, context);
+	const releaseEventKey = resolveResourceIdentityKey(callNode.arguments?.[0], context);
 	const pairedReleaseVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
 	const pushedResourceCollectionKey = findPushedResourceCollectionKey(usage, context);
 	const releaseReceiverForOfStatement = findForOfStatementForIteratorExpression(callee.object, context);
@@ -15140,6 +15356,11 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub" || releaseVerbName === "close" || releaseVerbName === "unwatch" || releaseVerbName === "unlisten" || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(releaseVerbName))) return true;
 	if (releaseVerbName === "abort" && releaseReceiverKey === getListenerAbortControllerKey(usage, context)) return true;
 	if (releaseVerbName === "abort" && isRetainedAbortControllerRefRelease(callee.object, usage, context)) return true;
+	if (usage.registrationVerbName === "addEventListener" && releaseVerbName === "removeEventListener" && isNodeOfType(usage.node, "CallExpression")) {
+		if (!isNodeOfType(stripParenExpression(usage.node.callee), "MemberExpression")) return false;
+		if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], callNode.arguments?.[2], context, true)) return false;
+	}
+	if (isNodeOfType(usage.node, "CallExpression") && !hasSafeForEachProjectionCleanup(usage.node, callNode, context)) return false;
 	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) return false;
 	if (usage.registrationVerbName === "subscribe" && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub") && usage.handleKey !== null && resolveExpressionKey(callNode.arguments?.[0], context) === usage.handleKey) return true;
 	const pairedVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
@@ -15149,6 +15370,9 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (isAssignmentFormForOfIteratorReference(usageEventArgument, context) || isAssignmentFormForOfIteratorReference(releaseEventArgument, context)) return false;
 	if (usage.eventKey !== null && releaseEventKey !== null && usage.eventKey !== releaseEventKey) {
 		if (!isNodeOfType(usage.node, "CallExpression")) return false;
+		const registrationEventProjectionKey = resolveForEachProjectionKey(usage.node.arguments?.[0], context);
+		const releaseEventProjectionKey = resolveForEachProjectionKey(callNode.arguments?.[0], context);
+		if ((registrationEventProjectionKey !== null || releaseEventProjectionKey !== null) && registrationEventProjectionKey !== releaseEventProjectionKey) return false;
 		const usageForOfStatement = findForOfStatementForIteratorExpression(usageEventArgument, context);
 		const releaseForOfStatement = findForOfStatementForIteratorExpression(releaseEventArgument, context);
 		if (usageForOfStatement === null !== (releaseForOfStatement === null)) return false;
@@ -15162,9 +15386,7 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 			const registrationCallee = stripParenExpression(usage.node.callee);
 			if (!isNodeOfType(registrationCallee, "MemberExpression")) return false;
 			if (!isStableLoopReceiver(registrationCallee.object, context) || !isStableLoopReceiver(callee.object, context) || registrationHandlerSymbolId === null || registrationHandlerSymbolId !== releaseHandlerSymbolId) return false;
-			const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
-			const releaseCapture = resolveEventListenerCapture(callNode.arguments?.[2], { allowIndeterminateEntries: true });
-			if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
+			if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], callNode.arguments?.[2], context)) return false;
 			if (!isDirectExhaustiveForOfRelease(callNode, releaseForOfStatement)) return false;
 		}
 	}
@@ -15173,27 +15395,28 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 		return isNodeOfType(handlerArgument, "Literal") && handlerArgument.value === null;
 	}
 	if (releaseVerbName === "removeEventListener" || releaseVerbName === "removeListener" || releaseVerbName === "off") {
-		const usesUnaryListenerSignature = usage.registrationVerbName === "addListener" && isNodeOfType(usage.node, "CallExpression") && usage.node.arguments?.length === 1 && callNode.arguments?.length === 1;
-		const releaseHandler = usesUnaryListenerSignature ? callNode.arguments?.[0] : callNode.arguments?.[1];
+		const usesUnaryListenerSignatureForCalls = isNodeOfType(usage.node, "CallExpression") && usesUnaryListenerSignature(usage.node, callNode);
+		const releaseHandler = usesUnaryListenerSignatureForCalls ? callNode.arguments?.[0] : callNode.arguments?.[1];
 		if (!releaseHandler) return releaseVerbName === "off";
-		const expectedHandlerKey = usesUnaryListenerSignature ? usage.eventKey : usage.handlerKey;
-		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignature ? 0 : 1] : null;
-		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
+		const expectedHandlerKey = usesUnaryListenerSignatureForCalls ? usage.eventKey : usage.handlerKey;
+		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignatureForCalls ? 0 : 1] : null;
+		return expectedHandlerKey !== null && resolveResourceIdentityKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
 	}
 	if (releaseVerbName === "unobserve" && usage.eventKey !== null) return releaseEventKey === usage.eventKey;
 	return true;
 };
 const matchesPairedReleaseVerb = (releaseVerbName, pairedVerbNames) => pairedVerbNames.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName);
 const isReturnedEffectCleanupFunction = (functionNode, context) => {
-	let currentNode = functionNode;
-	let parentNode = currentNode.parent;
-	while (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	const effectCallback = isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode ? findEnclosingFunction$1(parentNode) : isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode ? parentNode : null;
-	const effectCall = effectCallback?.parent;
-	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isReactHookCall(effectCall, CLEANUP_EFFECT_HOOK_NAMES, context.scopes));
+	const effectCallback = findEnclosingFunction$1(functionNode);
+	if (!effectCallback || !isFunctionLike$1(effectCallback)) return false;
+	const effectCall = effectCallback.parent;
+	if (!isNodeOfType(effectCall, "CallExpression") || !isReactHookCall(effectCall, CLEANUP_EFFECT_HOOK_NAMES, context.scopes)) return false;
+	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return resolveStableValue(effectCallback.body, context) === functionNode;
+	let isReturned = false;
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (isNodeOfType(child, "ReturnStatement") && child.argument && resolveStableValue(child.argument, context) === functionNode) isReturned = true;
+	});
+	return isReturned;
 };
 const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode, context)) return true;
@@ -15336,11 +15559,9 @@ const isRetainedDisposerRefRelease = (releaseNode, usage, context) => {
 };
 const isSelfReleasingListenerRelease = (releaseNode, releaseFunction, usage, context) => {
 	if (usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.receiverKey === null || usage.eventKey === null || !isNodeOfType(usage.node, "CallExpression") || !isFunctionLike$1(releaseFunction) || releaseFunction.async || releaseFunction.generator || !isNodeOfType(releaseFunction.body, "BlockStatement") || !doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
-	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
 	const releaseCall = isNodeOfType(releaseNode, "ChainExpression") ? releaseNode.expression : releaseNode;
 	if (!isNodeOfType(releaseCall, "CallExpression")) return false;
-	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
-	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
+	if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], releaseCall.arguments?.[2], context)) return false;
 	const ownerFunction = findEnclosingFunction$1(releaseFunction);
 	if (!ownerFunction || !isFunctionLike$1(ownerFunction)) return false;
 	const triggerRegistrations = [];
@@ -18810,11 +19031,12 @@ const forbidDomProps = defineRule({
 * carrying their own near-identical inlined implementation.
 */
 const flattenCalleeName = (callee) => {
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
-		const objectName = flattenCalleeName(callee.object);
+	const unwrappedCallee = stripParenExpression(callee);
+	if (isNodeOfType(unwrappedCallee, "Identifier")) return unwrappedCallee.name;
+	if (isNodeOfType(unwrappedCallee, "MemberExpression") && !unwrappedCallee.computed) {
+		const objectName = flattenCalleeName(unwrappedCallee.object);
 		if (!objectName) return null;
-		if (isNodeOfType(callee.property, "Identifier")) return `${objectName}.${callee.property.name}`;
+		if (isNodeOfType(unwrappedCallee.property, "Identifier")) return `${objectName}.${unwrappedCallee.property.name}`;
 	}
 	return null;
 };
@@ -24587,9 +24809,14 @@ const collectContextBindings = (programRoot) => {
 	}
 	return bindings;
 };
-const isCreateContextBindingJsxName = (node, contextBindings) => {
+const isCreateContextBindingJsxName = (node, contextBindings, scopes) => {
 	if (!isNodeOfType(node, "JSXIdentifier")) return false;
-	if (!contextBindings.has(node.name)) return false;
+	if (!contextBindings.has(node.name)) {
+		const symbol = scopes.symbolFor(node);
+		if (!symbol || symbol.kind !== "import") return false;
+		const importedName = getImportedName(symbol.declarationNode);
+		return getImportSourceForName(node, node.name)?.toLowerCase().includes("context") === true && (node.name.endsWith("Context") || importedName?.endsWith("Context") === true);
+	}
 	const binding = findVariableInitializer(node, node.name);
 	if (!binding) return false;
 	return binding.scopeOwner.type === "Program";
@@ -24613,7 +24840,7 @@ const jsxNoConstructedContextValues = defineRule({
 				if (isTestlikeFile) return;
 				const nameNode = node.name;
 				const isLegacyProvider = isProviderMemberName(nameNode);
-				const isReact19Shorthand = isCreateContextBindingJsxName(nameNode, contextBindings);
+				const isReact19Shorthand = isCreateContextBindingJsxName(nameNode, contextBindings, context.scopes);
 				if (!isLegacyProvider && !isReact19Shorthand) return;
 				if (!isInsideFunctionScope(node)) return;
 				for (const attribute of node.attributes) {
@@ -24884,6 +25111,29 @@ const buildSameFileJsxSlotPropRegistry = (program, memoRegistry, scopes) => {
 	return registry;
 };
 //#endregion
+//#region src/plugin/utils/has-custom-memo-comparator.ts
+const MEMO_CALLEE_NAMES$1 = new Set(["memo", "React.memo"]);
+const isIdentitySensitiveMemoComparator = (comparatorNode, scopes) => {
+	if (isNodeOfType(comparatorNode, "Identifier")) {
+		if (comparatorNode.name === "undefined") return scopes.isGlobalReference(comparatorNode);
+		return getImportedNameFromModule(comparatorNode, comparatorNode.name, "react-redux") === "shallowEqual";
+	}
+	if (!isNodeOfType(comparatorNode, "MemberExpression") || comparatorNode.computed || !isNodeOfType(comparatorNode.object, "Identifier") || !isNodeOfType(comparatorNode.property, "Identifier") || comparatorNode.property.name !== "shallowEqual") return false;
+	return isNamespaceImportFromModule$1(comparatorNode, comparatorNode.object.name, "react-redux");
+};
+const hasCustomMemoComparator = (openingName, scopes) => {
+	if (!openingName || !isNodeOfType(openingName, "JSXIdentifier")) return false;
+	const binding = findVariableInitializer(openingName, openingName.name);
+	if (!binding || !binding.initializer) return false;
+	const initializer = binding.initializer;
+	if (!isNodeOfType(initializer, "CallExpression")) return false;
+	const calleeName = flattenCalleeName(initializer.callee);
+	if (calleeName === null || !MEMO_CALLEE_NAMES$1.has(calleeName)) return false;
+	const comparatorNode = (initializer.arguments ?? [])[1];
+	if (!comparatorNode) return false;
+	return !isIdentitySensitiveMemoComparator(comparatorNode, scopes);
+};
+//#endregion
 //#region src/plugin/utils/is-on-intrinsic-html-element.ts
 const isJsxAttributeOnIntrinsicHtmlElement = (attribute) => {
 	const openingElement = attribute.parent;
@@ -25169,6 +25419,7 @@ const jsxNoJsxAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
+				if (hasCustomMemoComparator(openingName, context.scopes)) return;
 				const openingSymbol = openingName && isNodeOfType(openingName, "JSXIdentifier") ? context.scopes.symbolFor(openingName) : null;
 				if (openingSymbol && isNodeOfType(node.name, "JSXIdentifier") && jsxSlotPropRegistry?.get(openingSymbol.id)?.has(node.name.name)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier") && isSlotPropName(node.name.name)) return;
@@ -25188,19 +25439,6 @@ const jsxNoJsxAsProp = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/has-custom-memo-comparator.ts
-const MEMO_CALLEE_NAMES = new Set(["memo", "React.memo"]);
-const hasCustomMemoComparator = (openingName) => {
-	if (!openingName || !isNodeOfType(openingName, "JSXIdentifier")) return false;
-	const binding = findVariableInitializer(openingName, openingName.name);
-	if (!binding || !binding.initializer) return false;
-	const initializer = binding.initializer;
-	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const calleeName = flattenCalleeName(initializer.callee);
-	if (calleeName === null || !MEMO_CALLEE_NAMES.has(calleeName)) return false;
-	return (initializer.arguments ?? []).length >= 2;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-array-as-prop-tables.ts
 const DATA_ARRAY_PROP_NAMES = new Set([
 	"data",
@@ -25559,7 +25797,7 @@ const jsxNoNewArrayAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
-				if (hasCustomMemoComparator(openingName)) return;
+				if (hasCustomMemoComparator(openingName, context.scopes)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier") && isDataArrayPropName(node.name.name)) return;
 				if (!isInsideFunctionScope(node)) return;
 				const value = node.value;
@@ -26023,6 +26261,7 @@ const jsxNoNewFunctionAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
+				if (hasCustomMemoComparator(openingName, context.scopes)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier") && isOneShotHandlerName(node.name.name)) return;
 				if (!isInsideFunctionScope(node)) return;
 				const value = node.value;
@@ -26330,7 +26569,7 @@ const jsxNoNewObjectAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
-				if (hasCustomMemoComparator(openingName)) return;
+				if (hasCustomMemoComparator(openingName, context.scopes)) return;
 				if (!isInsideFunctionScope(node)) return;
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
 				if (ALWAYS_FRESH_OBJECT_PROPS.has(node.name.name)) return;
@@ -29362,6 +29601,14 @@ const nextjsNoImgElement = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-no-native-script.ts
+const hasEnabledBooleanAttribute = (attributes, attributeName) => {
+	const attribute = findJsxAttribute(attributes, attributeName);
+	if (!attribute) return false;
+	if (attribute.value === null) return true;
+	if (isNodeOfType(attribute.value, "Literal")) return true;
+	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return false;
+	return isNodeOfType(attribute.value.expression, "Literal") && Boolean(attribute.value.expression.value);
+};
 const nextjsNoNativeScript = defineRule({
 	id: "nextjs-no-native-script",
 	title: "Plain script can block Next.js rendering",
@@ -29374,6 +29621,9 @@ const nextjsNoNativeScript = defineRule({
 		const typeAttribute = findJsxAttribute(node.attributes ?? [], "type");
 		const typeValue = isNodeOfType(typeAttribute?.value, "Literal") ? typeAttribute.value.value : null;
 		if (typeof typeValue === "string" && !EXECUTABLE_SCRIPT_TYPES.has(typeValue)) return;
+		if (hasEnabledBooleanAttribute(node.attributes ?? [], "async")) return;
+		if (hasEnabledBooleanAttribute(node.attributes ?? [], "defer")) return;
+		if (typeValue === "module") return;
 		const hasSrcAttribute = Boolean(findJsxAttribute(node.attributes ?? [], "src"));
 		if (Boolean(findJsxAttribute(node.attributes ?? [], "dangerouslySetInnerHTML")) && !hasSrcAttribute) return;
 		context.report({
@@ -38911,15 +39161,16 @@ const callsOpaqueExternalSetter = (analysisFunctions, setterToStateName) => {
 	});
 	return didFindOpaqueSetterCall;
 };
-const isReactRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && (isReactApiCall(expression, "useRef", scopes, {
+const isReactUseRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && isReactApiCall(expression, "useRef", scopes, {
 	allowGlobalReactNamespace: true,
 	allowUnboundBareCalls: true,
 	resolveNamedAliases: true
-}) || isReactApiCall(expression, "createRef", scopes, {
+});
+const isReactRefCall = (expression, scopes) => isReactUseRefCall(expression, scopes) || isNodeOfType(expression, "CallExpression") && isReactApiCall(expression, "createRef", scopes, {
 	allowGlobalReactNamespace: true,
 	allowUnboundBareCalls: true,
 	resolveNamedAliases: true
-}));
+});
 const getDirectReactRefSymbol = (rawExpression, scopes) => {
 	const expression = stripParenExpression(rawExpression);
 	if (!isNodeOfType(expression, "Identifier")) return null;
@@ -38957,7 +39208,18 @@ const isIntrinsicRefCallbackParameter = (expression, scopes) => {
 	const rawFirstParameter = callback.params?.[0];
 	const firstParameter = isNodeOfType(rawFirstParameter, "AssignmentPattern") ? rawFirstParameter.left : rawFirstParameter;
 	const symbol = scopes.symbolFor(identifier);
-	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter);
+	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter && symbol.references.every((reference) => {
+		if (reference.flag !== "read") return false;
+		let referenceRoot = reference.identifier;
+		while (referenceRoot.parent) {
+			const parent = referenceRoot.parent;
+			if (isNodeOfType(parent, "AssignmentExpression")) return parent.left !== referenceRoot;
+			if (isNodeOfType(parent, "UpdateExpression")) return parent.argument !== referenceRoot;
+			if (isNodeOfType(parent, "ForInStatement") || isNodeOfType(parent, "ForOfStatement")) return parent.left !== referenceRoot;
+			referenceRoot = parent;
+		}
+		return true;
+	}));
 };
 const getDirectReactRefCall = (symbol, scopes) => {
 	const initializer = getDirectUnreassignedInitializer(symbol);
@@ -38965,15 +39227,38 @@ const getDirectReactRefCall = (symbol, scopes) => {
 	const expression = stripParenExpression(initializer);
 	return isNodeOfType(expression, "CallExpression") && isReactRefCall(expression, scopes) ? expression : null;
 };
+const isEmptyGlobalMapConstruction = (rawExpression, scopes) => {
+	const expression = stripParenExpression(rawExpression);
+	return isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Map" && scopes.isGlobalReference(expression.callee) && expression.arguments.length === 0;
+};
+const hasEmptyRefSentinelInitializer = (refCall, scopes) => {
+	if (!isReactUseRefCall(refCall, scopes) || refCall.arguments.length > 1) return false;
+	const [initialValue] = refCall.arguments;
+	return !initialValue || isNodeOfType(initialValue, "Literal") && initialValue.value === null || isNodeOfType(initialValue, "Identifier") && initialValue.name === "undefined" && scopes.isGlobalReference(initialValue);
+};
+const isDirectLazyEmptyMapInitialization = (currentExpression, symbol, scopes) => {
+	const assignment = currentExpression.parent;
+	if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.left !== currentExpression || assignment.operator !== "??=" || !isEmptyGlobalMapConstruction(assignment.right, scopes)) return false;
+	const refOwner = findEnclosingFunction$1(symbol.bindingIdentifier);
+	return refOwner !== null && findEnclosingFunction$1(assignment) === refOwner;
+};
 const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
-	const initialValue = getDirectReactRefCall(symbol, scopes)?.arguments?.[0];
-	if (!initialValue || !isNodeOfType(initialValue, "NewExpression") || !isNodeOfType(initialValue.callee, "Identifier") || initialValue.callee.name !== "Map" || !scopes.isGlobalReference(initialValue.callee) || initialValue.arguments.length !== 0) return false;
+	const refCall = getDirectReactRefCall(symbol, scopes);
+	const initialValue = refCall?.arguments[0];
+	const hasDirectEmptyMapInitializer = Boolean(initialValue && isEmptyGlobalMapConstruction(initialValue, scopes));
+	const hasLazyEmptyMapInitializer = Boolean(refCall && hasEmptyRefSentinelInitializer(refCall, scopes));
+	if (!hasDirectEmptyMapInitializer && !hasLazyEmptyMapInitializer) return false;
 	let intrinsicValueWriteCount = 0;
+	let lazyEmptyMapInitializationCount = 0;
 	for (const reference of symbol.references) {
 		const identifier = findTransparentExpressionRoot(reference.identifier);
 		const currentMember = identifier.parent;
 		if (!isNodeOfType(currentMember, "MemberExpression") || currentMember.object !== identifier || getStaticPropertyName(currentMember) !== "current") return false;
 		const currentExpression = findTransparentExpressionRoot(currentMember);
+		if (hasLazyEmptyMapInitializer && isDirectLazyEmptyMapInitialization(currentExpression, symbol, scopes)) {
+			lazyEmptyMapInitializationCount += 1;
+			continue;
+		}
 		const methodMember = currentExpression.parent;
 		if (!isNodeOfType(methodMember, "MemberExpression") || methodMember.object !== currentExpression) return false;
 		const methodName = getStaticPropertyName(methodMember);
@@ -38986,7 +39271,7 @@ const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
 		if (!storedValue || isNodeOfType(storedValue, "SpreadElement") || !isIntrinsicRefCallbackParameter(storedValue, scopes)) return false;
 		intrinsicValueWriteCount += 1;
 	}
-	return intrinsicValueWriteCount > 0;
+	return intrinsicValueWriteCount > 0 && (hasDirectEmptyMapInitializer || lazyEmptyMapInitializationCount === 1);
 };
 const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollectionValue = false, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(rawExpression);
@@ -39490,7 +39775,7 @@ const noEffectEventInDeps = defineRule({
 	title: "Effect Event listed in effect deps",
 	tags: ["test-noise"],
 	severity: "error",
-	recommendation: "Call the useEffectEvent function inside the effect body and don't list it in the deps. It changes on every render on purpose.",
+	recommendation: "Call the useEffectEvent function inside the effect body and don't list it in the deps. It's non-reactive on purpose, so it must be omitted.",
 	create: (context) => {
 		const componentBindings = createComponentBindingStackTracker({ onVariableDeclarator: (declaratorNode) => {
 			if (!isNodeOfType(declaratorNode, "VariableDeclarator")) return;
@@ -39512,7 +39797,7 @@ const noEffectEventInDeps = defineRule({
 					if (!isNodeOfType(element, "Identifier")) continue;
 					if (componentBindings.isBoundName(element.name)) context.report({
 						node: element,
-						message: `Listing "${element.name}" in the deps re-runs your effect every render & defeats useEffectEvent.`
+						message: `Listing "${element.name}" in the deps defeats useEffectEvent — Effect Events are non-reactive and must be omitted from deps.`
 					});
 				}
 			}
@@ -39555,6 +39840,7 @@ const noEffectWithFreshDeps = defineRule({
 	title: "Effect dependency recreated every render",
 	severity: "error",
 	category: "State & Effects",
+	disabledWhen: ["react-compiler"],
 	recommendation: "Move the value inside the hook body and depend on its simple inputs instead, or wrap it in useMemo / useCallback so it stays the same between renders.",
 	create: (context) => ({ CallExpression(node) {
 		for (const finding of findForwardedFreshHookDependencies(node, context, EFFECT_HOOK_NAMES$1)) context.report({
@@ -42495,14 +42781,13 @@ const noInlineExhaustiveStyle = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/performance/no-inline-prop-on-memo-component.ts
-const isMemoCall = (node) => {
+const MEMO_CALLEE_NAMES = new Set(["memo", "React.memo"]);
+const isMemoCall = (node) => isNodeOfType(node, "CallExpression") && MEMO_CALLEE_NAMES.has(flattenCalleeName(node.callee) ?? "");
+const hasCustomComparator = (node, scopes) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	if (isNodeOfType(node.callee, "Identifier") && node.callee.name === "memo") return true;
-	if (isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && node.callee.object.name === "React" && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "memo") return true;
-	return false;
+	const comparator = node.arguments?.[1];
+	return comparator ? !isIdentitySensitiveMemoComparator(comparator, scopes) : false;
 };
-const isDefaultEquivalentComparator = (comparator) => isNodeOfType(comparator, "Identifier") && (comparator.name === "undefined" || comparator.name === "shallowEqual");
-const hasCustomComparator = (node) => isNodeOfType(node, "CallExpression") && (node.arguments?.length ?? 0) >= 2 && !isDefaultEquivalentComparator(node.arguments?.[1]);
 const isInlineReference = (node, scopes) => {
 	const referenceNode = unwrapObjectIntegrityExpression(node, scopes);
 	if (isNodeOfType(referenceNode, "ArrowFunctionExpression") || isNodeOfType(referenceNode, "FunctionExpression") || isNodeOfType(referenceNode, "CallExpression") && isNodeOfType(referenceNode.callee, "MemberExpression") && isNodeOfType(referenceNode.callee.property, "Identifier") && referenceNode.callee.property.name === "bind") return "functions";
@@ -42516,16 +42801,17 @@ const noInlinePropOnMemoComponent = defineRule({
 	title: "Inline prop defeats memo()",
 	tags: ["test-noise"],
 	severity: "warn",
+	disabledWhen: ["react-compiler"],
 	recommendation: "Move the inline `() => ...` / `[]` / `{}` to a stable value with useMemo, useCallback, or module scope, so the memoized child stops redrawing on every parent render",
 	create: (context) => {
 		const memoizedComponentNames = /* @__PURE__ */ new Set();
 		return {
 			VariableDeclarator(node) {
 				if (!isNodeOfType(node.id, "Identifier") || !node.init) return;
-				if (isMemoCall(node.init) && !hasCustomComparator(node.init)) memoizedComponentNames.add(node.id.name);
+				if (isMemoCall(node.init) && !hasCustomComparator(node.init, context.scopes)) memoizedComponentNames.add(node.id.name);
 			},
 			ExportDefaultDeclaration(node) {
-				if (node.declaration && isNodeOfType(node.declaration, "CallExpression") && isMemoCall(node.declaration) && !hasCustomComparator(node.declaration)) {
+				if (node.declaration && isNodeOfType(node.declaration, "CallExpression") && isMemoCall(node.declaration) && !hasCustomComparator(node.declaration, context.scopes)) {
 					const innerArgument = node.declaration.arguments?.[0];
 					if (isNodeOfType(innerArgument, "Identifier")) memoizedComponentNames.add(innerArgument.name);
 				}
@@ -55380,6 +55666,7 @@ const preferModuleScopePureFunction = defineRule({
 	tags: ["test-noise"],
 	severity: "warn",
 	category: "Architecture",
+	disabledWhen: ["react-compiler"],
 	recommendation: "Move the function above the component, at the top of the file. It doesn't use local state, so rebuilding it each update is wasted work.",
 	create: (context) => {
 		const report = (functionNode, name, componentName) => {
@@ -56021,10 +56308,10 @@ const classifyCallableReadsInsideEffect = (callableIdentifier, effectCallback, c
 const preferUseEffectEvent = defineRule({
 	id: "prefer-use-effect-event",
 	title: "Effect re-subscribes on a changing callback",
-	requires: ["react:19"],
+	requires: ["react:19.2"],
 	tags: ["test-noise"],
 	severity: "warn",
-	recommendation: "Wrap the callback with `useEffectEvent(callback)` (React 19+) and call it inside the sub-handler. An Effect Event always sees the latest props and state but isn't a dependency, so the effect won't re-subscribe every time the parent redraws. See https://react.dev/reference/react/useEffectEvent",
+	recommendation: "Wrap the callback with `useEffectEvent(callback)` (React 19.2+) and call it inside the sub-handler. An Effect Event always sees the latest props and state but isn't a dependency, so the effect won't re-subscribe every time the parent redraws. See https://react.dev/reference/react/useEffectEvent",
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
@@ -57629,7 +57916,6 @@ const reduxUseselectorInlineDerivation = defineRule({
 	title: "useSelector derives data inline",
 	severity: "warn",
 	category: "Performance",
-	disabledWhen: ["react-compiler"],
 	recommendation: "Select the raw slice and memoize derivation so Redux actions do not rebuild a collection and redraw this component.",
 	create: (context) => {
 		let aliases = /* @__PURE__ */ new Set();
@@ -57689,7 +57975,6 @@ const reduxUseselectorReturnsNewCollection = defineRule({
 	title: "useSelector returns a new collection",
 	severity: "warn",
 	category: "Performance",
-	disabledWhen: ["react-compiler"],
 	recommendation: "Return a stable selected value, split selectors, or pass `shallowEqual` so every Redux action does not redraw this component.",
 	create: (context) => {
 		let aliases = /* @__PURE__ */ new Set();
@@ -57815,6 +58100,7 @@ const renderingHoistJsx = defineRule({
 	title: "Constant JSX rebuilt each render",
 	tags: ["test-noise"],
 	severity: "warn",
+	disabledWhen: ["react-compiler"],
 	recommendation: "Move the static JSX out to the top of the file: `const ICON = <svg>...</svg>`, so it isn't rebuilt on every render",
 	create: (context) => {
 		let componentDepth = 0;
@@ -58261,8 +58547,9 @@ const renderingHydrationNoFlicker = defineRule({
 	id: "rendering-hydration-no-flicker",
 	title: "useEffect setState flashes on mount",
 	tags: ["test-noise"],
+	requires: ["ssr"],
 	severity: "warn",
-	recommendation: "Use `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)` or add `suppressHydrationWarning` to the element",
+	recommendation: "Read the value with `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)` inside a reusable hook, or add `suppressHydrationWarning` to the element",
 	create: (context) => ({ CallExpression(node) {
 		if (!isHookCall$2(node, USE_EFFECT_ONLY) || (node.arguments?.length ?? 0) < 2) return;
 		const depsNode = node.arguments[1];
@@ -58715,7 +59002,7 @@ const renderingUsetransitionLoading = defineRule({
 	title: "Loading useState forces extra render",
 	tags: ["test-noise"],
 	severity: "warn",
-	recommendation: "Replace with `const [isPending, startTransition] = useTransition()`, which skips the extra render for the loading flag",
+	recommendation: "Replace with `const [isPending, startTransition] = useTransition()`, which marks the update as non-urgent and interruptible so the input stays responsive",
 	create: (context) => ({ VariableDeclarator(node) {
 		if (!isNodeOfType(node.id, "ArrayPattern") || !node.id.elements?.length) return;
 		if (!node.init || !isHookCall$2(node.init, "useState")) return;
@@ -58747,7 +59034,7 @@ const renderingUsetransitionLoading = defineRule({
 		}
 		context.report({
 			node: node.init,
-			message: `This adds an extra render because useState for "${stateVariableName}" re-renders just for the loading flag, so if it's a state change & not a data fetch, use useTransition instead`
+			message: `This makes the "${stateVariableName}" update urgent and blocking because it's a plain useState flag, so if it's a state change & not a data fetch, use useTransition to keep the UI responsive while it runs`
 		});
 	} })
 });
@@ -59062,6 +59349,7 @@ const rerenderDependencies = defineRule({
 	title: "Unstable value recreated every render",
 	tags: ["test-noise"],
 	severity: "error",
+	disabledWhen: ["react-compiler"],
 	recommendation: "Move it into a useMemo, useRef, or a constant outside the component so it stays the same between renders.",
 	create: (context) => ({ CallExpression(node) {
 		if (!isReactHookCall(node, HOOKS_WITH_DEPS, context.scopes) || node.arguments.length < 2) return;
@@ -59474,7 +59762,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 	title: "useMemo before an early return",
 	tags: ["test-noise"],
 	severity: "warn",
-	recommendation: "Move the JSX into a child component wrapped in memo, so the parent's early return skips it",
+	recommendation: "Move the JSX into a child component rendered after the early return, so renders that take the early return never build it",
 	create: (context) => {
 		const inspectFunctionBody = (statements) => {
 			let memoNode = null;
@@ -59500,7 +59788,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 					if (callbackGuardTests.some((guardTest) => areConditionsStructurallyEqual(stmt.test, guardTest))) continue;
 					context.report({
 						node: memoNode,
-						message: "This runs even when the component bails out because the useMemo builds JSX before an early return, so move the JSX into a child wrapped in memo to skip it on the early return"
+						message: "This rebuilds the JSX whenever its dependencies change even on renders that take the early return, so move the JSX into a child component rendered after the early return to skip it"
 					});
 					return;
 				}
@@ -60003,6 +60291,7 @@ const rerenderMemoWithDefaultValue = defineRule({
 	title: "Empty default prop breaks memo",
 	tags: ["test-noise"],
 	severity: "warn",
+	disabledWhen: ["react-compiler"],
 	recommendation: "Move it to the top of the file: `const EMPTY_ITEMS: Item[] = []`, then use that as the default value",
 	create: (context) => {
 		let memoRegistry = /* @__PURE__ */ new Map();
@@ -60828,6 +61117,7 @@ const rnListDataMapped = defineRule({
 	title: "List data rebuilt every render",
 	tags: ["test-noise"],
 	requires: ["react-native"],
+	disabledWhen: ["react-compiler"],
 	severity: "warn",
 	recommendation: "This builds a new array each time the parent redraws, so every row redraws too. Wrap it in `useMemo(() => items.map(...), [items])` to keep the same array.",
 	create: (context) => ({ JSXOpeningElement(node) {
@@ -63181,6 +63471,66 @@ const roleHasRequiredAriaProps = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/constants/global-aria-properties.ts
+const GLOBAL_ARIA_PROPERTIES = new Set([
+	"aria-atomic",
+	"aria-braillelabel",
+	"aria-brailleroledescription",
+	"aria-busy",
+	"aria-controls",
+	"aria-current",
+	"aria-describedby",
+	"aria-description",
+	"aria-details",
+	"aria-disabled",
+	"aria-dropeffect",
+	"aria-errormessage",
+	"aria-flowto",
+	"aria-grabbed",
+	"aria-haspopup",
+	"aria-hidden",
+	"aria-invalid",
+	"aria-keyshortcuts",
+	"aria-label",
+	"aria-labelledby",
+	"aria-live",
+	"aria-owns",
+	"aria-relevant",
+	"aria-roledescription"
+]);
+//#endregion
+//#region src/plugin/constants/prohibited-aria-properties-by-role.ts
+const ACCESSIBLE_NAME_PROPERTIES = new Set([
+	"aria-braillelabel",
+	"aria-label",
+	"aria-labelledby"
+]);
+const PROHIBITED_ARIA_PROPERTIES_BY_ROLE = {
+	caption: ACCESSIBLE_NAME_PROPERTIES,
+	code: ACCESSIBLE_NAME_PROPERTIES,
+	definition: ACCESSIBLE_NAME_PROPERTIES,
+	deletion: ACCESSIBLE_NAME_PROPERTIES,
+	emphasis: ACCESSIBLE_NAME_PROPERTIES,
+	generic: new Set([
+		"aria-braillelabel",
+		"aria-brailleroledescription",
+		"aria-label",
+		"aria-labelledby",
+		"aria-roledescription"
+	]),
+	insertion: ACCESSIBLE_NAME_PROPERTIES,
+	mark: ACCESSIBLE_NAME_PROPERTIES,
+	none: ACCESSIBLE_NAME_PROPERTIES,
+	paragraph: ACCESSIBLE_NAME_PROPERTIES,
+	presentation: ACCESSIBLE_NAME_PROPERTIES,
+	strong: ACCESSIBLE_NAME_PROPERTIES,
+	subscript: ACCESSIBLE_NAME_PROPERTIES,
+	superscript: ACCESSIBLE_NAME_PROPERTIES,
+	term: ACCESSIBLE_NAME_PROPERTIES,
+	time: ACCESSIBLE_NAME_PROPERTIES,
+	tooltip: ACCESSIBLE_NAME_PROPERTIES
+};
+//#endregion
 //#region src/plugin/constants/role-supports-aria-props.ts
 const ROLE_SUPPORTS_ARIA_PROPS = {
 	alert: new Set([
@@ -66281,6 +66631,12 @@ const ROLE_SUPPORTS_ARIA_PROPS = {
 	])
 };
 //#endregion
+//#region src/plugin/utils/is-aria-property-supported-by-role.ts
+const isAriaPropertySupportedByRole = (role, property) => {
+	if (PROHIBITED_ARIA_PROPERTIES_BY_ROLE[role]?.has(property)) return false;
+	return ROLE_SUPPORTS_ARIA_PROPS[role]?.has(property) === true || GLOBAL_ARIA_PROPERTIES.has(property);
+};
+//#endregion
 //#region src/plugin/rules/a11y/role-supports-aria-props.ts
 const buildMessageDefault = (roles, propName) => {
 	return `Screen reader users get no help from \`${propName}\` because role ${roles.map((role) => `\`${role}\``).join(" / ")} ignores it, so remove it or change the role.`;
@@ -66317,16 +66673,10 @@ const roleSupportsAriaProps = defineRule({
 		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 		const roleCandidates = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : [getImplicitRole(node, elementType, context.scopes)].filter((role) => role !== null);
 		if (roleCandidates === null || roleCandidates.length === 0) return;
-		const supportedSets = [];
-		for (const role of roleCandidates) {
-			if (!VALID_ARIA_ROLES.has(role)) return;
-			const supported = ROLE_SUPPORTS_ARIA_PROPS[role];
-			if (!supported) return;
-			supportedSets.push(supported);
-		}
+		for (const role of roleCandidates) if (!VALID_ARIA_ROLES.has(role)) return;
 		const isImplicit = !roleAttribute;
 		for (const { attribute, propName } of ariaAttributes) {
-			if (supportedSets.some((supported) => supported.has(propName))) continue;
+			if (roleCandidates.some((role) => isAriaPropertySupportedByRole(role, propName))) continue;
 			context.report({
 				node: attribute,
 				message: isImplicit ? buildMessageImplicit(roleCandidates[0], propName, elementType) : buildMessageDefault(roleCandidates, propName)
@@ -75108,7 +75458,7 @@ const EXTERNAL_RULES = [
 	{
 		key: "react-hooks-js/set-state-in-effect",
 		source: "react-compiler",
-		severity: "error"
+		severity: "warn"
 	},
 	{
 		key: "react-hooks-js/globals",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.8.1-dev.1839566",
+  "version": "0.8.1-dev.26b4a0c",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",