oxlint-plugin-react-doctor 0.7.9-dev.bd3655c → 0.7.9-dev.c245b9d

package/dist/index.d.ts

@@ -5503,6 +5503,29 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-ref-callback-cleanup-before-react-19";
+  readonly id: "no-ref-callback-cleanup-before-react-19";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<Capability>;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-ref-current-in-render";
   readonly id: "no-ref-current-in-render";
@@ -14792,6 +14815,29 @@ declare const RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-ref-callback-cleanup-before-react-19";
+  readonly id: "no-ref-callback-cleanup-before-react-19";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<Capability>;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-ref-current-in-render";
   readonly id: "no-ref-current-in-render";

package/dist/index.js

@@ -13652,7 +13652,7 @@ const getPromiseChainCallForCallback = (candidate) => {
 	if (!callbackContainer.arguments?.some((argument) => stripParenExpression(argument) === candidate)) return null;
 	return isPromiseChainCall(stripParenExpression(callbackContainer.callee)) ? callbackContainer : null;
 };
-const collectEffectInvokedFunctions = (effectCallback) => {
+const collectInvokedFunctions = (effectCallback, includePromiseCallbacks) => {
 	const invokedFunctions = new Set([effectCallback]);
 	const localFunctionBindings = /* @__PURE__ */ new Map();
 	const calledBindingNames = /* @__PURE__ */ new Set();
@@ -13686,12 +13686,14 @@ const collectEffectInvokedFunctions = (effectCallback) => {
 				calledBindingNames.add(callee.name);
 				return;
 			}
-			if (isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
+			if (includePromiseCallbacks && isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
 		});
 		for (const calledName of calledBindingNames) enqueue(localFunctionBindings.get(calledName));
 	}
 	return invokedFunctions;
 };
+const collectEffectInvokedFunctions = (effectCallback) => collectInvokedFunctions(effectCallback, true);
+const collectSynchronouslyEffectInvokedFunctions = (effectCallback) => collectInvokedFunctions(effectCallback, false);
 //#endregion
 //#region src/plugin/utils/is-react-hook-name.ts
 const isReactHookName = (name) => {
@@ -14412,7 +14414,7 @@ const findSingleDirectInvocation = (functionNode, caller, context) => {
 		const callNode = findDirectCallForReference(reference.identifier);
 		return callNode ? [callNode] : [];
 	});
-	if (invocationCalls.length !== 1) return null;
+	if (invocationCalls.length !== 1 || symbol.references.length !== 1) return null;
 	const invocationCall = invocationCalls[0];
 	return findEnclosingFunction$1(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
 };
@@ -14699,7 +14701,108 @@ const hasPotentialInterruptionAfterGuard = (callback, guardState, usageNode, con
 	});
 	return hasPotentialInterruption;
 };
+const getNumericReactRefCurrentKey = (expression, context) => {
+	const refSymbol = resolveReactRefSymbol(stripParenExpression(expression), context.scopes);
+	const initializer = refSymbol?.initializer ? stripParenExpression(refSymbol.initializer) : null;
+	if (!isNodeOfType(initializer, "CallExpression")) return null;
+	const initialValue = initializer.arguments?.[0] ? stripParenExpression(initializer.arguments[0]) : null;
+	if (!isNodeOfType(initialValue, "Literal") || typeof initialValue.value !== "number") return null;
+	return resolveExpressionKey(expression, context);
+};
+const getBlockingGenerationKey = (expression, context) => {
+	const test = stripParenExpression(expression);
+	if (isNodeOfType(test, "LogicalExpression") && test.operator === "||") return getBlockingGenerationKey(test.left, context) ?? getBlockingGenerationKey(test.right, context);
+	if (!isNodeOfType(test, "BinaryExpression") || test.operator !== "!==" && test.operator !== "!=") return null;
+	const leftKey = getNumericReactRefCurrentKey(test.left, context);
+	const rightKey = getNumericReactRefCurrentKey(test.right, context);
+	const snapshotExpression = leftKey ? stripParenExpression(test.right) : stripParenExpression(test.left);
+	const key = leftKey ?? rightKey;
+	return key && isNodeOfType(snapshotExpression, "Identifier") ? key : null;
+};
+const findGenerationGuardKeyForDeferredUsage = (usageFunction, usageNode, context) => {
+	if (!isFunctionLike$1(usageFunction)) return null;
+	let generationKey = null;
+	walkAst(usageFunction.body, (child) => {
+		if (generationKey) return false;
+		if (child !== usageFunction.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "IfStatement") || child.alternate) return;
+		const key = getBlockingGenerationKey(child.test, context);
+		if (!key || canNodeReachLaterNodeWithinFunction(child.consequent, usageNode, usageFunction, context) || !doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], usageFunction, context)) return;
+		generationKey = key;
+	});
+	return generationKey;
+};
+const isGenerationAdvance = (node, generationKey, context) => {
+	if (isNodeOfType(node, "UpdateExpression") && resolveExpressionKey(node.argument, context) === generationKey) return true;
+	if (!isNodeOfType(node, "AssignmentExpression") || resolveExpressionKey(node.left, context) !== generationKey || node.operator !== "+=" && node.operator !== "-=") return false;
+	const amount = stripParenExpression(node.right);
+	return isNodeOfType(amount, "Literal") && typeof amount.value === "number" && amount.value !== 0;
+};
+const functionAdvancesGeneration = (owner, generationKey, context) => {
+	if (!isFunctionLike$1(owner)) return false;
+	let didAdvanceGeneration = false;
+	walkAst(owner.body, (child) => {
+		if (didAdvanceGeneration) return false;
+		if (child !== owner.body && isFunctionLike$1(child)) return false;
+		if (isGenerationAdvance(child, generationKey, context)) {
+			didAdvanceGeneration = true;
+			return false;
+		}
+	});
+	return didAdvanceGeneration;
+};
+const cleanupReturnsReleaseUsage = (cleanupReturns, usage, context) => cleanupReturns.length > 0 && cleanupReturns.every((cleanupReturn) => {
+	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
+	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
+	return Boolean(cleanupFunction && isFunctionLike$1(cleanupFunction) && doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context));
+});
+const getOwnedFunctionReference = (reference, usageFunction, usageNode, callback, cleanupReturns, context) => {
+	const directCall = findDirectCallForReference(reference);
+	if (directCall) {
+		const referenceOwner = findEnclosingFunction$1(directCall);
+		if (referenceOwner && referenceOwner !== usageFunction && collectSynchronouslyEffectInvokedFunctions(callback).has(referenceOwner)) return { generationKey: null };
+		const generationKey = referenceOwner ? findGenerationGuardKeyForDeferredUsage(referenceOwner, directCall, context) : null;
+		return generationKey ? { generationKey } : null;
+	}
+	const referenceRoot = findTransparentExpressionRoot(reference);
+	const schedulerCall = referenceRoot.parent;
+	if (!isNodeOfType(schedulerCall, "CallExpression") || !schedulerCall.arguments.some((argument) => argument === referenceRoot) || !isNodeOfType(schedulerCall.callee, "Identifier") || schedulerCall.callee.name !== "setTimeout" || !context.scopes.isGlobalReference(schedulerCall.callee)) return null;
+	const schedulerUsage = {
+		kind: "timer",
+		node: schedulerCall,
+		resourceName: schedulerCall.callee.name,
+		handleKey: findAssignedResourceKey(schedulerCall, context),
+		receiverKey: null,
+		registrationVerbName: schedulerCall.callee.name,
+		eventKey: null,
+		handlerKey: null
+	};
+	const generationKey = findGenerationGuardKeyForDeferredUsage(usageFunction, usageNode, context);
+	return schedulerUsage.handleKey !== null && cleanupReturnsReleaseUsage(cleanupReturns, schedulerUsage, context) && generationKey ? { generationKey } : null;
+};
+const hasGuardedRefOwnedNestedCleanup = (callback, usage, cleanupReturns, context) => {
+	const usageFunction = findEnclosingFunction$1(usage.node);
+	const usageExpression = findTransparentExpressionRoot(usage.node);
+	const usageAssignment = usageExpression.parent;
+	if (usage.kind !== "subscribe" && usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !resolveReactRefSymbol(stripParenExpression(usageAssignment.left), context.scopes) || !collectSynchronouslyEffectInvokedFunctions(callback).has(usageFunction) || !cleanupReturnsReleaseUsage(cleanupReturns, usage, context) || !doMatchingNodesCoverEveryPathFromFunctionEntry(callback, cleanupReturns, context)) return false;
+	const cleanupFunctions = cleanupReturns.flatMap((cleanupReturn) => {
+		if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return [];
+		const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
+		return cleanupFunction && isFunctionLike$1(cleanupFunction) ? [cleanupFunction] : [];
+	});
+	const bindingIdentifier = getFunctionBindingIdentifier$1(usageFunction);
+	const functionSymbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
+	if (!functionSymbol || functionSymbol.references.length === 0) return false;
+	const ownedReferences = functionSymbol.references.map((reference) => getOwnedFunctionReference(reference.identifier, usageFunction, usage.node, callback, cleanupReturns, context));
+	if (ownedReferences.some((reference) => reference === null)) return false;
+	const generationKeys = new Set(ownedReferences.flatMap((reference) => reference?.generationKey ? [reference.generationKey] : []));
+	if (generationKeys.size !== 1) return false;
+	const generationKey = generationKeys.values().next().value;
+	if (typeof generationKey !== "string") return false;
+	return [...collectSynchronouslyEffectInvokedFunctions(callback), ...cleanupFunctions].some((owner) => functionAdvancesGeneration(owner, generationKey, context));
+};
 const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
+	if (hasGuardedRefOwnedNestedCleanup(callback, usage, cleanupReturns, context)) return true;
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
 	if (usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usage.node, "CallExpression") || !isNodeOfType(usage.node.callee, "Identifier") || !context.scopes.isGlobalReference(usage.node.callee) || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
@@ -14911,6 +15014,7 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (releaseVerbName === "abort" && releaseReceiverKey === getListenerAbortControllerKey(usage, context)) return true;
 	if (releaseVerbName === "abort" && isRetainedAbortControllerRefRelease(callee.object, usage, context)) return true;
 	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;
 	if (!pairedVerbNames || !matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return false;
 	const releaseEventKey = resolveExpressionKey(callNode.arguments?.[0], context);
@@ -14947,7 +15051,8 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 		const releaseHandler = usesUnaryListenerSignature ? callNode.arguments?.[0] : callNode.arguments?.[1];
 		if (!releaseHandler) return releaseVerbName === "off";
 		const expectedHandlerKey = usesUnaryListenerSignature ? usage.eventKey : usage.handlerKey;
-		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey;
+		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);
 	}
 	if (releaseVerbName === "unobserve" && usage.eventKey !== null) return releaseEventKey === usage.eventKey;
 	return true;
@@ -14972,13 +15077,188 @@ const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (!symbol) return false;
 	return symbol.references.some((reference) => findEnclosingFunction$1(reference.identifier) !== functionNode);
 };
+const isJsxRefAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && node.name.name === "ref";
+const isFunctionForwardedToReactRef = (functionNode, context) => {
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
+	if (!bindingIdentifier) return false;
+	const symbol = context.scopes.symbolFor(bindingIdentifier);
+	if (!symbol) return false;
+	return symbol.references.some((reference) => {
+		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+		const expressionContainer = referenceRoot.parent;
+		return Boolean(isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === referenceRoot && isJsxRefAttribute(expressionContainer.parent));
+	});
+};
+const findRetainedDisposerStorages = (disposerFunction, usage, context) => {
+	if (!isFunctionLike$1(disposerFunction) || disposerFunction.async || disposerFunction.generator) return [];
+	const usageFunction = findEnclosingFunction$1(usage.node);
+	if (!usageFunction || !isFunctionLike$1(usageFunction)) return [];
+	const assignments = /* @__PURE__ */ new Map();
+	const collectAssignment = (expression) => {
+		const expressionRoot = findTransparentExpressionRoot(expression);
+		const assignment = expressionRoot.parent;
+		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.right !== expressionRoot) return;
+		const refSymbol = resolveReactRefSymbol(stripParenExpression(assignment.left), context.scopes);
+		const refCurrentKey = resolveExpressionKey(assignment.left, context);
+		const retainedFunction = findEnclosingFunction$1(assignment);
+		const assignmentStart = getRangeStart(assignment);
+		if (!refSymbol || !refCurrentKey || !retainedFunction || retainedFunction !== usageFunction || assignmentStart === null) return;
+		assignments.set(assignmentStart, {
+			assignmentNode: assignment,
+			refCurrentKey,
+			retainedFunction
+		});
+	};
+	collectAssignment(disposerFunction);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(disposerFunction);
+	const symbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
+	for (const reference of symbol?.references ?? []) collectAssignment(reference.identifier);
+	walkAst(usageFunction.body, (child) => {
+		if (child !== usageFunction.body && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "AssignmentExpression") && resolveStableValue(child.right, context) === disposerFunction) collectAssignment(child.right);
+	});
+	return [...assignments.values()];
+};
+const isRetainedDisposerStorageEstablished = (storage, usage, context) => doMatchingNodesCoverEveryPathBeforeUsage(usage.node, [storage.assignmentNode], storage.retainedFunction, context) || doMatchingNodesCoverEveryPathAfterUsage(usage.node, [storage.assignmentNode], context);
+const hasUnsafeRetainedDisposerOverwrite = (storage, usage, context) => {
+	let hasUnsafeOverwrite = false;
+	walkAst(storage.retainedFunction.body, (child) => {
+		if (hasUnsafeOverwrite) return false;
+		if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "AssignmentExpression") || child === storage.assignmentNode || resolveExpressionKey(child.left, context) !== storage.refCurrentKey || !canNodeReachLaterNodeWithinFunction(usage.node, child, storage.retainedFunction, context)) return;
+		const storedValue = resolveStableValue(child.right, context);
+		if (!storedValue || !isFunctionLike$1(storedValue) || !doesCleanupFunctionReleaseUsage(storedValue, usage, context)) {
+			hasUnsafeOverwrite = true;
+			return false;
+		}
+	});
+	return hasUnsafeOverwrite;
+};
+const hasEffectCleanupInvocation = (storage, usage, context) => {
+	const componentFunction = findEnclosingFunction$1(storage.retainedFunction);
+	if (!componentFunction || !isFunctionLike$1(componentFunction)) return false;
+	const cleanupFunctionInvokesRef = (cleanupFunction) => {
+		if (!isFunctionLike$1(cleanupFunction)) return false;
+		let didFindCleanupCall = false;
+		walkAst(cleanupFunction.body, (child) => {
+			if (didFindCleanupCall) return false;
+			if (child !== cleanupFunction.body && isFunctionLike$1(child)) return false;
+			if (isNodeOfType(child, "CallExpression") && resolveExpressionKey(child.callee, context) === storage.refCurrentKey) {
+				const callRoot = findTransparentExpressionRoot(child);
+				const callStatement = callRoot.parent;
+				const isDirectBlockStatement = isNodeOfType(cleanupFunction.body, "BlockStatement") && isNodeOfType(callStatement, "ExpressionStatement") && callStatement.parent === cleanupFunction.body;
+				const isConciseBody = cleanupFunction.body === callRoot;
+				if ((isDirectBlockStatement || isConciseBody) && !hasUnprovenReturnBeforeRefOwnedRelease(cleanupFunction, child, storage.refCurrentKey, context)) {
+					didFindCleanupCall = true;
+					return false;
+				}
+			}
+		});
+		return didFindCleanupCall;
+	};
+	const effectReturnsCleanup = (effectCallback) => {
+		if (!isFunctionLike$1(effectCallback)) return false;
+		if (!isNodeOfType(effectCallback.body, "BlockStatement")) {
+			const cleanupFunction = resolveRefOwnedCleanupFunction(effectCallback.body, context);
+			return Boolean(cleanupFunction && cleanupFunctionInvokesRef(cleanupFunction));
+		}
+		const matchingReturns = [];
+		walkInsideStatementBlocks(effectCallback.body, (child) => {
+			if (!isNodeOfType(child, "ReturnStatement") || !child.argument) return;
+			const cleanupFunction = resolveRefOwnedCleanupFunction(child.argument, context);
+			if (!cleanupFunction || !cleanupFunctionInvokesRef(cleanupFunction)) return;
+			matchingReturns.push(child);
+		});
+		return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+	};
+	let didFindInvocation = false;
+	walkAst(componentFunction.body, (child) => {
+		if (didFindInvocation) return false;
+		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
+		const effectCallback = getEffectCallback(child);
+		if (effectCallback && effectReturnsCleanup(effectCallback)) {
+			didFindInvocation = true;
+			return false;
+		}
+	});
+	return didFindInvocation;
+};
+const hasCallbackRefReplacementInvocation = (storage, usage, context) => {
+	const isReturnedCallbackRefShape = () => {
+		if (!isFunctionLike$1(storage.retainedFunction)) return false;
+		const callbackCall = findTransparentExpressionRoot(storage.retainedFunction).parent;
+		if (!isNodeOfType(callbackCall, "CallExpression") || !isReactApiCall(callbackCall, "useCallback", context.scopes)) return false;
+		const nodeParameter = storage.retainedFunction.params?.[0];
+		const nodeParameterKey = resolveExpressionKey(nodeParameter, context);
+		if (!nodeParameterKey || usage.receiverKey !== nodeParameterKey) return false;
+		const bindingIdentifier = getFunctionBindingIdentifier$1(storage.retainedFunction);
+		const symbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
+		if (!Boolean(symbol?.references.some((reference) => {
+			const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+			const property = referenceRoot.parent;
+			if (!isNodeOfType(property, "Property") || property.value !== referenceRoot || !isNodeOfType(property.parent, "ObjectExpression")) return false;
+			const returnedObject = findTransparentExpressionRoot(property.parent);
+			const returnStatement = returnedObject.parent;
+			if (!isNodeOfType(returnStatement, "ReturnStatement") || returnStatement.argument !== returnedObject) return false;
+			const hookFunction = findEnclosingFunction$1(returnStatement);
+			return Boolean(hookFunction && getFunctionBindingIdentifier$1(hookFunction)?.name.startsWith("use"));
+		}))) return false;
+		const usageStart = getRangeStart(usage.node);
+		if (usageStart === null) return false;
+		let hasNullExit = false;
+		walkAst(storage.retainedFunction.body, (child) => {
+			if (hasNullExit) return false;
+			if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
+			if (!isNodeOfType(child, "IfStatement") || (getRangeStart(child) ?? usageStart) >= usageStart) return;
+			const test = stripParenExpression(child.test);
+			if (!isNodeOfType(test, "UnaryExpression") || test.operator !== "!" || resolveExpressionKey(test.argument, context) !== nodeParameterKey) return;
+			const consequent = child.consequent;
+			hasNullExit = isNodeOfType(consequent, "ReturnStatement") || isNodeOfType(consequent, "BlockStatement") && consequent.body.some((statement) => isNodeOfType(statement, "ReturnStatement"));
+			if (hasNullExit) return false;
+		});
+		return hasNullExit;
+	};
+	if (!isFunctionForwardedToReactRef(storage.retainedFunction, context) && !isReturnedCallbackRefShape()) return false;
+	const cleanupCalls = [];
+	walkAst(storage.retainedFunction.body, (child) => {
+		if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "CallExpression") && resolveExpressionKey(child.callee, context) === storage.refCurrentKey) cleanupCalls.push(child);
+	});
+	return doMatchingNodesCoverEveryPathBeforeUsage(usage.node, cleanupCalls, storage.retainedFunction, context);
+};
+const isRetainedDisposerRefRelease = (releaseNode, usage, context) => {
+	const disposerFunction = findEnclosingFunction$1(releaseNode);
+	if (!disposerFunction) return false;
+	return findRetainedDisposerStorages(disposerFunction, usage, context).some((storage) => isRetainedDisposerStorageEstablished(storage, usage, context) && !hasUnsafeRetainedDisposerOverwrite(storage, usage, context) && (hasEffectCleanupInvocation(storage, usage, context) || hasCallbackRefReplacementInvocation(storage, 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;
+	const ownerFunction = findEnclosingFunction$1(releaseFunction);
+	if (!ownerFunction || !isFunctionLike$1(ownerFunction)) return false;
+	const triggerRegistrations = [];
+	walkAst(ownerFunction.body, (child) => {
+		if (child !== ownerFunction.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const registrationDetails = getCallRegistrationDetails(child, context);
+		if (registrationDetails.registrationVerbName === "addEventListener" && registrationDetails.receiverKey === usage.receiverKey && resolveStableValue(child.arguments?.[1], context) === releaseFunction) triggerRegistrations.push(child);
+	});
+	if (triggerRegistrations.some((triggerRegistration) => triggerRegistration === usage.node)) return true;
+	return doMatchingNodesCoverEveryPathAfterUsage(usage.node, triggerRegistrations, context) || doMatchingNodesCoverEveryPathBeforeUsage(usage.node, triggerRegistrations, ownerFunction, context);
+};
 const isReleaseReachableForUsage = (releaseNode, usage, context) => {
 	if (!isNodeReachableWithinFunction(releaseNode, context)) return false;
 	const releaseFunction = findEnclosingFunction$1(releaseNode);
 	if (!releaseFunction) return true;
 	if (releaseFunction === findEnclosingFunction$1(usage.node)) return true;
+	if (isRetainedDisposerRefRelease(releaseNode, usage, context)) return true;
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	if (usageFunction && isFunctionLike$1(usageFunction) && getAssignedReactRefSymbol(usageFunction, context) && isCleanupFunctionReferencedByReturn(usageFunction, releaseFunction, context)) return isReactRefCallbackCleanupOwnedByEffect(usageFunction, releaseFunction, usage, context);
+	if (isSelfReleasingListenerRelease(releaseNode, releaseFunction, usage, context)) return true;
 	return isPotentiallyReachableFunction(releaseFunction, context);
 };
 const fileContainsReleaseForUsage = (usage, context) => {
@@ -17112,7 +17392,7 @@ const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys, allow
 				keys.add(depKey);
 				continue;
 			}
-			const identitySourceKeys = resolveReactiveIdentitySourceKeys(symbol, scopes);
+			const identitySourceKeys = resolvePureCalledFunctionSourceKeys(reference, symbol, scopes) ?? resolveRenderDerivedMutableSourceKeys(reference, symbol, scopes) ?? resolveReactiveIdentitySourceKeys(symbol, scopes);
 			if (identitySourceKeys) {
 				if (identitySourceKeys.size === 0) stableCapturedNames.add(depKey);
 				for (const identitySourceKey of identitySourceKeys) keys.add(identitySourceKey);
@@ -17195,6 +17475,161 @@ const resolveReactiveIdentitySourceKeys = (symbol, scopes) => {
 	if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || symbol.references.some((reference) => reference.flag !== "read")) return null;
 	return resolveIdentitySourceKeysFromExpression(symbol.initializer, scopes, new Set([symbol.id]));
 };
+const isPureDerivedExpression = (expression) => {
+	const candidate = unwrapExpression$3(expression);
+	if (isNodeOfType(candidate, "Literal") || isNodeOfType(candidate, "Identifier")) return true;
+	if (isNodeOfType(candidate, "MemberExpression")) return isPureDerivedExpression(candidate.object) && (!candidate.computed || isPureDerivedExpression(candidate.property));
+	if (isNodeOfType(candidate, "BinaryExpression") || isNodeOfType(candidate, "LogicalExpression")) return isPureDerivedExpression(candidate.left) && isPureDerivedExpression(candidate.right);
+	if (isNodeOfType(candidate, "UnaryExpression")) return candidate.operator !== "delete" && isPureDerivedExpression(candidate.argument);
+	if (isNodeOfType(candidate, "ConditionalExpression")) return isPureDerivedExpression(candidate.test) && isPureDerivedExpression(candidate.consequent) && isPureDerivedExpression(candidate.alternate);
+	if (isNodeOfType(candidate, "TemplateLiteral")) return candidate.expressions.every((nestedExpression) => isPureDerivedExpression(nestedExpression));
+	return false;
+};
+const isPureDerivedStatement = (statement) => {
+	if (isNodeOfType(statement, "BlockStatement")) return statement.body.every((nestedStatement) => isPureDerivedStatement(nestedStatement));
+	if (isNodeOfType(statement, "ReturnStatement")) return !statement.argument || isPureDerivedExpression(statement.argument);
+	if (isNodeOfType(statement, "IfStatement")) return isPureDerivedExpression(statement.test) && isPureDerivedStatement(statement.consequent) && (!statement.alternate || isPureDerivedStatement(statement.alternate));
+	return false;
+};
+const isPureDerivedFunction = (functionNode) => {
+	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return false;
+	if (functionNode.async || functionNode.generator) return false;
+	return isNodeOfType(functionNode.body, "BlockStatement") ? isPureDerivedStatement(functionNode.body) : isPureDerivedExpression(functionNode.body);
+};
+const resolvePureCalledFunctionSourceKeys = (reference, symbol, scopes) => {
+	if (symbol.references.some((symbolReference) => symbolReference.flag !== "read")) return null;
+	const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+	const callExpression = referenceRoot.parent;
+	if (!isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== referenceRoot) return null;
+	const functionNode = getFunctionValueNode(symbol);
+	if (!functionNode || !isPureDerivedFunction(functionNode)) return null;
+	const sourceKeys = /* @__PURE__ */ new Set();
+	for (const capturedReference of closureCaptures(functionNode, scopes)) {
+		const capturedSymbol = capturedReference.resolvedSymbol;
+		if (!capturedSymbol || capturedSymbol.id === symbol.id) continue;
+		if (isOutsideAllFunctions(capturedSymbol) || symbolHasStableValue(capturedSymbol, scopes)) continue;
+		const capturedKey = computeDepKey(capturedReference);
+		if (!capturedKey) return null;
+		if (capturedKey === capturedSymbol.name) {
+			const nestedSourceKeys = resolveReactiveIdentitySourceKeys(capturedSymbol, scopes);
+			if (nestedSourceKeys) {
+				for (const nestedSourceKey of nestedSourceKeys) sourceKeys.add(nestedSourceKey);
+				continue;
+			}
+		}
+		sourceKeys.add(capturedKey);
+	}
+	return sourceKeys.size > 0 ? sourceKeys : null;
+};
+const mergeDerivedExpressionSourceKeys = (expressions, scopes, visitedSymbolIds) => {
+	const sourceKeys = /* @__PURE__ */ new Set();
+	for (const expression of expressions) {
+		const expressionSourceKeys = resolveDerivedExpressionSourceKeys(expression, scopes, visitedSymbolIds);
+		if (!expressionSourceKeys) return null;
+		for (const expressionSourceKey of expressionSourceKeys) sourceKeys.add(expressionSourceKey);
+	}
+	return sourceKeys;
+};
+const resolveDerivedExpressionSourceKeys = (expression, scopes, visitedSymbolIds) => {
+	const candidate = unwrapExpression$3(expression);
+	if (isNodeOfType(candidate, "Literal")) return /* @__PURE__ */ new Set();
+	if (isNodeOfType(candidate, "Identifier")) {
+		if (scopes.isGlobalReference(candidate)) return /* @__PURE__ */ new Set();
+		const sourceSymbol = scopes.symbolFor(candidate);
+		if (!sourceSymbol) return null;
+		if (isOutsideAllFunctions(sourceSymbol) || symbolHasStableValue(sourceSymbol, scopes)) return /* @__PURE__ */ new Set();
+		if (sourceSymbol.kind === "const" && sourceSymbol.initializer && isNodeOfType(sourceSymbol.declarationNode, "VariableDeclarator") && sourceSymbol.declarationNode.id === sourceSymbol.bindingIdentifier && sourceSymbol.references.every((sourceReference) => sourceReference.flag === "read") && !visitedSymbolIds.has(sourceSymbol.id)) {
+			visitedSymbolIds.add(sourceSymbol.id);
+			const sourceKeys = resolveDerivedExpressionSourceKeys(sourceSymbol.initializer, scopes, visitedSymbolIds);
+			visitedSymbolIds.delete(sourceSymbol.id);
+			if (sourceKeys) return sourceKeys;
+		}
+		return new Set([sourceSymbol.name]);
+	}
+	if (isNodeOfType(candidate, "MemberExpression")) {
+		if (hasComputedMemberExpression(candidate)) return null;
+		const sourceKey = stringifyMemberChain(candidate);
+		const rootIdentifier = getMemberRootIdentifier(candidate);
+		const rootSymbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
+		if (!sourceKey || !rootSymbol) return null;
+		if (isOutsideAllFunctions(rootSymbol) || symbolHasStableValue(rootSymbol, scopes)) return /* @__PURE__ */ new Set();
+		return new Set([sourceKey]);
+	}
+	if (isNodeOfType(candidate, "BinaryExpression") || isNodeOfType(candidate, "LogicalExpression")) return mergeDerivedExpressionSourceKeys([candidate.left, candidate.right], scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator !== "delete") return resolveDerivedExpressionSourceKeys(candidate.argument, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "ConditionalExpression")) return mergeDerivedExpressionSourceKeys([
+		candidate.test,
+		candidate.consequent,
+		candidate.alternate
+	], scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "TemplateLiteral")) return mergeDerivedExpressionSourceKeys(candidate.expressions, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "NewExpression")) {
+		const callee = unwrapExpression$3(candidate.callee);
+		if (!isNodeOfType(callee, "Identifier") || callee.name !== "Error" || !scopes.isGlobalReference(callee)) return null;
+		const argumentsToAnalyze = [];
+		for (const argument of candidate.arguments) {
+			if (!isAstNode(argument) || isNodeOfType(argument, "SpreadElement")) return null;
+			argumentsToAnalyze.push(argument);
+		}
+		return mergeDerivedExpressionSourceKeys(argumentsToAnalyze, scopes, visitedSymbolIds);
+	}
+	return null;
+};
+const resolveWriteControlSourceKeys = (assignment, boundaryFunction, scopes) => {
+	const sourceKeys = /* @__PURE__ */ new Set();
+	let currentNode = assignment;
+	while (currentNode.parent && currentNode.parent !== boundaryFunction) {
+		const parentNode = currentNode.parent;
+		if (isNodeOfType(parentNode, "IfStatement")) {
+			if (parentNode.test === currentNode) return null;
+			const testSourceKeys = resolveDerivedExpressionSourceKeys(parentNode.test, scopes, /* @__PURE__ */ new Set());
+			if (!testSourceKeys) return null;
+			for (const testSourceKey of testSourceKeys) sourceKeys.add(testSourceKey);
+		} else if (!isNodeOfType(parentNode, "ExpressionStatement") && !isNodeOfType(parentNode, "BlockStatement")) return null;
+		currentNode = parentNode;
+	}
+	return currentNode.parent === boundaryFunction ? sourceKeys : null;
+};
+const isReadOnlyInitialStateUse = (referenceNode, scopes) => {
+	const referenceRoot = findTransparentExpressionRoot(referenceNode);
+	const callExpression = referenceRoot.parent;
+	return isNodeOfType(callExpression, "CallExpression") && callExpression.arguments.some((argument) => argument === referenceRoot) && isReactApiCall(callExpression, "useState", scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: true,
+		resolveNamedAliases: true
+	});
+};
+const resolveRenderDerivedMutableSourceKeys = (capturedReference, symbol, scopes) => {
+	if (symbol.kind !== "let" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
+	const boundaryFunction = findEnclosingFunction$1(symbol.bindingIdentifier);
+	if (!boundaryFunction) return null;
+	const capturingFunction = findEnclosingFunction$1(capturedReference.identifier);
+	if (!capturingFunction || capturingFunction === boundaryFunction) return null;
+	const sourceKeys = /* @__PURE__ */ new Set();
+	if (symbol.initializer) {
+		const initializerSourceKeys = resolveDerivedExpressionSourceKeys(symbol.initializer, scopes, new Set([symbol.id]));
+		if (!initializerSourceKeys) return null;
+		for (const initializerSourceKey of initializerSourceKeys) sourceKeys.add(initializerSourceKey);
+	}
+	let writeCount = 0;
+	for (const symbolReference of symbol.references) {
+		if (symbolReference.flag === "read") {
+			if (findEnclosingFunction$1(symbolReference.identifier) !== capturingFunction && !isReadOnlyInitialStateUse(symbolReference.identifier, scopes)) return null;
+			continue;
+		}
+		if (symbolReference.flag !== "write") return null;
+		const referenceRoot = findTransparentExpressionRoot(symbolReference.identifier);
+		const assignment = referenceRoot.parent;
+		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== referenceRoot || findEnclosingFunction$1(referenceRoot) !== boundaryFunction) return null;
+		const assignmentSourceKeys = resolveDerivedExpressionSourceKeys(assignment.right, scopes, new Set([symbol.id]));
+		const controlSourceKeys = resolveWriteControlSourceKeys(assignment, boundaryFunction, scopes);
+		if (!assignmentSourceKeys || !controlSourceKeys) return null;
+		for (const assignmentSourceKey of assignmentSourceKeys) sourceKeys.add(assignmentSourceKey);
+		for (const controlSourceKey of controlSourceKeys) sourceKeys.add(controlSourceKey);
+		writeCount += 1;
+	}
+	return writeCount > 0 && sourceKeys.size > 0 ? sourceKeys : null;
+};
 const isUseCallbackResultDep = (node, scopes) => {
 	const rootSymbol = getRootSymbol(node, scopes);
 	const initializer = rootSymbol?.initializer ? unwrapExpression$3(rootSymbol.initializer) : null;
@@ -40263,6 +40698,17 @@ const DOM_MEASUREMENT_NAMES = new Set([
 	"scrollHeight"
 ]);
 const MEASUREMENT_HELPER_CALLEE_PATTERN = /^(?:get|measure|read)\w*(?:Width|Height|Rect|Rects|Size|Bounds|Position)$/;
+const IMPERATIVE_DOM_MUTATION_NAMES = new Set([
+	"blur",
+	"focus",
+	"restoreSelection",
+	"scroll",
+	"scrollBy",
+	"scrollIntoView",
+	"scrollTo",
+	"setRangeText",
+	"setSelectionRange"
+]);
 const subtreeReadsDomMeasurement = (root) => {
 	if (!root) return false;
 	let found = false;
@@ -40281,29 +40727,66 @@ const subtreeReadsDomMeasurement = (root) => {
 	});
 	return found;
 };
-const collectMeasuringFunctionNames = (program) => {
+const collectFunctionNamesMatchingBody = (program, matchesBody) => {
 	const names = /* @__PURE__ */ new Set();
 	walkAst(program, (child) => {
 		if (isNodeOfType(child, "FunctionDeclaration")) {
-			if (child.id && isNodeOfType(child.id, "Identifier") && subtreeReadsDomMeasurement(child.body)) names.add(child.id.name);
+			if (child.id && isNodeOfType(child.id, "Identifier") && matchesBody(child.body)) names.add(child.id.name);
 			return;
 		}
 		if (!isNodeOfType(child, "VariableDeclarator") || !isNodeOfType(child.id, "Identifier")) return;
 		let functionValue = child.init;
 		if (functionValue && isNodeOfType(functionValue, "CallExpression") && isNodeOfType(functionValue.callee, "Identifier") && /^use[A-Z]/.test(functionValue.callee.name)) functionValue = functionValue.arguments?.[0];
-		if (functionValue && isFunctionLike$1(functionValue) && subtreeReadsDomMeasurement(functionValue.body)) names.add(child.id.name);
+		if (functionValue && isFunctionLike$1(functionValue) && matchesBody(functionValue.body)) names.add(child.id.name);
 	});
 	return names;
 };
-const callsAnyName = (root, names) => {
-	if (!root || names.size === 0) return false;
+const collectMeasuringFunctionNames = (program) => collectFunctionNamesMatchingBody(program, subtreeReadsDomMeasurement);
+const subtreeMutatesDomImperatively = (root) => {
+	if (!root || isFunctionLike$1(root)) return false;
+	let found = false;
+	walkAst(root, (child) => {
+		if (found) return false;
+		if (child !== root && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = stripParenExpression(child.callee);
+		const propertyName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : null;
+		if (propertyName !== null && IMPERATIVE_DOM_MUTATION_NAMES.has(propertyName)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+};
+const collectImperativeDomFunctionNames = (program) => collectFunctionNamesMatchingBody(program, subtreeMutatesDomImperatively);
+const callsAnyName = (root, names, shouldSkipNestedFunctions = false) => {
+	if (!root || names.size === 0 || shouldSkipNestedFunctions && isFunctionLike$1(root)) return false;
 	let found = false;
 	walkAst(root, (child) => {
 		if (found) return false;
+		if (shouldSkipNestedFunctions && child !== root && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && names.has(child.callee.name)) found = true;
 	});
 	return found;
 };
+const isFollowedByImperativeDomMutation = (call, imperativeDomFunctionNames) => {
+	let statement = call;
+	let parent = statement.parent;
+	while (parent) {
+		const statements = isNodeOfType(parent, "BlockStatement") || isNodeOfType(parent, "Program") || isNodeOfType(parent, "StaticBlock") ? parent.body : isNodeOfType(parent, "SwitchCase") ? parent.consequent : null;
+		if (statements) {
+			const statementIndex = statements.findIndex((siblingStatement) => siblingStatement === statement);
+			if (statementIndex >= 0) {
+				const nextStatement = statements[statementIndex + 1];
+				return subtreeMutatesDomImperatively(nextStatement) || callsAnyName(nextStatement, imperativeDomFunctionNames, true);
+			}
+		}
+		if (isFunctionLike$1(parent) || parent.type.endsWith("Statement") && !isNodeOfType(parent, "ExpressionStatement")) return false;
+		statement = parent;
+		parent = parent.parent;
+	}
+	return false;
+};
 const isInsideStartViewTransition = (node) => {
 	let cursor = node.parent;
 	while (cursor) {
@@ -40344,11 +40827,12 @@ const importsImperativeDomLibrary = (program) => {
 };
 const hasExemptFlushSyncCall = (program, localName) => {
 	const measuringFunctionNames = collectMeasuringFunctionNames(program);
+	const imperativeDomFunctionNames = collectImperativeDomFunctionNames(program);
 	let exempt = false;
 	walkAst(program, (child) => {
 		if (exempt) return false;
 		if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "Identifier") || child.callee.name !== localName) return;
-		if (isInsideStartViewTransition(child) || enclosingFunctionChainReadsMeasurement(child, measuringFunctionNames)) {
+		if (isInsideStartViewTransition(child) || enclosingFunctionChainReadsMeasurement(child, measuringFunctionNames) || isFollowedByImperativeDomMutation(child, imperativeDomFunctionNames)) {
 			exempt = true;
 			return false;
 		}
@@ -40913,41 +41397,223 @@ const readLogicalConditionResult = (operator, leftResult, rightResult) => {
 	if (leftResult === false && rightResult === false) return false;
 	return null;
 };
-const readHydrationConditionResult = (expression, context, runtime) => {
+const readHydrationConditionResult = (expression, context, runtime, state) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
 	if (predicateMatch) return predicateMatch[`${runtime}Result`];
 	const staticResult = readInitialStateBoolean(unwrappedExpression, context.scopes);
 	if (staticResult !== null) return staticResult;
+	const expressionSymbol = isNodeOfType(unwrappedExpression, "Identifier") ? context.scopes.symbolFor(unwrappedExpression) : null;
+	const parameterValue = expressionSymbol ? state.parameterValuesBySymbolId.get(expressionSymbol.id) : null;
+	if (expressionSymbol && parameterValue && !state.visitedSymbolIds.has(expressionSymbol.id)) {
+		state.visitedSymbolIds.add(expressionSymbol.id);
+		const result = readHydrationConditionResult(parameterValue, context, runtime, state);
+		state.visitedSymbolIds.delete(expressionSymbol.id);
+		return result;
+	}
+	if (expressionSymbol && expressionSymbol.kind === "const" && expressionSymbol.initializer && expressionSymbol.references.every((reference) => reference.flag === "read") && !state.visitedSymbolIds.has(expressionSymbol.id)) {
+		state.visitedSymbolIds.add(expressionSymbol.id);
+		const result = readHydrationConditionResult(expressionSymbol.initializer, context, runtime, state);
+		state.visitedSymbolIds.delete(expressionSymbol.id);
+		return result;
+	}
+	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
+		const callArguments = unwrappedExpression.arguments ?? [];
+		if (isReactApiCall(unwrappedExpression, "useMemo", context.scopes, {
+			allowGlobalReactNamespace: true,
+			resolveNamedAliases: true
+		})) {
+			const callbackArgument = callArguments[0];
+			if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
+			const callbackFunction = resolveExactLocalFunction(callbackArgument, context.scopes);
+			return isFunctionLike$1(callbackFunction) && callbackFunction.params.length === 0 ? readHydrationFunctionResult(callbackFunction, context, runtime, state) : null;
+		}
+		const callee = stripParenExpression(unwrappedExpression.callee);
+		if (isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee) && callArguments.length === 1 && !isNodeOfType(callArguments[0], "SpreadElement")) return readHydrationConditionResult(callArguments[0], context, runtime, state);
+		const helperFunction = resolveExactLocalFunction(callee, context.scopes);
+		if (!isFunctionLike$1(helperFunction) || helperFunction.async || isNodeOfType(helperFunction, "FunctionDeclaration") && helperFunction.generator || isNodeOfType(helperFunction, "FunctionExpression") && helperFunction.generator || helperFunction.params.some((parameter) => !isNodeOfType(parameter, "Identifier")) || callArguments.some((argument) => isNodeOfType(argument, "SpreadElement"))) return null;
+		const parameterValuesBySymbolId = new Map(state.parameterValuesBySymbolId);
+		for (let parameterIndex = 0; parameterIndex < helperFunction.params.length; parameterIndex++) {
+			const parameter = helperFunction.params[parameterIndex];
+			const argument = callArguments[parameterIndex];
+			if (!argument || !isNodeOfType(parameter, "Identifier")) continue;
+			const parameterSymbol = context.scopes.symbolFor(parameter);
+			if (parameterSymbol) parameterValuesBySymbolId.set(parameterSymbol.id, argument);
+		}
+		return readHydrationFunctionResult(helperFunction, context, runtime, {
+			...state,
+			parameterValuesBySymbolId
+		});
+	}
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime);
+		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime, state);
 		return argumentResult === null ? null : !argumentResult;
 	}
 	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime), readHydrationConditionResult(unwrappedExpression.right, context, runtime));
+	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime, state), readHydrationConditionResult(unwrappedExpression.right, context, runtime, state));
+};
+const readHydrationStatementResult = (statement, context, runtime, state) => {
+	if (isNodeOfType(statement, "ReturnStatement")) return {
+		didReturn: true,
+		value: statement.argument ? readHydrationConditionResult(statement.argument, context, runtime, state) : null
+	};
+	if (isNodeOfType(statement, "BlockStatement")) {
+		for (const childStatement of statement.body) {
+			const result = readHydrationStatementResult(childStatement, context, runtime, state);
+			if (result.didReturn) return result;
+			if (statementAlwaysExits(childStatement)) break;
+		}
+		return {
+			didReturn: false,
+			value: null
+		};
+	}
+	if (!isNodeOfType(statement, "IfStatement")) return {
+		didReturn: false,
+		value: null
+	};
+	const conditionResult = readHydrationConditionResult(statement.test, context, runtime, state);
+	if (conditionResult !== null) {
+		const selectedBranch = conditionResult ? statement.consequent : statement.alternate;
+		return selectedBranch ? readHydrationStatementResult(selectedBranch, context, runtime, state) : {
+			didReturn: false,
+			value: null
+		};
+	}
+	const consequentResult = readHydrationStatementResult(statement.consequent, context, runtime, state);
+	const alternateResult = statement.alternate ? readHydrationStatementResult(statement.alternate, context, runtime, state) : {
+		didReturn: false,
+		value: null
+	};
+	return consequentResult.didReturn && alternateResult.didReturn && consequentResult.value !== null && consequentResult.value === alternateResult.value ? consequentResult : {
+		didReturn: consequentResult.didReturn || alternateResult.didReturn,
+		value: null
+	};
+};
+const readHydrationFunctionResult = (functionNode, context, runtime, state) => {
+	if (!isFunctionLike$1(functionNode) || state.visitedFunctionNodes.has(functionNode)) return null;
+	state.visitedFunctionNodes.add(functionNode);
+	const result = isNodeOfType(functionNode.body, "BlockStatement") ? readHydrationStatementResult(functionNode.body, context, runtime, state).value : readHydrationConditionResult(functionNode.body, context, runtime, state);
+	state.visitedFunctionNodes.delete(functionNode);
+	return result;
+};
+const doEquivalentExpressionBindingsMatch = (leftExpression, rightExpression, scopes) => {
+	const left = stripParenExpression(leftExpression);
+	const right = stripParenExpression(rightExpression);
+	if (isNodeOfType(left, "Identifier") && isNodeOfType(right, "Identifier")) {
+		const leftSymbol = scopes.symbolFor(left);
+		const rightSymbol = scopes.symbolFor(right);
+		return leftSymbol || rightSymbol ? leftSymbol?.id === rightSymbol?.id : true;
+	}
+	if (isNodeOfType(left, "MemberExpression") && isNodeOfType(right, "MemberExpression")) return doEquivalentExpressionBindingsMatch(left.object, right.object, scopes) && (!left.computed || doEquivalentExpressionBindingsMatch(left.property, right.property, scopes));
+	if (isNodeOfType(left, "CallExpression") && isNodeOfType(right, "CallExpression")) {
+		const rightArguments = right.arguments ?? [];
+		return doEquivalentExpressionBindingsMatch(left.callee, right.callee, scopes) && (left.arguments ?? []).every((argument, index) => {
+			const rightArgument = rightArguments[index];
+			return Boolean(rightArgument && doEquivalentExpressionBindingsMatch(argument, rightArgument, scopes));
+		});
+	}
+	return true;
+};
+const areHelperReturnValuesEquivalent = (leftValue, rightValue, context) => {
+	if (areExpressionsStructurallyEqual(leftValue, rightValue)) return doEquivalentExpressionBindingsMatch(leftValue, rightValue, context.scopes);
+	const leftBoolean = readInitialStateBoolean(leftValue, context.scopes);
+	const rightBoolean = readInitialStateBoolean(rightValue, context.scopes);
+	return leftBoolean !== null && rightBoolean !== null && leftBoolean === rightBoolean;
+};
+const doHelperReturnValuesDiffer = (leftValues, rightValues, context) => {
+	const everyValueHasEquivalent = (values, candidateValues) => values.every((value) => candidateValues.some((candidateValue) => areHelperReturnValuesEquivalent(value, candidateValue, context)));
+	return !everyValueHasEquivalent(leftValues, rightValues) || !everyValueHasEquivalent(rightValues, leftValues);
 };
-const matchHydrationCondition = (expression, context) => {
+const matchHydrationConditionInternal = (expression, context, state) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
 	if (predicateMatch) return {
 		predicateMatch,
 		predicateNode: unwrappedExpression
 	};
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationCondition(unwrappedExpression.argument, context);
-	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	const leftMatch = matchHydrationCondition(unwrappedExpression.left, context);
-	const rightMatch = matchHydrationCondition(unwrappedExpression.right, context);
-	if (leftMatch && rightMatch) {
-		const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client");
-		const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server");
-		return clientResult !== null && serverResult !== null && clientResult !== serverResult ? leftMatch : null;
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = context.scopes.symbolFor(unwrappedExpression);
+		const parameterValue = symbol ? state.parameterValuesBySymbolId.get(symbol.id) : null;
+		if (symbol && parameterValue && !state.visitedSymbolIds.has(symbol.id)) {
+			state.visitedSymbolIds.add(symbol.id);
+			const match = matchHydrationConditionInternal(parameterValue, context, state);
+			state.visitedSymbolIds.delete(symbol.id);
+			return match;
+		}
+		if (!symbol || symbol.kind !== "const" || !symbol.initializer || symbol.references.some((reference) => reference.flag !== "read") || state.visitedSymbolIds.has(symbol.id)) return null;
+		state.visitedSymbolIds.add(symbol.id);
+		const match = matchHydrationConditionInternal(symbol.initializer, context, state);
+		state.visitedSymbolIds.delete(symbol.id);
+		return match;
+	}
+	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
+		const callArguments = unwrappedExpression.arguments ?? [];
+		if (isReactApiCall(unwrappedExpression, "useMemo", context.scopes, {
+			allowGlobalReactNamespace: true,
+			resolveNamedAliases: true
+		})) {
+			const callbackArgument = callArguments[0];
+			if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
+			const callbackFunction = resolveExactLocalFunction(callbackArgument, context.scopes);
+			return isFunctionLike$1(callbackFunction) && callbackFunction.params.length === 0 ? matchHydrationFunctionResult(callbackFunction, context, state) : null;
+		}
+		const callee = stripParenExpression(unwrappedExpression.callee);
+		if (isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee) && callArguments.length === 1 && !isNodeOfType(callArguments[0], "SpreadElement")) return matchHydrationConditionInternal(callArguments[0], context, state);
+		const helperFunction = resolveExactLocalFunction(callee, context.scopes);
+		if (!isFunctionLike$1(helperFunction) || helperFunction.async || isNodeOfType(helperFunction, "FunctionDeclaration") && helperFunction.generator || isNodeOfType(helperFunction, "FunctionExpression") && helperFunction.generator || helperFunction.params.some((parameter) => !isNodeOfType(parameter, "Identifier")) || callArguments.some((argument) => isNodeOfType(argument, "SpreadElement"))) return null;
+		const parameterValuesBySymbolId = new Map(state.parameterValuesBySymbolId);
+		for (let parameterIndex = 0; parameterIndex < helperFunction.params.length; parameterIndex++) {
+			const parameter = helperFunction.params[parameterIndex];
+			const argument = callArguments[parameterIndex];
+			if (!argument || !isNodeOfType(parameter, "Identifier")) continue;
+			const parameterSymbol = context.scopes.symbolFor(parameter);
+			if (parameterSymbol) parameterValuesBySymbolId.set(parameterSymbol.id, argument);
+		}
+		return matchHydrationFunctionResult(helperFunction, context, {
+			...state,
+			parameterValuesBySymbolId
+		});
 	}
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationConditionInternal(unwrappedExpression.argument, context, state);
+	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
+	const leftMatch = matchHydrationConditionInternal(unwrappedExpression.left, context, state);
+	const rightMatch = matchHydrationConditionInternal(unwrappedExpression.right, context, state);
 	const nestedMatch = leftMatch ?? rightMatch;
 	if (!nestedMatch) return null;
-	const otherResult = readInitialStateBoolean(leftMatch ? unwrappedExpression.right : unwrappedExpression.left, context.scopes);
-	if (unwrappedExpression.operator === "&&" && otherResult === false || unwrappedExpression.operator === "||" && otherResult === true) return null;
-	return nestedMatch;
+	const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client", state);
+	const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server", state);
+	return clientResult !== null && serverResult !== null && clientResult === serverResult ? null : nestedMatch;
 };
+const matchHydrationReturningStatement = (statement, context, state) => {
+	if (isNodeOfType(statement, "ReturnStatement")) return statement.argument ? matchHydrationConditionInternal(statement.argument, context, state) : null;
+	if (isNodeOfType(statement, "IfStatement")) {
+		const conditionMatch = matchHydrationConditionInternal(statement.test, context, state);
+		const consequentValues = getReturnedValues(statement.consequent);
+		const alternateValues = statement.alternate ? getReturnedValues(statement.alternate) : findFollowingReturnedValues(statement);
+		if (conditionMatch && consequentValues.length > 0 && alternateValues.length > 0 && doHelperReturnValuesDiffer(consequentValues, alternateValues, context)) return conditionMatch;
+		return matchHydrationReturningStatement(statement.consequent, context, state) ?? (statement.alternate ? matchHydrationReturningStatement(statement.alternate, context, state) : null);
+	}
+	if (!isNodeOfType(statement, "BlockStatement")) return null;
+	for (const childStatement of statement.body) {
+		const match = matchHydrationReturningStatement(childStatement, context, state);
+		if (match) return match;
+		if (statementAlwaysExits(childStatement)) break;
+	}
+	return null;
+};
+const matchHydrationFunctionResult = (functionNode, context, state) => {
+	if (!isFunctionLike$1(functionNode) || state.visitedFunctionNodes.has(functionNode)) return null;
+	state.visitedFunctionNodes.add(functionNode);
+	const match = isNodeOfType(functionNode.body, "BlockStatement") ? matchHydrationReturningStatement(functionNode.body, context, state) : matchHydrationConditionInternal(functionNode.body, context, state);
+	state.visitedFunctionNodes.delete(functionNode);
+	return match;
+};
+const matchHydrationCondition = (expression, context) => matchHydrationConditionInternal(expression, context, {
+	parameterValuesBySymbolId: /* @__PURE__ */ new Map(),
+	visitedFunctionNodes: /* @__PURE__ */ new Set(),
+	visitedSymbolIds: /* @__PURE__ */ new Set()
+});
 const areNodeArraysEquivalent = (leftNodes, rightNodes) => leftNodes.length === rightNodes.length && leftNodes.every((leftNode, index) => areRenderedBranchesEquivalent(leftNode, rightNodes[index]));
 const areRenderedBranchesEquivalent = (leftNode, rightNode) => {
 	if (!leftNode || !rightNode) return leftNode === rightNode;
@@ -41090,17 +41756,17 @@ const noHydrationBranchOnBrowserGlobal = defineRule({
 			const { predicateMatch, predicateNode } = conditionMatch;
 			if (reportedNodes.has(predicateNode)) return;
 			if (rightBranch && areRenderedBranchesEquivalent(leftBranch, rightBranch)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(predicateNode, context.scopes);
+			const componentOrHookNode = findRenderPhaseComponentOrHook(conditionNode, context.scopes);
 			if (!componentOrHookNode) return;
 			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (requiresRenderedContext && !isInRenderedOutput(predicateNode, componentOrHookNode, context.scopes)) return;
+			if (requiresRenderedContext && !isInRenderedOutput(conditionNode, componentOrHookNode, context.scopes)) return;
 			if (!isRenderedValue(leftBranch) && (!rightBranch || !isRenderedValue(rightBranch))) {
-				const attribute = findEnclosingJsxAttribute(predicateNode);
+				const attribute = findEnclosingJsxAttribute(conditionNode);
 				if (!attribute || isEventHandlerAttribute(attribute)) return;
 			}
-			if (fileIsEmailTemplate || isGatedByFalsyInitialState(predicateNode, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(predicateNode, componentOrHookNode, context.scopes)) return;
-			const openingElement = findEnclosingJsxOpeningElement(predicateNode);
+			if (fileIsEmailTemplate || isGatedByFalsyInitialState(conditionNode, context.scopes)) return;
+			if (isAfterClientOnlyEarlyReturn(conditionNode, componentOrHookNode, context.scopes)) return;
+			const openingElement = findEnclosingJsxOpeningElement(conditionNode);
 			if (hasSuppressHydrationWarningAttribute(openingElement) && !isStructuralRenderedValue(leftBranch) && !isStructuralRenderedValue(rightBranch)) return;
 			if (branchRootsSuppressSameElement(leftBranch, rightBranch)) return;
 			if (isGeneratedImageRenderContext(context, openingElement ?? leftBranch)) return;
@@ -41840,7 +42506,8 @@ const noJsxElementType = defineRule({
 	create: (context) => {
 		let isJsxImported = false;
 		const flaggedAnnotations = [];
-		const checkReturnType = (returnType) => {
+		const collectComponentReturnType = (functionNode, returnType) => {
+			if (!(isNodeOfType(functionNode, "TSDeclareFunction") ? Boolean(functionNode.id && isReactComponentName(functionNode.id.name)) : isComponentFunction$1(functionNode))) return;
 			const typeAnnotation = extractReturnTypeAnnotation(returnType);
 			if (!typeAnnotation) return;
 			if (isJsxElementTypeReference(typeAnnotation)) flaggedAnnotations.push(typeAnnotation);
@@ -41850,19 +42517,16 @@ const noJsxElementType = defineRule({
 				if (isJsxImportBinding(node)) isJsxImported = true;
 			},
 			FunctionDeclaration(node) {
-				checkReturnType(node.returnType);
+				collectComponentReturnType(node, node.returnType);
 			},
 			ArrowFunctionExpression(node) {
-				checkReturnType(node.returnType);
+				collectComponentReturnType(node, node.returnType);
 			},
 			FunctionExpression(node) {
-				checkReturnType(node.returnType);
+				collectComponentReturnType(node, node.returnType);
 			},
 			TSDeclareFunction(node) {
-				checkReturnType(node.returnType);
-			},
-			TSMethodSignature(node) {
-				checkReturnType(node.returnType);
+				collectComponentReturnType(node, node.returnType);
 			},
 			"Program:exit"() {
 				if (isJsxImported) return;
@@ -47086,6 +47750,69 @@ const noRedundantShouldComponentUpdate = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/correctness/no-ref-callback-cleanup-before-react-19.ts
+const resolveFunctionExpressions = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isFunctionLike$1(expression)) return expression.async || expression.generator ? [] : [expression];
+	if (isNodeOfType(expression, "ConditionalExpression")) {
+		if (isNodeOfType(expression.test, "Literal")) return resolveFunctionExpressions(expression.test.value ? expression.consequent : expression.alternate, scopes, visitedSymbolIds);
+		return [...resolveFunctionExpressions(expression.consequent, scopes, visitedSymbolIds), ...resolveFunctionExpressions(expression.alternate, scopes, visitedSymbolIds)];
+	}
+	if (isNodeOfType(expression, "LogicalExpression")) {
+		if (isNodeOfType(expression.left, "Literal")) {
+			const isLeftTruthy = Boolean(expression.left.value);
+			if (expression.operator === "&&" && !isLeftTruthy) return [];
+			if (expression.operator === "||" && isLeftTruthy) return [];
+			if (expression.operator === "??" && expression.left.value !== null) return [];
+		}
+		if (expression.operator === "&&") return resolveFunctionExpressions(expression.right, scopes, visitedSymbolIds);
+		return [...resolveFunctionExpressions(expression.left, scopes, visitedSymbolIds), ...resolveFunctionExpressions(expression.right, scopes, visitedSymbolIds)];
+	}
+	if (isNodeOfType(expression, "SequenceExpression")) {
+		const finalExpression = expression.expressions.at(-1);
+		return finalExpression ? resolveFunctionExpressions(finalExpression, scopes, visitedSymbolIds) : [];
+	}
+	if (isNodeOfType(expression, "CallExpression")) {
+		if (!isReactApiCall(expression, "useCallback", scopes)) return [];
+		const callback = expression.arguments[0];
+		return callback && !isNodeOfType(callback, "SpreadElement") ? resolveFunctionExpressions(callback, scopes, visitedSymbolIds) : [];
+	}
+	if (!isNodeOfType(expression, "Identifier")) return [];
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return [];
+	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration") && symbol.references.every((reference) => reference.flag === "read")) return resolveFunctionExpressions(symbol.declarationNode, scopes, new Set([...visitedSymbolIds, symbol.id]));
+	const initializer = getDirectConstInitializer(symbol);
+	if (!initializer) return [];
+	return resolveFunctionExpressions(initializer, scopes, new Set([...visitedSymbolIds, symbol.id]));
+};
+const functionReturnsCleanupFunction = (functionExpression, scopes) => {
+	if (!isFunctionLike$1(functionExpression)) return false;
+	if (!isNodeOfType(functionExpression.body, "BlockStatement")) return resolveFunctionExpressions(functionExpression.body, scopes).length > 0;
+	return collectFunctionReturnStatements(functionExpression).some((returnStatement) => Boolean(returnStatement.argument && resolveFunctionExpressions(returnStatement.argument, scopes).length > 0));
+};
+const callbackReturnsCleanupFunction = (callback, scopes) => {
+	return resolveFunctionExpressions(callback, scopes).some((functionExpression) => functionReturnsCleanupFunction(functionExpression, scopes));
+};
+const noRefCallbackCleanupBeforeReact19 = defineRule({
+	id: "no-ref-callback-cleanup-before-react-19",
+	title: "Ref cleanup requires React 19",
+	requires: ["react:18"],
+	disabledWhen: ["react:19"],
+	severity: "warn",
+	recommendation: "React 18 ignores functions returned from ref callbacks. Handle cleanup when React calls the ref with `null`, or require React 19 before returning a cleanup function.",
+	create: (context) => ({ JSXAttribute(node) {
+		if (getJsxAttributeName(node.name) !== "ref") return;
+		if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
+		const callback = node.value.expression;
+		if (!callback || isNodeOfType(callback, "JSXEmptyExpression")) return;
+		if (!callbackReturnsCleanupFunction(callback, context.scopes)) return;
+		context.report({
+			node,
+			message: "This ref callback returns a cleanup function, but React 18 ignores ref cleanup returns, so the cleanup never runs. Handle detachment when React calls the ref with `null`, or require React 19."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
 const REPEATED_ANCESTOR_TYPES = new Set([
 	"DoWhileStatement",
@@ -71853,6 +72580,17 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noRedundantShouldComponentUpdate.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-ref-callback-cleanup-before-react-19",
+		id: "no-ref-callback-cleanup-before-react-19",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noRefCallbackCleanupBeforeReact19,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
 	{
 		key: "react-doctor/no-ref-current-in-render",
 		id: "no-ref-current-in-render",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.9-dev.bd3655c",
+  "version": "0.7.9-dev.c245b9d",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",