oxlint-plugin-react-doctor 0.7.9-dev.194cc06 → 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;
@@ -12977,750 +13673,239 @@ const cleanupFunctionReleasesRefOwnedUsage = (cleanupFunction, componentFunction
 				hasUnsafeRefWrite = true;
 				return false;
 			}
-			return;
-		}
-		if (isNodeOfType(child, "CallExpression")) {
-			if ((child.arguments ?? []).some((argumentNode) => {
-				const argumentKey = resolveExpressionKey(argumentNode, context);
-				return argumentKey !== null && (argumentKey === storage.refKey || argumentKey === storage.refCurrentKey);
-			})) {
-				hasUnsafeRefWrite = true;
-				return false;
-			}
-			return;
-		}
-		if (!isNodeOfType(child, "AssignmentExpression")) return;
-		const assignmentTarget = stripParenExpression(child.left);
-		if (isNodeOfType(assignmentTarget, "MemberExpression") && assignmentTarget.computed && resolveExpressionKey(assignmentTarget.object, context) === storage.refCurrentKey) {
-			hasUnsafeRefWrite = true;
-			return false;
-		}
-		const assignedKey = resolveExpressionKey(child.left, context);
-		if (assignedKey === storage.handlerKey) {
-			hasUnsafeRefWrite = true;
-			return false;
-		}
-		if (assignedKey !== storage.refCurrentKey) return;
-		const assignedValue = stripParenExpression(child.right);
-		if (isNodeOfType(assignedValue, "Literal") && assignedValue.value === null && findEnclosingFunction$1(child) === cleanupFunction) return;
-		const assignedSessionProperties = (isNodeOfType(assignedValue, "ObjectExpression") ? assignedValue : null)?.properties ?? [];
-		const storesMatchingHandler = assignedSessionProperties.every((property) => isNodeOfType(property, "Property")) && assignedSessionProperties.some((property) => isNodeOfType(property, "Property") && `${storage.refCurrentKey}.${getStaticPropertyKeyName(property) ?? ""}` === storage.handlerKey && resolveExpressionKey(property.value, context) === usage.handlerKey);
-		if (findEnclosingFunction$1(child) !== retainedFunction || !storesMatchingHandler) {
-			hasUnsafeRefWrite = true;
-			return false;
-		}
-	});
-	return !hasUnsafeRefWrite;
-};
-const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retainedFunction, usage, context) => {
-	const matchesReturnedCleanup = (returnedValue) => {
-		const cleanupFunction = resolveRefOwnedCleanupFunction(returnedValue, context);
-		return Boolean(cleanupFunction && cleanupFunctionReleasesRefOwnedUsage(cleanupFunction, componentFunction, retainedFunction, usage, context));
-	};
-	if (!isFunctionLike$1(effectCallback)) return false;
-	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return matchesReturnedCleanup(stripParenExpression(effectCallback.body));
-	const matchingReturns = [];
-	walkInsideStatementBlocks(effectCallback.body, (child) => {
-		if (isNodeOfType(child, "ReturnStatement") && child.argument && matchesReturnedCleanup(stripParenExpression(child.argument))) matchingReturns.push(child);
-	});
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
-};
-const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) => {
-	const componentFunction = findEnclosingFunction$1(retainedFunction);
-	if (!componentFunction || !isFunctionLike$1(componentFunction)) return false;
-	let didFindCleanupEffect = false;
-	walkAst(componentFunction.body, (child) => {
-		if (didFindCleanupEffect) return false;
-		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
-		const effectStatement = findTransparentExpressionRoot(child).parent;
-		if (!isNodeOfType(effectStatement, "ExpressionStatement") || effectStatement.parent !== componentFunction.body) return;
-		const effectCallback = getEffectCallback(child);
-		if (effectCallback && effectReturnsRefOwnedCleanup(effectCallback, componentFunction, retainedFunction, usage, context)) {
-			didFindCleanupEffect = true;
-			return false;
-		}
-	});
-	return didFindCleanupEffect;
-};
-const isUseSyncExternalStoreSubscribeFunction = (functionNode, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
-	if (!bindingIdentifier) return false;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	const isSubscribeBinding = (candidateBinding) => {
-		const symbol = context.scopes.symbolFor(candidateBinding);
-		if (!symbol || visitedSymbolIds.has(symbol.id) || symbol.references.length === 0) return false;
-		visitedSymbolIds.add(symbol.id);
-		return symbol.references.every((reference) => {
-			const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-			const referenceParent = referenceRoot.parent;
-			if (isNodeOfType(referenceParent, "CallExpression") && referenceParent.arguments?.[0] === referenceRoot) return isReactApiCall(referenceParent, "useSyncExternalStore", context.scopes);
-			const aliasDeclaration = referenceParent?.parent;
-			return Boolean(isNodeOfType(referenceParent, "VariableDeclarator") && referenceParent.init === referenceRoot && isNodeOfType(referenceParent.id, "Identifier") && isNodeOfType(aliasDeclaration, "VariableDeclaration") && aliasDeclaration.kind === "const" && isSubscribeBinding(referenceParent.id));
-		});
-	};
-	return isSubscribeBinding(bindingIdentifier);
-};
-const doesResourceResultEscape = (resourceNode, allowConciseReturnEscape) => {
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode) return true;
-		if (isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode && allowConciseReturnEscape) return true;
-		if (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
-			currentNode = parentNode;
-			parentNode = currentNode.parent;
-			continue;
-		}
-		return false;
-	}
-	return false;
-};
-const findRetainedFunctionLeak = (retainedFunction, context) => {
-	if (!isFunctionLike$1(retainedFunction)) return null;
-	const body = retainedFunction.body;
-	if (!body) return null;
-	let leak = null;
-	const allowConciseReturnEscape = !isInlineRetainedHandlerFunction(retainedFunction, context);
-	const isExternalStoreSubscribeFunction = isUseSyncExternalStoreSubscribeFunction(retainedFunction, context);
-	const hasReleaseForUsage = (usage) => isExternalStoreSubscribeFunction ? effectHasCleanupForUsage(retainedFunction, usage, context) : fileContainsReleaseForUsage(usage, context) || hasGuaranteedRefOwnedUnmountCleanup(retainedFunction, usage, context);
-	walkAst(body, (child) => {
-		if (leak !== null) return false;
-		if (isFunctionLike$1(child)) return false;
-		if (isSocketConstruction(child) && !doesResourceResultEscape(child, false)) {
-			const socketUsage = {
-				kind: "socket",
-				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: null,
-				eventKey: null,
-				handlerKey: null
-			};
-			if (!hasReleaseForUsage(socketUsage)) {
-				leak = socketUsage;
-				return false;
-			}
-		}
-		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
-			const timerUsage = {
-				kind: "timer",
-				node: child,
-				resourceName: "setInterval",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: "setInterval",
-				eventKey: null,
-				handlerKey: null
-			};
-			if (!hasReleaseForUsage(timerUsage)) {
-				leak = timerUsage;
-				return false;
-			}
-		}
-		if (isSubscribeOrObserveCall(child) && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
-			const registrationDetails = getCallRegistrationDetails(child, context);
-			const subscriptionUsage = {
-				kind: "subscribe",
-				node: child,
-				resourceName: registrationDetails.registrationVerbName ?? "subscribe",
-				handleKey: findAssignedResourceKey(child, context),
-				...registrationDetails
-			};
-			if (!hasSelfReleasingListenerOptions(child, context) && !hasReleaseForUsage(subscriptionUsage)) leak = subscriptionUsage;
-			return false;
-		}
-	});
-	return leak;
-};
-const isRetainedComponentScopeFunction = (functionNode) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration")) return enclosingComponentOrHookName(functionNode) !== null;
-	if (!isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression")) return false;
-	if (!isNodeOfType(functionNode.parent, "VariableDeclarator")) return false;
-	return enclosingComponentOrHookName(functionNode) !== null;
-};
-const isDirectJsxEventHandlerValue = (expression) => {
-	const expressionRoot = findTransparentExpressionRoot(expression);
-	const expressionContainer = expressionRoot.parent;
-	return isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === expressionRoot && isEventHandlerAttribute(expressionContainer.parent);
-};
-const isInlineRetainedHandlerFunction = (functionNode, context) => {
-	if (!isFunctionLike$1(functionNode)) return false;
-	const functionRoot = findTransparentExpressionRoot(functionNode);
-	const callbackCall = functionRoot.parent;
-	if (isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments?.[0] === functionRoot && isHookCall$2(callbackCall, "useCallback") && isDirectJsxEventHandlerValue(callbackCall)) return true;
-	const parentNode = functionNode.parent;
-	if (isDirectJsxEventHandlerValue(functionNode)) return true;
-	if (!isNodeOfType(parentNode, "Property") || parentNode.value !== functionNode || parentNode.computed) return false;
-	const propertyName = getStaticPropertyKeyName(parentNode);
-	if (!propertyName || !/^on[A-Z]/.test(propertyName)) return false;
-	const objectExpression = parentNode.parent;
-	if (!isNodeOfType(objectExpression, "ObjectExpression")) return false;
-	const objectParent = objectExpression.parent;
-	return (isNodeOfType(objectParent, "CallExpression") && objectParent.arguments.some((argument) => argument === objectExpression) || isNodeOfType(objectParent, "JSXExpressionContainer")) && findRenderPhaseComponentOrHook(parentNode, context.scopes) !== null;
-};
-const effectNeedsCleanup = defineRule({
-	id: "effect-needs-cleanup",
-	title: "Effect subscription or timer never cleaned up",
-	severity: "error",
-	tags: ["test-noise"],
-	recommendation: "Return a cleanup function that stops the subscription or timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` or `clearTimeout(id)` for timers, `return () => observer.disconnect()` for observers, `return () => socket.close()` for connections, or `return unsubscribe` if the subscribe call already gave you one.",
-	create: (context) => {
-		const reportRetainedLeak = (retainedFunction) => {
-			if (!isPotentiallyReachableFunction(retainedFunction, context)) return;
-			const leak = findRetainedFunctionLeak(retainedFunction, context);
-			if (!leak) return;
-			const resourceNoun = RESOURCE_NOUN_BY_KIND[leak.kind];
-			context.report({
-				node: leak.node,
-				message: `\`${leak.resourceName}\` creates a ${resourceNoun} in a function that outlives the render, with no cleanup path. Store the handle and release it, or move this into a useEffect that returns cleanup, so it does not leak after unmount.`
-			});
-		};
-		return {
-			CallExpression(node) {
-				if (isHookCall$2(node, "useCallback")) {
-					const retainedCallback = getEffectCallback(node);
-					if (retainedCallback && !isInlineRetainedHandlerFunction(retainedCallback, context)) reportRetainedLeak(retainedCallback);
-					return;
-				}
-				if (!isHookCall$2(node, CLEANUP_EFFECT_HOOK_NAMES)) return;
-				const callback = getEffectCallback(node);
-				if (!callback) return;
-				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback, context), context);
-				if (usages.length === 0) return;
-				const firstUsage = findFirstUsageWithoutCleanup(callback, usages, context);
-				if (!firstUsage) return;
-				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
-				const hookName = getCalleeName$2(node) ?? "effect";
-				context.report({
-					node,
-					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without guaranteed cleanup. Return a cleanup function that owns every allocation so it does not leak after unmount.`
-				});
-			},
-			FunctionDeclaration(node) {
-				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
-			},
-			ArrowFunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
-			},
-			FunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
-			}
-		};
-	}
-});
-//#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;
+			return;
+		}
+		if (isNodeOfType(child, "CallExpression")) {
+			if ((child.arguments ?? []).some((argumentNode) => {
+				const argumentKey = resolveExpressionKey(argumentNode, context);
+				return argumentKey !== null && (argumentKey === storage.refKey || argumentKey === storage.refCurrentKey);
+			})) {
+				hasUnsafeRefWrite = true;
+				return false;
 			}
+			return;
 		}
-		for (const child of scope.children) visitScope(child);
-	};
-	visitScope(rootScope);
+		if (!isNodeOfType(child, "AssignmentExpression")) return;
+		const assignmentTarget = stripParenExpression(child.left);
+		if (isNodeOfType(assignmentTarget, "MemberExpression") && assignmentTarget.computed && resolveExpressionKey(assignmentTarget.object, context) === storage.refCurrentKey) {
+			hasUnsafeRefWrite = true;
+			return false;
+		}
+		const assignedKey = resolveExpressionKey(child.left, context);
+		if (assignedKey === storage.handlerKey) {
+			hasUnsafeRefWrite = true;
+			return false;
+		}
+		if (assignedKey !== storage.refCurrentKey) return;
+		const assignedValue = stripParenExpression(child.right);
+		if (isNodeOfType(assignedValue, "Literal") && assignedValue.value === null && findEnclosingFunction$1(child) === cleanupFunction) return;
+		const assignedSessionProperties = (isNodeOfType(assignedValue, "ObjectExpression") ? assignedValue : null)?.properties ?? [];
+		const storesMatchingHandler = assignedSessionProperties.every((property) => isNodeOfType(property, "Property")) && assignedSessionProperties.some((property) => isNodeOfType(property, "Property") && `${storage.refCurrentKey}.${getStaticPropertyKeyName(property) ?? ""}` === storage.handlerKey && resolveExpressionKey(property.value, context) === usage.handlerKey);
+		if (findEnclosingFunction$1(child) !== retainedFunction || !storesMatchingHandler) {
+			hasUnsafeRefWrite = true;
+			return false;
+		}
+	});
+	return !hasUnsafeRefWrite;
 };
-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()
+const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retainedFunction, usage, context) => {
+	const matchesReturnedCleanup = (returnedValue) => {
+		const cleanupFunction = resolveRefOwnedCleanupFunction(returnedValue, context);
+		return Boolean(cleanupFunction && cleanupFunctionReleasesRefOwnedUsage(cleanupFunction, componentFunction, retainedFunction, usage, context));
 	};
-	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;
+	if (!isFunctionLike$1(effectCallback)) return false;
+	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return matchesReturnedCleanup(stripParenExpression(effectCallback.body));
+	const matchingReturns = [];
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (isNodeOfType(child, "ReturnStatement") && child.argument && matchesReturnedCleanup(stripParenExpression(child.argument))) matchingReturns.push(child);
+	});
+	return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+};
+const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) => {
+	const componentFunction = findEnclosingFunction$1(retainedFunction);
+	if (!componentFunction || !isFunctionLike$1(componentFunction)) return false;
+	let didFindCleanupEffect = false;
+	walkAst(componentFunction.body, (child) => {
+		if (didFindCleanupEffect) return false;
+		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
+		const effectStatement = findTransparentExpressionRoot(child).parent;
+		if (!isNodeOfType(effectStatement, "ExpressionStatement") || effectStatement.parent !== componentFunction.body) return;
+		const effectCallback = getEffectCallback(child);
+		if (effectCallback && effectReturnsRefOwnedCleanup(effectCallback, componentFunction, retainedFunction, usage, context)) {
+			didFindCleanupEffect = true;
+			return false;
 		}
-		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
+	});
+	return didFindCleanupEffect;
+};
+const isUseSyncExternalStoreSubscribeFunction = (functionNode, context) => {
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
+	if (!bindingIdentifier) return false;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	const isSubscribeBinding = (candidateBinding) => {
+		const symbol = context.scopes.symbolFor(candidateBinding);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || symbol.references.length === 0) return false;
+		visitedSymbolIds.add(symbol.id);
+		return symbol.references.every((reference) => {
+			const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+			const referenceParent = referenceRoot.parent;
+			if (isNodeOfType(referenceParent, "CallExpression") && referenceParent.arguments?.[0] === referenceRoot) return isReactApiCall(referenceParent, "useSyncExternalStore", context.scopes);
+			const aliasDeclaration = referenceParent?.parent;
+			return Boolean(isNodeOfType(referenceParent, "VariableDeclarator") && referenceParent.init === referenceRoot && isNodeOfType(referenceParent.id, "Identifier") && isNodeOfType(aliasDeclaration, "VariableDeclaration") && aliasDeclaration.kind === "const" && isSubscribeBinding(referenceParent.id));
+		});
 	};
+	return isSubscribeBinding(bindingIdentifier);
 };
-const isDescendantScope = (inner, outer) => {
-	let current = inner;
-	while (current) {
-		if (current === outer) return true;
-		current = current.parent;
+const doesResourceResultEscape = (resourceNode, allowConciseReturnEscape) => {
+	let currentNode = resourceNode;
+	let parentNode = currentNode.parent;
+	while (parentNode) {
+		if (isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode) return true;
+		if (isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode && allowConciseReturnEscape) return true;
+		if (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
+			currentNode = parentNode;
+			parentNode = currentNode.parent;
+			continue;
+		}
+		return false;
 	}
 	return false;
 };
+const findRetainedFunctionLeak = (retainedFunction, context) => {
+	if (!isFunctionLike$1(retainedFunction)) return null;
+	const body = retainedFunction.body;
+	if (!body) return null;
+	let leak = null;
+	const allowConciseReturnEscape = !isInlineRetainedHandlerFunction(retainedFunction, context);
+	const isExternalStoreSubscribeFunction = isUseSyncExternalStoreSubscribeFunction(retainedFunction, context);
+	const hasReleaseForUsage = (usage) => isExternalStoreSubscribeFunction ? effectHasCleanupForUsage(retainedFunction, usage, context) : fileContainsReleaseForUsage(usage, context) || hasGuaranteedRefOwnedUnmountCleanup(retainedFunction, usage, context);
+	walkAst(body, (child) => {
+		if (leak !== null) return false;
+		if (isFunctionLike$1(child)) return false;
+		if (isSocketConstruction(child) && !doesResourceResultEscape(child, false)) {
+			const socketUsage = {
+				kind: "socket",
+				node: child,
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
+				handleKey: findAssignedResourceKey(child, context),
+				receiverKey: null,
+				registrationVerbName: null,
+				eventKey: null,
+				handlerKey: null
+			};
+			if (!hasReleaseForUsage(socketUsage)) {
+				leak = socketUsage;
+				return false;
+			}
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
+			const timerUsage = {
+				kind: "timer",
+				node: child,
+				resourceName: "setInterval",
+				handleKey: findAssignedResourceKey(child, context),
+				receiverKey: null,
+				registrationVerbName: "setInterval",
+				eventKey: null,
+				handlerKey: null
+			};
+			if (!hasReleaseForUsage(timerUsage)) {
+				leak = timerUsage;
+				return false;
+			}
+		}
+		if (isSubscribeOrObserveCall(child) && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
+			const registrationDetails = getCallRegistrationDetails(child, context);
+			const subscriptionUsage = {
+				kind: "subscribe",
+				node: child,
+				resourceName: registrationDetails.registrationVerbName ?? "subscribe",
+				handleKey: findAssignedResourceKey(child, context),
+				...registrationDetails
+			};
+			if (!hasSelfReleasingListenerOptions(child, context) && !hasReleaseForUsage(subscriptionUsage)) leak = subscriptionUsage;
+			return false;
+		}
+	});
+	return leak;
+};
+const isRetainedComponentScopeFunction = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration")) return enclosingComponentOrHookName(functionNode) !== null;
+	if (!isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression")) return false;
+	if (!isNodeOfType(functionNode.parent, "VariableDeclarator")) return false;
+	return enclosingComponentOrHookName(functionNode) !== null;
+};
+const isDirectJsxEventHandlerValue = (expression) => {
+	const expressionRoot = findTransparentExpressionRoot(expression);
+	const expressionContainer = expressionRoot.parent;
+	return isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === expressionRoot && isEventHandlerAttribute(expressionContainer.parent);
+};
+const isInlineRetainedHandlerFunction = (functionNode, context) => {
+	if (!isFunctionLike$1(functionNode)) return false;
+	const functionRoot = findTransparentExpressionRoot(functionNode);
+	const callbackCall = functionRoot.parent;
+	if (isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments?.[0] === functionRoot && isHookCall$2(callbackCall, "useCallback") && isDirectJsxEventHandlerValue(callbackCall)) return true;
+	const parentNode = functionNode.parent;
+	if (isDirectJsxEventHandlerValue(functionNode)) return true;
+	if (!isNodeOfType(parentNode, "Property") || parentNode.value !== functionNode || parentNode.computed) return false;
+	const propertyName = getStaticPropertyKeyName(parentNode);
+	if (!propertyName || !/^on[A-Z]/.test(propertyName)) return false;
+	const objectExpression = parentNode.parent;
+	if (!isNodeOfType(objectExpression, "ObjectExpression")) return false;
+	const objectParent = objectExpression.parent;
+	return (isNodeOfType(objectParent, "CallExpression") && objectParent.arguments.some((argument) => argument === objectExpression) || isNodeOfType(objectParent, "JSXExpressionContainer")) && findRenderPhaseComponentOrHook(parentNode, context.scopes) !== null;
+};
+const effectNeedsCleanup = defineRule({
+	id: "effect-needs-cleanup",
+	title: "Effect subscription or timer never cleaned up",
+	severity: "error",
+	tags: ["test-noise"],
+	recommendation: "Return a cleanup function that stops the subscription or timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` or `clearTimeout(id)` for timers, `return () => observer.disconnect()` for observers, `return () => socket.close()` for connections, or `return unsubscribe` if the subscribe call already gave you one.",
+	create: (context) => {
+		const reportRetainedLeak = (retainedFunction) => {
+			if (!isPotentiallyReachableFunction(retainedFunction, context)) return;
+			const leak = findRetainedFunctionLeak(retainedFunction, context);
+			if (!leak) return;
+			const resourceNoun = RESOURCE_NOUN_BY_KIND[leak.kind];
+			context.report({
+				node: leak.node,
+				message: `\`${leak.resourceName}\` creates a ${resourceNoun} in a function that outlives the render, with no cleanup path. Store the handle and release it, or move this into a useEffect that returns cleanup, so it does not leak after unmount.`
+			});
+		};
+		return {
+			CallExpression(node) {
+				if (isHookCall$2(node, "useCallback")) {
+					const retainedCallback = getEffectCallback(node);
+					if (retainedCallback && !isInlineRetainedHandlerFunction(retainedCallback, context)) reportRetainedLeak(retainedCallback);
+					return;
+				}
+				if (!isHookCall$2(node, CLEANUP_EFFECT_HOOK_NAMES)) return;
+				const callback = getEffectCallback(node);
+				if (!callback) return;
+				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback, context), context);
+				if (usages.length === 0) return;
+				const firstUsage = findFirstUsageWithoutCleanup(callback, usages, context);
+				if (!firstUsage) return;
+				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
+				const hookName = getCalleeName$2(node) ?? "effect";
+				context.report({
+					node,
+					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without guaranteed cleanup. Return a cleanup function that owns every allocation so it does not leak after unmount.`
+				});
+			},
+			FunctionDeclaration(node) {
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
+			},
+			ArrowFunctionExpression(node) {
+				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
+			},
+			FunctionExpression(node) {
+				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
+			}
+		};
+	}
+});
 //#endregion
 //#region src/plugin/semantic/closure-captures.ts
 const computeClosureCaptures = (functionNode, scopes) => {
@@ -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.";
@@ -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;
@@ -33136,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",
@@ -33151,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" })\`.`
@@ -41796,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;
@@ -41897,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) {
@@ -43088,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;
@@ -43146,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":
@@ -43256,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({
@@ -43435,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) => {
@@ -43445,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",
@@ -43476,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.`
@@ -43956,6 +44520,33 @@ 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;
@@ -44112,7 +44703,7 @@ const findPropUsedToResetAllState = (analysis, context, effectFnRefs, depsRefs,
 	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;
@@ -45809,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",
@@ -45820,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;
@@ -45868,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);
@@ -45878,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;
 				}
@@ -45894,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 {
@@ -49250,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
 								});
@@ -52210,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;
@@ -52257,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()));
@@ -52269,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;
@@ -55704,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",
@@ -55722,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;
@@ -60754,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) {
@@ -62412,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",
@@ -62508,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;