oxlint-plugin-react-doctor 0.9.2-dev.3728102 → 0.9.2-dev.3bc63ea

package/dist/index.d.ts

@@ -98,7 +98,7 @@ interface RuleContext extends Omit<BaseRuleContext, "getFilename"> {
 }
 //#endregion
 //#region src/plugin/utils/capability.d.ts
-declare const FRAMEWORK_TOKENS: readonly ["nextjs", "vite", "cra", "remix", "gatsby", "expo", "react-native", "tanstack-start", "preact", "unknown"];
+declare const FRAMEWORK_TOKENS: readonly ["nextjs", "astro", "vite", "cra", "remix", "gatsby", "expo", "react-native", "tanstack-start", "preact", "unknown"];
 type FrameworkToken = (typeof FRAMEWORK_TOKENS)[number];
 type Capability = FrameworkToken | "react" | "remotion" | "pure-preact" | "react-native" | "server-actions" | "ssr" | "client-only" | "expo:54" | "nextjs:static-export" | "nextjs:15" | "nextjs:16" | "tailwind" | "tailwind:3.4" | "tailwind:4" | "zod" | "zod:4" | "mobx" | "mobx-react" | "mobx-react-lite" | "mobx-react-binding" | "mobx-react-binding-observer-memo-guard" | "mobx-react-observer-memo-guard" | "mobx-react-lite-observer-memo-guard" | "mobx-state-tree" | "mobx-react-observer" | "zustand" | "typescript" | "react-compiler" | "reanimated" | "reanimated:4" | "tanstack-query" | "valtio" | "i18n" | "styled-components" | "styled-components:6" | "three" | "r3f" | "react-router" | "react-router-framework" | "react-router:6.4" | "react-router:6.7" | "react-router:6.9" | "react-router:6.19" | "react-router:7" | "react-router:7.8" | "react-router:7.9" | "react-router:7.10" | "react-router:7.15" | "react-router:8" | "pre-es2023" | "target-blank-needs-explicit-protection" | "target-blank-needs-noreferrer" | `react:${number}` | `preact:${number}` | `remotion:${number}` | `valtio:${number}` | `mobx:${number}` | `zustand:${number}` | `three:${number}` | `r3f:${number}`;
 type CapabilityQuery = (capability: Capability) => boolean;

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;
@@ -5887,6 +5887,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 +5954,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 +6244,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 +8815,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 +8974,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 +8989,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 +10185,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 +10200,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 +10225,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 +10358,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;
@@ -30471,7 +30674,8 @@ const STRING_TYPED_PROPERTY_NAMES = new Set([
 	"code",
 	"label",
 	"slug",
-	"prefix"
+	"prefix",
+	"__html"
 ]);
 const STRING_TYPED_IDENTIFIER_SUFFIXES = [
 	"Text",
@@ -30589,13 +30793,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 +30829,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 +31465,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;
@@ -46652,6 +46908,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 +47053,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 +47093,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 +47240,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 +47286,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 +47298,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 +47358,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 +47380,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,
@@ -88308,6 +88762,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 +88920,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 +88994,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 +89010,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 +89202,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 +89219,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 {
@@ -140049,6 +140567,7 @@ const shouldReadSecurityScanContent = (relativePath, isGeneratedBundle) => isGen
 //#region src/plugin/utils/capability.ts
 const FRAMEWORK_TOKENS = [
 	"nextjs",
+	"astro",
 	"vite",
 	"cra",
 	"remix",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.9.2-dev.3728102",
+  "version": "0.9.2-dev.3bc63ea",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",