oxlint-plugin-react-doctor 0.9.2-dev.83f3ff8 → 0.9.2-dev.9512488

package/dist/index.js

@@ -388,7 +388,7 @@ const SOURCE_FILE_PATTERN = /\.(?:[cm]?[jt]sx?)$/i;
 const SCRIPT_SOURCE_FILE_PATTERN = /\.(?:[cm]?[jt]sx?|py|php)$/i;
 const DATABASE_SOURCE_FILE_PATTERN = /\.(?:[cm]?[jt]sx?|py)$/i;
 const SERVER_CONTEXT_PATTERN = /(?:^|\/)(?:api|backend|server|servers|middleware|route|routes|functions|lambdas|workers)(?:\/|$)|(?:^|\/)[^/]+\.server\.[cm]?[jt]sx?$/i;
-const TEST_CONTEXT_PATTERN = /(?:^|\/)(?:__fixtures__|__mocks__|__tests__|__integration__|fixtures|mocks|test|tests|testdata|test-data|e2e|playwright|cypress|specs?)(?:\/|$)|\.(?:test|spec|e2e|e2e-spec|integration-test|fixture|fixtures|stories|story)\.[cm]?[jt]sx?$|(?:^|\/)(?:playwright|cypress|vitest|jest|karma)[^/]*\.conf(?:ig)?\.[cm]?[jt]s$|(?:^|\/)(?:test_[^/]+|[^/]+_test|conftest)\.py$|\.env\.[^/]*(?:test|e2e)[^/]*$/i;
+const TEST_CONTEXT_PATTERN = /(?:^|\/)(?:__fixtures__|__mocks__|__tests__|__integration__|fixtures|mocks|test|tests|testdata|test-data|e2e|playwright|cypress|specs?)(?:\/|$)|^(?:test|spec)-[^/]+\.[cm]?[jt]sx?$|\.(?:test|spec|e2e|e2e-spec|integration-test|fixture|fixtures|stories|story)\.[cm]?[jt]sx?$|(?:^|\/)(?:playwright|cypress|vitest|jest|karma)[^/]*\.conf(?:ig)?\.[cm]?[jt]s$|(?:^|\/)(?:test_[^/]+|[^/]+_test|conftest)\.py$|\.env\.[^/]*(?:test|e2e)[^/]*$/i;
 const BUILD_CONFIG_FILE_PATTERN = /(?:^|\/)(?:vite|next|nuxt|astro|remix|webpack|rollup|rspack|rsbuild|esbuild|tsup|metro|expo|babel|tailwind|postcss|svelte|farm|parcel|snowpack)[^/]*\.config\.[cm]?[jt]sx?$/i;
 const BUILD_SCRIPT_CONTEXT_PATTERN = /(?:^|\/)scripts(?:\/|$)/i;
 const DEMO_CONTEXT_PATTERN = /(?:^|\/)(?:examples?|tutorials?|demos?|samples?|playgrounds?)(?:\/|$)/i;
@@ -665,19 +665,6 @@ 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]/;
@@ -5887,6 +5874,7 @@ const isInlineFunctionExpression = (node) => Boolean(node && (isNodeOfType(node,
 //#endregion
 //#region src/plugin/rules/js-performance/async-await-in-loop.ts
 const LOOP_STATEMENT_TYPES$1 = new Set(LOOP_TYPES);
+const ORDERED_OUTPUT_INSERTION_METHOD_NAMES = new Set(["push", "unshift"]);
 const findFirstAwaitOutsideNestedFunctions = (block, skipNestedLoops = false) => {
 	let firstAwait = null;
 	walkAst(block, (child) => {
@@ -5953,7 +5941,151 @@ const isAwaitingManualPromiseWait = (awaitNode) => {
 	});
 	return isWaitLike;
 };
-const isIntentionallySequentialAwait = (awaitNode, context) => isAwaitingPossiblyMutatedMemberCall(awaitNode, context) || isAwaitingSleepLikeCall(awaitNode, context) || isAwaitingPromiseConcurrencyCall(awaitNode) || isAwaitingManualPromiseWait(awaitNode);
+const getRootObjectIdentifierName = (node) => {
+	let current = node;
+	while (isNodeOfType(current, "MemberExpression")) current = current.object;
+	return isNodeOfType(current, "Identifier") ? current.name : null;
+};
+const isScopeWithinFunction = (candidateScope, functionScope) => {
+	let currentScope = candidateScope;
+	while (currentScope) {
+		if (currentScope === functionScope) return true;
+		currentScope = currentScope.parent;
+	}
+	return false;
+};
+const isSymbolDirectlyReturned = (symbol, callerFunction) => Boolean(callerFunction) && symbol.references.some((reference) => {
+	const expressionRoot = findTransparentExpressionRoot(reference.identifier);
+	const parent = expressionRoot.parent;
+	return isNodeOfType(parent, "ReturnStatement") && parent.argument === expressionRoot && findEnclosingFunction$1(parent) === callerFunction;
+});
+const collectPatternBindingSymbolIds = (pattern, scopes, target) => {
+	if (isNodeOfType(pattern, "Identifier")) {
+		const symbol = scopes.symbolFor(pattern);
+		if (symbol) target.add(symbol.id);
+		return;
+	}
+	if (isNodeOfType(pattern, "ObjectPattern")) {
+		for (const property of pattern.properties ?? []) if (isNodeOfType(property, "Property") && property.value) collectPatternBindingSymbolIds(property.value, scopes, target);
+		else if (isNodeOfType(property, "RestElement") && property.argument) collectPatternBindingSymbolIds(property.argument, scopes, target);
+		return;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		for (const element of pattern.elements ?? []) if (element) collectPatternBindingSymbolIds(element, scopes, target);
+		return;
+	}
+	if (isNodeOfType(pattern, "AssignmentPattern") && pattern.left) collectPatternBindingSymbolIds(pattern.left, scopes, target);
+};
+const collectReferencedSymbolIds = (expression, scopes) => {
+	const referencedSymbolIds = /* @__PURE__ */ new Set();
+	walkAst(expression, (child) => {
+		if (child !== expression && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "Identifier")) return;
+		const symbol = scopes.symbolFor(child);
+		if (symbol) referencedSymbolIds.add(symbol.id);
+	});
+	return referencedSymbolIds;
+};
+const collectAwaitDerivedSymbolIds = (block, scopes) => {
+	const awaitDerivedSymbolIds = /* @__PURE__ */ new Set();
+	const bindingDependencies = [];
+	walkAst(block, (child) => {
+		if (child !== block && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "VariableDeclarator") && child.id && child.init) {
+			const declaredSymbolIds = /* @__PURE__ */ new Set();
+			collectPatternBindingSymbolIds(child.id, scopes, declaredSymbolIds);
+			if (containsDirectAwait(child.init)) for (const symbolId of declaredSymbolIds) awaitDerivedSymbolIds.add(symbolId);
+			const referencedSymbolIds = collectReferencedSymbolIds(child.init, scopes);
+			for (const declaredSymbolId of declaredSymbolIds) bindingDependencies.push({
+				declaredSymbolId,
+				referencedSymbolIds
+			});
+			return;
+		}
+		if (isNodeOfType(child, "AssignmentExpression") && child.left) {
+			const assignedSymbolIds = /* @__PURE__ */ new Set();
+			collectPatternBindingSymbolIds(child.left, scopes, assignedSymbolIds);
+			if (containsDirectAwait(child.right)) for (const symbolId of assignedSymbolIds) awaitDerivedSymbolIds.add(symbolId);
+			const referencedSymbolIds = collectReferencedSymbolIds(child.right, scopes);
+			for (const assignedSymbolId of assignedSymbolIds) bindingDependencies.push({
+				declaredSymbolId: assignedSymbolId,
+				referencedSymbolIds
+			});
+		}
+	});
+	let didGrow = true;
+	while (didGrow) {
+		didGrow = false;
+		for (const { declaredSymbolId, referencedSymbolIds } of bindingDependencies) {
+			if (awaitDerivedSymbolIds.has(declaredSymbolId)) continue;
+			for (const referencedSymbolId of referencedSymbolIds) {
+				if (!awaitDerivedSymbolIds.has(referencedSymbolId)) continue;
+				awaitDerivedSymbolIds.add(declaredSymbolId);
+				didGrow = true;
+				break;
+			}
+		}
+	}
+	return awaitDerivedSymbolIds;
+};
+const getSimpleParameterIdentifier = (parameter) => {
+	if (isNodeOfType(parameter, "Identifier")) return parameter;
+	if (isNodeOfType(parameter, "AssignmentPattern") && isNodeOfType(parameter.left, "Identifier")) return parameter.left;
+	return null;
+};
+const doesAwaitedLocalCallInsertAwaitDerivedOutput = (awaitNode, context) => {
+	if (!isNodeOfType(awaitNode, "AwaitExpression")) return false;
+	const callExpression = awaitNode.argument;
+	if (!isNodeOfType(callExpression, "CallExpression")) return false;
+	const localFunction = resolveStaticLocalCallFunction(callExpression, context.scopes);
+	if (!isFunctionLike$1(localFunction)) return false;
+	const callerFunction = findEnclosingFunction$1(callExpression);
+	const functionScope = context.scopes.ownScopeFor(localFunction);
+	if (!functionScope) return false;
+	const awaitDerivedSymbolIds = collectAwaitDerivedSymbolIds(localFunction.body, context.scopes);
+	const externallyReachableParameterSymbolIds = /* @__PURE__ */ new Set();
+	for (const [parameterIndex, parameter] of localFunction.params.entries()) {
+		const parameterIdentifier = getSimpleParameterIdentifier(parameter);
+		if (!parameterIdentifier) continue;
+		const argument = callExpression.arguments[parameterIndex];
+		if (!isNodeOfType(argument, "Identifier")) continue;
+		const parameterSymbol = context.scopes.symbolFor(parameterIdentifier);
+		const argumentSymbol = context.scopes.symbolFor(argument);
+		if (parameterSymbol && argumentSymbol && (isSymbolDirectlyReturned(argumentSymbol, callerFunction) || argumentSymbol.id === parameterSymbol.id)) externallyReachableParameterSymbolIds.add(parameterSymbol.id);
+	}
+	let doesInsertAwaitDerivedOutput = false;
+	walkAst(localFunction.body, (child) => {
+		if (doesInsertAwaitDerivedOutput) return false;
+		if (child !== localFunction.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = child.callee;
+		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || !ORDERED_OUTPUT_INSERTION_METHOD_NAMES.has(callee.property.name)) return;
+		let doesMutationConsumeAwaitedValue = false;
+		for (const mutationArgument of child.arguments ?? []) {
+			if (containsDirectAwait(mutationArgument)) {
+				doesMutationConsumeAwaitedValue = true;
+				break;
+			}
+			const referencedSymbolIds = collectReferencedSymbolIds(mutationArgument, context.scopes);
+			for (const referencedSymbolId of referencedSymbolIds) if (awaitDerivedSymbolIds.has(referencedSymbolId)) {
+				doesMutationConsumeAwaitedValue = true;
+				break;
+			}
+			if (doesMutationConsumeAwaitedValue) break;
+		}
+		if (!doesMutationConsumeAwaitedValue) return;
+		let receiverIdentifier = callee.object;
+		while (isNodeOfType(receiverIdentifier, "MemberExpression")) receiverIdentifier = receiverIdentifier.object;
+		if (!isNodeOfType(receiverIdentifier, "Identifier")) return;
+		const receiverSymbol = context.scopes.symbolFor(receiverIdentifier);
+		if (receiverSymbol && (externallyReachableParameterSymbolIds.has(receiverSymbol.id) || !isScopeWithinFunction(receiverSymbol.scope, functionScope) && isSymbolDirectlyReturned(receiverSymbol, callerFunction))) {
+			doesInsertAwaitDerivedOutput = true;
+			return false;
+		}
+	});
+	return doesInsertAwaitDerivedOutput;
+};
+const isIntentionallySequentialAwait = (awaitNode, context) => isAwaitingPossiblyMutatedMemberCall(awaitNode, context) || isAwaitingSleepLikeCall(awaitNode, context) || isAwaitingPromiseConcurrencyCall(awaitNode) || isAwaitingManualPromiseWait(awaitNode) || doesAwaitedLocalCallInsertAwaitDerivedOutput(awaitNode, context);
 const collectPatternIdentifiers = (pattern, target) => {
 	if (isNodeOfType(pattern, "Identifier")) target.add(pattern.name);
 	else if (isNodeOfType(pattern, "ObjectPattern")) {
@@ -6099,11 +6231,6 @@ const loopBodyHasAwaitDependentEarlyExit = (block, loopLabelName) => {
 	});
 	return hasAwaitDependentExit;
 };
-const getRootObjectIdentifierName = (node) => {
-	let current = node;
-	while (isNodeOfType(current, "MemberExpression")) current = current.object;
-	return isNodeOfType(current, "Identifier") ? current.name : null;
-};
 const MUTATING_ARRAY_METHOD_NAMES$2 = new Set([
 	...ARRAY_MUTATION_METHOD_NAMES,
 	"pop",
@@ -8675,7 +8802,7 @@ const resolveStableOptionsObject = (expression, observedPropertyNames, scopes, r
 //#endregion
 //#region src/plugin/rules/state-and-effects/class-component-missing-component-will-unmount-teardown.ts
 const MESSAGE$89 = "This class registers a listener or timer during mount without a matching teardown on every unmount path, so it can keep firing after the component unmounts; release it in `componentWillUnmount`.";
-const GLOBAL_OBJECT_NAMES$3 = new Set([
+const GLOBAL_OBJECT_NAMES$4 = new Set([
 	"window",
 	"globalThis",
 	"global",
@@ -8834,14 +8961,14 @@ const getTimerIdentifierAliasName = (identifier, scopes, visitedSymbolIds = /* @
 		const property = symbol.bindingIdentifier.parent;
 		const objectPattern = property?.parent;
 		const source = declaration.init ? stripParenExpression(declaration.init) : null;
-		if (isNodeOfType(property, "Property") && isNodeOfType(objectPattern, "ObjectPattern") && isNodeOfType(source, "Identifier") && GLOBAL_OBJECT_NAMES$3.has(source.name) && scopes.isGlobalReference(source)) return getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (isNodeOfType(property, "Property") && isNodeOfType(objectPattern, "ObjectPattern") && isNodeOfType(source, "Identifier") && GLOBAL_OBJECT_NAMES$4.has(source.name) && scopes.isGlobalReference(source)) return getStaticPropertyKeyName(property, { allowComputedString: true });
 		return null;
 	}
 	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
 	if (isNodeOfType(initializer, "Identifier")) return getTimerIdentifierAliasName(initializer, scopes, visitedSymbolIds);
 	if (!isNodeOfType(initializer, "MemberExpression")) return null;
 	const receiver = stripParenExpression(initializer.object);
-	return isNodeOfType(receiver, "Identifier") && GLOBAL_OBJECT_NAMES$3.has(receiver.name) && scopes.isGlobalReference(receiver) ? getStaticPropertyName(initializer) : null;
+	return isNodeOfType(receiver, "Identifier") && GLOBAL_OBJECT_NAMES$4.has(receiver.name) && scopes.isGlobalReference(receiver) ? getStaticPropertyName(initializer) : null;
 };
 const getTimerCalleeName = (node, scopes) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
@@ -8849,7 +8976,7 @@ const getTimerCalleeName = (node, scopes) => {
 	if (getBareCalleeName(node) && isNodeOfType(callee, "Identifier")) return getTimerIdentifierAliasName(callee, scopes);
 	if (!isNodeOfType(callee, "MemberExpression")) return null;
 	const receiver = stripParenExpression(callee.object);
-	if (!isNodeOfType(receiver, "Identifier") || !GLOBAL_OBJECT_NAMES$3.has(receiver.name) || findVariableInitializer(receiver, receiver.name)) return null;
+	if (!isNodeOfType(receiver, "Identifier") || !GLOBAL_OBJECT_NAMES$4.has(receiver.name) || findVariableInitializer(receiver, receiver.name)) return null;
 	return getStaticPropertyName(callee);
 };
 const getClassMemberName$1 = (member) => {
@@ -10045,6 +10172,12 @@ const FOCUS_FORWARDING_METHOD_NAMES = new Set([
 	"preventDefault",
 	"stopImmediatePropagation"
 ]);
+const DOM_QUERY_METHOD_NAMES = new Set(["getElementById", "querySelector"]);
+const GLOBAL_OBJECT_NAMES$3 = new Set([
+	"global",
+	"globalThis",
+	"window"
+]);
 const isFocusForwardingCall = (node) => {
 	if (!node) return false;
 	const inner = isNodeOfType(node, "ChainExpression") ? node.expression : node;
@@ -10054,6 +10187,12 @@ const isFocusForwardingCall = (node) => {
 	if (!isNodeOfType(callee.property, "Identifier")) return false;
 	return FOCUS_FORWARDING_METHOD_NAMES.has(callee.property.name);
 };
+const isGlobalDocumentExpression = (expression, scopes) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) return candidate.name === "document" && scopes.isGlobalReference(candidate);
+	if (!isNodeOfType(candidate, "MemberExpression") || !isNodeOfType(candidate.object, "Identifier") || !isNodeOfType(candidate.property, "Identifier") || candidate.property.name !== "document") return false;
+	return GLOBAL_OBJECT_NAMES$3.has(candidate.object.name) && scopes.isGlobalReference(candidate.object);
+};
 const isFocusForwardingFunctionBody = (body) => {
 	if (!body) return false;
 	if (isFocusForwardingCall(body)) return true;
@@ -10073,19 +10212,70 @@ const resolveHandlerFunction$2 = (attribute) => {
 	return resolveHandlerFunctionExpression(attribute.value.expression);
 };
 const resolveHandlerFunctionExpression = (handlerExpression) => {
-	let expression = handlerExpression;
+	let expression = stripParenExpression(handlerExpression);
 	if (isNodeOfType(expression, "Identifier")) {
 		const binding = findVariableInitializer(expression, expression.name);
 		if (!binding?.initializer) return null;
-		expression = binding.initializer;
+		expression = stripParenExpression(binding.initializer);
 	}
 	if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "FunctionDeclaration")) return expression;
 	return null;
 };
-const isFocusForwardingHandler = (attribute) => {
+const isEmptyReturn = (statement) => isNodeOfType(statement, "ReturnStatement") && statement.argument === null;
+const isClosestEarlyReturn = (statement) => {
+	if (!isNodeOfType(statement, "IfStatement") || statement.alternate) return false;
+	const consequent = statement.consequent;
+	if (!(isNodeOfType(consequent, "BlockStatement") ? consequent.body.length === 1 && isEmptyReturn(consequent.body[0]) : isEmptyReturn(consequent))) return false;
+	const test = stripParenExpression(statement.test);
+	const call = isNodeOfType(test, "ChainExpression") ? test.expression : test;
+	if (!isNodeOfType(call, "CallExpression") || call.arguments.length !== 1) return false;
+	const callee = stripParenExpression(call.callee);
+	const receiver = isNodeOfType(callee, "MemberExpression") ? stripParenExpression(callee.object) : null;
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "closest" && isNodeOfType(receiver, "MemberExpression") && isNodeOfType(receiver.object, "Identifier") && isNodeOfType(receiver.property, "Identifier") && receiver.property.name === "target" && isNodeOfType(call.arguments[0], "Literal") && typeof call.arguments[0].value === "string";
+};
+const isStaticSelectorExpression = (expression) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier") || isNodeOfType(candidate, "Literal")) return true;
+	return isNodeOfType(candidate, "TemplateLiteral") && candidate.expressions.every((innerExpression) => isStaticSelectorExpression(innerExpression));
+};
+const getDomQueryVariableName = (statement, scopes) => {
+	if (!isNodeOfType(statement, "VariableDeclaration") || statement.kind !== "const" || statement.declarations.length !== 1) return null;
+	const declaration = statement.declarations[0];
+	if (!declaration || !isNodeOfType(declaration.id, "Identifier") || !declaration.init) return null;
+	const initializer = stripParenExpression(declaration.init);
+	if (!isNodeOfType(initializer, "CallExpression") || initializer.arguments.length !== 1 || isNodeOfType(initializer.arguments[0], "SpreadElement") || !isStaticSelectorExpression(initializer.arguments[0])) return null;
+	const callee = stripParenExpression(initializer.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier") || !DOM_QUERY_METHOD_NAMES.has(callee.property.name) || !isGlobalDocumentExpression(callee.object, scopes)) return null;
+	return declaration.id.name;
+};
+const isFocusCallOnVariable = (statement, variableName) => {
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	const expression = stripParenExpression(statement.expression);
+	if (!isNodeOfType(expression, "CallExpression")) return false;
+	const callee = stripParenExpression(expression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === variableName && isNodeOfType(callee.property, "Identifier") && callee.property.name === "focus" && expression.arguments.length === 0;
+};
+const isConditionalFocusForwardingHandler = (attribute, scopes) => {
+	if (!attribute.value || !isNodeOfType(attribute.value, "JSXExpressionContainer")) return false;
+	const expression = stripParenExpression(attribute.value.expression);
+	if (!isNodeOfType(expression, "ConditionalExpression")) return false;
+	const consequent = stripParenExpression(expression.consequent);
+	const alternate = stripParenExpression(expression.alternate);
+	const nullishBranch = isNullishExpression$2(consequent) ? consequent : alternate;
+	if (!isNullishExpression$2(nullishBranch) || isNodeOfType(nullishBranch, "Identifier") && !scopes.isGlobalReference(nullishBranch)) return false;
+	const handlerFunction = resolveHandlerFunctionExpression(nullishBranch === consequent ? alternate : consequent);
+	if (!handlerFunction || !isNodeOfType(handlerFunction.body, "BlockStatement")) return false;
+	const [guard, query, focus, ...rest] = handlerFunction.body.body;
+	if (!guard || !query || !focus || rest.length > 0 || !isClosestEarlyReturn(guard)) return false;
+	const queryVariableName = getDomQueryVariableName(query, scopes);
+	return Boolean(queryVariableName && isFocusCallOnVariable(focus, queryVariableName));
+};
+const isFocusForwardingHandler = (attribute, scopes) => {
+	if (isConditionalFocusForwardingHandler(attribute, scopes)) return true;
 	const handlerFunction = resolveHandlerFunction$2(attribute);
-	if (!handlerFunction) return false;
-	return isFocusForwardingFunctionBody(handlerFunction.body ?? null);
+	return Boolean(handlerFunction && isFocusForwardingFunctionBody(handlerFunction.body ?? null));
 };
 const COMPOSITE_ITEM_ROLES$1 = new Set([
 	"option",
@@ -10155,7 +10345,7 @@ const clickEventsHaveKeyEvents = defineRule({
 			const spreadOnClickExpression = CLICK_HANDLERS.map((name) => spreadEventValues.get(name.toLowerCase())).find((expression) => expression !== void 0);
 			if (!onClick && !spreadOnClickExpression) return;
 			if (onClick && isPureEventBlockerHandler(onClick)) return;
-			if (onClick && isFocusForwardingHandler(onClick)) return;
+			if (onClick && isFocusForwardingHandler(onClick, context.scopes)) return;
 			const spreadHandlerFunction = spreadOnClickExpression ? resolveHandlerFunctionExpression(spreadOnClickExpression) : null;
 			if (spreadHandlerFunction && (isFocusForwardingFunctionBody(spreadHandlerFunction.body ?? null) || containsBackdropDismissComparison(spreadHandlerFunction.body ?? null))) return;
 			if (hasCompositeItemRole(node)) return;
@@ -17809,6 +17999,14 @@ 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
@@ -18027,13 +18225,15 @@ 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 isSynchronousIteratorCallback = (functionNode) => {
-	const callNode = functionNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
+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] === functionNode;
-	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$2.has(callee.property.name) && callNode.arguments[0] === functionNode;
+	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));
 };
 //#endregion
 //#region src/plugin/utils/is-within-assignment-target.ts
@@ -18153,11 +18353,35 @@ 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 capture = resolveEventListenerCapture(optionsNode, { allowIndeterminateEntries: true });
+	const stableOptionsNode = optionsNode ? resolveReadOnlyEventListenerOptions(optionsNode, context) : null;
+	if (optionsNode && !stableOptionsNode) return null;
+	const capture = resolveEventListenerCapture(stableOptionsNode, { allowIndeterminateEntries: true });
 	if (capture !== null) return `capture:${String(capture)}`;
-	if (!optionsNode) return null;
-	const unwrappedOptions = stripParenExpression(optionsNode);
+	if (!stableOptionsNode) return null;
+	const unwrappedOptions = stripParenExpression(stableOptionsNode);
 	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) {
 		const optionsKey = allowOpaqueOptionsIdentity ? resolveEventListenerCaptureValueIdentityKey(unwrappedOptions, context) : null;
 		return optionsKey ? `options:${optionsKey}` : null;
@@ -18204,12 +18428,8 @@ const doEventListenerCapturesMatch = (registrationOptions, releaseOptions, conte
 	return registrationCaptureKey !== null && registrationCaptureKey === resolveEventListenerCaptureIdentityKey(releaseOptions, context, allowOpaqueOptionsIdentity);
 };
 const findAssignedResourceKey = (resourceNode, context) => {
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (isNodeOfType(parentNode, "ChainExpression")) {
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
+	const currentNode = findTransparentExpressionRoot(resourceNode);
+	const 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;
@@ -18480,6 +18700,18 @@ 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);
@@ -19250,6 +19482,28 @@ 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);
@@ -19270,7 +19524,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) ?? releaseCall;
+	const releaseAnchor = findLiveExpressionGuardForRelease(releaseCall, usageFunction, releaseReceiverKey, context) ?? findCallbackRefReplacementReleaseGuard(releaseCall, usageFunction, releaseReceiverKey, registrationReceiverKey, context) ?? releaseCall;
 	const safeOwnershipAssignments = matchingOwnershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, [releaseAnchor], usageFunction, context));
 	return doNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
 };
@@ -19420,14 +19674,21 @@ 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;
-	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) 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.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;
@@ -19464,7 +19725,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.eventKey : usage.handlerKey;
+		const expectedHandlerKey = usesUnaryListenerSignatureForCalls ? usage.handlerKey ?? 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);
 	}
@@ -19938,6 +20199,7 @@ 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",
@@ -20190,6 +20452,164 @@ 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",
@@ -20200,13 +20620,19 @@ 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,
@@ -24626,14 +25052,14 @@ const getFirstLegendChild = (children, targetNode) => {
 		if (isNodeOfType(child, "JSXExpressionContainer")) {
 			const potentialLegends = [];
 			collectPotentialLegends(child.expression, potentialLegends);
-			const containingLegend = potentialLegends.find((legend) => isDescendantOf(targetNode, legend));
+			const containingLegend = potentialLegends.find((legend) => isDescendantOf$1(targetNode, legend));
 			if (containingLegend) return containingLegend;
 			if (potentialLegends[0]) return potentialLegends[0];
 		}
 	}
 	return null;
 };
-const isDescendantOf = (node, ancestor) => {
+const isDescendantOf$1 = (node, ancestor) => {
 	let current = node.parent;
 	while (current) {
 		if (current === ancestor) return true;
@@ -24658,7 +25084,7 @@ const isDisabledByFieldsetAncestor = (node, context) => {
 	while (ancestor) {
 		if (isNodeOfType(ancestor, "JSXElement") && resolveJsxElementType(ancestor.openingElement) === "fieldset" && openingElementMayBeDisabled(ancestor.openingElement, context)) {
 			const firstLegend = getFirstLegendChild(ancestor.children, node);
-			if (!firstLegend || !isDescendantOf(node, firstLegend)) return true;
+			if (!firstLegend || !isDescendantOf$1(node, firstLegend)) return true;
 		}
 		ancestor = ancestor.parent;
 	}
@@ -30471,7 +30897,8 @@ const STRING_TYPED_PROPERTY_NAMES = new Set([
 	"code",
 	"label",
 	"slug",
-	"prefix"
+	"prefix",
+	"__html"
 ]);
 const STRING_TYPED_IDENTIFIER_SUFFIXES = [
 	"Text",
@@ -30589,13 +31016,25 @@ const STRING_TYPED_IDENTIFIER_NAMES = new Set([
 	"title"
 ]);
 const STRING_RETURNING_CALLEE_PREFIX_PATTERN = /^(?:normalize|format|stringify|serialize)/;
+const FRESH_ARRAY_METHOD_NAMES$2 = new Set([
+	"concat",
+	"filter",
+	"flat",
+	"flatMap",
+	"map",
+	"slice",
+	"split"
+]);
 const isLikelyStringReceiver = (receiver) => {
 	if (!receiver) return false;
+	const unwrappedReceiver = stripParenExpression(receiver);
+	if (unwrappedReceiver !== receiver) return isLikelyStringReceiver(unwrappedReceiver);
 	if (isNodeOfType(receiver, "Literal") && typeof receiver.value === "string") return true;
 	if (isNodeOfType(receiver, "TemplateLiteral")) return true;
 	if (isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "Identifier") && receiver.callee.name === "String") return true;
 	if (isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "MemberExpression") && isNodeOfType(receiver.callee.property, "Identifier") && STRING_RETURNING_METHODS.has(receiver.callee.property.name)) return true;
 	if (isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "Identifier") && STRING_RETURNING_CALLEE_PREFIX_PATTERN.test(receiver.callee.name)) return true;
+	if (isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "MemberExpression") && isNodeOfType(receiver.callee.property, "Identifier") && (receiver.callee.property.name === "concat" || receiver.callee.property.name === "slice") && isLikelyStringReceiver(receiver.callee.object)) return true;
 	if (isNodeOfType(receiver, "MemberExpression") && isNodeOfType(receiver.property, "Identifier")) {
 		if (STRING_TYPED_PROPERTY_NAMES.has(receiver.property.name)) return true;
 	}
@@ -30613,8 +31052,46 @@ const isLikelyStringReceiver = (receiver) => {
 	}
 	if (isNodeOfType(receiver, "BinaryExpression") && receiver.operator === "+") return isLikelyStringReceiver(receiver.left) || isLikelyStringReceiver(receiver.right);
 	if (isNodeOfType(receiver, "ConditionalExpression")) return isLikelyStringReceiver(receiver.consequent) && isLikelyStringReceiver(receiver.alternate);
+	if (isNodeOfType(receiver, "LogicalExpression")) return isLikelyStringReceiver(receiver.left) && isLikelyStringReceiver(receiver.right);
 	return false;
 };
+const isFreshArrayReceiver = (receiver) => {
+	const unwrappedReceiver = stripParenExpression(receiver);
+	if (unwrappedReceiver !== receiver) return isFreshArrayReceiver(unwrappedReceiver);
+	if (!isNodeOfType(receiver, "CallExpression") || !isNodeOfType(receiver.callee, "MemberExpression") || !isNodeOfType(receiver.callee.property, "Identifier")) return false;
+	if (!FRESH_ARRAY_METHOD_NAMES$2.has(receiver.callee.property.name)) return false;
+	if (receiver.callee.property.name === "split") return isLikelyStringReceiver(receiver.callee.object);
+	const sourceReceiver = stripParenExpression(receiver.callee.object);
+	return isKnownNativeArrayReceiver(sourceReceiver) || isFreshArrayReceiver(sourceReceiver);
+};
+const isSmallRestHelperOmissionList = (node) => {
+	if (!node) return false;
+	const candidate = stripParenExpression(node);
+	if (!isNodeOfType(candidate, "ArrayExpression")) return false;
+	const elements = candidate.elements ?? [];
+	return elements.length <= 8 && elements.every((element) => element === null || !isNodeOfType(element, "SpreadElement"));
+};
+const isTypeScriptRestHelperLookup = (lookupCall, receiver, scopes) => {
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	const enclosingFunction = findEnclosingFunction$1(lookupCall);
+	if (!isNodeOfType(enclosingFunction, "FunctionExpression") || !isNodeOfType(enclosingFunction.params?.[1], "Identifier") || enclosingFunction.params[1].name !== receiver.name) return false;
+	let bindingIdentifier = null;
+	let ancestor = enclosingFunction.parent;
+	while (ancestor && !isFunctionLike$1(ancestor)) {
+		if (isNodeOfType(ancestor, "VariableDeclarator") && isNodeOfType(ancestor.id, "Identifier") && ancestor.id.name === "__rest") {
+			bindingIdentifier = ancestor.id;
+			break;
+		}
+		ancestor = ancestor.parent;
+	}
+	if (!bindingIdentifier) return false;
+	const helperSymbol = scopes.symbolFor(bindingIdentifier);
+	if (!helperSymbol || helperSymbol.references.length === 0) return false;
+	return helperSymbol.references.every((reference) => {
+		const callExpression = reference.identifier.parent;
+		return isNodeOfType(callExpression, "CallExpression") && callExpression.callee === reference.identifier && isSmallRestHelperOmissionList(callExpression.arguments?.[1]);
+	});
+};
 const INDEX_LIKE_IDENTIFIER_NAMES = new Set([
 	"i",
 	"j",
@@ -31211,6 +31688,8 @@ const jsSetMapLookups = defineRule({
 			const query = node.arguments[0];
 			if (methodName === "indexOf" && !isKnownSafeIndexOfQuery(query) && (isKnownUnsafeIndexOfQuery(query, receiver) || isKnownUnsafeIndexOfReceiver(receiver))) return;
 			if (isLikelyStringReceiver(receiver)) return;
+			if (isFreshArrayReceiver(receiver)) return;
+			if (isTypeScriptRestHelperLookup(node, receiver, context.scopes)) return;
 			if (isSmallInlineLiteralArray(receiver)) return;
 			if (isScreamingSnakeCaseConstantReceiver(receiver)) return;
 			if (isSmallFixedListMember(receiver)) return;
@@ -45124,14 +45603,6 @@ 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);
@@ -46652,6 +47123,101 @@ const isLoopCounterDeclarator = (declarator, referenceNode, indexName) => {
 	}
 	return isBindingReassignedOrMutated(referenceNode, indexName);
 };
+const findEnclosingWhileLoop = (node) => {
+	let current = node.parent;
+	while (current) {
+		if (isNodeOfType(current, "WhileStatement") || isNodeOfType(current, "DoWhileStatement")) return current;
+		if (isFunctionLike$1(current) || isNodeOfType(current, "Program")) return null;
+		current = current.parent;
+	}
+	return null;
+};
+const isStaticMemberChain = (expression) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier") || isNodeOfType(candidate, "ThisExpression")) return true;
+	return Boolean(isNodeOfType(candidate, "MemberExpression") && !candidate.computed && isNodeOfType(candidate.property, "Identifier") && isStaticMemberChain(candidate.object));
+};
+const findLengthBoundCollections = (expression) => {
+	const collections = [];
+	walkAst(expression, (child) => {
+		if (isNodeOfType(child, "MemberExpression") && !child.computed && isStaticMemberChain(child.object) && isNodeOfType(child.property, "Identifier") && child.property.name === "length") collections.push(child.object);
+	});
+	return collections;
+};
+const areSameBoundStaticMemberChains = (first, second) => isStaticMemberChain(first) && isStaticMemberChain(second) && areExpressionsStructurallyEqual(first, second, { areIdentifiersEqual: (firstIdentifier, secondIdentifier) => {
+	if (!isNodeOfType(firstIdentifier, "Identifier") || !isNodeOfType(secondIdentifier, "Identifier") || firstIdentifier.name !== secondIdentifier.name) return false;
+	const firstBinding = findVariableInitializer(firstIdentifier, firstIdentifier.name);
+	const secondBinding = findVariableInitializer(secondIdentifier, secondIdentifier.name);
+	return firstBinding?.bindingIdentifier === secondBinding?.bindingIdentifier;
+} });
+const RELATIONAL_BOUND_OPERATORS = new Set([
+	"<",
+	"<=",
+	">",
+	">="
+]);
+const loopTestBoundsCounterByLength = (expression, indexName, bindingIdentifier) => {
+	const readsCounter = (candidate) => {
+		let didReadCounter = false;
+		walkAst(candidate, (child) => {
+			if (didReadCounter) return false;
+			if (isNodeOfType(child, "Identifier") && child.name === indexName && findVariableInitializer(child, indexName)?.bindingIdentifier === bindingIdentifier) {
+				didReadCounter = true;
+				return false;
+			}
+		});
+		return didReadCounter;
+	};
+	const readsLength = (candidate) => {
+		let didReadLength = false;
+		walkAst(candidate, (child) => {
+			if (didReadLength) return false;
+			if (isNodeOfType(child, "MemberExpression") && !child.computed && isNodeOfType(child.property, "Identifier") && child.property.name === "length") {
+				didReadLength = true;
+				return false;
+			}
+		});
+		return didReadLength;
+	};
+	let didFindLengthBound = false;
+	walkAst(expression, (child) => {
+		if (didFindLengthBound) return false;
+		if (!isNodeOfType(child, "BinaryExpression") || !RELATIONAL_BOUND_OPERATORS.has(child.operator)) return;
+		if (readsCounter(child.left) && readsLength(child.right) || readsCounter(child.right) && readsLength(child.left)) {
+			didFindLengthBound = true;
+			return false;
+		}
+	});
+	return didFindLengthBound;
+};
+const isDataIndexedWhileLoopCounter = (referenceNode, bindingIdentifier, indexName) => {
+	if (!INDEX_PARAMETER_NAMES.has(indexName)) return false;
+	const loop = findEnclosingWhileLoop(referenceNode);
+	if (!loop) return false;
+	let doesTestReadCounter = false;
+	walkAst(loop.test, (child) => {
+		if (doesTestReadCounter) return false;
+		if (!isNodeOfType(child, "Identifier") || child.name !== indexName) return;
+		if (findVariableInitializer(child, indexName)?.bindingIdentifier === bindingIdentifier) {
+			doesTestReadCounter = true;
+			return false;
+		}
+	});
+	if (!doesTestReadCounter) return false;
+	const lengthBoundCollections = findLengthBoundCollections(loop.test);
+	if (lengthBoundCollections.length === 0) return false;
+	let didFindIndexedCollectionRead = false;
+	walkAst(loop.body, (child) => {
+		if (didFindIndexedCollectionRead) return false;
+		if (isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "MemberExpression") || !child.computed || !isNodeOfType(child.property, "Identifier") || child.property.name !== indexName) return;
+		if (findVariableInitializer(child.property, indexName)?.bindingIdentifier === bindingIdentifier && lengthBoundCollections.some((collection) => areSameBoundStaticMemberChains(collection, child.object))) {
+			didFindIndexedCollectionRead = true;
+			return false;
+		}
+	});
+	return didFindIndexedCollectionRead;
+};
 /**
 * Resolves whether an identifier is PROVABLY the positional array
 * index, by classifying its binding. Per the official rule prompt,
@@ -46702,6 +47268,12 @@ const resolvePositionalIndexBinding = (identifierNode, depth) => {
 	}
 	const declarator = binding.bindingIdentifier.parent;
 	if (declarator && isNodeOfType(declarator, "VariableDeclarator") && declarator.id === binding.bindingIdentifier && declarator.init) {
+		if (isDataIndexedWhileLoopCounter(identifierNode, binding.bindingIdentifier, identifierNode.name)) return {
+			iteratorCall: null,
+			bindingFunction: null,
+			indexParameterPosition: null,
+			isDataIndexedLoopCounter: true
+		};
 		const initializer = stripParenExpression(declarator.init);
 		if (isNodeOfType(initializer, "Literal") && typeof initializer.value === "number") {
 			if (!INDEX_PARAMETER_NAMES.has(identifierNode.name)) return null;
@@ -46736,6 +47308,101 @@ const iteratorCallExemptsIndexKey = (iteratorCall) => {
 	const receiver = iteratorCall.callee.object;
 	return isStaticPlaceholderReceiver(receiver) || isFixedMemoReceiver(receiver) || isStaticDefaultLiteralReceiver(receiver) || isStringDerivedReceiver(receiver);
 };
+const isReactNamespaceIdentifier = (node) => {
+	if (!isNodeOfType(node, "Identifier")) return false;
+	const importBinding = getImportBindingForName(node, node.name);
+	const visibleBinding = findVariableInitializer(node, node.name);
+	if (!importBinding) return node.name === "React" && !visibleBinding;
+	return visibleBinding?.initializer?.type.startsWith("Import") === true && importBinding.source === "react" && (importBinding.isNamespace || importBinding.exportedName === "default");
+};
+const isReactChildrenObject = (node) => {
+	const candidate = stripParenExpression(node);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const importBinding = getImportBindingForName(candidate, candidate.name);
+		const visibleBinding = findVariableInitializer(candidate, candidate.name);
+		return Boolean(visibleBinding?.initializer?.type === "ImportSpecifier" && importBinding?.source === "react" && importBinding.exportedName === "Children");
+	}
+	return Boolean(isNodeOfType(candidate, "MemberExpression") && !candidate.computed && isReactNamespaceIdentifier(candidate.object) && isNodeOfType(candidate.property, "Identifier") && candidate.property.name === "Children");
+};
+const isReactChildrenToArrayCall = (node) => {
+	const candidate = stripParenExpression(node);
+	if (!isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "MemberExpression") || candidate.callee.computed || !isReactChildrenObject(candidate.callee.object) || !isNodeOfType(candidate.callee.property, "Identifier") || candidate.callee.property.name !== "toArray") return false;
+	const normalizedValueNode = candidate.arguments?.[0];
+	const normalizedValue = normalizedValueNode ? stripParenExpression(normalizedValueNode) : null;
+	if (!normalizedValue || !isNodeOfType(normalizedValue, "Identifier") || normalizedValue.name !== "children") return false;
+	const normalizedBinding = findVariableInitializer(normalizedValue, normalizedValue.name);
+	return Boolean(normalizedBinding && findEnclosingParameter(normalizedBinding.bindingIdentifier));
+};
+const isSameIdentifier = (first, second) => {
+	const firstIdentifier = stripParenExpression(first);
+	const secondIdentifier = stripParenExpression(second);
+	if (!isNodeOfType(firstIdentifier, "Identifier") || !isNodeOfType(secondIdentifier, "Identifier") || firstIdentifier.name !== secondIdentifier.name) return false;
+	const firstBinding = findVariableInitializer(firstIdentifier, firstIdentifier.name);
+	const secondBinding = findVariableInitializer(secondIdentifier, secondIdentifier.name);
+	return firstBinding?.bindingIdentifier === secondBinding?.bindingIdentifier;
+};
+const isReactChildrenArrayNormalization = (node) => {
+	const candidate = stripParenExpression(node);
+	if (!isNodeOfType(candidate, "ConditionalExpression")) return false;
+	const test = stripParenExpression(candidate.test);
+	if (!isNodeOfType(test, "CallExpression") || !isNodeOfType(test.callee, "MemberExpression") || test.callee.computed || !isNodeOfType(test.callee.object, "Identifier") || test.callee.object.name !== "Array" || findVariableInitializer(test.callee.object, "Array") || !isNodeOfType(test.callee.property, "Identifier") || test.callee.property.name !== "isArray") return false;
+	const testedValueNode = test.arguments?.[0];
+	if (!testedValueNode) return false;
+	const testedValue = stripParenExpression(testedValueNode);
+	if (!isNodeOfType(testedValue, "Identifier")) return false;
+	const testedBinding = findVariableInitializer(testedValue, testedValue.name);
+	if (testedValue.name !== "children" || !testedBinding || !findEnclosingParameter(testedBinding.bindingIdentifier)) return false;
+	const branchWrapsTestedValue = (branch) => {
+		const unwrappedBranch = stripParenExpression(branch);
+		return isNodeOfType(unwrappedBranch, "ArrayExpression") && unwrappedBranch.elements?.length === 1 && Boolean(unwrappedBranch.elements[0] && isSameIdentifier(unwrappedBranch.elements[0], testedValue));
+	};
+	return isSameIdentifier(candidate.consequent, testedValue) && branchWrapsTestedValue(candidate.alternate) || isSameIdentifier(candidate.alternate, testedValue) && branchWrapsTestedValue(candidate.consequent);
+};
+const isMutatedEmptyArrayBinding = (identifierNode, depth) => {
+	const binding = findVariableInitializer(identifierNode, identifierNode.name);
+	const initializer = binding?.initializer ? stripParenExpression(binding.initializer) : null;
+	if (!binding || !initializer || !isNodeOfType(initializer, "ArrayExpression") || initializer.elements?.length !== 0) return false;
+	const program = findProgramRoot(identifierNode);
+	if (!program) return false;
+	let didFindReactChildPush = false;
+	walkAst(program, (child) => {
+		if (didFindReactChildPush) return false;
+		if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "MemberExpression") || child.callee.computed || !isNodeOfType(child.callee.object, "Identifier") || child.callee.object.name !== identifierNode.name || !isNodeOfType(child.callee.property, "Identifier") || child.callee.property.name !== "push") return;
+		if (findVariableInitializer(child.callee.object, identifierNode.name)?.bindingIdentifier === binding.bindingIdentifier && (child.arguments ?? []).some((argument) => {
+			const candidate = stripParenExpression(argument);
+			if (!(isNodeOfType(candidate, "Identifier") || isNodeOfType(candidate, "JSXElement") || isNodeOfType(candidate, "JSXFragment"))) return false;
+			let doesCarryReactChild = false;
+			walkAst(candidate, (argumentChild) => {
+				if (doesCarryReactChild) return false;
+				if (!isNodeOfType(argumentChild, "Identifier")) return;
+				const declarator = findVariableInitializer(argumentChild, argumentChild.name)?.bindingIdentifier.parent;
+				const declaration = declarator?.parent;
+				const forOfStatement = declaration?.parent;
+				if (declarator && isNodeOfType(declarator, "VariableDeclarator") && declaration && isNodeOfType(declaration, "VariableDeclaration") && forOfStatement && isNodeOfType(forOfStatement, "ForOfStatement") && forOfStatement.left === declaration && isDynamicReactChildrenExpression(forOfStatement.right, depth + 1)) {
+					doesCarryReactChild = true;
+					return false;
+				}
+			});
+			return doesCarryReactChild;
+		})) {
+			didFindReactChildPush = true;
+			return false;
+		}
+	});
+	return didFindReactChildPush;
+};
+const isDynamicReactChildrenExpression = (expression, depth) => {
+	if (depth > TYPE_RESOLUTION_DEPTH_LIMIT$2) return false;
+	const candidate = stripParenExpression(expression);
+	if (isReactChildrenToArrayCall(candidate) || isReactChildrenArrayNormalization(candidate)) return true;
+	if (isNodeOfType(candidate, "Identifier")) {
+		if (isMutatedEmptyArrayBinding(candidate, depth)) return true;
+		const binding = findVariableInitializer(candidate, candidate.name);
+		return Boolean(binding?.initializer && isDynamicReactChildrenExpression(binding.initializer, depth + 1));
+	}
+	if (isNodeOfType(candidate, "CallExpression") && isNodeOfType(candidate.callee, "MemberExpression") && !candidate.callee.computed && isNodeOfType(candidate.callee.property, "Identifier") && candidate.callee.property.name === "filter") return isDynamicReactChildrenExpression(candidate.callee.object, depth + 1);
+	return false;
+};
 const resolveKeyTemplateLiteral = (expression) => {
 	const node = stripParenExpression(expression);
 	if (isNodeOfType(node, "TemplateLiteral")) return node;
@@ -46788,28 +47455,19 @@ const findBareItemNamesReferencedByTemplate = (template, itemNames) => {
 	}
 	return referencedItemNames;
 };
-const forLoopTestReadsDataLength = (test) => {
-	let didFindLengthRead = false;
-	walkAst(test, (child) => {
-		if (didFindLengthRead) return false;
-		if (isNodeOfType(child, "MemberExpression") && isNodeOfType(child.property, "Identifier") && child.property.name === "length") {
-			didFindLengthRead = true;
-			return false;
-		}
-	});
-	return didFindLengthRead;
-};
-const isNumericForLoopCounter = (attributeNode, indexName) => {
+const isNumericPlaceholderLoopCounter = (attributeNode, indexName) => {
 	const binding = findVariableInitializer(attributeNode, indexName);
 	if (!binding) return false;
 	const declarator = binding.bindingIdentifier.parent;
 	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
 	const declaration = declarator.parent;
 	if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) return false;
+	if (!declarator.init || !isNodeOfType(declarator.init, "Literal") || typeof declarator.init.value !== "number") return false;
 	const forStatement = declaration.parent;
-	if (!forStatement || !isNodeOfType(forStatement, "ForStatement") || forStatement.init !== declaration || !declarator.init || !isNodeOfType(declarator.init, "Literal") || typeof declarator.init.value !== "number") return false;
-	if (forStatement.test && forLoopTestReadsDataLength(forStatement.test)) return false;
-	return true;
+	if (forStatement && isNodeOfType(forStatement, "ForStatement") && forStatement.init === declaration) return !(forStatement.test && loopTestBoundsCounterByLength(forStatement.test, indexName, binding.bindingIdentifier));
+	const whileLoop = findEnclosingWhileLoop(attributeNode);
+	if (!whileLoop) return false;
+	return !loopTestBoundsCounterByLength(whileLoop.test, indexName, binding.bindingIdentifier);
 };
 const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
 const findIteratorItemNamesOfBinding = (binding) => {
@@ -46843,11 +47501,11 @@ const collectDerivedRowContentNames = (bindingFunction, itemNames) => {
 * observable harm; anything stateful — form controls, media, custom
 * components, unknown calls — keeps the diagnostic.
 */
-const fragmentHasStatefulChildren = (openingElement, itemNames, derivedNames) => {
+const fragmentHasStatefulChildren = (openingElement, itemNames, derivedNames, areBareItemsDynamicReactChildren) => {
 	const jsxElement = openingElement.parent;
 	if (!jsxElement || !isNodeOfType(jsxElement, "JSXElement")) return false;
 	const children = jsxElement.children ?? [];
-	const bareIdentifierNames = children.some((child) => isNodeOfType(child, "JSXElement")) ? derivedNames : new Set([...derivedNames, ...itemNames]);
+	const bareIdentifierNames = children.some((child) => isNodeOfType(child, "JSXElement")) ? derivedNames : areBareItemsDynamicReactChildren ? derivedNames : new Set([...derivedNames, ...itemNames]);
 	return children.some((child) => containsStatefulDescendant(child, {
 		memberRootNames: itemNames,
 		allowAnyMemberRead: true,
@@ -46855,6 +47513,15 @@ const fragmentHasStatefulChildren = (openingElement, itemNames, derivedNames) =>
 		callCalleeRootNames: itemNames
 	}));
 };
+const elementHasDirectItemChild = (openingElement, itemNames) => {
+	const jsxElement = openingElement.parent;
+	if (!jsxElement || !isNodeOfType(jsxElement, "JSXElement")) return false;
+	return (jsxElement.children ?? []).some((child) => {
+		if (!isNodeOfType(child, "JSXExpressionContainer")) return false;
+		const expression = stripParenExpression(child.expression);
+		return isNodeOfType(expression, "Identifier") && itemNames.has(expression.name);
+	});
+};
 const callbackFiltersRows = (bindingFunction) => {
 	if (!bindingFunction) return false;
 	let didFindNullReturn = false;
@@ -46906,19 +47573,21 @@ const noArrayIndexAsKey = defineRule({
 		const indexUse = findPositionalIndexUse(node.value.expression, 0);
 		if (!indexUse) return;
 		const indexName = indexUse.identifier.name;
-		if (isNumericForLoopCounter(node, indexName)) return;
+		if (isNumericPlaceholderLoopCounter(node, indexName)) return;
 		if (indexUse.binding.iteratorCall && iteratorCallExemptsIndexKey(indexUse.binding.iteratorCall)) return;
 		const keyTemplate = resolveKeyTemplateLiteral(node.value.expression);
 		if (keyTemplate && templateHasOuterMemberIdentity(keyTemplate, indexUse.binding.bindingFunction)) return;
-		if (hasAriaHiddenAncestor(node)) return;
+		if (hasAriaHiddenAncestor(node) && !indexUse.binding.isDataIndexedLoopCounter) return;
 		const itemNames = findIteratorItemNamesOfBinding(indexUse.binding);
 		const derivedNames = collectDerivedRowContentNames(indexUse.binding.bindingFunction, itemNames);
+		const iteratorCallee = indexUse.binding.iteratorCall?.callee;
+		const hasDynamicReactChildren = Boolean(iteratorCallee && isNodeOfType(iteratorCallee, "MemberExpression") && isDynamicReactChildrenExpression(iteratorCallee.object, 0));
 		const openingElement = node.parent;
 		if (openingElement && isNodeOfType(openingElement, "JSXOpeningElement")) {
 			const elementName = openingElement.name;
 			if (isNodeOfType(elementName, "JSXIdentifier")) {
 				if (elementName.name === "Fragment") {
-					if (!fragmentHasStatefulChildren(openingElement, itemNames, derivedNames)) return;
+					if (!fragmentHasStatefulChildren(openingElement, itemNames, derivedNames, hasDynamicReactChildren)) return;
 				} else if (PURE_SVG_PRIMITIVE_TAGS.has(elementName.name)) {
 					if (!callbackFiltersRows(indexUse.binding.bindingFunction)) return;
 				} else if (STATELESS_HTML_LEAF_TAGS.has(elementName.name)) {
@@ -46926,14 +47595,14 @@ const noArrayIndexAsKey = defineRule({
 					if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
 						const isInlineTextRun = INLINE_TEXT_LEAF_TAGS.has(elementName.name);
 						const primitiveItemNames = keyTemplate ? findBareItemNamesReferencedByTemplate(keyTemplate, itemNames) : EMPTY_NAME_SET$1;
-						if (!containsStatefulDescendant(jsxElement, {
+						if (!(hasDynamicReactChildren && elementHasDirectItemChild(openingElement, itemNames) || containsStatefulDescendant(jsxElement, {
 							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET$1,
 							bareIdentifierNames: primitiveItemNames.size > 0 ? new Set([...derivedNames, ...primitiveItemNames]) : derivedNames
-						})) return;
+						}))) return;
 					}
 				}
 			}
-			if (isNodeOfType(elementName, "JSXMemberExpression") && isNodeOfType(elementName.object, "JSXIdentifier") && isNodeOfType(elementName.property, "JSXIdentifier") && elementName.object.name === "React" && elementName.property.name === "Fragment" && !fragmentHasStatefulChildren(openingElement, itemNames, derivedNames)) return;
+			if (isNodeOfType(elementName, "JSXMemberExpression") && isNodeOfType(elementName.object, "JSXIdentifier") && isNodeOfType(elementName.property, "JSXIdentifier") && elementName.object.name === "React" && elementName.property.name === "Fragment" && !fragmentHasStatefulChildren(openingElement, itemNames, derivedNames, hasDynamicReactChildren)) return;
 		}
 		context.report({
 			node,
@@ -63829,6 +64498,106 @@ const isGatedByFalsyInitialState = (node, scopes) => {
 };
 //#endregion
 //#region src/plugin/rules/performance/no-hydration-branch-on-browser-global.ts
+const findGuardingIfStatements = (node, functionBoundary) => {
+	const guardingIfStatements = [];
+	let currentNode = node.parent;
+	while (currentNode && currentNode !== functionBoundary) {
+		if (isNodeOfType(currentNode, "IfStatement")) guardingIfStatements.push(currentNode);
+		currentNode = currentNode.parent;
+	}
+	return guardingIfStatements;
+};
+const doesNodeReadSymbol = (node, symbol) => {
+	let doesReadSymbol = false;
+	walkAst(node, (childNode) => {
+		if (isNodeOfType(childNode, "Identifier") && symbol.references.some((reference) => reference.identifier === childNode && reference.flag !== "write")) {
+			doesReadSymbol = true;
+			return false;
+		}
+	});
+	return doesReadSymbol;
+};
+const collectWrittenSymbols = (node, scopes) => {
+	const writtenSymbols = /* @__PURE__ */ new Set();
+	walkAst(node, (childNode) => {
+		if (childNode !== node && isFunctionLike$1(childNode)) return false;
+		if (!isNodeOfType(childNode, "Identifier")) return;
+		const reference = scopes.referenceFor(childNode);
+		if (!reference || reference.flag === "read" || !reference.resolvedSymbol) return;
+		writtenSymbols.add(reference.resolvedSymbol);
+	});
+	return writtenSymbols;
+};
+const isDescendantOf = (node, ancestorNode) => {
+	let currentNode = node.parent;
+	while (currentNode) {
+		if (currentNode === ancestorNode) return true;
+		currentNode = currentNode.parent;
+	}
+	return false;
+};
+const getAssignedValue = (identifier) => {
+	const assignmentExpression = identifier.parent;
+	return isNodeOfType(assignmentExpression, "AssignmentExpression") && assignmentExpression.operator === "=" && assignmentExpression.left === identifier ? assignmentExpression.right : null;
+};
+const doesGuardPreserveInitialSymbolValue = (symbol, guardingIfStatement, scopes) => {
+	const initialValue = symbol.initializer;
+	if (!initialValue) return false;
+	const guardedWrites = symbol.references.filter((reference) => reference.flag !== "read" && isDescendantOf(reference.identifier, guardingIfStatement));
+	return guardedWrites.length > 0 && guardedWrites.every((reference) => {
+		const assignedValue = getAssignedValue(reference.identifier);
+		return Boolean(assignedValue && areExpressionsStructurallyEqual(initialValue, assignedValue) && doEquivalentExpressionBindingsMatch(initialValue, assignedValue, scopes));
+	});
+};
+const isWriteOverwrittenBefore = (symbol, writeIdentifier, guardingIfStatement, readIdentifier, context) => symbol.references.some((reference) => reference.flag !== "read" && reference.identifier !== writeIdentifier && !isDescendantOf(reference.identifier, guardingIfStatement) && isNodeReachableWithinFunction(reference.identifier, context) && isUnconditionalOrStaticallySelected(reference.identifier, context) && getNodeStartIndex(reference.identifier) > getNodeStartIndex(writeIdentifier) && getNodeStartIndex(reference.identifier) < getNodeStartIndex(readIdentifier));
+const isUnconditionalOrStaticallySelected = (node, context) => {
+	if (context.cfg.isUnconditionalFromEntry(node)) return true;
+	let currentNode = node;
+	let outermostStaticIfStatement = null;
+	let parentNode = currentNode.parent;
+	while (parentNode) {
+		if (isFunctionLike$1(parentNode)) break;
+		if (isNodeOfType(parentNode, "IfStatement")) {
+			const staticResult = readInitialStateBoolean(parentNode.test, context.scopes);
+			let selectedBranch = null;
+			if (staticResult === true) selectedBranch = parentNode.consequent;
+			if (staticResult === false) selectedBranch = parentNode.alternate;
+			if (!selectedBranch || currentNode !== selectedBranch && !isDescendantOf(currentNode, selectedBranch)) return false;
+			outermostStaticIfStatement = parentNode;
+		}
+		currentNode = parentNode;
+		parentNode = currentNode.parent;
+	}
+	return Boolean(outermostStaticIfStatement && context.cfg.isUnconditionalFromEntry(outermostStaticIfStatement));
+};
+const containsExplicitReactRuntimeReference = (node, scopes) => {
+	let hasRuntimeReference = false;
+	walkAst(node, (childNode) => {
+		if (isNodeOfType(childNode, "ImportDeclaration") && typeof childNode.source.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(childNode.source.value)) {
+			hasRuntimeReference = true;
+			return false;
+		}
+		if (!isNodeOfType(childNode, "CallExpression")) return;
+		const sourceArgument = (childNode.arguments ?? [])[0];
+		if (!isNodeOfType(childNode.callee, "Identifier") || childNode.callee.name !== "require" || !scopes.isGlobalReference(childNode.callee) || !isNodeOfType(sourceArgument, "Literal") || typeof sourceArgument.value !== "string" || !REACT_RUNTIME_MODULE_SOURCES.has(sourceArgument.value)) return;
+		hasRuntimeReference = true;
+		return false;
+	});
+	return hasRuntimeReference;
+};
+const findComponentRenderingLocalFunctionResult = (functionNode, scopes) => {
+	const bindingIdentifier = getDirectFunctionBindingIdentifier(functionNode);
+	if (!isNodeOfType(bindingIdentifier, "Identifier")) return null;
+	const functionSymbol = scopes.symbolFor(bindingIdentifier);
+	if (!functionSymbol) return null;
+	for (const reference of functionSymbol.references) {
+		const callExpression = reference.identifier.parent;
+		if (!isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== reference.identifier) continue;
+		const componentOrHookNode = findRenderPhaseComponentOrHook(callExpression, scopes);
+		if (componentOrHookNode && isInRenderedOutput(callExpression, componentOrHookNode, scopes)) return componentOrHookNode;
+	}
+	return null;
+};
 const evaluateEquality$1 = (operator, left, right) => {
 	if (operator === "===" || operator === "==") return left === right;
 	if (operator === "!==" || operator === "!=") return left !== right;
@@ -63879,6 +64648,107 @@ const readLogicalConditionResult = (operator, leftResult, rightResult) => {
 	if (leftResult === false && rightResult === false) return false;
 	return null;
 };
+const areLooselyEqualPrimitiveResults = (left, right) => {
+	if (left.kind === right.kind) return left.value === right.value;
+	if (left.kind === "null" && right.kind === "undefined" || left.kind === "undefined" && right.kind === "null") return true;
+	if (left.kind === "boolean") return areLooselyEqualPrimitiveResults({
+		kind: "number",
+		value: left.value ? 1 : 0
+	}, right);
+	if (right.kind === "boolean") return areLooselyEqualPrimitiveResults(left, {
+		kind: "number",
+		value: right.value ? 1 : 0
+	});
+	if (left.kind === "number" && right.kind === "string") return left.value === Number(right.value);
+	if (left.kind === "string" && right.kind === "number") return Number(left.value) === right.value;
+	return false;
+};
+const readHydrationPrimitiveResult = (expression, context, runtime, state) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
+	if (predicateMatch) return {
+		kind: "boolean",
+		value: predicateMatch[`${runtime}Result`]
+	};
+	if (isNodeOfType(unwrappedExpression, "Literal")) {
+		const value = unwrappedExpression.value;
+		if (value === null) return {
+			kind: "null",
+			value
+		};
+		if (typeof value === "boolean") return {
+			kind: "boolean",
+			value
+		};
+		if (typeof value === "number") return {
+			kind: "number",
+			value
+		};
+		if (typeof value === "string") return {
+			kind: "string",
+			value
+		};
+		return null;
+	}
+	if (isNodeOfType(unwrappedExpression, "Identifier") && unwrappedExpression.name === "undefined" && context.scopes.isGlobalReference(unwrappedExpression)) return {
+		kind: "undefined",
+		value: void 0
+	};
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = context.scopes.symbolFor(unwrappedExpression);
+		const parameterValue = symbol ? state.parameterValuesBySymbolId.get(symbol.id) : null;
+		if (symbol && parameterValue && !state.visitedSymbolIds.has(symbol.id)) {
+			state.visitedSymbolIds.add(symbol.id);
+			const result = readHydrationPrimitiveResult(parameterValue, context, runtime, state);
+			state.visitedSymbolIds.delete(symbol.id);
+			return result;
+		}
+		if (symbol && symbol.kind === "const" && symbol.initializer && symbol.references.every((reference) => reference.flag === "read") && !state.visitedSymbolIds.has(symbol.id)) {
+			state.visitedSymbolIds.add(symbol.id);
+			const result = readHydrationPrimitiveResult(symbol.initializer, context, runtime, state);
+			state.visitedSymbolIds.delete(symbol.id);
+			return result;
+		}
+	}
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
+		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime, state);
+		return argumentResult === null ? null : {
+			kind: "boolean",
+			value: !argumentResult
+		};
+	}
+	if (isNodeOfType(unwrappedExpression, "BinaryExpression")) {
+		const leftResult = readHydrationPrimitiveResult(unwrappedExpression.left, context, runtime, state);
+		const rightResult = readHydrationPrimitiveResult(unwrappedExpression.right, context, runtime, state);
+		if (!leftResult || !rightResult) return null;
+		if (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "!==") {
+			const areEqual = leftResult.kind === rightResult.kind && leftResult.value === rightResult.value;
+			return {
+				kind: "boolean",
+				value: unwrappedExpression.operator === "===" ? areEqual : !areEqual
+			};
+		}
+		if (unwrappedExpression.operator === "==" || unwrappedExpression.operator === "!=") {
+			const areEqual = areLooselyEqualPrimitiveResults(leftResult, rightResult);
+			return {
+				kind: "boolean",
+				value: unwrappedExpression.operator === "==" ? areEqual : !areEqual
+			};
+		}
+	}
+	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
+		const callArguments = unwrappedExpression.arguments ?? [];
+		const callee = stripParenExpression(unwrappedExpression.callee);
+		if (isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee) && callArguments.length === 1 && !isNodeOfType(callArguments[0], "SpreadElement")) {
+			const argumentResult = readHydrationConditionResult(callArguments[0], context, runtime, state);
+			return argumentResult === null ? null : {
+				kind: "boolean",
+				value: argumentResult
+			};
+		}
+	}
+	return null;
+};
 const readHydrationConditionResult = (expression, context, runtime, state) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
@@ -63927,6 +64797,10 @@ const readHydrationConditionResult = (expression, context, runtime, state) => {
 			parameterValuesBySymbolId
 		});
 	}
+	if (isNodeOfType(unwrappedExpression, "BinaryExpression")) {
+		const result = readHydrationPrimitiveResult(unwrappedExpression, context, runtime, state);
+		return result?.kind === "boolean" && typeof result.value === "boolean" ? result.value : null;
+	}
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
 		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime, state);
 		return argumentResult === null ? null : !argumentResult;
@@ -63987,13 +64861,19 @@ const doEquivalentExpressionBindingsMatch = (leftExpression, rightExpression, sc
 		const rightSymbol = scopes.symbolFor(right);
 		return leftSymbol || rightSymbol ? leftSymbol?.id === rightSymbol?.id : true;
 	}
-	if (isNodeOfType(left, "MemberExpression") && isNodeOfType(right, "MemberExpression")) return doEquivalentExpressionBindingsMatch(left.object, right.object, scopes) && (!left.computed || doEquivalentExpressionBindingsMatch(left.property, right.property, scopes));
-	if (isNodeOfType(left, "CallExpression") && isNodeOfType(right, "CallExpression")) {
-		const rightArguments = right.arguments ?? [];
-		return doEquivalentExpressionBindingsMatch(left.callee, right.callee, scopes) && (left.arguments ?? []).every((argument, index) => {
-			const rightArgument = rightArguments[index];
-			return Boolean(rightArgument && doEquivalentExpressionBindingsMatch(argument, rightArgument, scopes));
-		});
+	const rightEntries = new Map(Object.entries(right));
+	for (const [key, leftValue] of Object.entries(left)) {
+		if (key === "parent") continue;
+		const rightValue = rightEntries.get(key);
+		if (isAstNode(leftValue)) {
+			if (!isAstNode(rightValue) || !doEquivalentExpressionBindingsMatch(leftValue, rightValue, scopes)) return false;
+			continue;
+		}
+		if (!Array.isArray(leftValue)) continue;
+		if (!Array.isArray(rightValue)) return false;
+		const leftNodes = leftValue.filter(isAstNode);
+		const rightNodes = rightValue.filter(isAstNode);
+		if (leftNodes.length !== rightNodes.length || leftNodes.some((leftNode, index) => !rightNodes[index] || !doEquivalentExpressionBindingsMatch(leftNode, rightNodes[index], scopes))) return false;
 	}
 	return true;
 };
@@ -64007,6 +64887,57 @@ const doHelperReturnValuesDiffer = (leftValues, rightValues, context) => {
 	const everyValueHasEquivalent = (values, candidateValues) => values.every((value) => candidateValues.some((candidateValue) => areHelperReturnValuesEquivalent(value, candidateValue, context)));
 	return !everyValueHasEquivalent(leftValues, rightValues) || !everyValueHasEquivalent(rightValues, leftValues);
 };
+const isExpressionProvablyReflexive = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (matchBrowserPredicate(unwrappedExpression, context)) return true;
+	if (isNodeOfType(unwrappedExpression, "Literal")) return typeof unwrappedExpression.value !== "number" || !Number.isNaN(unwrappedExpression.value);
+	if (isNodeOfType(unwrappedExpression, "Identifier") && unwrappedExpression.name === "undefined" && context.scopes.isGlobalReference(unwrappedExpression)) return true;
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = context.scopes.symbolFor(unwrappedExpression);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || !symbol.initializer) return false;
+		visitedSymbolIds.add(symbol.id);
+		const assignedValues = symbol.references.filter((reference) => reference.flag !== "read").map((reference) => getAssignedValue(reference.identifier));
+		const isReflexive = isExpressionProvablyReflexive(symbol.initializer, context, visitedSymbolIds) && assignedValues.every((assignedValue) => Boolean(assignedValue && isExpressionProvablyReflexive(assignedValue, context, visitedSymbolIds)));
+		visitedSymbolIds.delete(symbol.id);
+		return isReflexive;
+	}
+	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) return isExpressionProvablyReflexive(unwrappedExpression.consequent, context, visitedSymbolIds) && isExpressionProvablyReflexive(unwrappedExpression.alternate, context, visitedSymbolIds);
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && (unwrappedExpression.operator === "!" || unwrappedExpression.operator === "typeof" || unwrappedExpression.operator === "void")) return true;
+	if (isNodeOfType(unwrappedExpression, "BinaryExpression")) return unwrappedExpression.operator === "===" || unwrappedExpression.operator === "!==" || unwrappedExpression.operator === "==" || unwrappedExpression.operator === "!=";
+	if (isNodeOfType(unwrappedExpression, "ArrayExpression") || isNodeOfType(unwrappedExpression, "ObjectExpression") || isNodeOfType(unwrappedExpression, "FunctionExpression") || isNodeOfType(unwrappedExpression, "ArrowFunctionExpression") || isNodeOfType(unwrappedExpression, "TemplateLiteral")) return true;
+	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return false;
+	const callee = stripParenExpression(unwrappedExpression.callee);
+	return isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee);
+};
+const getReturnedObjectPropertyValues = (node, propertyName, scopes) => {
+	if (isNodeOfType(node, "ReturnStatement")) return node.argument ? getReturnedObjectPropertyValues(node.argument, propertyName, scopes) : [];
+	if (isNodeOfType(node, "ObjectExpression")) return node.properties.flatMap((property) => isNodeOfType(property, "Property") && property.kind === "init" && getResolvedStaticPropertyName(property, scopes) === propertyName ? [property.value] : []);
+	if (isNodeOfType(node, "IfStatement")) return [...getReturnedObjectPropertyValues(node.consequent, propertyName, scopes), ...node.alternate ? getReturnedObjectPropertyValues(node.alternate, propertyName, scopes) : []];
+	if (isNodeOfType(node, "TryStatement")) return [
+		...getReturnedObjectPropertyValues(node.block, propertyName, scopes),
+		...node.handler ? getReturnedObjectPropertyValues(node.handler.body, propertyName, scopes) : [],
+		...node.finalizer ? getReturnedObjectPropertyValues(node.finalizer, propertyName, scopes) : []
+	];
+	if (!isNodeOfType(node, "BlockStatement")) return [];
+	const propertyValues = [];
+	for (const childStatement of node.body) {
+		propertyValues.push(...getReturnedObjectPropertyValues(childStatement, propertyName, scopes));
+		if (statementAlwaysExits$1(childStatement)) break;
+	}
+	return propertyValues;
+};
+const matchHydrationFunctionPropertyResult = (functionNode, propertyName, context, state) => {
+	if (!isFunctionLike$1(functionNode) || state.visitedFunctionNodes.has(functionNode)) return null;
+	state.visitedFunctionNodes.add(functionNode);
+	const propertyValues = getReturnedObjectPropertyValues(functionNode.body, propertyName, context.scopes);
+	let match = null;
+	for (const propertyValue of propertyValues) {
+		match = matchHydrationConditionInternal(propertyValue, context, state);
+		if (match) break;
+	}
+	state.visitedFunctionNodes.delete(functionNode);
+	return match;
+};
 const matchHydrationConditionInternal = (expression, context, state) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
@@ -64023,14 +64954,90 @@ const matchHydrationConditionInternal = (expression, context, state) => {
 			state.visitedSymbolIds.delete(symbol.id);
 			return match;
 		}
+		if (symbol && (symbol.kind === "let" || symbol.kind === "var") && !state.visitedSymbolIds.has(symbol.id)) {
+			state.visitedSymbolIds.add(symbol.id);
+			if (symbol.initializer && symbol.references.every((reference) => reference.flag === "read")) {
+				const match = matchHydrationConditionInternal(symbol.initializer, context, state);
+				state.visitedSymbolIds.delete(symbol.id);
+				return match;
+			}
+			for (const reference of symbol.references) {
+				if (reference.flag === "read") continue;
+				if (!isNodeReachableWithinFunction(reference.identifier, context)) continue;
+				const enclosingFunction = findEnclosingFunction$1(reference.identifier);
+				if (!enclosingFunction) continue;
+				for (const guardingIfStatement of findGuardingIfStatements(reference.identifier, enclosingFunction)) {
+					if (doesGuardPreserveInitialSymbolValue(symbol, guardingIfStatement, context.scopes) || isWriteOverwrittenBefore(symbol, reference.identifier, guardingIfStatement, unwrappedExpression, context)) continue;
+					const match = matchHydrationConditionInternal(guardingIfStatement.test, context, state);
+					if (match) {
+						state.visitedSymbolIds.delete(symbol.id);
+						return match;
+					}
+				}
+			}
+			const readingFunction = findEnclosingFunction$1(unwrappedExpression);
+			for (const reference of symbol.references) {
+				if (reference.flag === "read") continue;
+				const writingFunction = findEnclosingFunction$1(reference.identifier);
+				if (!readingFunction || !isFunctionLike$1(writingFunction) || writingFunction === readingFunction || writingFunction.async || writingFunction.params.length > 0 || isNodeOfType(writingFunction, "FunctionDeclaration") && writingFunction.generator || isNodeOfType(writingFunction, "FunctionExpression") && writingFunction.generator) continue;
+				const assignedValue = getAssignedValue(reference.identifier);
+				if (symbol.initializer && assignedValue && areExpressionsStructurallyEqual(symbol.initializer, assignedValue) && doEquivalentExpressionBindingsMatch(symbol.initializer, assignedValue, context.scopes)) continue;
+				const functionBinding = getDirectFunctionBindingIdentifier(writingFunction);
+				if (!isNodeOfType(functionBinding, "Identifier")) continue;
+				const functionSymbol = context.scopes.symbolFor(functionBinding);
+				if (!functionSymbol) continue;
+				for (const functionReference of functionSymbol.references) {
+					const callExpression = functionReference.identifier.parent;
+					if (!isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== functionReference.identifier || (callExpression.arguments ?? []).length > 0 || findEnclosingFunction$1(callExpression) !== readingFunction || !isNodeReachableWithinFunction(callExpression, context) || getNodeStartIndex(callExpression) >= getNodeStartIndex(unwrappedExpression)) continue;
+					for (const guardingIfStatement of findGuardingIfStatements(callExpression, readingFunction)) {
+						if (isWriteOverwrittenBefore(symbol, callExpression, guardingIfStatement, unwrappedExpression, context)) continue;
+						const match = matchHydrationConditionInternal(guardingIfStatement.test, context, state);
+						if (match) {
+							state.visitedSymbolIds.delete(symbol.id);
+							return match;
+						}
+					}
+				}
+			}
+			state.visitedSymbolIds.delete(symbol.id);
+		}
 		if (!symbol || symbol.kind !== "const" || !symbol.initializer || symbol.references.some((reference) => reference.flag !== "read") || state.visitedSymbolIds.has(symbol.id)) return null;
 		state.visitedSymbolIds.add(symbol.id);
 		const match = matchHydrationConditionInternal(symbol.initializer, context, state);
 		state.visitedSymbolIds.delete(symbol.id);
 		return match;
 	}
+	if (isNodeOfType(unwrappedExpression, "MemberExpression")) {
+		const propertyName = getResolvedStaticPropertyName(unwrappedExpression, context.scopes, {
+			allowConstNumericLiteral: true,
+			stringifyNonStringLiterals: true
+		});
+		const object = stripParenExpression(unwrappedExpression.object);
+		if (propertyName === null || !isNodeOfType(object, "CallExpression")) return null;
+		const callArguments = object.arguments ?? [];
+		if (isReactApiCall(object, "useMemo", context.scopes, {
+			allowGlobalReactNamespace: true,
+			resolveNamedAliases: true
+		})) {
+			const callbackArgument = callArguments[0];
+			if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
+			const callbackFunction = resolveExactLocalFunction(callbackArgument, context.scopes);
+			return isFunctionLike$1(callbackFunction) && callbackFunction.params.length === 0 ? matchHydrationFunctionPropertyResult(callbackFunction, propertyName, context, state) : null;
+		}
+		const helperFunction = resolveExactLocalFunction(object.callee, context.scopes);
+		return isFunctionLike$1(helperFunction) && helperFunction.params.length === 0 && callArguments.length === 0 ? matchHydrationFunctionPropertyResult(helperFunction, propertyName, context, state) : null;
+	}
 	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
 		const callArguments = unwrappedExpression.arguments ?? [];
+		if (isReactApiCall(unwrappedExpression, "useState", context.scopes, {
+			allowGlobalReactNamespace: true,
+			resolveNamedAliases: true
+		})) {
+			const initialState = callArguments[0];
+			if (!initialState || isNodeOfType(initialState, "SpreadElement")) return null;
+			const lazyInitializer = resolveExactLocalFunction(initialState, context.scopes);
+			return isFunctionLike$1(lazyInitializer) && lazyInitializer.params.length === 0 ? matchHydrationFunctionResult(lazyInitializer, context, state) : matchHydrationConditionInternal(initialState, context, state);
+		}
 		if (isReactApiCall(unwrappedExpression, "useMemo", context.scopes, {
 			allowGlobalReactNamespace: true,
 			resolveNamedAliases: true
@@ -64058,6 +65065,22 @@ const matchHydrationConditionInternal = (expression, context, state) => {
 		});
 	}
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationConditionInternal(unwrappedExpression.argument, context, state);
+	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
+		const staticTestResult = readInitialStateBoolean(unwrappedExpression.test, context.scopes);
+		if (staticTestResult !== null) return matchHydrationConditionInternal(staticTestResult ? unwrappedExpression.consequent : unwrappedExpression.alternate, context, state);
+		return matchHydrationConditionInternal(unwrappedExpression.test, context, state) ?? matchHydrationConditionInternal(unwrappedExpression.consequent, context, state) ?? matchHydrationConditionInternal(unwrappedExpression.alternate, context, state);
+	}
+	if (isNodeOfType(unwrappedExpression, "BinaryExpression")) {
+		if (unwrappedExpression.operator !== "===" && unwrappedExpression.operator !== "!==" && unwrappedExpression.operator !== "==" && unwrappedExpression.operator !== "!=") return null;
+		const leftMatch = matchHydrationConditionInternal(unwrappedExpression.left, context, state);
+		const rightMatch = matchHydrationConditionInternal(unwrappedExpression.right, context, state);
+		const nestedMatch = leftMatch ?? rightMatch;
+		if (!nestedMatch) return null;
+		const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client", state);
+		const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server", state);
+		if (clientResult !== null && serverResult !== null) return clientResult !== serverResult ? nestedMatch : null;
+		return leftMatch && rightMatch && areExpressionsStructurallyEqual(unwrappedExpression.left, unwrappedExpression.right) && doEquivalentExpressionBindingsMatch(unwrappedExpression.left, unwrappedExpression.right, context.scopes) && isExpressionProvablyReflexive(unwrappedExpression.left, context) ? null : nestedMatch;
+	}
 	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
 	const leftMatch = matchHydrationConditionInternal(unwrappedExpression.left, context, state);
 	const rightMatch = matchHydrationConditionInternal(unwrappedExpression.right, context, state);
@@ -64074,8 +65097,13 @@ const matchHydrationReturningStatement = (statement, context, state) => {
 		const consequentValues = getReturnedValues(statement.consequent);
 		const alternateValues = statement.alternate ? getReturnedValues(statement.alternate) : findFollowingReturnedValues(statement);
 		if (conditionMatch && consequentValues.length > 0 && alternateValues.length > 0 && doHelperReturnValuesDiffer(consequentValues, alternateValues, context)) return conditionMatch;
+		if (conditionMatch) {
+			const followingReturnedValues = findFollowingReturnedValues(statement);
+			if ([...new Set([...collectWrittenSymbols(statement.consequent, context.scopes), ...statement.alternate ? collectWrittenSymbols(statement.alternate, context.scopes) : []])].some((symbol) => !doesGuardPreserveInitialSymbolValue(symbol, statement, context.scopes) && followingReturnedValues.some((value) => doesNodeReadSymbol(value, symbol)))) return conditionMatch;
+		}
 		return matchHydrationReturningStatement(statement.consequent, context, state) ?? (statement.alternate ? matchHydrationReturningStatement(statement.alternate, context, state) : null);
 	}
+	if (isNodeOfType(statement, "TryStatement")) return matchHydrationReturningStatement(statement.block, context, state) ?? (statement.handler ? matchHydrationReturningStatement(statement.handler.body, context, state) : null) ?? (statement.finalizer ? matchHydrationReturningStatement(statement.finalizer, context, state) : null);
 	if (!isNodeOfType(statement, "BlockStatement")) return null;
 	for (const childStatement of statement.body) {
 		const match = matchHydrationReturningStatement(childStatement, context, state);
@@ -64096,47 +65124,62 @@ const matchHydrationCondition = (expression, context) => matchHydrationCondition
 	visitedFunctionNodes: /* @__PURE__ */ new Set(),
 	visitedSymbolIds: /* @__PURE__ */ new Set()
 });
-const areNodeArraysEquivalent = (leftNodes, rightNodes) => leftNodes.length === rightNodes.length && leftNodes.every((leftNode, index) => areRenderedBranchesEquivalent(leftNode, rightNodes[index]));
-const areRenderedBranchesEquivalent = (leftNode, rightNode) => {
+const areNodeArraysEquivalent = (leftNodes, rightNodes, scopes) => leftNodes.length === rightNodes.length && leftNodes.every((leftNode, index) => areRenderedBranchesEquivalent(leftNode, rightNodes[index], scopes));
+const areRenderedBranchesEquivalent = (leftNode, rightNode, scopes) => {
 	if (!leftNode || !rightNode) return leftNode === rightNode;
 	const left = stripParenExpression(leftNode);
 	const right = stripParenExpression(rightNode);
-	if (areExpressionsStructurallyEqual(left, right)) return true;
+	if (areExpressionsStructurallyEqual(left, right)) return doEquivalentExpressionBindingsMatch(left, right, scopes);
 	if (left.type !== right.type) return false;
 	if (isNodeOfType(left, "JSXText") && isNodeOfType(right, "JSXText")) return left.value === right.value;
 	if (isNodeOfType(left, "JSXExpressionContainer") && isNodeOfType(right, "JSXExpressionContainer")) {
 		if (!isAstNode(left.expression) || !isAstNode(right.expression)) return left.expression.type === right.expression.type;
-		return areRenderedBranchesEquivalent(left.expression, right.expression);
+		return areRenderedBranchesEquivalent(left.expression, right.expression, scopes);
 	}
 	if (isNodeOfType(left, "JSXElement") && isNodeOfType(right, "JSXElement")) {
 		if (flattenJsxName$1(left.openingElement.name) !== flattenJsxName$1(right.openingElement.name)) return false;
-		if (!areNodeArraysEquivalent(left.openingElement.attributes, right.openingElement.attributes)) return false;
-		return areNodeArraysEquivalent(left.children, right.children);
+		if (!areNodeArraysEquivalent(left.openingElement.attributes, right.openingElement.attributes, scopes)) return false;
+		return areNodeArraysEquivalent(left.children, right.children, scopes);
 	}
-	if (isNodeOfType(left, "JSXFragment") && isNodeOfType(right, "JSXFragment")) return areNodeArraysEquivalent(left.children, right.children);
+	if (isNodeOfType(left, "JSXFragment") && isNodeOfType(right, "JSXFragment")) return areNodeArraysEquivalent(left.children, right.children, scopes);
 	if (isNodeOfType(left, "JSXAttribute") && isNodeOfType(right, "JSXAttribute")) {
 		if (flattenJsxName$1(left.name) !== flattenJsxName$1(right.name)) return false;
-		return areRenderedBranchesEquivalent(left.value, right.value);
+		return areRenderedBranchesEquivalent(left.value, right.value, scopes);
 	}
-	if (isNodeOfType(left, "JSXSpreadAttribute") && isNodeOfType(right, "JSXSpreadAttribute")) return areRenderedBranchesEquivalent(left.argument, right.argument);
+	if (isNodeOfType(left, "JSXSpreadAttribute") && isNodeOfType(right, "JSXSpreadAttribute")) return areRenderedBranchesEquivalent(left.argument, right.argument, scopes);
 	if (isNodeOfType(left, "TemplateLiteral") && isNodeOfType(right, "TemplateLiteral")) {
 		if (left.quasis.length !== right.quasis.length) return false;
 		if (!left.quasis.every((quasi, index) => quasi.value.cooked === right.quasis[index]?.value.cooked && quasi.value.raw === right.quasis[index]?.value.raw)) return false;
-		return areNodeArraysEquivalent(left.expressions, right.expressions);
+		return areNodeArraysEquivalent(left.expressions, right.expressions, scopes);
 	}
 	return false;
 };
-const isRenderedValue = (node) => {
+const isProvenReactCreateElementCall = (node, scopes) => {
+	if (isReactApiCall(node, "createElement", scopes, {
+		allowGlobalReactNamespace: true,
+		resolveNamedAliases: true
+	})) return true;
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "createElement") return false;
+	const receiver = stripParenExpression(callee.object);
+	const namespaceIdentifier = isNodeOfType(receiver, "MemberExpression") && !receiver.computed && isNodeOfType(receiver.property, "Identifier") && receiver.property.name === "default" ? stripParenExpression(receiver.object) : receiver;
+	if (!isNodeOfType(namespaceIdentifier, "Identifier")) return false;
+	const namespaceSymbol = scopes.symbolFor(namespaceIdentifier);
+	return Boolean(namespaceSymbol?.initializer && namespaceSymbol.references.every((reference) => reference.flag === "read") && containsExplicitReactRuntimeReference(namespaceSymbol.initializer, scopes));
+};
+const isRenderedValue = (node, scopes) => {
 	const unwrappedNode = stripParenExpression(node);
 	if (isNodeOfType(unwrappedNode, "Literal")) return unwrappedNode.value !== null && unwrappedNode.value !== true && unwrappedNode.value !== false && unwrappedNode.value !== "";
 	if (isNodeOfType(unwrappedNode, "TemplateLiteral")) return unwrappedNode.expressions.length > 0 || unwrappedNode.quasis[0]?.value.cooked !== "";
+	if (isNodeOfType(unwrappedNode, "CallExpression")) return isProvenReactCreateElementCall(unwrappedNode, scopes);
 	return isNodeOfType(unwrappedNode, "JSXElement") || isNodeOfType(unwrappedNode, "JSXFragment");
 };
-const findRenderedValueInAndBranch = (node) => {
+const findRenderedValueInAndBranch = (node, scopes) => {
 	const unwrappedNode = stripParenExpression(node);
-	if (isRenderedValue(unwrappedNode)) return unwrappedNode;
+	if (isPotentiallyRenderedValue(unwrappedNode, scopes)) return unwrappedNode;
 	if (!isNodeOfType(unwrappedNode, "LogicalExpression") || unwrappedNode.operator !== "&&") return null;
-	return findRenderedValueInAndBranch(unwrappedNode.right);
+	return findRenderedValueInAndBranch(unwrappedNode.right, scopes);
 };
 const findEnclosingJsxAttribute = (node) => {
 	let currentNode = node.parent;
@@ -64169,6 +65212,11 @@ const getReturnedValues = (statement) => {
 	if (!statement) return [];
 	if (isNodeOfType(statement, "ReturnStatement")) return statement.argument ? [statement.argument] : [];
 	if (isNodeOfType(statement, "IfStatement")) return [...getReturnedValues(statement.consequent), ...getReturnedValues(statement.alternate)];
+	if (isNodeOfType(statement, "TryStatement")) return [
+		...getReturnedValues(statement.block),
+		...getReturnedValues(statement.handler?.body),
+		...getReturnedValues(statement.finalizer)
+	];
 	if (!isNodeOfType(statement, "BlockStatement")) return [];
 	const returnedValues = [];
 	for (const childStatement of statement.body) {
@@ -64177,6 +65225,127 @@ const getReturnedValues = (statement) => {
 	}
 	return returnedValues;
 };
+const isPotentiallyRenderedValueInternal = (node, scopes, visitedFunctionNodes) => {
+	const unwrappedNode = stripParenExpression(node);
+	if (isRenderedValue(unwrappedNode, scopes)) return true;
+	if (isNodeOfType(unwrappedNode, "ConditionalExpression")) return isPotentiallyRenderedValueInternal(unwrappedNode.consequent, scopes, visitedFunctionNodes) && isPotentiallyRenderedValueInternal(unwrappedNode.alternate, scopes, visitedFunctionNodes);
+	if (isNodeOfType(unwrappedNode, "LogicalExpression")) return isPotentiallyRenderedValueInternal(unwrappedNode.right, scopes, visitedFunctionNodes);
+	if (!isNodeOfType(unwrappedNode, "CallExpression")) return false;
+	const calledFunction = resolveExactLocalFunction(unwrappedNode.callee, scopes);
+	if (!isFunctionLike$1(calledFunction) || visitedFunctionNodes.has(calledFunction)) return false;
+	visitedFunctionNodes.add(calledFunction);
+	const returnedValues = isNodeOfType(calledFunction.body, "BlockStatement") ? getReturnedValues(calledFunction.body) : [calledFunction.body];
+	const isPotentiallyRendered = returnedValues.length > 0 && returnedValues.every((returnedValue) => isPotentiallyRenderedValueInternal(returnedValue, scopes, visitedFunctionNodes));
+	visitedFunctionNodes.delete(calledFunction);
+	return isPotentiallyRendered;
+};
+const isPotentiallyRenderedValue = (node, scopes) => isPotentiallyRenderedValueInternal(node, scopes, /* @__PURE__ */ new Set());
+const findUseStateBindingSymbol = (node, componentOrHookNode, scopes) => {
+	let currentNode = node.parent;
+	while (currentNode && currentNode !== componentOrHookNode) {
+		if (isNodeOfType(currentNode, "CallExpression") && isReactApiCall(currentNode, "useState", scopes, {
+			allowGlobalReactNamespace: true,
+			resolveNamedAliases: true
+		}) && isNodeOfType(currentNode.parent, "VariableDeclarator") && isNodeOfType(currentNode.parent.id, "ArrayPattern")) {
+			const stateBinding = currentNode.parent.id.elements?.[0];
+			return isNodeOfType(stateBinding, "Identifier") ? scopes.symbolFor(stateBinding) : null;
+		}
+		if (isFunctionLike$1(currentNode)) return null;
+		currentNode = currentNode.parent;
+	}
+	return null;
+};
+const doesReferenceControlStructuralRenderedValue = (referenceIdentifier) => {
+	let currentNode = referenceIdentifier;
+	let parentNode = currentNode.parent;
+	while (parentNode) {
+		if (isNodeOfType(parentNode, "ConditionalExpression") && parentNode.test === currentNode && (isStructuralRenderedValue(parentNode.consequent) || isStructuralRenderedValue(parentNode.alternate))) return true;
+		if (isNodeOfType(parentNode, "LogicalExpression") && parentNode.left === currentNode && isStructuralRenderedValue(parentNode.right)) return true;
+		if (isNodeOfType(parentNode, "JSXExpressionContainer") || isFunctionLike$1(parentNode)) return false;
+		currentNode = parentNode;
+		parentNode = currentNode.parent;
+	}
+	return false;
+};
+const isRenderedHydrationConsumer = (node, producerHookNode, scopes) => {
+	const renderingComponent = findRenderPhaseComponentOrHook(node, scopes);
+	return Boolean(renderingComponent && renderingComponent !== producerHookNode && isInRenderedOutput(node, renderingComponent, scopes) && !isGatedByFalsyInitialState(node, scopes) && !isAfterClientOnlyEarlyReturn(node, renderingComponent, scopes) && (!hasSuppressHydrationWarningAttribute(findEnclosingJsxOpeningElement(node)) || doesReferenceControlStructuralRenderedValue(node)));
+};
+const doesConsumerExpressionReachRenderedOutput = (node, producerHookNode, scopes, visitedSymbolIds) => {
+	if (isRenderedHydrationConsumer(node, producerHookNode, scopes)) return true;
+	const parentNode = node.parent;
+	if (!isNodeOfType(parentNode, "VariableDeclarator") || parentNode.init !== node || !isNodeOfType(parentNode.id, "Identifier")) return false;
+	const aliasSymbol = scopes.symbolFor(parentNode.id);
+	if (!aliasSymbol || visitedSymbolIds.has(aliasSymbol.id)) return false;
+	visitedSymbolIds.add(aliasSymbol.id);
+	const doesReachRenderedOutput = aliasSymbol.references.some((reference) => doesConsumerExpressionReachRenderedOutput(reference.identifier, producerHookNode, scopes, visitedSymbolIds));
+	visitedSymbolIds.delete(aliasSymbol.id);
+	return doesReachRenderedOutput;
+};
+const doesConsumerBindingReachRenderedOutput = (bindingIdentifier, producerHookNode, scopes) => {
+	if (!isNodeOfType(bindingIdentifier, "Identifier")) return false;
+	const consumerSymbol = scopes.symbolFor(bindingIdentifier);
+	if (!consumerSymbol) return false;
+	return consumerSymbol.references.some((reference) => doesConsumerExpressionReachRenderedOutput(reference.identifier, producerHookNode, scopes, new Set([consumerSymbol.id])));
+};
+const getReturnedStatePaths = (returnedValue, stateSymbol, scopes) => {
+	const unwrappedValue = stripParenExpression(returnedValue);
+	if (isNodeOfType(unwrappedValue, "ObjectExpression")) return unwrappedValue.properties.flatMap((property) => {
+		if (!isNodeOfType(property, "Property") || property.kind !== "init" || !doesNodeReadSymbol(property.value, stateSymbol)) return [];
+		const propertyName = getResolvedStaticPropertyName(property, scopes);
+		return propertyName === null ? [] : [{
+			kind: "property",
+			key: propertyName
+		}];
+	});
+	if (isNodeOfType(unwrappedValue, "ArrayExpression")) return (unwrappedValue.elements ?? []).flatMap((element, index) => element && isAstNode(element) && doesNodeReadSymbol(element, stateSymbol) ? [{
+		kind: "index",
+		key: String(index)
+	}] : []);
+	return doesNodeReadSymbol(unwrappedValue, stateSymbol) ? [{
+		kind: "direct",
+		key: null
+	}] : [];
+};
+const doesCallResultPathReachRenderedOutput = (callExpression, returnedStatePath, producerHookNode, scopes) => {
+	const callParent = callExpression.parent;
+	if (returnedStatePath.kind === "direct") return doesConsumerExpressionReachRenderedOutput(callExpression, producerHookNode, scopes, /* @__PURE__ */ new Set());
+	if (isNodeOfType(callParent, "MemberExpression") && callParent.object === callExpression && getResolvedStaticPropertyName(callParent, scopes, {
+		allowConstNumericLiteral: true,
+		stringifyNonStringLiterals: true
+	}) === returnedStatePath.key) return doesConsumerExpressionReachRenderedOutput(callParent, producerHookNode, scopes, /* @__PURE__ */ new Set());
+	if (!isNodeOfType(callParent, "VariableDeclarator") || callParent.init !== callExpression) return false;
+	if (returnedStatePath.kind === "property" && isNodeOfType(callParent.id, "ObjectPattern")) return callParent.id.properties.some((property) => isNodeOfType(property, "Property") && getResolvedStaticPropertyName(property, scopes) === returnedStatePath.key && doesConsumerBindingReachRenderedOutput(property.value, producerHookNode, scopes));
+	if (returnedStatePath.kind === "index" && isNodeOfType(callParent.id, "ArrayPattern")) {
+		const element = callParent.id.elements?.[Number(returnedStatePath.key)];
+		return Boolean(element && doesConsumerBindingReachRenderedOutput(element, producerHookNode, scopes));
+	}
+	if (!isNodeOfType(callParent.id, "Identifier")) return false;
+	const resultSymbol = scopes.symbolFor(callParent.id);
+	if (!resultSymbol) return false;
+	return resultSymbol.references.some((reference) => {
+		const memberExpression = reference.identifier.parent;
+		return Boolean(isNodeOfType(memberExpression, "MemberExpression") && memberExpression.object === reference.identifier && getResolvedStaticPropertyName(memberExpression, scopes, {
+			allowConstNumericLiteral: true,
+			stringifyNonStringLiterals: true
+		}) === returnedStatePath.key && doesConsumerExpressionReachRenderedOutput(memberExpression, producerHookNode, scopes, new Set([resultSymbol.id])));
+	});
+};
+const isReturnedUseStateInitializerRendered = (node, componentOrHookNode, scopes) => {
+	if (!isFunctionLike$1(componentOrHookNode)) return false;
+	const stateSymbol = findUseStateBindingSymbol(node, componentOrHookNode, scopes);
+	if (!stateSymbol) return false;
+	const returnedStatePaths = (isNodeOfType(componentOrHookNode.body, "BlockStatement") ? getReturnedValues(componentOrHookNode.body) : [componentOrHookNode.body]).flatMap((returnedValue) => getReturnedStatePaths(returnedValue, stateSymbol, scopes));
+	if (returnedStatePaths.length === 0) return false;
+	const functionBinding = getDirectFunctionBindingIdentifier(componentOrHookNode);
+	if (!isNodeOfType(functionBinding, "Identifier")) return false;
+	const functionSymbol = scopes.symbolFor(functionBinding);
+	if (!functionSymbol) return false;
+	return functionSymbol.references.some((functionReference) => {
+		const callExpression = functionReference.identifier.parent;
+		return Boolean(isNodeOfType(callExpression, "CallExpression") && callExpression.callee === functionReference.identifier && returnedStatePaths.some((returnedStatePath) => doesCallResultPathReachRenderedOutput(callExpression, returnedStatePath, componentOrHookNode, scopes)));
+	});
+};
 const findFollowingReturnedValues = (ifStatement) => {
 	const parentNode = ifStatement.parent;
 	if (!isNodeOfType(parentNode, "BlockStatement")) return [];
@@ -64189,24 +65358,24 @@ const findFollowingReturnedValues = (ifStatement) => {
 	}
 	return returnedValues;
 };
-const areConditionExpressionsEquivalent = (leftExpression, rightExpression) => {
+const areConditionExpressionsEquivalent = (leftExpression, rightExpression, scopes) => {
 	const left = stripParenExpression(leftExpression);
 	const right = stripParenExpression(rightExpression);
-	if (areExpressionsStructurallyEqual(left, right)) return true;
+	if (areExpressionsStructurallyEqual(left, right)) return doEquivalentExpressionBindingsMatch(left, right, scopes);
 	if (left.type !== right.type) return false;
-	if (isNodeOfType(left, "UnaryExpression") && isNodeOfType(right, "UnaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.argument, right.argument);
-	if (isNodeOfType(left, "LogicalExpression") && isNodeOfType(right, "LogicalExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left) && areConditionExpressionsEquivalent(left.right, right.right);
-	if (isNodeOfType(left, "BinaryExpression") && isNodeOfType(right, "BinaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left) && areConditionExpressionsEquivalent(left.right, right.right);
+	if (isNodeOfType(left, "UnaryExpression") && isNodeOfType(right, "UnaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.argument, right.argument, scopes);
+	if (isNodeOfType(left, "LogicalExpression") && isNodeOfType(right, "LogicalExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left, scopes) && areConditionExpressionsEquivalent(left.right, right.right, scopes);
+	if (isNodeOfType(left, "BinaryExpression") && isNodeOfType(right, "BinaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left, scopes) && areConditionExpressionsEquivalent(left.right, right.right, scopes);
 	return false;
 };
-const areReturnTreesEquivalent = (leftStatement, rightStatement) => {
+const areReturnTreesEquivalent = (leftStatement, rightStatement, scopes) => {
 	if (!leftStatement || !rightStatement) return leftStatement === rightStatement;
-	if (isNodeOfType(leftStatement, "ReturnStatement") && isNodeOfType(rightStatement, "ReturnStatement")) return areRenderedBranchesEquivalent(leftStatement.argument, rightStatement.argument);
-	if (isNodeOfType(leftStatement, "IfStatement") && isNodeOfType(rightStatement, "IfStatement")) return areConditionExpressionsEquivalent(leftStatement.test, rightStatement.test) && areReturnTreesEquivalent(leftStatement.consequent, rightStatement.consequent) && areReturnTreesEquivalent(leftStatement.alternate, rightStatement.alternate);
+	if (isNodeOfType(leftStatement, "ReturnStatement") && isNodeOfType(rightStatement, "ReturnStatement")) return areRenderedBranchesEquivalent(leftStatement.argument, rightStatement.argument, scopes);
+	if (isNodeOfType(leftStatement, "IfStatement") && isNodeOfType(rightStatement, "IfStatement")) return areConditionExpressionsEquivalent(leftStatement.test, rightStatement.test, scopes) && areReturnTreesEquivalent(leftStatement.consequent, rightStatement.consequent, scopes) && areReturnTreesEquivalent(leftStatement.alternate, rightStatement.alternate, scopes);
 	if (!isNodeOfType(leftStatement, "BlockStatement") || !isNodeOfType(rightStatement, "BlockStatement")) return false;
 	const leftReturningStatements = leftStatement.body.filter((statement) => getReturnedValues(statement).length > 0);
 	const rightReturningStatements = rightStatement.body.filter((statement) => getReturnedValues(statement).length > 0);
-	return leftReturningStatements.length === rightReturningStatements.length && leftReturningStatements.every((statement, index) => areReturnTreesEquivalent(statement, rightReturningStatements[index]));
+	return leftReturningStatements.length === rightReturningStatements.length && leftReturningStatements.every((statement, index) => areReturnTreesEquivalent(statement, rightReturningStatements[index], scopes));
 };
 const isStructuralRenderedValue = (node) => {
 	if (!node) return false;
@@ -64230,19 +65399,22 @@ const noHydrationBranchOnBrowserGlobal = defineRule({
 		if (isTestlikeFilename(context.filename)) return {};
 		if (classifyReactNativeFileTarget(context) === "react-native") return {};
 		let fileHasUseClientDirective = false;
+		let fileHasExplicitReactRuntimeReference = false;
 		let fileIsEmailTemplate = false;
 		const reportedNodes = /* @__PURE__ */ new Set();
-		const reportHydrationBranch = (conditionNode, leftBranch, rightBranch, requiresRenderedContext) => {
+		const reportHydrationBranch = (conditionNode, leftBranch, rightBranch, requiresRenderedContext, hasProvenRenderedConsumer = false) => {
 			const conditionMatch = matchHydrationCondition(conditionNode, context);
 			if (!conditionMatch) return;
 			const { predicateMatch, predicateNode } = conditionMatch;
 			if (reportedNodes.has(predicateNode)) return;
-			if (rightBranch && areRenderedBranchesEquivalent(leftBranch, rightBranch)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(conditionNode, context.scopes);
+			if (rightBranch && areRenderedBranchesEquivalent(leftBranch, rightBranch, context.scopes)) return;
+			const enclosingFunction = findEnclosingFunction$1(conditionNode);
+			const componentOrHookNode = findRenderPhaseComponentOrHook(conditionNode, context.scopes) ?? (enclosingFunction ? findComponentRenderingLocalFunctionResult(enclosingFunction, context.scopes) : null);
 			if (!componentOrHookNode) return;
-			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (requiresRenderedContext && !isInRenderedOutput(conditionNode, componentOrHookNode, context.scopes)) return;
-			if (!isRenderedValue(leftBranch) && (!rightBranch || !isRenderedValue(rightBranch))) {
+			const hasRenderedLocalFunctionConsumer = Boolean(enclosingFunction && enclosingFunction !== componentOrHookNode && findComponentRenderingLocalFunctionResult(enclosingFunction, context.scopes) === componentOrHookNode);
+			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective) && !fileHasExplicitReactRuntimeReference) return;
+			if (requiresRenderedContext && !isInRenderedOutput(conditionNode, componentOrHookNode, context.scopes) && !hasRenderedLocalFunctionConsumer) return;
+			if (!hasProvenRenderedConsumer && !(requiresRenderedContext ? isPotentiallyRenderedValue(leftBranch, context.scopes) : isRenderedValue(leftBranch, context.scopes)) && (!rightBranch || !(requiresRenderedContext ? isPotentiallyRenderedValue(rightBranch, context.scopes) : isRenderedValue(rightBranch, context.scopes)))) {
 				const attribute = findEnclosingJsxAttribute(conditionNode);
 				if (!attribute || isEventHandlerAttribute(attribute)) return;
 			}
@@ -64261,28 +65433,31 @@ const noHydrationBranchOnBrowserGlobal = defineRule({
 		return {
 			Program(node) {
 				fileHasUseClientDirective = hasDirective(node, "use client");
+				fileHasExplicitReactRuntimeReference = containsExplicitReactRuntimeReference(node, context.scopes);
 				fileIsEmailTemplate = hasEmailTemplateImport(node);
 			},
 			ConditionalExpression(node) {
 				reportHydrationBranch(node.test, node.consequent, node.alternate, true);
+				const componentOrHookNode = findRenderPhaseComponentOrHook(node, context.scopes);
+				if (componentOrHookNode && isReturnedUseStateInitializerRendered(node, componentOrHookNode, context.scopes)) reportHydrationBranch(node.test, node.consequent, node.alternate, false, true);
 			},
 			LogicalExpression(node) {
 				if (node.operator !== "&&" && node.operator !== "||") return;
-				const renderedValue = node.operator === "&&" ? findRenderedValueInAndBranch(node.right) : isRenderedValue(node.right) ? node.right : null;
+				const renderedValue = node.operator === "&&" ? findRenderedValueInAndBranch(node.right, context.scopes) : isPotentiallyRenderedValue(node.right, context.scopes) ? node.right : null;
 				if (!renderedValue) return;
 				reportHydrationBranch(node, renderedValue, null, true);
 			},
 			IfStatement(node) {
-				if (node.alternate && areReturnTreesEquivalent(node.consequent, node.alternate)) return;
+				if (node.alternate && areReturnTreesEquivalent(node.consequent, node.alternate, context.scopes)) return;
 				const consequentValues = getReturnedValues(node.consequent);
 				const alternateValues = node.alternate ? getReturnedValues(node.alternate) : findFollowingReturnedValues(node);
 				if (consequentValues.length === 0 || alternateValues.length === 0) return;
-				const componentOrHookNode = findRenderPhaseComponentOrHook(node.test, context.scopes);
-				if (!componentOrHookNode) return;
 				const enclosingFunction = findEnclosingFunction$1(node);
-				if (enclosingFunction !== componentOrHookNode && (!enclosingFunction || !isInRenderedOutput(enclosingFunction, componentOrHookNode, context.scopes))) return;
+				const componentOrHookNode = findRenderPhaseComponentOrHook(node.test, context.scopes) ?? (enclosingFunction ? findComponentRenderingLocalFunctionResult(enclosingFunction, context.scopes) : null);
+				if (!componentOrHookNode) return;
+				if (enclosingFunction !== componentOrHookNode && (!enclosingFunction || !isInRenderedOutput(enclosingFunction, componentOrHookNode, context.scopes) && findComponentRenderingLocalFunctionResult(enclosingFunction, context.scopes) !== componentOrHookNode)) return;
 				for (const consequentValue of consequentValues) for (const alternateValue of alternateValues) {
-					if (!isRenderedValue(consequentValue) && !isRenderedValue(alternateValue)) continue;
+					if (!isRenderedValue(consequentValue, context.scopes) && !isRenderedValue(alternateValue, context.scopes)) continue;
 					reportHydrationBranch(node.test, consequentValue, alternateValue, false);
 				}
 			}
@@ -73823,6 +74998,29 @@ 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;
@@ -73863,6 +75061,26 @@ 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);
@@ -73871,11 +75089,17 @@ 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 || !isNodeOfType(initializer, "CallExpression")) return false;
+	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 (!isOptionalResultPath && !isImmediatelyGuardedFinderResult(assertion, resultSymbol, resultPath, context)) return false;
-	const finderCallee = stripParenExpression(initializer.callee);
+	const finderCallee = stripParenExpression(finderCall.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 = initializer.arguments[1];
+	const predicateArgument = finderCall.arguments[1];
 	if (!predicateArgument) return false;
 	const predicateFunction = resolveExactLocalFunction(predicateArgument, context.scopes);
 	if (!predicateFunction || !isFunctionLike$1(predicateFunction)) return false;
@@ -73899,6 +75123,43 @@ 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) => {
@@ -73999,6 +75260,123 @@ 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);
@@ -74022,15 +75400,15 @@ const unwrapFalseBooleanGuard = (test) => {
 };
 const isEnsureThenMapGet = (assertion, receiver, lookupKey, context) => {
 	const stableLookupKey = stripParenExpression(lookupKey);
-	if (!isNodeOfType(stableLookupKey, "Identifier") && !isNodeOfType(stableLookupKey, "Literal")) return false;
+	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;
 	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)) {
@@ -74050,7 +75428,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]))) continue;
+				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 (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;
@@ -74160,6 +75538,7 @@ 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") {
@@ -74169,6 +75548,7 @@ 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") {
@@ -88308,6 +89688,11 @@ const noUndersizedIconButton = defineRule({
 //#region src/plugin/rules/correctness/no-unescaped-dynamic-string-in-regexp.ts
 const TEST_CONTEXT_FILE_PATTERN = /(\.test\.|\.spec\.|__tests__|(^|\/)(test|tests|e2e|cypress|playwright)\/)/;
 const SEARCH_TERM_NAME_PATTERN = /search|query|highlight|filter|term(?!in)|keyword/i;
+const REGEX_SOURCE_WORDS = [
+	"pattern",
+	"regex",
+	"regexp"
+];
 const ESCAPE_HELPER_NAME_PATTERN = /escape.*reg|safe.*reg/i;
 const SANITIZED_NAME_PATTERN = /escap|sanitiz/i;
 const INITIALIZER_RESOLUTION_HOPS = 2;
@@ -88461,14 +89846,70 @@ const isTypePositionIdentifier = (identifier) => {
 	}
 	return false;
 };
-const collectRawSearchTermIdentifiers = (argument) => {
-	const rawSearchTermIdentifiers = [];
+const identifierNameHasPathSegmentSemantics = (identifierName) => {
+	const identifierWords = identifierName.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_]+/).map((word) => word.toLowerCase());
+	if (identifierWords.some((word) => REGEX_SOURCE_WORDS.includes(word))) return false;
+	return identifierWords.some((word) => [
+		"path",
+		"folder",
+		"directory",
+		"root"
+	].includes(word)) || identifierWords.includes("top") && identifierWords.includes("level");
+};
+const flattenPatternParts = (expression) => {
+	const inner = stripParenExpression(expression);
+	const staticValue = literalStringValue(inner);
+	if (staticValue !== null) return [staticValue];
+	if (isNodeOfType(inner, "Identifier")) return [inner];
+	if (isNodeOfType(inner, "TemplateLiteral")) {
+		const parts = [];
+		for (let index = 0; index < inner.quasis.length; index += 1) {
+			const quasi = inner.quasis[index];
+			if (quasi) parts.push(quasi.value.cooked ?? quasi.value.raw);
+			const templateExpression = inner.expressions[index];
+			if (templateExpression) parts.push(stripParenExpression(templateExpression));
+		}
+		return parts;
+	}
+	if (isNodeOfType(inner, "BinaryExpression") && inner.operator === "+") {
+		const leftParts = flattenPatternParts(inner.left);
+		const rightParts = flattenPatternParts(inner.right);
+		return leftParts && rightParts ? [...leftParts, ...rightParts] : null;
+	}
+	if (isNodeOfType(inner, "CallExpression") && isNodeOfType(inner.callee, "MemberExpression") && getStaticPropertyName(inner.callee) === "concat") {
+		const receiverParts = flattenPatternParts(inner.callee.object);
+		if (!receiverParts) return null;
+		const parts = [...receiverParts];
+		for (const argument of inner.arguments) {
+			if (isNodeOfType(argument, "SpreadElement")) return null;
+			const argumentParts = flattenPatternParts(argument);
+			if (!argumentParts) return null;
+			parts.push(...argumentParts);
+		}
+		return parts;
+	}
+	return null;
+};
+const isIdentifierAnAnchoredPathSegment = (argument, identifier) => {
+	if (!identifierNameHasPathSegmentSemantics(identifier.name)) return false;
+	const parts = flattenPatternParts(argument);
+	if (!parts) return false;
+	const identifierPartIndex = parts.findIndex((part) => part === identifier);
+	if (identifierPartIndex < 0) return false;
+	const precedingParts = parts.slice(0, identifierPartIndex);
+	if (precedingParts.some((part) => typeof part !== "string")) return false;
+	const staticPrefix = precedingParts.join("");
+	const followingPart = parts[identifierPartIndex + 1];
+	return staticPrefix === "^" && typeof followingPart === "string" && followingPart.startsWith("/");
+};
+const collectRawDynamicLiteralIdentifiers = (argument) => {
+	const rawDynamicLiteralIdentifiers = [];
 	walkAst(argument, (child) => {
 		if (isEscapingCall(child) || isRegexSourceAccess(child)) return false;
 		if (isLiteralReturningGetterCall(child)) return false;
-		if (isNodeOfType(child, "Identifier") && SEARCH_TERM_NAME_PATTERN.test(child.name) && !isPropertyNamePosition(child) && !isTypePositionIdentifier(child)) rawSearchTermIdentifiers.push(child);
+		if (isNodeOfType(child, "Identifier") && (SEARCH_TERM_NAME_PATTERN.test(child.name) || isIdentifierAnAnchoredPathSegment(argument, child)) && !isPropertyNamePosition(child) && !isTypePositionIdentifier(child)) rawDynamicLiteralIdentifiers.push(child);
 	});
-	return rawSearchTermIdentifiers;
+	return rawDynamicLiteralIdentifiers;
 };
 const collectLeafIdentifiers = (node) => {
 	const leafIdentifiers = [];
@@ -88479,8 +89920,11 @@ const collectLeafIdentifiers = (node) => {
 	return leafIdentifiers;
 };
 const compositeInitializerResolvesEscaped = (strippedInitializer, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames) => {
+	if (isNodeOfType(strippedInitializer, "ConditionalExpression")) return [strippedInitializer.consequent, strippedInitializer.alternate].every((branch) => initializerLooksEscaped(branch, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames));
+	if (isNodeOfType(strippedInitializer, "BinaryExpression") || isNodeOfType(strippedInitializer, "LogicalExpression")) return [strippedInitializer.left, strippedInitializer.right].every((operand) => initializerLooksEscaped(operand, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames));
+	if (isNodeOfType(strippedInitializer, "TemplateLiteral")) return strippedInitializer.expressions.every((expression) => initializerLooksEscaped(expression, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames));
 	let didResolveAnyLeafEscaped = false;
-	for (const leafIdentifier of collectLeafIdentifiers(strippedInitializer)) if (identifierResolvesToEscapedValue(leafIdentifier, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames)) didResolveAnyLeafEscaped = true;
+	for (const leafIdentifier of collectLeafIdentifiers(strippedInitializer)) if (identifierResolvesToEscapedValue(leafIdentifier, remainingHops - 1, scopes, regexpObjectSymbolIds, globalRegExpObjectNames)) didResolveAnyLeafEscaped = true;
 	else if (SEARCH_TERM_NAME_PATTERN.test(leafIdentifier.name)) return false;
 	return didResolveAnyLeafEscaped;
 };
@@ -88492,7 +89936,7 @@ const initializerLooksEscaped = (initializer, remainingHops, scopes, regexpObjec
 	if (isNodeOfType(strippedInitializer, "CallExpression") && (isEscapingCall(strippedInitializer) || calleeBindingBodyEscapes(strippedInitializer))) return true;
 	if (remainingHops > 0) {
 		if (isNodeOfType(strippedInitializer, "Identifier")) return identifierResolvesToEscapedValue(strippedInitializer, remainingHops - 1, scopes, regexpObjectSymbolIds, globalRegExpObjectNames);
-		return compositeInitializerResolvesEscaped(strippedInitializer, remainingHops - 1, scopes, regexpObjectSymbolIds, globalRegExpObjectNames);
+		return compositeInitializerResolvesEscaped(strippedInitializer, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames);
 	}
 	return false;
 };
@@ -88684,7 +90128,7 @@ const noUnescapedDynamicStringInRegexp = defineRule({
 	severity: "warn",
 	category: "Correctness",
 	tags: ["test-noise"],
-	recommendation: "A search/filter/highlight term dropped straight into `new RegExp(...)` lets its regex metacharacters act as operators, so a user typing `.` or `(` over-matches or throws. Escape the value with an `escapeRegExp` helper before constructing the pattern.",
+	recommendation: "A dynamic literal string such as a search term or path segment dropped straight into `new RegExp(...)` lets its regex metacharacters act as operators, so values containing `.` or `(` over-match or throw. Escape the value with an `escapeRegExp` helper before constructing the pattern.",
 	create: (context) => {
 		if (TEST_CONTEXT_FILE_PATTERN.test(context.filename ?? "")) return {};
 		let regexpObjectIndex = null;
@@ -88701,10 +90145,10 @@ const noUnescapedDynamicStringInRegexp = defineRule({
 				regexpObjectIndex = buildRegExpObjectIndex(programRoot, context.scopes);
 			}
 			const currentRegExpObjectIndex = regexpObjectIndex;
-			if (!collectRawSearchTermIdentifiers(firstArgument).some((identifier) => !identifierResolvesToEscapedValue(identifier, INITIALIZER_RESOLUTION_HOPS, context.scopes, currentRegExpObjectIndex.regexpObjectSymbolIds, currentRegExpObjectIndex.globalRegExpObjectNames) && !isShapeTestedByDominatingGuard(node, identifier, context.scopes) && !isParameterFedOnlyMetacharacterFreeLiterals(identifier, context.scopes))) return;
+			if (!collectRawDynamicLiteralIdentifiers(firstArgument).some((identifier) => !identifierResolvesToEscapedValue(identifier, INITIALIZER_RESOLUTION_HOPS, context.scopes, currentRegExpObjectIndex.regexpObjectSymbolIds, currentRegExpObjectIndex.globalRegExpObjectNames) && !isShapeTestedByDominatingGuard(node, identifier, context.scopes) && !isParameterFedOnlyMetacharacterFreeLiterals(identifier, context.scopes))) return;
 			context.report({
 				node,
-				message: "This builds a `RegExp` from a dynamic search/filter term without escaping it, so regex metacharacters in the value act as operators and over-match or throw. Escape the value with an `escapeRegExp` helper first."
+				message: "This builds a `RegExp` from a dynamic literal string without escaping it, so regex metacharacters in the value act as operators and over-match or throw. Escape the value with an `escapeRegExp` helper first."
 			});
 		};
 		return {
@@ -108446,9 +109890,6 @@ 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",
@@ -108467,7 +109908,6 @@ 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({