oxlint-plugin-react-doctor 0.7.8 → 0.7.9-dev.61111f1

package/dist/index.js

@@ -2339,8 +2339,309 @@ const anchorAmbiguousText = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/constants/aria-roles.ts
+const VALID_ARIA_ROLES = new Set([
+	"alert",
+	"alertdialog",
+	"application",
+	"article",
+	"banner",
+	"blockquote",
+	"button",
+	"caption",
+	"cell",
+	"checkbox",
+	"code",
+	"columnheader",
+	"combobox",
+	"complementary",
+	"contentinfo",
+	"definition",
+	"deletion",
+	"dialog",
+	"directory",
+	"doc-abstract",
+	"doc-acknowledgments",
+	"doc-afterword",
+	"doc-appendix",
+	"doc-backlink",
+	"doc-biblioentry",
+	"doc-bibliography",
+	"doc-biblioref",
+	"doc-chapter",
+	"doc-colophon",
+	"doc-conclusion",
+	"doc-cover",
+	"doc-credit",
+	"doc-credits",
+	"doc-dedication",
+	"doc-endnote",
+	"doc-endnotes",
+	"doc-epigraph",
+	"doc-epilogue",
+	"doc-errata",
+	"doc-example",
+	"doc-footnote",
+	"doc-foreword",
+	"doc-glossary",
+	"doc-glossref",
+	"doc-index",
+	"doc-introduction",
+	"doc-noteref",
+	"doc-notice",
+	"doc-pagebreak",
+	"doc-pagelist",
+	"doc-part",
+	"doc-preface",
+	"doc-prologue",
+	"doc-pullquote",
+	"doc-qna",
+	"doc-subtitle",
+	"doc-tip",
+	"doc-toc",
+	"document",
+	"emphasis",
+	"feed",
+	"figure",
+	"form",
+	"generic",
+	"graphics-document",
+	"graphics-object",
+	"graphics-symbol",
+	"grid",
+	"gridcell",
+	"group",
+	"heading",
+	"img",
+	"insertion",
+	"link",
+	"list",
+	"listbox",
+	"listitem",
+	"log",
+	"main",
+	"mark",
+	"marquee",
+	"math",
+	"menu",
+	"menubar",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"meter",
+	"navigation",
+	"none",
+	"note",
+	"option",
+	"paragraph",
+	"presentation",
+	"progressbar",
+	"radio",
+	"radiogroup",
+	"region",
+	"row",
+	"rowgroup",
+	"rowheader",
+	"scrollbar",
+	"search",
+	"searchbox",
+	"separator",
+	"slider",
+	"spinbutton",
+	"status",
+	"strong",
+	"subscript",
+	"superscript",
+	"switch",
+	"tab",
+	"table",
+	"tablist",
+	"tabpanel",
+	"term",
+	"textbox",
+	"time",
+	"timer",
+	"toolbar",
+	"tooltip",
+	"tree",
+	"treegrid",
+	"treeitem"
+]);
+const INTERACTIVE_ROLES = new Set([
+	"button",
+	"checkbox",
+	"columnheader",
+	"combobox",
+	"grid",
+	"gridcell",
+	"link",
+	"listbox",
+	"menu",
+	"menubar",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"option",
+	"radio",
+	"radiogroup",
+	"row",
+	"rowheader",
+	"scrollbar",
+	"searchbox",
+	"separator",
+	"slider",
+	"spinbutton",
+	"switch",
+	"tab",
+	"tablist",
+	"textbox",
+	"toolbar",
+	"tree",
+	"treegrid",
+	"treeitem"
+]);
+const NON_INTERACTIVE_ROLES = new Set([
+	"alert",
+	"alertdialog",
+	"application",
+	"article",
+	"banner",
+	"blockquote",
+	"caption",
+	"cell",
+	"complementary",
+	"contentinfo",
+	"definition",
+	"deletion",
+	"dialog",
+	"directory",
+	"document",
+	"feed",
+	"figure",
+	"form",
+	"group",
+	"heading",
+	"img",
+	"insertion",
+	"list",
+	"listitem",
+	"log",
+	"main",
+	"marquee",
+	"math",
+	"navigation",
+	"note",
+	"paragraph",
+	"progressbar",
+	"region",
+	"rowgroup",
+	"search",
+	"status",
+	"table",
+	"tabpanel",
+	"term",
+	"time",
+	"timer",
+	"tooltip"
+]);
+const ABSTRACT_ROLES = new Set([
+	"command",
+	"composite",
+	"input",
+	"landmark",
+	"range",
+	"roletype",
+	"section",
+	"sectionhead",
+	"select",
+	"structure",
+	"widget",
+	"window"
+]);
+const PRESENTATION_ROLES$1 = new Set(["presentation", "none"]);
+//#endregion
+//#region src/plugin/utils/read-static-boolean.ts
+const readStaticBoolean = (node) => {
+	if (!node) return null;
+	const unwrappedNode = stripParenExpression(node);
+	if (!isNodeOfType(unwrappedNode, "Literal") || typeof unwrappedNode.value !== "boolean") return null;
+	return unwrappedNode.value;
+};
+//#endregion
+//#region src/plugin/utils/get-jsx-prop-static-string-values.ts
+const MAX_CONST_RESOLUTION_HOPS = 4;
+const resolveStaticStringValues = (rawExpression, scopes, maximumConstAliases, shouldFoldStaticConditions) => {
+	const staticStringValues = [];
+	const workItems = [{
+		expression: rawExpression,
+		remainingConstAliases: maximumConstAliases,
+		resolvingSymbols: /* @__PURE__ */ new Set()
+	}];
+	while (workItems.length > 0) {
+		const workItem = workItems.pop();
+		if (!workItem) continue;
+		const expression = stripParenExpression(workItem.expression);
+		if (isNodeOfType(expression, "Literal")) {
+			if (typeof expression.value !== "string") return null;
+			staticStringValues.push(expression.value);
+			continue;
+		}
+		if (isNodeOfType(expression, "TemplateLiteral")) {
+			const staticValue = getStaticTemplateLiteralValue(expression);
+			if (staticValue === null) return null;
+			staticStringValues.push(staticValue);
+			continue;
+		}
+		if (isNodeOfType(expression, "ConditionalExpression")) {
+			const staticTestValue = shouldFoldStaticConditions ? readStaticBoolean(expression.test) : null;
+			if (staticTestValue !== null) {
+				workItems.push({
+					expression: staticTestValue ? expression.consequent : expression.alternate,
+					remainingConstAliases: workItem.remainingConstAliases,
+					resolvingSymbols: workItem.resolvingSymbols
+				});
+				continue;
+			}
+			workItems.push({
+				expression: expression.alternate,
+				remainingConstAliases: workItem.remainingConstAliases,
+				resolvingSymbols: new Set(workItem.resolvingSymbols)
+			});
+			workItems.push({
+				expression: expression.consequent,
+				remainingConstAliases: workItem.remainingConstAliases,
+				resolvingSymbols: new Set(workItem.resolvingSymbols)
+			});
+			continue;
+		}
+		if (isNodeOfType(expression, "Identifier")) {
+			const symbol = scopes.referenceFor(expression)?.resolvedSymbol;
+			if (!symbol || symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || workItem.remainingConstAliases === 0 || workItem.resolvingSymbols.has(symbol)) return null;
+			workItem.resolvingSymbols.add(symbol);
+			workItems.push({
+				expression: symbol.initializer,
+				remainingConstAliases: workItem.remainingConstAliases === null ? null : workItem.remainingConstAliases - 1,
+				resolvingSymbols: workItem.resolvingSymbols
+			});
+			continue;
+		}
+		return null;
+	}
+	return staticStringValues;
+};
+const getJsxPropStaticStringValuesWithMode = (attribute, scopes, maximumConstAliases, shouldFoldStaticConditions) => {
+	const value = attribute.value;
+	if (!value) return null;
+	if (isNodeOfType(value, "Literal")) return typeof value.value === "string" ? [value.value] : null;
+	if (isNodeOfType(value, "JSXExpressionContainer")) return resolveStaticStringValues(value.expression, scopes, maximumConstAliases, shouldFoldStaticConditions);
+	return null;
+};
+const getJsxPropStaticStringValues = (attribute, scopes) => getJsxPropStaticStringValuesWithMode(attribute, scopes, MAX_CONST_RESOLUTION_HOPS, false);
+const getJsxPropExhaustiveStaticStringValues = (attribute, scopes) => getJsxPropStaticStringValuesWithMode(attribute, scopes, null, true);
+//#endregion
 //#region src/plugin/rules/a11y/anchor-has-content.ts
 const MESSAGE$62 = "Blind users can't follow this link because screen readers announce nothing, so add visible text, `aria-label`, or `aria-labelledby`.";
+const hasLinkRole = (roleValue) => roleValue.trim().split(/\s+/).find((roleToken) => VALID_ARIA_ROLES.has(roleToken)) === "link";
 const isTransComponentsTemplate = (node) => {
 	let current = node.parent;
 	while (current) {
@@ -2358,7 +2659,7 @@ const anchorHasContent = defineRule({
 	title: "Anchor has no content",
 	tags: ["react-jsx-only"],
 	severity: "warn",
-	recommendation: "Put readable text inside every `<a>`.",
+	recommendation: "Put readable text inside every link.",
 	category: "Accessibility",
 	create: (context) => {
 		const isTestlikeFile = isTestlikeFilename(context.filename);
@@ -2366,6 +2667,11 @@ const anchorHasContent = defineRule({
 			if (isTestlikeFile) return;
 			const opening = node.openingElement;
 			if (getElementType(opening, context.settings) !== "a") return;
+			const hrefAttribute = hasJsxPropIgnoreCase(opening.attributes, "href");
+			const roleAttribute = hasJsxPropIgnoreCase(opening.attributes, "role");
+			const roleValues = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : [];
+			const canHaveLinkRole = roleValues === null || roleValues.some((roleValue) => hasLinkRole(roleValue));
+			if (!hrefAttribute && !canHaveLinkRole) return;
 			if (isHiddenFromScreenReader(opening, context.settings)) return;
 			if (objectHasAccessibleChild(node, context.settings)) return;
 			for (const attribute of [
@@ -2382,39 +2688,6 @@ const anchorHasContent = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-jsx-prop-static-string-values.ts
-const MAX_CONST_RESOLUTION_HOPS = 4;
-const resolveStaticStringValues = (rawExpression, scopes, remainingHops) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isNodeOfType(expression, "Literal")) return typeof expression.value === "string" ? [expression.value] : null;
-	if (isNodeOfType(expression, "TemplateLiteral")) {
-		const staticValue = getStaticTemplateLiteralValue(expression);
-		return staticValue === null ? null : [staticValue];
-	}
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		const consequentValues = resolveStaticStringValues(expression.consequent, scopes, remainingHops);
-		if (consequentValues === null) return null;
-		const alternateValues = resolveStaticStringValues(expression.alternate, scopes, remainingHops);
-		if (alternateValues === null) return null;
-		return [...consequentValues, ...alternateValues];
-	}
-	if (isNodeOfType(expression, "Identifier")) {
-		if (remainingHops === 0) return null;
-		const symbol = scopes.referenceFor(expression)?.resolvedSymbol;
-		if (!symbol || symbol.kind !== "const" || !symbol.initializer) return null;
-		if (!isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
-		return resolveStaticStringValues(symbol.initializer, scopes, remainingHops - 1);
-	}
-	return null;
-};
-const getJsxPropStaticStringValues = (attribute, scopes) => {
-	const value = attribute.value;
-	if (!value) return null;
-	if (isNodeOfType(value, "Literal")) return typeof value.value === "string" ? [value.value] : null;
-	if (isNodeOfType(value, "JSXExpressionContainer")) return resolveStaticStringValues(value.expression, scopes, MAX_CONST_RESOLUTION_HOPS);
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/a11y/anchor-is-valid.ts
 const MESSAGE_MISSING_HREF = "Keyboard users can't reach this link because it has no `href`, so add a real `href` (or use `<button>` for actions).";
 const MESSAGE_INCORRECT_HREF = "Keyboard users can't reach this link because its `href` goes nowhere (`#`, `javascript:`, or empty), so point it at a real destination.";
@@ -2737,6 +3010,95 @@ const NON_INTERACTIVE_ELEMENTS = new Set([
 	"ul"
 ]);
 //#endregion
+//#region src/plugin/utils/get-direct-const-initializer.ts
+const getDirectConstInitializer = (symbol) => {
+	if (symbol.kind !== "const" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
+	return symbol.initializer;
+};
+//#endregion
+//#region src/plugin/utils/can-content-editable-be-tabbable.ts
+const ENABLED_CONTENT_EDITABLE_VALUES = new Set([
+	"",
+	"plaintext-only",
+	"true"
+]);
+const ENABLED_CONTENT_EDITABLE = {
+	canBeDisabled: false,
+	canBeEnabled: true,
+	canBeInherited: false
+};
+const DISABLED_CONTENT_EDITABLE = {
+	canBeDisabled: true,
+	canBeEnabled: false,
+	canBeInherited: false
+};
+const INHERITED_CONTENT_EDITABLE = {
+	canBeDisabled: false,
+	canBeEnabled: false,
+	canBeInherited: true
+};
+const UNKNOWN_CONTENT_EDITABLE = {
+	canBeDisabled: true,
+	canBeEnabled: true,
+	canBeInherited: true
+};
+const mergeContentEditablePossibilities = (left, right) => ({
+	canBeDisabled: left.canBeDisabled || right.canBeDisabled,
+	canBeEnabled: left.canBeEnabled || right.canBeEnabled,
+	canBeInherited: left.canBeInherited || right.canBeInherited
+});
+const resolveContentEditableExpression = (rawExpression, scopes, visitedSymbolIds) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isNodeOfType(expression, "Literal")) {
+		if (typeof expression.value === "boolean") return expression.value ? ENABLED_CONTENT_EDITABLE : DISABLED_CONTENT_EDITABLE;
+		if (typeof expression.value === "string") {
+			const contentEditableValue = expression.value.toLowerCase();
+			if (ENABLED_CONTENT_EDITABLE_VALUES.has(contentEditableValue)) return ENABLED_CONTENT_EDITABLE;
+			return contentEditableValue === "false" ? DISABLED_CONTENT_EDITABLE : INHERITED_CONTENT_EDITABLE;
+		}
+		return INHERITED_CONTENT_EDITABLE;
+	}
+	if (isNodeOfType(expression, "ConditionalExpression")) return mergeContentEditablePossibilities(resolveContentEditableExpression(expression.consequent, scopes, visitedSymbolIds), resolveContentEditableExpression(expression.alternate, scopes, visitedSymbolIds));
+	if (isNodeOfType(expression, "Identifier")) {
+		const symbol = scopes.referenceFor(expression)?.resolvedSymbol;
+		if (!symbol || visitedSymbolIds.has(symbol.id)) return UNKNOWN_CONTENT_EDITABLE;
+		const initializer = getDirectConstInitializer(symbol);
+		if (!initializer) return UNKNOWN_CONTENT_EDITABLE;
+		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+		nextVisitedSymbolIds.add(symbol.id);
+		return resolveContentEditableExpression(initializer, scopes, nextVisitedSymbolIds);
+	}
+	return UNKNOWN_CONTENT_EDITABLE;
+};
+const getContentEditablePossibilities = (node, scopes) => {
+	const attribute = hasJsxPropIgnoreCase(node.attributes, "contenteditable");
+	if (!attribute) return null;
+	if (!attribute.value) return ENABLED_CONTENT_EDITABLE;
+	if (isNodeOfType(attribute.value, "Literal")) return resolveContentEditableExpression(attribute.value, scopes, /* @__PURE__ */ new Set());
+	if (isNodeOfType(attribute.value, "JSXExpressionContainer")) return resolveContentEditableExpression(attribute.value.expression, scopes, /* @__PURE__ */ new Set());
+	return UNKNOWN_CONTENT_EDITABLE;
+};
+const hasDefinitelyEnabledContentEditableAncestor = (node, scopes, settings) => {
+	let ancestor = node.parent?.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) {
+			const openingElement = ancestor.openingElement;
+			if (!HTML_TAGS.has(getElementType(openingElement, settings))) return false;
+			const possibilities = getContentEditablePossibilities(openingElement, scopes);
+			if (possibilities) {
+				if (possibilities.canBeEnabled && !possibilities.canBeDisabled && !possibilities.canBeInherited) return true;
+				if (!(possibilities.canBeInherited && !possibilities.canBeDisabled && !possibilities.canBeEnabled)) return false;
+			}
+		}
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const canContentEditableBeTabbable = (node, scopes, settings) => {
+	if (!getContentEditablePossibilities(node, scopes)?.canBeEnabled) return false;
+	return !hasDefinitelyEnabledContentEditableAncestor(node, scopes, settings);
+};
+//#endregion
 //#region src/plugin/utils/is-interactive-element.ts
 const isInteractiveElement = (tagName, openingElement) => {
 	switch (tagName) {
@@ -2809,19 +3171,6 @@ const parseJsxValue = (value) => {
 //#endregion
 //#region src/plugin/rules/a11y/aria-activedescendant-has-tabindex.ts
 const MESSAGE$61 = "Keyboard users can't focus this element with `aria-activedescendant` because it isn't tabbable, so add `tabIndex={0}`.";
-const mayBeContentEditable = (node) => {
-	const attribute = hasJsxPropIgnoreCase(node.attributes, "contenteditable");
-	if (!attribute) return false;
-	if (!attribute.value) return true;
-	const stringValue = getJsxPropStringValue(attribute);
-	if (stringValue !== null) return stringValue !== "false";
-	const value = attribute.value;
-	if (isNodeOfType(value, "JSXExpressionContainer")) {
-		const expression = value.expression;
-		if (isNodeOfType(expression, "Literal")) return expression.value !== false && expression.value !== "false";
-	}
-	return true;
-};
 const ariaActivedescendantHasTabindex = defineRule({
 	id: "aria-activedescendant-has-tabindex",
 	title: "aria-activedescendant missing tabindex",
@@ -2844,7 +3193,7 @@ const ariaActivedescendantHasTabindex = defineRule({
 			return;
 		}
 		if (isInteractiveElement(tag, node)) return;
-		if (mayBeContentEditable(node)) return;
+		if (canContentEditableBeTabbable(node, context.scopes, context.settings)) return;
 		context.report({
 			node: node.name,
 			message: MESSAGE$61
@@ -3297,227 +3646,6 @@ const ariaProptypes = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/constants/aria-roles.ts
-const VALID_ARIA_ROLES = new Set([
-	"alert",
-	"alertdialog",
-	"application",
-	"article",
-	"banner",
-	"blockquote",
-	"button",
-	"caption",
-	"cell",
-	"checkbox",
-	"code",
-	"columnheader",
-	"combobox",
-	"complementary",
-	"contentinfo",
-	"definition",
-	"deletion",
-	"dialog",
-	"directory",
-	"doc-abstract",
-	"doc-acknowledgments",
-	"doc-afterword",
-	"doc-appendix",
-	"doc-backlink",
-	"doc-biblioentry",
-	"doc-bibliography",
-	"doc-biblioref",
-	"doc-chapter",
-	"doc-colophon",
-	"doc-conclusion",
-	"doc-cover",
-	"doc-credit",
-	"doc-credits",
-	"doc-dedication",
-	"doc-endnote",
-	"doc-endnotes",
-	"doc-epigraph",
-	"doc-epilogue",
-	"doc-errata",
-	"doc-example",
-	"doc-footnote",
-	"doc-foreword",
-	"doc-glossary",
-	"doc-glossref",
-	"doc-index",
-	"doc-introduction",
-	"doc-noteref",
-	"doc-notice",
-	"doc-pagebreak",
-	"doc-pagelist",
-	"doc-part",
-	"doc-preface",
-	"doc-prologue",
-	"doc-pullquote",
-	"doc-qna",
-	"doc-subtitle",
-	"doc-tip",
-	"doc-toc",
-	"document",
-	"emphasis",
-	"feed",
-	"figure",
-	"form",
-	"generic",
-	"graphics-document",
-	"graphics-object",
-	"graphics-symbol",
-	"grid",
-	"gridcell",
-	"group",
-	"heading",
-	"img",
-	"insertion",
-	"link",
-	"list",
-	"listbox",
-	"listitem",
-	"log",
-	"main",
-	"mark",
-	"marquee",
-	"math",
-	"menu",
-	"menubar",
-	"menuitem",
-	"menuitemcheckbox",
-	"menuitemradio",
-	"meter",
-	"navigation",
-	"none",
-	"note",
-	"option",
-	"paragraph",
-	"presentation",
-	"progressbar",
-	"radio",
-	"radiogroup",
-	"region",
-	"row",
-	"rowgroup",
-	"rowheader",
-	"scrollbar",
-	"search",
-	"searchbox",
-	"separator",
-	"slider",
-	"spinbutton",
-	"status",
-	"strong",
-	"subscript",
-	"superscript",
-	"switch",
-	"tab",
-	"table",
-	"tablist",
-	"tabpanel",
-	"term",
-	"textbox",
-	"time",
-	"timer",
-	"toolbar",
-	"tooltip",
-	"tree",
-	"treegrid",
-	"treeitem"
-]);
-const INTERACTIVE_ROLES = new Set([
-	"button",
-	"checkbox",
-	"columnheader",
-	"combobox",
-	"grid",
-	"gridcell",
-	"link",
-	"listbox",
-	"menu",
-	"menubar",
-	"menuitem",
-	"menuitemcheckbox",
-	"menuitemradio",
-	"option",
-	"radio",
-	"radiogroup",
-	"row",
-	"rowheader",
-	"scrollbar",
-	"searchbox",
-	"separator",
-	"slider",
-	"spinbutton",
-	"switch",
-	"tab",
-	"tablist",
-	"textbox",
-	"toolbar",
-	"tree",
-	"treegrid",
-	"treeitem"
-]);
-const NON_INTERACTIVE_ROLES = new Set([
-	"alert",
-	"alertdialog",
-	"application",
-	"article",
-	"banner",
-	"blockquote",
-	"caption",
-	"cell",
-	"complementary",
-	"contentinfo",
-	"definition",
-	"deletion",
-	"dialog",
-	"directory",
-	"document",
-	"feed",
-	"figure",
-	"form",
-	"group",
-	"heading",
-	"img",
-	"insertion",
-	"list",
-	"listitem",
-	"log",
-	"main",
-	"marquee",
-	"math",
-	"navigation",
-	"note",
-	"paragraph",
-	"progressbar",
-	"region",
-	"rowgroup",
-	"search",
-	"status",
-	"table",
-	"tabpanel",
-	"term",
-	"time",
-	"timer",
-	"tooltip"
-]);
-const ABSTRACT_ROLES = new Set([
-	"command",
-	"composite",
-	"input",
-	"landmark",
-	"range",
-	"roletype",
-	"section",
-	"sectionhead",
-	"select",
-	"structure",
-	"widget",
-	"window"
-]);
-const PRESENTATION_ROLES$1 = new Set(["presentation", "none"]);
-//#endregion
 //#region src/plugin/rules/a11y/aria-role.ts
 const buildBaseMessage = (suffix) => `This \`role\` is not a valid ARIA role, so assistive tech cannot expose it correctly. Use a real, non-abstract role.${suffix}`;
 const resolveSettings$50 = (settings) => {
@@ -5187,133 +5315,644 @@ const asyncAwaitInLoop = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/collect-pattern-default-reference-names.ts
-const collectPatternDefaultReferenceNames = (pattern, into) => {
-	if (!pattern) return;
-	if (isNodeOfType(pattern, "AssignmentPattern")) {
-		collectReferenceIdentifierNames(pattern.right, into);
-		collectPatternDefaultReferenceNames(pattern.left, into);
+//#region src/plugin/semantic/scope-analysis.ts
+const isHoistedBindingKind = (kind) => kind === "var" || kind === "function";
+const findHoistTargetScope = (scope) => {
+	let current = scope;
+	while (current) {
+		if (current.kind === "module" || current.kind === "function" || current.kind === "arrow-function" || current.kind === "method") return current;
+		current = current.parent;
+	}
+	return scope;
+};
+const createScope = (kind, node, parent, state) => {
+	const scope = {
+		id: state.nextScopeId++,
+		kind,
+		node,
+		parent,
+		children: [],
+		symbols: [],
+		references: [],
+		symbolsByName: /* @__PURE__ */ new Map()
+	};
+	if (parent) parent.children.push(scope);
+	return scope;
+};
+const pushScope = (kind, node, state) => {
+	const scope = createScope(kind, node, state.currentScope, state);
+	state.scopeStack.push(scope);
+	state.currentScope = scope;
+	state.ownScopeForNode.set(node, scope);
+	return scope;
+};
+const popScope = (state) => {
+	state.scopeStack.pop();
+	const previous = state.scopeStack[state.scopeStack.length - 1];
+	if (!previous) throw new Error("scope stack underflow");
+	state.currentScope = previous;
+};
+const recordSymbol = (scope, state, options) => {
+	const symbol = {
+		id: state.nextSymbolId++,
+		name: options.name,
+		kind: options.kind,
+		bindingIdentifier: options.bindingIdentifier,
+		declarationNode: options.declarationNode,
+		scope,
+		initializer: options.initializer,
+		references: []
+	};
+	scope.symbols.push(symbol);
+	scope.symbolsByName.set(options.name, symbol);
+	state.symbolByBindingIdentifier.set(options.bindingIdentifier, symbol);
+	return symbol;
+};
+const collectBindingNamesFromPattern = (pattern) => {
+	const out = [];
+	const visit = (node) => {
+		if (isNodeOfType(node, "Identifier")) {
+			out.push(node);
+			return;
+		}
+		if (isNodeOfType(node, "ObjectPattern")) {
+			for (const property of node.properties) if (isNodeOfType(property, "Property")) {
+				const propValue = property.value;
+				visit(propValue);
+			} else if (isNodeOfType(property, "RestElement")) visit(property.argument);
+			return;
+		}
+		if (isNodeOfType(node, "ArrayPattern")) {
+			for (const element of node.elements) if (element) visit(element);
+			return;
+		}
+		if (isNodeOfType(node, "RestElement")) {
+			visit(node.argument);
+			return;
+		}
+		if (isNodeOfType(node, "AssignmentPattern")) visit(node.left);
+	};
+	visit(pattern);
+	return out;
+};
+const visitDestructuringDeclarations = (pattern, baseInitializer, scope, state, symbolKind, declarationNode) => {
+	if (isNodeOfType(pattern, "Identifier")) {
+		recordSymbol(scope, state, {
+			name: pattern.name,
+			kind: symbolKind,
+			bindingIdentifier: pattern,
+			declarationNode,
+			initializer: baseInitializer
+		});
 		return;
 	}
-	if (isNodeOfType(pattern, "RestElement")) {
-		collectPatternDefaultReferenceNames(pattern.argument, into);
+	if (isNodeOfType(pattern, "ObjectPattern")) {
+		for (const property of pattern.properties) if (isNodeOfType(property, "Property")) {
+			const propertyValue = property.value;
+			visitDestructuringDeclarations(propertyValue, isNodeOfType(propertyValue, "AssignmentPattern") ? propertyValue.right : baseInitializer, scope, state, symbolKind, declarationNode);
+		} else if (isNodeOfType(property, "RestElement")) visitDestructuringDeclarations(property.argument, baseInitializer, scope, state, symbolKind, declarationNode);
 		return;
 	}
 	if (isNodeOfType(pattern, "ArrayPattern")) {
-		for (const element of pattern.elements ?? []) collectPatternDefaultReferenceNames(element, into);
+		for (const element of pattern.elements) {
+			if (!element) continue;
+			visitDestructuringDeclarations(element, isNodeOfType(element, "AssignmentPattern") ? element.right ?? null : baseInitializer, scope, state, symbolKind, declarationNode);
+		}
 		return;
 	}
-	if (isNodeOfType(pattern, "ObjectPattern")) {
-		for (const property of pattern.properties ?? []) if (isNodeOfType(property, "RestElement")) collectPatternDefaultReferenceNames(property.argument, into);
-		else if (isNodeOfType(property, "Property")) {
-			if (property.computed) collectReferenceIdentifierNames(property.key, into);
-			collectPatternDefaultReferenceNames(property.value, into);
-		}
+	if (isNodeOfType(pattern, "AssignmentPattern")) {
+		visitDestructuringDeclarations(pattern.left, pattern.right ?? null, scope, state, symbolKind, declarationNode);
+		return;
 	}
+	if (isNodeOfType(pattern, "RestElement")) visitDestructuringDeclarations(pattern.argument, null, scope, state, symbolKind, declarationNode);
 };
-//#endregion
-//#region src/plugin/utils/is-bare-await-expression-statement.ts
-const isBareAwaitExpressionStatement = (statement) => {
-	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
-	return isNodeOfType(statement.expression, "AwaitExpression");
+const tagAsBinding = (state, identifier) => {
+	bindingPositionMarker.add(identifier);
 };
-//#endregion
-//#region src/plugin/utils/is-early-exit-if-statement.ts
-const isEarlyExitStatement = (statement) => isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "ContinueStatement") || isNodeOfType(statement, "BreakStatement");
-const isEarlyExitIfStatement = (statement) => {
-	if (!isNodeOfType(statement, "IfStatement")) return false;
-	const consequent = statement.consequent;
-	if (!consequent) return false;
-	if (isEarlyExitStatement(consequent)) return true;
-	if (!isNodeOfType(consequent, "BlockStatement")) return false;
-	for (const inner of consequent.body ?? []) if (isEarlyExitStatement(inner)) return true;
-	return false;
+const bindingPositionMarker = /* @__PURE__ */ new WeakSet();
+const recordReference = (state, identifier, flag) => {
+	const reference = {
+		id: state.nextReferenceId++,
+		identifier,
+		resolvedSymbol: null,
+		flag,
+		scope: state.currentScope
+	};
+	state.currentScope.references.push(reference);
+	state.referenceByIdentifier.set(identifier, reference);
 };
-//#endregion
-//#region src/plugin/rules/performance/async-defer-await.ts
-const hasAnyIdentifierName = (identifierNames, candidateNames) => {
-	for (const candidateName of candidateNames) if (identifierNames.has(candidateName)) return true;
-	return false;
+const isFunctionBodyBlock = (block) => {
+	if (!block.parent) return false;
+	return isFunctionLike$1(block.parent);
 };
-const collectDeclaratorDependencyIdentifierNames = (declarator, into) => {
-	if (!isNodeOfType(declarator, "VariableDeclarator")) return;
-	collectReferenceIdentifierNames(declarator.init, into);
-	collectPatternDefaultReferenceNames(declarator.id, into);
+const isCatchClauseBlock = (block) => block.parent !== null && block.parent !== void 0 && block.parent.type === "CatchClause";
+const handleVariableDeclaration = (declaration, state) => {
+	if (!isNodeOfType(declaration, "VariableDeclaration")) return;
+	const symbolKind = declaration.kind === "var" ? "var" : declaration.kind === "let" ? "let" : declaration.kind === "const" ? "const" : "using";
+	const targetScope = isHoistedBindingKind(symbolKind) ? findHoistTargetScope(state.currentScope) : state.currentScope;
+	for (const declarator of declaration.declarations) {
+		const declaratorNode = declarator;
+		const init = declarator.init ?? null;
+		visitDestructuringDeclarations(declarator.id, init, targetScope, state, symbolKind, declaratorNode);
+		for (const identifier of collectBindingNamesFromPattern(declarator.id)) tagAsBinding(state, identifier);
+	}
 };
-const processVariableDeclaration = (declaration, awaitedBindingNames) => {
-	if (!isNodeOfType(declaration, "VariableDeclaration")) return {
-		didIntroduceAwait: false,
-		didGrowBindings: false
-	};
-	let didIntroduceAwait = false;
-	const sizeBeforeAll = awaitedBindingNames.size;
-	let hasChanged = true;
-	while (hasChanged) {
-		hasChanged = false;
-		for (const declarator of declaration.declarations ?? []) {
-			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
-			if (containsDirectAwait(declarator.init) || containsDirectAwait(declarator.id)) {
-				didIntroduceAwait = true;
-				const sizeBefore = awaitedBindingNames.size;
-				collectPatternNames(declarator.id, awaitedBindingNames);
-				if (awaitedBindingNames.size > sizeBefore) hasChanged = true;
-				continue;
-			}
-			const dependencyIdentifiers = /* @__PURE__ */ new Set();
-			collectDeclaratorDependencyIdentifierNames(declarator, dependencyIdentifiers);
-			if (!hasAnyIdentifierName(dependencyIdentifiers, awaitedBindingNames)) continue;
-			const sizeBefore = awaitedBindingNames.size;
-			collectPatternNames(declarator.id, awaitedBindingNames);
-			if (awaitedBindingNames.size > sizeBefore) hasChanged = true;
-		}
+const handleFunctionDeclaration = (fn, state) => {
+	if (!isNodeOfType(fn, "FunctionDeclaration")) return;
+	if (fn.id) {
+		recordSymbol(findHoistTargetScope(state.currentScope), state, {
+			name: fn.id.name,
+			kind: "function",
+			bindingIdentifier: fn.id,
+			declarationNode: fn,
+			initializer: fn
+		});
+		tagAsBinding(state, fn.id);
 	}
-	const didGrowBindings = awaitedBindingNames.size > sizeBeforeAll;
-	return {
-		didIntroduceAwait,
-		didGrowBindings
-	};
 };
-const CANCELLATION_GUARD_NAMES = new Set([
-	"cancelled",
-	"canceled",
-	"isCancelled",
-	"isCanceled",
-	"aborted",
-	"isAborted",
-	"disposed",
-	"isDisposed",
-	"destroyed",
-	"isDestroyed",
-	"stopped",
-	"isStopped",
-	"mounted",
-	"isMounted",
-	"unmounted",
-	"isUnmounted",
-	"active",
-	"isActive",
-	"stale",
-	"isStale",
-	"signal",
-	"abortSignal",
-	"abortController"
-]);
-const testReadsRefCurrent = (test) => {
-	let didFindRefCurrentRead = false;
-	walkAst(test, (child) => {
-		if (didFindRefCurrentRead) return false;
-		if (!isNodeOfType(child, "MemberExpression") || child.computed) return;
-		if (!isNodeOfType(child.property, "Identifier") || child.property.name !== "current") return;
-		if (!isNodeOfType(child.object, "Identifier")) return;
-		const refCandidateName = child.object.name;
-		if (refCandidateName.endsWith("Ref") && refCandidateName.length > 3) {
-			didFindRefCurrentRead = true;
-			return false;
-		}
+const handleClassDeclaration = (cls, state) => {
+	if (!isNodeOfType(cls, "ClassDeclaration")) return;
+	if (cls.id) {
+		recordSymbol(state.currentScope, state, {
+			name: cls.id.name,
+			kind: "class",
+			bindingIdentifier: cls.id,
+			declarationNode: cls,
+			initializer: cls
+		});
+		tagAsBinding(state, cls.id);
+	}
+};
+const handleImportDeclaration = (importDeclaration, state) => {
+	if (!isNodeOfType(importDeclaration, "ImportDeclaration")) return;
+	const target = findHoistTargetScope(state.currentScope);
+	for (const specifier of importDeclaration.specifiers) {
+		const local = specifier.local;
+		if (!isNodeOfType(local, "Identifier")) continue;
+		recordSymbol(target, state, {
+			name: local.name,
+			kind: "import",
+			bindingIdentifier: local,
+			declarationNode: specifier,
+			initializer: specifier
+		});
+		tagAsBinding(state, local);
+	}
+};
+const handleTsDeclarations = (node, state) => {
+	if (node.type !== "TSImportEqualsDeclaration" && node.type !== "TSEnumDeclaration" && node.type !== "TSTypeAliasDeclaration" && node.type !== "TSInterfaceDeclaration" && node.type !== "TSModuleDeclaration") return;
+	const idNode = node.id;
+	if (!idNode || !isNodeOfType(idNode, "Identifier")) return;
+	const kind = node.type === "TSImportEqualsDeclaration" ? "ts-import-equals" : node.type === "TSEnumDeclaration" ? "ts-enum" : node.type === "TSTypeAliasDeclaration" ? "ts-type-alias" : node.type === "TSInterfaceDeclaration" ? "ts-interface" : "ts-module";
+	recordSymbol(findHoistTargetScope(state.currentScope), state, {
+		name: idNode.name,
+		kind,
+		bindingIdentifier: idNode,
+		declarationNode: node,
+		initializer: null
 	});
-	return didFindRefCurrentRead;
+	tagAsBinding(state, idNode);
 };
-const CANCELLATION_NAME_FRAGMENTS = [
+const handleFunctionParameters = (params, scope, state) => {
+	for (const param of params) {
+		visitDestructuringDeclarations(param, null, scope, state, "parameter", param);
+		for (const identifier of collectBindingNamesFromPattern(param)) tagAsBinding(state, identifier);
+	}
+};
+const shouldPushBlockScope = (block) => {
+	if (!isNodeOfType(block, "BlockStatement")) return false;
+	if (isFunctionBodyBlock(block)) return false;
+	if (isCatchClauseBlock(block)) return false;
+	if (block.parent && block.parent.type === "TSModuleDeclaration") return false;
+	return true;
+};
+const isJsxIdentifierBindingReference = (identifier) => {
+	const parent = identifier.parent;
+	if (!parent) return false;
+	if (parent.type === "JSXMemberExpression") return parent.object === identifier;
+	if (parent.type === "JSXNamespacedName") return false;
+	const ASCII_LOWERCASE_A = 97;
+	const ASCII_LOWERCASE_Z = 122;
+	const firstCharCode = identifier.name.charCodeAt(0);
+	if (firstCharCode >= ASCII_LOWERCASE_A && firstCharCode <= ASCII_LOWERCASE_Z) return false;
+	return true;
+};
+const isNonReferencePosition = (identifier) => {
+	const parent = identifier.parent;
+	if (!parent) return false;
+	switch (parent.type) {
+		case "MemberExpression": return parent.property === identifier && !parent.computed;
+		case "Property": return parent.key === identifier && !parent.computed && !parent.shorthand;
+		case "MethodDefinition":
+		case "PropertyDefinition": return parent.key === identifier && !parent.computed;
+		case "JSXAttribute": return parent.name === identifier;
+		case "ImportSpecifier": return parent.imported === identifier;
+		case "ExportSpecifier": return parent.exported === identifier && parent.local !== parent.exported;
+		case "LabeledStatement":
+		case "BreakStatement":
+		case "ContinueStatement": return parent.label === identifier;
+		default: return false;
+	}
+};
+const inferReferenceFlag = (identifier) => {
+	const parent = identifier.parent;
+	if (!parent) return "read";
+	switch (parent.type) {
+		case "AssignmentExpression":
+			if (parent.left === identifier) return parent.operator === "=" ? "write" : "read-write";
+			return "read";
+		case "UpdateExpression": return "read-write";
+		case "ForInStatement":
+		case "ForOfStatement": return parent.left === identifier ? "write" : "read";
+		default: return "read";
+	}
+};
+const setNodeScope = (node, state) => {
+	state.nodeScope.set(node, state.currentScope);
+};
+const walkParameterReferences = (pattern, state) => {
+	if (isNodeOfType(pattern, "AssignmentPattern")) {
+		walkParameterReferences(pattern.left, state);
+		const defaultValue = pattern.right ?? null;
+		if (defaultValue) walk(defaultValue, state);
+		return;
+	}
+	if (isNodeOfType(pattern, "ObjectPattern")) {
+		for (const property of pattern.properties) {
+			const propertyNode = property;
+			if (isNodeOfType(propertyNode, "RestElement")) {
+				walkParameterReferences(propertyNode.argument, state);
+				continue;
+			}
+			if (!isNodeOfType(propertyNode, "Property")) continue;
+			const propertyDetail = propertyNode;
+			if (propertyDetail.computed) walk(propertyDetail.key, state);
+			walkParameterReferences(propertyDetail.value, state);
+		}
+		return;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		for (const element of pattern.elements) if (element) walkParameterReferences(element, state);
+		return;
+	}
+	if (isNodeOfType(pattern, "RestElement")) walkParameterReferences(pattern.argument, state);
+};
+const walk = (node, state) => {
+	if (isFunctionLike$1(node)) {
+		if (isNodeOfType(node, "FunctionDeclaration") && node.id) handleFunctionDeclaration(node, state);
+		const functionParams = node.params ?? [];
+		for (const param of functionParams) {
+			if (!("decorators" in param) || !Array.isArray(param.decorators)) continue;
+			for (const decorator of param.decorators) if (isAstNode(decorator)) walk(decorator, state);
+		}
+		setNodeScope(node, state);
+		const fnScope = pushScope(node.type === "ArrowFunctionExpression" ? "arrow-function" : "function", node, state);
+		if ((isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && node.id) {
+			recordSymbol(fnScope, state, {
+				name: node.id.name,
+				kind: "function",
+				bindingIdentifier: node.id,
+				declarationNode: node,
+				initializer: node
+			});
+			tagAsBinding(state, node.id);
+		}
+		handleFunctionParameters(functionParams, fnScope, state);
+		for (const param of functionParams) walkParameterReferences(param, state);
+		const body = node.body;
+		if (body) walk(body, state);
+		popScope(state);
+		return;
+	}
+	if (isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression")) {
+		if (isNodeOfType(node, "ClassDeclaration") && node.id) handleClassDeclaration(node, state);
+		if (Array.isArray(node.decorators)) {
+			for (const decorator of node.decorators) if (isAstNode(decorator)) walk(decorator, state);
+		}
+		const classScope = pushScope("class", node, state);
+		setNodeScope(node, state);
+		if (isNodeOfType(node, "ClassExpression") && node.id) {
+			recordSymbol(classScope, state, {
+				name: node.id.name,
+				kind: "class",
+				bindingIdentifier: node.id,
+				declarationNode: node,
+				initializer: node
+			});
+			tagAsBinding(state, node.id);
+		}
+		if (node.superClass) walk(node.superClass, state);
+		if (node.body) walk(node.body, state);
+		popScope(state);
+		return;
+	}
+	if (isNodeOfType(node, "CatchClause")) {
+		const catchScope = pushScope("catch", node, state);
+		setNodeScope(node, state);
+		if (node.param) {
+			visitDestructuringDeclarations(node.param, null, catchScope, state, "catch-clause-parameter", node);
+			for (const identifier of collectBindingNamesFromPattern(node.param)) tagAsBinding(state, identifier);
+		}
+		if (node.body) walk(node.body, state);
+		popScope(state);
+		return;
+	}
+	if (isNodeOfType(node, "ForStatement") || isNodeOfType(node, "ForInStatement") || isNodeOfType(node, "ForOfStatement")) {
+		pushScope("for", node, state);
+		setNodeScope(node, state);
+		const nodeRecord = node;
+		for (const key of Object.keys(nodeRecord)) {
+			if (key === "parent") continue;
+			if (TYPE_POSITION_CHILD_KEYS.has(key)) continue;
+			const child = nodeRecord[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) walk(item, state);
+			} else if (isAstNode(child)) walk(child, state);
+		}
+		popScope(state);
+		return;
+	}
+	if (isNodeOfType(node, "SwitchStatement")) {
+		pushScope("switch", node, state);
+		setNodeScope(node, state);
+		if (node.discriminant) walk(node.discriminant, state);
+		for (const switchCase of node.cases) walk(switchCase, state);
+		popScope(state);
+		return;
+	}
+	if (isNodeOfType(node, "TSModuleDeclaration")) {
+		const moduleScope = pushScope("ts-module", node, state);
+		setNodeScope(node, state);
+		if (node.id && isNodeOfType(node.id, "Identifier")) {
+			const identifier = node.id;
+			recordSymbol(findHoistTargetScope(moduleScope.parent ?? state.currentScope), state, {
+				name: identifier.name,
+				kind: "ts-module",
+				bindingIdentifier: identifier,
+				declarationNode: node,
+				initializer: null
+			});
+			tagAsBinding(state, identifier);
+		}
+		if (node.body) walk(node.body, state);
+		popScope(state);
+		return;
+	}
+	if (isNodeOfType(node, "TSEnumDeclaration")) {
+		handleTsDeclarations(node, state);
+		pushScope("ts-enum", node, state);
+		setNodeScope(node, state);
+		const members = node.members ?? [];
+		for (const member of members) walk(member, state);
+		popScope(state);
+		return;
+	}
+	if (isNodeOfType(node, "BlockStatement") && shouldPushBlockScope(node)) {
+		pushScope("block", node, state);
+		setNodeScope(node, state);
+		for (const statement of node.body) walk(statement, state);
+		popScope(state);
+		return;
+	}
+	setNodeScope(node, state);
+	if (isNodeOfType(node, "VariableDeclaration")) handleVariableDeclaration(node, state);
+	else if (isNodeOfType(node, "FunctionDeclaration")) handleFunctionDeclaration(node, state);
+	else if (isNodeOfType(node, "ClassDeclaration")) handleClassDeclaration(node, state);
+	else if (isNodeOfType(node, "ImportDeclaration")) handleImportDeclaration(node, state);
+	else if (node.type === "TSImportEqualsDeclaration" || node.type === "TSTypeAliasDeclaration" || node.type === "TSInterfaceDeclaration") handleTsDeclarations(node, state);
+	if ((isNodeOfType(node, "Identifier") || isNodeOfType(node, "JSXIdentifier")) && !bindingPositionMarker.has(node) && !isNonReferencePosition(node)) if (isNodeOfType(node, "JSXIdentifier")) {
+		if (isJsxIdentifierBindingReference(node)) recordReference(state, node, inferReferenceFlag(node));
+	} else recordReference(state, node, inferReferenceFlag(node));
+	const nodeRecord = node;
+	for (const key of Object.keys(nodeRecord)) {
+		if (key === "parent") continue;
+		if (TYPE_POSITION_CHILD_KEYS.has(key)) continue;
+		const child = nodeRecord[key];
+		if (Array.isArray(child)) {
+			for (const item of child) if (isAstNode(item)) walk(item, state);
+		} else if (isAstNode(child)) walk(child, state);
+	}
+};
+const resolveReferences = (rootScope) => {
+	const visitScope = (scope) => {
+		for (const reference of scope.references) {
+			const name = reference.identifier.name;
+			if (typeof name !== "string") continue;
+			let lookup = scope;
+			while (lookup) {
+				const found = lookup.symbolsByName.get(name);
+				if (found) {
+					reference.resolvedSymbol = found;
+					found.references.push(reference);
+					break;
+				}
+				lookup = lookup.parent;
+			}
+		}
+		for (const child of scope.children) visitScope(child);
+	};
+	visitScope(rootScope);
+};
+const analyzeScopes = (program) => {
+	const rootScope = {
+		id: 0,
+		kind: "module",
+		node: program,
+		parent: null,
+		children: [],
+		symbols: [],
+		references: [],
+		symbolsByName: /* @__PURE__ */ new Map()
+	};
+	const state = {
+		nextScopeId: 1,
+		nextSymbolId: 0,
+		nextReferenceId: 0,
+		currentScope: rootScope,
+		scopeStack: [rootScope],
+		rootScope,
+		nodeScope: /* @__PURE__ */ new WeakMap(),
+		ownScopeForNode: /* @__PURE__ */ new WeakMap(),
+		symbolByBindingIdentifier: /* @__PURE__ */ new WeakMap(),
+		referenceByIdentifier: /* @__PURE__ */ new WeakMap()
+	};
+	state.nodeScope.set(program, rootScope);
+	state.ownScopeForNode.set(program, rootScope);
+	if (isNodeOfType(program, "Program")) for (const statement of program.body) walk(statement, state);
+	else walk(program, state);
+	resolveReferences(rootScope);
+	const scopeFor = (node) => {
+		let current = node;
+		while (current) {
+			const scope = state.nodeScope.get(current);
+			if (scope) return scope;
+			current = current.parent ?? null;
+		}
+		return rootScope;
+	};
+	const symbolFor = (identifier) => {
+		const reference = state.referenceByIdentifier.get(identifier);
+		if (reference) return reference.resolvedSymbol;
+		const symbolForBinding = state.symbolByBindingIdentifier.get(identifier);
+		if (symbolForBinding) return symbolForBinding;
+		return null;
+	};
+	const referenceFor = (identifier) => {
+		return state.referenceByIdentifier.get(identifier) ?? null;
+	};
+	const isGlobalReference = (identifier) => {
+		const reference = state.referenceByIdentifier.get(identifier);
+		if (!reference) return false;
+		return reference.resolvedSymbol === null;
+	};
+	const ownScopeFor = (node) => {
+		return state.ownScopeForNode.get(node) ?? null;
+	};
+	return {
+		rootScope,
+		scopeFor,
+		ownScopeFor,
+		symbolFor,
+		referenceFor,
+		isGlobalReference
+	};
+};
+const isDescendantScope = (inner, outer) => {
+	let current = inner;
+	while (current) {
+		if (current === outer) return true;
+		current = current.parent;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/collect-pattern-default-reference-names.ts
+const collectPatternDefaultReferenceNames = (pattern, into) => {
+	if (!pattern) return;
+	if (isNodeOfType(pattern, "AssignmentPattern")) {
+		collectReferenceIdentifierNames(pattern.right, into);
+		collectPatternDefaultReferenceNames(pattern.left, into);
+		return;
+	}
+	if (isNodeOfType(pattern, "RestElement")) {
+		collectPatternDefaultReferenceNames(pattern.argument, into);
+		return;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		for (const element of pattern.elements ?? []) collectPatternDefaultReferenceNames(element, into);
+		return;
+	}
+	if (isNodeOfType(pattern, "ObjectPattern")) {
+		for (const property of pattern.properties ?? []) if (isNodeOfType(property, "RestElement")) collectPatternDefaultReferenceNames(property.argument, into);
+		else if (isNodeOfType(property, "Property")) {
+			if (property.computed) collectReferenceIdentifierNames(property.key, into);
+			collectPatternDefaultReferenceNames(property.value, into);
+		}
+	}
+};
+//#endregion
+//#region src/plugin/utils/is-bare-await-expression-statement.ts
+const isBareAwaitExpressionStatement = (statement) => {
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	return isNodeOfType(statement.expression, "AwaitExpression");
+};
+//#endregion
+//#region src/plugin/utils/is-early-exit-if-statement.ts
+const isEarlyExitStatement = (statement) => isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "ContinueStatement") || isNodeOfType(statement, "BreakStatement");
+const isEarlyExitIfStatement = (statement) => {
+	if (!isNodeOfType(statement, "IfStatement")) return false;
+	const consequent = statement.consequent;
+	if (!consequent) return false;
+	if (isEarlyExitStatement(consequent)) return true;
+	if (!isNodeOfType(consequent, "BlockStatement")) return false;
+	for (const inner of consequent.body ?? []) if (isEarlyExitStatement(inner)) return true;
+	return false;
+};
+//#endregion
+//#region src/plugin/rules/performance/async-defer-await.ts
+const hasAnyIdentifierName = (identifierNames, candidateNames) => {
+	for (const candidateName of candidateNames) if (identifierNames.has(candidateName)) return true;
+	return false;
+};
+const collectDeclaratorDependencyIdentifierNames = (declarator, into) => {
+	if (!isNodeOfType(declarator, "VariableDeclarator")) return;
+	collectReferenceIdentifierNames(declarator.init, into);
+	collectPatternDefaultReferenceNames(declarator.id, into);
+};
+const processVariableDeclaration = (declaration, awaitedBindingNames) => {
+	if (!isNodeOfType(declaration, "VariableDeclaration")) return {
+		didIntroduceAwait: false,
+		didGrowBindings: false
+	};
+	let didIntroduceAwait = false;
+	const sizeBeforeAll = awaitedBindingNames.size;
+	let hasChanged = true;
+	while (hasChanged) {
+		hasChanged = false;
+		for (const declarator of declaration.declarations ?? []) {
+			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+			if (containsDirectAwait(declarator.init) || containsDirectAwait(declarator.id)) {
+				didIntroduceAwait = true;
+				const sizeBefore = awaitedBindingNames.size;
+				collectPatternNames(declarator.id, awaitedBindingNames);
+				if (awaitedBindingNames.size > sizeBefore) hasChanged = true;
+				continue;
+			}
+			const dependencyIdentifiers = /* @__PURE__ */ new Set();
+			collectDeclaratorDependencyIdentifierNames(declarator, dependencyIdentifiers);
+			if (!hasAnyIdentifierName(dependencyIdentifiers, awaitedBindingNames)) continue;
+			const sizeBefore = awaitedBindingNames.size;
+			collectPatternNames(declarator.id, awaitedBindingNames);
+			if (awaitedBindingNames.size > sizeBefore) hasChanged = true;
+		}
+	}
+	const didGrowBindings = awaitedBindingNames.size > sizeBeforeAll;
+	return {
+		didIntroduceAwait,
+		didGrowBindings
+	};
+};
+const CANCELLATION_GUARD_NAMES = new Set([
+	"cancelled",
+	"canceled",
+	"isCancelled",
+	"isCanceled",
+	"aborted",
+	"isAborted",
+	"disposed",
+	"isDisposed",
+	"destroyed",
+	"isDestroyed",
+	"stopped",
+	"isStopped",
+	"mounted",
+	"isMounted",
+	"unmounted",
+	"isUnmounted",
+	"active",
+	"isActive",
+	"stale",
+	"isStale",
+	"signal",
+	"abortSignal",
+	"abortController"
+]);
+const testReadsRefCurrent = (test) => {
+	let didFindRefCurrentRead = false;
+	walkAst(test, (child) => {
+		if (didFindRefCurrentRead) return false;
+		if (!isNodeOfType(child, "MemberExpression") || child.computed) return;
+		if (!isNodeOfType(child.property, "Identifier") || child.property.name !== "current") return;
+		if (!isNodeOfType(child.object, "Identifier")) return;
+		const refCandidateName = child.object.name;
+		if (refCandidateName.endsWith("Ref") && refCandidateName.length > 3) {
+			didFindRefCurrentRead = true;
+			return false;
+		}
+	});
+	return didFindRefCurrentRead;
+};
+const CANCELLATION_NAME_FRAGMENTS = [
 	"cancel",
 	"abort",
 	"dispos",
@@ -5371,15 +6010,56 @@ const guardTestReadsMutableEnvironment = (test) => {
 };
 const isNonLiteralComparisonTest = (test) => {
 	if (!test) return false;
-	if (!isNodeOfType(test, "BinaryExpression")) return false;
+	const unwrappedTest = stripParenExpression(test);
+	if (!isNodeOfType(unwrappedTest, "BinaryExpression")) return false;
 	if (![
 		"===",
 		"!==",
 		"==",
 		"!="
-	].includes(test.operator)) return false;
-	const isLiteralOperand = (operand) => isNodeOfType(operand, "Literal") || isNodeOfType(operand, "TemplateLiteral") || isNodeOfType(operand, "UnaryExpression") && isLiteralOperand(operand.argument);
-	return !isLiteralOperand(test.left) && !isLiteralOperand(test.right);
+	].includes(unwrappedTest.operator)) return false;
+	const isLiteralOperand = (operand) => {
+		const unwrappedOperand = stripParenExpression(operand);
+		return isNodeOfType(unwrappedOperand, "Literal") || isNodeOfType(unwrappedOperand, "TemplateLiteral") || isNodeOfType(unwrappedOperand, "UnaryExpression") && isLiteralOperand(unwrappedOperand.argument);
+	};
+	return !isLiteralOperand(unwrappedTest.left) && !isLiteralOperand(unwrappedTest.right);
+};
+const isLocalConstSnapshotOperand = (operand, scopes, functionScope) => {
+	const unwrappedOperand = stripParenExpression(operand);
+	if (!isNodeOfType(unwrappedOperand, "Identifier")) return false;
+	const symbol = scopes.symbolFor(unwrappedOperand);
+	return Boolean(symbol && symbol.kind === "const" && symbol.initializer && isDescendantScope(symbol.scope, functionScope));
+};
+const isLiveFreshnessOperand = (operand, scopes, functionScope) => {
+	const unwrappedOperand = stripParenExpression(operand);
+	if (isNodeOfType(unwrappedOperand, "MemberExpression")) return true;
+	if (!isNodeOfType(unwrappedOperand, "Identifier")) return false;
+	const symbol = scopes.symbolFor(unwrappedOperand);
+	return Boolean(symbol && (symbol.kind === "let" || symbol.kind === "var" || symbol.kind === "import") && !isDescendantScope(symbol.scope, functionScope));
+};
+const isProvenFreshnessComparison = (test, scopes, functionScope) => {
+	const unwrappedTest = stripParenExpression(test);
+	if (!isNonLiteralComparisonTest(unwrappedTest)) return false;
+	if (!isNodeOfType(unwrappedTest, "BinaryExpression")) return false;
+	return isLocalConstSnapshotOperand(unwrappedTest.left, scopes, functionScope) && isLiveFreshnessOperand(unwrappedTest.right, scopes, functionScope) || isLocalConstSnapshotOperand(unwrappedTest.right, scopes, functionScope) && isLiveFreshnessOperand(unwrappedTest.left, scopes, functionScope);
+};
+const isLogicalCompositionOfFreshnessComparisons = (test, scopes, functionScope) => {
+	if (!functionScope) return false;
+	if (!test) return false;
+	const unwrappedTest = stripParenExpression(test);
+	if (!isNodeOfType(unwrappedTest, "LogicalExpression") || unwrappedTest.operator !== "&&" && unwrappedTest.operator !== "||") return false;
+	const pendingTests = [unwrappedTest.left, unwrappedTest.right];
+	while (pendingTests.length > 0) {
+		const candidateTest = pendingTests.pop();
+		if (!candidateTest) continue;
+		const unwrappedCandidateTest = stripParenExpression(candidateTest);
+		if (isNodeOfType(unwrappedCandidateTest, "LogicalExpression") && (unwrappedCandidateTest.operator === "&&" || unwrappedCandidateTest.operator === "||")) {
+			pendingTests.push(unwrappedCandidateTest.left, unwrappedCandidateTest.right);
+			continue;
+		}
+		if (!isProvenFreshnessComparison(unwrappedCandidateTest, scopes, functionScope)) return false;
+	}
+	return true;
 };
 const guardConsequentPerformsSideEffects = (consequent) => {
 	if (!consequent) return false;
@@ -5484,7 +6164,9 @@ const asyncDeferAwait = defineRule({
 					statementIndex = window.guardCandidateIndex - 1;
 					continue;
 				}
-				if (isCancellationGuardTest(guardStatement.test) || guardTestReadsMutableEnvironment(guardStatement.test) || isNonLiteralComparisonTest(guardStatement.test) || guardTestReadsReassignedLocal(guardStatement.test, guardStatement) || guardConsequentPerformsSideEffects(guardStatement.consequent)) {
+				const enclosingFunction = findEnclosingFunction(guardStatement);
+				const functionScope = enclosingFunction ? context.scopes.ownScopeFor(enclosingFunction) : null;
+				if (isCancellationGuardTest(guardStatement.test) || guardTestReadsMutableEnvironment(guardStatement.test) || isNonLiteralComparisonTest(guardStatement.test) || isLogicalCompositionOfFreshnessComparisons(guardStatement.test, context.scopes, functionScope) || guardTestReadsReassignedLocal(guardStatement.test, guardStatement) || guardConsequentPerformsSideEffects(guardStatement.consequent)) {
 					statementIndex = window.guardCandidateIndex - 1;
 					continue;
 				}
@@ -5523,6 +6205,23 @@ const asyncDeferAwait = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/expression-reads-pattern-binding.ts
+const expressionReadsPatternBinding = (expression, patterns, scopes) => {
+	const bindingSymbolIds = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) walkAst(pattern, (child) => {
+		if (!isNodeOfType(child, "Identifier")) return;
+		const symbol = scopes.symbolFor(child);
+		if (symbol?.bindingIdentifier === child) bindingSymbolIds.add(symbol.id);
+	});
+	let didReadBinding = false;
+	walkAst(expression, (child) => {
+		if (didReadBinding || !isNodeOfType(child, "Identifier")) return;
+		const reference = scopes.referenceFor(child);
+		if (reference?.flag !== "write" && reference?.resolvedSymbol && bindingSymbolIds.has(reference.resolvedSymbol.id)) didReadBinding = true;
+	});
+	return didReadBinding;
+};
+//#endregion
 //#region src/plugin/utils/get-callee-identifier-trail.ts
 const getCalleeIdentifierTrail = (call) => {
 	let entry = call;
@@ -5628,16 +6327,12 @@ const isInsideTransactionCallback = (node) => {
 	return false;
 };
 const reportIfIndependent = (statements, context) => {
-	const declaredNames = /* @__PURE__ */ new Set();
+	const declaredPatterns = [];
 	for (const statement of statements) {
 		const awaitArgument = getAwaitedCall(statement);
 		if (!awaitArgument) continue;
-		let referencesEarlierResult = false;
-		walkAst(awaitArgument, (child) => {
-			if (isNodeOfType(child, "Identifier") && declaredNames.has(child.name)) referencesEarlierResult = true;
-		});
-		if (referencesEarlierResult) return;
-		if (isNodeOfType(statement, "VariableDeclaration") && statement.declarations[0]?.id) collectPatternNames(statement.declarations[0].id, declaredNames);
+		if (expressionReadsPatternBinding(awaitArgument, declaredPatterns, context.scopes)) return;
+		if (isNodeOfType(statement, "VariableDeclaration") && statement.declarations[0]?.id) declaredPatterns.push(statement.declarations[0].id);
 	}
 	context.report({
 		node: statements[0],
@@ -7121,12 +7816,6 @@ const clientLocalstorageNoVersion = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-direct-const-initializer.ts
-const getDirectConstInitializer = (symbol) => {
-	if (symbol.kind !== "const" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
-	return symbol.initializer;
-};
-//#endregion
 //#region src/plugin/utils/get-range-start.ts
 const getRangeStart = (node) => {
 	const rangeStart = node.range?.[0];
@@ -7787,10 +8476,21 @@ const isDestructuredReactApiBinding = (identifier, apiNames, scopes, options) =>
 };
 const isReactApiCall = (node, apiNames, scopes, options = {}) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
+	return isReactApiCallee(node.callee, apiNames, scopes, options, /* @__PURE__ */ new Set());
+};
+const isReactApiCallee = (rawCallee, apiNames, scopes, options, visitedSymbolIds) => {
+	const callee = stripParenExpression(rawCallee);
+	if (options.resolveConditionalAliases && isNodeOfType(callee, "ConditionalExpression")) return isReactApiCallee(callee.consequent, apiNames, scopes, options, new Set(visitedSymbolIds)) && isReactApiCallee(callee.alternate, apiNames, scopes, options, new Set(visitedSymbolIds));
 	if (isNodeOfType(callee, "Identifier")) {
 		if (isNamedReactApiImport(callee, apiNames, scopes, Boolean(options.resolveNamedAliases))) return true;
 		if (options.resolveNamedAliases && isDestructuredReactApiBinding(callee, apiNames, scopes, options)) return true;
+		if (options.resolveConditionalAliases) {
+			const symbol = scopes.symbolFor(callee);
+			if (symbol?.kind === "const" && symbol.initializer && !visitedSymbolIds.has(symbol.id)) {
+				visitedSymbolIds.add(symbol.id);
+				return isReactApiCallee(symbol.initializer, apiNames, scopes, options, visitedSymbolIds);
+			}
+		}
 		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
 	}
 	if (!isNodeOfType(callee, "MemberExpression") || !includesApiName(apiNames, getStaticPropertyName(callee) ?? "")) return false;
@@ -10812,14 +11512,6 @@ const displayName = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/read-static-boolean.ts
-const readStaticBoolean = (node) => {
-	if (!node) return null;
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "Literal") || typeof unwrappedNode.value !== "boolean") return null;
-	return unwrappedNode.value;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/build-listener-cleanup-mismatch-message.ts
 const buildListenerCleanupMismatchMessage = (eventName, registrationCapture, removalCapture, callbackComparison) => {
 	const hasCallbackMismatch = callbackComparison === "different";
@@ -11655,6 +12347,10 @@ const isConstAliasOfGlobalArrayFrom = (node, scopes) => {
 };
 const executesDuringRender = (functionNode, scopes) => {
 	const parent = functionNode.parent;
+	if (isNodeOfType(parent, "NewExpression")) {
+		const callee = stripParenExpression(parent.callee);
+		return Boolean(scopes && parent.arguments?.[0] === functionNode && isNodeOfType(callee, "Identifier") && callee.name === "Promise" && scopes.isGlobalReference(callee));
+	}
 	if (!isNodeOfType(parent, "CallExpression")) return false;
 	if (parent.callee === functionNode) return true;
 	if ((scopes ? isReactApiCall(parent, REACT_RENDER_PHASE_HOOK_NAMES, scopes, { allowGlobalReactNamespace: true }) : isHookCall$2(parent, REACT_RENDER_PHASE_HOOK_NAMES)) && parent.arguments?.[0] === functionNode) return true;
@@ -11674,7 +12370,7 @@ const findRenderPhaseComponentOrHook = (node, scopes) => {
 };
 //#endregion
 //#region src/plugin/utils/get-function-binding-name.ts
-const getFunctionBindingIdentifier = (functionNode) => {
+const getFunctionBindingIdentifier$1 = (functionNode) => {
 	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
 	const parent = functionNode.parent;
 	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
@@ -11685,7 +12381,7 @@ const getFunctionBindingIdentifier = (functionNode) => {
 	}
 	return null;
 };
-const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(functionNode)?.name ?? null;
+const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier$1(functionNode)?.name ?? null;
 //#endregion
 //#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);
@@ -12272,7 +12968,7 @@ const findDirectCallForReference = (identifier) => {
 	return isNodeOfType(callNode, "CallExpression") && callNode.callee === expressionRoot ? callNode : null;
 };
 const findSingleDirectInvocation = (functionNode, caller, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier || resolveStableValue(bindingIdentifier, context) !== functionNode) return null;
 	const symbol = context.scopes.symbolFor(bindingIdentifier);
 	if (!symbol) return null;
@@ -12809,7 +13505,7 @@ const isReturnedEffectCleanupFunction = (functionNode) => {
 };
 const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode)) return true;
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) return false;
 	const symbol = context.scopes.symbolFor(bindingIdentifier);
 	if (!symbol) return false;
@@ -13043,7 +13739,7 @@ const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) =
 	return didFindCleanupEffect;
 };
 const isUseSyncExternalStoreSubscribeFunction = (functionNode, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) return false;
 	const visitedSymbolIds = /* @__PURE__ */ new Set();
 	const isSubscribeBinding = (candidateBinding) => {
@@ -13211,517 +13907,6 @@ const effectNeedsCleanup = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/semantic/scope-analysis.ts
-const isHoistedBindingKind = (kind) => kind === "var" || kind === "function";
-const findHoistTargetScope = (scope) => {
-	let current = scope;
-	while (current) {
-		if (current.kind === "module" || current.kind === "function" || current.kind === "arrow-function" || current.kind === "method") return current;
-		current = current.parent;
-	}
-	return scope;
-};
-const createScope = (kind, node, parent, state) => {
-	const scope = {
-		id: state.nextScopeId++,
-		kind,
-		node,
-		parent,
-		children: [],
-		symbols: [],
-		references: [],
-		symbolsByName: /* @__PURE__ */ new Map()
-	};
-	if (parent) parent.children.push(scope);
-	return scope;
-};
-const pushScope = (kind, node, state) => {
-	const scope = createScope(kind, node, state.currentScope, state);
-	state.scopeStack.push(scope);
-	state.currentScope = scope;
-	state.ownScopeForNode.set(node, scope);
-	return scope;
-};
-const popScope = (state) => {
-	state.scopeStack.pop();
-	const previous = state.scopeStack[state.scopeStack.length - 1];
-	if (!previous) throw new Error("scope stack underflow");
-	state.currentScope = previous;
-};
-const recordSymbol = (scope, state, options) => {
-	const symbol = {
-		id: state.nextSymbolId++,
-		name: options.name,
-		kind: options.kind,
-		bindingIdentifier: options.bindingIdentifier,
-		declarationNode: options.declarationNode,
-		scope,
-		initializer: options.initializer,
-		references: []
-	};
-	scope.symbols.push(symbol);
-	scope.symbolsByName.set(options.name, symbol);
-	state.symbolByBindingIdentifier.set(options.bindingIdentifier, symbol);
-	return symbol;
-};
-const collectBindingNamesFromPattern = (pattern) => {
-	const out = [];
-	const visit = (node) => {
-		if (isNodeOfType(node, "Identifier")) {
-			out.push(node);
-			return;
-		}
-		if (isNodeOfType(node, "ObjectPattern")) {
-			for (const property of node.properties) if (isNodeOfType(property, "Property")) {
-				const propValue = property.value;
-				visit(propValue);
-			} else if (isNodeOfType(property, "RestElement")) visit(property.argument);
-			return;
-		}
-		if (isNodeOfType(node, "ArrayPattern")) {
-			for (const element of node.elements) if (element) visit(element);
-			return;
-		}
-		if (isNodeOfType(node, "RestElement")) {
-			visit(node.argument);
-			return;
-		}
-		if (isNodeOfType(node, "AssignmentPattern")) visit(node.left);
-	};
-	visit(pattern);
-	return out;
-};
-const visitDestructuringDeclarations = (pattern, baseInitializer, scope, state, symbolKind, declarationNode) => {
-	if (isNodeOfType(pattern, "Identifier")) {
-		recordSymbol(scope, state, {
-			name: pattern.name,
-			kind: symbolKind,
-			bindingIdentifier: pattern,
-			declarationNode,
-			initializer: baseInitializer
-		});
-		return;
-	}
-	if (isNodeOfType(pattern, "ObjectPattern")) {
-		for (const property of pattern.properties) if (isNodeOfType(property, "Property")) {
-			const propertyValue = property.value;
-			visitDestructuringDeclarations(propertyValue, isNodeOfType(propertyValue, "AssignmentPattern") ? propertyValue.right : baseInitializer, scope, state, symbolKind, declarationNode);
-		} else if (isNodeOfType(property, "RestElement")) visitDestructuringDeclarations(property.argument, baseInitializer, scope, state, symbolKind, declarationNode);
-		return;
-	}
-	if (isNodeOfType(pattern, "ArrayPattern")) {
-		for (const element of pattern.elements) {
-			if (!element) continue;
-			visitDestructuringDeclarations(element, isNodeOfType(element, "AssignmentPattern") ? element.right ?? null : baseInitializer, scope, state, symbolKind, declarationNode);
-		}
-		return;
-	}
-	if (isNodeOfType(pattern, "AssignmentPattern")) {
-		visitDestructuringDeclarations(pattern.left, pattern.right ?? null, scope, state, symbolKind, declarationNode);
-		return;
-	}
-	if (isNodeOfType(pattern, "RestElement")) visitDestructuringDeclarations(pattern.argument, null, scope, state, symbolKind, declarationNode);
-};
-const tagAsBinding = (state, identifier) => {
-	bindingPositionMarker.add(identifier);
-};
-const bindingPositionMarker = /* @__PURE__ */ new WeakSet();
-const recordReference = (state, identifier, flag) => {
-	const reference = {
-		id: state.nextReferenceId++,
-		identifier,
-		resolvedSymbol: null,
-		flag,
-		scope: state.currentScope
-	};
-	state.currentScope.references.push(reference);
-	state.referenceByIdentifier.set(identifier, reference);
-};
-const isFunctionBodyBlock = (block) => {
-	if (!block.parent) return false;
-	return isFunctionLike$1(block.parent);
-};
-const isCatchClauseBlock = (block) => block.parent !== null && block.parent !== void 0 && block.parent.type === "CatchClause";
-const handleVariableDeclaration = (declaration, state) => {
-	if (!isNodeOfType(declaration, "VariableDeclaration")) return;
-	const symbolKind = declaration.kind === "var" ? "var" : declaration.kind === "let" ? "let" : declaration.kind === "const" ? "const" : "using";
-	const targetScope = isHoistedBindingKind(symbolKind) ? findHoistTargetScope(state.currentScope) : state.currentScope;
-	for (const declarator of declaration.declarations) {
-		const declaratorNode = declarator;
-		const init = declarator.init ?? null;
-		visitDestructuringDeclarations(declarator.id, init, targetScope, state, symbolKind, declaratorNode);
-		for (const identifier of collectBindingNamesFromPattern(declarator.id)) tagAsBinding(state, identifier);
-	}
-};
-const handleFunctionDeclaration = (fn, state) => {
-	if (!isNodeOfType(fn, "FunctionDeclaration")) return;
-	if (fn.id) {
-		recordSymbol(findHoistTargetScope(state.currentScope), state, {
-			name: fn.id.name,
-			kind: "function",
-			bindingIdentifier: fn.id,
-			declarationNode: fn,
-			initializer: fn
-		});
-		tagAsBinding(state, fn.id);
-	}
-};
-const handleClassDeclaration = (cls, state) => {
-	if (!isNodeOfType(cls, "ClassDeclaration")) return;
-	if (cls.id) {
-		recordSymbol(state.currentScope, state, {
-			name: cls.id.name,
-			kind: "class",
-			bindingIdentifier: cls.id,
-			declarationNode: cls,
-			initializer: cls
-		});
-		tagAsBinding(state, cls.id);
-	}
-};
-const handleImportDeclaration = (importDeclaration, state) => {
-	if (!isNodeOfType(importDeclaration, "ImportDeclaration")) return;
-	const target = findHoistTargetScope(state.currentScope);
-	for (const specifier of importDeclaration.specifiers) {
-		const local = specifier.local;
-		if (!isNodeOfType(local, "Identifier")) continue;
-		recordSymbol(target, state, {
-			name: local.name,
-			kind: "import",
-			bindingIdentifier: local,
-			declarationNode: specifier,
-			initializer: specifier
-		});
-		tagAsBinding(state, local);
-	}
-};
-const handleTsDeclarations = (node, state) => {
-	if (node.type !== "TSImportEqualsDeclaration" && node.type !== "TSEnumDeclaration" && node.type !== "TSTypeAliasDeclaration" && node.type !== "TSInterfaceDeclaration" && node.type !== "TSModuleDeclaration") return;
-	const idNode = node.id;
-	if (!idNode || !isNodeOfType(idNode, "Identifier")) return;
-	const kind = node.type === "TSImportEqualsDeclaration" ? "ts-import-equals" : node.type === "TSEnumDeclaration" ? "ts-enum" : node.type === "TSTypeAliasDeclaration" ? "ts-type-alias" : node.type === "TSInterfaceDeclaration" ? "ts-interface" : "ts-module";
-	recordSymbol(findHoistTargetScope(state.currentScope), state, {
-		name: idNode.name,
-		kind,
-		bindingIdentifier: idNode,
-		declarationNode: node,
-		initializer: null
-	});
-	tagAsBinding(state, idNode);
-};
-const handleFunctionParameters = (params, scope, state) => {
-	for (const param of params) {
-		visitDestructuringDeclarations(param, null, scope, state, "parameter", param);
-		for (const identifier of collectBindingNamesFromPattern(param)) tagAsBinding(state, identifier);
-	}
-};
-const shouldPushBlockScope = (block) => {
-	if (!isNodeOfType(block, "BlockStatement")) return false;
-	if (isFunctionBodyBlock(block)) return false;
-	if (isCatchClauseBlock(block)) return false;
-	if (block.parent && block.parent.type === "TSModuleDeclaration") return false;
-	return true;
-};
-const isJsxIdentifierBindingReference = (identifier) => {
-	const parent = identifier.parent;
-	if (!parent) return false;
-	if (parent.type === "JSXMemberExpression") return parent.object === identifier;
-	if (parent.type === "JSXNamespacedName") return false;
-	const ASCII_LOWERCASE_A = 97;
-	const ASCII_LOWERCASE_Z = 122;
-	const firstCharCode = identifier.name.charCodeAt(0);
-	if (firstCharCode >= ASCII_LOWERCASE_A && firstCharCode <= ASCII_LOWERCASE_Z) return false;
-	return true;
-};
-const isNonReferencePosition = (identifier) => {
-	const parent = identifier.parent;
-	if (!parent) return false;
-	switch (parent.type) {
-		case "MemberExpression": return parent.property === identifier && !parent.computed;
-		case "Property": return parent.key === identifier && !parent.computed && !parent.shorthand;
-		case "MethodDefinition":
-		case "PropertyDefinition": return parent.key === identifier && !parent.computed;
-		case "JSXAttribute": return parent.name === identifier;
-		case "ImportSpecifier": return parent.imported === identifier;
-		case "ExportSpecifier": return parent.exported === identifier && parent.local !== parent.exported;
-		case "LabeledStatement":
-		case "BreakStatement":
-		case "ContinueStatement": return parent.label === identifier;
-		default: return false;
-	}
-};
-const inferReferenceFlag = (identifier) => {
-	const parent = identifier.parent;
-	if (!parent) return "read";
-	switch (parent.type) {
-		case "AssignmentExpression":
-			if (parent.left === identifier) return parent.operator === "=" ? "write" : "read-write";
-			return "read";
-		case "UpdateExpression": return "read-write";
-		case "ForInStatement":
-		case "ForOfStatement": return parent.left === identifier ? "write" : "read";
-		default: return "read";
-	}
-};
-const setNodeScope = (node, state) => {
-	state.nodeScope.set(node, state.currentScope);
-};
-const walkParameterReferences = (pattern, state) => {
-	if (isNodeOfType(pattern, "AssignmentPattern")) {
-		walkParameterReferences(pattern.left, state);
-		const defaultValue = pattern.right ?? null;
-		if (defaultValue) walk(defaultValue, state);
-		return;
-	}
-	if (isNodeOfType(pattern, "ObjectPattern")) {
-		for (const property of pattern.properties) {
-			const propertyNode = property;
-			if (isNodeOfType(propertyNode, "RestElement")) {
-				walkParameterReferences(propertyNode.argument, state);
-				continue;
-			}
-			if (!isNodeOfType(propertyNode, "Property")) continue;
-			const propertyDetail = propertyNode;
-			if (propertyDetail.computed) walk(propertyDetail.key, state);
-			walkParameterReferences(propertyDetail.value, state);
-		}
-		return;
-	}
-	if (isNodeOfType(pattern, "ArrayPattern")) {
-		for (const element of pattern.elements) if (element) walkParameterReferences(element, state);
-		return;
-	}
-	if (isNodeOfType(pattern, "RestElement")) walkParameterReferences(pattern.argument, state);
-};
-const walk = (node, state) => {
-	if (isFunctionLike$1(node)) {
-		if (isNodeOfType(node, "FunctionDeclaration") && node.id) handleFunctionDeclaration(node, state);
-		const functionParams = node.params ?? [];
-		for (const param of functionParams) {
-			if (!("decorators" in param) || !Array.isArray(param.decorators)) continue;
-			for (const decorator of param.decorators) if (isAstNode(decorator)) walk(decorator, state);
-		}
-		setNodeScope(node, state);
-		const fnScope = pushScope(node.type === "ArrowFunctionExpression" ? "arrow-function" : "function", node, state);
-		if ((isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && node.id) {
-			recordSymbol(fnScope, state, {
-				name: node.id.name,
-				kind: "function",
-				bindingIdentifier: node.id,
-				declarationNode: node,
-				initializer: node
-			});
-			tagAsBinding(state, node.id);
-		}
-		handleFunctionParameters(functionParams, fnScope, state);
-		for (const param of functionParams) walkParameterReferences(param, state);
-		const body = node.body;
-		if (body) walk(body, state);
-		popScope(state);
-		return;
-	}
-	if (isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression")) {
-		if (isNodeOfType(node, "ClassDeclaration") && node.id) handleClassDeclaration(node, state);
-		if (Array.isArray(node.decorators)) {
-			for (const decorator of node.decorators) if (isAstNode(decorator)) walk(decorator, state);
-		}
-		const classScope = pushScope("class", node, state);
-		setNodeScope(node, state);
-		if (isNodeOfType(node, "ClassExpression") && node.id) {
-			recordSymbol(classScope, state, {
-				name: node.id.name,
-				kind: "class",
-				bindingIdentifier: node.id,
-				declarationNode: node,
-				initializer: node
-			});
-			tagAsBinding(state, node.id);
-		}
-		if (node.superClass) walk(node.superClass, state);
-		if (node.body) walk(node.body, state);
-		popScope(state);
-		return;
-	}
-	if (isNodeOfType(node, "CatchClause")) {
-		const catchScope = pushScope("catch", node, state);
-		setNodeScope(node, state);
-		if (node.param) {
-			visitDestructuringDeclarations(node.param, null, catchScope, state, "catch-clause-parameter", node);
-			for (const identifier of collectBindingNamesFromPattern(node.param)) tagAsBinding(state, identifier);
-		}
-		if (node.body) walk(node.body, state);
-		popScope(state);
-		return;
-	}
-	if (isNodeOfType(node, "ForStatement") || isNodeOfType(node, "ForInStatement") || isNodeOfType(node, "ForOfStatement")) {
-		pushScope("for", node, state);
-		setNodeScope(node, state);
-		const nodeRecord = node;
-		for (const key of Object.keys(nodeRecord)) {
-			if (key === "parent") continue;
-			if (TYPE_POSITION_CHILD_KEYS.has(key)) continue;
-			const child = nodeRecord[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) walk(item, state);
-			} else if (isAstNode(child)) walk(child, state);
-		}
-		popScope(state);
-		return;
-	}
-	if (isNodeOfType(node, "SwitchStatement")) {
-		pushScope("switch", node, state);
-		setNodeScope(node, state);
-		if (node.discriminant) walk(node.discriminant, state);
-		for (const switchCase of node.cases) walk(switchCase, state);
-		popScope(state);
-		return;
-	}
-	if (isNodeOfType(node, "TSModuleDeclaration")) {
-		const moduleScope = pushScope("ts-module", node, state);
-		setNodeScope(node, state);
-		if (node.id && isNodeOfType(node.id, "Identifier")) {
-			const identifier = node.id;
-			recordSymbol(findHoistTargetScope(moduleScope.parent ?? state.currentScope), state, {
-				name: identifier.name,
-				kind: "ts-module",
-				bindingIdentifier: identifier,
-				declarationNode: node,
-				initializer: null
-			});
-			tagAsBinding(state, identifier);
-		}
-		if (node.body) walk(node.body, state);
-		popScope(state);
-		return;
-	}
-	if (isNodeOfType(node, "TSEnumDeclaration")) {
-		handleTsDeclarations(node, state);
-		pushScope("ts-enum", node, state);
-		setNodeScope(node, state);
-		const members = node.members ?? [];
-		for (const member of members) walk(member, state);
-		popScope(state);
-		return;
-	}
-	if (isNodeOfType(node, "BlockStatement") && shouldPushBlockScope(node)) {
-		pushScope("block", node, state);
-		setNodeScope(node, state);
-		for (const statement of node.body) walk(statement, state);
-		popScope(state);
-		return;
-	}
-	setNodeScope(node, state);
-	if (isNodeOfType(node, "VariableDeclaration")) handleVariableDeclaration(node, state);
-	else if (isNodeOfType(node, "FunctionDeclaration")) handleFunctionDeclaration(node, state);
-	else if (isNodeOfType(node, "ClassDeclaration")) handleClassDeclaration(node, state);
-	else if (isNodeOfType(node, "ImportDeclaration")) handleImportDeclaration(node, state);
-	else if (node.type === "TSImportEqualsDeclaration" || node.type === "TSTypeAliasDeclaration" || node.type === "TSInterfaceDeclaration") handleTsDeclarations(node, state);
-	if ((isNodeOfType(node, "Identifier") || isNodeOfType(node, "JSXIdentifier")) && !bindingPositionMarker.has(node) && !isNonReferencePosition(node)) if (isNodeOfType(node, "JSXIdentifier")) {
-		if (isJsxIdentifierBindingReference(node)) recordReference(state, node, inferReferenceFlag(node));
-	} else recordReference(state, node, inferReferenceFlag(node));
-	const nodeRecord = node;
-	for (const key of Object.keys(nodeRecord)) {
-		if (key === "parent") continue;
-		if (TYPE_POSITION_CHILD_KEYS.has(key)) continue;
-		const child = nodeRecord[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (isAstNode(item)) walk(item, state);
-		} else if (isAstNode(child)) walk(child, state);
-	}
-};
-const resolveReferences = (rootScope) => {
-	const visitScope = (scope) => {
-		for (const reference of scope.references) {
-			const name = reference.identifier.name;
-			if (typeof name !== "string") continue;
-			let lookup = scope;
-			while (lookup) {
-				const found = lookup.symbolsByName.get(name);
-				if (found) {
-					reference.resolvedSymbol = found;
-					found.references.push(reference);
-					break;
-				}
-				lookup = lookup.parent;
-			}
-		}
-		for (const child of scope.children) visitScope(child);
-	};
-	visitScope(rootScope);
-};
-const analyzeScopes = (program) => {
-	const rootScope = {
-		id: 0,
-		kind: "module",
-		node: program,
-		parent: null,
-		children: [],
-		symbols: [],
-		references: [],
-		symbolsByName: /* @__PURE__ */ new Map()
-	};
-	const state = {
-		nextScopeId: 1,
-		nextSymbolId: 0,
-		nextReferenceId: 0,
-		currentScope: rootScope,
-		scopeStack: [rootScope],
-		rootScope,
-		nodeScope: /* @__PURE__ */ new WeakMap(),
-		ownScopeForNode: /* @__PURE__ */ new WeakMap(),
-		symbolByBindingIdentifier: /* @__PURE__ */ new WeakMap(),
-		referenceByIdentifier: /* @__PURE__ */ new WeakMap()
-	};
-	state.nodeScope.set(program, rootScope);
-	state.ownScopeForNode.set(program, rootScope);
-	if (isNodeOfType(program, "Program")) for (const statement of program.body) walk(statement, state);
-	else walk(program, state);
-	resolveReferences(rootScope);
-	const scopeFor = (node) => {
-		let current = node;
-		while (current) {
-			const scope = state.nodeScope.get(current);
-			if (scope) return scope;
-			current = current.parent ?? null;
-		}
-		return rootScope;
-	};
-	const symbolFor = (identifier) => {
-		const reference = state.referenceByIdentifier.get(identifier);
-		if (reference) return reference.resolvedSymbol;
-		const symbolForBinding = state.symbolByBindingIdentifier.get(identifier);
-		if (symbolForBinding) return symbolForBinding;
-		return null;
-	};
-	const referenceFor = (identifier) => {
-		return state.referenceByIdentifier.get(identifier) ?? null;
-	};
-	const isGlobalReference = (identifier) => {
-		const reference = state.referenceByIdentifier.get(identifier);
-		if (!reference) return false;
-		return reference.resolvedSymbol === null;
-	};
-	const ownScopeFor = (node) => {
-		return state.ownScopeForNode.get(node) ?? null;
-	};
-	return {
-		rootScope,
-		scopeFor,
-		ownScopeFor,
-		symbolFor,
-		referenceFor,
-		isGlobalReference
-	};
-};
-const isDescendantScope = (inner, outer) => {
-	let current = inner;
-	while (current) {
-		if (current === outer) return true;
-		current = current.parent;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/semantic/closure-captures.ts
 const computeClosureCaptures = (functionNode, scopes) => {
 	const functionScope = scopes.ownScopeFor(functionNode) ?? scopes.scopeFor(functionNode);
@@ -17006,8 +17191,86 @@ const htmlNoNestedInteractive = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/get-authoritative-jsx-attribute.ts
+const getAuthoritativeJsxAttribute = (attributes, targetName, isCaseSensitive = true) => {
+	const normalizedTargetName = isCaseSensitive ? targetName : targetName.toLowerCase();
+	for (let attributeIndex = attributes.length - 1; attributeIndex >= 0; attributeIndex -= 1) {
+		const attribute = attributes[attributeIndex];
+		if (!attribute || isNodeOfType(attribute, "JSXSpreadAttribute")) return null;
+		if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+		const attributeName = getJsxAttributeName(attribute.name);
+		if ((isCaseSensitive ? attributeName : attributeName?.toLowerCase()) === normalizedTargetName) return attribute;
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/is-jsx-fragment-element.ts
+const isJsxFragmentElement = (node, scopes) => {
+	if (!isNodeOfType(node, "JSXOpeningElement")) return false;
+	const elementName = node.name;
+	if (isNodeOfType(elementName, "JSXIdentifier")) {
+		if (!scopes) return elementName.name === "Fragment";
+		const symbol = resolveConstIdentifierAlias(elementName, scopes);
+		if (!symbol) return elementName.name === "Fragment" && scopes.isGlobalReference(elementName);
+		return isImportedFromReact(symbol) && getImportedName(symbol.declarationNode) === "Fragment";
+	}
+	if (isNodeOfType(elementName, "JSXMemberExpression")) {
+		if (!isNodeOfType(elementName.object, "JSXIdentifier")) return false;
+		if (elementName.property.name !== "Fragment") return false;
+		if (!scopes) return elementName.object.name === "React";
+		if (isReactNamespaceImport(elementName.object, scopes)) return true;
+		return elementName.object.name === "React" && scopes.isGlobalReference(elementName.object);
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/a11y/iframe-has-title.ts
 const MESSAGE$51 = "Screen reader users cannot identify this `<iframe>` because it has no title. Add a `title` that describes its content.";
+const isStaticallyAriaHidden = (openingElement) => {
+	const ariaHiddenAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-hidden", false);
+	if (!ariaHiddenAttribute) return false;
+	if (!ariaHiddenAttribute.value) return true;
+	const value = ariaHiddenAttribute.value;
+	if (isNodeOfType(value, "Literal")) return value.value === true || value.value === "true";
+	if (!isNodeOfType(value, "JSXExpressionContainer")) return false;
+	return isNodeOfType(value.expression, "Literal") && (value.expression.value === true || value.expression.value === "true");
+};
+const hasStaticallyNegativeTabIndex = (openingElement) => {
+	const tabIndexAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "tabIndex", false);
+	if (!tabIndexAttribute) return false;
+	const value = tabIndexAttribute.value;
+	if (value && isNodeOfType(value, "JSXExpressionContainer") && isNodeOfType(value.expression, "ConditionalExpression") && !isNodeOfType(value.expression.test, "Literal")) return false;
+	const tabIndexValue = parseJsxValue(value);
+	return tabIndexValue !== null && tabIndexValue < 0;
+};
+const hasStaticallyDecorativeRole = (openingElement, scopes) => {
+	const roleAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "role", false);
+	if (!roleAttribute) return false;
+	const roleCandidates = getJsxPropStaticStringValues(roleAttribute, scopes);
+	return roleCandidates !== null && roleCandidates.length > 0 && roleCandidates.every((roleCandidate) => {
+		const firstValidRole = roleCandidate.split(/\s+/).find((roleToken) => VALID_ARIA_ROLES.has(roleToken));
+		return firstValidRole !== void 0 && PRESENTATION_ROLES$1.has(firstValidRole);
+	});
+};
+const isInsideStaticallyHiddenJsxSubtree = (openingElement, scopes) => {
+	if (isStaticallyAriaHidden(openingElement)) return true;
+	let ancestor = openingElement.parent?.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXAttribute")) {
+			if (!(isNodeOfType(ancestor.name, "JSXIdentifier") && ancestor.name.name === "children")) return false;
+		}
+		if (isNodeOfType(ancestor, "JSXElement") && !isJsxFragmentElement(ancestor.openingElement, scopes)) {
+			const ancestorName = ancestor.openingElement.name;
+			if (!isNodeOfType(ancestorName, "JSXIdentifier")) return false;
+			const firstCharacter = ancestorName.name[0];
+			if (!(firstCharacter === firstCharacter?.toLowerCase())) return false;
+			if (isStaticallyAriaHidden(ancestor.openingElement)) return true;
+		}
+		if (isNodeOfType(ancestor, "CallExpression") || isNodeOfType(ancestor, "NewExpression") || isNodeOfType(ancestor, "VariableDeclarator") || isNodeOfType(ancestor, "AssignmentExpression") || isNodeOfType(ancestor, "Property") || isFunctionLike$1(ancestor) || isNodeOfType(ancestor, "Program")) return false;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
 const evaluateTitleValue = (value) => {
 	if (!value) return "missing";
 	if (isNodeOfType(value, "Literal")) {
@@ -17042,6 +17305,9 @@ const iframeHasTitle = defineRule({
 	create: (context) => ({ JSXOpeningElement(node) {
 		const tag = getElementType(node, context.settings);
 		if (tag !== "iframe") return;
+		if (isInsideStaticallyHiddenJsxSubtree(node, context.scopes)) return;
+		if (hasStaticallyNegativeTabIndex(node)) return;
+		if (hasStaticallyDecorativeRole(node, context.scopes)) return;
 		const hasSpread = node.attributes.some((attribute) => isNodeOfType(attribute, "JSXSpreadAttribute"));
 		const titleAttr = hasJsxPropIgnoreCase(node.attributes, "title");
 		if (!titleAttr) {
@@ -17574,7 +17840,7 @@ const interactiveSupportsFocus = defineRule({
 			if (!hasInteractiveHandler) return;
 			const elementType = getElementType(node, context.settings);
 			if (!HTML_TAGS.has(elementType)) return;
-			if (isDisabledElement(node) || isHiddenFromScreenReader(node, context.settings) || isPresentationRole(node)) return;
+			if (canContentEditableBeTabbable(node, context.scopes, context.settings) || isDisabledElement(node) || isHiddenFromScreenReader(node, context.settings) || isPresentationRole(node)) return;
 			const hasTabIndex = Boolean(hasJsxPropIgnoreCase(node.attributes, "tabIndex"));
 			const hasId = Boolean(hasJsxPropIgnoreCase(node.attributes, "id"));
 			for (const role of roleCandidates) {
@@ -21134,26 +21400,6 @@ const jsxFilenameExtension = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-jsx-fragment-element.ts
-const isJsxFragmentElement = (node, scopes) => {
-	if (!isNodeOfType(node, "JSXOpeningElement")) return false;
-	const elementName = node.name;
-	if (isNodeOfType(elementName, "JSXIdentifier")) {
-		if (!scopes) return elementName.name === "Fragment";
-		const symbol = resolveConstIdentifierAlias(elementName, scopes);
-		if (!symbol) return elementName.name === "Fragment" && scopes.isGlobalReference(elementName);
-		return isImportedFromReact(symbol) && getImportedName(symbol.declarationNode) === "Fragment";
-	}
-	if (isNodeOfType(elementName, "JSXMemberExpression")) {
-		if (!isNodeOfType(elementName.object, "JSXIdentifier")) return false;
-		if (elementName.property.name !== "Fragment") return false;
-		if (!scopes) return elementName.object.name === "React";
-		if (isReactNamespaceImport(elementName.object, scopes)) return true;
-		return elementName.object.name === "React" && scopes.isGlobalReference(elementName.object);
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/jsx-fragments.ts
 const SYNTAX_MESSAGE = "`<React.Fragment>` is used where shorthand fragments are configured, so similar wrappers look different across the codebase.";
 const ELEMENT_MESSAGE = "Fragment shorthand is used where explicit fragments are configured, so similar wrappers look different across the codebase.";
@@ -21492,7 +21738,7 @@ const namedCallbackIteratorCallCache = /* @__PURE__ */ new WeakMap();
 const findNamedCallbackIteratorCall = (functionNode) => {
 	const cached = namedCallbackIteratorCallCache.get(functionNode);
 	if (cached !== void 0) return cached;
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) {
 		namedCallbackIteratorCallCache.set(functionNode, null);
 		return null;
@@ -22317,7 +22563,7 @@ const isReactSlotType = (typeNode, environment, activeDeclarations) => {
 	}
 	return environment.reactSlotTypeBindings.has(typeName);
 };
-const getPropertyName = (property) => {
+const getPropertyName$1 = (property) => {
 	if (!isNodeOfType(property, "TSPropertySignature") || property.computed) return null;
 	if (isNodeOfType(property.key, "Identifier")) return property.key.name;
 	if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") return property.key.value;
@@ -22329,7 +22575,7 @@ const collectSlotPropertyNames = (propsType, environment, slotPropertyNames, act
 	if (isNodeOfType(propsType, "TSInterfaceDeclaration")) members = propsType.body.body;
 	if (members) {
 		for (const member of members) {
-			const propertyName = getPropertyName(member);
+			const propertyName = getPropertyName$1(member);
 			if (!propertyName || !isNodeOfType(member, "TSPropertySignature")) continue;
 			const annotation = member.typeAnnotation;
 			if (annotation && isNodeOfType(annotation, "TSTypeAnnotation") && isReactSlotType(annotation.typeAnnotation, environment, /* @__PURE__ */ new Set())) slotPropertyNames.add(propertyName);
@@ -26051,6 +26297,7 @@ const nextjsNoClientSideRedirect = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-no-css-link.ts
+const HTTP_STYLESHEET_URL_PATTERN = /^https?:\/\//i;
 const nextjsNoCssLink = defineRule({
 	id: "nextjs-no-css-link",
 	title: "Linked stylesheet bypasses Next.js CSS optimization",
@@ -26064,10 +26311,10 @@ const nextjsNoCssLink = defineRule({
 		const relAttribute = findJsxAttribute(attributes, "rel");
 		if (!relAttribute?.value) return;
 		if ((isNodeOfType(relAttribute.value, "Literal") ? relAttribute.value.value : null) !== "stylesheet") return;
-		const hrefAttribute = findJsxAttribute(attributes, "href");
-		if (!hrefAttribute?.value) return;
-		const hrefValue = isNodeOfType(hrefAttribute.value, "Literal") ? hrefAttribute.value.value : null;
-		if (typeof hrefValue === "string" && GOOGLE_FONTS_PATTERN.test(hrefValue)) return;
+		if (!findJsxAttribute(attributes, "href")?.value) return;
+		const authoritativeHrefAttribute = getAuthoritativeJsxAttribute(attributes, "href");
+		const hrefCandidates = authoritativeHrefAttribute ? getJsxPropStaticStringValues(authoritativeHrefAttribute, context.scopes) : null;
+		if (hrefCandidates !== null && hrefCandidates.length > 0 && hrefCandidates.every((hrefCandidate) => HTTP_STYLESHEET_URL_PATTERN.test(hrefCandidate))) return;
 		context.report({
 			node,
 			message: "This <link rel=\"stylesheet\"> bypasses Next.js CSS handling, so the CSS loads unbundled and unoptimized."
@@ -29593,18 +29840,143 @@ const ARITHMETIC_KEY_OPERATORS = new Set([
 	"%"
 ]);
 const bindingMutationResultsByProgram = /* @__PURE__ */ new WeakMap();
-const extractCandidateIdentifiers = (expression) => {
+const UNKNOWN_STATIC_KEY_BRANCH_VALUE = {
+	isNullish: null,
+	isTruthy: null
+};
+const mergeStaticKeyBranchValues = (firstValue, secondValue) => ({
+	isNullish: firstValue.isNullish === secondValue.isNullish ? firstValue.isNullish : null,
+	isTruthy: firstValue.isTruthy === secondValue.isTruthy ? firstValue.isTruthy : null
+});
+const readStaticKeyBranchValue = (expression, depth) => {
+	if (depth > TYPE_RESOLUTION_DEPTH_LIMIT) return null;
+	const node = stripParenExpression(expression);
+	if (isNodeOfType(node, "Literal")) return {
+		isNullish: node.value === null,
+		isTruthy: Boolean(node.value)
+	};
+	if (isNodeOfType(node, "ArrayExpression") || isNodeOfType(node, "ObjectExpression") || isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ClassExpression") || isNodeOfType(node, "NewExpression")) return {
+		isNullish: false,
+		isTruthy: true
+	};
+	if (isNodeOfType(node, "TemplateLiteral")) return {
+		isNullish: false,
+		isTruthy: (node.quasis ?? []).some((quasi) => typeof quasi.value?.cooked === "string" && quasi.value.cooked.length > 0) ? true : null
+	};
+	if (isNodeOfType(node, "BinaryExpression")) return {
+		isNullish: false,
+		isTruthy: null
+	};
+	if (isNodeOfType(node, "Identifier")) {
+		const binding = findVariableInitializer(node, node.name);
+		if (!binding) {
+			if (node.name === "undefined") return {
+				isNullish: true,
+				isTruthy: false
+			};
+			if (node.name === "NaN") return {
+				isNullish: false,
+				isTruthy: false
+			};
+			if (node.name === "Infinity") return {
+				isNullish: false,
+				isTruthy: true
+			};
+			return null;
+		}
+		if (!isConstDeclaredBinding(binding) || !binding.initializer) return null;
+		const declarator = binding.bindingIdentifier.parent;
+		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || declarator.id !== binding.bindingIdentifier || declarator.init !== binding.initializer) return null;
+		return readStaticKeyBranchValue(binding.initializer, depth + 1);
+	}
+	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier")) {
+		if (!Boolean(findVariableInitializer(node.callee, node.callee.name)) && STRING_COERCION_FUNCTIONS.has(node.callee.name)) return {
+			isNullish: false,
+			isTruthy: null
+		};
+	}
+	if (isNodeOfType(node, "UnaryExpression")) {
+		if (node.operator === "void") return {
+			isNullish: true,
+			isTruthy: false
+		};
+		if (node.operator === "typeof") return {
+			isNullish: false,
+			isTruthy: true
+		};
+		if (node.operator === "+" || node.operator === "-" || node.operator === "~") return {
+			isNullish: false,
+			isTruthy: null
+		};
+		if (node.operator !== "!") return null;
+		const argumentValue = readStaticKeyBranchValue(node.argument, depth + 1);
+		if (!argumentValue || argumentValue.isTruthy === null) return null;
+		return {
+			isNullish: false,
+			isTruthy: !argumentValue.isTruthy
+		};
+	}
+	if (isNodeOfType(node, "SequenceExpression")) {
+		const finalExpression = node.expressions.at(-1);
+		return finalExpression ? readStaticKeyBranchValue(finalExpression, depth + 1) : null;
+	}
+	if (isNodeOfType(node, "LogicalExpression")) {
+		const leftValue = readStaticKeyBranchValue(node.left, depth + 1) ?? UNKNOWN_STATIC_KEY_BRANCH_VALUE;
+		if (node.operator === "&&" && leftValue.isTruthy !== null) return leftValue.isTruthy ? readStaticKeyBranchValue(node.right, depth + 1) : leftValue;
+		if (node.operator === "||" && leftValue.isTruthy !== null) return leftValue.isTruthy ? leftValue : readStaticKeyBranchValue(node.right, depth + 1);
+		if (node.operator === "??" && leftValue.isNullish !== null) return leftValue.isNullish ? readStaticKeyBranchValue(node.right, depth + 1) : leftValue;
+		const rightValue = readStaticKeyBranchValue(node.right, depth + 1) ?? UNKNOWN_STATIC_KEY_BRANCH_VALUE;
+		if (node.operator === "||") return {
+			isNullish: rightValue.isNullish === false ? false : null,
+			isTruthy: rightValue.isTruthy === true ? true : null
+		};
+		if (node.operator === "&&") return {
+			isNullish: leftValue.isNullish === false && rightValue.isNullish === false ? false : null,
+			isTruthy: rightValue.isTruthy === false ? false : null
+		};
+		return {
+			isNullish: rightValue.isNullish === false ? false : null,
+			isTruthy: leftValue.isTruthy !== null && leftValue.isTruthy === rightValue.isTruthy ? leftValue.isTruthy : null
+		};
+	}
+	if (isNodeOfType(node, "ConditionalExpression")) {
+		const testValue = readStaticKeyBranchValue(node.test, depth + 1);
+		if (testValue?.isTruthy !== null && testValue?.isTruthy !== void 0) return readStaticKeyBranchValue(testValue.isTruthy ? node.consequent : node.alternate, depth + 1);
+		return mergeStaticKeyBranchValues(readStaticKeyBranchValue(node.consequent, depth + 1) ?? UNKNOWN_STATIC_KEY_BRANCH_VALUE, readStaticKeyBranchValue(node.alternate, depth + 1) ?? UNKNOWN_STATIC_KEY_BRANCH_VALUE);
+	}
+	return null;
+};
+const extractCandidateIdentifiers = (expression, depth = 0) => {
+	if (depth > TYPE_RESOLUTION_DEPTH_LIMIT) return [];
 	const node = stripParenExpression(expression);
 	if (isNodeOfType(node, "Identifier")) return [node];
-	if (isNodeOfType(node, "UnaryExpression") && (node.operator === "-" || node.operator === "+" || node.operator === "~") && isNodeOfType(node.argument, "Identifier")) return [node.argument];
+	if (isNodeOfType(node, "UnaryExpression") && (node.operator === "-" || node.operator === "+" || node.operator === "~") && node.argument) return extractCandidateIdentifiers(node.argument, depth + 1);
 	if (isNodeOfType(node, "TemplateLiteral")) {
 		const identifiers = [];
-		for (const templateExpression of node.expressions ?? []) if (isNodeOfType(templateExpression, "Identifier")) identifiers.push(templateExpression);
+		for (const templateExpression of node.expressions ?? []) identifiers.push(...extractCandidateIdentifiers(templateExpression, depth + 1));
 		return identifiers;
 	}
+	if (isNodeOfType(node, "LogicalExpression")) {
+		const leftValue = readStaticKeyBranchValue(node.left, 0);
+		if (leftValue) {
+			if (node.operator === "&&" && leftValue.isTruthy !== null) return extractCandidateIdentifiers(leftValue.isTruthy ? node.right : node.left, depth + 1);
+			if (node.operator === "||" && leftValue.isTruthy !== null) return extractCandidateIdentifiers(leftValue.isTruthy ? node.left : node.right, depth + 1);
+			if (node.operator === "??" && leftValue.isNullish !== null) return extractCandidateIdentifiers(leftValue.isNullish ? node.right : node.left, depth + 1);
+		}
+		return [...extractCandidateIdentifiers(node.left, depth + 1), ...extractCandidateIdentifiers(node.right, depth + 1)];
+	}
+	if (isNodeOfType(node, "ConditionalExpression")) {
+		const testValue = readStaticKeyBranchValue(node.test, 0);
+		if (testValue && testValue.isTruthy !== null) return extractCandidateIdentifiers(testValue.isTruthy ? node.consequent : node.alternate, depth + 1);
+		return [...extractCandidateIdentifiers(node.consequent, depth + 1), ...extractCandidateIdentifiers(node.alternate, depth + 1)];
+	}
+	if (isNodeOfType(node, "SequenceExpression")) {
+		const finalExpression = node.expressions.at(-1);
+		return finalExpression ? extractCandidateIdentifiers(finalExpression, depth + 1) : [];
+	}
 	if (isNodeOfType(node, "CallExpression")) {
-		if (isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "toString") return [node.callee.object];
-		if (isNodeOfType(node.callee, "Identifier") && STRING_COERCION_FUNCTIONS.has(node.callee.name) && isNodeOfType(node.arguments?.[0], "Identifier")) return [node.arguments[0]];
+		if (isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "toString") return extractCandidateIdentifiers(node.callee.object, depth + 1);
+		if (isNodeOfType(node.callee, "Identifier") && STRING_COERCION_FUNCTIONS.has(node.callee.name) && !findVariableInitializer(node.callee, node.callee.name) && node.arguments?.[0]) return extractCandidateIdentifiers(node.arguments[0], depth + 1);
 		return [];
 	}
 	if (isNodeOfType(node, "BinaryExpression")) {
@@ -31757,6 +32129,7 @@ const createStateTriggerReachability = ({ analysis, context, effectFunction }) =
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-chain-state-updates.ts
+const APPLICABLE_EFFECT_HOOK_NAMES = new Set(["useEffect", "useLayoutEffect"]);
 const getUseStateDeclarator = (ref) => (ref.resolved?.defs ?? []).map((def) => def.node).find((node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "ArrayPattern")) ?? null;
 const isDeclaredWithin = (node, container) => {
 	let walker = node;
@@ -31808,7 +32181,12 @@ const noChainStateUpdates = defineRule({
 	tags: ["test-noise"],
 	recommendation: "Set all the related state together in the event handler that starts it, instead of having one useEffect react to a state change and set more state. See https://react.dev/learn/you-might-not-need-an-effect#chains-of-computations",
 	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
+		if (!isReactApiCall(node, APPLICABLE_EFFECT_HOOK_NAMES, context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveConditionalAliases: true,
+			resolveNamedAliases: true
+		})) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		if (hasCleanup(analysis, node)) return;
@@ -31988,17 +32366,611 @@ const noCreateContextInRender = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/collect-function-children-references.ts
+const collectFunctionChildrenReferences = (functionNode, scopes) => {
+	if (!isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "FunctionDeclaration")) return null;
+	const rawPropsParameter = functionNode.params[0];
+	const propsParameter = isNodeOfType(rawPropsParameter, "AssignmentPattern") ? rawPropsParameter.left : rawPropsParameter;
+	if (isNodeOfType(propsParameter, "ObjectPattern")) {
+		const childrenProperty = propsParameter.properties.find((property) => isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "children");
+		if (!childrenProperty || !isNodeOfType(childrenProperty, "Property")) return null;
+		const childrenBinding = isNodeOfType(childrenProperty.value, "AssignmentPattern") ? childrenProperty.value.left : childrenProperty.value;
+		if (!isNodeOfType(childrenBinding, "Identifier")) return null;
+		const childrenSymbol = scopes.symbolFor(childrenBinding);
+		if (!childrenSymbol || childrenSymbol.references.length === 0 || childrenSymbol.references.some((reference) => reference.flag !== "read")) return null;
+		return childrenSymbol.references.map((reference) => reference.identifier);
+	}
+	if (!isNodeOfType(propsParameter, "Identifier")) return null;
+	const propsSymbol = scopes.symbolFor(propsParameter);
+	if (!propsSymbol || propsSymbol.references.length === 0) return null;
+	const childrenReferences = [];
+	for (const reference of propsSymbol.references) {
+		if (reference.flag !== "read") return null;
+		const propertyPath = [];
+		let expression = findTransparentExpressionRoot(reference.identifier);
+		while (expression.parent && isNodeOfType(expression.parent, "MemberExpression") && expression.parent.object === expression) {
+			const propertyName = getStaticPropertyName(expression.parent);
+			if (!propertyName) return null;
+			propertyPath.push(propertyName);
+			expression = findTransparentExpressionRoot(expression.parent);
+		}
+		if (propertyPath[0] !== "children") {
+			if (propertyPath.length === 0) return null;
+			continue;
+		}
+		if (propertyPath.length !== 1) return null;
+		childrenReferences.push(expression);
+	}
+	return childrenReferences.length > 0 ? childrenReferences : null;
+};
+//#endregion
+//#region src/plugin/utils/is-proven-react-class-component.ts
+const REACT_COMPONENT_CLASS_NAMES = new Set(["Component", "PureComponent"]);
+const isReactComponentClassValue = (node, scopes, visitedClassNodes, visitedSymbolIds) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "MemberExpression")) {
+		const propertyName = getStaticPropertyName(expression);
+		const receiver = stripParenExpression(expression.object);
+		return Boolean(propertyName && REACT_COMPONENT_CLASS_NAMES.has(propertyName) && isNodeOfType(receiver, "Identifier") && !hasStaticPropertyWriteBefore(receiver, propertyName, expression, scopes) && isReactNamespaceImport(receiver, scopes));
+	}
+	if (isNodeOfType(expression, "ClassExpression")) return isProvenReactClassComponent(expression, scopes, visitedClassNodes, visitedSymbolIds);
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, expression, scopes)) return false;
+	visitedSymbolIds.add(symbol.id);
+	if (isImportedFromReact(symbol)) {
+		const importedName = getImportedName(symbol.declarationNode);
+		return Boolean(importedName && REACT_COMPONENT_CLASS_NAMES.has(importedName));
+	}
+	if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes, visitedClassNodes, visitedSymbolIds);
+	return Boolean(symbol.kind === "const" && symbol.initializer && isReactComponentClassValue(symbol.initializer, scopes, visitedClassNodes, visitedSymbolIds));
+};
+const isProvenReactClassComponent = (classNode, scopes, visitedClassNodes = /* @__PURE__ */ new Set(), visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression") || visitedClassNodes.has(classNode) || !classNode.superClass) return false;
+	visitedClassNodes.add(classNode);
+	return isReactComponentClassValue(classNode.superClass, scopes, visitedClassNodes, visitedSymbolIds);
+};
+//#endregion
+//#region src/plugin/utils/is-proven-intrinsic-jsx-element.ts
+const isProvenIntrinsicJsxElement = (openingElement, scopes) => {
+	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
+	const resolvedElementType = resolveJsxElementType(openingElement);
+	if (resolvedElementType[0] === resolvedElementType[0]?.toLowerCase()) return true;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	const isIntrinsicValue = (node) => {
+		const current = findTransparentExpressionRoot(node);
+		if (isNodeOfType(current, "Literal")) return typeof current.value === "string";
+		if (isNodeOfType(current, "Identifier") || isNodeOfType(current, "JSXIdentifier")) {
+			const symbol = scopes.symbolFor(current);
+			if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return false;
+			visitedSymbolIds.add(symbol.id);
+			const isIntrinsic = isIntrinsicValue(symbol.initializer);
+			visitedSymbolIds.delete(symbol.id);
+			return isIntrinsic;
+		}
+		if (isNodeOfType(current, "ConditionalExpression")) return isIntrinsicValue(current.consequent) && isIntrinsicValue(current.alternate);
+		return false;
+	};
+	return isIntrinsicValue(openingElement.name);
+};
+//#endregion
+//#region src/plugin/rules/react-builtins/is-safe-create-ref-callback-current-write.ts
+const pathStartsWith$1 = (propertyPath, prefix) => prefix.every((propertyName, index) => propertyPath[index] === propertyName);
+const collectMemberExpression = (identifier) => {
+	let expression = findTransparentExpressionRoot(identifier);
+	while (expression.parent && isNodeOfType(expression.parent, "MemberExpression") && expression.parent.object === expression) {
+		if (!getStaticPropertyName(expression.parent)) return null;
+		expression = findTransparentExpressionRoot(expression.parent);
+	}
+	return expression;
+};
+const isInlineIntrinsicRefCallback = (functionNode, scopes) => {
+	const functionExpression = findTransparentExpressionRoot(functionNode);
+	if (!isFunctionLike$1(functionExpression) || functionExpression.async || functionExpression.generator) return false;
+	const container = functionExpression.parent;
+	if (!container || !isNodeOfType(container, "JSXExpressionContainer")) return false;
+	const attribute = container.parent;
+	if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
+	const openingElement = attribute.parent;
+	return Boolean(openingElement && isNodeOfType(openingElement, "JSXOpeningElement") && isProvenIntrinsicJsxElement(openingElement, scopes));
+};
+const isSafeCreateRefCallbackCurrentWrite = (referenceNode, accessedPropertyPath, targetPropertyPath, scopes) => {
+	if (accessedPropertyPath.length !== targetPropertyPath.length + 1 || !pathStartsWith$1(accessedPropertyPath, targetPropertyPath) || accessedPropertyPath[targetPropertyPath.length] !== "current") return false;
+	const memberExpression = collectMemberExpression(referenceNode);
+	const assignment = memberExpression?.parent;
+	if (!memberExpression || !assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== memberExpression) return false;
+	const enclosingFunction = findEnclosingFunction$1(referenceNode);
+	if (!enclosingFunction) return false;
+	if (isInlineIntrinsicRefCallback(enclosingFunction, scopes)) return true;
+	if (!isFunctionLike$1(enclosingFunction) || enclosingFunction.async || enclosingFunction.generator) return false;
+	const callbackFunction = findEnclosingFunction$1(enclosingFunction);
+	if (!callbackFunction || !isInlineIntrinsicRefCallback(callbackFunction, scopes)) return false;
+	const cleanupFunction = findTransparentExpressionRoot(enclosingFunction);
+	const cleanupContainer = cleanupFunction.parent;
+	return Boolean(isNodeOfType(cleanupContainer, "ReturnStatement") && cleanupContainer.argument === cleanupFunction && findEnclosingFunction$1(cleanupContainer) === callbackFunction || isNodeOfType(callbackFunction, "ArrowFunctionExpression") && callbackFunction.body === cleanupFunction);
+};
+//#endregion
+//#region src/plugin/rules/react-builtins/is-value-rendered-in-same-render.ts
+const isValueRenderedFromOwner = (expressionNode, renderOwner, scopes, visitedSymbolIds, options) => {
+	const expression = findTransparentExpressionRoot(expressionNode);
+	const parent = expression.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "ReturnStatement") && parent.argument === expression) return findEnclosingFunction$1(parent) === renderOwner;
+	if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === expression) return parent === renderOwner;
+	if (isNodeOfType(parent, "JSXFragment") && parent.children.some((child) => child === expression)) return isValueRenderedFromOwner(parent, renderOwner, scopes, visitedSymbolIds, options);
+	if (isNodeOfType(parent, "JSXElement") && parent.children.some((child) => child === expression) && (isProvenIntrinsicJsxElement(parent.openingElement, scopes) || isJsxFragmentElement(parent.openingElement, scopes) || options.doesCustomElementRenderChildren?.(parent.openingElement))) return isValueRenderedFromOwner(parent, renderOwner, scopes, visitedSymbolIds, options);
+	if (isNodeOfType(parent, "JSXExpressionContainer") && parent.expression === expression && parent.parent && (isNodeOfType(parent.parent, "JSXFragment") || isNodeOfType(parent.parent, "JSXElement") && (isProvenIntrinsicJsxElement(parent.parent.openingElement, scopes) || isJsxFragmentElement(parent.parent.openingElement, scopes) || options.doesCustomElementRenderChildren?.(parent.parent.openingElement)))) return isValueRenderedFromOwner(parent.parent, renderOwner, scopes, visitedSymbolIds, options);
+	if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === expression || parent.alternate === expression) || isNodeOfType(parent, "LogicalExpression") && (parent.left === expression || parent.right === expression) || isNodeOfType(parent, "ArrayExpression") && parent.elements.some((element) => element === expression)) return isValueRenderedFromOwner(parent, renderOwner, scopes, visitedSymbolIds, options);
+	if (!isNodeOfType(parent, "VariableDeclarator") || parent.init !== expression || !isNodeOfType(parent.id, "Identifier")) return false;
+	const symbol = scopes.symbolFor(parent.id);
+	if (!symbol || symbol.kind !== "const" || symbol.references.length === 0 || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	const isRendered = symbol.references.every((reference) => reference.flag === "read" && isValueRenderedFromOwner(reference.identifier, renderOwner, scopes, visitedSymbolIds, options));
+	visitedSymbolIds.delete(symbol.id);
+	return isRendered;
+};
+const isValueRenderedInSameRender = (expressionNode, scopes, options = {}) => isValueRenderedFromOwner(expressionNode, findEnclosingFunction$1(expressionNode), scopes, /* @__PURE__ */ new Set(), options);
+//#endregion
+//#region src/plugin/rules/react-builtins/is-create-ref-result-write-only.ts
+const pathStartsWith = (propertyPath, prefix) => prefix.every((propertyName, index) => propertyPath[index] === propertyName);
+const pathsOverlap = (firstPath, secondPath) => pathStartsWith(firstPath, secondPath) || pathStartsWith(secondPath, firstPath);
+const isClosedNoopFunction = (node) => isFunctionLike$1(node) && isNodeOfType(node.body, "BlockStatement") && node.body.body.length === 0;
+const isProvenReactCall = (callExpression, expectedName, scopes) => isReactApiCall(callExpression, expectedName, scopes, { resolveNamedAliases: true });
+const objectHasOnlyClosedNoopFunctions = (objectExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!isNodeOfType(objectExpression, "ObjectExpression")) return false;
+	return objectExpression.properties.every((property) => {
+		if (isNodeOfType(property, "SpreadElement")) {
+			const spreadArgument = findTransparentExpressionRoot(property.argument);
+			if (isNodeOfType(spreadArgument, "ObjectExpression")) return objectHasOnlyClosedNoopFunctions(spreadArgument, scopes, visitedSymbolIds);
+			if (!isNodeOfType(spreadArgument, "Identifier")) return false;
+			const symbol = scopes.symbolFor(spreadArgument);
+			if (!symbol || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.initializer, "ObjectExpression")) return false;
+			visitedSymbolIds.add(symbol.id);
+			const isClosed = objectHasOnlyClosedNoopFunctions(symbol.initializer, scopes, visitedSymbolIds);
+			visitedSymbolIds.delete(symbol.id);
+			return isClosed;
+		}
+		if (!isNodeOfType(property, "Property")) return false;
+		return !isFunctionLike$1(property.value) || isClosedNoopFunction(property.value);
+	});
+};
+const getValuePathPropertyName = (memberExpression) => {
+	const propertyName = getStaticPropertyName(memberExpression);
+	if (propertyName) return propertyName;
+	return memberExpression.computed && isNodeOfType(memberExpression.property, "Literal") && typeof memberExpression.property.value === "number" && Number.isSafeInteger(memberExpression.property.value) && memberExpression.property.value >= 0 ? String(memberExpression.property.value) : null;
+};
+const collectMemberAccess = (identifier) => {
+	const propertyPath = [];
+	let expression = findTransparentExpressionRoot(identifier);
+	while (expression.parent && isNodeOfType(expression.parent, "MemberExpression") && expression.parent.object === expression) {
+		const propertyName = getValuePathPropertyName(expression.parent);
+		if (!propertyName) return null;
+		propertyPath.push(propertyName);
+		expression = findTransparentExpressionRoot(expression.parent);
+	}
+	return {
+		expression,
+		propertyPath
+	};
+};
+const getEnvironment = (program, filename, state) => {
+	const cached = state.environmentsByProgram.get(program);
+	if (cached) return cached;
+	const environment = {
+		filename,
+		program,
+		scopes: analyzeScopes(program)
+	};
+	state.environmentsByProgram.set(program, environment);
+	return environment;
+};
+const unwrapProvenReactHocFunction = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!node) return null;
+	const current = findTransparentExpressionRoot(node);
+	if (isFunctionLike$1(current)) return current;
+	if (isNodeOfType(current, "Identifier")) {
+		const symbol = scopes.symbolFor(current);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || !symbol.initializer || hasSymbolWriteBefore(symbol, current, scopes)) return null;
+		visitedSymbolIds.add(symbol.id);
+		return unwrapProvenReactHocFunction(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(current, "CallExpression")) return null;
+	if (!isProvenReactCall(current, "memo", scopes) && !isProvenReactCall(current, "forwardRef", scopes)) return null;
+	const firstArgument = current.arguments[0];
+	if (!firstArgument || isNodeOfType(firstArgument, "SpreadElement")) return null;
+	return unwrapProvenReactHocFunction(firstArgument, scopes, visitedSymbolIds);
+};
+const isForwardRefValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const current = findTransparentExpressionRoot(node);
+	if (isNodeOfType(current, "Identifier")) {
+		const symbol = scopes.symbolFor(current);
+		if (!symbol || !symbol.initializer || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, current, scopes)) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isForwardRefValue(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(current, "CallExpression")) return false;
+	if (isProvenReactCall(current, "forwardRef", scopes)) return true;
+	if (!isProvenReactCall(current, "memo", scopes)) return false;
+	const firstArgument = current.arguments[0];
+	if (!firstArgument || isNodeOfType(firstArgument, "SpreadElement")) return false;
+	return isForwardRefValue(firstArgument, scopes, visitedSymbolIds);
+};
+const functionFromExport = (resolved, state) => {
+	const environment = getEnvironment(resolved.programNode, resolved.filePath, state);
+	const functionNode = unwrapProvenReactHocFunction(resolved.exportedNode, environment.scopes);
+	if (!functionNode) return null;
+	return {
+		environment,
+		functionNode,
+		isForwardRef: isForwardRefValue(resolved.exportedNode, environment.scopes)
+	};
+};
+const resolveFunctionValue = (identifier, environment, state) => {
+	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
+	const symbol = environment.scopes.symbolFor(identifier);
+	if (symbol && symbol.kind !== "import") {
+		if (hasSymbolWriteBefore(symbol, identifier, environment.scopes)) return null;
+		const functionNode = unwrapProvenReactHocFunction(symbol.initializer, environment.scopes);
+		if (!functionNode) return null;
+		return {
+			environment,
+			functionNode,
+			isForwardRef: Boolean(symbol.initializer && isForwardRefValue(symbol.initializer, environment.scopes))
+		};
+	}
+	const binding = getImportBindingForName(identifier, identifier.name);
+	if (!binding || binding.isNamespace || binding.exportedName === null) return null;
+	const resolved = resolveCrossFileValueExportWithFilePath(environment.filename, binding.source, binding.exportedName);
+	return resolved ? functionFromExport(resolved, state) : null;
+};
+const resolveJsxFunctionValue = (elementName, environment, state) => {
+	if (isNodeOfType(elementName, "JSXIdentifier")) return resolveFunctionValue(elementName, environment, state);
+	if (!isNodeOfType(elementName, "JSXMemberExpression") || !isNodeOfType(elementName.object, "JSXIdentifier")) return null;
+	const namespaceBinding = getImportBindingForName(elementName.object, elementName.object.name);
+	if (!namespaceBinding?.isNamespace) return null;
+	const resolved = resolveCrossFileValueExportWithFilePath(environment.filename, namespaceBinding.source, elementName.property.name);
+	return resolved ? functionFromExport(resolved, state) : null;
+};
+const isProvenReactClassValue = (node, environment, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const current = findTransparentExpressionRoot(node);
+	if (isNodeOfType(current, "Identifier")) {
+		const symbol = environment.scopes.symbolFor(current);
+		if (!symbol || !symbol.initializer || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, current, environment.scopes)) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isProvenReactClassValue(symbol.initializer, environment, visitedSymbolIds);
+	}
+	return isProvenReactClassComponent(current, environment.scopes);
+};
+const isProvenClassComponentIdentifier = (identifier, environment, state) => {
+	if (!isNodeOfType(identifier, "JSXIdentifier")) return false;
+	const symbol = environment.scopes.symbolFor(identifier);
+	if (symbol && symbol.kind !== "import") {
+		if (hasSymbolWriteBefore(symbol, identifier, environment.scopes)) return false;
+		return Boolean(symbol.initializer && isProvenReactClassValue(symbol.initializer, environment));
+	}
+	const binding = getImportBindingForName(identifier, identifier.name);
+	if (!binding || binding.isNamespace || binding.exportedName === null) return false;
+	const resolved = resolveCrossFileValueExportWithFilePath(environment.filename, binding.source, binding.exportedName);
+	if (!resolved) return false;
+	const resolvedEnvironment = getEnvironment(resolved.programNode, resolved.filePath, state);
+	return isProvenReactClassValue(resolved.exportedNode, resolvedEnvironment);
+};
+const resolveClassValue = (node, environment) => {
+	if (!node) return null;
+	const classNode = findTransparentExpressionRoot(node);
+	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression") || !isProvenReactClassValue(classNode, environment)) return null;
+	return {
+		classNode,
+		environment
+	};
+};
+const resolveJsxClassValue = (elementName, environment, state) => {
+	if (!isNodeOfType(elementName, "JSXIdentifier")) return null;
+	const symbol = environment.scopes.symbolFor(elementName);
+	if (symbol && symbol.kind !== "import") {
+		if (hasSymbolWriteBefore(symbol, elementName, environment.scopes)) return null;
+		return resolveClassValue(symbol.initializer, environment);
+	}
+	const binding = getImportBindingForName(elementName, elementName.name);
+	if (!binding || binding.isNamespace || binding.exportedName === null) return null;
+	const resolved = resolveCrossFileValueExportWithFilePath(environment.filename, binding.source, binding.exportedName);
+	if (!resolved) return null;
+	const resolvedEnvironment = getEnvironment(resolved.programNode, resolved.filePath, state);
+	return resolveClassValue(resolved.exportedNode, resolvedEnvironment);
+};
+const findOwnedSymbolValue = (expressionNode, initialPropertyPath, environment) => {
+	const propertyPath = [...initialPropertyPath];
+	let expression = findTransparentExpressionRoot(expressionNode);
+	while (expression.parent) {
+		const parent = expression.parent;
+		if (isNodeOfType(parent, "ArrayExpression")) {
+			if (parent.elements.some((element) => element && isNodeOfType(element, "SpreadElement"))) return null;
+			const elementIndex = parent.elements.findIndex((element) => element === expression);
+			if (elementIndex < 0) return null;
+			propertyPath.unshift(String(elementIndex));
+			expression = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		if (isNodeOfType(parent, "Property") && parent.value === expression) {
+			const propertyName = getStaticPropertyKeyName(parent, { allowComputedString: true });
+			const objectExpression = parent.parent;
+			if (!propertyName || !objectExpression || !objectHasOnlyClosedNoopFunctions(objectExpression, environment.scopes)) return null;
+			propertyPath.unshift(propertyName);
+			expression = findTransparentExpressionRoot(objectExpression);
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === expression || parent.alternate === expression) || isNodeOfType(parent, "LogicalExpression") && (parent.left === expression || parent.right === expression)) {
+			expression = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		if (isNodeOfType(parent, "VariableDeclarator") && parent.init === expression && isNodeOfType(parent.id, "Identifier")) {
+			const symbol = environment.scopes.symbolFor(parent.id);
+			if (!symbol || symbol.kind !== "const") return null;
+			return {
+				environment,
+				propertyPath,
+				symbol
+			};
+		}
+		if (isNodeOfType(parent, "AssignmentExpression") && parent.operator === "=" && parent.right === expression && isNodeOfType(parent.left, "MemberExpression")) {
+			const assignedPropertyPath = [];
+			let assignedExpression = parent.left;
+			while (isNodeOfType(assignedExpression, "MemberExpression")) {
+				const propertyName = getValuePathPropertyName(assignedExpression);
+				if (!propertyName) return null;
+				assignedPropertyPath.unshift(propertyName);
+				assignedExpression = findTransparentExpressionRoot(assignedExpression.object);
+			}
+			if (!isNodeOfType(assignedExpression, "Identifier")) return null;
+			const symbol = environment.scopes.symbolFor(assignedExpression);
+			if (!symbol || symbol.kind !== "const") return null;
+			return {
+				environment,
+				originWriteReference: assignedExpression,
+				propertyPath: [...assignedPropertyPath, ...propertyPath],
+				symbol
+			};
+		}
+		return null;
+	}
+	return null;
+};
+const analyzePatternPath = (pattern, propertyPath, environment, state, remainingDepth) => {
+	if (isNodeOfType(pattern, "AssignmentPattern")) return analyzePatternPath(pattern.left, propertyPath, environment, state, remainingDepth);
+	if (isNodeOfType(pattern, "Identifier")) {
+		const symbol = environment.scopes.symbolFor(pattern);
+		return Boolean(symbol && analyzeSymbolValuePath({
+			environment,
+			propertyPath,
+			symbol
+		}, state, remainingDepth - 1));
+	}
+	if (!isNodeOfType(pattern, "ObjectPattern") || propertyPath.length === 0) return false;
+	const [firstPropertyName, ...remainingPropertyPath] = propertyPath;
+	for (const property of pattern.properties) {
+		if (!isNodeOfType(property, "Property")) continue;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (!propertyName) return false;
+		if (propertyName !== firstPropertyName) continue;
+		return analyzePatternPath(property.value, remainingPropertyPath, environment, state, remainingDepth);
+	}
+	const restProperty = pattern.properties.find((property) => isNodeOfType(property, "RestElement"));
+	return restProperty ? analyzePatternPath(restProperty.argument, propertyPath, environment, state, remainingDepth) : true;
+};
+const isIntrinsicReactElementFactoryCall = (callExpression, environment) => {
+	const element = callExpression.arguments[0];
+	if (!element || isNodeOfType(element, "SpreadElement")) return false;
+	if (isProvenReactCall(callExpression, "createElement", environment.scopes)) return isNodeOfType(element, "Literal") && typeof element.value === "string";
+	if (!isProvenReactCall(callExpression, "cloneElement", environment.scopes)) return false;
+	if (!isNodeOfType(element, "JSXElement")) return false;
+	return isProvenIntrinsicJsxElement(element.openingElement, environment.scopes);
+};
+const isIntrinsicReactElementRefProperty = (expression, propertyPath, environment, state, remainingDepth) => {
+	if (propertyPath.length > 0) return false;
+	const property = expression.parent;
+	if (!property || !isNodeOfType(property, "Property") || property.value !== expression) return false;
+	if (getStaticPropertyKeyName(property, { allowComputedString: true }) !== "ref") return false;
+	const props = property.parent;
+	if (!props || !isNodeOfType(props, "ObjectExpression")) return false;
+	const callExpression = props.parent;
+	if (!callExpression || !isNodeOfType(callExpression, "CallExpression") || callExpression.arguments[1] !== props || !isIntrinsicReactElementFactoryCall(callExpression, environment) || !isValueRenderedForEnvironment(callExpression, environment, state, remainingDepth)) return false;
+	return true;
+};
+const analyzeFunctionInput = (resolvedFunction, parameterIndex, propertyPath, state, remainingDepth) => {
+	if (remainingDepth <= 0 || !isFunctionLike$1(resolvedFunction.functionNode) || resolvedFunction.functionNode.async || resolvedFunction.functionNode.generator) return false;
+	const parameter = resolvedFunction.functionNode.params[parameterIndex];
+	return Boolean(parameter && analyzePatternPath(parameter, propertyPath, resolvedFunction.environment, state, remainingDepth));
+};
+const isThisPropsChildren = (node) => {
+	if (!isNodeOfType(node, "MemberExpression") || getStaticPropertyName(node) !== "children") return false;
+	const propsMember = findTransparentExpressionRoot(node.object);
+	return Boolean(isNodeOfType(propsMember, "MemberExpression") && getStaticPropertyName(propsMember) === "props" && isNodeOfType(findTransparentExpressionRoot(propsMember.object), "ThisExpression"));
+};
+const isProvenReactContextProvider = (openingElement, environment) => {
+	if (!isNodeOfType(openingElement, "JSXOpeningElement") || !isNodeOfType(openingElement.name, "JSXMemberExpression") || openingElement.name.property.name !== "Provider" || !isNodeOfType(openingElement.name.object, "JSXIdentifier")) return false;
+	const contextSymbol = environment.scopes.symbolFor(openingElement.name.object);
+	return Boolean(contextSymbol?.kind === "const" && contextSymbol.initializer && isNodeOfType(contextSymbol.initializer, "CallExpression") && isProvenReactCall(contextSymbol.initializer, "createContext", environment.scopes));
+};
+const isValueRenderedForEnvironment = (expression, environment, state, remainingDepth) => isValueRenderedInSameRender(expression, environment.scopes, { doesCustomElementRenderChildren: (openingElement) => doesCustomElementRenderChildren(openingElement, environment, state, remainingDepth - 1) });
+const doesFunctionComponentRenderChildren = (resolvedFunction, state, remainingDepth) => {
+	const { functionNode } = resolvedFunction;
+	if (remainingDepth <= 0 || state.activeRenderedChildrenComponents.has(functionNode) || !isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "FunctionDeclaration") || functionNode.async || functionNode.generator) return false;
+	const childrenReferences = collectFunctionChildrenReferences(functionNode, resolvedFunction.environment.scopes);
+	if (!childrenReferences) return false;
+	state.activeRenderedChildrenComponents.add(functionNode);
+	const isRendered = childrenReferences.every((childrenReference) => isValueRenderedForEnvironment(childrenReference, resolvedFunction.environment, state, remainingDepth));
+	state.activeRenderedChildrenComponents.delete(functionNode);
+	return isRendered;
+};
+const doesClassComponentRenderChildren = (resolvedClass, state, remainingDepth) => {
+	const { classNode, environment } = resolvedClass;
+	if (remainingDepth <= 0 || state.activeRenderedChildrenComponents.has(classNode) || !isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression")) return false;
+	const renderMethod = classNode.body.body.find((element) => isNodeOfType(element, "MethodDefinition") && !element.computed && isNodeOfType(element.key, "Identifier") && element.key.name === "render");
+	if (!renderMethod || !isNodeOfType(renderMethod, "MethodDefinition")) return false;
+	const childrenReads = [];
+	walkAst(classNode, (node) => {
+		if (isThisPropsChildren(node)) childrenReads.push(node);
+	});
+	if (childrenReads.length === 0) return false;
+	state.activeRenderedChildrenComponents.add(classNode);
+	const isRendered = childrenReads.every((childrenRead) => findEnclosingFunction$1(childrenRead) === renderMethod.value && isValueRenderedForEnvironment(childrenRead, environment, state, remainingDepth));
+	state.activeRenderedChildrenComponents.delete(classNode);
+	return isRendered;
+};
+const doesCustomElementRenderChildren = (openingElement, environment, state, remainingDepth) => {
+	if (remainingDepth <= 0 || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	if (isProvenReactContextProvider(openingElement, environment)) return true;
+	const resolvedFunction = resolveJsxFunctionValue(openingElement.name, environment, state);
+	if (resolvedFunction) return doesFunctionComponentRenderChildren(resolvedFunction, state, remainingDepth);
+	const resolvedClass = resolveJsxClassValue(openingElement.name, environment, state);
+	return Boolean(resolvedClass && doesClassComponentRenderChildren(resolvedClass, state, remainingDepth));
+};
+const analyzeJsxAttributeUse = (attribute, propertyPath, environment, state, remainingDepth) => {
+	const attributeName = getJsxAttributeName(attribute.name);
+	const openingElement = attribute.parent;
+	if (!attributeName || !openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	const jsxElement = openingElement.parent;
+	if (!jsxElement || !isNodeOfType(jsxElement, "JSXElement") || !isValueRenderedForEnvironment(jsxElement, environment, state, remainingDepth)) return false;
+	if (isProvenIntrinsicJsxElement(openingElement, environment.scopes)) return attributeName === "ref" && propertyPath.length === 0;
+	if (isNodeOfType(openingElement.name, "JSXIdentifier") && attributeName === "ref" && propertyPath.length === 0 && isProvenClassComponentIdentifier(openingElement.name, environment, state)) return true;
+	const resolvedFunction = resolveJsxFunctionValue(openingElement.name, environment, state);
+	if (!resolvedFunction) return false;
+	if (attributeName === "ref" && resolvedFunction.isForwardRef) return analyzeFunctionInput(resolvedFunction, 1, propertyPath, state, remainingDepth);
+	return analyzeFunctionInput(resolvedFunction, 0, [attributeName, ...propertyPath], state, remainingDepth);
+};
+const analyzeCallArgumentUse = (callExpression, argumentExpression, propertyPath, environment, state, remainingDepth) => {
+	const argumentIndex = callExpression.arguments.findIndex((argument) => argument === argumentExpression);
+	if (argumentIndex < 0) return false;
+	if (argumentIndex === 0 && isNodeOfType(callExpression.callee, "Identifier") && callExpression.callee.name === "Boolean" && environment.scopes.isGlobalReference(callExpression.callee)) return true;
+	if (argumentIndex === 0 && isProvenReactCall(callExpression, "useImperativeHandle", environment.scopes)) return propertyPath.length === 0;
+	if (argumentIndex === 1 && propertyPath.length === 1 && propertyPath[0] === "ref" && isIntrinsicReactElementFactoryCall(callExpression, environment) && isValueRenderedForEnvironment(callExpression, environment, state, remainingDepth)) return true;
+	const inlineCallee = findTransparentExpressionRoot(callExpression.callee);
+	if (isFunctionLike$1(inlineCallee)) {
+		if (functionContainsReactRenderOutput(inlineCallee, environment.scopes) && !isValueRenderedForEnvironment(callExpression, environment, state, remainingDepth)) return false;
+		return analyzeFunctionInput({
+			environment,
+			functionNode: inlineCallee,
+			isForwardRef: false
+		}, argumentIndex, propertyPath, state, remainingDepth);
+	}
+	if (!isNodeOfType(callExpression.callee, "Identifier")) return false;
+	const resolvedFunction = resolveFunctionValue(callExpression.callee, environment, state);
+	return Boolean(resolvedFunction && (!functionContainsReactRenderOutput(resolvedFunction.functionNode, resolvedFunction.environment.scopes) || isValueRenderedForEnvironment(callExpression, environment, state, remainingDepth)) && analyzeFunctionInput(resolvedFunction, argumentIndex, propertyPath, state, remainingDepth));
+};
+const isIntrinsicJsxSpreadRefUse = (expression, propertyPath, environment, state, remainingDepth) => {
+	let spreadAttribute;
+	if (propertyPath.length === 1 && propertyPath[0] === "ref") spreadAttribute = expression.parent;
+	else if (propertyPath.length === 0) {
+		const property = expression.parent;
+		if (!property || !isNodeOfType(property, "Property") || property.value !== expression || getStaticPropertyKeyName(property, { allowComputedString: true }) !== "ref") return false;
+		spreadAttribute = property.parent?.parent;
+	}
+	if (!spreadAttribute || !isNodeOfType(spreadAttribute, "JSXSpreadAttribute")) return false;
+	const openingElement = spreadAttribute.parent;
+	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	const jsxElement = openingElement.parent;
+	return Boolean(isProvenIntrinsicJsxElement(openingElement, environment.scopes) && jsxElement && isNodeOfType(jsxElement, "JSXElement") && isValueRenderedForEnvironment(jsxElement, environment, state, remainingDepth));
+};
+const analyzeValueUse = (expressionNode, propertyPath, environment, state, remainingDepth) => {
+	const expression = findTransparentExpressionRoot(expressionNode);
+	const parent = expression.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "ExpressionStatement")) return true;
+	if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void" && parent.argument === expression) return true;
+	if (propertyPath.length === 0 && isNodeOfType(parent, "BinaryExpression") && (parent.operator === "===" || parent.operator === "!==" || parent.operator === "==" || parent.operator === "!=")) {
+		const comparedExpression = parent.left === expression ? parent.right : parent.left;
+		return Boolean(isNodeOfType(expression, "Identifier") && isNodeOfType(comparedExpression, "Identifier") && environment.scopes.symbolFor(expression)?.id === environment.scopes.symbolFor(comparedExpression)?.id);
+	}
+	if (isIntrinsicJsxSpreadRefUse(expression, propertyPath, environment, state, remainingDepth)) return true;
+	if (isIntrinsicReactElementRefProperty(expression, propertyPath, environment, state, remainingDepth)) return true;
+	if (propertyPath.length > 0 && (isNodeOfType(parent, "LogicalExpression") && parent.left === expression || isNodeOfType(parent, "ConditionalExpression") && parent.test === expression || isNodeOfType(parent, "IfStatement") && parent.test === expression || isNodeOfType(parent, "UnaryExpression") && parent.operator === "!" && parent.argument === expression)) return true;
+	if (isNodeOfType(parent, "JSXExpressionContainer") && parent.expression === expression) {
+		const attribute = parent.parent;
+		return Boolean(attribute && isNodeOfType(attribute, "JSXAttribute") && analyzeJsxAttributeUse(attribute, propertyPath, environment, state, remainingDepth));
+	}
+	if (isNodeOfType(parent, "CallExpression")) return analyzeCallArgumentUse(parent, expression, propertyPath, environment, state, remainingDepth);
+	if (isNodeOfType(parent, "VariableDeclarator") && parent.init === expression && !isNodeOfType(parent.id, "Identifier")) return analyzePatternPath(parent.id, propertyPath, environment, state, remainingDepth);
+	const propagatedValue = findOwnedSymbolValue(expression, propertyPath, environment);
+	return Boolean(propagatedValue && analyzeSymbolValuePath(propagatedValue, state, remainingDepth - 1));
+};
+const getFunctionBindingIdentifier = (functionNode) => {
+	const parent = functionNode.parent;
+	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.init === functionNode && isNodeOfType(parent.id, "Identifier")) return parent.id;
+	if ((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id) return functionNode.id;
+	return null;
+};
+const isSynchronouslyInvokedLocalFunction = (functionNode, callerFunction, scopes) => {
+	if (!functionNode || !callerFunction || !isFunctionLike$1(functionNode) || functionNode.async || functionNode.generator) return false;
+	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	if (!bindingIdentifier) return false;
+	if (((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id === bindingIdentifier ? findEnclosingFunction$1(functionNode) : findEnclosingFunction$1(bindingIdentifier)) !== callerFunction) return false;
+	const symbol = isNodeOfType(functionNode, "FunctionDeclaration") ? scopes.ownScopeFor(callerFunction)?.symbolsByName.get(bindingIdentifier.name) : scopes.symbolFor(bindingIdentifier);
+	return Boolean(symbol && symbol.references.length > 0 && symbol.references.every((reference) => {
+		const referenceExpression = findTransparentExpressionRoot(reference.identifier);
+		const callExpression = referenceExpression.parent;
+		return Boolean(callExpression && isNodeOfType(callExpression, "CallExpression") && callExpression.callee === referenceExpression && findEnclosingFunction$1(callExpression) === callerFunction && isValueRenderedInSameRender(callExpression, scopes));
+	}));
+};
+const analyzeSymbolValuePath = (valuePath, state, remainingDepth) => {
+	if (remainingDepth <= 0) return false;
+	const activePathKey = `${valuePath.environment.filename}:${valuePath.symbol.id}:${valuePath.propertyPath.join(".")}`;
+	if (state.activePaths.has(activePathKey)) return false;
+	state.activePaths.add(activePathKey);
+	const bindingFunction = findEnclosingFunction$1(valuePath.symbol.bindingIdentifier);
+	const result = valuePath.symbol.references.every((reference) => {
+		if (reference.identifier === valuePath.originWriteReference) return true;
+		const referenceParent = reference.identifier.parent;
+		if (referenceParent && isNodeOfType(referenceParent, "Property") && !referenceParent.computed && referenceParent.key === reference.identifier && referenceParent.value !== reference.identifier) return true;
+		const memberAccess = collectMemberAccess(reference.identifier);
+		if (!memberAccess) return false;
+		if (!pathsOverlap(memberAccess.propertyPath, valuePath.propertyPath)) return true;
+		const referenceFunction = findEnclosingFunction$1(reference.identifier);
+		if (referenceFunction !== bindingFunction && !isSynchronouslyInvokedLocalFunction(referenceFunction, bindingFunction, valuePath.environment.scopes)) {
+			if (isSafeCreateRefCallbackCurrentWrite(reference.identifier, memberAccess.propertyPath, valuePath.propertyPath, valuePath.environment.scopes)) return true;
+			return false;
+		}
+		if (reference.flag !== "read") return false;
+		if (pathStartsWith(memberAccess.propertyPath, valuePath.propertyPath)) {
+			if (memberAccess.propertyPath.length > valuePath.propertyPath.length) {
+				const parent = memberAccess.expression.parent;
+				return Boolean(memberAccess.propertyPath.length === valuePath.propertyPath.length + 1 && memberAccess.propertyPath[valuePath.propertyPath.length] === "current" && parent && isNodeOfType(parent, "UnaryExpression") && parent.operator === "void" && parent.argument === memberAccess.expression);
+			}
+			return analyzeValueUse(memberAccess.expression, [], valuePath.environment, state, remainingDepth);
+		}
+		return analyzeValueUse(memberAccess.expression, valuePath.propertyPath.slice(memberAccess.propertyPath.length), valuePath.environment, state, remainingDepth);
+	});
+	state.activePaths.delete(activePathKey);
+	return result;
+};
+const isCreateRefResultWriteOnly = (createRefCall, filename, scopes) => {
+	if (!filename) return false;
+	const program = findProgramRoot(createRefCall);
+	if (!program) return false;
+	const environment = {
+		filename,
+		program,
+		scopes
+	};
+	const state = {
+		activePaths: /* @__PURE__ */ new Set(),
+		activeRenderedChildrenComponents: /* @__PURE__ */ new WeakSet(),
+		environmentsByProgram: new WeakMap([[program, environment]])
+	};
+	const ownedValue = findOwnedSymbolValue(createRefCall, [], environment);
+	return ownedValue ? analyzeSymbolValuePath(ownedValue, state, 12) : analyzeValueUse(createRefCall, [], environment, state, 12);
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/no-create-ref-in-function-component.ts
-const MESSAGE$31 = "`createRef()` in a function component allocates a brand-new ref on every render, so it never holds a value between renders. Use the `useRef()` hook instead.";
-const isUseMemoCallbackArgument = (functionNode) => {
+const MESSAGE$31 = "`createRef()` may escape or be observed beyond the render that created it, so a later render can replace the ref object and detach the observed one. Hoist a `useRef()` call to the component's unconditional top level instead.";
+const isUseMemoCallbackArgument = (functionNode, scopes) => {
 	const parent = functionNode.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
 	if (parent.arguments?.[0] !== functionNode) return false;
-	return isReactFunctionCall(parent, "useMemo");
+	return isReactApiCall(parent, "useMemo", scopes, { resolveNamedAliases: true });
 };
-const findEnclosingRenderFunction = (node) => {
+const findEnclosingRenderFunction = (node, scopes) => {
 	let enclosingFunction = findEnclosingFunction$1(node);
-	while (enclosingFunction && isUseMemoCallbackArgument(enclosingFunction)) enclosingFunction = findEnclosingFunction$1(enclosingFunction);
+	while (enclosingFunction && isUseMemoCallbackArgument(enclosingFunction, scopes)) enclosingFunction = findEnclosingFunction$1(enclosingFunction);
 	return enclosingFunction;
 };
 const noCreateRefInFunctionComponent = defineRule({
@@ -32007,16 +32979,17 @@ const noCreateRefInFunctionComponent = defineRule({
 	severity: "warn",
 	recommendation: "Replace `createRef()` with the `useRef()` hook inside function components and hooks. `createRef` is only for class components.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isReactFunctionCall(node, "createRef")) return;
-		if (isNodeOfType(node.callee, "Identifier")) {
-			const symbol = context.scopes.symbolFor(node.callee);
-			if (symbol && symbol.kind !== "import") return;
-		}
-		const enclosingFunction = findEnclosingRenderFunction(node);
+		if (!isReactApiCall(node, "createRef", context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveNamedAliases: true
+		})) return;
+		const enclosingFunction = findEnclosingRenderFunction(node, context.scopes);
 		if (!enclosingFunction) return;
 		const displayName = componentOrHookDisplayNameForFunction(enclosingFunction);
 		if (!displayName) return;
 		if (!(isReactHookName(displayName) || functionContainsReactRenderOutput(enclosingFunction, context.scopes, context.cfg))) return;
+		if (isCreateRefResultWriteOnly(node, context.filename, context.scopes)) return;
 		context.report({
 			node,
 			message: MESSAGE$31
@@ -32541,6 +33514,28 @@ const noDarkModeGlow = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/architecture/no-default-props.ts
+const hasReachingWriteOnAliasPath = (receiver, context) => {
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let reference = receiver;
+	let symbol = context.scopes.symbolFor(reference);
+	while (symbol) {
+		if (visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, reference, context.scopes)) return true;
+		visitedSymbolIds.add(symbol.id);
+		if (symbol.kind !== "const" || !symbol.initializer) return false;
+		const initializer = stripParenExpression(symbol.initializer);
+		if (!isNodeOfType(initializer, "Identifier")) return false;
+		reference = initializer;
+		symbol = context.scopes.symbolFor(reference);
+	}
+	return false;
+};
+const isStableClassReceiver = (receiver, context) => {
+	const symbol = resolveConstIdentifierAlias(receiver, context.scopes);
+	if (!symbol || hasReachingWriteOnAliasPath(receiver, context)) return false;
+	if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return true;
+	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
+	return Boolean(symbol.kind === "const" && isNodeOfType(initializer, "ClassExpression"));
+};
 const noDefaultProps = defineRule({
 	id: "no-default-props",
 	title: "defaultProps removed in React 19",
@@ -32556,6 +33551,7 @@ const noDefaultProps = defineRule({
 		if (!isNodeOfType(left.property, "Identifier") || left.property.name !== "defaultProps") return;
 		if (!isNodeOfType(left.object, "Identifier")) return;
 		if (!isUppercaseName(left.object.name)) return;
+		if (isStableClassReceiver(left.object, context)) return;
 		context.report({
 			node: left,
 			message: `${left.object.name}.defaultProps stops applying in React 19, so your users see missing defaults. Set them in the destructured props parameter instead, like \`function ${left.object.name}({ size = "md" })\`.`
@@ -38195,33 +39191,6 @@ const noLegacyClassLifecycles = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-proven-react-class-component.ts
-const REACT_COMPONENT_CLASS_NAMES = new Set(["Component", "PureComponent"]);
-const isReactComponentClassValue = (node, scopes, visitedClassNodes, visitedSymbolIds) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "MemberExpression")) {
-		const propertyName = getStaticPropertyName(expression);
-		const receiver = stripParenExpression(expression.object);
-		return Boolean(propertyName && REACT_COMPONENT_CLASS_NAMES.has(propertyName) && isNodeOfType(receiver, "Identifier") && !hasStaticPropertyWriteBefore(receiver, propertyName, expression, scopes) && isReactNamespaceImport(receiver, scopes));
-	}
-	if (isNodeOfType(expression, "ClassExpression")) return isProvenReactClassComponent(expression, scopes, visitedClassNodes, visitedSymbolIds);
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, expression, scopes)) return false;
-	visitedSymbolIds.add(symbol.id);
-	if (isImportedFromReact(symbol)) {
-		const importedName = getImportedName(symbol.declarationNode);
-		return Boolean(importedName && REACT_COMPONENT_CLASS_NAMES.has(importedName));
-	}
-	if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes, visitedClassNodes, visitedSymbolIds);
-	return Boolean(symbol.kind === "const" && symbol.initializer && isReactComponentClassValue(symbol.initializer, scopes, visitedClassNodes, visitedSymbolIds));
-};
-const isProvenReactClassComponent = (classNode, scopes, visitedClassNodes = /* @__PURE__ */ new Set(), visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression") || visitedClassNodes.has(classNode) || !classNode.superClass) return false;
-	visitedClassNodes.add(classNode);
-	return isReactComponentClassValue(classNode.superClass, scopes, visitedClassNodes, visitedSymbolIds);
-};
-//#endregion
 //#region src/plugin/utils/function-contains-proven-react-hook-call.ts
 const functionContainsProvenReactHookCall = (functionNode, scopes) => {
 	if (!isFunctionLike$1(functionNode)) return false;
@@ -38685,7 +39654,7 @@ const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, sc
 		}
 		if (isFunctionInvokedBeforeUsage(methodCallFunction, usageNode, usageBoundary, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes))) return true;
 	}
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) return false;
 	const symbol = scopes.symbolFor(bindingIdentifier);
 	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
@@ -41228,6 +42197,133 @@ const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactU
 	}
 	return callbackPropNames.size > 0 ? { callbackPropNames } : null;
 };
+const isParentPropsContextMerge = (analysis, expression) => {
+	let currentExpression = stripParenExpression(expression);
+	const visitedVariables = /* @__PURE__ */ new Set();
+	while (isNodeOfType(currentExpression, "Identifier")) {
+		const currentReference = getRef(analysis, currentExpression);
+		const currentVariable = currentReference?.resolved;
+		if (!currentReference || !currentVariable || visitedVariables.has(currentVariable) || hasMutableBindingWrite(currentReference)) return false;
+		visitedVariables.add(currentVariable);
+		const definitions = currentVariable.defs.filter((definition) => isNodeOfType(definition.node, "VariableDeclarator"));
+		if (definitions.length !== 1) return false;
+		const declarator = definitions[0]?.node;
+		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || getDeclarationKind(declarator) !== "const" || !declarator.init) return false;
+		currentExpression = stripParenExpression(declarator.init);
+	}
+	if (!isNodeOfType(currentExpression, "ObjectExpression")) return false;
+	const [contextSpread, propsSpread] = currentExpression.properties ?? [];
+	if (currentExpression.properties?.length !== 2 || !contextSpread || !propsSpread || !isNodeOfType(contextSpread, "SpreadElement") || !isNodeOfType(propsSpread, "SpreadElement")) return false;
+	const propsExpression = stripParenExpression(propsSpread.argument);
+	if (!isNodeOfType(propsExpression, "Identifier")) return false;
+	const propsReference = getRef(analysis, propsExpression);
+	if (!propsReference?.resolved || !isWholePropsObjectReference(analysis, propsReference) || hasMutableBindingWrite(propsReference) || propsReference.resolved.references.some((candidateReference) => candidateReference !== propsReference)) return false;
+	const contextExpression = stripParenExpression(contextSpread.argument);
+	if (!isNodeOfType(contextExpression, "Identifier")) return false;
+	const contextReference = getRef(analysis, contextExpression);
+	if (!contextReference?.resolved || hasMutableBindingWrite(contextReference) || contextReference.resolved.references.some((candidateReference) => !candidateReference.init && candidateReference !== contextReference)) return false;
+	const contextInitializer = contextReference.resolved?.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
+	if (!contextInitializer || !isNodeOfType(contextInitializer, "VariableDeclarator") || getDeclarationKind(contextInitializer) !== "const" || !contextInitializer.init || !isNodeOfType(contextInitializer.init, "CallExpression")) return false;
+	const contextHook = stripParenExpression(contextInitializer.init.callee);
+	if (!isNodeOfType(contextHook, "Identifier") || !/^use[A-Z].*Context$/.test(contextHook.name)) return false;
+	const contextHookReference = getRef(analysis, contextHook);
+	return Boolean(contextHookReference?.resolved?.defs.some((definition) => definition.type === "ImportBinding"));
+};
+const getImmutableParentCallbackPropName = (analysis, expression) => {
+	let currentExpression = stripParenExpression(expression);
+	const visitedVariables = /* @__PURE__ */ new Set();
+	while (isNodeOfType(currentExpression, "Identifier")) {
+		const currentReference = getRef(analysis, currentExpression);
+		const currentVariable = currentReference?.resolved;
+		if (!currentReference || !currentVariable || visitedVariables.has(currentVariable) || hasMutableBindingWrite(currentReference)) return null;
+		visitedVariables.add(currentVariable);
+		const definition = currentVariable.defs.length === 1 ? currentVariable.defs[0] : null;
+		const bindingIdentifier = definition?.name;
+		if (bindingIdentifier && isNodeOfType(bindingIdentifier.parent, "AssignmentPattern")) return null;
+		const definitionNode = definition?.node;
+		if (!definitionNode || !isNodeOfType(definitionNode, "VariableDeclarator")) return getParentCallbackPropName(analysis, currentExpression);
+		if (getDeclarationKind(definitionNode) !== "const" || !definitionNode.init) return null;
+		if (isNodeOfType(definitionNode.id, "ObjectPattern")) return getParentCallbackPropName(analysis, currentExpression) ?? (isParentPropsContextMerge(analysis, definitionNode.init) ? getDestructuredBindingPropertyName(bindingIdentifier ?? currentExpression) : null);
+		if (!isNodeOfType(definitionNode.id, "Identifier")) return null;
+		currentExpression = stripParenExpression(definitionNode.init);
+		if (!isNodeOfType(currentExpression, "Identifier") && !isNodeOfType(currentExpression, "MemberExpression")) return null;
+	}
+	return null;
+};
+const objectExpressionPreservesCallbackProperty = (analysis, expression, propertyName) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "ObjectExpression")) return false;
+	let callbackSourceName = null;
+	for (const property of unwrappedExpression.properties ?? []) {
+		if (!isNodeOfType(property, "Property")) return false;
+		const candidatePropertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (candidatePropertyName === null) return false;
+		if (candidatePropertyName !== propertyName) continue;
+		if (callbackSourceName || property.kind !== "init") return false;
+		if (!isNodeOfType(stripParenExpression(property.value), "Identifier")) return false;
+		callbackSourceName = getImmutableParentCallbackPropName(analysis, property.value);
+		if (!callbackSourceName) return false;
+	}
+	return callbackSourceName === propertyName;
+};
+const refCurrentObjectPreservesCallbackProperty = (analysis, expression, propertyName, isReactUseRefCall) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "MemberExpression") || getStaticMemberPropertyName(unwrappedExpression) !== "current") return false;
+	const bindingProvenance = getRefBindingProvenance(analysis, stripParenExpression(unwrappedExpression.object), isReactUseRefCall);
+	if (!bindingProvenance) return false;
+	const initializer = bindingProvenance.refCall.arguments?.[0];
+	if (!initializer || !objectExpressionPreservesCallbackProperty(analysis, initializer, propertyName)) return false;
+	for (const variable of bindingProvenance.variables) for (const candidateReference of variable.references) {
+		if (candidateReference.init) continue;
+		const identifier = candidateReference.identifier;
+		if (getRefAliasDeclarator(identifier)) continue;
+		const currentMember = getRefMember(identifier);
+		if (!currentMember || getStaticMemberPropertyName(currentMember) !== "current") return false;
+		const currentAssignment = getRefMemberAssignment(identifier);
+		if (currentAssignment) {
+			if (currentAssignment.operator !== "=" || !objectExpressionPreservesCallbackProperty(analysis, currentAssignment.right, propertyName)) return false;
+			continue;
+		}
+		const currentRoot = findTransparentExpressionRoot(currentMember);
+		const currentParent = currentRoot.parent;
+		if (currentParent && isNodeOfType(currentParent, "VariableDeclarator") && currentParent.init === currentRoot && isNodeOfType(currentParent.id, "ObjectPattern")) continue;
+		if (currentParent && isNodeOfType(currentParent, "MemberExpression") && currentParent.object === currentRoot && getStaticMemberPropertyName(currentParent) === propertyName) {
+			const propertyParent = findTransparentExpressionRoot(currentParent).parent;
+			if (!propertyParent || !isNodeOfType(propertyParent, "VariableDeclarator")) return false;
+			continue;
+		}
+		return false;
+	}
+	return true;
+};
+const getCommandCallbackPropName = (analysis, expression, isReactUseRefCall) => {
+	const directCallbackName = getImmutableParentCallbackPropName(analysis, expression);
+	if (directCallbackName && COMMAND_PROP_NAME_PATTERN.test(directCallbackName)) return directCallbackName;
+	let currentExpression = stripParenExpression(expression);
+	const visitedVariables = /* @__PURE__ */ new Set();
+	while (isNodeOfType(currentExpression, "Identifier")) {
+		const callbackReference = getRef(analysis, currentExpression);
+		const callbackVariable = callbackReference?.resolved;
+		if (!callbackReference || !callbackVariable || visitedVariables.has(callbackVariable) || hasMutableBindingWrite(callbackReference)) return null;
+		visitedVariables.add(callbackVariable);
+		const definition = callbackVariable.defs.length === 1 ? callbackVariable.defs[0] : null;
+		const declarator = definition?.node;
+		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || getDeclarationKind(declarator) !== "const" || !declarator.init) return null;
+		const bindingIdentifier = definition?.name;
+		if (bindingIdentifier && isNodeOfType(bindingIdentifier.parent, "AssignmentPattern")) return null;
+		if (isNodeOfType(declarator.id, "ObjectPattern")) {
+			const propertyName = bindingIdentifier ? getDestructuredBindingPropertyName(bindingIdentifier) : null;
+			if (!propertyName || !COMMAND_PROP_NAME_PATTERN.test(propertyName)) return null;
+			return refCurrentObjectPreservesCallbackProperty(analysis, declarator.init, propertyName, isReactUseRefCall) ? propertyName : null;
+		}
+		if (!isNodeOfType(declarator.id, "Identifier")) return null;
+		currentExpression = stripParenExpression(declarator.init);
+	}
+	if (!isNodeOfType(currentExpression, "MemberExpression")) return null;
+	const propertyName = getStaticMemberPropertyName(currentExpression);
+	if (!propertyName || !COMMAND_PROP_NAME_PATTERN.test(propertyName)) return null;
+	return refCurrentObjectPreservesCallbackProperty(analysis, currentExpression.object, propertyName, isReactUseRefCall) ? propertyName : null;
+};
 const isWrapperHookCallbackRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
@@ -41329,6 +42425,8 @@ const noPassDataToParent = defineRule({
 				if (callbackRefProvenance) {
 					if ([...callbackRefProvenance.callbackPropNames].some((callbackPropName) => COMMAND_PROP_NAME_PATTERN.test(callbackPropName))) continue;
 				} else if (calleeNode === identifier) {
+					const callbackPropName = getCommandCallbackPropName(analysis, identifier, isReactUseRefCall);
+					if (callbackPropName && COMMAND_PROP_NAME_PATTERN.test(callbackPropName)) continue;
 					if (!isDirectParentCallbackRef(analysis, ref)) continue;
 					if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
 				} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
@@ -42520,7 +43618,16 @@ const getElementImplicitRoles = (tag) => IMPLICIT_ROLES_BY_TAG.get(tag) ?? EMPTY
 const getTagsForRole = (role) => TAGS_BY_ROLE.get(role) ?? EMPTY_ROLE_LIST;
 //#endregion
 //#region src/plugin/utils/get-implicit-role.ts
-const getImplicitRole = (node, elementType) => {
+const getInputTypeImplicitRole = (inputTypeValue) => {
+	const inputType = inputTypeValue.toLowerCase();
+	if (inputType === "button" || inputType === "image" || inputType === "reset" || inputType === "submit") return "button";
+	if (inputType === "checkbox") return "checkbox";
+	if (inputType === "number") return "spinbutton";
+	if (inputType === "radio") return "radio";
+	if (inputType === "range") return "slider";
+	return "textbox";
+};
+const getImplicitRole = (node, elementType, scopes) => {
 	const propStringValue = (propName) => {
 		const attribute = hasJsxPropIgnoreCase(node.attributes, propName);
 		return attribute ? getJsxPropStringValue(attribute) : null;
@@ -42578,13 +43685,18 @@ const getImplicitRole = (node, elementType) => {
 			break;
 		}
 		case "input": {
-			const inputType = propStringValue("type");
-			if (inputType === null) implicit = "textbox";
-			else if (inputType === "button" || inputType === "image" || inputType === "reset" || inputType === "submit") implicit = "button";
-			else if (inputType === "checkbox") implicit = "checkbox";
-			else if (inputType === "radio") implicit = "radio";
-			else if (inputType === "range") implicit = "slider";
-			else implicit = "textbox";
+			const inputTypeAttribute = hasJsxPropIgnoreCase(node.attributes, "type");
+			if (!inputTypeAttribute) {
+				implicit = "textbox";
+				break;
+			}
+			const inputTypeValues = getJsxPropStaticStringValues(inputTypeAttribute, scopes);
+			if (inputTypeValues === null) {
+				implicit = "";
+				break;
+			}
+			const implicitRoles = new Set(inputTypeValues.map(getInputTypeImplicitRole));
+			implicit = implicitRoles.size === 1 ? implicitRoles.values().next().value ?? "" : "";
 			break;
 		}
 		case "li":
@@ -42688,7 +43800,7 @@ const noRedundantRoles = defineRule({
 			if (tag === "td" || tag === "th") {
 				if (findSameFileTableContext(node, context.settings) !== "table") return;
 				implicitRoles = [getTableCellPrimaryRole(node, tag)];
-			} else if (ATTRIBUTE_DEPENDENT_IMPLICIT_ROLE_TAGS.has(tag)) implicitRoles = [getImplicitRole(node, tag)].filter((resolvedRole) => resolvedRole !== null);
+			} else if (ATTRIBUTE_DEPENDENT_IMPLICIT_ROLE_TAGS.has(tag)) implicitRoles = [getImplicitRole(node, tag, context.scopes)].filter((resolvedRole) => resolvedRole !== null);
 			else implicitRoles = getElementImplicitRoles(tag);
 			const allowedHere = [...DEFAULT_NON_REDUNDANT_ROLES[tag] ?? [], ...settings.exceptions[tag] ?? []];
 			if (implicitRoles.includes(role) && !allowedHere.includes(role)) context.report({
@@ -42867,9 +43979,9 @@ const isInsideComponentContext = (node) => {
 	}
 	return false;
 };
-const functionBodyOf = (node) => {
-	if (isFunctionLike$1(node)) return node.body ?? null;
-	if (isNodeOfType(node, "VariableDeclarator") && node.init && isFunctionLike$1(node.init)) return node.init.body ?? null;
+const getFunctionFromDeclaration = (node) => {
+	if (isFunctionLike$1(node)) return node;
+	if (isNodeOfType(node, "VariableDeclarator") && node.init && isFunctionLike$1(node.init)) return node.init;
 	return null;
 };
 const isHookCallee = (callee) => {
@@ -42877,23 +43989,43 @@ const isHookCallee = (callee) => {
 	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier") && isUppercaseName(callee.object.name) && isNodeOfType(callee.property, "Identifier")) return isReactHookName(callee.property.name);
 	return false;
 };
-const containsHookCall = (body) => {
-	let found = false;
-	walkAst(body, (child) => {
-		if (found) return false;
-		if (child !== body && isFunctionLike$1(child) && isComponentFunction$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isHookCallee(child.callee)) found = true;
+const containsReachableHookCall = (functionNode, rootFunction, context, visitedFunctions) => {
+	if (!isFunctionLike$1(functionNode) || visitedFunctions.has(functionNode)) return false;
+	visitedFunctions.add(functionNode);
+	let didFindReachableHook = false;
+	walkAst(functionNode.body, (child) => {
+		if (didFindReachableHook) return false;
+		if (isFunctionLike$1(child) && !executesDuringRender(child, context.scopes)) return false;
+		if (!isNodeOfType(child, "CallExpression") && !isNodeOfType(child, "NewExpression")) return;
+		if (isNodeOfType(child, "CallExpression")) {
+			if (isHookCallee(child.callee)) {
+				didFindReachableHook = true;
+				return false;
+			}
+			const calledFunction = resolveExactLocalFunction(child.callee, context.scopes);
+			if (calledFunction && isAstDescendant(calledFunction, rootFunction) && containsReachableHookCall(calledFunction, rootFunction, context, visitedFunctions)) {
+				didFindReachableHook = true;
+				return false;
+			}
+		}
+		for (const callArgument of child.arguments ?? []) {
+			if (!executesDuringRender(callArgument, context.scopes)) continue;
+			const callbackFunction = resolveExactLocalFunction(callArgument, context.scopes);
+			if (callbackFunction && isAstDescendant(callbackFunction, rootFunction) && containsReachableHookCall(callbackFunction, rootFunction, context, visitedFunctions)) {
+				didFindReachableHook = true;
+				return false;
+			}
+		}
 	});
-	return found;
+	return didFindReachableHook;
 };
-const isHookCallingRenderHelper = (symbol) => {
+const isHookCallingRenderHelper = (symbol, context) => {
 	if (!symbol) return false;
 	const declaration = symbol.declarationNode;
 	if (!isNodeOfType(declaration, "FunctionDeclaration") && !isNodeOfType(declaration, "VariableDeclarator")) return false;
-	const body = functionBodyOf(declaration);
-	if (!body) return false;
-	return containsHookCall(body);
+	const functionNode = getFunctionFromDeclaration(declaration);
+	if (!functionNode) return false;
+	return containsReachableHookCall(functionNode, functionNode, context, /* @__PURE__ */ new Set());
 };
 const noRenderInRender = defineRule({
 	id: "no-render-in-render",
@@ -42908,7 +44040,7 @@ const noRenderInRender = defineRule({
 		const calleeName = expression.callee.name;
 		if (!RENDER_FUNCTION_PATTERN.test(calleeName)) return;
 		if (!isInsideComponentContext(node)) return;
-		if (!isHookCallingRenderHelper(context.scopes.symbolFor(expression.callee))) return;
+		if (!isHookCallingRenderHelper(context.scopes.symbolFor(expression.callee), context)) return;
 		context.report({
 			node: expression,
 			message: `"${calleeName}()" hides a component behind an inline call, so pull it into its own component and render it as JSX so React can track it.`
@@ -42992,6 +44124,31 @@ const noRenderReturnValue = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-reset-all-state-on-prop-change.ts
+const SYNCHRONOUS_ARRAY_CALLBACK_METHOD_NAMES = new Set([
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"flatMap",
+	"forEach",
+	"map",
+	"reduce",
+	"reduceRight",
+	"some"
+]);
+const createConstantFormula = (constantValue) => ({
+	kind: "constant",
+	constantValue
+});
+const createNotFormula = (formula) => ({
+	kind: "not",
+	left: formula
+});
+const createBinaryFormula = (kind, left, right) => ({
+	kind,
+	left,
+	right
+});
 const isUndefinedNode = (node) => {
 	if (node === null || node === void 0) return true;
 	return isNodeOfType(node, "Identifier") && node.name === "undefined";
@@ -43053,6 +44210,241 @@ const getLivePropExpressionIdentity = (analysis, context, node, visitedSymbolIds
 	}
 	return null;
 };
+const getLivePropAtomKey = (identity) => `prop:${identity.propSymbolId}:${JSON.stringify(identity.memberPath)}:${identity.booleanNormalization}`;
+const getBooleanFormula$1 = (analysis, context, node, protectedSymbolIds, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "Literal")) return createConstantFormula(Boolean(expression.value));
+	if (isNodeOfType(expression, "Identifier")) {
+		if (expression.name === "undefined" && context.scopes.isGlobalReference(expression)) return createConstantFormula(false);
+		const symbol = context.scopes.symbolFor(expression);
+		if (!symbol) return null;
+		if (!protectedSymbolIds.has(symbol.id) && symbol.kind === "const" && !visitedSymbolIds.has(symbol.id) && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && symbol.declarationNode.id === symbol.bindingIdentifier) {
+			const initializer = getDirectConstInitializer(symbol);
+			if (initializer) {
+				visitedSymbolIds.add(symbol.id);
+				const initializerFormula = getBooleanFormula$1(analysis, context, initializer, protectedSymbolIds, visitedSymbolIds);
+				if (initializerFormula) return initializerFormula;
+			}
+		}
+		return {
+			kind: "atom",
+			atomKey: `symbol:${symbol.id}`
+		};
+	}
+	if (isNodeOfType(expression, "MemberExpression")) {
+		const identity = getLivePropExpressionIdentity(analysis, context, expression);
+		return identity ? {
+			kind: "atom",
+			atomKey: getLivePropAtomKey(identity)
+		} : null;
+	}
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") {
+		const argumentFormula = getBooleanFormula$1(analysis, context, expression.argument, protectedSymbolIds, visitedSymbolIds);
+		return argumentFormula ? createNotFormula(argumentFormula) : null;
+	}
+	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee) && expression.arguments.length === 1 && !isNodeOfType(expression.arguments[0], "SpreadElement")) return getBooleanFormula$1(analysis, context, expression.arguments[0], protectedSymbolIds, visitedSymbolIds);
+	if (isNodeOfType(expression, "LogicalExpression") && (expression.operator === "&&" || expression.operator === "||")) {
+		const leftFormula = getBooleanFormula$1(analysis, context, expression.left, protectedSymbolIds, new Set(visitedSymbolIds));
+		const rightFormula = getBooleanFormula$1(analysis, context, expression.right, protectedSymbolIds, new Set(visitedSymbolIds));
+		if (!leftFormula || !rightFormula) return null;
+		return createBinaryFormula(expression.operator === "&&" ? "and" : "or", leftFormula, rightFormula);
+	}
+	if (isNodeOfType(expression, "ConditionalExpression")) {
+		const testFormula = getBooleanFormula$1(analysis, context, expression.test, protectedSymbolIds, new Set(visitedSymbolIds));
+		const consequentFormula = getBooleanFormula$1(analysis, context, expression.consequent, protectedSymbolIds, new Set(visitedSymbolIds));
+		const alternateFormula = getBooleanFormula$1(analysis, context, expression.alternate, protectedSymbolIds, new Set(visitedSymbolIds));
+		if (!testFormula || !consequentFormula || !alternateFormula) return null;
+		return createBinaryFormula("or", createBinaryFormula("and", testFormula, consequentFormula), createBinaryFormula("and", createNotFormula(testFormula), alternateFormula));
+	}
+	if (isNodeOfType(expression, "BinaryExpression") && (expression.operator === "===" || expression.operator === "==" || expression.operator === "!==" || expression.operator === "!=")) {
+		const leftIsBoolean = isNodeOfType(expression.left, "Literal") && typeof expression.left.value === "boolean";
+		if (leftIsBoolean === (isNodeOfType(expression.right, "Literal") && typeof expression.right.value === "boolean")) return null;
+		const booleanLiteral = leftIsBoolean ? expression.left : expression.right;
+		const comparedFormula = getBooleanFormula$1(analysis, context, leftIsBoolean ? expression.right : expression.left, protectedSymbolIds, visitedSymbolIds);
+		if (!comparedFormula || !isNodeOfType(booleanLiteral, "Literal")) return null;
+		return (expression.operator === "===" || expression.operator === "==" ? booleanLiteral.value : !booleanLiteral.value) ? comparedFormula : createNotFormula(comparedFormula);
+	}
+	return null;
+};
+const getRequiredTruthyConditions = (analysis, context, node, protectedSymbolIds) => {
+	const formula = getBooleanFormula$1(analysis, context, node, protectedSymbolIds);
+	if (formula) return [formula];
+	const expression = stripParenExpression(node);
+	if (!isNodeOfType(expression, "LogicalExpression") || expression.operator !== "&&") return [];
+	return [...getRequiredTruthyConditions(analysis, context, expression.left, protectedSymbolIds), ...getRequiredTruthyConditions(analysis, context, expression.right, protectedSymbolIds)];
+};
+const evaluateBooleanFormula$1 = (formula, assignments) => {
+	if (formula.kind === "constant") return formula.constantValue ?? null;
+	if (formula.kind === "atom") return formula.atomKey === void 0 ? null : assignments.get(formula.atomKey) ?? null;
+	if (formula.kind === "not") {
+		if (!formula.left) return null;
+		const value = evaluateBooleanFormula$1(formula.left, assignments);
+		return value === null ? null : !value;
+	}
+	if (!formula.left || !formula.right) return null;
+	const leftValue = evaluateBooleanFormula$1(formula.left, assignments);
+	const rightValue = evaluateBooleanFormula$1(formula.right, assignments);
+	if (formula.kind === "and") {
+		if (leftValue === false || rightValue === false) return false;
+		return leftValue === true && rightValue === true ? true : null;
+	}
+	if (leftValue === true || rightValue === true) return true;
+	return leftValue === false && rightValue === false ? false : null;
+};
+const assignBooleanFact = (facts, atomKey, value) => {
+	const existingValue = facts.assignments.get(atomKey);
+	if (existingValue === void 0) {
+		facts.assignments.set(atomKey, value);
+		facts.didChange = true;
+	} else if (existingValue !== value) facts.didConflict = true;
+};
+const addRequiredBooleanFacts = (formula, expectedValue, facts) => {
+	const existingValue = evaluateBooleanFormula$1(formula, facts.assignments);
+	if (existingValue !== null) {
+		if (existingValue !== expectedValue) facts.didConflict = true;
+		return;
+	}
+	if (formula.kind === "atom" && formula.atomKey !== void 0) {
+		assignBooleanFact(facts, formula.atomKey, expectedValue);
+		return;
+	}
+	if (formula.kind === "not" && formula.left) {
+		addRequiredBooleanFacts(formula.left, !expectedValue, facts);
+		return;
+	}
+	if (!formula.left || !formula.right) return;
+	if (formula.kind === "and") {
+		if (expectedValue) {
+			addRequiredBooleanFacts(formula.left, true, facts);
+			addRequiredBooleanFacts(formula.right, true, facts);
+			return;
+		}
+		const leftValue = evaluateBooleanFormula$1(formula.left, facts.assignments);
+		const rightValue = evaluateBooleanFormula$1(formula.right, facts.assignments);
+		if (leftValue === true) addRequiredBooleanFacts(formula.right, false, facts);
+		if (rightValue === true) addRequiredBooleanFacts(formula.left, false, facts);
+		return;
+	}
+	if (!expectedValue) {
+		addRequiredBooleanFacts(formula.left, false, facts);
+		addRequiredBooleanFacts(formula.right, false, facts);
+		return;
+	}
+	const leftValue = evaluateBooleanFormula$1(formula.left, facts.assignments);
+	const rightValue = evaluateBooleanFormula$1(formula.right, facts.assignments);
+	if (leftValue === false) addRequiredBooleanFacts(formula.right, true, facts);
+	if (rightValue === false) addRequiredBooleanFacts(formula.left, true, facts);
+};
+const doConditionsImplyFormula = (conditions, target) => {
+	const facts = {
+		assignments: /* @__PURE__ */ new Map(),
+		didConflict: false,
+		didChange: true
+	};
+	while (facts.didChange && !facts.didConflict) {
+		facts.didChange = false;
+		for (const condition of conditions) addRequiredBooleanFacts(condition, true, facts);
+	}
+	return facts.didConflict || evaluateBooleanFormula$1(target, facts.assignments) === true;
+};
+const getFunctionBindingSymbol = (functionNode, scopes) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && functionNode.id) return scopes.symbolFor(functionNode.id);
+	const parent = functionNode.parent;
+	if ((isNodeOfType(functionNode, "ArrowFunctionExpression") || isNodeOfType(functionNode, "FunctionExpression")) && isNodeOfType(parent, "VariableDeclarator") && parent.init === functionNode && isNodeOfType(parent.id, "Identifier")) return scopes.symbolFor(parent.id);
+	return null;
+};
+const getComponentFunctionNode = (containingNode) => {
+	if (isFunctionLike$1(containingNode)) return containingNode;
+	if (!isNodeOfType(containingNode, "VariableDeclarator") || !containingNode.init) return null;
+	const initializer = stripParenExpression(containingNode.init);
+	if (isFunctionLike$1(initializer)) return initializer;
+	if (!isNodeOfType(initializer, "CallExpression")) return null;
+	const firstArgument = initializer.arguments[0];
+	return firstArgument && !isNodeOfType(firstArgument, "SpreadElement") && isFunctionLike$1(firstArgument) ? firstArgument : null;
+};
+const isReferenceDirectlyCalled = (identifier) => {
+	const unwrappedIdentifier = stripParenExpression(identifier);
+	const parent = unwrappedIdentifier.parent;
+	return isNodeOfType(parent, "CallExpression") && parent.callee === unwrappedIdentifier ? parent : null;
+};
+const getSynchronousCallbackCall = (functionNode) => {
+	const callExpression = functionNode.parent;
+	if (!isNodeOfType(callExpression, "CallExpression") || !callExpression.arguments.some((argument) => argument === functionNode) || !isNodeOfType(callExpression.callee, "MemberExpression")) return null;
+	const methodName = getStaticMemberPropertyName(callExpression.callee);
+	return methodName && SYNCHRONOUS_ARRAY_CALLBACK_METHOD_NAMES.has(methodName) ? callExpression : null;
+};
+const isNodeEvaluatedDuringRender = (node, componentNode, scopes, visitedFunctionSymbolIds = /* @__PURE__ */ new Set()) => {
+	const functionNode = findEnclosingFunction$1(node);
+	if (!functionNode) return false;
+	if (functionNode === componentNode) return true;
+	const synchronousCallbackCall = getSynchronousCallbackCall(functionNode);
+	if (synchronousCallbackCall) return isNodeEvaluatedDuringRender(synchronousCallbackCall, componentNode, scopes, visitedFunctionSymbolIds);
+	if (executesDuringRender(functionNode, scopes)) return isNodeEvaluatedDuringRender(functionNode.parent ?? functionNode, componentNode, scopes, visitedFunctionSymbolIds);
+	const functionSymbol = getFunctionBindingSymbol(functionNode, scopes);
+	if (!functionSymbol || visitedFunctionSymbolIds.has(functionSymbol.id)) return false;
+	visitedFunctionSymbolIds.add(functionSymbol.id);
+	let callCount = 0;
+	for (const reference of functionSymbol.references) {
+		const callExpression = isReferenceDirectlyCalled(reference.identifier);
+		if (!callExpression) return false;
+		if (!isNodeEvaluatedDuringRender(callExpression, componentNode, scopes, new Set(visitedFunctionSymbolIds))) return false;
+		callCount += 1;
+	}
+	return callCount > 0;
+};
+const isInlineJsxCallback = (functionNode) => {
+	let ancestor = functionNode.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXAttribute")) return true;
+		if (isFunctionLike$1(ancestor) || isNodeOfType(ancestor, "Program")) return false;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const collectExposureConditions = (analysis, context, node, componentNode, protectedSymbolIds) => {
+	const conditions = [];
+	let child = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === child) {
+			if (parent.operator === "&&") conditions.push(...getRequiredTruthyConditions(analysis, context, parent.left, protectedSymbolIds));
+			if (parent.operator === "||") {
+				const leftFormula = getBooleanFormula$1(analysis, context, parent.left, protectedSymbolIds);
+				if (leftFormula) conditions.push(createNotFormula(leftFormula));
+			}
+		} else if (isNodeOfType(parent, "ConditionalExpression")) {
+			const testFormula = getBooleanFormula$1(analysis, context, parent.test, protectedSymbolIds);
+			if (testFormula && parent.consequent === child) conditions.push(testFormula);
+			if (testFormula && parent.alternate === child) conditions.push(createNotFormula(testFormula));
+		} else if (isNodeOfType(parent, "IfStatement")) {
+			const testFormula = getBooleanFormula$1(analysis, context, parent.test, protectedSymbolIds);
+			if (testFormula && parent.consequent === child) conditions.push(testFormula);
+			if (testFormula && parent.alternate === child) conditions.push(createNotFormula(testFormula));
+		}
+		if (parent === componentNode) break;
+		if (isFunctionLike$1(parent) && parent !== componentNode && !isInlineJsxCallback(parent)) {
+			const synchronousCallbackCall = getSynchronousCallbackCall(parent);
+			if (synchronousCallbackCall) {
+				child = synchronousCallbackCall;
+				parent = synchronousCallbackCall.parent;
+				continue;
+			}
+			const functionSymbol = getFunctionBindingSymbol(parent, context.scopes);
+			if (functionSymbol?.references.length === 1) {
+				const callExpression = isReferenceDirectlyCalled(functionSymbol.references[0].identifier);
+				if (callExpression) {
+					child = callExpression;
+					parent = callExpression.parent;
+					continue;
+				}
+			}
+			break;
+		}
+		child = parent;
+		parent = parent.parent;
+	}
+	return conditions;
+};
 const isMountSnapshotInitializer = (context, node) => {
 	if (!isReactApiCall(node, "useMemo", context.scopes, { resolveNamedAliases: true }) || !isNodeOfType(node, "CallExpression")) return false;
 	const dependencies = node.arguments?.[1];
@@ -43128,13 +44520,194 @@ const countUseStates = (analysis, componentNode) => {
 	for (const ref of getDownstreamRefs(analysis, componentNode)) if (isState(analysis, ref)) stateVariables.add(ref.resolved);
 	return stateVariables.size;
 };
+const hasUnconditionalAwaitBefore = (functionNode, boundaryNode, context) => {
+	const boundaryStart = getRangeStart(boundaryNode);
+	if (boundaryStart === null) return false;
+	let didFindAwait = false;
+	walkAst(functionNode, (child) => {
+		if (didFindAwait) return false;
+		if (child !== functionNode && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "AwaitExpression") || !isNodeReachableWithinFunction(child, context) || !context.cfg.isUnconditionalFromEntry(child)) return;
+		const awaitStart = getRangeStart(child);
+		if (awaitStart !== null && awaitStart < boundaryStart) {
+			didFindAwait = true;
+			return false;
+		}
+	});
+	return didFindAwait;
+};
+const helperReloadsSetterAfterAwait = (analysis, context, helperFunction, setterReference) => getDownstreamRefs(analysis, helperFunction).some((helperReference) => {
+	if (!setterReference.resolved || helperReference.resolved !== setterReference.resolved) return false;
+	const helperSetterCall = getCallExpr(helperReference);
+	return Boolean(helperSetterCall && findEnclosingFunction$1(helperSetterCall) === helperFunction && isNodeReachableWithinFunction(helperSetterCall, context) && hasUnconditionalAwaitBefore(helperFunction, helperSetterCall, context));
+});
+const effectInvokesAsyncSetterReloadHelper = (analysis, context, effectReferences, effectFunction, setterReference) => effectReferences.some((effectReference) => {
+	const helperCall = getCallExpr(effectReference);
+	if (!isNodeOfType(helperCall, "CallExpression") || findEnclosingFunction$1(helperCall) !== effectFunction || !isNodeReachableWithinFunction(helperCall, context)) return false;
+	const helperFunction = resolveExactLocalFunction(helperCall.callee, context.scopes);
+	return Boolean(helperFunction && helperFunction !== effectFunction && helperReloadsSetterAfterAwait(analysis, context, helperFunction, setterReference));
+});
+const getStateSymbolForSetter = (analysis, context, setterReference) => {
+	const useStateDeclaration = getUseStateDecl(analysis, setterReference);
+	if (!useStateDeclaration || !isNodeOfType(useStateDeclaration, "VariableDeclarator") || !isNodeOfType(useStateDeclaration.id, "ArrayPattern")) return null;
+	const stateBinding = useStateDeclaration.id.elements[0];
+	return stateBinding && isNodeOfType(stateBinding, "Identifier") ? context.scopes.symbolFor(stateBinding) : null;
+};
+const getPropertyName = (node) => {
+	if (isNodeOfType(node, "Identifier")) return node.name;
+	return isNodeOfType(node, "Literal") && typeof node.value === "string" ? node.value : null;
+};
+const isBooleanTypeNode = (node) => {
+	if (!node) return false;
+	if (isNodeOfType(node, "TSBooleanKeyword")) return true;
+	if (!isNodeOfType(node, "TSUnionType")) return false;
+	return node.types.every((typeNode) => isNodeOfType(typeNode, "TSBooleanKeyword") || isNodeOfType(typeNode, "TSUndefinedKeyword") || isNodeOfType(typeNode, "TSNullKeyword"));
+};
+const getBooleanPropertyType = (typeNode, propertyName, referenceNode) => {
+	const unwrappedType = isNodeOfType(typeNode, "TSTypeAnnotation") ? typeNode.typeAnnotation : typeNode;
+	if (isNodeOfType(unwrappedType, "TSTypeLiteral")) return unwrappedType.members.some((member) => isNodeOfType(member, "TSPropertySignature") && getPropertyName(member.key) === propertyName && isBooleanTypeNode(member.typeAnnotation?.typeAnnotation));
+	if (!isNodeOfType(unwrappedType, "TSTypeReference") || !isNodeOfType(unwrappedType.typeName, "Identifier")) return false;
+	const typeName = unwrappedType.typeName.name;
+	if (hasEnclosingTypeParameterNamed(referenceNode, typeName)) return false;
+	const programNode = findProgramNode(referenceNode);
+	if (!isNodeOfType(programNode, "Program")) return false;
+	const matchingInterfaces = programNode.body.flatMap((statement) => {
+		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
+		return isNodeOfType(declaration, "TSInterfaceDeclaration") && declaration.id.name === typeName ? [declaration] : [];
+	});
+	if (matchingInterfaces.length !== 1) return false;
+	let sameNameTypeBindingCount = 0;
+	walkAst(programNode, (candidate) => {
+		const identifier = isNodeOfType(candidate, "TSInterfaceDeclaration") || isNodeOfType(candidate, "TSTypeAliasDeclaration") || isNodeOfType(candidate, "ClassDeclaration") || isNodeOfType(candidate, "ClassExpression") || isNodeOfType(candidate, "TSEnumDeclaration") ? candidate.id : isNodeOfType(candidate, "TSTypeParameter") ? candidate.name : null;
+		if (isNodeOfType(identifier, "Identifier") && identifier.name === typeName) sameNameTypeBindingCount += 1;
+	});
+	if (sameNameTypeBindingCount !== 1) return false;
+	return matchingInterfaces[0].body.body.some((member) => isNodeOfType(member, "TSPropertySignature") && getPropertyName(member.key) === propertyName && isBooleanTypeNode(member.typeAnnotation?.typeAnnotation));
+};
+const findProgramNode = (node) => {
+	let currentNode = node;
+	while (currentNode.parent) currentNode = currentNode.parent;
+	return currentNode;
+};
+const hasBooleanBindingAnnotation = (symbol, identifier) => {
+	const property = symbol.bindingIdentifier.parent;
+	const objectPattern = property?.parent;
+	if (!isNodeOfType(property, "Property") || !isNodeOfType(objectPattern, "ObjectPattern") || !objectPattern.typeAnnotation) return false;
+	const propertyName = getPropertyName(property.key);
+	return Boolean(propertyName && getBooleanPropertyType(objectPattern.typeAnnotation, propertyName, identifier));
+};
+const isBooleanExpression$1 = (context, node, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "Literal")) return typeof expression.value === "boolean";
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") return true;
+	if (isNodeOfType(expression, "BinaryExpression")) return [
+		"==",
+		"===",
+		"!=",
+		"!==",
+		"<",
+		"<=",
+		">",
+		">="
+	].includes(expression.operator);
+	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee)) return true;
+	if (isNodeOfType(expression, "LogicalExpression")) return isBooleanExpression$1(context, expression.left, new Set(visitedSymbolIds)) && isBooleanExpression$1(context, expression.right, new Set(visitedSymbolIds));
+	if (isNodeOfType(expression, "ConditionalExpression")) return isBooleanExpression$1(context, expression.consequent, new Set(visitedSymbolIds)) && isBooleanExpression$1(context, expression.alternate, new Set(visitedSymbolIds));
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = context.scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	if (hasBooleanBindingAnnotation(symbol, expression)) return true;
+	visitedSymbolIds.add(symbol.id);
+	const initializer = getDirectConstInitializer(symbol);
+	return Boolean(initializer && isBooleanExpression$1(context, initializer, visitedSymbolIds));
+};
+const getPropDerivedDependencySymbols = (analysis, context, dependencyReferences) => {
+	const symbolsById = /* @__PURE__ */ new Map();
+	for (const dependencyReference of dependencyReferences) {
+		if (!getUpstreamRefs(analysis, dependencyReference).some((upstreamReference) => isProp(analysis, upstreamReference))) continue;
+		const symbol = context.scopes.symbolFor(dependencyReference.identifier);
+		if (symbol) symbolsById.set(symbol.id, symbol);
+	}
+	return [...symbolsById.values()];
+};
+const getImpliedDependencyValue = (conditions, dependencyFormulas) => {
+	const impliesTrue = dependencyFormulas.some((dependencyFormula) => doConditionsImplyFormula(conditions, dependencyFormula));
+	if (impliesTrue === dependencyFormulas.some((dependencyFormula) => doConditionsImplyFormula(conditions, createNotFormula(dependencyFormula)))) return null;
+	return impliesTrue;
+};
+const getSetterExposureConditions = (analysis, context, setterReference, componentNode, protectedSymbolIds) => {
+	const functionNode = findEnclosingFunction$1(setterReference.identifier);
+	if (!functionNode) return null;
+	if (isInlineJsxCallback(functionNode)) return [collectExposureConditions(analysis, context, functionNode, componentNode, protectedSymbolIds)];
+	const functionSymbol = getFunctionBindingSymbol(functionNode, context.scopes);
+	if (!functionSymbol || functionSymbol.references.length === 0) return null;
+	const conditionsByReference = [];
+	for (const reference of functionSymbol.references) {
+		if (isReferenceDirectlyCalled(reference.identifier)) return null;
+		let ancestor = reference.identifier.parent;
+		while (ancestor && !isNodeOfType(ancestor, "JSXAttribute") && !isFunctionLike$1(ancestor)) ancestor = ancestor.parent;
+		if (!isNodeOfType(ancestor, "JSXAttribute")) return null;
+		conditionsByReference.push(collectExposureConditions(analysis, context, reference.identifier, componentNode, protectedSymbolIds));
+	}
+	return conditionsByReference;
+};
+const areAllSetterWritesVisibilityGuarded = (analysis, context, componentNode, resetSetterReferences, dependencySymbolIds, dependencyFormulas, visibleDependencyValue) => {
+	const resetIdentifiers = new Set(resetSetterReferences.map((setterReference) => setterReference.identifier));
+	const setterVariables = new Set(resetSetterReferences.map((reference) => reference.resolved));
+	for (const setterVariable of setterVariables) {
+		if (!setterVariable) return false;
+		for (const setterReference of setterVariable.references) {
+			if (setterVariable.identifiers.some((identifier) => identifier === setterReference.identifier)) continue;
+			if (resetIdentifiers.has(setterReference.identifier)) continue;
+			if (!getCallExpr(setterReference)) return false;
+			const conditionsByExposure = getSetterExposureConditions(analysis, context, setterReference, componentNode, dependencySymbolIds);
+			if (!conditionsByExposure || conditionsByExposure.some((conditions) => getImpliedDependencyValue(conditions, dependencyFormulas) !== visibleDependencyValue)) return false;
+		}
+	}
+	return true;
+};
+const areAllResetStateReadsHiddenUntilReset = (analysis, context, componentNode, setterReferences, dependencyReferences) => {
+	if (dependencyReferences.length !== 1) return false;
+	const dependencySymbols = getPropDerivedDependencySymbols(analysis, context, dependencyReferences);
+	if (dependencySymbols.length === 0 || dependencySymbols.some((symbol) => !isBooleanExpression$1(context, symbol.bindingIdentifier) || symbol.references.some((reference) => reference.flag !== "read"))) return false;
+	const dependencySymbolIds = new Set(dependencySymbols.map((symbol) => symbol.id));
+	const dependencyFormulas = dependencySymbols.map((symbol) => ({
+		kind: "atom",
+		atomKey: `symbol:${symbol.id}`
+	}));
+	const resetStateSymbolsById = /* @__PURE__ */ new Map();
+	for (const setterReference of setterReferences) {
+		const stateSymbol = getStateSymbolForSetter(analysis, context, setterReference);
+		if (!stateSymbol) return false;
+		resetStateSymbolsById.set(stateSymbol.id, stateSymbol);
+	}
+	let visibleDependencyValue = null;
+	for (const stateSymbol of resetStateSymbolsById.values()) {
+		let exposedReadCount = 0;
+		for (const reference of stateSymbol.references) {
+			if (reference.flag === "write") continue;
+			const isRenderRead = isNodeEvaluatedDuringRender(reference.identifier, componentNode, context.scopes);
+			const functionNode = findEnclosingFunction$1(reference.identifier);
+			if (!isRenderRead && functionNode && !isInlineJsxCallback(functionNode)) return false;
+			const referenceDependencyValue = getImpliedDependencyValue(collectExposureConditions(analysis, context, reference.identifier, componentNode, dependencySymbolIds), dependencyFormulas);
+			if (referenceDependencyValue === null) return false;
+			if (visibleDependencyValue !== null && visibleDependencyValue !== referenceDependencyValue) return false;
+			visibleDependencyValue = referenceDependencyValue;
+			exposedReadCount += 1;
+		}
+		if (exposedReadCount === 0) return false;
+	}
+	return Boolean(resetStateSymbolsById.size > 0 && visibleDependencyValue !== null && areAllSetterWritesVisibilityGuarded(analysis, context, componentNode, setterReferences, dependencySymbolIds, dependencyFormulas, visibleDependencyValue));
+};
 const findPropUsedToResetAllState = (analysis, context, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
 	const stateSetterRefs = effectFnRefs.filter((ref) => isSyncStateSetterCall(analysis, ref, effectFn));
 	if (stateSetterRefs.length === 0) return null;
 	if (!stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, context, ref))) return null;
-	if (stateSetterRefs.every((setterRef) => effectFnRefs.some((otherRef) => otherRef !== setterRef && otherRef.resolved === setterRef.resolved && Boolean(getCallExpr(otherRef)) && !isSyncStateSetterCall(analysis, otherRef, effectFn)))) return null;
+	if (stateSetterRefs.every((setterRef) => effectFnRefs.some((otherRef) => otherRef !== setterRef && otherRef.resolved === setterRef.resolved && Boolean(getCallExpr(otherRef)) && !isSyncStateSetterCall(analysis, otherRef, effectFn)) || effectInvokesAsyncSetterReloadHelper(analysis, context, effectFnRefs, effectFn, setterRef))) return null;
 	const containing = findContainingNode(analysis, useEffectNode);
 	if (new Set(stateSetterRefs.map((setterRef) => setterRef.resolved)).size !== countUseStates(analysis, containing)) return null;
+	const componentFunctionNode = containing ? getComponentFunctionNode(containing) : null;
+	if (componentFunctionNode && areAllResetStateReadsHiddenUntilReset(analysis, context, componentFunctionNode, stateSetterRefs, depsRefs)) return null;
 	for (const depRef of depsRefs) for (const upRef of getUpstreamRefs(analysis, depRef)) if (isProp(analysis, upRef)) return upRef;
 	return null;
 };
@@ -44827,9 +46400,13 @@ const UNCONTROLLED_INPUT_TAGS = new Set([
 	"select"
 ]);
 const VALUE_BYPASS_INPUT_TYPES = new Set([
-	"hidden",
+	"button",
 	"checkbox",
-	"radio"
+	"hidden",
+	"image",
+	"radio",
+	"reset",
+	"submit"
 ]);
 const VALUE_PARTNER_ATTRIBUTES = [
 	"onChange",
@@ -44838,12 +46415,6 @@ const VALUE_PARTNER_ATTRIBUTES = [
 	"disabled"
 ];
 const isLiteralFalseAttributeValue = (attribute) => isNodeOfType(attribute.value, "JSXExpressionContainer") && isNodeOfType(attribute.value.expression, "Literal") && attribute.value.expression.value === false;
-const getInputTypeLiteral = (attributes) => {
-	const typeAttribute = findJsxAttribute(attributes, "type");
-	if (!typeAttribute || !isNodeOfType(typeAttribute.value, "Literal")) return null;
-	const value = typeAttribute.value.value;
-	return typeof value === "string" ? value : null;
-};
 const isUseStateUndefinedInitializer = (init) => {
 	if (!init || !isNodeOfType(init, "CallExpression")) return false;
 	if (!isHookCall$2(init, "useState")) return false;
@@ -44886,9 +46457,18 @@ const noUncontrolledInput = defineRule({
 				if (hasJsxSpreadAttribute(attributes)) return;
 				const valueAttribute = findJsxAttribute(attributes, "value");
 				if (!valueAttribute) return;
+				let inputTypeCandidates = null;
+				let hasExplicitInputType = false;
+				let doesTypeBypassMissingOnChange = false;
+				let doesTypeUseCheckedControlledness = false;
+				let couldTypeUseCheckedControlledness = false;
 				if (tagName === "input") {
-					const inputType = getInputTypeLiteral(attributes);
-					if (inputType !== null && VALUE_BYPASS_INPUT_TYPES.has(inputType)) return;
+					const typeAttribute = findJsxAttribute([...attributes].reverse(), "type");
+					hasExplicitInputType = Boolean(typeAttribute);
+					inputTypeCandidates = typeAttribute ? getJsxPropExhaustiveStaticStringValues(typeAttribute, context.scopes) : null;
+					doesTypeBypassMissingOnChange = Boolean(inputTypeCandidates !== null && inputTypeCandidates.length > 0 && inputTypeCandidates.every((inputTypeCandidate) => VALUE_BYPASS_INPUT_TYPES.has(inputTypeCandidate.toLowerCase())));
+					doesTypeUseCheckedControlledness = Boolean(inputTypeCandidates !== null && inputTypeCandidates.length > 0 && inputTypeCandidates.every((inputTypeCandidate) => inputTypeCandidate === "checkbox" || inputTypeCandidate === "radio"));
+					couldTypeUseCheckedControlledness = Boolean(hasExplicitInputType && (inputTypeCandidates === null || inputTypeCandidates.some((inputTypeCandidate) => inputTypeCandidate === "checkbox" || inputTypeCandidate === "radio")));
 				}
 				const hasAllowedPartner = VALUE_PARTNER_ATTRIBUTES.some((partnerAttributeName) => {
 					const partnerAttribute = findJsxAttribute(attributes, partnerAttributeName);
@@ -44896,12 +46476,12 @@ const noUncontrolledInput = defineRule({
 					if (partnerAttributeName === "disabled" && isLiteralFalseAttributeValue(partnerAttribute)) return false;
 					return true;
 				});
-				if (isNodeOfType(valueAttribute.value, "JSXExpressionContainer") && isNodeOfType(valueAttribute.value.expression, "Identifier") && undefinedInitialStateNames.has(valueAttribute.value.expression.name)) {
+				if (isNodeOfType(valueAttribute.value, "JSXExpressionContainer") && isNodeOfType(valueAttribute.value.expression, "Identifier") && undefinedInitialStateNames.has(valueAttribute.value.expression.name) && !doesTypeUseCheckedControlledness) {
 					const stateName = valueAttribute.value.expression.name;
-					const partnerHint = hasAllowedPartner ? "Give useState a starting value" : "Give useState a starting value and add onChange (or readOnly)";
+					const partnerHint = hasAllowedPartner || doesTypeBypassMissingOnChange || couldTypeUseCheckedControlledness ? "Give useState a starting value" : "Give useState a starting value and add onChange (or readOnly)";
 					context.report({
 						node: child,
-						message: `This can trigger a console warning and reset the field because "${stateName}" starts undefined, so <${tagName} value={${stateName}}> flips from uncontrolled to controlled. ${partnerHint} (e.g. \`useState("")\`).`
+						message: couldTypeUseCheckedControlledness ? `When \`type\` resolves to a value-controlled input type, this can trigger a console warning and reset the field because "${stateName}" starts undefined, so <input value={${stateName}}> can flip from uncontrolled to controlled. ${partnerHint} (e.g. \`useState("")\`).` : `This can trigger a console warning and reset the field because "${stateName}" starts undefined, so <${tagName} value={${stateName}}> flips from uncontrolled to controlled. ${partnerHint} (e.g. \`useState("")\`).`
 					});
 					return;
 				}
@@ -44912,10 +46492,13 @@ const noUncontrolledInput = defineRule({
 					});
 					return;
 				}
-				if (!hasAllowedPartner) context.report({
-					node: child,
-					message: `Your users can't type in this <${tagName} value={...}> because it has no \`onChange\` or \`readOnly\`, so add \`onChange\` (or \`readOnly\` if that's intended).`
-				});
+				if (!hasAllowedPartner && !doesTypeBypassMissingOnChange) {
+					const couldResolveToReadOnlyValueType = tagName === "input" && hasExplicitInputType && (inputTypeCandidates === null || inputTypeCandidates.some((inputTypeCandidate) => VALUE_BYPASS_INPUT_TYPES.has(inputTypeCandidate.toLowerCase())));
+					context.report({
+						node: child,
+						message: couldResolveToReadOnlyValueType ? `When \`type\` resolves to an editable input type, users can't type in this <input value={...}> because it has no \`onChange\` or \`readOnly\`. Add \`onChange\` or \`readOnly\` unless \`type\` is always a read-only-value input type.` : `Your users can't type in this <${tagName} value={...}> because it has no \`onChange\` or \`readOnly\`, so add \`onChange\` (or \`readOnly\` if that's intended).`
+					});
+				}
 			});
 		};
 		return {
@@ -48268,7 +49851,8 @@ const onlyExportComponents = defineRule({
 							const declaration = child.declaration;
 							if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
 								isExportedNodeIds.add(declaration);
-								exports.push(functionHasReactRenderSemantics(declaration, state) || localComponentNames.has(declaration.id.name) ? classifyExport(declaration.id.name, declaration.id, true, null, state) : {
+								const classifiedExport = classifyExport(declaration.id.name, declaration.id, true, null, state);
+								exports.push(functionHasReactRenderSemantics(declaration, state) || localComponentNames.has(declaration.id.name) || classifiedExport.kind === "allowed" ? classifiedExport : {
 									kind: "non-component",
 									reportNode: declaration.id
 								});
@@ -51228,14 +52812,6 @@ const collectPluginEntries = (rawNode, scopes, visitedSymbolIds) => {
 	}
 	return entries;
 };
-const findEffectiveExplicitAttribute = (attributes, attributeName) => {
-	for (let attributeIndex = attributes.length - 1; attributeIndex >= 0; attributeIndex -= 1) {
-		const attribute = attributes[attributeIndex];
-		if (!attribute || isNodeOfType(attribute, "JSXSpreadAttribute")) return null;
-		if (isNodeOfType(attribute, "JSXAttribute") && isNodeOfType(attribute.name, "JSXIdentifier") && attribute.name.name === attributeName) return attribute;
-	}
-	return null;
-};
 const getAttributeExpression = (attribute) => {
 	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return null;
 	return isNodeOfType(attribute.value.expression, "JSXEmptyExpression") ? null : attribute.value.expression;
@@ -51275,7 +52851,7 @@ const hasDynamicUnsanitizedChildren = (openingElement, scopes) => {
 		if (isNodeOfType(child.expression, "JSXEmptyExpression")) return false;
 		return !isStaticOrSanitizedMarkdownExpression(child.expression, scopes, /* @__PURE__ */ new Set());
 	});
-	const childrenAttribute = findEffectiveExplicitAttribute(openingElement.attributes, "children");
+	const childrenAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "children");
 	if (!childrenAttribute) return false;
 	const childrenExpression = getAttributeExpression(childrenAttribute);
 	return Boolean(childrenExpression && !isStaticOrSanitizedMarkdownExpression(childrenExpression, scopes, /* @__PURE__ */ new Set()));
@@ -51287,7 +52863,7 @@ const reactMarkdownUnsanitizedRawHtml = defineRule({
 	recommendation: "Add `rehype-sanitize` to `rehypePlugins` or sanitize dynamic markdown before rendering. `skipHtml` does not disable HTML already parsed by `rehype-raw`.",
 	create: skipNonProductionFiles((context) => ({ JSXOpeningElement(node) {
 		if (!isReactMarkdownComponent(node.name, context.scopes)) return;
-		const pluginsAttribute = findEffectiveExplicitAttribute(node.attributes, "rehypePlugins");
+		const pluginsAttribute = getAuthoritativeJsxAttribute(node.attributes, "rehypePlugins");
 		if (!pluginsAttribute) return;
 		const pluginsExpression = getAttributeExpression(pluginsAttribute);
 		if (!pluginsExpression) return;
@@ -54722,6 +56298,22 @@ const isLikelyNumericExpression = (node) => {
 	if (isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && isNumericName(node.property.name)) return true;
 	return false;
 };
+const isRenderedInsideIntrinsicDomHost = (node, scopes) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXAttribute")) {
+			if (!(isNodeOfType(ancestor.name, "JSXIdentifier") && ancestor.name.name === "children")) return false;
+		}
+		if (isNodeOfType(ancestor, "JSXElement") && !isJsxFragmentElement(ancestor.openingElement, scopes)) {
+			const elementName = ancestor.openingElement.name;
+			if (!isNodeOfType(elementName, "JSXIdentifier")) return false;
+			return HTML_TAGS.has(elementName.name) || SVG_TAGS.has(elementName.name);
+		}
+		if (isNodeOfType(ancestor, "CallExpression") || isNodeOfType(ancestor, "NewExpression") || isNodeOfType(ancestor, "VariableDeclarator") || isNodeOfType(ancestor, "AssignmentExpression") || isNodeOfType(ancestor, "Property") || isFunctionLike$1(ancestor) || isNodeOfType(ancestor, "Program")) return false;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
 const rnNoFalsyAndRender = defineRule({
 	id: "rn-no-falsy-and-render",
 	title: "Numeric && renders bare zero",
@@ -54740,6 +56332,7 @@ const rnNoFalsyAndRender = defineRule({
 				if (!(isNodeOfType(node.right, "JSXElement") || isNodeOfType(node.right, "JSXFragment"))) return;
 				const parent = node.parent;
 				if (!(isNodeOfType(parent, "JSXExpressionContainer") || isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&")) return;
+				if (isRenderedInsideIntrinsicDomHost(node, context.scopes)) return;
 				const left = node.left;
 				if (!left) return;
 				if (!isLikelyNumericExpression(left)) return;
@@ -59772,7 +61365,7 @@ const roleSupportsAriaProps = defineRule({
 		if (!ariaAttributes) return;
 		const elementType = getElementType(node, context.settings);
 		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
-		const roleCandidates = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : [getImplicitRole(node, elementType)].filter((role) => role !== null);
+		const roleCandidates = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : [getImplicitRole(node, elementType, context.scopes)].filter((role) => role !== null);
 		if (roleCandidates === null || roleCandidates.length === 0) return;
 		const supportedSets = [];
 		for (const role of roleCandidates) {
@@ -61430,29 +63023,19 @@ const serverNoMutableModuleState = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/server/server-sequential-independent-await.ts
-const collectDeclaredNames = (declaration) => {
-	const names = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(declaration, "VariableDeclaration")) return names;
-	for (const declarator of declaration.declarations ?? []) collectPatternNames(declarator.id, names);
-	return names;
-};
 const declarationStartsWithAwait = (declaration) => {
 	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
 	for (const declarator of declaration.declarations ?? []) if (isNodeOfType(declarator.init, "AwaitExpression")) return true;
 	return false;
 };
-const declarationReadsAnyName = (declaration, names) => {
-	if (names.size === 0) return false;
+const declarationReadsAnyPatternBinding = (declaration, patterns, context) => {
+	if (patterns.length === 0) return false;
 	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
-	let didRead = false;
 	for (const declarator of declaration.declarations ?? []) {
 		if (!declarator.init) continue;
-		walkAst(declarator.init, (child) => {
-			if (didRead) return;
-			if (isNodeOfType(child, "Identifier") && names.has(child.name)) didRead = true;
-		});
+		if (expressionReadsPatternBinding(declarator.init, patterns, context.scopes)) return true;
 	}
-	return didRead;
+	return false;
 };
 const GATE_LEADING_VERBS = new Set([
 	"require",
@@ -61526,11 +63109,11 @@ const serverSequentialIndependentAwait = defineRule({
 				const currentStatement = statements[statementIndex];
 				if (!isNodeOfType(currentStatement, "VariableDeclaration")) continue;
 				if (!declarationStartsWithAwait(currentStatement)) continue;
-				const declaredNames = collectDeclaredNames(currentStatement);
+				const declaredPatterns = currentStatement.declarations.map((declarator) => declarator.id);
 				const nextStatement = statements[statementIndex + 1];
 				if (!isNodeOfType(nextStatement, "VariableDeclaration")) continue;
 				if (!declarationStartsWithAwait(nextStatement)) continue;
-				if (declarationReadsAnyName(nextStatement, declaredNames)) continue;
+				if (declarationReadsAnyPatternBinding(nextStatement, declaredPatterns, context)) continue;
 				if (declarationAwaitsExistingPromise(nextStatement)) continue;
 				if (declarationAwaitsRequestScopedCall(currentStatement) || declarationAwaitsRequestScopedCall(nextStatement)) continue;
 				if (declarationAwaitsGate(currentStatement, context)) continue;
@@ -62551,7 +64134,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 			return false;
 		};
 		const isWiredAsEventHandler = (functionNode) => {
-			const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+			const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 			if (!bindingIdentifier) return false;
 			const bindingSymbol = context.scopes.symbolFor(bindingIdentifier);
 			if (!bindingSymbol) return false;
@@ -62571,7 +64154,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 			return false;
 		};
 		const isSynchronouslyInvokedAnonymousWrapper = (functionNode) => {
-			if (getFunctionBindingIdentifier(functionNode)) return false;
+			if (getFunctionBindingIdentifier$1(functionNode)) return false;
 			const parent = functionNode.parent;
 			if (!isNodeOfType(parent, "CallExpression")) return false;
 			return parent.callee === functionNode || (parent.arguments ?? []).some((callArgument) => callArgument === functionNode);
@@ -68503,6 +70086,7 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"no-indeterminate-attribute",
 	"no-locale-format-in-render",
 	"no-match-media-in-state-initializer",
+	"no-create-ref-in-function-component",
 	"no-adjust-state-on-prop-change",
 	"no-derived-state",
 	"no-derived-state-effect",
@@ -68607,6 +70191,18 @@ const collectForwardedHookDependencies = ({ absoluteFilePath, staticImports }) =
 		collectProgramDependencies(resolved.filePath, resolved.programNode, 4);
 	}
 };
+const collectCreateRefDependencies = ({ absoluteFilePath, program }) => {
+	attachParentReferences(program);
+	const scopes = analyzeScopes(program);
+	walkAst(program, (node) => {
+		if (!isNodeOfType(node, "CallExpression") || !isReactApiCall(node, "createRef", scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveNamedAliases: true
+		})) return;
+		isCreateRefResultWriteOnly(node, absoluteFilePath, scopes);
+	});
+};
 const collectMutatingReducerDependencies = ({ absoluteFilePath, sourceText, staticImports, program }) => {
 	const namedUseReducerLocals = /* @__PURE__ */ new Set();
 	const reactObjectLocals = /* @__PURE__ */ new Set();
@@ -68695,6 +70291,7 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["no-indeterminate-attribute", collectNearestManifestDependencies],
 	["no-locale-format-in-render", collectNearestManifestDependencies],
 	["no-match-media-in-state-initializer", collectNearestManifestDependencies],
+	["no-create-ref-in-function-component", collectCreateRefDependencies],
 	["no-adjust-state-on-prop-change", collectEffectValueHelperDependencies],
 	["no-derived-state", collectEffectValueHelperDependencies],
 	["no-derived-state-effect", collectEffectValueHelperDependencies],