oxlint-plugin-react-doctor 0.9.2-dev.c126684 → 0.9.2-dev.d6f02bb

package/dist/index.js

@@ -665,6 +665,19 @@ const TRIVIAL_INITIALIZER_NAMES = new Set([
 	"parseInt",
 	"parseFloat"
 ]);
+const TRIVIAL_CONSTRUCTOR_NAMES = new Set([
+	"Date",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"WeakRef",
+	"RegExp",
+	"Error",
+	"URL",
+	"URLSearchParams",
+	"AbortController"
+]);
 const SETTER_PATTERN = /^set[A-Z]/;
 const RENDER_FUNCTION_PATTERN = /^render[A-Z]/;
 const UPPERCASE_PATTERN = /^[A-Z]/;
@@ -17999,14 +18012,6 @@ const findRenderPhaseComponentOrHook = (node, scopes) => {
 //#region src/plugin/utils/is-event-handler-attribute.ts
 const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
 //#endregion
-//#region src/plugin/utils/is-early-exit-statement.ts
-const isEarlyExitStatement$1 = (statement) => {
-	if (!statement) return false;
-	if (statementAlwaysExits$1(statement)) return true;
-	if (isNodeOfType(statement, "BlockStatement")) return isEarlyExitStatement$1(statement.body.at(-1));
-	return isNodeOfType(statement, "ContinueStatement") || isNodeOfType(statement, "BreakStatement");
-};
-//#endregion
 //#region src/plugin/utils/is-ast-descendant.ts
 /**
 * True when `inner` is `outer` itself or any descendant in the AST
@@ -18225,15 +18230,13 @@ const isSynchronousIteratorCall = (callNode, callbackArgument, scopes) => {
 	}
 	return Boolean(methodName && EAGER_ITERATOR_METHOD_NAMES.has(methodName) && callNode.arguments[0] === callbackArgument && !isProvablyEmptyEagerCollection(callee.object, scopes) && (methodName === "forEach" ? isProvablyEagerForEachCollection(callee.object, scopes) : isProvablyEagerCollection(callee.object, scopes)));
 };
-const isSynchronousIteratorCallbackCall = (callNode, callbackArgument) => {
-	const callee = stripParenExpression(callNode.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
-	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from") return callNode.arguments[1] === callbackArgument;
-	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$2.has(callee.property.name) && callNode.arguments[0] === callbackArgument;
-};
 const isSynchronousIteratorCallback = (functionNode) => {
 	const callNode = functionNode.parent;
-	return Boolean(isNodeOfType(callNode, "CallExpression") && isSynchronousIteratorCallbackCall(callNode, functionNode));
+	if (!isNodeOfType(callNode, "CallExpression")) return false;
+	const callee = stripParenExpression(callNode.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
+	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from") return callNode.arguments[1] === functionNode;
+	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$2.has(callee.property.name) && callNode.arguments[0] === functionNode;
 };
 //#endregion
 //#region src/plugin/utils/is-within-assignment-target.ts
@@ -18353,35 +18356,11 @@ const resolveEventListenerCaptureValueIdentityKey = (expression, context) => {
 	const rightIdentityKey = resolveEventListenerCaptureValueIdentityKey(unwrappedExpression.right, context);
 	return leftIdentityKey && rightIdentityKey ? `${unwrappedExpression.type}:${unwrappedExpression.operator}:${leftIdentityKey}:${rightIdentityKey}` : null;
 };
-const resolveReadOnlyEventListenerOptions = (optionsNode, context) => {
-	const unwrappedOptions = stripParenExpression(optionsNode);
-	if (!isNodeOfType(unwrappedOptions, "Identifier")) return resolveStableValue(unwrappedOptions, context);
-	const optionsSymbol = context.scopes.symbolFor(unwrappedOptions);
-	const initializer = optionsSymbol?.initializer ? stripParenExpression(optionsSymbol.initializer) : null;
-	if (!optionsSymbol || !initializer) return resolveStableValue(unwrappedOptions, context);
-	if (!isNodeOfType(initializer, "ObjectExpression")) {
-		if (isNodeOfType(initializer, "Identifier") || isNodeOfType(initializer, "MemberExpression")) return null;
-		return resolveStableValue(unwrappedOptions, context);
-	}
-	if (optionsSymbol.kind !== "const") return null;
-	return optionsSymbol.references.every((reference) => {
-		if (reference.flag !== "read" || isWithinAssignmentTarget(reference.identifier)) return false;
-		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-		const callNode = referenceRoot.parent;
-		if (!isNodeOfType(callNode, "CallExpression") || callNode.arguments[2] !== referenceRoot) return false;
-		const callee = stripParenExpression(callNode.callee);
-		if (!isNodeOfType(callee, "MemberExpression")) return false;
-		const methodName = getStaticPropertyKeyName(callee);
-		return methodName === "addEventListener" || methodName === "removeEventListener";
-	}) ? initializer : null;
-};
 const resolveEventListenerCaptureIdentityKey = (optionsNode, context, allowOpaqueOptionsIdentity) => {
-	const stableOptionsNode = optionsNode ? resolveReadOnlyEventListenerOptions(optionsNode, context) : null;
-	if (optionsNode && !stableOptionsNode) return null;
-	const capture = resolveEventListenerCapture(stableOptionsNode, { allowIndeterminateEntries: true });
+	const capture = resolveEventListenerCapture(optionsNode, { allowIndeterminateEntries: true });
 	if (capture !== null) return `capture:${String(capture)}`;
-	if (!stableOptionsNode) return null;
-	const unwrappedOptions = stripParenExpression(stableOptionsNode);
+	if (!optionsNode) return null;
+	const unwrappedOptions = stripParenExpression(optionsNode);
 	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) {
 		const optionsKey = allowOpaqueOptionsIdentity ? resolveEventListenerCaptureValueIdentityKey(unwrappedOptions, context) : null;
 		return optionsKey ? `options:${optionsKey}` : null;
@@ -18428,8 +18407,12 @@ const doEventListenerCapturesMatch = (registrationOptions, releaseOptions, conte
 	return registrationCaptureKey !== null && registrationCaptureKey === resolveEventListenerCaptureIdentityKey(releaseOptions, context, allowOpaqueOptionsIdentity);
 };
 const findAssignedResourceKey = (resourceNode, context) => {
-	const currentNode = findTransparentExpressionRoot(resourceNode);
-	const parentNode = currentNode.parent;
+	let currentNode = resourceNode;
+	let parentNode = currentNode.parent;
+	while (isNodeOfType(parentNode, "ChainExpression")) {
+		currentNode = parentNode;
+		parentNode = currentNode.parent;
+	}
 	if (isNodeOfType(parentNode, "VariableDeclarator") && parentNode.init === currentNode) return resolveExpressionKey(parentNode.id, context);
 	if (isNodeOfType(parentNode, "AssignmentExpression") && parentNode.right === currentNode) return resolveExpressionKey(parentNode.left, context);
 	return null;
@@ -18700,18 +18683,6 @@ const resolveIteratorCollectionKey = (expression, context) => {
 	}
 	return null;
 };
-const resolveReceiverIteratorCollectionKey = (expression, context) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
-	const collectionExpression = findForOfStatementForIteratorExpression(unwrappedExpression, context)?.right;
-	if (!collectionExpression) return null;
-	const collectionIdentifier = stripParenExpression(collectionExpression);
-	if (!isNodeOfType(collectionIdentifier, "Identifier") || !isPrivatePlainConstIdentifier(collectionIdentifier, context)) return null;
-	const collectionSymbol = context.scopes.symbolFor(collectionIdentifier);
-	const initializer = collectionSymbol?.initializer ? stripParenExpression(collectionSymbol.initializer) : null;
-	return collectionSymbol && isNodeOfType(initializer, "ArrayExpression") && hasOnlyReplayableCollectionReferences(collectionIdentifier, context, /* @__PURE__ */ new Set()) ? `symbol:${collectionSymbol.id}` : null;
-};
 const isStableLoopReceiver = (expression, context) => {
 	if (!expression) return false;
 	const unwrappedExpression = stripParenExpression(expression);
@@ -19482,28 +19453,6 @@ const isFunctionReturnedFromReactHook = (functionNode, context, requireRefProper
 	});
 };
 const isFunctionUsedAsReactRef = (functionNode, context) => isFunctionForwardedToReactRef(functionNode, context) || isFunctionReturnedFromReactHook(functionNode, context, true);
-const findCallbackRefReplacementReleaseGuard = (releaseCall, ownerFunction, releaseReceiverKey, registrationReceiverKey, context) => {
-	let descendant = releaseCall;
-	let ancestor = descendant.parent;
-	while (ancestor && ancestor !== ownerFunction) {
-		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant && ancestor.alternate === null) {
-			const test = stripParenExpression(ancestor.test);
-			if (!isNodeOfType(test, "LogicalExpression") || test.operator !== "&&") return null;
-			const operands = [stripParenExpression(test.left), stripParenExpression(test.right)];
-			const hasLiveReceiverTest = operands.some((operand) => doesTestRequireLiveExpressionKey(operand, releaseReceiverKey, context));
-			const hasDifferentReceiverTest = operands.some((operand) => {
-				if (!isNodeOfType(operand, "BinaryExpression") || operand.operator !== "!==" && operand.operator !== "!=") return false;
-				const leftKey = resolveExpressionKey(operand.left, context);
-				const rightKey = resolveExpressionKey(operand.right, context);
-				return leftKey === releaseReceiverKey && rightKey === registrationReceiverKey || rightKey === releaseReceiverKey && leftKey === registrationReceiverKey;
-			});
-			return hasLiveReceiverTest && hasDifferentReceiverTest ? ancestor : null;
-		}
-		descendant = ancestor;
-		ancestor = descendant.parent;
-	}
-	return null;
-};
 const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
 	if (!isNodeOfType(usage.node, "CallExpression")) return false;
 	const usageFunction = findEnclosingFunction$1(usage.node);
@@ -19524,7 +19473,7 @@ const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
 		if (child !== usageFunctionBody && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "AssignmentExpression") && child.operator === "=" && resolveReactRefSymbol(stripParenExpression(child.left), context.scopes)?.id === releaseRefSymbol.id && resolveExpressionKey(child.right, context) === registrationReceiverKey && releaseStart !== null && (getRangeStart(child) ?? -1) > releaseStart) matchingOwnershipAssignments.push(child);
 	});
-	const releaseAnchor = findLiveExpressionGuardForRelease(releaseCall, usageFunction, releaseReceiverKey, context) ?? findCallbackRefReplacementReleaseGuard(releaseCall, usageFunction, releaseReceiverKey, registrationReceiverKey, context) ?? releaseCall;
+	const releaseAnchor = findLiveExpressionGuardForRelease(releaseCall, usageFunction, releaseReceiverKey, context) ?? releaseCall;
 	const safeOwnershipAssignments = matchingOwnershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, [releaseAnchor], usageFunction, context));
 	return doNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
 };
@@ -19674,21 +19623,14 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (usage.kind === "socket") return usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (SOCKET_RELEASE_VERB_NAMES.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName));
 	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 (usage.registrationVerbName === "addListener" && isNodeOfType(usage.node, "CallExpression") && usage.node.arguments?.length === 1) return isProvenLegacyMediaQueryListMethodCall(usage.node, "addListener", context) && releaseVerbName === "removeListener" && isProvenLegacyMediaQueryListMethodCall(callNode, "removeListener", context) && usage.receiverKey !== null && resolveStableMediaQueryListenerIdentityKey(callee.object, context) === usage.receiverKey && usage.handlerKey !== null && resolveStableMediaQueryListenerIdentityKey(callNode.arguments?.[0], context) === usage.handlerKey;
 	if (releaseVerbName === "abort" && isRetainedAbortControllerRefRelease(callee.object, usage, context)) return true;
-	if (usage.registrationVerbName === "addListener" && releaseVerbName === "removeListener" && isNodeOfType(usage.node, "CallExpression") && usage.node.arguments?.length === 1) {
-		if (callNode.arguments?.length !== 1) return false;
-		const registrationHandler = resolveStableValue(usage.node.arguments[0], context);
-		if (!isProvenLegacyMediaQueryListMethodCall(usage.node, "addListener", context) && !isFunctionLike$1(registrationHandler)) return false;
-	}
 	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;
-	const registrationCallee = isNodeOfType(usage.node, "CallExpression") ? stripParenExpression(usage.node.callee) : null;
-	const registrationReceiverCollectionKey = isNodeOfType(registrationCallee, "MemberExpression") ? resolveReceiverIteratorCollectionKey(registrationCallee.object, context) : null;
-	const releaseReceiverCollectionKeyForPair = resolveReceiverIteratorCollectionKey(callee.object, context);
-	if (!(registrationReceiverCollectionKey !== null && registrationReceiverCollectionKey === releaseReceiverCollectionKeyForPair) && (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey)) 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;
 	if (!pairedVerbNames || !matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return false;
@@ -19725,7 +19667,7 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 		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 = usesUnaryListenerSignatureForCalls ? usage.handlerKey ?? usage.eventKey : usage.handlerKey;
+		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);
 	}
@@ -20199,7 +20141,6 @@ const findRetainedFunctionLeak = (retainedFunction, context, options) => {
 	walkAst(body, (child) => {
 		if (leak !== null) return false;
 		if (isFunctionLike$1(child)) return false;
-		if (!isNodeReachableWithinFunction(child, context)) return false;
 		if (isSocketConstruction(child) && !doesResourceResultEscape(child, allowReturnedSocketEscape, false, context)) {
 			const socketUsage = {
 				kind: "socket",
@@ -20452,164 +20393,6 @@ const isInlineRetainedHandlerFunction = (functionNode, context) => {
 	const objectParent = objectExpression.parent;
 	return (isNodeOfType(objectParent, "CallExpression") && objectParent.arguments.some((argument) => argument === objectExpression) || isNodeOfType(objectParent, "JSXExpressionContainer")) && findRenderPhaseComponentOrHook(parentNode, context.scopes) !== null;
 };
-const readInvocationArgumentValue = (expression, context) => {
-	if (!expression) return {
-		isDefinitelyUndefined: true,
-		truthiness: "falsy"
-	};
-	const target = stripParenExpression(expression);
-	if (isNodeOfType(target, "Literal")) return {
-		isDefinitelyUndefined: false,
-		truthiness: target.value ? "truthy" : "falsy"
-	};
-	if (isNodeOfType(target, "Identifier") && target.name === "undefined" && context.scopes.isGlobalReference(target)) return {
-		isDefinitelyUndefined: true,
-		truthiness: "falsy"
-	};
-	if (isNodeOfType(target, "UnaryExpression") && target.operator === "void") return {
-		isDefinitelyUndefined: true,
-		truthiness: "falsy"
-	};
-	if (isNodeOfType(target, "ArrayExpression") || isNodeOfType(target, "ArrowFunctionExpression") || isNodeOfType(target, "ClassExpression") || isNodeOfType(target, "FunctionExpression") || isNodeOfType(target, "NewExpression") || isNodeOfType(target, "ObjectExpression")) return {
-		isDefinitelyUndefined: false,
-		truthiness: "truthy"
-	};
-	return {
-		isDefinitelyUndefined: false,
-		truthiness: "unknown"
-	};
-};
-const readInvocationConditionTruthiness = (expression, parameterValues, context) => {
-	const target = stripParenExpression(expression);
-	const atomicValue = readInvocationArgumentValue(target, context);
-	if (atomicValue.truthiness !== "unknown") return atomicValue.truthiness;
-	if (isNodeOfType(target, "Identifier")) {
-		const symbol = context.scopes.symbolFor(target);
-		return symbol ? parameterValues.get(symbol.id)?.truthiness ?? "unknown" : "unknown";
-	}
-	if (isNodeOfType(target, "UnaryExpression") && target.operator === "!") {
-		const argumentTruthiness = readInvocationConditionTruthiness(target.argument, parameterValues, context);
-		return argumentTruthiness === "truthy" ? "falsy" : argumentTruthiness === "falsy" ? "truthy" : "unknown";
-	}
-	if (isNodeOfType(target, "LogicalExpression")) {
-		const leftTruthiness = readInvocationConditionTruthiness(target.left, parameterValues, context);
-		const rightTruthiness = readInvocationConditionTruthiness(target.right, parameterValues, context);
-		if (target.operator === "&&") {
-			if (leftTruthiness === "falsy" || rightTruthiness === "falsy") return "falsy";
-			return leftTruthiness === "truthy" && rightTruthiness === "truthy" ? "truthy" : "unknown";
-		}
-		if (target.operator === "||") {
-			if (leftTruthiness === "truthy" || rightTruthiness === "truthy") return "truthy";
-			return leftTruthiness === "falsy" && rightTruthiness === "falsy" ? "falsy" : "unknown";
-		}
-		return "unknown";
-	}
-	if (isNodeOfType(target, "ConditionalExpression")) {
-		const testTruthiness = readInvocationConditionTruthiness(target.test, parameterValues, context);
-		if (testTruthiness === "truthy") return readInvocationConditionTruthiness(target.consequent, parameterValues, context);
-		if (testTruthiness === "falsy") return readInvocationConditionTruthiness(target.alternate, parameterValues, context);
-		const consequentTruthiness = readInvocationConditionTruthiness(target.consequent, parameterValues, context);
-		return consequentTruthiness === readInvocationConditionTruthiness(target.alternate, parameterValues, context) ? consequentTruthiness : "unknown";
-	}
-	if (isNodeOfType(target, "CallExpression") && isNodeOfType(target.callee, "Identifier") && target.callee.name === "Boolean" && context.scopes.isGlobalReference(target.callee) && target.arguments[0] && isAstNode(target.arguments[0])) return readInvocationConditionTruthiness(target.arguments[0], parameterValues, context);
-	return "unknown";
-};
-const getInvocationParameterValues = (retainedFunction, invocation, leakNode, context) => {
-	const parameterValues = /* @__PURE__ */ new Map();
-	if (!isFunctionLike$1(retainedFunction) || !invocation.isDirect) return parameterValues;
-	for (const [parameterIndex, parameter] of retainedFunction.params.entries()) {
-		const argument = invocation.call.arguments[parameterIndex];
-		const argumentExpression = argument && isAstNode(argument) ? argument : null;
-		let parameterIdentifier = null;
-		let parameterValue = readInvocationArgumentValue(argumentExpression, context);
-		if (isNodeOfType(parameter, "Identifier")) parameterIdentifier = parameter;
-		else if (isNodeOfType(parameter, "AssignmentPattern") && isNodeOfType(parameter.left, "Identifier")) {
-			parameterIdentifier = parameter.left;
-			if (parameterValue.isDefinitelyUndefined) parameterValue = readInvocationArgumentValue(parameter.right, context);
-		} else if (isNodeOfType(parameter, "RestElement") && isNodeOfType(parameter.argument, "Identifier")) {
-			parameterIdentifier = parameter.argument;
-			parameterValue = {
-				isDefinitelyUndefined: false,
-				truthiness: "truthy"
-			};
-		}
-		if (!parameterIdentifier) continue;
-		const parameterSymbol = context.scopes.symbolFor(parameterIdentifier);
-		if (!parameterSymbol) continue;
-		const isWrittenBeforeLeak = parameterSymbol.references.some((reference) => reference.flag !== "read" && reference.identifier.range[0] < leakNode.range[0]);
-		parameterValues.set(parameterSymbol.id, isWrittenBeforeLeak ? {
-			isDefinitelyUndefined: false,
-			truthiness: "unknown"
-		} : parameterValue);
-	}
-	return parameterValues;
-};
-const isLeakPathDisabledForInvocation = (retainedFunction, leakNode, invocation, context) => {
-	if (!invocation.isDirect) return false;
-	const parameterValues = getInvocationParameterValues(retainedFunction, invocation, leakNode, context);
-	let child = leakNode;
-	let ancestor = leakNode.parent ?? null;
-	while (ancestor && ancestor !== retainedFunction) {
-		if (isNodeOfType(ancestor, "BlockStatement")) {
-			const childIndex = ancestor.body.findIndex((statement) => statement === child);
-			for (const precedingStatement of ancestor.body.slice(0, childIndex)) {
-				if (!isNodeOfType(precedingStatement, "IfStatement") || precedingStatement.alternate || !isEarlyExitStatement$1(precedingStatement.consequent)) continue;
-				if (readInvocationConditionTruthiness(precedingStatement.test, parameterValues, context) === "truthy") return true;
-			}
-		}
-		let requiredTruthiness = null;
-		let condition = null;
-		if (isNodeOfType(ancestor, "IfStatement")) {
-			condition = ancestor.test;
-			requiredTruthiness = ancestor.consequent === child ? "truthy" : "falsy";
-		} else if (isNodeOfType(ancestor, "ConditionalExpression")) {
-			condition = ancestor.test;
-			requiredTruthiness = ancestor.consequent === child ? "truthy" : "falsy";
-		} else if (isNodeOfType(ancestor, "LogicalExpression") && ancestor.right === child && ancestor.operator !== "??") {
-			condition = ancestor.left;
-			requiredTruthiness = ancestor.operator === "&&" ? "truthy" : "falsy";
-		} else if ((isNodeOfType(ancestor, "WhileStatement") || isNodeOfType(ancestor, "DoWhileStatement")) && ancestor.body === child) {
-			condition = ancestor.test;
-			requiredTruthiness = "truthy";
-		} else if (isNodeOfType(ancestor, "ForStatement") && ancestor.body === child && ancestor.test) {
-			condition = ancestor.test;
-			requiredTruthiness = "truthy";
-		}
-		if (condition && requiredTruthiness) {
-			const conditionTruthiness = readInvocationConditionTruthiness(condition, parameterValues, context);
-			if (conditionTruthiness !== "unknown" && conditionTruthiness !== requiredTruthiness) return true;
-		}
-		child = ancestor;
-		ancestor = ancestor.parent ?? null;
-	}
-	return false;
-};
-const getEffectRetainedInvocations = (retainedFunction, context) => {
-	if (!isFunctionLike$1(retainedFunction)) return [];
-	const componentFunction = findEnclosingFunction$1(retainedFunction);
-	if (!componentFunction || !isFunctionLike$1(componentFunction)) return [];
-	const invocations = [];
-	walkAst(componentFunction.body, (child) => {
-		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction || !isReactHookCall(child, CLEANUP_EFFECT_HOOK_NAMES, context.scopes)) return;
-		const effectCallback = getEffectCallback(child);
-		if (!effectCallback || !isFunctionLike$1(effectCallback)) return;
-		walkAst(effectCallback.body, (effectChild) => {
-			if (effectChild !== effectCallback.body && isFunctionLike$1(effectChild)) return false;
-			if (!isNodeOfType(effectChild, "CallExpression") || !isNodeReachableWithinFunction(effectChild, context)) return;
-			const isDirectInvocation = resolveRefOwnedCleanupFunction(effectChild.callee, context) === retainedFunction;
-			const isSynchronousIteratorInvocation = effectChild.arguments.some((argument) => isAstNode(argument) && resolveRefOwnedCleanupFunction(argument, context) === retainedFunction && isSynchronousIteratorCallbackCall(effectChild, argument));
-			if (isDirectInvocation) invocations.push({
-				call: effectChild,
-				isDirect: true
-			});
-			if (isSynchronousIteratorInvocation) invocations.push({
-				call: effectChild,
-				isDirect: false
-			});
-		});
-	});
-	return invocations;
-};
 const effectNeedsCleanup = defineRule({
 	id: "effect-needs-cleanup",
 	title: "Effect subscription or timer never cleaned up",
@@ -20620,19 +20403,13 @@ const effectNeedsCleanup = defineRule({
 		const reportRetainedLeak = (retainedFunction) => {
 			const refEffectUsage = getReactRefEffectUsage(retainedFunction, context);
 			if (!refEffectUsage && !isPotentiallyReachableFunction(retainedFunction, context)) return;
-			const effectInvocations = getEffectRetainedInvocations(retainedFunction, context);
-			const isEffectInvoked = effectInvocations.length > 0;
 			const leak = findRetainedFunctionLeak(retainedFunction, context, refEffectUsage ? {
 				allowReturnedResourceEscape: refEffectUsage.doesEffectOwnEveryResult,
 				allowReturnedTimerEscape: false,
 				includeOneShotTimers: true,
 				requireCallableReturnedResource: true
-			} : isEffectInvoked ? {
-				allowReturnedTimerEscape: false,
-				includeOneShotTimers: true
 			} : void 0);
 			if (!leak) return;
-			if (isEffectInvoked && leak.resourceName === "setTimeout" && (!isNodeReachableWithinFunction(leak.node, context) || isFunctionLike$1(retainedFunction) && retainedFunction.params.length > 0 && !context.cfg.isUnconditionalFromEntry(leak.node) && effectInvocations.every((invocation) => isLeakPathDisabledForInvocation(retainedFunction, leak.node, invocation, context)))) return;
 			const resourceNoun = RESOURCE_NOUN_BY_KIND[leak.kind];
 			context.report({
 				node: leak.node,
@@ -29461,11 +29238,6 @@ const jsCacheStorage = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/js-combine-iterations.ts
-const SMALL_ARRAY_NON_MUTATING_METHODS = new Set([
-	...CHAINABLE_ITERATION_METHODS,
-	"find",
-	"some"
-]);
 const isIteratorProducingCall = (callExpression, generatorNamesInFile) => {
 	const callee = callExpression.callee;
 	if (isNodeOfType(callee, "MemberExpression")) {
@@ -29577,34 +29349,21 @@ const isStringSplitRootedChain = (receiverNode) => {
 	return false;
 };
 const isSmallLiteralArray = (node) => {
-	const arrayNode = stripParenExpression(node);
-	if (!isNodeOfType(arrayNode, "ArrayExpression")) return false;
-	const elements = arrayNode.elements ?? [];
-	if (elements.length === 0 || elements.length > 9) return false;
+	if (!isNodeOfType(node, "ArrayExpression")) return false;
+	const elements = node.elements ?? [];
+	if (elements.length === 0 || elements.length > 8) return false;
 	for (const element of elements) {
 		if (!element) continue;
 		if (isNodeOfType(element, "SpreadElement")) return false;
 	}
 	return true;
 };
-const isNonMutatingSmallArrayMethodReference = (identifier) => {
-	const identifierRoot = findTransparentExpressionRoot(identifier);
-	const memberExpression = identifierRoot.parent;
-	if (!isNodeOfType(memberExpression, "MemberExpression") || memberExpression.object !== identifierRoot || !isNodeOfType(memberExpression.property, "Identifier") || !SMALL_ARRAY_NON_MUTATING_METHODS.has(memberExpression.property.name)) return false;
-	const callExpression = memberExpression.parent;
-	return isNodeOfType(callExpression, "CallExpression") && callExpression.callee === memberExpression;
-};
-const isSmallLiteralArrayRootedChain = (receiverNode, scopes) => {
+const isSmallLiteralArrayRootedChain = (receiverNode, smallConstArrayNames) => {
 	let cursor = receiverNode;
 	while (cursor) {
 		cursor = stripParenExpression(cursor);
 		if (isNodeOfType(cursor, "ArrayExpression")) return isSmallLiteralArray(cursor);
-		if (isNodeOfType(cursor, "Identifier")) {
-			const symbol = scopes.symbolFor(cursor);
-			if (!symbol?.initializer || !isSmallLiteralArray(symbol.initializer)) return false;
-			if (!isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier")) return false;
-			return (symbol.kind === "const" || symbol.kind === "let" || symbol.kind === "var") && symbol.references.every((reference) => reference.flag === "read" && isNonMutatingSmallArrayMethodReference(reference.identifier));
-		}
+		if (isNodeOfType(cursor, "Identifier")) return smallConstArrayNames.has(cursor.name);
 		if (!isNodeOfType(cursor, "CallExpression")) return false;
 		if (!isChainPassThroughCall(cursor)) return false;
 		const nextCallee = cursor.callee;
@@ -29613,6 +29372,22 @@ const isSmallLiteralArrayRootedChain = (receiverNode, scopes) => {
 	}
 	return false;
 };
+const collectSmallConstArrayNames = (programNode) => {
+	const names = /* @__PURE__ */ new Set();
+	const statements = programNode.body ?? [];
+	for (const statement of statements) {
+		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
+		if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) continue;
+		if (declaration.kind !== "const") continue;
+		for (const declarator of declaration.declarations ?? []) {
+			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			if (!declarator.init || !isSmallLiteralArray(declarator.init)) continue;
+			names.add(declarator.id.name);
+		}
+	}
+	return names;
+};
 const collectGeneratorNames = (programNode) => {
 	const generatorNames = /* @__PURE__ */ new Set();
 	walkAst(programNode, (child) => {
@@ -29633,11 +29408,16 @@ const jsCombineIterations = defineRule({
 	create: (context) => {
 		let programNode = null;
 		let generatorNamesInFile = null;
+		let smallConstArrayNames = null;
 		const coveredChainCalls = /* @__PURE__ */ new WeakSet();
 		const getGeneratorNamesInFile = () => {
 			generatorNamesInFile ??= programNode ? collectGeneratorNames(programNode) : /* @__PURE__ */ new Set();
 			return generatorNamesInFile;
 		};
+		const getSmallConstArrayNames = () => {
+			smallConstArrayNames ??= programNode ? collectSmallConstArrayNames(programNode) : /* @__PURE__ */ new Set();
+			return smallConstArrayNames;
+		};
 		return {
 			Program(node) {
 				programNode = node;
@@ -29667,7 +29447,7 @@ const jsCombineIterations = defineRule({
 					if (isTypePredicateArrow(filterArgument)) return;
 				}
 				if (isReceiverChainIteratorRooted(innerCall.callee.object, getGeneratorNamesInFile())) return;
-				if (isSmallLiteralArrayRootedChain(innerCall.callee.object, context.scopes)) return;
+				if (isSmallLiteralArrayRootedChain(innerCall.callee.object, getSmallConstArrayNames())) return;
 				if (isStringSplitRootedChain(innerCall.callee.object)) return;
 				coveredChainCalls.add(innerCall);
 				context.report({
@@ -45600,6 +45380,14 @@ const noAriaInvalidWithoutDescription = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-early-exit-statement.ts
+const isEarlyExitStatement$1 = (statement) => {
+	if (!statement) return false;
+	if (statementAlwaysExits$1(statement)) return true;
+	if (isNodeOfType(statement, "BlockStatement")) return isEarlyExitStatement$1(statement.body.at(-1));
+	return isNodeOfType(statement, "ContinueStatement") || isNodeOfType(statement, "BreakStatement");
+};
+//#endregion
 //#region src/plugin/utils/unwrap-negative-guard-form.ts
 const unwrapNegativeGuardForm = (test) => {
 	const expression = stripParenExpression(test);
@@ -56087,9 +55875,6 @@ const isInitialOnlyPropName = (propName) => {
 	return /^initial[A-Z]/.test(propName) || /^default[A-Z]/.test(propName) || /^seed[A-Z]/.test(propName) || /^starting[A-Z]/.test(propName) || /^baseline[A-Z]/.test(propName) || /^preset[A-Z]/.test(propName);
 };
 //#endregion
-//#region src/plugin/utils/nextjs-page-data-export-names.ts
-const NEXTJS_PAGE_DATA_EXPORT_NAMES = new Set(["getServerSideProps", "getStaticProps"]);
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-derived-use-state.ts
 const isInitialOnlySeedName = (propName) => isInitialOnlyPropName(propName) || propName === "initial" || propName === "autoFocus" || propName === "autoPlay" || propName === "startOpen" || /^initially[A-Z]/.test(propName) || /Initial([A-Z]|$)/.test(propName);
 const SNAPSHOT_STATE_NAME_PATTERN = /^(initial|previous|prev|preserved|saved|original|cached|snapshot|prior|debounced|deferred)([A-Z_]|$)/;
@@ -56246,6 +56031,7 @@ const isDraftCommittedToParent = (componentFunction, stateValueName, isPropName)
 	});
 	return isCommitted;
 };
+const NEXTJS_PAGE_DATA_EXPORT_NAMES = new Set(["getServerSideProps", "getStaticProps"]);
 const isNextjsDataFetchingPage = (node) => {
 	const program = findProgramRoot(node);
 	if (!program) return false;
@@ -67190,124 +66976,6 @@ const isInsideSnapshotHelper = (node) => {
 	}
 	return false;
 };
-const findEnclosingNextjsPageDataFunction = (node) => {
-	let outermostFunction = null;
-	let cursor = node.parent;
-	while (cursor) {
-		if (isFunctionLike$1(cursor)) outermostFunction = cursor;
-		if (isNodeOfType(cursor, "Program")) {
-			if (!outermostFunction) return null;
-			for (const exportName of NEXTJS_PAGE_DATA_EXPORT_NAMES) {
-				const exportedValue = findExportedValue(cursor, exportName);
-				if (exportedValue && isAstDescendant(outermostFunction, exportedValue)) return outermostFunction;
-			}
-			return null;
-		}
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-const findConditionalReturnExpressionRoot = (node) => {
-	let expressionRoot = findTransparentExpressionRoot(node);
-	while (expressionRoot.parent && isNodeOfType(expressionRoot.parent, "ConditionalExpression") && (expressionRoot.parent.consequent === expressionRoot || expressionRoot.parent.alternate === expressionRoot)) expressionRoot = findTransparentExpressionRoot(expressionRoot.parent);
-	return expressionRoot;
-};
-const isReturnedPageDataResultBinding = (returnExpression, pageDataFunction, context) => {
-	const declarator = returnExpression.parent;
-	if (!isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== returnExpression || !isNodeOfType(declarator.id, "Identifier") || findEnclosingFunction$1(declarator) !== pageDataFunction) return false;
-	const bindingSymbol = context.scopes.symbolFor(declarator.id);
-	if (!bindingSymbol || bindingSymbol.references.length !== 1) return false;
-	const referenceRoot = findTransparentExpressionRoot(bindingSymbol.references[0].identifier);
-	const returnStatement = referenceRoot.parent;
-	return isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument === referenceRoot && findEnclosingFunction$1(returnStatement) === pageDataFunction;
-};
-const isSameShorthandPropertyValue = (node, property) => property.shorthand && (node === property.key || node === property.value);
-const isValueForwardedThroughLiteralStructure = (node, structure) => {
-	const strippedNode = stripParenExpression(node);
-	const strippedStructure = stripParenExpression(structure);
-	if (strippedNode === strippedStructure) return true;
-	if (isNodeOfType(strippedStructure, "ConditionalExpression")) return isValueForwardedThroughLiteralStructure(strippedNode, strippedStructure.consequent) || isValueForwardedThroughLiteralStructure(strippedNode, strippedStructure.alternate);
-	if (isNodeOfType(strippedStructure, "ArrayExpression")) return strippedStructure.elements.some((element) => element && !isNodeOfType(element, "SpreadElement") && isValueForwardedThroughLiteralStructure(strippedNode, element));
-	if (!isNodeOfType(strippedStructure, "ObjectExpression")) return false;
-	return strippedStructure.properties.some((property) => {
-		if (isNodeOfType(property, "SpreadElement")) return isValueForwardedThroughLiteralStructure(strippedNode, property.argument);
-		if (!isNodeOfType(property, "Property")) return false;
-		if (isValueForwardedThroughLiteralStructure(strippedNode, property.value)) return true;
-		return isSameShorthandPropertyValue(strippedNode, property);
-	});
-};
-const isValueForwardedToPropertyValue = (node, property) => {
-	const directValue = findConditionalReturnExpressionRoot(node);
-	if (isValueForwardedThroughLiteralStructure(directValue, property.value)) return true;
-	return isSameShorthandPropertyValue(directValue, property);
-};
-const isInsideReturnedNextjsProps = (node, pageDataFunction, context) => {
-	let cursor = node.parent;
-	while (cursor && cursor !== pageDataFunction) {
-		if (isNodeOfType(cursor, "Property") && getStaticPropertyKeyName(cursor, { allowComputedString: true }) === "props" && isValueForwardedToPropertyValue(node, cursor)) {
-			const propertyContainer = cursor.parent;
-			if (!propertyContainer) return false;
-			const returnExpression = findConditionalReturnExpressionRoot(propertyContainer);
-			const returnStatement = returnExpression.parent;
-			if (isNodeOfType(returnStatement, "ReturnStatement") && findEnclosingFunction$1(returnStatement) === pageDataFunction) return true;
-			if (isNodeOfType(pageDataFunction, "ArrowFunctionExpression") && !isNodeOfType(pageDataFunction.body, "BlockStatement") && stripParenExpression(pageDataFunction.body) === stripParenExpression(returnExpression)) return true;
-			if (isReturnedPageDataResultBinding(returnExpression, pageDataFunction, context)) return true;
-		}
-		cursor = cursor.parent ?? null;
-	}
-	return false;
-};
-const isExpressionReturnedByFunction = (node, functionNode) => {
-	const returnExpression = findConditionalReturnExpressionRoot(node);
-	if (isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode.body, "BlockStatement")) return stripParenExpression(functionNode.body) === stripParenExpression(returnExpression);
-	const returnStatement = returnExpression.parent;
-	return isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument === returnExpression && findEnclosingFunction$1(returnStatement) === functionNode;
-};
-const isValueForwardedToBindingInitializer = (node, bindingInitializer) => {
-	if (isValueForwardedThroughLiteralStructure(findConditionalReturnExpressionRoot(node), bindingInitializer)) return true;
-	const initializer = stripParenExpression(bindingInitializer);
-	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const callee = stripParenExpression(initializer.callee);
-	return isFunctionLike$1(callee) && isExpressionReturnedByFunction(node, callee);
-};
-const findPageDataResultBinding = (node) => {
-	let cursor = node.parent;
-	while (cursor) {
-		if (isNodeOfType(cursor, "VariableDeclarator")) {
-			if (cursor.init && isNodeOfType(cursor.id, "Identifier") && isValueForwardedToBindingInitializer(node, cursor.init)) return cursor.id;
-			return null;
-		}
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-const isUsedToSerializeNextjsPageProps = (node, context) => {
-	if (!isInProjectDirectory(context, "pages") || isInProjectDirectory(context, "pages/api")) return false;
-	const pageDataFunction = findEnclosingNextjsPageDataFunction(node);
-	if (!pageDataFunction) return false;
-	if (isInsideReturnedNextjsProps(node, pageDataFunction, context)) return true;
-	const bindingIdentifier = findPageDataResultBinding(node);
-	const bindingSymbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
-	if (!bindingSymbol) return false;
-	const aliasSymbols = collectConstAliasSymbols(bindingSymbol, context.scopes);
-	const aliasSymbolIds = new Set(aliasSymbols.map((aliasSymbol) => aliasSymbol.id));
-	let hasPagePropsReference = false;
-	for (const aliasSymbol of aliasSymbols) for (const reference of aliasSymbol.references) {
-		if (findEnclosingFunction$1(reference.identifier) !== pageDataFunction) return false;
-		if (isInsideReturnedNextjsProps(reference.identifier, pageDataFunction, context)) {
-			hasPagePropsReference = true;
-			continue;
-		}
-		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-		const declarator = referenceRoot.parent;
-		if (isNodeOfType(declarator, "VariableDeclarator") && declarator.init === referenceRoot && isNodeOfType(declarator.id, "Identifier")) {
-			const aliasSymbolForReference = context.scopes.symbolFor(declarator.id);
-			if (aliasSymbolForReference && aliasSymbolIds.has(aliasSymbolForReference.id)) continue;
-		}
-		return false;
-	}
-	return hasPagePropsReference;
-};
 const noJsonParseStringifyClone = defineRule({
 	id: "no-json-parse-stringify-clone",
 	title: "JSON parse/stringify deep clone",
@@ -67325,7 +66993,6 @@ const noJsonParseStringifyClone = defineRule({
 		if (isInsideSnapshotHelper(node)) return;
 		if (isAssignedToNormalizationBinding(node)) return;
 		if (isCatchParameterRoundTrip(firstArgument)) return;
-		if (isUsedToSerializeNextjsPageProps(node, context)) return;
 		context.report({
 			node,
 			message: MESSAGE$35
@@ -68741,77 +68408,6 @@ const isCancellationGuardTest = (test) => {
 	});
 	return matches;
 };
-const getReactRefCurrent = (expression, context) => {
-	const stripped = stripParenExpression(expression);
-	if (!isNodeOfType(stripped, "MemberExpression") || getStaticPropertyName(stripped) !== "current") return null;
-	const receiver = stripParenExpression(stripped.object);
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const binding = findVariableInitializer(receiver, receiver.name);
-	const initializer = binding?.initializer ? stripParenExpression(binding.initializer) : null;
-	return initializer && isNodeOfType(initializer, "CallExpression") && isReactApiCall(initializer, USE_REF_HOOK_NAMES$1, context.scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true
-	}) ? stripped : null;
-};
-const getStableOwnershipToken = (expression, context) => {
-	const stripped = stripParenExpression(expression);
-	if (!isNodeOfType(stripped, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(stripped);
-	const initializer = symbol?.initializer ? stripParenExpression(symbol.initializer) : null;
-	const isStableAsyncIdentity = Boolean(initializer && isNodeOfType(initializer, "ObjectExpression")) || Boolean(initializer && getReactRefCurrent(initializer, context)) || Boolean(initializer && isNodeOfType(initializer, "UpdateExpression") && initializer.operator === "++" && getReactRefCurrent(initializer.argument, context));
-	return symbol && symbol.kind === "const" && symbol.references.every((reference) => reference.flag === "read") && isStableAsyncIdentity ? stripped : null;
-};
-const getAsyncOwnershipComparison = (test, context) => {
-	const stripped = stripParenExpression(test);
-	if (!isNodeOfType(stripped, "BinaryExpression")) return null;
-	const leftRef = getReactRefCurrent(stripped.left, context);
-	const rightRef = getReactRefCurrent(stripped.right, context);
-	const leftToken = getStableOwnershipToken(stripped.left, context);
-	const rightToken = getStableOwnershipToken(stripped.right, context);
-	if (stripped.operator === "===" || stripped.operator === "==") {
-		if (leftRef && rightToken) return {
-			refCurrent: leftRef,
-			token: rightToken,
-			mode: "owns",
-			isOrdered: false
-		};
-		if (rightRef && leftToken) return {
-			refCurrent: rightRef,
-			token: leftToken,
-			mode: "owns",
-			isOrdered: false
-		};
-		return null;
-	}
-	if (stripped.operator === "!==" || stripped.operator === "!=") {
-		if (leftRef && rightToken) return {
-			refCurrent: leftRef,
-			token: rightToken,
-			mode: "lost",
-			isOrdered: false
-		};
-		if (rightRef && leftToken) return {
-			refCurrent: rightRef,
-			token: leftToken,
-			mode: "lost",
-			isOrdered: false
-		};
-		return null;
-	}
-	if (stripped.operator === "<=" && leftRef && rightToken) return {
-		refCurrent: leftRef,
-		token: rightToken,
-		mode: "owns",
-		isOrdered: true
-	};
-	if (stripped.operator === ">=" && rightRef && leftToken) return {
-		refCurrent: rightRef,
-		token: leftToken,
-		mode: "owns",
-		isOrdered: true
-	};
-	return null;
-};
 const dedupeCatchPathStates = (states) => {
 	const statesByKey = /* @__PURE__ */ new Map();
 	for (const state of states) statesByKey.set(`${Number(state.isCleared)}:${Number(state.isCancellationPath)}`, state);
@@ -69144,221 +68740,7 @@ const isInsideTryFinalizer = (node, tryStatement) => {
 	}
 	return false;
 };
-const getDirectBlockEntry = (node, functionNode) => {
-	let entry = node;
-	let cursor = node.parent;
-	while (cursor && cursor !== functionNode) {
-		if (isNodeOfType(cursor, "BlockStatement")) return {
-			block: cursor,
-			entry
-		};
-		entry = cursor;
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-const claimPrecedesTruthySet = (claimNode, truthySet, firstRiskyAwait, functionNode, context) => {
-	const claimStart = getNodeStart$1(claimNode);
-	if (claimStart === null || claimStart >= firstRiskyAwait.start || truthySet.start >= firstRiskyAwait.start) return false;
-	const claimEntry = getDirectBlockEntry(claimNode, functionNode);
-	const truthyEntry = getDirectBlockEntry(truthySet.node, functionNode);
-	if (!claimEntry || !truthyEntry || claimEntry.block !== truthyEntry.block) return false;
-	let claimCursor = claimNode.parent;
-	while (claimCursor && claimCursor !== claimEntry.block) {
-		if (isNodeOfType(claimCursor, "IfStatement") || isNodeOfType(claimCursor, "SwitchCase") || isNodeOfType(claimCursor, "ConditionalExpression") || isNodeOfType(claimCursor, "LogicalExpression") || isNodeOfType(claimCursor, "ForStatement") || isNodeOfType(claimCursor, "ForInStatement") || isNodeOfType(claimCursor, "ForOfStatement") || isNodeOfType(claimCursor, "WhileStatement") || isNodeOfType(claimCursor, "DoWhileStatement")) return false;
-		claimCursor = claimCursor.parent ?? null;
-	}
-	const claimIndex = claimEntry.block.body.findIndex((statement) => statement === claimEntry.entry);
-	const truthyIndex = claimEntry.block.body.findIndex((statement) => statement === truthyEntry.entry);
-	if (claimIndex === -1 || truthyIndex === -1 || claimIndex >= truthyIndex) return false;
-	return claimEntry.block.body.slice(claimIndex + 1, truthyIndex).every((statement) => !subtreeHasAbruptSynchronousOperation(statement, functionNode, context));
-};
-const getOwningFunction = (functionNode) => {
-	let ownerFunction = functionNode;
-	let cursor = functionNode.parent;
-	while (cursor) {
-		if (isFunctionLike$1(cursor)) ownerFunction = cursor;
-		cursor = cursor.parent ?? null;
-	}
-	return ownerFunction;
-};
-const isEffectInvalidationPairedWithReset = (writeNode, truthySets, context) => {
-	const truthyCall = truthySets[0]?.node;
-	if (!truthyCall || !isNodeOfType(truthyCall, "CallExpression")) return false;
-	const setter = getSetterBooleanValue(truthyCall, context);
-	if (!setter) return false;
-	let effectCallback = writeNode.parent;
-	while (effectCallback && !isFunctionLike$1(effectCallback)) effectCallback = effectCallback.parent ?? null;
-	if (!effectCallback || !isEffectCallback(effectCallback, context)) return false;
-	if (!isUnconditionallyExecutedWithinFunction(writeNode, effectCallback, context)) return false;
-	const writeEntry = getDirectBlockEntry(writeNode, effectCallback);
-	if (!writeEntry) return false;
-	let isPaired = false;
-	walkOwnFunctionScope(effectCallback, (candidate) => {
-		if (isPaired || !isNodeOfType(candidate, "CallExpression")) return;
-		const candidateSetter = getSetterBooleanValue(candidate, context);
-		if (candidateSetter?.setterKey !== setter.setterKey || candidateSetter.value || !isUnconditionallyExecutedWithinFunction(candidate, effectCallback, context)) return;
-		const resetEntry = getDirectBlockEntry(candidate, effectCallback);
-		if (!resetEntry || resetEntry.block !== writeEntry.block) return;
-		const writeIndex = writeEntry.block.body.findIndex((statement) => statement === writeEntry.entry);
-		const resetIndex = resetEntry.block.body.findIndex((statement) => statement === resetEntry.entry);
-		if (writeIndex === -1 || resetIndex === -1) return;
-		if (resetIndex <= writeIndex) {
-			isPaired = true;
-			return false;
-		}
-		isPaired = writeEntry.block.body.slice(writeIndex + 1, resetIndex).every((statement) => !subtreeHasAbruptSynchronousOperation(statement, effectCallback, context));
-		return isPaired ? false : void 0;
-	});
-	return isPaired;
-};
-const isUnconditionalReturnBranch = (statement) => {
-	if (isNodeOfType(statement, "ReturnStatement")) return true;
-	return Boolean(isNodeOfType(statement, "BlockStatement") && statement.body.length === 1 && isNodeOfType(statement.body[0], "ReturnStatement"));
-};
-const findSingleFlightSnapshotClaim = (tokenInitializer, functionNode, truthySets, firstRiskyAwait, resetNode, context) => {
-	const snapshotEntry = getDirectBlockEntry(tokenInitializer, functionNode);
-	const resetEntry = getDirectBlockEntry(resetNode, functionNode);
-	if (!snapshotEntry || !resetEntry) return null;
-	const claimCandidates = [];
-	const releaseCandidates = [];
-	walkOwnFunctionScope(functionNode, (candidate) => {
-		if (!isNodeOfType(candidate, "AssignmentExpression") || candidate.operator !== "=" || !getReactRefCurrent(candidate.left, context)) return;
-		const assignedValue = stripParenExpression(candidate.right);
-		if (!isNodeOfType(assignedValue, "Literal") || typeof assignedValue.value !== "boolean") return;
-		const candidateKey = serializeReferenceKey({
-			node: candidate.left,
-			scopes: context.scopes
-		});
-		if (!candidateKey) return;
-		if (!assignedValue.value) {
-			if (getDirectBlockEntry(candidate, functionNode)?.block === resetEntry.block) releaseCandidates.push(candidate);
-			return;
-		}
-		if (!truthySets.some((truthySet) => claimPrecedesTruthySet(candidate, truthySet, firstRiskyAwait, functionNode, context))) return;
-		const candidateEntry = getDirectBlockEntry(candidate, functionNode);
-		if (!candidateEntry || candidateEntry.block !== snapshotEntry.block) return;
-		const candidateIndex = candidateEntry.block.body.findIndex((statement) => statement === candidateEntry.entry);
-		const snapshotIndex = candidateEntry.block.body.findIndex((statement) => statement === snapshotEntry.entry);
-		if (candidateIndex === -1 || snapshotIndex === -1 || candidateIndex >= snapshotIndex) return;
-		const guardIndex = candidateEntry.block.body.findLastIndex((statement, statementIndex) => {
-			if (statementIndex >= candidateIndex || !isNodeOfType(statement, "IfStatement") || statement.alternate !== null || !isUnconditionalReturnBranch(statement.consequent)) return false;
-			return serializeReferenceKey({
-				node: stripParenExpression(statement.test),
-				scopes: context.scopes
-			}) === candidateKey;
-		});
-		if (guardIndex === -1 || !candidateEntry.block.body.slice(guardIndex + 1, candidateIndex).every((statement) => !subtreeHasAbruptSynchronousOperation(statement, functionNode, context))) return;
-		claimCandidates.push(candidate);
-	});
-	const claim = claimCandidates.find((claimCandidate) => {
-		const candidateKey = serializeReferenceKey({
-			node: claimCandidate.left,
-			scopes: context.scopes
-		});
-		return releaseCandidates.some((releaseCandidate) => serializeReferenceKey({
-			node: releaseCandidate.left,
-			scopes: context.scopes
-		}) === candidateKey);
-	});
-	if (!claim) return null;
-	const claimKey = serializeReferenceKey({
-		node: claim.left,
-		scopes: context.scopes
-	});
-	const release = releaseCandidates.find((releaseCandidate) => serializeReferenceKey({
-		node: releaseCandidate.left,
-		scopes: context.scopes
-	}) === claimKey);
-	if (!claimKey || !release) return null;
-	const releaseEntry = getDirectBlockEntry(release, functionNode);
-	if (!releaseEntry || releaseEntry.block !== resetEntry.block) return null;
-	const releaseIndex = resetEntry.block.body.findIndex((statement) => statement === releaseEntry.entry);
-	const resetIndex = resetEntry.block.body.findIndex((statement) => statement === resetEntry.entry);
-	if (releaseIndex === -1 || resetIndex === -1 || !resetEntry.block.body.slice(Math.min(releaseIndex, resetIndex) + 1, Math.max(releaseIndex, resetIndex)).every((statement) => !subtreeHasAbruptSynchronousOperation(statement, functionNode, context))) return null;
-	let didFindUnsafeWrite = false;
-	walkAst(getOwningFunction(functionNode), (candidate) => {
-		if (didFindUnsafeWrite || candidate === claim || candidate === release) return;
-		const writeTarget = isNodeOfType(candidate, "AssignmentExpression") ? candidate.left : isNodeOfType(candidate, "UpdateExpression") || isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "delete" ? candidate.argument : null;
-		if (writeTarget && serializeReferenceKey({
-			node: writeTarget,
-			scopes: context.scopes
-		}) === claimKey && !isEffectInvalidationPairedWithReset(candidate, truthySets, context)) didFindUnsafeWrite = true;
-	});
-	return didFindUnsafeWrite ? null : claim;
-};
-const findOwnershipClaim = (comparison, functionNode, truthySets, firstRiskyAwait, resetNode, context) => {
-	const refKey = serializeReferenceKey({
-		node: comparison.refCurrent,
-		scopes: context.scopes
-	});
-	const tokenKey = serializeReferenceKey({
-		node: comparison.token,
-		scopes: context.scopes
-	});
-	if (!refKey || !tokenKey) return null;
-	const candidates = [];
-	const tokenSymbol = context.scopes.symbolFor(comparison.token);
-	const tokenInitializer = tokenSymbol?.initializer ? stripParenExpression(tokenSymbol.initializer) : null;
-	if (comparison.isOrdered && !isNodeOfType(tokenInitializer, "UpdateExpression")) return null;
-	if (tokenInitializer && isNodeOfType(tokenInitializer, "UpdateExpression") && tokenInitializer.operator === "++" && serializeReferenceKey({
-		node: tokenInitializer.argument,
-		scopes: context.scopes
-	}) === refKey) candidates.push(tokenInitializer);
-	if (tokenInitializer && getReactRefCurrent(tokenInitializer, context) && serializeReferenceKey({
-		node: tokenInitializer,
-		scopes: context.scopes
-	}) === refKey) {
-		const singleFlightClaim = findSingleFlightSnapshotClaim(tokenInitializer, functionNode, truthySets, firstRiskyAwait, resetNode, context);
-		if (singleFlightClaim) candidates.push(singleFlightClaim);
-	}
-	if (tokenInitializer && isNodeOfType(tokenInitializer, "UpdateExpression")) {
-		const generationKey = serializeReferenceKey({
-			node: tokenInitializer.argument,
-			scopes: context.scopes
-		});
-		if (generationKey && generationKey === refKey) {
-			const ownerFunction = getOwningFunction(functionNode);
-			let didFindOtherGenerationWrite = false;
-			walkAst(ownerFunction, (candidate) => {
-				if (didFindOtherGenerationWrite || candidate === tokenInitializer) return;
-				const writeTarget = isNodeOfType(candidate, "AssignmentExpression") ? candidate.left : isNodeOfType(candidate, "UpdateExpression") || isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "delete" ? candidate.argument : null;
-				if (writeTarget && serializeReferenceKey({
-					node: writeTarget,
-					scopes: context.scopes
-				}) === generationKey && !isEffectInvalidationPairedWithReset(candidate, truthySets, context)) didFindOtherGenerationWrite = true;
-			});
-			if (didFindOtherGenerationWrite) return null;
-		}
-	}
-	walkOwnFunctionScope(functionNode, (candidate) => {
-		if (!isNodeOfType(candidate, "AssignmentExpression") || candidate.operator !== "=") return;
-		if (serializeReferenceKey({
-			node: candidate.left,
-			scopes: context.scopes
-		}) === refKey && serializeReferenceKey({
-			node: candidate.right,
-			scopes: context.scopes
-		}) === tokenKey) candidates.push(candidate);
-	});
-	const claim = candidates.find((candidate) => truthySets.some((truthySet) => claimPrecedesTruthySet(candidate, truthySet, firstRiskyAwait, functionNode, context)));
-	if (!claim) return null;
-	let didFindOtherWrite = false;
-	walkAst(getOwningFunction(functionNode), (candidate) => {
-		if (didFindOtherWrite || candidate === claim) return;
-		const writeTarget = isNodeOfType(candidate, "AssignmentExpression") ? candidate.left : isNodeOfType(candidate, "UpdateExpression") || isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "delete" ? candidate.argument : null;
-		if (writeTarget && serializeReferenceKey({
-			node: writeTarget,
-			scopes: context.scopes
-		}) === refKey && !isEffectInvalidationPairedWithReset(candidate, truthySets, context)) didFindOtherWrite = true;
-	});
-	return didFindOtherWrite ? null : claim;
-};
-const isClaimedOwnershipComparison = (test, expectedMode, functionNode, truthySets, firstRiskyAwait, resetNode, context) => {
-	const comparison = getAsyncOwnershipComparison(test, context);
-	return Boolean(comparison && comparison.mode === expectedMode && findOwnershipClaim(comparison, functionNode, truthySets, firstRiskyAwait, resetNode, context));
-};
-const hasLifecycleGuardWriteOutsideCleanup = (effectCallback, guardKey, acceptedAssignments, context) => {
+const hasLifecycleGuardWriteOutsideCleanup = (effectCallback, guardKey, acceptedCleanupAssignments, context) => {
 	let didFindOtherWrite = false;
 	walkAst(effectCallback, (candidate) => {
 		if (didFindOtherWrite) return false;
@@ -69366,7 +68748,7 @@ const hasLifecycleGuardWriteOutsideCleanup = (effectCallback, guardKey, accepted
 			if (serializeReferenceKey({
 				node: candidate.left,
 				scopes: context.scopes
-			}) === guardKey && !acceptedAssignments.has(candidate)) {
+			}) === guardKey && !acceptedCleanupAssignments.has(candidate)) {
 				didFindOtherWrite = true;
 				return false;
 			}
@@ -69382,103 +68764,48 @@ const hasLifecycleGuardWriteOutsideCleanup = (effectCallback, guardKey, accepted
 	});
 	return didFindOtherWrite;
 };
-const collectCleanupBackedLifecycleAssignments = (effectCallback, guardKey, context) => {
-	const acceptedAssignments = /* @__PURE__ */ new Set();
-	for (const cleanupFunction of collectReturnedCleanupFunctions(effectCallback, context.scopes)) walkOwnFunctionScope(cleanupFunction, (cleanupNode) => {
-		const assignedValue = isNodeOfType(cleanupNode, "AssignmentExpression") ? stripParenExpression(cleanupNode.right) : null;
-		if (!isNodeOfType(cleanupNode, "AssignmentExpression") || cleanupNode.operator !== "=" || !isNodeOfType(assignedValue, "Literal") || assignedValue.value !== false || serializeReferenceKey({
-			node: cleanupNode.left,
-			scopes: context.scopes
-		}) !== guardKey || !isUnconditionallyExecutedWithinFunction(cleanupNode, cleanupFunction, context)) return;
-		acceptedAssignments.add(cleanupNode);
-	});
-	if (acceptedAssignments.size === 0) return null;
-	walkOwnFunctionScope(effectCallback, (effectNode) => {
-		const assignedValue = isNodeOfType(effectNode, "AssignmentExpression") ? stripParenExpression(effectNode.right) : null;
-		if (isNodeOfType(effectNode, "AssignmentExpression") && effectNode.operator === "=" && isNodeOfType(assignedValue, "Literal") && assignedValue.value === true && serializeReferenceKey({
-			node: effectNode.left,
-			scopes: context.scopes
-		}) === guardKey && isUnconditionallyExecutedWithinFunction(effectNode, effectCallback, context)) acceptedAssignments.add(effectNode);
-	});
-	return acceptedAssignments;
-};
-const isEffectCallback = (node, context) => {
-	const callbackRoot = findTransparentExpressionRoot(node);
-	const callbackCall = callbackRoot.parent;
-	return Boolean(callbackCall && isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments[0] === callbackRoot && isReactApiCall(callbackCall, EFFECT_HOOK_NAMES$6, context.scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true
-	}));
-};
-const isCleanupBackedLifecycleGuard = (guardExpression, functionNode, context) => {
-	const guardKey = serializeReferenceKey({
-		node: guardExpression,
-		scopes: context.scopes
-	});
-	if (!guardKey || !isInitiallyActiveLifecycleGuard(guardExpression, context)) return false;
-	let ownerFunction = functionNode.parent;
-	while (ownerFunction && !isFunctionLike$1(ownerFunction)) ownerFunction = ownerFunction.parent ?? null;
-	if (!ownerFunction) return false;
-	const effectCallbacks = [];
-	if (isEffectCallback(ownerFunction, context)) effectCallbacks.push(ownerFunction);
-	walkOwnFunctionScope(ownerFunction, (candidate) => {
-		if (!isNodeOfType(candidate, "CallExpression")) return;
-		if (!isReactApiCall(candidate, EFFECT_HOOK_NAMES$6, context.scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true
-		})) return;
-		const effectCallback = candidate.arguments[0];
-		if (effectCallback && isFunctionLike$1(effectCallback)) effectCallbacks.push(effectCallback);
-	});
-	const acceptedAssignments = /* @__PURE__ */ new Set();
-	for (const effectCallback of effectCallbacks) {
-		const effectAssignments = collectCleanupBackedLifecycleAssignments(effectCallback, guardKey, context);
-		if (!effectAssignments) continue;
-		for (const assignment of effectAssignments) acceptedAssignments.add(assignment);
-	}
-	return Boolean(acceptedAssignments.size > 0 && !hasLifecycleGuardWriteOutsideCleanup(ownerFunction, guardKey, acceptedAssignments, context));
-};
-const collectLogicalOperands = (expression, operator) => {
-	const stripped = stripParenExpression(expression);
-	if (isNodeOfType(stripped, "LogicalExpression") && stripped.operator === operator) return [...collectLogicalOperands(stripped.left, operator), ...collectLogicalOperands(stripped.right, operator)];
-	return [stripped];
-};
-const collectFinalizerGuardExpressions = (resetNode, protectingTry) => {
-	const positive = [];
-	const negative = [];
+const isResetGuardedByCleanupBackedLifecycle = (resetNode, functionNode, context) => {
 	let child = resetNode;
 	let cursor = resetNode.parent;
-	while (cursor && cursor !== protectingTry) {
-		if (isNodeOfType(cursor, "IfStatement")) {
-			if (cursor.consequent !== child || cursor.alternate !== null) return null;
-			positive.push(...collectLogicalOperands(cursor.test, "&&"));
-		} else if (isNodeOfType(cursor, "LogicalExpression")) {
-			if (cursor.operator !== "&&" || cursor.right !== child) return null;
-			positive.push(...collectLogicalOperands(cursor.left, "&&"));
-		} else if (isNodeOfType(cursor, "BlockStatement")) {
-			const childIndex = cursor.body.findIndex((statement) => statement === child);
-			if (childIndex !== -1) for (const statement of cursor.body.slice(0, childIndex)) {
-				if (!isNodeOfType(statement, "IfStatement") || statement.alternate !== null || !isUnconditionalReturnBranch(statement.consequent)) continue;
-				negative.push(...collectLogicalOperands(statement.test, "||"));
-			}
-		} else if (isNodeOfType(cursor, "SwitchCase") || isNodeOfType(cursor, "ConditionalExpression") || isNodeOfType(cursor, "ForStatement") || isNodeOfType(cursor, "ForInStatement") || isNodeOfType(cursor, "ForOfStatement") || isNodeOfType(cursor, "WhileStatement") || isNodeOfType(cursor, "DoWhileStatement")) return null;
+	let guardKey = null;
+	let guardExpression = null;
+	while (cursor && cursor !== functionNode) {
+		if (isNodeOfType(cursor, "IfStatement") && cursor.consequent === child && cursor.alternate === null) {
+			guardExpression = cursor.test;
+			guardKey = serializeReferenceKey({
+				node: cursor.test,
+				scopes: context.scopes
+			});
+			break;
+		}
 		child = cursor;
 		cursor = cursor.parent ?? null;
 	}
-	return cursor === protectingTry && positive.length + negative.length > 0 ? {
-		positive,
-		negative
-	} : null;
-};
-const isPositiveFinalizerGuard = (expression, resetNode, functionNode, truthySets, firstRiskyAwait, context) => isCleanupBackedLifecycleGuard(expression, functionNode, context) || isClaimedOwnershipComparison(expression, "owns", functionNode, truthySets, firstRiskyAwait, resetNode, context);
-const isNegativeFinalizerGuard = (expression, resetNode, functionNode, truthySets, firstRiskyAwait, context) => {
-	const stripped = stripParenExpression(expression);
-	if (isNodeOfType(stripped, "UnaryExpression") && stripped.operator === "!") return isPositiveFinalizerGuard(stripped.argument, resetNode, functionNode, truthySets, firstRiskyAwait, context);
-	return isClaimedOwnershipComparison(stripped, "lost", functionNode, truthySets, firstRiskyAwait, resetNode, context);
-};
-const isFinalizerResetProvablyGuarded = (resetNode, protectingTry, functionNode, truthySets, firstRiskyAwait, context) => {
-	const guards = collectFinalizerGuardExpressions(resetNode, protectingTry);
-	return Boolean(guards && guards.positive.every((guard) => isPositiveFinalizerGuard(guard, resetNode, functionNode, truthySets, firstRiskyAwait, context)) && guards.negative.every((guard) => isNegativeFinalizerGuard(guard, resetNode, functionNode, truthySets, firstRiskyAwait, context)));
+	if (!guardKey || !guardExpression || !isInitiallyActiveLifecycleGuard(guardExpression, context)) return false;
+	cursor = functionNode.parent;
+	while (cursor) {
+		if (isFunctionLike$1(cursor)) {
+			const callbackRoot = findTransparentExpressionRoot(cursor);
+			const callbackCall = callbackRoot.parent;
+			if (Boolean(callbackCall && isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments[0] === callbackRoot && isReactApiCall(callbackCall, EFFECT_HOOK_NAMES$6, context.scopes, {
+				allowGlobalReactNamespace: true,
+				allowUnboundBareCalls: true
+			}))) {
+				const acceptedCleanupAssignments = /* @__PURE__ */ new Set();
+				for (const cleanupFunction of collectReturnedCleanupFunctions(cursor, context.scopes)) walkOwnFunctionScope(cleanupFunction, (cleanupNode) => {
+					const assignedValue = isNodeOfType(cleanupNode, "AssignmentExpression") ? stripParenExpression(cleanupNode.right) : null;
+					if (!isNodeOfType(cleanupNode, "AssignmentExpression") || cleanupNode.operator !== "=" || !isNodeOfType(assignedValue, "Literal") || assignedValue.value !== false || serializeReferenceKey({
+						node: cleanupNode.left,
+						scopes: context.scopes
+					}) !== guardKey || !isUnconditionallyExecutedWithinFunction(cleanupNode, cleanupFunction, context)) return;
+					acceptedCleanupAssignments.add(cleanupNode);
+				});
+				if (acceptedCleanupAssignments.size > 0 && !hasLifecycleGuardWriteOutsideCleanup(cursor, guardKey, acceptedCleanupAssignments, context)) return true;
+			}
+		}
+		cursor = cursor.parent ?? null;
+	}
+	return false;
 };
 const isAwaitInsideProtectedTry = (awaitNode, tryStatement) => {
 	let child = awaitNode;
@@ -69584,13 +68911,7 @@ const analyzeFunction = (functionNode, context) => {
 		const exceptionallyProtectedAwaits = collectExceptionallyProtectedAwaits(awaitSites, calls);
 		const riskyAwaitsWithTruthySet = awaitSites.filter((awaitSite) => rejectingAwaitNodes.has(awaitSite.node) && !exceptionallyProtectedAwaits.has(awaitSite.node) && truthySets.some((truthySet) => truthySet.start < awaitSite.start && !areOnExclusiveBranches(truthySet.node, awaitSite.node, functionNode)));
 		if (riskyAwaitsWithTruthySet.length === 0) continue;
-		const conditionalExceptionalResets = calls.filter((call) => {
-			if (call.value || call.context === "plain" || call.isUnconditional || call.protectingTry === null) return false;
-			const protectingTry = call.protectingTry;
-			if (!isInsideTryFinalizer(call.node, protectingTry)) return true;
-			const firstRiskyAwait = riskyAwaitsWithTruthySet.find((awaitSite) => isAwaitInsideProtectedTry(awaitSite.node, protectingTry));
-			return !(firstRiskyAwait && isFinalizerResetProvablyGuarded(call.node, protectingTry, functionNode, truthySets, firstRiskyAwait, context));
-		});
+		const conditionalExceptionalResets = calls.filter((call) => !call.value && call.context !== "plain" && !call.isUnconditional && call.protectingTry !== null && !(isInsideTryFinalizer(call.node, call.protectingTry) && isResetGuardedByCleanupBackedLifecycle(call.node, functionNode, context)));
 		for (const reset of conditionalExceptionalResets) {
 			const catchHandler = reset.protectingTry?.handler;
 			if (catchHandler && !catchHandlerCanBypassReset(catchHandler, functionNode, setterKey, context, false)) continue;
@@ -75462,29 +74783,6 @@ const doesPredicateTruthRequireMatch = (matchCall, predicateFunction) => {
 	}
 	return !isNegated && predicateFunction.body === child;
 };
-const doesPredicateReturnNormalizedMatch = (matchCall, predicateFunction) => {
-	if (!isFunctionLike$1(predicateFunction) || !isNodeOfType(predicateFunction.body, "BlockStatement") || predicateFunction.body.body.length !== 2 || !isNodeOfType(predicateFunction.body.body[0], "VariableDeclaration")) return false;
-	const returnStatement = predicateFunction.body.body[1];
-	if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return false;
-	let negationCount = 0;
-	let expression = matchCall;
-	let parent = expression.parent ?? null;
-	while (parent && parent !== returnStatement) {
-		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "!") {
-			negationCount += 1;
-			expression = parent;
-			parent = parent.parent ?? null;
-			continue;
-		}
-		if (TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) || isNodeOfType(parent, "ChainExpression")) {
-			expression = parent;
-			parent = parent.parent ?? null;
-			continue;
-		}
-		return false;
-	}
-	return parent === returnStatement && returnStatement.argument === expression && negationCount % 2 === 0;
-};
 const isStringTypeofGuardForPath = (test, expectedPath) => {
 	const target = stripParenExpression(test);
 	if (!isNodeOfType(target, "BinaryExpression") || target.operator !== "===") return false;
@@ -75525,26 +74823,6 @@ const pathUsesOptionalAccess = (node) => {
 		current = current.object;
 	}
 };
-const getNormalizedClassNameRoot = (expression) => {
-	const conditional = stripParenExpression(expression);
-	if (!isNodeOfType(conditional, "ConditionalExpression")) return null;
-	const consequent = stripParenExpression(conditional.consequent);
-	const rootIdentifier = getRootIdentifier(consequent);
-	if (!rootIdentifier || receiverPathKey(consequent) !== `${rootIdentifier.name}.className`) return null;
-	const test = stripParenExpression(conditional.test);
-	if (!isNodeOfType(test, "BinaryExpression") || test.operator !== "===") return null;
-	const testOperands = [test.left, test.right].map((operand) => stripParenExpression(operand));
-	const typeofOperand = testOperands.find((operand) => isNodeOfType(operand, "UnaryExpression"));
-	const stringOperand = testOperands.find((operand) => isNodeOfType(operand, "Literal"));
-	if (!typeofOperand || !isNodeOfType(typeofOperand, "UnaryExpression") || typeofOperand.operator !== "typeof" || receiverPathKey(typeofOperand.argument) !== `${rootIdentifier.name}.className` || !stringOperand || !isNodeOfType(stringOperand, "Literal") || stringOperand.value !== "string") return null;
-	const alternate = stripParenExpression(conditional.alternate);
-	if (!isNodeOfType(alternate, "LogicalExpression") || alternate.operator !== "??") return null;
-	const fallback = stripParenExpression(alternate.right);
-	const attributeCall = stripParenExpression(alternate.left);
-	if (!isNodeOfType(fallback, "Literal") || fallback.value !== "" || !isNodeOfType(attributeCall, "CallExpression") || !isNodeOfType(attributeCall.callee, "MemberExpression") || getStaticPropertyName(attributeCall.callee) !== "getAttribute" || receiverPathKey(attributeCall.callee.object) !== rootIdentifier.name) return null;
-	const attributeName = attributeCall.arguments[0] ? stripParenExpression(attributeCall.arguments[0]) : null;
-	return attributeName && isNodeOfType(attributeName, "Literal") && attributeName.value === "class" ? rootIdentifier : null;
-};
 const isMatchProvenByFindUpUntilPredicate = (assertion, matchReceiver, assertedPattern, context) => {
 	const resultIdentifier = getRootIdentifier(matchReceiver);
 	const resultPath = receiverPathKey(matchReceiver);
@@ -75553,17 +74831,11 @@ const isMatchProvenByFindUpUntilPredicate = (assertion, matchReceiver, assertedP
 	if (!isDirectFinderMatchReturn(assertion) && !isOptionalResultPath) return false;
 	const resultSymbol = context.scopes.symbolFor(resultIdentifier);
 	const initializer = resultSymbol?.initializer ? stripParenExpression(resultSymbol.initializer) : null;
-	if (resultSymbol?.kind !== "const" || !initializer) return false;
-	const finderCall = isNodeOfType(initializer, "CallExpression") ? initializer : isNodeOfType(initializer, "ConditionalExpression") ? (() => {
-		const alternate = stripParenExpression(initializer.alternate);
-		const consequent = stripParenExpression(initializer.consequent);
-		return (isNodeOfType(alternate, "Literal") && alternate.value === null || isNodeOfType(alternate, "Identifier") && alternate.name === "undefined" && context.scopes.isGlobalReference(alternate)) && isNodeOfType(consequent, "CallExpression") ? consequent : null;
-	})() : null;
-	if (!finderCall || !isNodeOfType(finderCall, "CallExpression")) return false;
+	if (resultSymbol?.kind !== "const" || !initializer || !isNodeOfType(initializer, "CallExpression")) return false;
 	if (!isOptionalResultPath && !isImmediatelyGuardedFinderResult(assertion, resultSymbol, resultPath, context)) return false;
-	const finderCallee = stripParenExpression(finderCall.callee);
+	const finderCallee = stripParenExpression(initializer.callee);
 	if (!isNodeOfType(finderCallee, "Identifier") || !(context.scopes.symbolFor(finderCallee)?.kind === "import" && getImportedNameFromModule(assertion, finderCallee.name, CLOUDSCAPE_DOM_MODULE) === "findUpUntil" || finderCallee.name === "findUpUntil" && context.scopes.isGlobalReference(finderCallee))) return false;
-	const predicateArgument = finderCall.arguments[1];
+	const predicateArgument = initializer.arguments[1];
 	if (!predicateArgument) return false;
 	const predicateFunction = resolveExactLocalFunction(predicateArgument, context.scopes);
 	if (!predicateFunction || !isFunctionLike$1(predicateFunction)) return false;
@@ -75587,43 +74859,6 @@ const isMatchProvenByFindUpUntilPredicate = (assertion, matchReceiver, assertedP
 	});
 	return didProveMatch;
 };
-const isMatchProvenByNormalizedFindUpUntilPredicate = (assertion, matchReceiver, assertedPattern, context) => {
-	const normalizedReceiver = stripParenExpression(matchReceiver);
-	if (!isNodeOfType(normalizedReceiver, "Identifier")) return false;
-	const normalizedReceiverSymbol = context.scopes.symbolFor(normalizedReceiver);
-	const normalizedReceiverInitializer = normalizedReceiverSymbol?.initializer ? stripParenExpression(normalizedReceiverSymbol.initializer) : null;
-	const resultIdentifier = normalizedReceiverInitializer ? getNormalizedClassNameRoot(normalizedReceiverInitializer) : null;
-	if (normalizedReceiverSymbol?.kind !== "const" || normalizedReceiverSymbol.references.some((reference) => reference.flag !== "read") || !resultIdentifier) return false;
-	const resultSymbol = context.scopes.symbolFor(resultIdentifier);
-	const finderCall = resultSymbol?.initializer ? stripParenExpression(resultSymbol.initializer) : null;
-	if (resultSymbol?.kind !== "const" || resultSymbol.references.some((reference) => reference.flag !== "read") || !finderCall || !isNodeOfType(finderCall, "CallExpression")) return false;
-	const finderCallee = stripParenExpression(finderCall.callee);
-	if (!isNodeOfType(finderCallee, "Identifier") || context.scopes.symbolFor(finderCallee)?.kind !== "import" || getImportedNameFromModule(assertion, finderCallee.name, CLOUDSCAPE_DOM_MODULE) !== "findUpUntil") return false;
-	if (!isPresenceProvenBeforeNode(assertion, (test) => {
-		const expression = stripParenExpression(test);
-		return isNodeOfType(expression, "Identifier") && context.scopes.symbolFor(expression)?.id === resultSymbol.id;
-	})) return false;
-	const predicateArgument = finderCall.arguments[1];
-	const predicateFunction = predicateArgument ? resolveExactLocalFunction(predicateArgument, context.scopes) : null;
-	if (!predicateFunction || !isFunctionLike$1(predicateFunction) || predicateFunction.async || predicateFunction.generator) return false;
-	const predicateParameter = predicateFunction.params[0];
-	if (!isNodeOfType(predicateParameter, "Identifier")) return false;
-	let didProveNormalizedMatch = false;
-	walkAst(predicateFunction.body, (child) => {
-		if (didProveNormalizedMatch || isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "MemberExpression") || getStaticPropertyName(child.callee) !== "match" || !child.arguments[0] || !areRegexPatternsEquivalent(child.arguments[0], assertedPattern, context) || !doesPredicateTruthRequireMatch(child, predicateFunction) && !doesPredicateReturnNormalizedMatch(child, predicateFunction)) return;
-		const predicateReceiver = stripParenExpression(child.callee.object);
-		if (!isNodeOfType(predicateReceiver, "Identifier")) return;
-		const predicateReceiverSymbol = context.scopes.symbolFor(predicateReceiver);
-		const predicateReceiverInitializer = predicateReceiverSymbol?.initializer ? stripParenExpression(predicateReceiverSymbol.initializer) : null;
-		const predicateRoot = predicateReceiverInitializer ? getNormalizedClassNameRoot(predicateReceiverInitializer) : null;
-		if (predicateReceiverSymbol?.kind === "const" && predicateReceiverSymbol.references.every((reference) => reference.flag === "read") && predicateRoot?.name === predicateParameter.name) {
-			didProveNormalizedMatch = true;
-			return false;
-		}
-	});
-	return didProveNormalizedMatch;
-};
 const scopeProvesFindMatch = (assertion, findReceiver, findPredicate, context) => {
 	if (!isStablePredicate(findPredicate, context)) return false;
 	return isPresenceProvenBeforeNode(assertion, (test) => testPositivelyContainsCall(test, (call) => {
@@ -75724,123 +74959,6 @@ const isEnsureThenFind = (assertion, findReceiver, findPredicate) => {
 	}
 	return false;
 };
-const getReceiverRootIdentifier = (node) => {
-	let target = stripParenExpression(node);
-	while (isNodeOfType(target, "MemberExpression")) target = stripParenExpression(target.object);
-	return isNodeOfType(target, "Identifier") ? target : null;
-};
-const getReceiverStatePath = (node) => {
-	const target = stripParenExpression(node);
-	if (isNodeOfType(target, "Identifier")) return target.name;
-	if (!isNodeOfType(target, "MemberExpression")) return null;
-	const objectPath = getReceiverStatePath(target.object);
-	if (!objectPath) return null;
-	return `${objectPath}.${getStaticPropertyName(target) ?? "*"}`;
-};
-const doesReceiverStateChangeBeforeAssertion = (ownerFunction, receiver, startOffset, assertion, context) => {
-	const receiverRoot = getReceiverRootIdentifier(receiver);
-	const receiverSymbol = receiverRoot ? context.scopes.symbolFor(receiverRoot) : null;
-	const receiverPath = getReceiverStatePath(receiver);
-	if (!receiverRoot || !receiverSymbol || !receiverPath) return true;
-	const receiverAliasPaths = new Map([[receiverSymbol.id, receiverRoot.name]]);
-	let didAddAlias = true;
-	while (didAddAlias) {
-		didAddAlias = false;
-		walkAst(ownerFunction, (child) => {
-			if (child !== ownerFunction && isFunctionLike$1(child)) return false;
-			if (!isNodeOfType(child, "VariableDeclarator") || !isNodeOfType(child.id, "Identifier") || !child.init) return;
-			const initializer = stripParenExpression(child.init);
-			if (!isNodeOfType(initializer, "Identifier") && !isNodeOfType(initializer, "MemberExpression")) return;
-			const initializerRoot = getReceiverRootIdentifier(initializer);
-			const initializerSymbol = initializerRoot ? context.scopes.symbolFor(initializerRoot) : null;
-			const initializerBasePath = initializerSymbol ? receiverAliasPaths.get(initializerSymbol.id) : null;
-			const initializerPath = getReceiverStatePath(initializer);
-			if (!initializerRoot || !initializerBasePath || !initializerPath) return;
-			const aliasSymbol = context.scopes.symbolFor(child.id);
-			if (aliasSymbol && !receiverAliasPaths.has(aliasSymbol.id)) {
-				const initializerSuffix = initializerPath.slice(initializerRoot.name.length);
-				receiverAliasPaths.set(aliasSymbol.id, `${initializerBasePath}${initializerSuffix}`);
-				didAddAlias = true;
-			}
-		});
-	}
-	let didChangeReceiverState = false;
-	walkAst(ownerFunction, (child) => {
-		if (didChangeReceiverState) return false;
-		if (child !== ownerFunction && isFunctionLike$1(child)) return false;
-		if (child.range[0] <= startOffset || child.range[0] >= assertion.range[0]) return;
-		if (isNodeOfType(child, "CallExpression")) {
-			didChangeReceiverState = true;
-			return false;
-		}
-		const mutationTarget = isNodeOfType(child, "AssignmentExpression") || isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete" ? stripParenExpression(isNodeOfType(child, "AssignmentExpression") ? child.left : child.argument) : null;
-		const mutationRoot = mutationTarget ? getReceiverRootIdentifier(mutationTarget) : null;
-		const mutationSymbol = mutationRoot ? context.scopes.symbolFor(mutationRoot) : null;
-		const mutationBasePath = mutationSymbol ? receiverAliasPaths.get(mutationSymbol.id) : null;
-		const mutationPath = mutationTarget ? getReceiverStatePath(mutationTarget) : null;
-		if (mutationRoot && mutationBasePath && mutationPath) {
-			const canonicalMutationPath = `${mutationBasePath}${mutationPath.slice(mutationRoot.name.length)}`;
-			if (canonicalMutationPath !== receiverPath && !canonicalMutationPath.startsWith(`${receiverPath}.`) && !receiverPath.startsWith(`${canonicalMutationPath}.`)) return;
-			didChangeReceiverState = true;
-			return false;
-		}
-	});
-	return didChangeReceiverState;
-};
-const isFindProvenByGuardedMaximum = (assertion, findReceiver, findPredicate, context) => {
-	const findLookup = findEqualityLookupParts(findPredicate);
-	const maximumIdentifier = findLookup ? stripParenExpression(findLookup.comparedValue) : null;
-	if (!findLookup || !maximumIdentifier || !isNodeOfType(maximumIdentifier, "Identifier")) return false;
-	const maximumSymbol = context.scopes.symbolFor(maximumIdentifier);
-	const maximumInitializer = maximumSymbol?.initializer ? stripParenExpression(maximumSymbol.initializer) : null;
-	if (maximumSymbol?.kind !== "const" || maximumSymbol.references.some((reference) => reference.flag !== "read") || !maximumInitializer || !isNodeOfType(maximumInitializer, "CallExpression") || !isNodeOfType(maximumInitializer.callee, "MemberExpression") || getStaticPropertyName(maximumInitializer.callee) !== "reduce") return false;
-	const filterCall = stripParenExpression(maximumInitializer.callee.object);
-	if (!isNodeOfType(filterCall, "CallExpression") || !isNodeOfType(filterCall.callee, "MemberExpression") || getStaticPropertyName(filterCall.callee) !== "filter" || !areNodesLooselyEqual(filterCall.callee.object, findReceiver)) return false;
-	const filterPredicate = filterCall.arguments[0] ? stripParenExpression(filterCall.arguments[0]) : null;
-	if (!filterPredicate || !isStablePredicate(filterPredicate, context)) return false;
-	const reducerArgument = maximumInitializer.arguments[0] ? stripParenExpression(maximumInitializer.arguments[0]) : null;
-	const reducerFunction = reducerArgument ? resolveExactLocalFunction(reducerArgument, context.scopes) : null;
-	const initialValue = maximumInitializer.arguments[1] ? stripParenExpression(maximumInitializer.arguments[1]) : null;
-	if (!reducerFunction || !isFunctionLike$1(reducerFunction) || reducerFunction.async || reducerFunction.generator || !initialValue || !isNodeOfType(initialValue, "Literal") || typeof initialValue.value !== "number") return false;
-	const accumulatorParameter = reducerFunction.params[0];
-	const itemParameter = reducerFunction.params[1];
-	const reducerBody = singleExpressionPredicateBody(reducerFunction);
-	if (!isNodeOfType(accumulatorParameter, "Identifier") || !isNodeOfType(itemParameter, "Identifier") || !reducerBody || !isNodeOfType(reducerBody, "CallExpression") || !isNodeOfType(reducerBody.callee, "MemberExpression") || getStaticPropertyName(reducerBody.callee) !== "max") return false;
-	const mathReceiver = stripParenExpression(reducerBody.callee.object);
-	if (!isNodeOfType(mathReceiver, "Identifier") || mathReceiver.name !== "Math" || !context.scopes.isGlobalReference(mathReceiver) || reducerBody.arguments.length !== 2) return false;
-	const accumulatorArgument = reducerBody.arguments.find((argument) => {
-		const expression = stripParenExpression(argument);
-		return isNodeOfType(expression, "Identifier") && expression.name === accumulatorParameter.name;
-	});
-	const itemMemberArgument = reducerBody.arguments.find((argument) => {
-		const expression = stripParenExpression(argument);
-		const rootIdentifier = getRootIdentifier(expression);
-		return isNodeOfType(expression, "MemberExpression") && rootIdentifier?.name === itemParameter.name && receiverPathKey(expression)?.slice(itemParameter.name.length + 1) === findLookup.propertyName;
-	});
-	if (!accumulatorArgument || !itemMemberArgument) return false;
-	if (!receiverPathKey(findReceiver)) return false;
-	let ownerFunction = assertion.parent ?? null;
-	while (ownerFunction && !isFunctionLike$1(ownerFunction)) ownerFunction = ownerFunction.parent ?? null;
-	if (!ownerFunction || !isFunctionLike$1(ownerFunction)) return false;
-	const maximumEnd = maximumInitializer.range[1];
-	if (doesReceiverStateChangeBeforeAssertion(ownerFunction.body, findReceiver, maximumEnd, assertion, context)) return false;
-	return isPresenceProvenBeforeNode(assertion, (test) => {
-		const comparison = stripParenExpression(test);
-		if (!isNodeOfType(comparison, "BinaryExpression")) return false;
-		return [[
-			comparison.left,
-			comparison.right,
-			comparison.operator
-		], [
-			comparison.right,
-			comparison.left,
-			comparison.operator === "<" ? ">" : comparison.operator === ">" ? "<" : comparison.operator
-		]].some(([candidateMaximum, candidateInitial, operator]) => {
-			const candidateMaximumIdentifier = stripParenExpression(candidateMaximum);
-			return operator === ">" && isNodeOfType(candidateMaximumIdentifier, "Identifier") && context.scopes.symbolFor(candidateMaximumIdentifier)?.id === maximumSymbol.id && areNodesLooselyEqual(stripParenExpression(candidateInitial), initialValue);
-		});
-	});
-};
 const isDefinitelyNonNullishMapValue = (value) => {
 	if (!value) return false;
 	const expression = stripParenExpression(value);
@@ -75864,15 +74982,15 @@ const unwrapFalseBooleanGuard = (test) => {
 };
 const isEnsureThenMapGet = (assertion, receiver, lookupKey, context) => {
 	const stableLookupKey = stripParenExpression(lookupKey);
-	const lookupKeyRoot = isNodeOfType(stableLookupKey, "MemberExpression") ? getRootIdentifier(stableLookupKey) : null;
-	const lookupKeySymbol = isNodeOfType(stableLookupKey, "Identifier") ? context.scopes.symbolFor(stableLookupKey) : lookupKeyRoot ? context.scopes.symbolFor(lookupKeyRoot) : null;
-	if (!isNodeOfType(stableLookupKey, "Identifier") && !isNodeOfType(stableLookupKey, "Literal") && (!isNodeOfType(stableLookupKey, "MemberExpression") || !lookupKeyRoot || lookupKeySymbol?.kind !== "const")) return false;
+	if (!isNodeOfType(stableLookupKey, "Identifier") && !isNodeOfType(stableLookupKey, "Literal")) return false;
 	const receiverSymbol = context.scopes.symbolFor(receiver);
 	if (!receiverSymbol) return false;
 	const receiverMatches = (candidate) => {
 		const target = stripParenExpression(candidate);
 		return isNodeOfType(target, "Identifier") && context.scopes.symbolFor(target)?.id === receiverSymbol.id;
 	};
+	const lookupKeyExpression = stripParenExpression(lookupKey);
+	const lookupKeySymbol = isNodeOfType(lookupKeyExpression, "Identifier") ? context.scopes.symbolFor(lookupKeyExpression) : null;
 	let child = assertion;
 	let ancestor = assertion.parent ?? null;
 	while (ancestor && !isFunctionLike$1(ancestor)) {
@@ -75892,7 +75010,7 @@ const isEnsureThenMapGet = (assertion, receiver, lookupKey, context) => {
 				const populationCall = populationCalls[0];
 				if (!populationCall) continue;
 				const populationCallStart = populationCall.range[0];
-				if (Boolean(lookupKeySymbol?.references.some((reference) => reference.flag !== "read" && reference.identifier.range[0] > populationCallStart && reference.identifier.range[0] < assertion.range[0])) || Boolean(lookupKeySymbol && isNodeOfType(stableLookupKey, "MemberExpression") && subtreeWritesSymbol(ancestor, new Set([lookupKeySymbol.id]), context, void 0, assertion))) continue;
+				if (Boolean(lookupKeySymbol?.references.some((reference) => reference.flag !== "read" && reference.identifier.range[0] > populationCallStart && reference.identifier.range[0] < assertion.range[0]))) continue;
 				if (receiverSymbol.references.some((reference) => reference.flag !== "read" && reference.identifier.range[0] > populationCallStart && reference.identifier.range[0] < assertion.range[0])) continue;
 				if (!indexedRelevantCalls(ancestor).some((laterCall) => {
 					if (laterCall.range[0] <= populationCallStart || laterCall.range[0] >= assertion.range[0] || !isNodeOfType(laterCall.callee, "MemberExpression") || !receiverMatches(laterCall.callee.object)) return false;
@@ -76002,7 +75120,6 @@ const noNonNullAssertionOnMaybeUndefinedResult = defineRule({
 				const findReceiver = callee.object;
 				if (predicate && isExhaustiveLiteralTupleMapping(findReceiver, predicate, context)) return;
 				if (predicate && scopeProvesFindMatch(node, findReceiver, predicate, context)) return;
-				if (predicate && isFindProvenByGuardedMaximum(node, findReceiver, predicate, context)) return;
 				if (predicate && isEnsureThenFind(node, findReceiver, predicate)) return;
 			}
 			if (methodName === "match") {
@@ -76012,7 +75129,6 @@ const noNonNullAssertionOnMaybeUndefinedResult = defineRule({
 				const regexKey = pattern ? regexComparableKey(pattern, context) : null;
 				if (pattern && isGuardedAnchoredCharacterMatch(node, matchReceiver, pattern)) return;
 				if (pattern && regexKey && isMatchProvenByFindUpUntilPredicate(node, matchReceiver, pattern, context)) return;
-				if (pattern && regexKey && isMatchProvenByNormalizedFindUpUntilPredicate(node, matchReceiver, pattern, context)) return;
 				if (regexKey && scopeProvesMatchTested(node, regexKey, matchReceiver, context)) return;
 			}
 			if (methodName === "get") {
@@ -79951,23 +79067,16 @@ const MAX_INITIATOR_RESOLUTION_DEPTH = 3;
 const STATE_DISPATCHER_HOOK_NAMES = new Set(["useState", "useReducer"]);
 const REF_HOOK_NAMES = new Set(["useRef"]);
 const MESSAGE$26 = "This promise chain runs in an effect, ends in a `.then` that sets state or mutates a ref, and has no `.catch` or enclosing try/catch, so a rejection leaves the state unset and surfaces as an unhandled rejection. Add a `.catch` handler on the chain (`.finally` does not count).";
-const isKnownNonRejectingHandlerReturn = (expression, context, visitedBindingIdentifiers = /* @__PURE__ */ new Set()) => {
+const isKnownNonThenableHandlerReturn = (expression, context, visitedBindingIdentifiers = /* @__PURE__ */ new Set()) => {
 	const strippedExpression = stripParenExpression(expression);
 	if (isDefinitelyNonThenableValue(strippedExpression)) return true;
-	if (isNodeOfType(strippedExpression, "CallExpression") && isNodeOfType(strippedExpression.callee, "MemberExpression")) {
-		const receiver = stripParenExpression(strippedExpression.callee.object);
-		if (isNodeOfType(receiver, "Identifier") && receiver.name === "Promise" && context.scopes.isGlobalReference(receiver) && getStaticPropertyName(strippedExpression.callee) === "resolve") {
-			const resolvedValue = strippedExpression.arguments[0];
-			return !resolvedValue || !isNodeOfType(resolvedValue, "SpreadElement") && isKnownNonRejectingHandlerReturn(resolvedValue, context, visitedBindingIdentifiers);
-		}
-	}
 	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
 	if (strippedExpression.name === "undefined" && context.scopes.isGlobalReference(strippedExpression)) return true;
 	const symbol = context.scopes.symbolFor(strippedExpression);
 	if (!symbol || visitedBindingIdentifiers.has(symbol.bindingIdentifier)) return false;
 	visitedBindingIdentifiers.add(symbol.bindingIdentifier);
 	const initializer = getDirectUnreassignedInitializer(symbol);
-	return Boolean(initializer && isKnownNonRejectingHandlerReturn(initializer, context, visitedBindingIdentifiers));
+	return Boolean(initializer && isKnownNonThenableHandlerReturn(initializer, context, visitedBindingIdentifiers));
 };
 const isKnownNonRejectingHandler = (argument, context) => {
 	if (!argument) return false;
@@ -79982,7 +79091,7 @@ const isKnownNonRejectingHandler = (argument, context) => {
 			canReject = true;
 			return false;
 		}
-		if (isNodeOfType(child, "ReturnStatement") && child.argument && !isKnownNonRejectingHandlerReturn(child.argument, context)) {
+		if (isNodeOfType(child, "ReturnStatement") && child.argument && !isKnownNonThenableHandlerReturn(child.argument, context)) {
 			if (!isNodeOfType(stripParenExpression(child.argument), "CallExpression")) {
 				canReject = true;
 				return false;
@@ -80031,28 +79140,6 @@ const handlerHasPotentiallyThrowingMemberRead = (argument, context) => {
 	});
 	return hasPotentiallyThrowingMemberRead;
 };
-const hasRejectionHandler = (chain, argument, context, allowTerminalCatchBlock) => {
-	if (!argument) return false;
-	if (!handlerHasPotentiallyThrowingMemberRead(argument, context) && (chainCarriesRejectionHandler(chain, context.scopes) || isKnownNonRejectingHandler(argument, context))) return true;
-	if (!allowTerminalCatchBlock) return false;
-	const candidate = stripParenExpression(argument);
-	const handler = isNodeOfType(candidate, "Identifier") ? resolveExactLocalFunction(candidate, context.scopes) : candidate;
-	if (!handler || !isFunctionLike$1(handler)) return isNodeOfType(candidate, "MemberExpression") || isNodeOfType(candidate, "Identifier") && candidate.name !== "undefined";
-	if (!isNodeOfType(handler.body, "BlockStatement")) return false;
-	let doesExplicitlyReject = false;
-	walkOwnFunctionScope(handler, (child) => {
-		if (doesExplicitlyReject) return false;
-		if (isNodeOfType(child, "ThrowStatement") || isNodeOfType(child, "AwaitExpression")) {
-			doesExplicitlyReject = true;
-			return false;
-		}
-		if (isNodeOfType(child, "ReturnStatement") && child.argument && !isKnownNonRejectingHandlerReturn(child.argument, context)) {
-			doesExplicitlyReject = true;
-			return false;
-		}
-	});
-	return !doesExplicitlyReject;
-};
 const walkPromiseChain = (chainExpression, context) => {
 	let cursor = stripParenExpression(chainExpression);
 	let hasCatch = false;
@@ -80064,9 +79151,10 @@ const walkPromiseChain = (chainExpression, context) => {
 	while (isNodeOfType(cursor, "CallExpression") && isNodeOfType(cursor.callee, "MemberExpression") && PROMISE_METHOD_NAMES.has(getStaticPropertyName(cursor.callee) ?? "")) {
 		const methodName = getStaticPropertyName(cursor.callee);
 		const rejectionHandlerArgument = methodName === "catch" ? cursor.arguments[0] : cursor.arguments[1];
-		if (!didReachTerminalThen && methodName === "catch" && hasRejectionHandler(cursor, rejectionHandlerArgument, context, true)) hasCatch = true;
+		const hasAbsorbingRejectionHandler = !handlerHasPotentiallyThrowingMemberRead(rejectionHandlerArgument, context) && (chainCarriesRejectionHandler(cursor, context.scopes) || isKnownNonRejectingHandler(rejectionHandlerArgument, context));
+		if (!didReachTerminalThen && methodName === "catch" && hasAbsorbingRejectionHandler) hasCatch = true;
 		if (methodName === "then") {
-			if (!didReachTerminalThen && hasRejectionHandler(cursor, rejectionHandlerArgument, context, false)) hasRejectionHandlerArgument = true;
+			if (!didReachTerminalThen && hasAbsorbingRejectionHandler) hasRejectionHandlerArgument = true;
 			didReachTerminalThen = true;
 			sawThen = true;
 			const callbackArgument = cursor.arguments[0];
@@ -82393,45 +81481,6 @@ const noRefCallbackCleanupBeforeReact19 = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/contains-non-deterministic-source.ts
-const NON_DETERMINISTIC_MEMBER_CALLS = new Set([
-	"Math.random",
-	"Date.now",
-	"performance.now",
-	"crypto.randomUUID",
-	"crypto.getRandomValues"
-]);
-const NON_DETERMINISTIC_ID_GENERATOR_NAMES = new Set([
-	"nanoid",
-	"uuid",
-	"cuid",
-	"ulid",
-	"createId"
-]);
-const isZeroArgDateConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Date" && (node.arguments?.length ?? 0) === 0;
-const containsNonDeterministicSource = (root) => {
-	let found = false;
-	walkAst(root, (child) => {
-		if (found) return false;
-		if (isFunctionLike$1(child)) return false;
-		if (isZeroArgDateConstruction(child)) {
-			found = true;
-			return false;
-		}
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = child.callee;
-		if (isNodeOfType(callee, "Identifier") && NON_DETERMINISTIC_ID_GENERATOR_NAMES.has(callee.name)) {
-			found = true;
-			return false;
-		}
-		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && NON_DETERMINISTIC_MEMBER_CALLS.has(`${callee.object.name}.${callee.property.name}`)) {
-			found = true;
-			return false;
-		}
-	});
-	return found;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
 const REPEATED_ANCESTOR_TYPES = new Set([
 	"DoWhileStatement",
@@ -82462,75 +81511,45 @@ const resolveImmutableInitializationValue = (node, scopes, visitedSymbolIds = /*
 };
 const isProvablyTruthyInitializationValue = (node, scopes) => {
 	const expression = resolveImmutableInitializationValue(node, scopes);
-	if (!expression) return false;
-	if (isNodeOfType(expression, "CallExpression")) {
-		const callee = stripParenExpression(expression.callee);
-		return isNodeOfType(callee, "Identifier") && callee.name.startsWith("create");
-	}
-	return isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "ClassExpression");
+	return Boolean(expression && (isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "ClassExpression")));
 };
-const getInitializationValueName = (node, scopes) => {
+const getInitializationConstructorName = (node, scopes) => {
 	const expression = resolveImmutableInitializationValue(node, scopes);
 	if (!expression) return null;
-	if (isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "CallExpression")) {
+	if (isNodeOfType(expression, "NewExpression")) {
 		const callee = stripParenExpression(expression.callee);
-		if (!isNodeOfType(callee, "Identifier")) return null;
-		return callee.name.startsWith("create") && callee.name.length > 6 ? callee.name.slice(6) : callee.name;
+		return isNodeOfType(callee, "Identifier") ? callee.name : null;
 	}
 	return null;
 };
-const isMatchingReturnType = (typeNode, initializationValue, scopes) => {
-	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
-	const typeName = typeNode.typeName;
-	if (!isNodeOfType(typeName, "Identifier") || typeName.name !== "ReturnType") return false;
-	const [returnTypeArgument] = typeNode.typeArguments?.params ?? [];
-	if (!returnTypeArgument || !isNodeOfType(returnTypeArgument, "TSTypeQuery")) return false;
-	const queriedName = returnTypeArgument.exprName;
-	const expression = stripParenExpression(initializationValue);
-	if (!isNodeOfType(queriedName, "Identifier") || !isNodeOfType(expression, "CallExpression")) return false;
-	const callee = stripParenExpression(expression.callee);
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	const queriedSymbol = scopes.symbolFor(queriedName);
-	const calleeSymbol = scopes.symbolFor(callee);
-	return queriedSymbol && calleeSymbol ? queriedSymbol.id === calleeSymbol.id : queriedName.name === callee.name;
-};
 const isClosedTruthyTypeDomain = (typeNode, initializationValue, scopes) => {
 	const initializationExpression = stripParenExpression(initializationValue);
 	if (isNodeOfType(typeNode, "TSTypeLiteral")) return isNodeOfType(initializationExpression, "ObjectExpression");
 	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return isNodeOfType(initializationExpression, "ArrayExpression");
 	if (isNodeOfType(typeNode, "TSFunctionType") || isNodeOfType(typeNode, "TSConstructorType")) return isNodeOfType(initializationExpression, "ArrowFunctionExpression") || isNodeOfType(initializationExpression, "FunctionExpression") || isNodeOfType(initializationExpression, "ClassExpression");
 	if (isNodeOfType(typeNode, "TSObjectKeyword")) return true;
-	if (isNodeOfType(typeNode, "TSIndexedAccessType")) return isNodeOfType(initializationExpression, "ObjectExpression");
 	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
 	const typeName = typeNode.typeName;
-	if (isNodeOfType(initializationExpression, "ObjectExpression") || isMatchingReturnType(typeNode, initializationExpression, scopes)) return true;
-	return isNodeOfType(typeName, "Identifier") && typeName.name === getInitializationValueName(initializationExpression, scopes);
+	return isNodeOfType(typeName, "Identifier") && typeName.name === getInitializationConstructorName(initializationExpression, scopes);
 };
 const refHasClosedFalsySentinelDomain = (refSymbol, initializationValue, scopes) => {
 	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
 	const [initialValue] = initializer.arguments ?? [];
-	if (initialValue && isNodeOfType(initialValue, "SpreadElement") || initialValue && !isEmptySentinel(initialValue, scopes)) return false;
+	if (!initialValue || isNodeOfType(initialValue, "SpreadElement") || !isEmptySentinel(initialValue, scopes)) return false;
 	const [declaredType] = initializer.typeArguments?.params ?? [];
-	if (!declaredType) return false;
-	const domainTypes = isNodeOfType(declaredType, "TSUnionType") ? declaredType.types : [declaredType];
+	if (!declaredType || !isNodeOfType(declaredType, "TSUnionType")) return false;
+	let hasEmptySentinel = false;
 	let hasTruthyDomain = false;
-	for (const memberType of domainTypes) {
-		if (isNodeOfType(memberType, "TSNullKeyword") || isNodeOfType(memberType, "TSUndefinedKeyword")) continue;
+	for (const memberType of declaredType.types ?? []) {
+		if (isNodeOfType(memberType, "TSNullKeyword") || isNodeOfType(memberType, "TSUndefinedKeyword")) {
+			hasEmptySentinel = true;
+			continue;
+		}
 		if (!isClosedTruthyTypeDomain(memberType, initializationValue, scopes)) return false;
 		hasTruthyDomain = true;
 	}
-	return hasTruthyDomain;
-};
-const refHasEmptySentinelInitializer = (refSymbol, scopes) => {
-	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	const [initialValue] = initializer.arguments ?? [];
-	return Boolean(!initialValue || !isNodeOfType(initialValue, "SpreadElement") && isEmptySentinel(initialValue, scopes));
-};
-const refHasDeclaredType = (refSymbol) => {
-	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
-	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && (initializer.typeArguments?.params.length ?? 0) > 0);
+	return hasEmptySentinel && hasTruthyDomain;
 };
 const isSafeRefIdentifierUse = (identifier) => {
 	const expressionRoot = findTransparentExpressionRoot(identifier);
@@ -82562,40 +81581,25 @@ const expressionContainsRefCurrent = (expression, refSymbol, scopes) => {
 	});
 	return didFindRefCurrent;
 };
-const isEmptySentinel = (node, scopes) => {
-	const expression = stripParenExpression(node);
-	return isNodeOfType(expression, "Literal") && expression.value === null || isNodeOfType(expression, "Identifier") && expression.name === "undefined" && scopes.isGlobalReference(expression);
-};
-const isInitializationInputIndependent = (node, renderOwner, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	let isInputIndependent = true;
-	walkAst(node, (child) => {
-		if (!isInputIndependent) return false;
-		if (resolveReactRefSymbol(child, scopes)) return false;
-		if (!isNodeOfType(child, "Identifier")) return;
-		const symbol = scopes.symbolFor(child);
-		if (!symbol) return;
-		if (symbol.kind === "import") return false;
-		if (symbol.kind === "let" || symbol.kind === "var" || symbol.kind === "using") {
-			isInputIndependent = false;
-			return false;
+const hasNoCompetingRefCurrentWrite = (branchRoot, assignmentExpression, refSymbol, scopes) => {
+	let writeCount = 0;
+	walkAst(branchRoot, (child) => {
+		if (writeCount > 1) return false;
+		if (isNodeOfType(child, "AssignmentExpression")) {
+			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
+			return;
 		}
-		if (isOutsideAllFunctions(symbol)) return false;
-		if (symbol.kind === "parameter") {
-			if (symbol.scope.node === renderOwner) isInputIndependent = false;
-			return false;
+		if (isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
+			if (expressionContainsRefCurrent(child.argument, refSymbol, scopes)) writeCount++;
+			return;
 		}
-		if (!symbol.initializer || symbol.references.some((reference) => reference.flag !== "read")) {
-			isInputIndependent = false;
-			return false;
+		if (isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement")) {
+			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
 		}
-		if (visitedSymbolIds.has(symbol.id)) return false;
-		visitedSymbolIds.add(symbol.id);
-		if (!isInitializationInputIndependent(symbol.initializer, renderOwner, scopes, visitedSymbolIds)) isInputIndependent = false;
-		return false;
 	});
-	return isInputIndependent;
+	return writeCount === 1 && expressionContainsRefCurrent(assignmentExpression.left, refSymbol, scopes);
 };
-const isPredictableInitializationValue = (node, refSymbol, renderOwner, scopes, requiresClosedTruthyDomain) => isInitializationInputIndependent(node, renderOwner, scopes) && !containsNonDeterministicSource(node) && (isProvablyTruthyInitializationValue(node, scopes) && (!requiresClosedTruthyDomain || !refHasDeclaredType(refSymbol)) || refHasClosedFalsySentinelDomain(refSymbol, node, scopes));
+const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined" && scopes.isGlobalReference(node);
 const hasRepeatedExecutionAncestor = (node, stop) => {
 	let ancestor = node.parent;
 	while (ancestor && ancestor !== stop) {
@@ -82625,27 +81629,6 @@ const canExecuteTogether = (firstConstraints, secondConstraints) => {
 	}
 	return true;
 };
-const hasNoCoExecutableCompetingWrite = (assignmentExpression, renderOwner, refSymbol, scopes) => {
-	const assignmentConstraints = getBranchConstraints(assignmentExpression, renderOwner);
-	const synchronouslyInvokedFunctions = collectSynchronouslyEffectInvokedFunctions(renderOwner, scopes);
-	let hasCompetingWrite = false;
-	walkAst(renderOwner, (child) => {
-		if (hasCompetingWrite) return false;
-		let writtenExpression = null;
-		if (isNodeOfType(child, "AssignmentExpression")) {
-			if (child === assignmentExpression) return;
-			writtenExpression = child.left;
-		} else if (isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") writtenExpression = child.argument;
-		else if (isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement")) writtenExpression = child.left;
-		const deferredExecutionBoundary = findDeferredExecutionBoundary(child);
-		const deferredWriteValue = isNodeOfType(child, "AssignmentExpression") && child.operator === "=" ? resolveImmutableInitializationValue(child.right, scopes) : null;
-		const isDeferredTruthyWrite = deferredExecutionBoundary !== null && deferredExecutionBoundary !== renderOwner && !synchronouslyInvokedFunctions.has(deferredExecutionBoundary) && !executesDuringRender(deferredExecutionBoundary, scopes) && deferredWriteValue !== null && !isNodeOfType(deferredWriteValue, "CallExpression") && isProvablyTruthyInitializationValue(deferredWriteValue, scopes);
-		if (!writtenExpression || isDeferredTruthyWrite || !expressionContainsRefCurrent(writtenExpression, refSymbol, scopes) || !canExecuteTogether(assignmentConstraints, getBranchConstraints(child, renderOwner))) return;
-		hasCompetingWrite = true;
-		return false;
-	});
-	return !hasCompetingWrite;
-};
 const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol, scopes) => {
 	const assignmentConstraints = getBranchConstraints(assignmentExpression, branchRoot);
 	const assignmentStart = getRangeStart(assignmentExpression);
@@ -82661,17 +81644,16 @@ const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol
 	});
 	return !hasCoExecutableWrite;
 };
-const isPredictableGuardedInitialization = (assignmentExpression, guardedBranch, renderOwner, refSymbol, scopes, requiresClosedTruthyDomain) => refHasEmptySentinelInitializer(refSymbol, scopes) && isPredictableInitializationValue(assignmentExpression.right, refSymbol, renderOwner, scopes, requiresClosedTruthyDomain) && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && (guardedBranch === renderOwner || !hasRepeatedExecutionAncestor(guardedBranch, renderOwner)) && hasNoPriorCoExecutableWrite(assignmentExpression, renderOwner, refSymbol, scopes) && hasNoCoExecutableCompetingWrite(assignmentExpression, renderOwner, refSymbol, scopes) && refDoesNotEscape(renderOwner, refSymbol, scopes);
 const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
+	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return true;
+	if (assignmentExpression.operator !== "=") return false;
 	const renderOwner = findRenderPhaseComponentOrHook(assignmentExpression, scopes);
 	if (!renderOwner) return false;
-	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return isPredictableGuardedInitialization(assignmentExpression, renderOwner, renderOwner, refSymbol, scopes, assignmentExpression.operator === "||=");
-	if (assignmentExpression.operator !== "=") return false;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
 		const test = isNodeOfType(ancestor, "IfStatement") ? stripParenExpression(ancestor.test) : null;
-		if (isNodeOfType(ancestor, "IfStatement") && test && isNodeOfType(test, "UnaryExpression") && test.operator === "!" && isSameRefCurrentAlias(test.argument, refSymbol, scopes) && ancestor.consequent === descendant && isPredictableGuardedInitialization(assignmentExpression, ancestor.consequent, renderOwner, refSymbol, scopes, true)) return true;
+		if (isNodeOfType(ancestor, "IfStatement") && test && isNodeOfType(test, "UnaryExpression") && test.operator === "!" && isSameRefCurrentAlias(test.argument, refSymbol, scopes) && ancestor.consequent === descendant && isProvablyTruthyInitializationValue(assignmentExpression.right, scopes) && refHasClosedFalsySentinelDomain(refSymbol, assignmentExpression.right, scopes) && !hasRepeatedExecutionAncestor(assignmentExpression, ancestor.consequent) && !hasRepeatedExecutionAncestor(ancestor, renderOwner) && hasNoPriorCoExecutableWrite(assignmentExpression, ancestor.consequent, refSymbol, scopes) && hasNoCompetingRefCurrentWrite(renderOwner, assignmentExpression, refSymbol, scopes) && refDoesNotEscape(renderOwner, refSymbol, scopes)) return true;
 		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(test, "BinaryExpression") && [
 			"===",
 			"==",
@@ -82681,7 +81663,7 @@ const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes)
 			const { left, right } = test;
 			const comparesEmptySentinel = isSameRefCurrentAlias(left, refSymbol, scopes) && isEmptySentinel(right, scopes) || isSameRefCurrentAlias(right, refSymbol, scopes) && isEmptySentinel(left, scopes);
 			const guardedBranch = test.operator === "===" || test.operator === "==" ? ancestor.consequent : ancestor.alternate;
-			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && isPredictableGuardedInitialization(assignmentExpression, guardedBranch, renderOwner, refSymbol, scopes, false)) return true;
+			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && hasNoPriorCoExecutableWrite(assignmentExpression, guardedBranch, refSymbol, scopes)) return true;
 		}
 		descendant = ancestor;
 		ancestor = descendant.parent;
@@ -110488,6 +109470,9 @@ const rerenderFunctionalSetstate = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-trivial-built-in-construction.ts
+const isTrivialBuiltInConstruction = (expression) => isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && TRIVIAL_CONSTRUCTOR_NAMES.has(expression.callee.name) && (expression.arguments ?? []).length === 0;
+//#endregion
 //#region src/plugin/rules/state-and-effects/rerender-lazy-ref-init.ts
 const rerenderLazyRefInit = defineRule({
 	id: "rerender-lazy-ref-init",
@@ -110506,6 +109491,7 @@ const rerenderLazyRefInit = defineRule({
 		const memberPropertyName = isNodeOfType(callee, "MemberExpression") && (isNodeOfType(callee.property, "Identifier") || isNodeOfType(callee.property, "PrivateIdentifier")) ? callee.property.name : null;
 		const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : memberPropertyName ?? "fn";
 		if (TRIVIAL_INITIALIZER_NAMES.has(calleeName)) return;
+		if (isTrivialBuiltInConstruction(initializer)) return;
 		if (isPlainCall && isReactHookName(calleeName)) return;
 		const callShape = isNewCall ? `new ${calleeName}()` : `${calleeName}()`;
 		context.report({