oxlint-plugin-react-doctor 0.2.9 → 0.2.10

package/dist/index.js

@@ -2,264 +2,6 @@ import path from "node:path";
 import { analyze } from "eslint-scope";
 import * as eslintVisitorKeys from "eslint-visitor-keys";
 import fs from "node:fs";
-//#region src/plugin/constants/library.ts
-const HEAVY_LIBRARIES = new Set([
-	"@monaco-editor/react",
-	"monaco-editor",
-	"recharts",
-	"@react-pdf/renderer",
-	"react-quill",
-	"@codemirror/view",
-	"@codemirror/state",
-	"chart.js",
-	"react-chartjs-2",
-	"@toast-ui/editor",
-	"draft-js"
-]);
-const FETCH_CALLEE_NAMES = new Set([
-	"fetch",
-	"ky",
-	"got",
-	"wretch",
-	"ofetch"
-]);
-const FETCH_MEMBER_OBJECTS = new Set([
-	"axios",
-	"ky",
-	"got",
-	"ofetch",
-	"wretch",
-	"request"
-]);
-const MUTATION_METHOD_NAMES = new Set([
-	"create",
-	"insert",
-	"insertInto",
-	"update",
-	"upsert",
-	"delete",
-	"remove",
-	"destroy",
-	"set",
-	"append"
-]);
-const MUTATING_HTTP_METHODS = new Set([
-	"POST",
-	"PUT",
-	"DELETE",
-	"PATCH"
-]);
-const SAFE_MUTABLE_CONSTRUCTOR_NAMES = new Set([
-	"Map",
-	"Set",
-	"WeakMap",
-	"WeakSet",
-	"Headers",
-	"URLSearchParams",
-	"FormData",
-	"Response",
-	"NextResponse"
-]);
-const RESPONSE_FACTORY_OBJECTS = new Set(["Response", "NextResponse"]);
-const RESPONSE_FACTORY_METHODS = new Set([
-	"json",
-	"redirect",
-	"next",
-	"rewrite",
-	"error"
-]);
-//#endregion
-//#region src/plugin/constants/dom.ts
-const PASSIVE_EVENT_NAMES = new Set([
-	"scroll",
-	"wheel",
-	"touchstart",
-	"touchmove",
-	"touchend"
-]);
-const SCRIPT_LOADING_ATTRIBUTES = new Set(["defer", "async"]);
-const EXECUTABLE_SCRIPT_TYPES = new Set([
-	"text/javascript",
-	"application/javascript",
-	"module"
-]);
-const TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES = new Set([
-	"setTimeout",
-	"setInterval",
-	"requestAnimationFrame",
-	"requestIdleCallback",
-	"queueMicrotask"
-]);
-const TIMER_CALLEE_NAMES_REQUIRING_CLEANUP = new Set(["setInterval", "setTimeout"]);
-const TIMER_CLEANUP_CALLEE_NAMES = new Set(["clearInterval", "clearTimeout"]);
-const MUTABLE_GLOBAL_ROOTS = new Set([
-	"location",
-	"window",
-	"document",
-	"navigator",
-	"history",
-	"screen",
-	"performance"
-]);
-const EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS = new Set([
-	"IntersectionObserver",
-	"MutationObserver",
-	"ResizeObserver",
-	"PerformanceObserver"
-]);
-const STORAGE_OBJECTS$1 = new Set(["localStorage", "sessionStorage"]);
-//#endregion
-//#region src/plugin/constants/react.ts
-const INDEX_PARAMETER_NAMES = new Set([
-	"index",
-	"idx",
-	"i"
-]);
-const LOADING_STATE_PATTERN = /^(?:isLoading|isPending)$/;
-const STABLE_HOOK_WRAPPERS = new Set([
-	"useState",
-	"useMemo",
-	"useRef"
-]);
-const GENERIC_EVENT_SUFFIXES = new Set([
-	"Click",
-	"Change",
-	"Input",
-	"Blur",
-	"Focus"
-]);
-const TRIVIAL_INITIALIZER_NAMES = new Set([
-	"Boolean",
-	"String",
-	"Number",
-	"Array",
-	"Object",
-	"parseInt",
-	"parseFloat"
-]);
-const TRIVIAL_DERIVATION_CALLEE_NAMES = new Set([
-	"Boolean",
-	"String",
-	"Number",
-	"Array",
-	"Object",
-	"parseInt",
-	"parseFloat",
-	"isNaN",
-	"isFinite",
-	"BigInt",
-	"Symbol"
-]);
-const SETTER_PATTERN = /^set[A-Z]/;
-const RENDER_FUNCTION_PATTERN = /^render[A-Z]/;
-const UPPERCASE_PATTERN = /^[A-Z]/;
-const REACT_HANDLER_PROP_PATTERN = /^on[A-Z]/;
-const EFFECT_HOOK_NAMES$1 = new Set(["useEffect", "useLayoutEffect"]);
-const HOOKS_WITH_DEPS = new Set([
-	"useEffect",
-	"useLayoutEffect",
-	"useMemo",
-	"useCallback"
-]);
-const REACT_HOC_NAMES = new Set([
-	"memo",
-	"forwardRef",
-	"React.memo",
-	"React.forwardRef"
-]);
-const SUBSCRIPTION_METHOD_NAMES = new Set([
-	"subscribe",
-	"addEventListener",
-	"addListener",
-	"on",
-	"watch",
-	"listen",
-	"sub"
-]);
-const CLEANUP_RETURNING_SUBSCRIPTION_METHOD_NAMES = new Set(["subscribe", "sub"]);
-const GLOBAL_RELEASE_METHOD_NAMES = new Set([
-	"unsubscribe",
-	"removeEventListener",
-	"removeListener",
-	"off",
-	"unwatch",
-	"unlisten",
-	"unsub",
-	"abort"
-]);
-const BOUND_RESOURCE_RELEASE_METHOD_NAMES = new Set([
-	"remove",
-	"cleanup",
-	"dispose",
-	"destroy",
-	"stop",
-	"teardown"
-]);
-const CLEANUP_LIKE_RELEASE_CALLEE_NAMES = new Set([
-	...GLOBAL_RELEASE_METHOD_NAMES,
-	"cleanup",
-	"dispose",
-	"destroy",
-	"teardown"
-]);
-const EXTERNAL_SYNC_MEMBER_METHOD_NAMES = new Set([
-	...SUBSCRIPTION_METHOD_NAMES,
-	"connect",
-	"disconnect",
-	"open",
-	"close",
-	"fetch",
-	"post",
-	"put",
-	"patch"
-]);
-const EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS = new Set([
-	...FETCH_MEMBER_OBJECTS,
-	"api",
-	"client",
-	"http",
-	"fetcher"
-]);
-const EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES = new Set([
-	"get",
-	"head",
-	"options",
-	"delete"
-]);
-const EXTERNAL_SYNC_DIRECT_CALLEE_NAMES = new Set([...FETCH_CALLEE_NAMES, ...TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES]);
-const EVENT_TRIGGERED_SIDE_EFFECT_CALLEES = new Set([
-	...FETCH_CALLEE_NAMES,
-	"post",
-	"put",
-	"patch",
-	"navigate",
-	"navigateTo",
-	"showNotification",
-	"toast",
-	"alert",
-	"confirm",
-	"logVisit",
-	"captureEvent"
-]);
-const EVENT_TRIGGERED_SIDE_EFFECT_MEMBER_METHODS = new Set([
-	"post",
-	"put",
-	"patch",
-	"delete",
-	"navigate",
-	"capture",
-	"track",
-	"logEvent"
-]);
-const EVENT_TRIGGERED_NAVIGATION_METHOD_NAMES = new Set(["push", "replace"]);
-const NAVIGATION_RECEIVER_NAMES = new Set([
-	"router",
-	"navigation",
-	"navigator",
-	"history",
-	"location"
-]);
-//#endregion
 //#region src/plugin/utils/is-testlike-filename.ts
 const NON_PRODUCTION_PATH_SEGMENTS = [
 	"/test/",
@@ -537,15 +279,291 @@ const defineRule = (rule) => {
 	};
 };
 //#endregion
-//#region src/plugin/utils/get-effect-callback.ts
-const getEffectCallback = (node) => {
-	if (!isNodeOfType(node, "CallExpression") && !isNodeOfType(node, "NewExpression")) return null;
-	if (!node.arguments?.length) return null;
-	const callback = node.arguments[0];
-	if (isNodeOfType(callback, "ArrowFunctionExpression") || isNodeOfType(callback, "FunctionExpression")) return callback;
+//#region src/plugin/constants/library.ts
+const HEAVY_LIBRARIES = new Set([
+	"@monaco-editor/react",
+	"monaco-editor",
+	"recharts",
+	"@react-pdf/renderer",
+	"react-quill",
+	"@codemirror/view",
+	"@codemirror/state",
+	"chart.js",
+	"react-chartjs-2",
+	"@toast-ui/editor",
+	"draft-js"
+]);
+const FETCH_CALLEE_NAMES = new Set([
+	"fetch",
+	"ky",
+	"got",
+	"wretch",
+	"ofetch"
+]);
+const FETCH_MEMBER_OBJECTS = new Set([
+	"axios",
+	"ky",
+	"got",
+	"ofetch",
+	"wretch",
+	"request"
+]);
+const MUTATION_METHOD_NAMES = new Set([
+	"create",
+	"insert",
+	"insertInto",
+	"update",
+	"upsert",
+	"delete",
+	"remove",
+	"destroy",
+	"set",
+	"append"
+]);
+const MUTATING_HTTP_METHODS = new Set([
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH"
+]);
+const SAFE_MUTABLE_CONSTRUCTOR_NAMES = new Set([
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Headers",
+	"URLSearchParams",
+	"FormData",
+	"Response",
+	"NextResponse"
+]);
+const RESPONSE_FACTORY_OBJECTS = new Set(["Response", "NextResponse"]);
+const RESPONSE_FACTORY_METHODS = new Set([
+	"json",
+	"redirect",
+	"next",
+	"rewrite",
+	"error"
+]);
+//#endregion
+//#region src/plugin/constants/dom.ts
+const PASSIVE_EVENT_NAMES = new Set([
+	"scroll",
+	"wheel",
+	"touchstart",
+	"touchmove",
+	"touchend"
+]);
+const SCRIPT_LOADING_ATTRIBUTES = new Set(["defer", "async"]);
+const EXECUTABLE_SCRIPT_TYPES = new Set([
+	"text/javascript",
+	"application/javascript",
+	"module"
+]);
+const TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES = new Set([
+	"setTimeout",
+	"setInterval",
+	"requestAnimationFrame",
+	"requestIdleCallback",
+	"queueMicrotask"
+]);
+const TIMER_CALLEE_NAMES_REQUIRING_CLEANUP = new Set(["setInterval", "setTimeout"]);
+const TIMER_CLEANUP_CALLEE_NAMES = new Set(["clearInterval", "clearTimeout"]);
+const MUTABLE_GLOBAL_ROOTS = new Set([
+	"location",
+	"window",
+	"document",
+	"navigator",
+	"history",
+	"screen",
+	"performance"
+]);
+const EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS = new Set([
+	"IntersectionObserver",
+	"MutationObserver",
+	"ResizeObserver",
+	"PerformanceObserver"
+]);
+const STORAGE_OBJECTS$1 = new Set(["localStorage", "sessionStorage"]);
+//#endregion
+//#region src/plugin/constants/react.ts
+const INDEX_PARAMETER_NAMES = new Set([
+	"index",
+	"idx",
+	"i"
+]);
+const LOADING_STATE_PATTERN = /^(?:isLoading|isPending)$/;
+const STABLE_HOOK_WRAPPERS = new Set([
+	"useState",
+	"useMemo",
+	"useRef"
+]);
+const GENERIC_EVENT_SUFFIXES = new Set([
+	"Click",
+	"Change",
+	"Input",
+	"Blur",
+	"Focus"
+]);
+const TRIVIAL_INITIALIZER_NAMES = new Set([
+	"Boolean",
+	"String",
+	"Number",
+	"Array",
+	"Object",
+	"parseInt",
+	"parseFloat"
+]);
+const TRIVIAL_DERIVATION_CALLEE_NAMES = new Set([
+	"Boolean",
+	"String",
+	"Number",
+	"Array",
+	"Object",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"BigInt",
+	"Symbol"
+]);
+const SETTER_PATTERN = /^set[A-Z]/;
+const RENDER_FUNCTION_PATTERN = /^render[A-Z]/;
+const UPPERCASE_PATTERN = /^[A-Z]/;
+const REACT_HANDLER_PROP_PATTERN = /^on[A-Z]/;
+const EFFECT_HOOK_NAMES$1 = new Set(["useEffect", "useLayoutEffect"]);
+const HOOKS_WITH_DEPS = new Set([
+	"useEffect",
+	"useLayoutEffect",
+	"useMemo",
+	"useCallback"
+]);
+const REACT_HOC_NAMES = new Set([
+	"memo",
+	"forwardRef",
+	"React.memo",
+	"React.forwardRef"
+]);
+const SUBSCRIPTION_METHOD_NAMES = new Set([
+	"subscribe",
+	"addEventListener",
+	"addListener",
+	"on",
+	"watch",
+	"listen",
+	"sub"
+]);
+const CLEANUP_RETURNING_SUBSCRIPTION_METHOD_NAMES = new Set(["subscribe", "sub"]);
+const GLOBAL_RELEASE_METHOD_NAMES = new Set([
+	"unsubscribe",
+	"removeEventListener",
+	"removeListener",
+	"off",
+	"unwatch",
+	"unlisten",
+	"unsub",
+	"abort"
+]);
+const BOUND_RESOURCE_RELEASE_METHOD_NAMES = new Set([
+	"remove",
+	"cleanup",
+	"dispose",
+	"destroy",
+	"stop",
+	"teardown"
+]);
+const CLEANUP_LIKE_RELEASE_CALLEE_NAMES = new Set([
+	...GLOBAL_RELEASE_METHOD_NAMES,
+	"cleanup",
+	"dispose",
+	"destroy",
+	"teardown"
+]);
+const EXTERNAL_SYNC_MEMBER_METHOD_NAMES = new Set([
+	...SUBSCRIPTION_METHOD_NAMES,
+	"connect",
+	"disconnect",
+	"open",
+	"close",
+	"fetch",
+	"post",
+	"put",
+	"patch"
+]);
+const EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS = new Set([
+	...FETCH_MEMBER_OBJECTS,
+	"api",
+	"client",
+	"http",
+	"fetcher"
+]);
+const EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES = new Set([
+	"get",
+	"head",
+	"options",
+	"delete"
+]);
+const EXTERNAL_SYNC_DIRECT_CALLEE_NAMES = new Set([...FETCH_CALLEE_NAMES, ...TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES]);
+const EVENT_TRIGGERED_SIDE_EFFECT_CALLEES = new Set([
+	...FETCH_CALLEE_NAMES,
+	"post",
+	"put",
+	"patch",
+	"navigate",
+	"navigateTo",
+	"showNotification",
+	"toast",
+	"alert",
+	"confirm",
+	"logVisit",
+	"captureEvent"
+]);
+const EVENT_TRIGGERED_SIDE_EFFECT_MEMBER_METHODS = new Set([
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"navigate",
+	"capture",
+	"track",
+	"logEvent"
+]);
+const EVENT_TRIGGERED_NAVIGATION_METHOD_NAMES = new Set(["push", "replace"]);
+const NAVIGATION_RECEIVER_NAMES = new Set([
+	"router",
+	"navigation",
+	"navigator",
+	"history",
+	"location"
+]);
+//#endregion
+//#region src/plugin/utils/find-program-root.ts
+/**
+* Walks up the AST `parent` chain from `node` to its enclosing
+* `Program` root and returns it; `null` when the chain doesn't lead
+* to a `Program` (e.g. detached fragments used by test utilities).
+*
+* Was duplicated byte-identical across seven sites (five rule files
+* + two utility modules). Promoted to a shared helper so adding a
+* new ESTree top-level shape only touches one place.
+*/
+const findProgramRoot = (node) => {
+	let cursor = node;
+	while (cursor) {
+		if (isNodeOfType(cursor, "Program")) return cursor;
+		cursor = cursor.parent ?? null;
+	}
 	return null;
 };
 //#endregion
+//#region src/plugin/utils/get-imported-name.ts
+const getImportedName$1 = (importSpecifier) => {
+	if (!isNodeOfType(importSpecifier, "ImportSpecifier")) return void 0;
+	const imported = importSpecifier.imported;
+	if (isNodeOfType(imported, "Identifier")) return imported.name;
+	if (isNodeOfType(imported, "Literal") && typeof imported.value === "string") return imported.value;
+};
+//#endregion
 //#region src/plugin/utils/get-callee-name.ts
 const getCalleeName$1 = (node) => {
 	if (!isNodeOfType(node, "CallExpression") && !isNodeOfType(node, "NewExpression")) return null;
@@ -582,6 +600,132 @@ const walkAst = (node, visitor) => {
 	}
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/activity-wraps-effect-heavy-subtree.ts
+const ACTIVITY_IMPORTED_NAMES = new Set(["Activity", "unstable_Activity"]);
+const isStaticallyKnownMode = (modeAttribute) => {
+	const value = modeAttribute.value;
+	if (!value) return false;
+	if (isNodeOfType(value, "Literal")) return true;
+	if (isNodeOfType(value, "JSXExpressionContainer")) return isNodeOfType(value.expression, "Literal");
+	return false;
+};
+const collectChildComponentNames = (element, into) => {
+	walkAst(element, (child) => {
+		if (!isNodeOfType(child, "JSXOpeningElement")) return;
+		if (!isNodeOfType(child.name, "JSXIdentifier")) return;
+		const name = child.name.name;
+		if (!UPPERCASE_PATTERN.test(name)) return;
+		into.add(name);
+	});
+};
+const findSameFileComponentBody = (programRoot, componentName) => {
+	let foundBody = null;
+	walkAst(programRoot, (node) => {
+		if (foundBody) return false;
+		if (isNodeOfType(node, "FunctionDeclaration") && node.id && node.id.name === componentName) {
+			foundBody = node.body;
+			return false;
+		}
+		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.id.name === componentName) {
+			const initializer = node.init;
+			if (isNodeOfType(initializer, "ArrowFunctionExpression") || isNodeOfType(initializer, "FunctionExpression")) {
+				foundBody = initializer.body;
+				return false;
+			}
+		}
+	});
+	return foundBody;
+};
+const countEffectHookCalls = (body) => {
+	if (!body) return 0;
+	let count = 0;
+	walkAst(body, (child) => {
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (isHookCall$1(child, EFFECT_HOOK_NAMES$1)) count++;
+	});
+	return count;
+};
+const activityWrapsEffectHeavySubtree = defineRule({
+	id: "activity-wraps-effect-heavy-subtree",
+	severity: "warn",
+	requires: ["react:19.2"],
+	recommendation: "Audit the subtree under `<Activity>` — every hide / show cycle tears down and recreates every Effect inside. Move subscriptions and effect-driven setState chains outside the Activity boundary, or pre-resolve the data above it",
+	create: (context) => {
+		const localActivityNames = /* @__PURE__ */ new Set();
+		const reactNamespaceLocalNames = /* @__PURE__ */ new Set();
+		return {
+			ImportDeclaration(node) {
+				if (node.source?.value !== "react") return;
+				for (const specifier of node.specifiers ?? []) {
+					if (isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
+						if (isNodeOfType(specifier.local, "Identifier")) reactNamespaceLocalNames.add(specifier.local.name);
+						continue;
+					}
+					if (isNodeOfType(specifier, "ImportDefaultSpecifier")) {
+						if (isNodeOfType(specifier.local, "Identifier")) reactNamespaceLocalNames.add(specifier.local.name);
+						continue;
+					}
+					if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
+					const importedName = getImportedName$1(specifier);
+					if (!importedName || !ACTIVITY_IMPORTED_NAMES.has(importedName)) continue;
+					if (isNodeOfType(specifier.local, "Identifier")) localActivityNames.add(specifier.local.name);
+				}
+			},
+			JSXElement(node) {
+				const openingElement = node.openingElement;
+				if (!openingElement) return;
+				const elementName = openingElement.name;
+				let isActivity = false;
+				if (isNodeOfType(elementName, "JSXIdentifier")) isActivity = localActivityNames.has(elementName.name);
+				else if (isNodeOfType(elementName, "JSXMemberExpression")) {
+					if (isNodeOfType(elementName.object, "JSXIdentifier") && reactNamespaceLocalNames.has(elementName.object.name) && isNodeOfType(elementName.property, "JSXIdentifier")) isActivity = ACTIVITY_IMPORTED_NAMES.has(elementName.property.name);
+				}
+				if (!isActivity) return;
+				let modeAttribute = null;
+				for (const attribute of openingElement.attributes ?? []) {
+					if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+					if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
+					if (attribute.name.name !== "mode") continue;
+					modeAttribute = attribute;
+					break;
+				}
+				if (!modeAttribute) return;
+				if (isStaticallyKnownMode(modeAttribute)) return;
+				const childComponentNames = /* @__PURE__ */ new Set();
+				collectChildComponentNames(node, childComponentNames);
+				for (const activityName of localActivityNames) childComponentNames.delete(activityName);
+				if (childComponentNames.size === 0) return;
+				const programRoot = findProgramRoot(node);
+				if (!programRoot) return;
+				let totalEffects = 0;
+				const effectfulChildren = [];
+				for (const componentName of childComponentNames) {
+					const body = findSameFileComponentBody(programRoot, componentName);
+					if (!body) continue;
+					const effectCount = countEffectHookCalls(body);
+					if (effectCount === 0) continue;
+					totalEffects += effectCount;
+					effectfulChildren.push(`<${componentName}>`);
+				}
+				if (totalEffects === 0) return;
+				context.report({
+					node: openingElement,
+					message: `<Activity> wraps ${effectfulChildren.join(", ")} which use ${totalEffects} effect hook${totalEffects === 1 ? "" : "s"} — every hide/show cycle recreates them all. Audit the subtree or move subscriptions outside the boundary`
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/utils/get-effect-callback.ts
+const getEffectCallback = (node) => {
+	if (!isNodeOfType(node, "CallExpression") && !isNodeOfType(node, "NewExpression")) return null;
+	if (!node.arguments?.length) return null;
+	const callback = node.arguments[0];
+	if (isNodeOfType(callback, "ArrowFunctionExpression") || isNodeOfType(callback, "FunctionExpression")) return callback;
+	return null;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/advanced-event-handler-refs.ts
 const advancedEventHandlerRefs = defineRule({
 	id: "advanced-event-handler-refs",
@@ -875,7 +1019,7 @@ const altText = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/anchor-ambiguous-text.ts
-const buildMessage$24 = (text) => `\`${text}\` is ambiguous link text — describe the destination instead (e.g. "View pricing details").`;
+const buildMessage$28 = (text) => `\`${text}\` is ambiguous link text — describe the destination instead (e.g. "View pricing details").`;
 const DEFAULT_AMBIGUOUS = [
 	"click here",
 	"here",
@@ -932,14 +1076,14 @@ const anchorAmbiguousText = defineRule({
 			const normalized = normalizeText(accessibleText);
 			if (ambiguousSet.has(normalized)) context.report({
 				node: node.openingElement.name,
-				message: buildMessage$24(normalized)
+				message: buildMessage$28(normalized)
 			});
 		} };
 	}
 });
 //#endregion
 //#region src/plugin/rules/a11y/anchor-has-content.ts
-const MESSAGE$46 = "Anchor must have accessible content — provide visible text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$47 = "Anchor must have accessible content — provide visible text, `aria-label`, or `aria-labelledby`.";
 const anchorHasContent = defineRule({
 	id: "anchor-has-content",
 	tags: ["react-jsx-only"],
@@ -954,7 +1098,7 @@ const anchorHasContent = defineRule({
 		for (const attribute of ["title", "aria-label"]) if (hasJsxPropIgnoreCase(opening.attributes, attribute)) return;
 		context.report({
 			node: opening.name,
-			message: MESSAGE$46
+			message: MESSAGE$47
 		});
 	} })
 });
@@ -1347,7 +1491,7 @@ const parseJsxValue = (value) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/aria-activedescendant-has-tabindex.ts
-const MESSAGE$45 = "An element with `aria-activedescendant` must be tabbable — add `tabIndex={0}` so it can receive focus.";
+const MESSAGE$46 = "An element with `aria-activedescendant` must be tabbable — add `tabIndex={0}` so it can receive focus.";
 const ariaActivedescendantHasTabindex = defineRule({
 	id: "aria-activedescendant-has-tabindex",
 	tags: ["react-jsx-only"],
@@ -1364,14 +1508,14 @@ const ariaActivedescendantHasTabindex = defineRule({
 			if (tabIndexValue === null || tabIndexValue >= -1) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$45
+				message: MESSAGE$46
 			});
 			return;
 		}
 		if (isInteractiveElement(tag, node)) return;
 		context.report({
 			node: node.name,
-			message: MESSAGE$45
+			message: MESSAGE$46
 		});
 	} })
 });
@@ -1511,7 +1655,7 @@ const ARIA_PROPERTIES = new Map([
 const isValidAriaProperty = (name) => ARIA_PROPERTIES.has(name);
 //#endregion
 //#region src/plugin/rules/a11y/aria-props.ts
-const buildMessage$23 = (name) => `\`${name}\` is not a valid ARIA property — check WAI-ARIA spec.`;
+const buildMessage$27 = (name) => `\`${name}\` is not a valid ARIA property — check WAI-ARIA spec.`;
 const ariaProps = defineRule({
 	id: "aria-props",
 	tags: ["react-jsx-only"],
@@ -1524,7 +1668,7 @@ const ariaProps = defineRule({
 		if (!name || !name.startsWith("aria-")) return;
 		if (!isValidAriaProperty(name)) context.report({
 			node: node.name,
-			message: buildMessage$23(name)
+			message: buildMessage$27(name)
 		});
 	} })
 });
@@ -1675,7 +1819,7 @@ const buildExpectedDescription = (propType) => {
 		case "token-list": return `a space-separated list of: ${propType.tokens.join(", ")}`;
 	}
 };
-const buildMessage$22 = (propName, propType) => `\`${propName}\` value must be ${buildExpectedDescription(propType)}.`;
+const buildMessage$26 = (propName, propType) => `\`${propName}\` value must be ${buildExpectedDescription(propType)}.`;
 const allowNoneValue = (propType) => {
 	switch (propType.kind) {
 		case "boolean":
@@ -1808,13 +1952,13 @@ const ariaProptypes = defineRule({
 		if (!node.value) {
 			if (!allowNoneValue(propType)) context.report({
 				node,
-				message: buildMessage$22(propName, propType)
+				message: buildMessage$26(propName, propType)
 			});
 			return;
 		}
 		if (!isValidValueForType(propType, node.value)) context.report({
 			node,
-			message: buildMessage$22(propName, propType)
+			message: buildMessage$26(propName, propType)
 		});
 	} })
 });
@@ -2126,7 +2270,7 @@ const ariaRole = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/aria-unsupported-elements.ts
-const buildMessage$21 = (tag, attribute) => `\`<${tag}>\` does not support \`${attribute}\` — reserved HTML elements don't accept ARIA attributes.`;
+const buildMessage$25 = (tag, attribute) => `\`<${tag}>\` does not support \`${attribute}\` — reserved HTML elements don't accept ARIA attributes.`;
 const ariaUnsupportedElements = defineRule({
 	id: "aria-unsupported-elements",
 	tags: ["react-jsx-only"],
@@ -2143,7 +2287,7 @@ const ariaUnsupportedElements = defineRule({
 			if (!attrName) continue;
 			if (attrName.startsWith("aria-") || attrName === "role") context.report({
 				node: attribute,
-				message: buildMessage$21(tag, attrName)
+				message: buildMessage$25(tag, attrName)
 			});
 		}
 	} })
@@ -2398,7 +2542,7 @@ const INTENTIONAL_SEQUENCING_CALLEE_NAMES = new Set([
 * (`FUNCTION_LIKE_TYPES.has(node.type)`) and as a type-guard. The
 * type-guard form covers both shapes without callers paying a cast.
 */
-const isFunctionLike = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
+const isFunctionLike$1 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
 //#endregion
 //#region src/plugin/utils/is-inline-function-expression.ts
 /**
@@ -2421,7 +2565,7 @@ const findFirstAwaitOutsideNestedFunctions = (block) => {
 	let firstAwait = null;
 	walkAst(block, (child) => {
 		if (firstAwait) return false;
-		if (child !== block && isFunctionLike(child)) return false;
+		if (child !== block && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "AwaitExpression")) firstAwait = child;
 	});
 	return firstAwait;
@@ -2873,13 +3017,13 @@ const asyncDeferAwait = defineRule({
 		const inspectAllStatementBlocks = (functionBody) => {
 			if (!functionBody) return;
 			walkAst(functionBody, (descendant) => {
-				if (isFunctionLike(descendant)) return false;
+				if (isFunctionLike$1(descendant)) return false;
 				if (isNodeOfType(descendant, "BlockStatement")) inspectStatements(descendant.body ?? []);
 				else if (isNodeOfType(descendant, "SwitchCase")) inspectStatements(descendant.consequent ?? []);
 			});
 		};
 		const enterFunction = (node) => {
-			if (!isFunctionLike(node)) return;
+			if (!isFunctionLike$1(node)) return;
 			if (!node.async) return;
 			if (!isNodeOfType(node.body, "BlockStatement")) return;
 			inspectAllStatementBlocks(node.body);
@@ -3010,7 +3154,7 @@ const asyncParallel = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/autocomplete-valid.ts
-const buildMessage$20 = (value) => `\`autoComplete\` value \`${value}\` is not a known HTML autofill token.`;
+const buildMessage$24 = (value) => `\`autoComplete\` value \`${value}\` is not a known HTML autofill token.`;
 const AUTOFILL_TOKENS = new Set([
 	"off",
 	"on",
@@ -3098,7 +3242,7 @@ const autocompleteValid = defineRule({
 				if (!AUTOFILL_TOKENS.has(token)) {
 					context.report({
 						node: attribute,
-						message: buildMessage$20(value)
+						message: buildMessage$24(value)
 					});
 					return;
 				}
@@ -3373,7 +3517,7 @@ const isPureEventBlockerHandler = (attribute) => {
 //#endregion
 //#region src/plugin/rules/a11y/click-events-have-key-events.ts
 const PRESENTATION_ROLES$1 = new Set(["presentation", "none"]);
-const MESSAGE$44 = "Visible non-interactive elements with click handlers must have a corresponding keyboard listener (`onKeyUp`, `onKeyDown`, or `onKeyPress`).";
+const MESSAGE$45 = "Visible non-interactive elements with click handlers must have a corresponding keyboard listener (`onKeyUp`, `onKeyDown`, or `onKeyPress`).";
 const KEY_HANDLERS = [
 	"onKeyUp",
 	"onKeyDown",
@@ -3404,7 +3548,7 @@ const clickEventsHaveKeyEvents = defineRule({
 			if (KEY_HANDLERS.some((handler) => hasJsxPropIgnoreCase(node.attributes, handler))) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$44
+				message: MESSAGE$45
 			});
 		} };
 	}
@@ -3489,14 +3633,42 @@ const isReactComponentName = (name) => {
 	return firstCharacter >= 65 && firstCharacter <= 90;
 };
 //#endregion
+//#region src/plugin/utils/strip-paren-expression.ts
+const TS_WRAPPER_TYPES = new Set([
+	"ParenthesizedExpression",
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion",
+	"TSNonNullExpression",
+	"TSInstantiationExpression"
+]);
+const stripParenExpression = (node) => {
+	let current = node;
+	while (true) {
+		if (TS_WRAPPER_TYPES.has(current.type) && "expression" in current && current.expression) {
+			current = current.expression;
+			continue;
+		}
+		if (isNodeOfType(current, "ChainExpression") && current.expression) {
+			current = current.expression;
+			continue;
+		}
+		break;
+	}
+	return current;
+};
+//#endregion
 //#region src/plugin/rules/a11y/control-has-associated-label.ts
-const MESSAGE$43 = "A control must be associated with a text label — add visible text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$44 = "A control must be associated with a text label — add visible text, `aria-label`, or `aria-labelledby`.";
 const DEFAULT_IGNORE_ELEMENTS = ["link", "canvas"];
 const DEFAULT_LABELLING_PROPS = [
 	"alt",
 	"aria-label",
 	"aria-labelledby"
 ];
+const ID_ATTRIBUTE = "id";
+const HTML_FOR_ATTRIBUTE = "htmlFor";
+const LABEL_ELEMENT = "label";
 const DEFAULT_DEPTH = 5;
 const MAX_DEPTH = 25;
 const resolveSettings$46 = (settings) => {
@@ -3524,6 +3696,29 @@ const hasLabellingProp = (attributes, customAttributes) => {
 	}
 	return false;
 };
+const toAttributeMatchKey = (kind, value) => {
+	const trimmedValue = value.trim();
+	return trimmedValue.length > 0 ? `${kind}:${trimmedValue}` : null;
+};
+const getLiteralAttributeMatchKey = (value) => {
+	if (typeof value === "string") return toAttributeMatchKey("literal", value);
+	if (typeof value === "number") return toAttributeMatchKey("literal", String(value));
+	return null;
+};
+const getAttributeMatchKey = (attribute) => {
+	if (!attribute?.value) return null;
+	const value = attribute.value;
+	if (isNodeOfType(value, "Literal")) return getLiteralAttributeMatchKey(value.value);
+	if (!isNodeOfType(value, "JSXExpressionContainer")) return null;
+	const expression = value.expression;
+	if (isNodeOfType(expression, "Identifier")) return toAttributeMatchKey("identifier", expression.name);
+	if (isNodeOfType(expression, "Literal")) return getLiteralAttributeMatchKey(expression.value);
+	if (isNodeOfType(expression, "TemplateLiteral")) {
+		const staticValue = getStaticTemplateLiteralValue(expression);
+		return staticValue === null ? null : toAttributeMatchKey("literal", staticValue);
+	}
+	return null;
+};
 const checkChildForLabel = (child, currentDepth, context) => {
 	if (currentDepth > context.depth) return false;
 	if (isNodeOfType(child, "JSXExpressionContainer")) return true;
@@ -3539,6 +3734,55 @@ const checkChildForLabel = (child, currentDepth, context) => {
 	}
 	return false;
 };
+const hasAccessibleLabelText = (element, context) => {
+	if (hasLabellingProp(element.openingElement.attributes, context.customAttributes)) return true;
+	return element.children.some((child) => checkChildForLabel(child, 1, context));
+};
+const isFunctionBoundary = (node) => isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration");
+const hasAncestorLabel = (element, context) => {
+	let current = element.parent;
+	while (current) {
+		if (isFunctionBoundary(current)) break;
+		if (isNodeOfType(current, "JSXElement")) {
+			if (getElementType(current.openingElement, context.settings) === LABEL_ELEMENT && hasAccessibleLabelText(current, context)) return true;
+		}
+		current = current.parent ?? null;
+	}
+	return false;
+};
+const findEnclosingJsxTreeRoot = (element) => {
+	let root = element;
+	let current = element.parent;
+	while (current) {
+		if (isFunctionBoundary(current)) break;
+		if (isNodeOfType(current, "JSXElement") || isNodeOfType(current, "JSXFragment")) root = current;
+		current = current.parent ?? null;
+	}
+	return root;
+};
+const collectJsxFromExpression = (rawExpression) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isNodeOfType(expression, "JSXElement") || isNodeOfType(expression, "JSXFragment")) return [expression];
+	if (isNodeOfType(expression, "LogicalExpression")) return [...collectJsxFromExpression(expression.left), ...collectJsxFromExpression(expression.right)];
+	if (isNodeOfType(expression, "ConditionalExpression")) return [...collectJsxFromExpression(expression.consequent), ...collectJsxFromExpression(expression.alternate)];
+	return [];
+};
+const searchForHtmlForLabel = (node, controlIdKey, context) => {
+	if (isNodeOfType(node, "JSXExpressionContainer")) return collectJsxFromExpression(node.expression).some((jsxNode) => searchForHtmlForLabel(jsxNode, controlIdKey, context));
+	const children = isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment") ? node.children : [];
+	if (isNodeOfType(node, "JSXElement")) {
+		if (getElementType(node.openingElement, context.settings) === LABEL_ELEMENT) {
+			if (getAttributeMatchKey(hasJsxPropIgnoreCase(node.openingElement.attributes, HTML_FOR_ATTRIBUTE)) === controlIdKey && hasAccessibleLabelText(node, context)) return true;
+		}
+	}
+	for (const child of children) if (searchForHtmlForLabel(child, controlIdKey, context)) return true;
+	return false;
+};
+const hasHtmlForLabel = (element, context) => {
+	const controlIdKey = getAttributeMatchKey(hasJsxPropIgnoreCase(element.openingElement.attributes, ID_ATTRIBUTE));
+	if (controlIdKey === null) return false;
+	return searchForHtmlForLabel(findEnclosingJsxTreeRoot(element), controlIdKey, context);
+};
 const controlHasAssociatedLabel = defineRule({
 	id: "control-has-associated-label",
 	tags: ["react-jsx-only"],
@@ -3570,10 +3814,12 @@ const controlHasAssociatedLabel = defineRule({
 				controlComponents: settings.controlComponents,
 				settings: context.settings
 			};
+			if (hasAncestorLabel(node, checkContext)) return;
+			if (hasHtmlForLabel(node, checkContext)) return;
 			for (const child of node.children) if (checkChildForLabel(child, 1, checkContext)) return;
 			context.report({
 				node: opening,
-				message: MESSAGE$43
+				message: MESSAGE$44
 			});
 		} };
 	}
@@ -3863,25 +4109,6 @@ const noVagueButtonLabel = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/find-program-root.ts
-/**
-* Walks up the AST `parent` chain from `node` to its enclosing
-* `Program` root and returns it; `null` when the chain doesn't lead
-* to a `Program` (e.g. detached fragments used by test utilities).
-*
-* Was duplicated byte-identical across seven sites (five rule files
-* + two utility modules). Promoted to a shared helper so adding a
-* new ESTree top-level shape only touches one place.
-*/
-const findProgramRoot = (node) => {
-	let cursor = node;
-	while (cursor) {
-		if (isNodeOfType(cursor, "Program")) return cursor;
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/is-es5-component.ts
 const PRAGMA$2 = "React";
 const CREATE_CLASS = "createReactClass";
@@ -3916,7 +4143,7 @@ const isEs6Component = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/display-name.ts
-const MESSAGE$42 = "Component is missing a `displayName` — assign one for easier debugging.";
+const MESSAGE$43 = "Component is missing a `displayName` — assign one for easier debugging.";
 const resolveSettings$45 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.displayName ?? {} : {};
@@ -4112,7 +4339,7 @@ const displayName = defineRule({
 		const reportAt = (node) => {
 			context.report({
 				node,
-				message: MESSAGE$42
+				message: MESSAGE$43
 			});
 		};
 		return {
@@ -4235,7 +4462,7 @@ const displayName = defineRule({
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
 	if (!node || typeof node !== "object") return;
-	if (isFunctionLike(node)) return;
+	if (isFunctionLike$1(node)) return;
 	visitor(node);
 	const nodeRecord = node;
 	for (const key of Object.keys(nodeRecord)) {
@@ -4323,7 +4550,7 @@ const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubs
 	let didFindRelease = false;
 	walkAst(node, (child) => {
 		if (didFindRelease) return false;
-		if (child !== node && isFunctionLike(child) && !isIteratorCallbackArgument(child)) return false;
+		if (child !== node && isFunctionLike$1(child) && !isIteratorCallbackArgument(child)) return false;
 		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
 			didFindRelease = true;
 			return false;
@@ -4332,7 +4559,7 @@ const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubs
 	return didFindRelease;
 };
 const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	if (!isFunctionLike(node)) return false;
+	if (!isFunctionLike$1(node)) return false;
 	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
 };
 const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
@@ -4574,7 +4801,7 @@ const recordReference = (state, identifier, flag) => {
 };
 const isFunctionBodyBlock = (block) => {
 	if (!block.parent) return false;
-	return isFunctionLike(block.parent);
+	return isFunctionLike$1(block.parent);
 };
 const isCatchClauseBlock = (block) => block.parent !== null && block.parent !== void 0 && block.parent.type === "CatchClause";
 const handleVariableDeclaration = (declaration, state) => {
@@ -4702,7 +4929,7 @@ const setNodeScope = (node, state) => {
 	state.nodeScope.set(node, state.currentScope);
 };
 const walk = (node, state) => {
-	if (isFunctionLike(node)) {
+	if (isFunctionLike$1(node)) {
 		if (isNodeOfType(node, "FunctionDeclaration") && node.id) handleFunctionDeclaration(node, state);
 		setNodeScope(node, state);
 		const fnScope = pushScope(node.type === "ArrowFunctionExpression" ? "arrow-function" : "function", node, state);
@@ -4952,7 +5179,7 @@ const closureCaptures = (functionNode, scopes) => {
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
 	const visit = (node) => {
-		if (node !== functionNode && isFunctionLike(node)) {
+		if (node !== functionNode && isFunctionLike$1(node)) {
 			const innerCaptures = closureCaptures(node, scopes);
 			for (const reference of innerCaptures) if (reference.resolvedSymbol && !isDescendantScope(reference.resolvedSymbol.scope, functionScope)) {
 				if (!seen.has(reference.id)) {
@@ -5973,7 +6200,7 @@ const flattenJsxName$1 = (name) => {
 	return "";
 };
 const isSupportedJsxName = (name) => isNodeOfType(name, "JSXIdentifier") || isNodeOfType(name, "JSXMemberExpression");
-const buildMessage$19 = (propName, message) => message ?? `Prop \`${propName}\` is forbidden on this component.`;
+const buildMessage$23 = (propName, message) => message ?? `Prop \`${propName}\` is forbidden on this component.`;
 const forbidComponentProps = defineRule({
 	id: "forbid-component-props",
 	severity: "warn",
@@ -5999,7 +6226,7 @@ const forbidComponentProps = defineRule({
 					if (!isForbiddenForTag(entry, tag)) continue;
 					context.report({
 						node: attribute,
-						message: buildMessage$19(propName, entry.message)
+						message: buildMessage$23(propName, entry.message)
 					});
 					break;
 				}
@@ -6009,7 +6236,7 @@ const forbidComponentProps = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-dom-props.ts
-const buildMessage$18 = (propName, customMessage) => customMessage ?? `Prop \`${propName}\` is forbidden on DOM nodes.`;
+const buildMessage$22 = (propName, customMessage) => customMessage ?? `Prop \`${propName}\` is forbidden on DOM nodes.`;
 const resolveSettings$43 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidDomProps ?? {} : {};
@@ -6047,7 +6274,7 @@ const forbidDomProps = defineRule({
 				if (disallowedFor && disallowedFor.size > 0 && !disallowedFor.has(elementName)) continue;
 				context.report({
 					node: attribute.name,
-					message: buildMessage$18(propName, descriptor.message)
+					message: buildMessage$22(propName, descriptor.message)
 				});
 			}
 		} };
@@ -6117,7 +6344,7 @@ const isReactFunctionCall = (node, expectedCall) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-elements.ts
-const buildMessage$17 = (element, customHelp) => customHelp ? `<${element}> is forbidden — ${customHelp}` : `<${element}> is forbidden.`;
+const buildMessage$21 = (element, customHelp) => customHelp ? `<${element}> is forbidden — ${customHelp}` : `<${element}> is forbidden.`;
 const resolveSettings$42 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidElements ?? {} : {};
@@ -6141,7 +6368,7 @@ const forbidElements = defineRule({
 				if (!fullName || !forbidMap.has(fullName)) return;
 				context.report({
 					node: node.name,
-					message: buildMessage$17(fullName, forbidMap.get(fullName))
+					message: buildMessage$21(fullName, forbidMap.get(fullName))
 				});
 			},
 			CallExpression(node) {
@@ -6161,7 +6388,7 @@ const forbidElements = defineRule({
 				if (!elementName || !forbidMap.has(elementName)) return;
 				context.report({
 					node: firstArgument,
-					message: buildMessage$17(elementName, forbidMap.get(elementName))
+					message: buildMessage$21(elementName, forbidMap.get(elementName))
 				});
 			}
 		};
@@ -6169,7 +6396,7 @@ const forbidElements = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/forward-ref-uses-ref.ts
-const MESSAGE$41 = "Components wrapped with `forwardRef` must accept a `ref` parameter — drop `forwardRef` if you don't need a ref.";
+const MESSAGE$42 = "Components wrapped with `forwardRef` must accept a `ref` parameter — drop `forwardRef` if you don't need a ref.";
 const forwardRefUsesRef = defineRule({
 	id: "forward-ref-uses-ref",
 	severity: "warn",
@@ -6188,13 +6415,13 @@ const forwardRefUsesRef = defineRule({
 		if (isNodeOfType(onlyParam, "RestElement")) return;
 		context.report({
 			node: inner,
-			message: MESSAGE$41
+			message: MESSAGE$42
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/a11y/heading-has-content.ts
-const MESSAGE$40 = "Heading elements must contain accessible text content (or `aria-label` / `aria-labelledby`).";
+const MESSAGE$41 = "Heading elements must contain accessible text content (or `aria-label` / `aria-labelledby`).";
 const DEFAULT_HEADING_TAGS = [
 	"h1",
 	"h2",
@@ -6226,7 +6453,7 @@ const headingHasContent = defineRule({
 			if (isHiddenFromScreenReader(node, context.settings)) return;
 			context.report({
 				node,
-				message: MESSAGE$40
+				message: MESSAGE$41
 			});
 		} };
 	}
@@ -6327,8 +6554,42 @@ const hookUseState = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/hooks-no-nan-in-deps.ts
+const HOOKS_WITH_DEP_ARRAY = new Set([
+	"useEffect",
+	"useLayoutEffect",
+	"useInsertionEffect",
+	"useCallback",
+	"useMemo",
+	"useImperativeHandle"
+]);
+const NAN_MESSAGE = "`NaN` in a hook dependency array is almost always a coercion bug upstream (e.g. `Number(input)` returned `NaN` from an unchecked value). React's `Object.is` comparator treats `NaN` as equal to `NaN`, so once a poisoned value lands in the deps the hook keeps firing as if nothing changed — and any later transition between `NaN` and a real number can wedge tracking. Guard the value before passing it.";
+const isNanLiteral = (node) => {
+	if (isNodeOfType(node, "Identifier") && node.name === "NaN") return true;
+	if (isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.object, "Identifier") && node.object.name === "Number" && isNodeOfType(node.property, "Identifier") && node.property.name === "NaN") return true;
+	return false;
+};
+const hooksNoNanInDeps = defineRule({
+	id: "hooks-no-nan-in-deps",
+	severity: "warn",
+	recommendation: "Remove `NaN` (or `Number.NaN`) from the dependency array. If a value can be NaN at runtime, normalise it (`Number.isNaN(x) ? 0 : x`) before passing it.",
+	create: (context) => ({ CallExpression(node) {
+		if (!isHookCall$1(node, HOOKS_WITH_DEP_ARRAY)) return;
+		const depsIndex = getCalleeName$1(node) === "useImperativeHandle" ? 2 : 1;
+		const depsArgument = node.arguments[depsIndex];
+		if (!depsArgument || !isNodeOfType(depsArgument, "ArrayExpression")) return;
+		for (const element of depsArgument.elements) {
+			if (!element) continue;
+			if (isNanLiteral(element)) context.report({
+				node: element,
+				message: NAN_MESSAGE
+			});
+		}
+	} })
+});
+//#endregion
 //#region src/plugin/rules/a11y/html-has-lang.ts
-const MESSAGE$39 = "`<html>` element must have a non-empty `lang` attribute.";
+const MESSAGE$40 = "`<html>` element must have a non-empty `lang` attribute.";
 const resolveSettings$39 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { htmlTags: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.htmlHasLang ?? {} : {}).htmlTags ?? ["html"] };
@@ -6375,7 +6636,7 @@ const htmlHasLang = defineRule({
 			if (!lang) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$39
+					message: MESSAGE$40
 				});
 				return;
 			}
@@ -6383,20 +6644,224 @@ const htmlHasLang = defineRule({
 			if (verdict === "missing" || verdict === "empty") {
 				context.report({
 					node: lang,
-					message: MESSAGE$39
+					message: MESSAGE$40
 				});
 				return;
 			}
 			if (hasSpread && !lang) context.report({
 				node: node.name,
-				message: MESSAGE$39
+				message: MESSAGE$40
 			});
 		} };
 	}
 });
 //#endregion
+//#region src/plugin/rules/correctness/html-no-invalid-paragraph-child.ts
+const BLOCK_LEVEL_ELEMENTS = new Set([
+	"address",
+	"article",
+	"aside",
+	"blockquote",
+	"details",
+	"div",
+	"dl",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hgroup",
+	"hr",
+	"main",
+	"menu",
+	"nav",
+	"ol",
+	"p",
+	"pre",
+	"search",
+	"section",
+	"table",
+	"ul"
+]);
+const buildMessage$20 = (childTagName) => `Block-level \`<${childTagName}>\` cannot appear inside a \`<p>\` — the HTML parser auto-closes the paragraph at the start of \`<${childTagName}>\`, splitting your DOM in ways the renderer never expressed and triggering hydration mismatches.`;
+const isParagraphElement = (candidate) => {
+	if (!isNodeOfType(candidate, "JSXElement")) return false;
+	const opening = candidate.openingElement;
+	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
+	return opening.name.name === "p";
+};
+const findEnclosingParagraph = (openingElement) => {
+	const owningElement = openingElement.parent;
+	if (!owningElement) return null;
+	let ancestor = owningElement.parent;
+	while (ancestor) {
+		if (isParagraphElement(ancestor)) return ancestor;
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
+const htmlNoInvalidParagraphChild = defineRule({
+	id: "html-no-invalid-paragraph-child",
+	severity: "warn",
+	recommendation: "Replace the surrounding `<p>` with a `<div>`, or hoist the block-level child outside the paragraph.",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		const childTagName = node.name.name;
+		if (!BLOCK_LEVEL_ELEMENTS.has(childTagName)) return;
+		if (!findEnclosingParagraph(node)) return;
+		context.report({
+			node: node.name,
+			message: buildMessage$20(childTagName)
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/correctness/html-no-invalid-table-nesting.ts
+const TABLE_ELEMENTS = new Set([
+	"table",
+	"thead",
+	"tbody",
+	"tfoot",
+	"tr",
+	"td",
+	"th"
+]);
+const ROW_GROUPS = new Set([
+	"thead",
+	"tbody",
+	"tfoot"
+]);
+const buildMessage$19 = (childTag, expectedParent, actualParent) => `Improper table nesting — \`<${childTag}>\` must be a direct child of ${expectedParent}, but its nearest host ancestor is \`<${actualParent}>\`. Browsers auto-rewrite invalid table structure, producing a DOM that doesn't match the JSX (broken hydration, broken \`>\` selectors, broken accessibility tree).`;
+const buildNestedTableMessage = () => "Improper table nesting — `<table>` cannot be a direct descendant of another table element. Tables can only nest inside a `<td>` or `<th>` cell of an outer table.";
+const getHostTagName = (jsxElement) => {
+	if (!isNodeOfType(jsxElement, "JSXElement")) return null;
+	const opening = jsxElement.openingElement;
+	if (!isNodeOfType(opening.name, "JSXIdentifier")) return null;
+	const tagName = opening.name.name;
+	if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return null;
+	return tagName;
+};
+const findClosestHostAncestor = (jsxElement) => {
+	let ancestor = jsxElement.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) {
+			const opening = ancestor.openingElement;
+			if (isNodeOfType(opening.name, "JSXIdentifier")) {
+				const ancestorTag = opening.name.name;
+				if (ancestorTag.length === 0) {
+					ancestor = ancestor.parent ?? null;
+					continue;
+				}
+				if (ancestorTag[0] === ancestorTag[0].toLowerCase()) return {
+					kind: "host",
+					tagName: ancestorTag,
+					element: ancestor
+				};
+				return { kind: "opaque" };
+			}
+			return { kind: "opaque" };
+		}
+		ancestor = ancestor.parent ?? null;
+	}
+	return { kind: "none" };
+};
+const NESTED_TABLE_BOUNDARY_CELLS = new Set(["td", "th"]);
+const findEnclosingTable = (jsxElement) => {
+	let ancestor = jsxElement.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement")) {
+			const tag = getHostTagName(ancestor);
+			if (tag === "table") return ancestor;
+			if (tag !== null && NESTED_TABLE_BOUNDARY_CELLS.has(tag)) return null;
+			if (tag === null) return null;
+		}
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
+const htmlNoInvalidTableNesting = defineRule({
+	id: "html-no-invalid-table-nesting",
+	severity: "warn",
+	recommendation: "Wrap each table element in its required parent: `<thead>`/`<tbody>`/`<tfoot>` directly inside `<table>`, `<tr>` inside a row group, `<td>`/`<th>` inside `<tr>`. Browsers reflow malformed table structure silently — the only safe fix is to author the markup to spec.",
+	create: (context) => ({ JSXElement(node) {
+		const tagName = getHostTagName(node);
+		if (!tagName || !TABLE_ELEMENTS.has(tagName)) return;
+		if (tagName === "table") {
+			if (findEnclosingTable(node)) context.report({
+				node: node.openingElement.name,
+				message: buildNestedTableMessage()
+			});
+			return;
+		}
+		const closestHost = findClosestHostAncestor(node);
+		if (closestHost.kind !== "host") return;
+		const actualParent = closestHost.tagName;
+		if (ROW_GROUPS.has(tagName)) {
+			if (actualParent !== "table") context.report({
+				node: node.openingElement.name,
+				message: buildMessage$19(tagName, "`<table>`", actualParent)
+			});
+			return;
+		}
+		if (tagName === "tr") {
+			if (!ROW_GROUPS.has(actualParent) && actualParent !== "table") context.report({
+				node: node.openingElement.name,
+				message: buildMessage$19(tagName, "`<thead>`, `<tbody>`, or `<tfoot>`", actualParent)
+			});
+			return;
+		}
+		if (tagName === "td" || tagName === "th") {
+			if (actualParent !== "tr") context.report({
+				node: node.openingElement.name,
+				message: buildMessage$19(tagName, "`<tr>`", actualParent)
+			});
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/rules/correctness/html-no-nested-interactive.ts
+const buildMessage$18 = (tagName) => `Improper nesting of \`<${tagName}>\` inside another \`<${tagName}>\` — the HTML parser auto-closes the outer element, splitting your DOM in ways the renderer never expressed and breaking event delegation, focus, and accessibility.`;
+const isJsxElementWithTagName = (candidate, tagName) => {
+	if (!isNodeOfType(candidate, "JSXElement")) return false;
+	const opening = candidate.openingElement;
+	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
+	return opening.name.name === tagName;
+};
+const findEnclosingSameTag = (openingElement, tagName) => {
+	const owningElement = openingElement.parent;
+	if (!owningElement) return null;
+	let ancestor = owningElement.parent;
+	while (ancestor) {
+		if (isJsxElementWithTagName(ancestor, tagName)) return ancestor;
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
+const htmlNoNestedInteractive = defineRule({
+	id: "html-no-nested-interactive",
+	severity: "warn",
+	recommendation: "Hoist the inner `<a>` or `<button>` to a sibling, or replace the outer one with a non-interactive wrapper (e.g. a `<div>` or `<span>`).",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		const tagName = node.name.name;
+		if (tagName !== "a" && tagName !== "button") return;
+		if (!findEnclosingSameTag(node, tagName)) return;
+		context.report({
+			node: node.name,
+			message: buildMessage$18(tagName)
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/a11y/iframe-has-title.ts
-const MESSAGE$38 = "`<iframe>` element must have a non-empty `title` attribute for assistive technology.";
+const MESSAGE$39 = "`<iframe>` element must have a non-empty `title` attribute for assistive technology.";
 const evaluateTitleValue = (value) => {
 	if (!value) return "missing";
 	if (isNodeOfType(value, "Literal")) {
@@ -6435,14 +6900,14 @@ const iframeHasTitle = defineRule({
 		if (!titleAttr) {
 			if (hasSpread || tag === "iframe") context.report({
 				node: node.name,
-				message: MESSAGE$38
+				message: MESSAGE$39
 			});
 			return;
 		}
 		const verdict = evaluateTitleValue(titleAttr.value);
 		if (verdict === "missing" || verdict === "empty") context.report({
 			node: titleAttr,
-			message: MESSAGE$38
+			message: MESSAGE$39
 		});
 	} })
 });
@@ -6545,7 +7010,7 @@ const iframeMissingSandbox = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/img-redundant-alt.ts
-const MESSAGE$37 = "`alt` text contains redundant words like \"image\" / \"photo\" / \"picture\" — describe the content instead.";
+const MESSAGE$38 = "`alt` text contains redundant words like \"image\" / \"photo\" / \"picture\" — describe the content instead.";
 const DEFAULT_COMPONENTS = ["img"];
 const DEFAULT_REDUNDANT_WORDS = [
 	"image",
@@ -6607,7 +7072,7 @@ const imgRedundantAlt = defineRule({
 			if (!altAttribute) return;
 			if (altValueRedundant(altAttribute, settings.words)) context.report({
 				node: altAttribute,
-				message: MESSAGE$37
+				message: MESSAGE$38
 			});
 		} };
 	}
@@ -6720,6 +7185,437 @@ const interactiveSupportsFocus = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/find-import-source-for-name.ts
+const collectFromProgram = (programRoot) => {
+	const lookup = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (node.type === "ImportDeclaration" && "source" in node && node.source) {
+			const source = node.source.value;
+			if (typeof source !== "string") return;
+			if ("specifiers" in node && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
+				if (!("local" in specifier) || !specifier.local) continue;
+				const local = specifier.local;
+				if (typeof local.name !== "string") continue;
+				if (specifier.type === "ImportDefaultSpecifier") lookup.set(local.name, {
+					source,
+					imported: null,
+					isDefault: true,
+					isNamespace: false
+				});
+				else if (specifier.type === "ImportNamespaceSpecifier") lookup.set(local.name, {
+					source,
+					imported: null,
+					isDefault: false,
+					isNamespace: true
+				});
+				else if (specifier.type === "ImportSpecifier") {
+					const importedNode = specifier.imported;
+					const importedName = importedNode?.name ?? (typeof importedNode?.value === "string" ? importedNode.value : null);
+					lookup.set(local.name, {
+						source,
+						imported: importedName,
+						isDefault: false,
+						isNamespace: false
+					});
+				}
+			}
+			return;
+		}
+		const nodeRecord = node;
+		for (const key of Object.keys(nodeRecord)) {
+			if (key === "parent") continue;
+			const child = nodeRecord[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+		}
+	};
+	visit(programRoot);
+	return lookup;
+};
+const importLookupCache = /* @__PURE__ */ new WeakMap();
+const getImportLookup = (node) => {
+	const programRoot = findProgramRoot(node);
+	if (!programRoot) return null;
+	let cached = importLookupCache.get(programRoot);
+	if (!cached) {
+		cached = collectFromProgram(programRoot);
+		importLookupCache.set(programRoot, cached);
+	}
+	return cached;
+};
+const isImportedFromModule = (contextNode, localIdentifierName, moduleSource) => {
+	const lookup = getImportLookup(contextNode);
+	if (!lookup) return false;
+	const info = lookup.get(localIdentifierName);
+	if (!info) return false;
+	return info.source === moduleSource;
+};
+const getImportedNameFromModule = (contextNode, localIdentifierName, moduleSource) => {
+	const lookup = getImportLookup(contextNode);
+	if (!lookup) return null;
+	const info = lookup.get(localIdentifierName);
+	if (!info) return null;
+	if (info.source !== moduleSource) return null;
+	return info.imported;
+};
+//#endregion
+//#region src/plugin/rules/jotai/jotai-derived-atom-returns-fresh-object.ts
+const isAtomFromJotai = (callExpression) => {
+	if (!isNodeOfType(callExpression.callee, "Identifier")) return false;
+	const localName = callExpression.callee.name;
+	if (!isImportedFromModule(callExpression, localName, "jotai")) return false;
+	return getImportedNameFromModule(callExpression, localName, "jotai") === "atom";
+};
+const isFunctionLike = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
+const getFirstParameterName = (fn) => {
+	const parameters = fn.params ?? [];
+	if (parameters.length !== 1) return null;
+	const first = parameters[0];
+	return isNodeOfType(first, "Identifier") ? first.name : null;
+};
+const FRESH_ARRAY_INSTANCE_METHODS = new Set([
+	"filter",
+	"map",
+	"flatMap",
+	"slice",
+	"concat",
+	"flat",
+	"toSorted",
+	"toReversed",
+	"toSpliced",
+	"with",
+	"sort",
+	"reverse"
+]);
+const FRESH_STATIC_OBJECT_CALLS = {
+	Object: new Set([
+		"keys",
+		"values",
+		"entries",
+		"fromEntries",
+		"assign",
+		"create"
+	]),
+	Array: new Set(["from", "of"])
+};
+const freshFromObjectLiteral = (expression) => {
+	if (isNodeOfType(expression, "ObjectExpression")) return {
+		kind: "object",
+		reportNode: expression
+	};
+	if (isNodeOfType(expression, "ArrayExpression")) return {
+		kind: "array",
+		reportNode: expression
+	};
+	return null;
+};
+const freshFromMethodChain = (expression) => {
+	if (!isNodeOfType(expression, "CallExpression")) return null;
+	const callee = expression.callee;
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	if (callee.computed) return null;
+	if (!isNodeOfType(callee.property, "Identifier")) return null;
+	const methodName = callee.property.name;
+	if (FRESH_ARRAY_INSTANCE_METHODS.has(methodName)) return {
+		kind: "array",
+		reportNode: expression
+	};
+	if (isNodeOfType(callee.object, "Identifier")) {
+		if (FRESH_STATIC_OBJECT_CALLS[callee.object.name]?.has(methodName)) return {
+			kind: callee.object.name === "Array" || methodName === "keys" || methodName === "values" || methodName === "entries" ? "array" : "object",
+			reportNode: expression
+		};
+	}
+	return null;
+};
+const classifyReturnedExpression = (expression) => {
+	if (!expression) return null;
+	const inner = stripParenExpression(expression);
+	const literalReturn = freshFromObjectLiteral(inner);
+	if (literalReturn) return literalReturn;
+	return freshFromMethodChain(inner);
+};
+const collectTopLevelReturnExpressions$1 = (block) => {
+	const returns = [];
+	walkAst(block, (child) => {
+		if (isNodeOfType(child, "FunctionDeclaration") || isNodeOfType(child, "FunctionExpression") || isNodeOfType(child, "ArrowFunctionExpression")) return false;
+		if (isNodeOfType(child, "ReturnStatement")) returns.push(child.argument);
+	});
+	return returns;
+};
+const getFreshReturnForFunction = (fn) => {
+	const body = fn.body;
+	if (!body) return null;
+	if (!isNodeOfType(body, "BlockStatement")) return classifyReturnedExpression(body);
+	const returnExpressions = collectTopLevelReturnExpressions$1(body);
+	if (returnExpressions.length === 0) return null;
+	let firstFresh = null;
+	for (const returnArgument of returnExpressions) {
+		const classification = classifyReturnedExpression(returnArgument);
+		if (!classification) return null;
+		if (!firstFresh) firstFresh = classification;
+	}
+	return firstFresh;
+};
+const functionBodyReferencesGetParameter = (fn, getParameterName) => {
+	const body = fn.body;
+	if (!body) return false;
+	let found = false;
+	walkAst(body, (child) => {
+		if (found) return false;
+		if (isNodeOfType(child, "FunctionDeclaration") || isNodeOfType(child, "FunctionExpression") || isNodeOfType(child, "ArrowFunctionExpression")) {
+			if (child !== fn) return false;
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!isNodeOfType(child.callee, "Identifier")) return;
+		if (child.callee.name === getParameterName) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+};
+const jotaiDerivedAtomReturnsFreshObject = defineRule({
+	id: "jotai-derived-atom-returns-fresh-object",
+	severity: "warn",
+	recommendation: "Split the derivation into multiple primitive derived atoms (each `Object.is`-dedupable), or wrap with `selectAtom(source, fn, shallow)` from jotai/utils if a wrapper object is required",
+	create: (context) => ({ CallExpression(node) {
+		if (!isAtomFromJotai(node)) return;
+		const args = node.arguments ?? [];
+		if (args.length === 0) return;
+		const reader = args[0];
+		if (!isFunctionLike(reader)) return;
+		const getParameterName = getFirstParameterName(reader);
+		if (!getParameterName) return;
+		const freshReturn = getFreshReturnForFunction(reader);
+		if (!freshReturn) return;
+		if (!functionBodyReferencesGetParameter(reader, getParameterName)) return;
+		const shape = freshReturn.kind === "object" ? "object" : "array";
+		context.report({
+			node: freshReturn.reportNode,
+			message: `Derived atom returns a fresh ${shape} — jotai compares with Object.is, so every upstream notify re-renders every consumer. Split into per-field derived atoms or use \`selectAtom(source, fn, shallow)\``
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/jotai/jotai-select-atom-in-render-body.ts
+const JOTAI_SELECT_ATOM_SOURCES = ["jotai/utils", "jotai"];
+const MEMOIZING_HOOK_NAMES = new Set(["useMemo", "useCallback"]);
+const COMPONENT_NAME_PATTERN = /^[A-Z]/;
+const HOOK_NAME_PATTERN = /^use[A-Z]/;
+const isFunctionLikeNode = (node) => isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
+const isImportedSelectAtom = (callExpression) => {
+	if (!isNodeOfType(callExpression.callee, "Identifier")) return false;
+	const localName = callExpression.callee.name;
+	for (const source of JOTAI_SELECT_ATOM_SOURCES) {
+		if (!isImportedFromModule(callExpression, localName, source)) continue;
+		if (getImportedNameFromModule(callExpression, localName, source) === "selectAtom") return true;
+	}
+	return false;
+};
+const isCallbackOfMemoizingHook = (functionNode) => {
+	const callParent = functionNode.parent;
+	if (!isNodeOfType(callParent, "CallExpression")) return false;
+	if (!isNodeOfType(callParent.callee, "Identifier")) return false;
+	if (!MEMOIZING_HOOK_NAMES.has(callParent.callee.name)) return false;
+	return callParent.arguments?.[0] === functionNode;
+};
+const containingFunctionIsComponentOrHook = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && functionNode.id) {
+		const declaredName = functionNode.id.name;
+		return COMPONENT_NAME_PATTERN.test(declaredName) || HOOK_NAME_PATTERN.test(declaredName);
+	}
+	let cursor = functionNode.parent ?? null;
+	while (cursor && isNodeOfType(cursor, "CallExpression")) cursor = cursor.parent ?? null;
+	if (!cursor) return false;
+	if (!isNodeOfType(cursor, "VariableDeclarator")) return false;
+	if (!isNodeOfType(cursor.id, "Identifier")) return false;
+	return COMPONENT_NAME_PATTERN.test(cursor.id.name) || HOOK_NAME_PATTERN.test(cursor.id.name);
+};
+const jotaiSelectAtomInRenderBody = defineRule({
+	id: "jotai-select-atom-in-render-body",
+	severity: "error",
+	recommendation: "Lift `selectAtom(base, fn)` to module scope, or wrap it: `const atom = useMemo(() => selectAtom(base, fn), [deps])`. Calling it in render rebuilds the derived atom every render and infinitely re-subscribes",
+	create: (context) => ({ CallExpression(node) {
+		if (!isImportedSelectAtom(node)) return;
+		let cursor = node.parent ?? null;
+		let nearestFunctionLike = null;
+		while (cursor) {
+			if (isFunctionLikeNode(cursor)) {
+				nearestFunctionLike = cursor;
+				break;
+			}
+			cursor = cursor.parent ?? null;
+		}
+		if (!nearestFunctionLike) return;
+		if (isCallbackOfMemoizingHook(nearestFunctionLike)) return;
+		let outerCursor = nearestFunctionLike;
+		while (outerCursor) {
+			if (isFunctionLikeNode(outerCursor) && containingFunctionIsComponentOrHook(outerCursor)) {
+				context.report({
+					node,
+					message: "`selectAtom(...)` called in a component / hook body without `useMemo` — every render builds a new derived atom and `useAtomValue` re-subscribes forever. Lift it to module scope or wrap with `useMemo(() => selectAtom(...), [deps])`"
+				});
+				return;
+			}
+			outerCursor = outerCursor.parent ?? null;
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/rules/jotai/jotai-tq-use-raw-query-atom.ts
+const QUERY_ATOM_FACTORY_IMPORTED_NAMES = new Set([
+	"atomWithQuery",
+	"atomWithSuspenseQuery",
+	"atomWithInfiniteQuery",
+	"atomWithSuspenseInfiniteQuery"
+]);
+const SUBSCRIBING_HOOK_NAMES = new Set(["useAtomValue", "useAtom"]);
+const QUERY_ATOM_NAMING_CONVENTION = /(SuspenseInfiniteQuery|SuspenseQuery|InfiniteQuery|Query)Atom$/;
+const jotaiTqUseRawQueryAtom = defineRule({
+	id: "jotai-tq-use-raw-query-atom",
+	severity: "warn",
+	recommendation: "Derive the field you read: `const dataAtom = atom((get) => get(queryAtom).data)`. Subscribing directly to a jotai-tanstack-query atom re-renders on every observer notify (refetches, focus events, no-op cache hits)",
+	create: (context) => {
+		const queryAtomFactoryLocalNames = /* @__PURE__ */ new Set();
+		const queryAtomBindingNames = /* @__PURE__ */ new Set();
+		return {
+			ImportDeclaration(node) {
+				const source = node.source?.value;
+				for (const specifier of node.specifiers ?? []) {
+					if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
+					if (!isNodeOfType(specifier.local, "Identifier")) continue;
+					const localName = specifier.local.name;
+					if (source === "jotai-tanstack-query") {
+						const importedName = getImportedName$1(specifier);
+						if (importedName && QUERY_ATOM_FACTORY_IMPORTED_NAMES.has(importedName)) queryAtomFactoryLocalNames.add(localName);
+						continue;
+					}
+					if (typeof source !== "string") continue;
+					if (source.startsWith("jotai") || source === "react" || source.startsWith("react/")) continue;
+					if (QUERY_ATOM_NAMING_CONVENTION.test(localName)) queryAtomBindingNames.add(localName);
+				}
+			},
+			VariableDeclarator(node) {
+				if (queryAtomFactoryLocalNames.size === 0) return;
+				if (!isNodeOfType(node.id, "Identifier")) return;
+				const initializer = node.init;
+				if (!isNodeOfType(initializer, "CallExpression")) return;
+				if (!isNodeOfType(initializer.callee, "Identifier")) return;
+				if (!queryAtomFactoryLocalNames.has(initializer.callee.name)) return;
+				queryAtomBindingNames.add(node.id.name);
+			},
+			CallExpression(node) {
+				if (queryAtomBindingNames.size === 0) return;
+				if (!isNodeOfType(node.callee, "Identifier")) return;
+				if (!SUBSCRIBING_HOOK_NAMES.has(node.callee.name)) return;
+				const args = node.arguments ?? [];
+				if (args.length === 0) return;
+				const firstArgument = args[0];
+				if (!isNodeOfType(firstArgument, "Identifier")) return;
+				if (!queryAtomBindingNames.has(firstArgument.name)) return;
+				context.report({
+					node,
+					message: `\`${node.callee.name}(${firstArgument.name})\` subscribes directly to a jotai-tanstack-query atom — every observer notify (refetch, focus, no-op cache hit) re-renders consumers. Derive the field first: \`const dataAtom = atom((get) => get(${firstArgument.name}).data)\``
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/js-performance/js-async-reduce-without-awaited-acc.ts
+const isAsyncFunctionLike$1 = (node) => {
+	if (!node) return false;
+	if (!isNodeOfType(node, "ArrowFunctionExpression") && !isNodeOfType(node, "FunctionExpression")) return false;
+	return node.async === true;
+};
+const classifyFirstParameter = (fn) => {
+	const parameters = fn.params ?? [];
+	if (parameters.length === 0) return null;
+	const first = parameters[0];
+	if (isNodeOfType(first, "Identifier")) return {
+		kind: "identifier",
+		name: first.name
+	};
+	if (isNodeOfType(first, "ArrayPattern") || isNodeOfType(first, "ObjectPattern")) return { kind: "destructured" };
+	if (isNodeOfType(first, "AssignmentPattern")) {
+		if (isNodeOfType(first.left, "Identifier")) return {
+			kind: "identifier",
+			name: first.left.name
+		};
+		if (isNodeOfType(first.left, "ArrayPattern") || isNodeOfType(first.left, "ObjectPattern")) return { kind: "destructured" };
+	}
+	return null;
+};
+const isReduceCallee = (callee) => {
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	if (!callee.computed) {
+		if (!isNodeOfType(callee.property, "Identifier")) return null;
+		if (callee.property.name !== "reduce" && callee.property.name !== "reduceRight") return null;
+		return { methodName: callee.property.name };
+	}
+	if (isNodeOfType(callee.property, "Literal") && typeof callee.property.value === "string") {
+		const propertyName = callee.property.value;
+		if (propertyName !== "reduce" && propertyName !== "reduceRight") return null;
+		return { methodName: propertyName };
+	}
+	return null;
+};
+const bodyAwaitsAccumulator = (fn, accumulatorName) => {
+	const body = fn.body;
+	if (!body) return false;
+	let awaitsAccumulator = false;
+	walkAst(body, (child) => {
+		if (awaitsAccumulator) return false;
+		if (isNodeOfType(child, "FunctionDeclaration") || isNodeOfType(child, "FunctionExpression") || isNodeOfType(child, "ArrowFunctionExpression")) {
+			if (child !== fn) return false;
+		}
+		if (!isNodeOfType(child, "AwaitExpression")) return;
+		if (!child.argument) return;
+		const awaitArgument = stripParenExpression(child.argument);
+		if (isNodeOfType(awaitArgument, "Identifier") && awaitArgument.name === accumulatorName) {
+			awaitsAccumulator = true;
+			return false;
+		}
+	});
+	return awaitsAccumulator;
+};
+const jsAsyncReduceWithoutAwaitedAcc = defineRule({
+	id: "js-async-reduce-without-awaited-acc",
+	severity: "warn",
+	recommendation: "Await the accumulator first: `const acc = await previous; ...; return acc;`. Use `Promise.resolve(initial)` as the seed so iteration 1's accumulator is also a Promise",
+	create: (context) => ({ CallExpression(node) {
+		const reduceMatch = isReduceCallee(node.callee);
+		if (!reduceMatch) return;
+		const args = node.arguments ?? [];
+		if (args.length === 0) return;
+		const reducerCandidate = stripParenExpression(args[0]);
+		if (!isAsyncFunctionLike$1(reducerCandidate)) return;
+		const reducer = reducerCandidate;
+		if (!containsDirectAwait(reducer.body)) return;
+		const firstParameter = classifyFirstParameter(reducer);
+		if (!firstParameter) return;
+		if (firstParameter.kind === "destructured") {
+			context.report({
+				node: reducer,
+				message: `Async \`.${reduceMatch.methodName}\` reducer destructures its accumulator — destructuring runs against the previous Promise (iteration 2+), produces undefined slots, and silently drops every iteration's work. Use \`async (previous, item) => { const [...] = await previous; ...; return [...]; }\` and seed with \`Promise.resolve([...])\``
+			});
+			return;
+		}
+		if (bodyAwaitsAccumulator(reducer, firstParameter.name)) return;
+		const previousParamName = [
+			"previous",
+			"prev",
+			"priorResult"
+		].find((candidate) => candidate !== firstParameter.name) ?? `${firstParameter.name}Prev`;
+		context.report({
+			node: reducer,
+			message: `Async \`.${reduceMatch.methodName}\` reducer never awaits its accumulator "${firstParameter.name}" — every iteration sees a Promise and the final result silently drops every iteration's work. Either reassign at the top (\`${firstParameter.name} = await ${firstParameter.name};\`) or restructure as \`async (${previousParamName}, item) => { const ${firstParameter.name} = await ${previousParamName}; ...; return ${firstParameter.name}; }\`, and seed with \`Promise.resolve(...)\``
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/js-performance/js-batch-dom-css.ts
 const ITERATOR_METHOD_NAMES$1 = new Set([
 	"forEach",
@@ -6743,7 +7639,7 @@ const isInsideLoopContext = (node) => {
 	let current = node.parent;
 	while (current) {
 		if (isNodeOfType(current, "ForStatement") || isNodeOfType(current, "ForInStatement") || isNodeOfType(current, "ForOfStatement") || isNodeOfType(current, "WhileStatement") || isNodeOfType(current, "DoWhileStatement")) return true;
-		if (isFunctionLike(current)) {
+		if (isFunctionLike$1(current)) {
 			if (isIteratorCallback(current)) return true;
 			return false;
 		}
@@ -7097,7 +7993,7 @@ const jsHoistIntl = defineRule({
 		let cursor = node.parent ?? null;
 		let inFunctionBody = false;
 		while (cursor) {
-			if (isFunctionLike(cursor)) {
+			if (isFunctionLike$1(cursor)) {
 				inFunctionBody = true;
 				const fnParent = cursor.parent;
 				if (fnParent && isNodeOfType(fnParent, "CallExpression") && fnParent.arguments?.[0] === cursor) {
@@ -8440,33 +9336,8 @@ const findVariableInitializer = (referenceNode, bindingName) => {
 	return best;
 };
 //#endregion
-//#region src/plugin/utils/strip-paren-expression.ts
-const TS_WRAPPER_TYPES = new Set([
-	"ParenthesizedExpression",
-	"TSAsExpression",
-	"TSSatisfiesExpression",
-	"TSTypeAssertion",
-	"TSNonNullExpression",
-	"TSInstantiationExpression"
-]);
-const stripParenExpression = (node) => {
-	let current = node;
-	while (true) {
-		if (TS_WRAPPER_TYPES.has(current.type) && "expression" in current && current.expression) {
-			current = current.expression;
-			continue;
-		}
-		if (isNodeOfType(current, "ChainExpression") && current.expression) {
-			current = current.expression;
-			continue;
-		}
-		break;
-	}
-	return current;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/jsx-max-depth.ts
-const buildMessage$16 = (depth, max) => `JSX nesting depth ${depth} exceeds maximum ${max}.`;
+const buildMessage$17 = (depth, max) => `JSX nesting depth ${depth} exceeds maximum ${max}.`;
 const DEFAULT_MAX_DEPTH = 14;
 const resolveSettings$30 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
@@ -8533,7 +9404,7 @@ const jsxMaxDepth = defineRule({
 			const total = computeJsxAncestorDepth(node) + computeChildrenDepth(node.children ?? [], /* @__PURE__ */ new Set());
 			if (total > max) context.report({
 				node,
-				message: buildMessage$16(total, max)
+				message: buildMessage$17(total, max)
 			});
 		};
 		return {
@@ -8548,7 +9419,7 @@ const jsxMaxDepth = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-comment-textnodes.ts
-const MESSAGE$36 = "Comment-like text in JSX must live inside `{/* … */}` — bare `//` or `/*` becomes literal text.";
+const MESSAGE$37 = "Comment-like text in JSX must live inside `{/* … */}` — bare `//` or `/*` becomes literal text.";
 const LITERAL_TEXT_TAGS = new Set([
 	"code",
 	"pre",
@@ -8583,7 +9454,7 @@ const jsxNoCommentTextnodes = defineRule({
 		if (isInsideLiteralTextTag(node)) return;
 		context.report({
 			node,
-			message: MESSAGE$36
+			message: MESSAGE$37
 		});
 	} })
 });
@@ -8605,7 +9476,7 @@ const isInsideFunctionScope = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-constructed-context-values.ts
-const MESSAGE$35 = "Context `value` prop is constructed inline — wrap with `useMemo`/`useCallback` or hoist a constant to avoid re-renders.";
+const MESSAGE$36 = "Context `value` prop is constructed inline — wrap with `useMemo`/`useCallback` or hoist a constant to avoid re-renders.";
 const isConstructedValue = (expression) => {
 	const stripped = stripParenExpression(expression);
 	if (isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "ArrayExpression") || isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "FunctionExpression") || isNodeOfType(stripped, "ClassExpression") || isNodeOfType(stripped, "NewExpression") || isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment")) return true;
@@ -8641,7 +9512,7 @@ const jsxNoConstructedContextValues = defineRule({
 				if (!isConstructedValue(innerExpression)) continue;
 				context.report({
 					node: attribute,
-					message: MESSAGE$35
+					message: MESSAGE$36
 				});
 			}
 		} };
@@ -8724,7 +9595,7 @@ const isJsxAttributeOnIntrinsicHtmlElement = (attribute) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-jsx-as-prop.ts
-const MESSAGE$34 = "JSX prop receives JSX created on every render — extract it or memoize to avoid re-renders.";
+const MESSAGE$35 = "JSX prop receives JSX created on every render — extract it or memoize to avoid re-renders.";
 const KNOWN_SLOT_PROP_NAMES = new Set([
 	"icon",
 	"Icon",
@@ -8992,7 +9863,7 @@ const jsxNoJsxAsProp = defineRule({
 				if (!isJsxProducingExpression(expressionNode) && !followsRenderLocalJsxBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$34
+					message: MESSAGE$35
 				});
 			}
 		};
@@ -9280,7 +10151,7 @@ const DATA_ARRAY_PROP_SUFFIXES = [
 ];
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-array-as-prop.ts
-const MESSAGE$33 = "JSX prop receives a new Array on every render — extract it or memoize to avoid re-renders.";
+const MESSAGE$34 = "JSX prop receives a new Array on every render — extract it or memoize to avoid re-renders.";
 const isDataArrayPropName = (propName) => {
 	if (DATA_ARRAY_PROP_NAMES.has(propName)) return true;
 	for (const suffix of DATA_ARRAY_PROP_SUFFIXES) if (propName.length > suffix.length && propName.endsWith(suffix)) return true;
@@ -9363,7 +10234,7 @@ const jsxNoNewArrayAsProp = defineRule({
 				if (!isArrayProducingExpression(expressionNode) && !followsRenderLocalArrayBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$33
+					message: MESSAGE$34
 				});
 			}
 		};
@@ -9621,7 +10492,7 @@ const SAFE_RECEIVER_NAMES = new Set([
 ]);
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-function-as-prop.ts
-const MESSAGE$32 = "JSX prop receives a new Function on every render — extract it or memoize (`useCallback`) to avoid re-renders.";
+const MESSAGE$33 = "JSX prop receives a new Function on every render — extract it or memoize (`useCallback`) to avoid re-renders.";
 const isAccessorPredicateName = (propName) => {
 	for (const prefix of ACCESSOR_PREDICATE_PREFIXES) {
 		if (propName.length <= prefix.length) continue;
@@ -9826,7 +10697,7 @@ const jsxNoNewFunctionAsProp = defineRule({
 				if (!isFunctionProducingExpression(expressionNode) && !followsRenderLocalFunctionBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$32
+					message: MESSAGE$33
 				});
 			}
 		};
@@ -10046,7 +10917,7 @@ const CONFIG_OBJECT_PROP_SUFFIXES = [
 ];
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-object-as-prop.ts
-const MESSAGE$31 = "JSX prop receives a new Object on every render — extract it or memoize to avoid re-renders.";
+const MESSAGE$32 = "JSX prop receives a new Object on every render — extract it or memoize to avoid re-renders.";
 const isConfigObjectPropName = (propName) => {
 	if (CONFIG_OBJECT_PROP_NAMES.has(propName)) return true;
 	for (const suffix of CONFIG_OBJECT_PROP_SUFFIXES) if (propName.length > suffix.length && propName.endsWith(suffix)) return true;
@@ -10133,7 +11004,7 @@ const jsxNoNewObjectAsProp = defineRule({
 				if (!isObjectProducingExpression(expressionNode) && !followsRenderLocalObjectBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$31
+					message: MESSAGE$32
 				});
 			}
 		};
@@ -10141,7 +11012,7 @@ const jsxNoNewObjectAsProp = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-script-url.ts
-const MESSAGE$30 = "React 19 disallows `javascript:` URLs as a security precaution — use an event handler instead.";
+const MESSAGE$31 = "React 19 disallows `javascript:` URLs as a security precaution — use an event handler instead.";
 const JAVASCRIPT_URL_PATTERN = /j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
 const resolveSettings$29 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
@@ -10181,7 +11052,7 @@ const jsxNoScriptUrl = defineRule({
 				if (!value || !isNodeOfType(value, "Literal") || typeof value.value !== "string") continue;
 				if (JAVASCRIPT_URL_PATTERN.test(value.value)) context.report({
 					node: attribute,
-					message: MESSAGE$30
+					message: MESSAGE$31
 				});
 			}
 		} };
@@ -10469,7 +11340,7 @@ const jsxNoTargetBlank = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-undef.ts
-const buildMessage$15 = (name) => `\`${name}\` is not defined in this scope.`;
+const buildMessage$16 = (name) => `\`${name}\` is not defined in this scope.`;
 const KNOWN_GLOBALS = new Set([
 	"globalThis",
 	"window",
@@ -10504,7 +11375,7 @@ const jsxNoUndef = defineRule({
 		if (findVariableInitializer(node, rootIdentifier)) return;
 		context.report({
 			node: node.name,
-			message: buildMessage$15(rootIdentifier)
+			message: buildMessage$16(rootIdentifier)
 		});
 	} })
 });
@@ -10603,7 +11474,7 @@ const jsxNoUselessFragment = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-pascal-case.ts
-const buildMessage$14 = (componentName, allowAllCaps) => allowAllCaps ? `JSX component \`${componentName}\` must be in PascalCase or SCREAMING_SNAKE_CASE.` : `JSX component \`${componentName}\` must be in PascalCase.`;
+const buildMessage$15 = (componentName, allowAllCaps) => allowAllCaps ? `JSX component \`${componentName}\` must be in PascalCase or SCREAMING_SNAKE_CASE.` : `JSX component \`${componentName}\` must be in PascalCase.`;
 const resolveSettings$26 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxPascalCase ?? {} : {};
@@ -10719,7 +11590,7 @@ const jsxPascalCase = defineRule({
 				if (!isPascal && !isAllCaps) {
 					context.report({
 						node,
-						message: buildMessage$14(segment, settings.allowAllCaps)
+						message: buildMessage$15(segment, settings.allowAllCaps)
 					});
 					return;
 				}
@@ -10771,7 +11642,7 @@ const jsxPropsNoSpreadMulti = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-props-no-spreading.ts
-const MESSAGE$29 = "JSX prop spreading is forbidden — list each prop explicitly.";
+const MESSAGE$30 = "JSX prop spreading is forbidden — list each prop explicitly.";
 const resolveSettings$25 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxPropsNoSpreading ?? {} : {};
@@ -10811,7 +11682,7 @@ const jsxPropsNoSpreading = defineRule({
 				}
 				context.report({
 					node: attribute,
-					message: MESSAGE$29
+					message: MESSAGE$30
 				});
 			}
 		} };
@@ -10966,7 +11837,7 @@ const labelHasAssociatedControl = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/lang.ts
-const MESSAGE$28 = "`<html lang>` value must be a valid IANA / BCP-47 language tag (e.g. `en`, `en-US`).";
+const MESSAGE$29 = "`<html lang>` value must be a valid IANA / BCP-47 language tag (e.g. `en`, `en-US`).";
 const COMMON_LANGUAGE_PRIMARY_TAGS = new Set([
 	"aa",
 	"ab",
@@ -11177,7 +12048,7 @@ const lang = defineRule({
 			if (expression.type === "Identifier" && expression.name === "undefined" || expression.type === "Literal" && expression.value === null) {
 				context.report({
 					node: langAttr,
-					message: MESSAGE$28
+					message: MESSAGE$29
 				});
 				return;
 			}
@@ -11186,13 +12057,13 @@ const lang = defineRule({
 		if (value === null) return;
 		if (!isValidLangTag(value)) context.report({
 			node: langAttr,
-			message: MESSAGE$28
+			message: MESSAGE$29
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/a11y/media-has-caption.ts
-const MESSAGE$27 = "`<audio>` / `<video>` must have a `<track kind=\"captions\">` child for users who can't hear audio.";
+const MESSAGE$28 = "`<audio>` / `<video>` must have a `<track kind=\"captions\">` child for users who can't hear audio.";
 const DEFAULT_AUDIO = ["audio"];
 const DEFAULT_VIDEO = ["video"];
 const DEFAULT_TRACK = ["track"];
@@ -11232,7 +12103,7 @@ const mediaHasCaption = defineRule({
 			if (!parent || !isNodeOfType(parent, "JSXElement")) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$27
+					message: MESSAGE$28
 				});
 				return;
 			}
@@ -11249,7 +12120,7 @@ const mediaHasCaption = defineRule({
 				return kindValue.value.toLowerCase() === "captions";
 			})) context.report({
 				node: node.name,
-				message: MESSAGE$27
+				message: MESSAGE$28
 			});
 		} };
 	}
@@ -11940,7 +12811,7 @@ const collectChainedGetHandlerBodies = (initNode) => {
 };
 const resolveBodiesFromExpression = (expression, resolveBinding, remainingDepth) => {
 	if (remainingDepth <= 0) return [];
-	if (isFunctionLike(expression)) return expression.body ? [expression.body] : [];
+	if (isFunctionLike$1(expression)) return expression.body ? [expression.body] : [];
 	if (isNodeOfType(expression, "CallExpression")) {
 		for (const callArgument of expression.arguments ?? []) {
 			if (isNodeOfType(callArgument, "ArrowFunctionExpression") || isNodeOfType(callArgument, "FunctionExpression")) {
@@ -12020,14 +12891,6 @@ const nextjsNoSideEffectInGetHandler = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-imported-name.ts
-const getImportedName = (importSpecifier) => {
-	if (!isNodeOfType(importSpecifier, "ImportSpecifier")) return void 0;
-	const imported = importSpecifier.imported;
-	if (isNodeOfType(imported, "Identifier")) return imported.name;
-	if (isNodeOfType(imported, "Literal") && typeof imported.value === "string") return imported.value;
-};
-//#endregion
 //#region src/plugin/rules/nextjs/nextjs-no-use-search-params-without-suspense.ts
 const fileMentionsSuspense = (programNode) => {
 	let didSee = false;
@@ -12038,7 +12901,7 @@ const fileMentionsSuspense = (programNode) => {
 			return false;
 		}
 		if (isNodeOfType(child, "ImportDeclaration") && child.source?.value === "react") {
-			if ((child.specifiers ?? []).some((specifier) => isNodeOfType(specifier, "ImportSpecifier") && getImportedName(specifier) === "Suspense")) {
+			if ((child.specifiers ?? []).some((specifier) => isNodeOfType(specifier, "ImportSpecifier") && getImportedName$1(specifier) === "Suspense")) {
 				didSee = true;
 				return false;
 			}
@@ -12071,7 +12934,7 @@ const nextjsNoUseSearchParamsWithoutSuspense = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-access-key.ts
-const MESSAGE$26 = "`accessKey` should not be used — accessKeys conflict with screen reader and OS-level shortcuts.";
+const MESSAGE$27 = "`accessKey` should not be used — accessKeys conflict with screen reader and OS-level shortcuts.";
 const isUndefinedIdentifier = (expression) => isNodeOfType(expression, "Identifier") && expression.name === "undefined";
 const noAccessKey = defineRule({
 	id: "no-access-key",
@@ -12087,7 +12950,7 @@ const noAccessKey = defineRule({
 		if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") {
 			context.report({
 				node: accessKey,
-				message: MESSAGE$26
+				message: MESSAGE$27
 			});
 			return;
 		}
@@ -12097,7 +12960,7 @@ const noAccessKey = defineRule({
 			if (isUndefinedIdentifier(expression)) return;
 			context.report({
 				node: accessKey,
-				message: MESSAGE$26
+				message: MESSAGE$27
 			});
 		}
 	} })
@@ -12406,7 +13269,7 @@ const getEffectFn = (analysis, node) => {
 	if (isNodeOfType(fn, "ArrowFunctionExpression") || isNodeOfType(fn, "FunctionExpression")) return fn;
 	if (isNodeOfType(fn, "Identifier")) {
 		const definitionNode = getRef(analysis, fn)?.resolved?.defs[0]?.node;
-		if (definitionNode && isFunctionLike(definitionNode)) return definitionNode;
+		if (definitionNode && isFunctionLike$1(definitionNode)) return definitionNode;
 		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
 			const initializer = definitionNode.init;
 			if (isNodeOfType(initializer, "ArrowFunctionExpression") || isNodeOfType(initializer, "FunctionExpression")) return initializer;
@@ -12499,14 +13362,14 @@ const getUseStateDecl = (analysis, ref) => {
 	return node ?? null;
 };
 const isCleanupReturnArgument = (analysis, node) => {
-	if (isFunctionLike(node)) return true;
+	if (isFunctionLike$1(node)) return true;
 	if (isNodeOfType(node, "MemberExpression")) return true;
 	if (isNodeOfType(node, "Identifier")) {
 		const definitionNode = getRef(analysis, node)?.resolved?.defs[0]?.node;
-		if (definitionNode && isFunctionLike(definitionNode)) return true;
+		if (definitionNode && isFunctionLike$1(definitionNode)) return true;
 		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
 			const initializer = definitionNode.init;
-			return isFunctionLike(initializer);
+			return isFunctionLike$1(initializer);
 		}
 	}
 	if (isNodeOfType(node, "ConditionalExpression")) return isCleanupReturnArgument(analysis, node.consequent) || isCleanupReturnArgument(analysis, node.alternate);
@@ -12516,7 +13379,7 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 	if (visited.has(node)) return false;
 	visited.add(node);
 	if (isNodeOfType(node, "ReturnStatement") && node.argument != null) return isCleanupReturnArgument(analysis, node.argument);
-	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike(node)) return false;
+	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$1(node)) return false;
 	const record = node;
 	for (const [key, value] of Object.entries(record)) {
 		if (key === "parent") continue;
@@ -12528,7 +13391,7 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 };
 const hasCleanup = (analysis, node) => {
 	const fn = getEffectFn(analysis, node);
-	if (!isFunctionLike(fn)) return false;
+	if (!isFunctionLike$1(fn)) return false;
 	if (!isNodeOfType(fn.body, "BlockStatement")) return false;
 	return hasCleanupReturn(analysis, fn.body);
 };
@@ -12570,7 +13433,7 @@ const noAdjustStateOnPropChange = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-aria-hidden-on-focusable.ts
-const MESSAGE$25 = "Focusable elements must not have `aria-hidden=\"true\"` — focus would skip the hidden subtree, confusing keyboard users.";
+const MESSAGE$26 = "Focusable elements must not have `aria-hidden=\"true\"` — focus would skip the hidden subtree, confusing keyboard users.";
 const noAriaHiddenOnFocusable = defineRule({
 	id: "no-aria-hidden-on-focusable",
 	tags: ["react-jsx-only"],
@@ -12596,7 +13459,7 @@ const noAriaHiddenOnFocusable = defineRule({
 		const isImplicitlyFocusable = isInteractiveElement(tag, node);
 		if (isExplicitlyFocusable || isImplicitlyFocusable) context.report({
 			node: ariaHidden,
-			message: MESSAGE$25
+			message: MESSAGE$26
 		});
 	} })
 });
@@ -12876,7 +13739,7 @@ const isInsideStaticPlaceholderMap = (node) => {
 	let current = node;
 	while (current.parent) {
 		const parent = current.parent;
-		if (isFunctionLike(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+		if (isFunctionLike$1(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
 			const callee = parent.callee;
 			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach")) return isStaticPlaceholderReceiver(callee.object);
 			if (isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current) return isArrayFromLengthObjectCall(parent);
@@ -12895,7 +13758,7 @@ const findIteratorItemName$1 = (node) => {
 	let current = node;
 	while (current.parent) {
 		const parent = current.parent;
-		if (isFunctionLike(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+		if (isFunctionLike$1(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
 			const callee = parent.callee;
 			const isIteratorMethodCall = isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach");
 			const isArrayFromCallback = isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current;
@@ -12963,7 +13826,7 @@ const noArrayIndexAsKey = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-array-index-key.ts
-const MESSAGE$24 = "Array index in `key` doesn't uniquely identify the element — re-renders may use stale state.";
+const MESSAGE$25 = "Array index in `key` doesn't uniquely identify the element — re-renders may use stale state.";
 const SECOND_INDEX_METHODS = new Set([
 	"every",
 	"filter",
@@ -13165,7 +14028,7 @@ const noArrayIndexKey = defineRule({
 			}
 			context.report({
 				node: keyAttribute,
-				message: MESSAGE$24
+				message: MESSAGE$25
 			});
 		},
 		CallExpression(node) {
@@ -13185,7 +14048,7 @@ const noArrayIndexKey = defineRule({
 				if (propName !== "key") continue;
 				if (expressionUsesIndex(property.value, indexBinding.name)) context.report({
 					node: property,
-					message: MESSAGE$24
+					message: MESSAGE$25
 				});
 			}
 		}
@@ -13193,7 +14056,7 @@ const noArrayIndexKey = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-autofocus.ts
-const MESSAGE$23 = "`autoFocus` should not be used — it disrupts users who expect the page focus to remain at the top of the document on load.";
+const MESSAGE$24 = "`autoFocus` should not be used — it disrupts users who expect the page focus to remain at the top of the document on load.";
 const resolveSettings$21 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { ignoreNonDOM: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noAutofocus ?? {} : {}).ignoreNonDOM ?? true };
@@ -13248,7 +14111,7 @@ const noAutofocus = defineRule({
 			}
 			context.report({
 				node: autoFocusAttribute,
-				message: MESSAGE$23
+				message: MESSAGE$24
 			});
 		} };
 	}
@@ -13739,7 +14602,7 @@ const noChainStateUpdates = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-children-prop.ts
-const MESSAGE$22 = "Avoid passing children using a `children` prop — nest them between the JSX tags or pass them as additional `React.createElement` arguments instead.";
+const MESSAGE$23 = "Avoid passing children using a `children` prop — nest them between the JSX tags or pass them as additional `React.createElement` arguments instead.";
 const noChildrenProp = defineRule({
 	id: "no-children-prop",
 	severity: "warn",
@@ -13750,7 +14613,7 @@ const noChildrenProp = defineRule({
 			if (node.name.name !== "children") return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$22
+				message: MESSAGE$23
 			});
 		},
 		CallExpression(node) {
@@ -13763,90 +14626,15 @@ const noChildrenProp = defineRule({
 				const propertyKey = property.key;
 				if (isNodeOfType(propertyKey, "Identifier") && propertyKey.name === "children" || isNodeOfType(propertyKey, "Literal") && propertyKey.value === "children") context.report({
 					node: propertyKey,
-					message: MESSAGE$22
+					message: MESSAGE$23
 				});
 			}
 		}
 	})
 });
 //#endregion
-//#region src/plugin/utils/find-import-source-for-name.ts
-const collectFromProgram = (programRoot) => {
-	const lookup = /* @__PURE__ */ new Map();
-	const visit = (node) => {
-		if (node.type === "ImportDeclaration" && "source" in node && node.source) {
-			const source = node.source.value;
-			if (typeof source !== "string") return;
-			if ("specifiers" in node && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
-				if (!("local" in specifier) || !specifier.local) continue;
-				const local = specifier.local;
-				if (typeof local.name !== "string") continue;
-				if (specifier.type === "ImportDefaultSpecifier") lookup.set(local.name, {
-					source,
-					imported: null,
-					isDefault: true,
-					isNamespace: false
-				});
-				else if (specifier.type === "ImportNamespaceSpecifier") lookup.set(local.name, {
-					source,
-					imported: null,
-					isDefault: false,
-					isNamespace: true
-				});
-				else if (specifier.type === "ImportSpecifier") {
-					const importedNode = specifier.imported;
-					const importedName = importedNode?.name ?? (typeof importedNode?.value === "string" ? importedNode.value : null);
-					lookup.set(local.name, {
-						source,
-						imported: importedName,
-						isDefault: false,
-						isNamespace: false
-					});
-				}
-			}
-			return;
-		}
-		const nodeRecord = node;
-		for (const key of Object.keys(nodeRecord)) {
-			if (key === "parent") continue;
-			const child = nodeRecord[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-		}
-	};
-	visit(programRoot);
-	return lookup;
-};
-const importLookupCache = /* @__PURE__ */ new WeakMap();
-const getImportLookup = (node) => {
-	const programRoot = findProgramRoot(node);
-	if (!programRoot) return null;
-	let cached = importLookupCache.get(programRoot);
-	if (!cached) {
-		cached = collectFromProgram(programRoot);
-		importLookupCache.set(programRoot, cached);
-	}
-	return cached;
-};
-const isImportedFromModule = (contextNode, localIdentifierName, moduleSource) => {
-	const lookup = getImportLookup(contextNode);
-	if (!lookup) return false;
-	const info = lookup.get(localIdentifierName);
-	if (!info) return false;
-	return info.source === moduleSource;
-};
-const getImportedNameFromModule = (contextNode, localIdentifierName, moduleSource) => {
-	const lookup = getImportLookup(contextNode);
-	if (!lookup) return null;
-	const info = lookup.get(localIdentifierName);
-	if (!info) return null;
-	if (info.source !== moduleSource) return null;
-	return info.imported;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/no-clone-element.ts
-const MESSAGE$21 = "`React.cloneElement` is uncommon and leads to fragile components.";
+const MESSAGE$22 = "`React.cloneElement` is uncommon and leads to fragile components.";
 const noCloneElement = defineRule({
 	id: "no-clone-element",
 	severity: "warn",
@@ -13858,7 +14646,7 @@ const noCloneElement = defineRule({
 		if (isNodeOfType(callee, "Identifier") && callee.name === "cloneElement") {
 			if (isImportedFromModule(node, "cloneElement", "react")) context.report({
 				node: callee,
-				message: MESSAGE$21
+				message: MESSAGE$22
 			});
 			return;
 		}
@@ -13871,14 +14659,14 @@ const noCloneElement = defineRule({
 			if (!isImportedFromModule(node, callee.object.name, "react")) return;
 			context.report({
 				node: callee,
-				message: MESSAGE$21
+				message: MESSAGE$22
 			});
 		}
 	} })
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-danger.ts
-const MESSAGE$20 = "Do not use `dangerouslySetInnerHTML` — it injects raw HTML and is a common XSS vector.";
+const MESSAGE$21 = "Do not use `dangerouslySetInnerHTML` — it injects raw HTML and is a common XSS vector.";
 const noDanger = defineRule({
 	id: "no-danger",
 	severity: "warn",
@@ -13889,7 +14677,7 @@ const noDanger = defineRule({
 			if (!propAttribute) return;
 			context.report({
 				node: propAttribute.name,
-				message: MESSAGE$20
+				message: MESSAGE$21
 			});
 		},
 		CallExpression(node) {
@@ -13901,7 +14689,7 @@ const noDanger = defineRule({
 				const propertyKey = property.key;
 				if (isNodeOfType(propertyKey, "Identifier") && propertyKey.name === "dangerouslySetInnerHTML" || isNodeOfType(propertyKey, "Literal") && propertyKey.value === "dangerouslySetInnerHTML") context.report({
 					node: propertyKey,
-					message: MESSAGE$20
+					message: MESSAGE$21
 				});
 			}
 		}
@@ -13909,7 +14697,7 @@ const noDanger = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-danger-with-children.ts
-const MESSAGE$19 = "Only set one of `children` or `dangerouslySetInnerHTML` — React throws a runtime warning when both are present.";
+const MESSAGE$20 = "Only set one of `children` or `dangerouslySetInnerHTML` — React throws a runtime warning when both are present.";
 const isLineBreak = (child) => {
 	if (!isNodeOfType(child, "JSXText")) return false;
 	return child.value.trim().length === 0 && child.value.includes("\n");
@@ -13978,7 +14766,7 @@ const noDangerWithChildren = defineRule({
 			if (!hasChildrenProp && !hasNestedChildren) return;
 			if (hasJsxPropIgnoreCase(opening.attributes, "dangerouslySetInnerHTML") || spreadPropsShape.hasDangerously) context.report({
 				node: opening,
-				message: MESSAGE$19
+				message: MESSAGE$20
 			});
 		},
 		CallExpression(node) {
@@ -13990,7 +14778,7 @@ const noDangerWithChildren = defineRule({
 			if (!propsShape.hasDangerously) return;
 			if (node.arguments.length >= 3 || propsShape.hasChildren) context.report({
 				node,
-				message: MESSAGE$19
+				message: MESSAGE$20
 			});
 		}
 	})
@@ -14365,7 +15153,7 @@ const extractDestructuredPropNames = (params) => {
 };
 const getInlineFunctionNode = (node) => {
 	if (!node) return null;
-	if (isFunctionLike(node)) return node;
+	if (isFunctionLike$1(node)) return node;
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	for (const argument of node.arguments ?? []) {
 		const inlineFunctionNode = getInlineFunctionNode(argument);
@@ -14376,7 +15164,7 @@ const getInlineFunctionNode = (node) => {
 const getNearestComponentFunction = (node) => {
 	let cursor = node.parent ?? null;
 	while (cursor) {
-		if (isFunctionLike(cursor)) return cursor;
+		if (isFunctionLike$1(cursor)) return cursor;
 		cursor = cursor.parent ?? null;
 	}
 	return null;
@@ -14557,7 +15345,7 @@ const isSetStateCallInLifecycle = (setStateCall, lifecycleNames, options = {}) =
 //#endregion
 //#region src/plugin/rules/react-builtins/no-did-mount-set-state.ts
 const LIFECYCLE_NAMES$2 = new Set(["componentDidMount"]);
-const MESSAGE$18 = "Do not use `this.setState` in `componentDidMount`.";
+const MESSAGE$19 = "Do not use `this.setState` in `componentDidMount`.";
 const resolveSettings$20 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { mode: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noDidMountSetState ?? {} : {}).mode ?? "allowed" };
@@ -14575,7 +15363,7 @@ const noDidMountSetState = defineRule({
 			if (!isSetStateCallInLifecycle(node, LIFECYCLE_NAMES$2, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			context.report({
 				node: node.callee,
-				message: MESSAGE$18
+				message: MESSAGE$19
 			});
 		} };
 	}
@@ -14583,7 +15371,7 @@ const noDidMountSetState = defineRule({
 //#endregion
 //#region src/plugin/rules/react-builtins/no-did-update-set-state.ts
 const LIFECYCLE_NAMES$1 = new Set(["componentDidUpdate"]);
-const MESSAGE$17 = "Do not use `this.setState` in `componentDidUpdate` — it can cause infinite loops.";
+const MESSAGE$18 = "Do not use `this.setState` in `componentDidUpdate` — it can cause infinite loops.";
 const resolveSettings$19 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { mode: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noDidUpdateSetState ?? {} : {}).mode ?? "allowed" };
@@ -14601,7 +15389,7 @@ const noDidUpdateSetState = defineRule({
 			if (!isSetStateCallInLifecycle(node, LIFECYCLE_NAMES$1, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			context.report({
 				node: node.callee,
-				message: MESSAGE$17
+				message: MESSAGE$18
 			});
 		} };
 	}
@@ -14624,7 +15412,7 @@ const isStateMemberExpression = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/no-direct-mutation-state.ts
-const MESSAGE$16 = "Never mutate `this.state` directly.";
+const MESSAGE$17 = "Never mutate `this.state` directly.";
 const shouldIgnoreMutation = (node) => {
 	let isConstructor = false;
 	let isInsideCallExpression = false;
@@ -14646,7 +15434,7 @@ const reportIfStateMutation = (context, reportNode, target) => {
 	if (shouldIgnoreMutation(reportNode)) return;
 	context.report({
 		node: reportNode,
-		message: MESSAGE$16
+		message: MESSAGE$17
 	});
 };
 const noDirectMutationState = defineRule({
@@ -14702,7 +15490,7 @@ const collectFunctionLocalBindings = (functionNode) => {
 const walkComponentRespectingShadows = (node, shadowedStateNames, visit) => {
 	if (!node || typeof node !== "object") return;
 	let nextShadowedStateNames = shadowedStateNames;
-	if (isFunctionLike(node)) {
+	if (isFunctionLike$1(node)) {
 		const localBindings = collectFunctionLocalBindings(node);
 		if (localBindings.size > 0) {
 			const merged = new Set(shadowedStateNames);
@@ -14809,7 +15597,7 @@ const noDisabledZoom = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-distracting-elements.ts
-const buildMessage$13 = (tag) => `\`<${tag}>\` is distracting and should not be used — replace with semantic, accessible markup.`;
+const buildMessage$14 = (tag) => `\`<${tag}>\` is distracting and should not be used — replace with semantic, accessible markup.`;
 const DEFAULT_DISTRACTING = ["marquee", "blink"];
 const resolveSettings$18 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
@@ -14829,7 +15617,7 @@ const noDistractingElements = defineRule({
 			const tag = getElementType(node, context.settings);
 			if (distractingTags.has(tag)) context.report({
 				node: node.name,
-				message: buildMessage$13(tag)
+				message: buildMessage$14(tag)
 			});
 		} };
 	}
@@ -16159,7 +16947,7 @@ const ALLOWED_NAMESPACES = new Set([
 	"ReactDOM",
 	"ReactDom"
 ]);
-const MESSAGE$15 = "Unexpected call to `findDOMNode` — removed in React 19.";
+const MESSAGE$16 = "Unexpected call to `findDOMNode` — removed in React 19.";
 const noFindDomNode = defineRule({
 	id: "no-find-dom-node",
 	severity: "warn",
@@ -16169,7 +16957,7 @@ const noFindDomNode = defineRule({
 		if (isNodeOfType(callee, "Identifier") && callee.name === "findDOMNode") {
 			context.report({
 				node: callee,
-				message: MESSAGE$15
+				message: MESSAGE$16
 			});
 			return;
 		}
@@ -16180,7 +16968,7 @@ const noFindDomNode = defineRule({
 			if (callee.property.name !== "findDOMNode") return;
 			context.report({
 				node: callee.property,
-				message: MESSAGE$15
+				message: MESSAGE$16
 			});
 		}
 	} })
@@ -16197,7 +16985,7 @@ const noFlushSync = defineRule({
 		if (node.source?.value !== "react-dom") return;
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-			if (getImportedName(specifier) === "flushSync") context.report({
+			if (getImportedName$1(specifier) === "flushSync") context.report({
 				node: specifier,
 				message: "flushSync from react-dom skips View Transition snapshots and concurrent rendering — prefer startTransition for non-urgent updates"
 			});
@@ -16239,6 +17027,64 @@ const noGenericHandlerNames = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/function-contains-react-render-output.ts
+const NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression",
+	"ClassDeclaration",
+	"ClassExpression"
+]);
+const isReactImport$1 = (symbol) => {
+	let importDeclaration = symbol.declarationNode?.parent;
+	while (importDeclaration && !isNodeOfType(importDeclaration, "ImportDeclaration")) importDeclaration = importDeclaration.parent ?? null;
+	if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return false;
+	return importDeclaration.source.value === "react";
+};
+const getImportedName = (symbol) => {
+	if (symbol.kind !== "import") return null;
+	if (!isReactImport$1(symbol)) return null;
+	return getImportedName$1(symbol.declarationNode) ?? null;
+};
+const isReactNamespaceImport = (symbol) => {
+	if (symbol.kind !== "import") return false;
+	if (!isReactImport$1(symbol)) return false;
+	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier");
+};
+const isReactCreateElementIdentifierCall = (callee, scopes) => {
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const symbol = scopes.symbolFor(callee);
+	return Boolean(symbol && getImportedName(symbol) === "createElement");
+};
+const isReactCreateElementMemberCall = (callee, scopes) => {
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	if (callee.computed) return false;
+	if (!isNodeOfType(callee.object, "Identifier")) return false;
+	if (!isNodeOfType(callee.property, "Identifier")) return false;
+	if (callee.property.name !== "createElement") return false;
+	const symbol = scopes.symbolFor(callee.object);
+	return Boolean(symbol && isReactNamespaceImport(symbol));
+};
+const isReactCreateElementCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	return isReactCreateElementIdentifierCall(node.callee, scopes) || isReactCreateElementMemberCall(node.callee, scopes);
+};
+const containsRenderOutput = (node, rootNode, scopes) => {
+	if (node !== rootNode && NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type)) return false;
+	if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
+	if (isReactCreateElementCall(node, scopes)) return true;
+	const nodeRecord = node;
+	for (const key of Object.keys(nodeRecord)) {
+		if (key === "parent") continue;
+		const child = nodeRecord[key];
+		if (Array.isArray(child)) {
+			for (const innerChild of child) if (isAstNode(innerChild) && containsRenderOutput(innerChild, rootNode, scopes)) return true;
+		} else if (isAstNode(child) && containsRenderOutput(child, rootNode, scopes)) return true;
+	}
+	return false;
+};
+const functionContainsReactRenderOutput = (functionNode, scopes) => containsRenderOutput(functionNode, functionNode, scopes);
+//#endregion
 //#region src/plugin/rules/architecture/no-giant-component.ts
 const noGiantComponent = defineRule({
 	id: "no-giant-component",
@@ -16246,10 +17092,13 @@ const noGiantComponent = defineRule({
 	tags: ["test-noise", "react-jsx-only"],
 	recommendation: "Extract logical sections into focused components: `<UserHeader />`, `<UserActions />`, etc.",
 	create: (context) => {
-		const reportOversizedComponent = (nameNode, componentName, bodyNode) => {
-			if (!bodyNode.loc) return;
+		const getOversizedComponentLineCount = (bodyNode) => {
+			if (!bodyNode.loc) return null;
 			const lineCount = bodyNode.loc.end.line - bodyNode.loc.start.line + 1;
-			if (lineCount > 300) context.report({
+			return lineCount > 300 ? lineCount : null;
+		};
+		const reportOversizedComponent = (nameNode, componentName, lineCount) => {
+			context.report({
 				node: nameNode,
 				message: `Component "${componentName}" is ${lineCount} lines — consider breaking it into smaller focused components`
 			});
@@ -16257,12 +17106,18 @@ const noGiantComponent = defineRule({
 		return {
 			FunctionDeclaration(node) {
 				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
-				reportOversizedComponent(node.id, node.id.name, node);
+				const lineCount = getOversizedComponentLineCount(node);
+				if (lineCount === null) return;
+				if (!functionContainsReactRenderOutput(node, context.scopes)) return;
+				reportOversizedComponent(node.id, node.id.name, lineCount);
 			},
 			VariableDeclarator(node) {
 				if (!isComponentAssignment(node)) return;
 				if (!isNodeOfType(node.id, "Identifier") || !node.init) return;
-				reportOversizedComponent(node.id, node.id.name, node.init);
+				const lineCount = getOversizedComponentLineCount(node.init);
+				if (lineCount === null) return;
+				if (!functionContainsReactRenderOutput(node.init, context.scopes)) return;
+				reportOversizedComponent(node.id, node.id.name, lineCount);
 			}
 		};
 	}
@@ -16603,7 +17458,7 @@ const noInlinePropOnMemoComponent = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-interactive-element-to-noninteractive-role.ts
-const buildMessage$12 = (tag, role) => `Interactive element \`<${tag}>\` cannot have non-interactive role \`${role}\`.`;
+const buildMessage$13 = (tag, role) => `Interactive element \`<${tag}>\` cannot have non-interactive role \`${role}\`.`;
 const PRESENTATION_ROLES = ["presentation", "none"];
 const DEFAULT_ALLOWED_ROLES$1 = {
 	tr: ["none", "presentation"],
@@ -16647,7 +17502,7 @@ const noInteractiveElementToNoninteractiveRole = defineRule({
 			if (!isNonInteractiveRole(firstRole) && !PRESENTATION_ROLES.includes(firstRole)) return;
 			context.report({
 				node: roleAttribute,
-				message: buildMessage$12(elementType, firstRole)
+				message: buildMessage$13(elementType, firstRole)
 			});
 		} };
 	}
@@ -16848,7 +17703,7 @@ const isInsideClassBody = (node) => {
 	let current = node.parent;
 	while (current) {
 		if (isNodeOfType(current, "ClassBody")) return true;
-		if (isFunctionLike(current)) return false;
+		if (isFunctionLike$1(current)) return false;
 		current = current.parent;
 	}
 	return false;
@@ -17091,7 +17946,7 @@ const noMoment = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-multi-comp.ts
-const buildMessage$11 = (componentName) => `Declare only one React component per file. Found extra component: ${componentName}.`;
+const buildMessage$12 = (componentName) => `Declare only one React component per file. Found extra component: ${componentName}.`;
 const resolveSettings$16 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { ignoreStateless: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noMultiComp ?? {} : {}).ignoreStateless ?? false };
@@ -17412,7 +18267,7 @@ const noMultiComp = defineRule({
 			if (isSmallFeatureModule || isLargeFeatureModule || isVeryLargeFeatureModule) return;
 			for (const component of flagged.slice(1)) context.report({
 				node: component.reportNode,
-				message: buildMessage$11(component.name)
+				message: buildMessage$12(component.name)
 			});
 		} };
 	}
@@ -17490,7 +18345,7 @@ const noMutableInDeps = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-mutating-reducer-state.ts
-const MESSAGE$14 = "Reducer mutates its current state and returns the same reference. Return a copied object or array so React can observe the update.";
+const MESSAGE$15 = "Reducer mutates its current state and returns the same reference. Return a copied object or array so React can observe the update.";
 const MUTATING_ARRAY_METHODS = new Set([
 	"copyWithin",
 	"fill",
@@ -17687,7 +18542,7 @@ const analyzeReactUseReducerFunctionForStateMutation = (context, functionNode, r
 			reportedNodes.add(mutation.node);
 			context.report({
 				node: mutation.node,
-				message: MESSAGE$14
+				message: MESSAGE$15
 			});
 		}
 	};
@@ -17773,7 +18628,7 @@ const noMutatingReducerState = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-namespace.ts
-const buildMessage$10 = (componentName) => `React component \`${componentName}\` must not be in a namespace — React doesn't support them.`;
+const buildMessage$11 = (componentName) => `React component \`${componentName}\` must not be in a namespace — React doesn't support them.`;
 const noNamespace = defineRule({
 	id: "no-namespace",
 	severity: "warn",
@@ -17785,7 +18640,7 @@ const noNamespace = defineRule({
 			const fullName = `${namespaced.namespace.name}:${namespaced.name.name}`;
 			context.report({
 				node: namespaced,
-				message: buildMessage$10(fullName)
+				message: buildMessage$11(fullName)
 			});
 		},
 		CallExpression(node) {
@@ -17796,7 +18651,7 @@ const noNamespace = defineRule({
 			if (!firstArgument.value.includes(":")) return;
 			context.report({
 				node: firstArgument,
-				message: buildMessage$10(firstArgument.value)
+				message: buildMessage$11(firstArgument.value)
 			});
 		}
 	})
@@ -17840,7 +18695,7 @@ const noNestedComponentDefinition = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-noninteractive-element-interactions.ts
-const buildMessage$9 = (tag) => `Non-interactive element \`<${tag}>\` should not have interactive event handlers — convert to a semantic interactive element or add an interactive role.`;
+const buildMessage$10 = (tag) => `Non-interactive element \`<${tag}>\` should not have interactive event handlers — convert to a semantic interactive element or add an interactive role.`;
 const INTERACTIVE_HANDLERS = [
 	"onClick",
 	"onMouseDown",
@@ -17866,13 +18721,13 @@ const noNoninteractiveElementInteractions = defineRule({
 		}
 		context.report({
 			node: node.name,
-			message: buildMessage$9(tag)
+			message: buildMessage$10(tag)
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-noninteractive-element-to-interactive-role.ts
-const buildMessage$8 = (tag, role) => `Non-interactive element \`<${tag}>\` cannot have interactive role \`${role}\` — use a semantic interactive element instead.`;
+const buildMessage$9 = (tag, role) => `Non-interactive element \`<${tag}>\` cannot have interactive role \`${role}\` — use a semantic interactive element instead.`;
 const DEFAULT_ALLOWED_ROLES = {
 	ul: [
 		"menu",
@@ -17936,14 +18791,14 @@ const noNoninteractiveElementToInteractiveRole = defineRule({
 			if (!isInteractiveRole(firstRole)) return;
 			context.report({
 				node: roleAttribute,
-				message: buildMessage$8(elementType, firstRole)
+				message: buildMessage$9(elementType, firstRole)
 			});
 		} };
 	}
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-noninteractive-tabindex.ts
-const MESSAGE$13 = "Don't add `tabIndex` to non-interactive elements — keyboard users would have no expected behavior on focus.";
+const MESSAGE$14 = "Don't add `tabIndex` to non-interactive elements — keyboard users would have no expected behavior on focus.";
 const resolveSettings$14 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noNoninteractiveTabindex ?? {} : {};
@@ -17970,7 +18825,7 @@ const noNoninteractiveTabindex = defineRule({
 			if (numeric === null) {
 				if (isNodeOfType(tabIndexValue, "JSXExpressionContainer") && !settings.allowExpressionValues) context.report({
 					node: tabIndex,
-					message: MESSAGE$13
+					message: MESSAGE$14
 				});
 				return;
 			}
@@ -17983,7 +18838,7 @@ const noNoninteractiveTabindex = defineRule({
 			if (!roleAttribute) {
 				context.report({
 					node: tabIndex,
-					message: MESSAGE$13
+					message: MESSAGE$14
 				});
 				return;
 			}
@@ -17997,7 +18852,7 @@ const noNoninteractiveTabindex = defineRule({
 			}
 			context.report({
 				node: tabIndex,
-				message: MESSAGE$13
+				message: MESSAGE$14
 			});
 		} };
 	}
@@ -18558,7 +19413,7 @@ const noPureBlackBackground = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-react-children.ts
-const MESSAGE$12 = "`React.Children` is uncommon and leads to fragile components.";
+const MESSAGE$13 = "`React.Children` is uncommon and leads to fragile components.";
 const isChildrenIdentifier = (node, contextNode) => {
 	if (!isNodeOfType(node, "Identifier") || node.name !== "Children") return false;
 	return isImportedFromModule(contextNode, "Children", "react");
@@ -18583,13 +19438,13 @@ const noReactChildren = defineRule({
 		if (isChildrenIdentifier(memberObject, node)) {
 			context.report({
 				node: calleeOuter,
-				message: MESSAGE$12
+				message: MESSAGE$13
 			});
 			return;
 		}
 		if (isReactNamespaceMember(memberObject, node)) context.report({
 			node: calleeOuter,
-			message: MESSAGE$12
+			message: MESSAGE$13
 		});
 	} })
 });
@@ -18605,7 +19460,7 @@ const createDeprecatedReactImportRule = ({ source, messages, handleExtraSource }
 			if (sourceValue !== source) return;
 			for (const specifier of node.specifiers ?? []) {
 				if (isNodeOfType(specifier, "ImportSpecifier")) {
-					const importedName = getImportedName(specifier);
+					const importedName = getImportedName$1(specifier);
 					if (!importedName) continue;
 					const message = messages.get(importedName);
 					if (message) context.report({
@@ -18657,7 +19512,7 @@ const buildTestUtilsMessage = (importedName) => {
 const reportTestUtilsImports = (node, context) => {
 	for (const specifier of node.specifiers ?? []) {
 		if (isNodeOfType(specifier, "ImportSpecifier")) {
-			const importedName = getImportedName(specifier) ?? "default";
+			const importedName = getImportedName$1(specifier) ?? "default";
 			context.report({
 				node: specifier,
 				message: buildTestUtilsMessage(importedName)
@@ -18785,7 +19640,7 @@ const getTagsForRole = (role) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/no-redundant-roles.ts
-const buildMessage$7 = (tag, role) => `\`<${tag}>\` already has implicit role \`${role}\` — remove the redundant \`role\` attribute.`;
+const buildMessage$8 = (tag, role) => `\`<${tag}>\` already has implicit role \`${role}\` — remove the redundant \`role\` attribute.`;
 const resolveSettings$13 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { exceptions: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noRedundantRoles ?? {} : {}).exceptions ?? {} };
@@ -18808,14 +19663,14 @@ const noRedundantRoles = defineRule({
 			const allowedHere = settings.exceptions[tag] ?? [];
 			if (implicitRoles.includes(role) && !allowedHere.includes(role)) context.report({
 				node: roleAttr,
-				message: buildMessage$7(tag, role)
+				message: buildMessage$8(tag, role)
 			});
 		} };
 	}
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-redundant-should-component-update.ts
-const buildMessage$6 = (className) => `${className} does not need \`shouldComponentUpdate\` when extending \`React.PureComponent\`.`;
+const buildMessage$7 = (className) => `${className} does not need \`shouldComponentUpdate\` when extending \`React.PureComponent\`.`;
 const isPureComponentSuper = (superClass) => {
 	if (!superClass) return false;
 	if (isNodeOfType(superClass, "Identifier")) return superClass.name === "PureComponent";
@@ -18847,7 +19702,7 @@ const noRedundantShouldComponentUpdate = defineRule({
 			const className = classNode.id?.name ?? "<anonymous class>";
 			context.report({
 				node: reportNode,
-				message: buildMessage$6(className)
+				message: buildMessage$7(className)
 			});
 		};
 		return {
@@ -18906,7 +19761,7 @@ const noRenderPropChildren = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-render-return-value.ts
-const MESSAGE$11 = "Do not use the return value from `ReactDOM.render`.";
+const MESSAGE$12 = "Do not use the return value from `ReactDOM.render`.";
 const isReactDomRenderCall = (node) => {
 	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
 	if (!isNodeOfType(node.callee.object, "Identifier")) return false;
@@ -18929,7 +19784,7 @@ const noRenderReturnValue = defineRule({
 		if (!isUsedAsReturnValue(node.parent)) return;
 		context.report({
 			node: node.callee,
-			message: MESSAGE$11
+			message: MESSAGE$12
 		});
 	} })
 });
@@ -19324,7 +20179,7 @@ const isTanStackServerFnHandler = (node) => {
 const isInsideServerOnlyScope = (node) => {
 	let currentNode = node.parent ?? null;
 	while (currentNode) {
-		if (isFunctionLike(currentNode)) {
+		if (isFunctionLike$1(currentNode)) {
 			if (hasUseServerDirective(currentNode) || isTanStackServerFnHandler(currentNode)) return true;
 		}
 		currentNode = currentNode.parent ?? null;
@@ -19389,7 +20244,7 @@ const getParentComponent = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/no-set-state.ts
-const MESSAGE$10 = "Do not use `this.setState` in components.";
+const MESSAGE$11 = "Do not use `this.setState` in components.";
 const noSetState = defineRule({
 	id: "no-set-state",
 	severity: "warn",
@@ -19403,7 +20258,7 @@ const noSetState = defineRule({
 		if (!getParentComponent(node)) return;
 		context.report({
 			node: node.callee,
-			message: MESSAGE$10
+			message: MESSAGE$11
 		});
 	} })
 });
@@ -19562,7 +20417,7 @@ const isAbstractRole = (openingElement, settings) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/no-static-element-interactions.ts
-const MESSAGE$9 = "Static HTML elements with event handlers require a role — add `role=\"…\"` or use a semantic HTML element instead.";
+const MESSAGE$10 = "Static HTML elements with event handlers require a role — add `role=\"…\"` or use a semantic HTML element instead.";
 const DEFAULT_HANDLERS = [
 	"onClick",
 	"onMouseDown",
@@ -19621,7 +20476,7 @@ const noStaticElementInteractions = defineRule({
 			if (!roleAttribute || !roleAttribute.value) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$9
+					message: MESSAGE$10
 				});
 				return;
 			}
@@ -19631,14 +20486,14 @@ const noStaticElementInteractions = defineRule({
 				if (firstRole && (isInteractiveRole(firstRole) || isNonInteractiveRole(firstRole))) return;
 				context.report({
 					node: node.name,
-					message: MESSAGE$9
+					message: MESSAGE$10
 				});
 				return;
 			}
 			if (isNodeOfType(attributeValue, "JSXExpressionContainer") && settings.allowExpressionValues) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$9
+				message: MESSAGE$10
 			});
 		} };
 	}
@@ -19694,7 +20549,7 @@ const noStringRefs = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-this-in-sfc.ts
-const MESSAGE$8 = "Stateless functional components shouldn't use `this` — read props/context from function parameters.";
+const MESSAGE$9 = "Stateless functional components shouldn't use `this` — read props/context from function parameters.";
 const isInsideClassMethod = (node, customClassFactoryNames) => {
 	let ancestor = node.parent;
 	while (ancestor) {
@@ -19762,7 +20617,7 @@ const noThisInSfc = defineRule({
 			if (!looksLikeFunctionComponent(enclosingFunction)) return;
 			context.report({
 				node,
-				message: MESSAGE$8
+				message: MESSAGE$9
 			});
 		} };
 	}
@@ -19944,7 +20799,7 @@ const ESCAPED_VERSIONS = {
 	">": "`&gt;` / `&#62;`",
 	"}": "`&#125;` (or wrap the literal in `{'}'}`)"
 };
-const buildMessage$5 = (character) => `\`${character}\` in JSX text can be confused with markup — escape with ${ESCAPED_VERSIONS[character]}.`;
+const buildMessage$6 = (character) => `\`${character}\` in JSX text can be confused with markup — escape with ${ESCAPED_VERSIONS[character]}.`;
 const noUnescapedEntities = defineRule({
 	id: "no-unescaped-entities",
 	severity: "warn",
@@ -19955,7 +20810,7 @@ const noUnescapedEntities = defineRule({
 		for (const character of value) if (character in ESCAPED_VERSIONS) {
 			context.report({
 				node,
-				message: buildMessage$5(character)
+				message: buildMessage$6(character)
 			});
 			return;
 		}
@@ -20976,7 +21831,7 @@ const SAFER_REPLACEMENT = {
 	componentWillUpdate: "componentDidUpdate",
 	UNSAFE_componentWillUpdate: "componentDidUpdate"
 };
-const buildMessage$4 = (methodName) => `Unsafe lifecycle method \`${methodName}\` — use \`${SAFER_REPLACEMENT[methodName] ?? "an alternative lifecycle method"}\` instead.`;
+const buildMessage$5 = (methodName) => `Unsafe lifecycle method \`${methodName}\` — use \`${SAFER_REPLACEMENT[methodName] ?? "an alternative lifecycle method"}\` instead.`;
 const resolveSettings$9 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { checkAliases: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noUnsafe ?? {} : {}).checkAliases ?? false };
@@ -21024,7 +21879,7 @@ const noUnsafe = defineRule({
 				if (!getParentComponent(node)) return;
 				context.report({
 					node: node.key,
-					message: buildMessage$4(name)
+					message: buildMessage$5(name)
 				});
 			},
 			Property(node) {
@@ -21035,7 +21890,7 @@ const noUnsafe = defineRule({
 					if (isEs5Component(ancestor)) {
 						context.report({
 							node: node.key,
-							message: buildMessage$4(name)
+							message: buildMessage$5(name)
 						});
 						return;
 					}
@@ -21047,7 +21902,7 @@ const noUnsafe = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-unstable-nested-components.ts
-const buildMessage$3 = (parentName, isInProp, allowAsProps) => {
+const buildMessage$4 = (parentName, isInProp, allowAsProps) => {
 	let message = "Don't define components inside another component";
 	if (parentName) message += ` (\`${parentName}\`)`;
 	message += " — extract it to module scope.";
@@ -21116,7 +21971,7 @@ const isReactClassComponent = (classNode) => {
 const findEnclosingComponent = (node) => {
 	let walker = node.parent;
 	while (walker) {
-		if (isFunctionLike(walker)) {
+		if (isFunctionLike$1(walker)) {
 			const componentName = inferFunctionLikeName(walker);
 			if (componentName && isReactComponentName(componentName) && expressionContainsJsxOrCreateElement(walker)) return {
 				component: walker,
@@ -21282,7 +22137,7 @@ const noUnstableNestedComponents = defineRule({
 			if (!enclosing) return;
 			context.report({
 				node: reportNode,
-				message: buildMessage$3(enclosing.name, propInfo !== null, settings.allowAsProps)
+				message: buildMessage$4(enclosing.name, propInfo !== null, settings.allowAsProps)
 			});
 		};
 		const checkFunctionLike = (node) => {
@@ -21414,7 +22269,7 @@ const noWideLetterSpacing = defineRule({
 //#endregion
 //#region src/plugin/rules/react-builtins/no-will-update-set-state.ts
 const LIFECYCLE_NAMES = new Set(["componentWillUpdate", "UNSAFE_componentWillUpdate"]);
-const MESSAGE$7 = "Do not use `this.setState` in `componentWillUpdate` — schedule the update via `componentDidUpdate` instead.";
+const MESSAGE$8 = "Do not use `this.setState` in `componentWillUpdate` — schedule the update via `componentDidUpdate` instead.";
 const resolveSettings$7 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { mode: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noWillUpdateSetState ?? {} : {}).mode ?? "allowed" };
@@ -21447,7 +22302,7 @@ const noWillUpdateSetState = defineRule({
 			if (!isSetStateCallInLifecycle(node, activeLifecycleNames, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			context.report({
 				node: node.callee,
-				message: MESSAGE$7
+				message: MESSAGE$8
 			});
 		} };
 	}
@@ -21985,6 +22840,214 @@ const onlyExportComponents = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/preact/preact-no-children-length.ts
+const ARRAY_READ_METHOD_NAMES = new Set([
+	"length",
+	"map",
+	"forEach",
+	"filter",
+	"find",
+	"reduce",
+	"some",
+	"every",
+	"flat",
+	"flatMap",
+	"indexOf",
+	"includes",
+	"slice",
+	"concat",
+	"join"
+]);
+const CHILDREN_ARRAY_MESSAGE = "`props.children` is not always an array in Preact — use `toChildArray(children)` from `preact` before calling array methods or reading `.length`.";
+const isDestructuredChildrenParam = (identifier) => {
+	let cursor = identifier.parent;
+	while (cursor) {
+		if (isNodeOfType(cursor, "FunctionDeclaration") || isNodeOfType(cursor, "FunctionExpression") || isNodeOfType(cursor, "ArrowFunctionExpression")) {
+			const firstParam = cursor.params[0];
+			if (!firstParam || !isNodeOfType(firstParam, "ObjectPattern")) return false;
+			return firstParam.properties.some((property) => isNodeOfType(property, "Property") && isNodeOfType(property.key, "Identifier") && property.key.name === "children");
+		}
+		cursor = cursor.parent ?? null;
+	}
+	return false;
+};
+const isChildrenMemberExpression = (node) => {
+	const object = node.object;
+	if (!isNodeOfType(object, "MemberExpression")) return isNodeOfType(object, "Identifier") && object.name === "children" && isDestructuredChildrenParam(object);
+	if (!isNodeOfType(object.property, "Identifier") || object.property.name !== "children") return false;
+	const propsObject = object.object;
+	if (isNodeOfType(propsObject, "Identifier") && propsObject.name === "props") return true;
+	if (isNodeOfType(propsObject, "MemberExpression") && isNodeOfType(propsObject.property, "Identifier") && propsObject.property.name === "props" && isNodeOfType(propsObject.object, "ThisExpression")) return true;
+	return false;
+};
+const preactNoChildrenLength = defineRule({
+	id: "preact-no-children-length",
+	requires: ["preact"],
+	severity: "warn",
+	recommendation: "Wrap with `toChildArray(children)` from `preact` before accessing array methods or `.length`.",
+	create: (context) => ({ MemberExpression(node) {
+		if (node.computed) return;
+		if (!isNodeOfType(node.property, "Identifier")) return;
+		if (!ARRAY_READ_METHOD_NAMES.has(node.property.name)) return;
+		if (!isChildrenMemberExpression(node)) return;
+		context.report({
+			node,
+			message: CHILDREN_ARRAY_MESSAGE
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/preact/preact-no-react-hooks-import.ts
+const REACT_HOOK_NAMES = new Set([
+	"useCallback",
+	"useContext",
+	"useDebugValue",
+	"useDeferredValue",
+	"useEffect",
+	"useId",
+	"useImperativeHandle",
+	"useInsertionEffect",
+	"useLayoutEffect",
+	"useMemo",
+	"useReducer",
+	"useRef",
+	"useState",
+	"useSyncExternalStore",
+	"useTransition"
+]);
+const buildMessage$3 = (importedNames) => `Import ${importedNames.map((innerName) => `\`${innerName}\``).join(", ")} from \`preact/hooks\` (or \`preact/compat\`) — importing hooks from \`react\` in a pure-Preact project loads a second copy of Preact's hook state and triggers \`__H\` undefined errors.`;
+const preactNoReactHooksImport = defineRule({
+	id: "preact-no-react-hooks-import",
+	requires: ["pure-preact"],
+	severity: "warn",
+	recommendation: "Replace `from \"react\"` with `from \"preact/hooks\"` (or `from \"preact/compat\"` if other React API surface is needed).",
+	create: (context) => ({ ImportDeclaration(node) {
+		const source = node.source;
+		if (!isNodeOfType(source, "Literal") || source.value !== "react") return;
+		const reactHookSpecifiers = [];
+		for (const specifier of node.specifiers) {
+			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
+			const imported = specifier.imported;
+			if (!isNodeOfType(imported, "Identifier")) continue;
+			if (REACT_HOOK_NAMES.has(imported.name)) reactHookSpecifiers.push(specifier);
+		}
+		if (reactHookSpecifiers.length === 0) return;
+		const importedNames = reactHookSpecifiers.map((specifier) => {
+			const imported = specifier.imported;
+			return isNodeOfType(imported, "Identifier") ? imported.name : "";
+		});
+		context.report({
+			node,
+			message: buildMessage$3(importedNames)
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/preact/preact-no-render-arguments.ts
+const PREACT_COMPONENT_NAMESPACES = new Set(["Preact"]);
+const PREACT_COMPONENT_NAMES = new Set(["Component", "PureComponent"]);
+const isPreactNamespaceComponentRef = (node) => {
+	if (!isNodeOfType(node, "MemberExpression")) return false;
+	if (!isNodeOfType(node.object, "Identifier")) return false;
+	if (!PREACT_COMPONENT_NAMESPACES.has(node.object.name)) return false;
+	if (!isNodeOfType(node.property, "Identifier")) return false;
+	return PREACT_COMPONENT_NAMES.has(node.property.name);
+};
+const isPreactOrReactComponentClass = (node) => {
+	if (isEs6Component(node)) return true;
+	if (!isNodeOfType(node, "ClassDeclaration") && !isNodeOfType(node, "ClassExpression")) return false;
+	const superClass = node.superClass;
+	if (!superClass) return false;
+	return isPreactNamespaceComponentRef(superClass);
+};
+const RENDER_ARGUMENTS_MESSAGE = "Preact's `render(props, state)` argument shape is harder to type than `this.props` / `this.state`, breaks under `preact/compat` (which mirrors React's parameterless signature), and quietly diverges from every other Preact lifecycle method. Prefer reading from `this.props` / `this.state`.";
+const isInstanceMethodNamedRender = (node) => isNodeOfType(node, "MethodDefinition") && node.kind === "method" && node.static !== true && isNodeOfType(node.key, "Identifier") && node.key.name === "render";
+const isInsideEs6Component$1 = (methodDefinition) => {
+	const classBody = methodDefinition.parent;
+	if (!classBody || !isNodeOfType(classBody, "ClassBody")) return false;
+	const owningClass = classBody.parent;
+	if (!owningClass) return false;
+	return isPreactOrReactComponentClass(owningClass);
+};
+const stripThisParameter = (params) => {
+	const first = params[0];
+	if (!first) return params;
+	if (isNodeOfType(first, "Identifier") && first.name === "this") return params.slice(1);
+	return params;
+};
+const preactNoRenderArguments = defineRule({
+	id: "preact-no-render-arguments",
+	requires: ["preact"],
+	severity: "warn",
+	recommendation: "Read state/props from `this.props` / `this.state` inside `render()` instead of declaring positional parameters.",
+	create: (context) => ({ MethodDefinition(node) {
+		if (!isInstanceMethodNamedRender(node)) return;
+		if (!isInsideEs6Component$1(node)) return;
+		const renderFunction = node.value;
+		if (!renderFunction || !isNodeOfType(renderFunction, "FunctionExpression")) return;
+		const firstParameter = stripThisParameter(renderFunction.params)[0];
+		if (!firstParameter) return;
+		context.report({
+			node: firstParameter,
+			message: RENDER_ARGUMENTS_MESSAGE
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/preact/preact-prefer-ondblclick.ts
+const MESSAGE$7 = "Preact follows DOM event naming — use `onDblClick` (lowercase second word). React's `onDoubleClick` handler never fires in Preact core.";
+const preactPreferOndblclick = defineRule({
+	id: "preact-prefer-ondblclick",
+	requires: ["pure-preact"],
+	severity: "warn",
+	recommendation: "Rename the handler from `onDoubleClick` to `onDblClick` to match the DOM event name.",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		const tagName = node.name.name;
+		if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
+		const onDoubleClickAttribute = findJsxAttribute(node.attributes, "onDoubleClick");
+		if (!onDoubleClickAttribute) return;
+		context.report({
+			node: onDoubleClickAttribute,
+			message: MESSAGE$7
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/preact/preact-prefer-oninput.ts
+const PREFER_ONINPUT_MESSAGE = "In Preact core, `onChange` on text-like inputs only fires on blur — use `onInput` for real-time updates. If using `preact/compat`, this is handled automatically.";
+const COMPAT_EXEMPT_INPUT_TYPES = new Set([
+	"checkbox",
+	"radio",
+	"file"
+]);
+const isTextLikeInput = (openingElement) => {
+	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
+	const tagName = openingElement.name.name;
+	if (tagName === "textarea") return true;
+	if (tagName !== "input") return false;
+	const typeAttribute = findJsxAttribute(openingElement.attributes, "type");
+	if (!typeAttribute) return true;
+	const typeValue = getJsxPropStringValue(typeAttribute);
+	if (typeValue === null) return true;
+	return !COMPAT_EXEMPT_INPUT_TYPES.has(typeValue);
+};
+const preactPreferOninput = defineRule({
+	id: "preact-prefer-oninput",
+	requires: ["pure-preact"],
+	severity: "warn",
+	recommendation: "Replace `onChange` with `onInput` on text-like inputs, or use `preact/compat` which remaps `onChange` automatically.",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (!isTextLikeInput(node)) return;
+		const onChangeAttribute = findJsxAttribute(node.attributes, "onChange");
+		if (!onChangeAttribute) return;
+		context.report({
+			node: onChangeAttribute,
+			message: PREFER_ONINPUT_MESSAGE
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/bundle-size/prefer-dynamic-import.ts
 const preferDynamicImport = defineRule({
 	id: "prefer-dynamic-import",
@@ -22106,6 +23169,49 @@ const preferFunctionComponent = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/a11y/prefer-html-dialog.ts
+const ROLE_DIALOG_VALUES = new Set(["dialog", "alertdialog"]);
+const ROLE_DIALOG_MESSAGE = "Use the native `<dialog>` element instead of `role=\"dialog\"` on a generic container — `<dialog>` ships built-in focus trap, `Escape` dismissal, the top-layer backdrop, and the right accessibility tree without you having to wire any of it up.";
+const ARIA_MODAL_MESSAGE = "Use the native `<dialog>` element with `dialog.showModal()` instead of `aria-modal=\"true\"` on a generic container — the browser then owns focus trapping, scroll locking, and `Escape` dismissal, none of which `aria-modal` actually delivers on its own.";
+const isAriaModalTrue = (attribute) => {
+	const stringValue = getJsxPropStringValue(attribute);
+	if (stringValue !== null) return stringValue === "true";
+	const value = attribute.value;
+	if (!value) return true;
+	if (isNodeOfType(value, "JSXExpressionContainer")) {
+		const expression = value.expression;
+		if (isNodeOfType(expression, "Literal") && expression.value === true) return true;
+	}
+	return false;
+};
+const preferHtmlDialog = defineRule({
+	id: "prefer-html-dialog",
+	severity: "warn",
+	recommendation: "Replace the wrapper with `<dialog>` and open it with `dialog.showModal()`. For the trigger, prefer `<button commandfor=\"id\" command=\"show-modal\">` (Chrome 135+) or fall back to a `useRef`-driven `dialogRef.current?.showModal()`.",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		const tagName = node.name.name;
+		if (tagName === "dialog") return;
+		if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
+		const roleAttribute = findJsxAttribute(node.attributes, "role");
+		if (roleAttribute) {
+			const roleValue = getJsxPropStringValue(roleAttribute);
+			if (roleValue !== null && ROLE_DIALOG_VALUES.has(roleValue)) {
+				context.report({
+					node: roleAttribute,
+					message: ROLE_DIALOG_MESSAGE
+				});
+				return;
+			}
+		}
+		const ariaModalAttribute = findJsxAttribute(node.attributes, "aria-modal");
+		if (ariaModalAttribute && isAriaModalTrue(ariaModalAttribute)) context.report({
+			node: ariaModalAttribute,
+			message: ARIA_MODAL_MESSAGE
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/a11y/prefer-tag-over-role.ts
 const buildMessage$2 = (role, tag) => `Prefer the semantic \`<${tag}>\` element over \`role="${role}"\` on a generic tag.`;
 const preferTagOverRole = defineRule({
@@ -23118,7 +24224,7 @@ const hasOwnAwait = (functionBody) => {
 	let found = false;
 	walkAst(functionBody, (child) => {
 		if (found) return;
-		if (child !== functionBody && isFunctionLike(child)) return false;
+		if (child !== functionBody && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "AwaitExpression")) found = true;
 	});
 	return found;
@@ -23137,7 +24243,7 @@ const setterIsCalledInAsyncContext = (componentBody, setterName) => {
 	let found = false;
 	walkAst(componentBody, (child) => {
 		if (found) return;
-		if (!isFunctionLike(child)) return;
+		if (!isFunctionLike$1(child)) return;
 		const functionBody = child.body;
 		if (!(Boolean(child.async) || hasOwnAwait(functionBody))) return;
 		if (callsIdentifier(functionBody, setterName)) found = true;
@@ -24209,6 +25315,55 @@ const rnListDataMapped = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/react-native/rn-list-missing-estimated-item-size.ts
+const RECYCLABLE_LIST_PACKAGES = {
+	FlashList: ["@shopify/flash-list"],
+	LegendList: ["@legendapp/list"]
+};
+const SIZING_HINT_ATTRIBUTE_NAMES = new Set(["estimatedItemSize", "estimatedListSize"]);
+const isEmptyArrayLiteral = (node) => {
+	if (!isNodeOfType(node.value, "JSXExpressionContainer")) return false;
+	const expression = node.value.expression;
+	return isNodeOfType(expression, "ArrayExpression") && (expression.elements?.length ?? 0) === 0;
+};
+const rnListMissingEstimatedItemSize = defineRule({
+	id: "rn-list-missing-estimated-item-size",
+	tags: ["test-noise"],
+	requires: ["react-native"],
+	severity: "warn",
+	recommendation: "Add `estimatedItemSize={<avg-row-height-in-px>}` so the initial container pool matches the real rows — without it the engine guesses and flashes blank cells on fast scroll",
+	create: (context) => ({ JSXOpeningElement(node) {
+		const localElementName = resolveJsxElementName(node);
+		if (!localElementName) return;
+		let canonicalRecyclerName = null;
+		for (const [canonicalName, packageSources] of Object.entries(RECYCLABLE_LIST_PACKAGES)) if (packageSources.some((packageSource) => getImportedNameFromModule(node, localElementName, packageSource) === canonicalName)) {
+			canonicalRecyclerName = canonicalName;
+			break;
+		}
+		if (!canonicalRecyclerName) return;
+		let hasSizingHint = false;
+		let dataIsEmptyLiteral = false;
+		let hasDataProp = false;
+		for (const attribute of node.attributes ?? []) {
+			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+			if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
+			const attributeName = attribute.name.name;
+			if (SIZING_HINT_ATTRIBUTE_NAMES.has(attributeName)) hasSizingHint = true;
+			if (attributeName === "data") {
+				hasDataProp = true;
+				if (isEmptyArrayLiteral(attribute)) dataIsEmptyLiteral = true;
+			}
+		}
+		if (hasSizingHint) return;
+		if (dataIsEmptyLiteral) return;
+		if (!hasDataProp) return;
+		context.report({
+			node,
+			message: `<${localElementName}> (from ${canonicalRecyclerName}) is missing \`estimatedItemSize\` — the engine guesses the initial container pool from a default that often mismatches your rows, causing blank flashes on fast scroll`
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/react-native/rn-list-recyclable-without-types.ts
 const RECYCLABLE_LIST_NAMES = new Set(["FlashList", "LegendList"]);
 const rnListRecyclableWithoutTypes = defineRule({
@@ -24396,7 +25551,7 @@ const rnNoDeprecatedModules = defineRule({
 			if (node.source?.value !== "react-native") return;
 			for (const specifier of node.specifiers ?? []) {
 				if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-				const importedName = getImportedName(specifier);
+				const importedName = getImportedName$1(specifier);
 				if (!importedName) continue;
 				const baseReplacement = DEPRECATED_RN_MODULE_REPLACEMENTS.get(importedName);
 				if (!baseReplacement) continue;
@@ -24850,6 +26005,80 @@ const rnNoRawText = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/react-native/rn-no-renderitem-key.ts
+const collectTopLevelReturnExpressions = (functionNode) => {
+	if (isNodeOfType(functionNode, "ArrowFunctionExpression") && functionNode.body) {
+		if (!isNodeOfType(functionNode.body, "BlockStatement")) return [functionNode.body];
+	}
+	const block = functionNode.body;
+	if (!block || !isNodeOfType(block, "BlockStatement")) return [];
+	const returnExpressions = [];
+	const visit = (node) => {
+		if (FUNCTION_LIKE_TYPES$1.has(node.type)) return;
+		if (isNodeOfType(node, "ReturnStatement") && node.argument) returnExpressions.push(node.argument);
+		const nodeRecord = node;
+		for (const fieldName of Object.keys(nodeRecord)) {
+			if (fieldName === "parent") continue;
+			const child = nodeRecord[fieldName];
+			if (Array.isArray(child)) {
+				for (const childItem of child) if (isAstNode(childItem)) visit(childItem);
+			} else if (isAstNode(child)) visit(child);
+		}
+	};
+	visit(block);
+	return returnExpressions;
+};
+const collectReturnedJsxElements = (expression) => {
+	const elements = [];
+	const visit = (current) => {
+		const unwrapped = stripParenExpression(current);
+		if (isNodeOfType(unwrapped, "JSXElement")) {
+			elements.push(unwrapped);
+			return;
+		}
+		if (isNodeOfType(unwrapped, "ConditionalExpression")) {
+			visit(unwrapped.consequent);
+			visit(unwrapped.alternate);
+			return;
+		}
+		if (isNodeOfType(unwrapped, "LogicalExpression")) {
+			visit(unwrapped.right);
+			if (unwrapped.operator === "||" || unwrapped.operator === "??") visit(unwrapped.left);
+		}
+	};
+	visit(expression);
+	return elements;
+};
+const rnNoRenderitemKey = defineRule({
+	id: "rn-no-renderitem-key",
+	tags: ["test-noise"],
+	requires: ["react-native"],
+	severity: "warn",
+	recommendation: "Remove `key` from the JSX returned by renderItem — React Native lists key rows from `keyExtractor` (or `item.key`); the inner `key` is a no-op and hides a missing `keyExtractor`",
+	create: (context) => ({ JSXAttribute(attributeNode) {
+		if (!isNodeOfType(attributeNode.name, "JSXIdentifier") || !RENDER_ITEM_PROP_NAMES.has(attributeNode.name.name)) return;
+		const openingElement = attributeNode.parent;
+		if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return;
+		const listComponentName = resolveJsxElementName(openingElement);
+		if (!listComponentName || !REACT_NATIVE_LIST_COMPONENTS.has(listComponentName)) return;
+		if (!attributeNode.value || !isNodeOfType(attributeNode.value, "JSXExpressionContainer")) return;
+		const renderFunction = attributeNode.value.expression;
+		if (!isNodeOfType(renderFunction, "ArrowFunctionExpression") && !isNodeOfType(renderFunction, "FunctionExpression")) return;
+		const returnExpressions = collectTopLevelReturnExpressions(renderFunction);
+		const renderPropName = attributeNode.name.name;
+		for (const returnExpression of returnExpressions) {
+			const returnedJsxElements = collectReturnedJsxElements(returnExpression);
+			for (const jsxElement of returnedJsxElements) {
+				if (!hasJsxKeyAttribute(jsxElement.openingElement)) continue;
+				context.report({
+					node: jsxElement.openingElement,
+					message: `\`key\` on the JSX returned by ${renderPropName} on <${listComponentName}> is a no-op — React Native lists key rows from \`keyExtractor\` (or \`item.key\`). Remove this \`key\` and set \`keyExtractor\` on the list instead`
+				});
+			}
+		}
+	} })
+});
+//#endregion
 //#region src/plugin/rules/react-native/rn-no-scroll-state.ts
 const SET_STATE_PATTERN = /^set[A-Z]/;
 const findSetStateInBody = (body) => {
@@ -25004,7 +26233,7 @@ const rnPreferExpoImage = defineRule({
 			if (node.source?.value !== "react-native") return;
 			for (const specifier of node.specifiers ?? []) {
 				if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-				const importedName = getImportedName(specifier);
+				const importedName = getImportedName$1(specifier);
 				if (importedName !== "Image" && importedName !== "ImageBackground") continue;
 				context.report({
 					node: specifier,
@@ -25034,7 +26263,7 @@ const rnPreferPressable = defineRule({
 		if (typeof source !== "string" || !TOUCHABLE_SOURCES.has(source)) return;
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-			const importedName = getImportedName(specifier);
+			const importedName = getImportedName$1(specifier);
 			if (!importedName || !TOUCHABLE_COMPONENTS.has(importedName)) continue;
 			context.report({
 				node: specifier,
@@ -25044,6 +26273,81 @@ const rnPreferPressable = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/react-native/rn-prefer-pressable-over-gesture-detector.ts
+const COMPOSING_CHAIN_METHOD_NAMES = new Set([
+	"simultaneousWithExternalGesture",
+	"requireExternalGestureToFail",
+	"blocksExternalGesture"
+]);
+const analyzeGestureChain = (expression) => {
+	if (!isNodeOfType(expression, "CallExpression")) return null;
+	const chainMethodNames = [];
+	let numberOfTapsArgument = null;
+	let cursor = expression;
+	while (cursor && isNodeOfType(cursor, "CallExpression")) {
+		const callExpression = cursor;
+		const callee = callExpression.callee;
+		if (!isNodeOfType(callee, "MemberExpression")) return null;
+		if (!isNodeOfType(callee.property, "Identifier")) return null;
+		const methodName = callee.property.name;
+		if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Gesture") return {
+			factoryName: methodName,
+			chainMethodNames,
+			numberOfTapsArgument
+		};
+		if (methodName === "numberOfTaps" && numberOfTapsArgument === null && callExpression.arguments?.length === 1) numberOfTapsArgument = callExpression.arguments[0] ?? null;
+		chainMethodNames.push(methodName);
+		cursor = callee.object;
+	}
+	return null;
+};
+const isTapChainEligibleForPressable = (chain) => {
+	if (chain.factoryName !== "Tap") return false;
+	for (const methodName of chain.chainMethodNames) if (COMPOSING_CHAIN_METHOD_NAMES.has(methodName)) return false;
+	const tapsArg = chain.numberOfTapsArgument;
+	if (tapsArg !== null) {
+		if (!isNodeOfType(tapsArg, "Literal")) return false;
+		if (typeof tapsArg.value !== "number") return false;
+		if (tapsArg.value !== 1) return false;
+	}
+	return true;
+};
+const rnPreferPressableOverGestureDetector = defineRule({
+	id: "rn-prefer-pressable-over-gesture-detector",
+	tags: ["test-noise"],
+	requires: ["react-native"],
+	severity: "warn",
+	recommendation: "Replace `<GestureDetector gesture={Gesture.Tap()...}>` with `<Pressable>` (or `createCSSAnimatedComponent(Pressable)` from react-native-reanimated/css for animated press feedback) — every GestureDetector registers a native handler on mount",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (resolveJsxElementName(node) !== "GestureDetector") return;
+		if (!isImportedFromModule(node, "GestureDetector", "react-native-gesture-handler")) return;
+		let gestureExpression = null;
+		for (const attribute of node.attributes ?? []) {
+			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+			if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
+			if (attribute.name.name !== "gesture") continue;
+			if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) continue;
+			gestureExpression = attribute.value.expression;
+			break;
+		}
+		if (!gestureExpression) return;
+		const resolvedExpression = stripParenExpression(gestureExpression);
+		let chainExpression = resolvedExpression;
+		if (isNodeOfType(resolvedExpression, "Identifier")) {
+			const binding = findVariableInitializer(node, resolvedExpression.name);
+			if (!binding || !binding.initializer) return;
+			chainExpression = stripParenExpression(binding.initializer);
+		}
+		const chain = analyzeGestureChain(chainExpression);
+		if (!chain) return;
+		if (!isTapChainEligibleForPressable(chain)) return;
+		context.report({
+			node,
+			message: "<GestureDetector gesture={Gesture.Tap()...}> registers a native handler per mount — for tap-only feedback use <Pressable> (with createCSSAnimatedComponent(Pressable) from react-native-reanimated/css for animation)"
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/react-native/rn-prefer-reanimated.ts
 const JS_THREAD_ANIMATION_IMPORTS = new Set(["Animated", "LayoutAnimation"]);
 const rnPreferReanimated = defineRule({
@@ -25056,7 +26360,7 @@ const rnPreferReanimated = defineRule({
 		if (node.source?.value !== "react-native") return;
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-			const importedName = getImportedName(specifier);
+			const importedName = getImportedName$1(specifier);
 			if (!importedName || !JS_THREAD_ANIMATION_IMPORTS.has(importedName)) continue;
 			const suggestion = importedName === "LayoutAnimation" ? "LayoutAnimation runs animations on the JS thread and causes full layout recalculations — use Reanimated's Layout Animations (entering/exiting/layout props) for UI-thread layout transitions" : "Animated from react-native runs animations on the JS thread — use react-native-reanimated for performant UI-thread animations";
 			context.report({
@@ -25187,6 +26491,101 @@ const rnScrollviewDynamicPadding = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/react-native/rn-scrollview-flex-in-content-container.ts
+const VIRTUALIZED_LIST_NAMES = new Set(["FlashList", "LegendList"]);
+const getStaticMemberKeyName = (expression) => {
+	if (!expression.computed) {
+		if (isNodeOfType(expression.property, "Identifier")) return expression.property.name;
+		return null;
+	}
+	if (isNodeOfType(expression.property, "Literal") && typeof expression.property.value === "string") return expression.property.value;
+	return null;
+};
+const isStyleSheetCreateCallExpression = (expression) => {
+	if (!expression) return false;
+	const callExpression = stripParenExpression(expression);
+	if (!isNodeOfType(callExpression, "CallExpression")) return false;
+	const callee = callExpression.callee;
+	return isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier") && callee.object.name === "StyleSheet" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "create";
+};
+const resolveContentContainerStyleObject = (attribute) => {
+	if (!isNodeOfType(attribute.name, "JSXIdentifier")) return null;
+	if (attribute.name.name !== "contentContainerStyle") return null;
+	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return null;
+	const expression = stripParenExpression(attribute.value.expression);
+	if (isNodeOfType(expression, "ObjectExpression")) return expression;
+	if (isNodeOfType(expression, "MemberExpression")) {
+		const styleObjectKeyName = getStaticMemberKeyName(expression);
+		if (!styleObjectKeyName) return null;
+		const styleObjectIdentifierName = getRootIdentifierName(expression);
+		if (!styleObjectIdentifierName) return null;
+		const binding = findVariableInitializer(expression, styleObjectIdentifierName);
+		if (!binding || !binding.initializer) return null;
+		if (!isStyleSheetCreateCallExpression(binding.initializer)) return null;
+		const argument = stripParenExpression(binding.initializer).arguments?.[0];
+		if (!isNodeOfType(argument, "ObjectExpression")) return null;
+		for (const property of argument.properties ?? []) {
+			if (!isNodeOfType(property, "Property")) continue;
+			if (property.computed) continue;
+			let matchesKey = false;
+			if (isNodeOfType(property.key, "Identifier")) matchesKey = property.key.name === styleObjectKeyName;
+			else if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") matchesKey = property.key.value === styleObjectKeyName;
+			if (!matchesKey) continue;
+			const propertyValue = stripParenExpression(property.value);
+			if (isNodeOfType(propertyValue, "ObjectExpression")) return propertyValue;
+			return null;
+		}
+	}
+	return null;
+};
+const collectStyleKeyNames = (objectExpression) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const property of objectExpression.properties ?? []) {
+		if (!isNodeOfType(property, "Property")) continue;
+		if (property.computed) continue;
+		if (isNodeOfType(property.key, "Identifier")) names.add(property.key.name);
+		else if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") names.add(property.key.value);
+	}
+	return names;
+};
+const findFlexShorthandProperty = (objectExpression) => {
+	for (const property of objectExpression.properties ?? []) {
+		if (!isNodeOfType(property, "Property")) continue;
+		if (property.computed) continue;
+		if (!isNodeOfType(property.key, "Identifier") || property.key.name !== "flex") continue;
+		const value = property.value;
+		if (!isNodeOfType(value, "Literal")) return null;
+		if (typeof value.value !== "number" || value.value <= 0) return null;
+		return property;
+	}
+	return null;
+};
+const rnScrollviewFlexInContentContainer = defineRule({
+	id: "rn-scrollview-flex-in-content-container",
+	tags: ["test-noise"],
+	requires: ["react-native"],
+	severity: "warn",
+	recommendation: "Use `flexGrow: 1` on `contentContainerStyle` — RN's `flex: 1` shorthand sets `flexBasis: 0` and collapses the container on small devices",
+	create: (context) => ({ JSXOpeningElement(node) {
+		const elementName = resolveJsxElementName(node);
+		if (!elementName) return;
+		if (!SCROLLVIEW_NAMES.has(elementName) && !VIRTUALIZED_LIST_NAMES.has(elementName)) return;
+		for (const attribute of node.attributes ?? []) {
+			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+			const objectExpression = resolveContentContainerStyleObject(attribute);
+			if (!objectExpression) continue;
+			const keyNames = collectStyleKeyNames(objectExpression);
+			if (keyNames.has("flexGrow") || keyNames.has("flexBasis")) continue;
+			const flexProperty = findFlexShorthandProperty(objectExpression);
+			if (!flexProperty) continue;
+			context.report({
+				node: flexProperty,
+				message: `<${elementName}> contentContainerStyle uses \`flex: <number>\` — RN's flex shorthand sets flexBasis: 0 and collapses the container on small devices. Use \`flexGrow: 1\` instead`
+			});
+		}
+	} })
+});
+//#endregion
 //#region src/plugin/rules/react-native/rn-style-prefer-box-shadow.ts
 const LEGACY_SHADOW_KEYS = new Set([
 	"shadowColor",
@@ -28746,7 +30145,7 @@ const isUseEffectEventSymbol = (symbol) => {
 const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike(current)) {
+		if (isFunctionLike$1(current)) {
 			const resolvedName = inferFunctionName(current);
 			if (resolvedName !== null && isReactComponentOrHookName(resolvedName)) return current;
 		}
@@ -28767,7 +30166,7 @@ const isCallbackArgumentForAllowedEffectEventHook = (functionNode, additionalEff
 const isInsideAllowedEffectEventCallback = (node, additionalEffectHooksRegex) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
+		if (isFunctionLike$1(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
 		current = current.parent ?? null;
 	}
 	return false;
@@ -29101,7 +30500,7 @@ const containsAuthCheck = (rootNodes, allowedFunctionNames, genericMethodNames)
 	let foundAuthCall = false;
 	for (const rootNode of rootNodes) walkAst(rootNode, (child) => {
 		if (foundAuthCall) return;
-		if (isFunctionLike(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (getAuthCallName(child, allowedFunctionNames, genericMethodNames)) foundAuthCall = true;
 	});
@@ -30353,7 +31752,7 @@ const useLazyMotion = defineRule({
 		if (node.specifiers?.some((specifier) => {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) return false;
 			if (specifier.importKind === "type") return false;
-			return getImportedName(specifier) === "motion";
+			return getImportedName$1(specifier) === "motion";
 		})) context.report({
 			node,
 			message: "Import \"m\" with LazyMotion instead of \"motion\" — saves ~30kb in bundle size"
@@ -30434,6 +31833,17 @@ const voidDomElementsNoChildren = defineRule({
 //#endregion
 //#region src/plugin/rule-registry.ts
 const reactDoctorRules = [
+	{
+		key: "react-doctor/activity-wraps-effect-heavy-subtree",
+		id: "activity-wraps-effect-heavy-subtree",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...activityWrapsEffectHeavySubtree,
+			framework: "global",
+			category: "State & Effects"
+		}
+	},
 	{
 		key: "react-doctor/advanced-event-handler-refs",
 		id: "advanced-event-handler-refs",
@@ -30819,6 +32229,17 @@ const reactDoctorRules = [
 			category: "Architecture"
 		}
 	},
+	{
+		key: "react-doctor/hooks-no-nan-in-deps",
+		id: "hooks-no-nan-in-deps",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...hooksNoNanInDeps,
+			framework: "global",
+			category: "State & Effects"
+		}
+	},
 	{
 		key: "react-doctor/html-has-lang",
 		id: "html-has-lang",
@@ -30830,6 +32251,39 @@ const reactDoctorRules = [
 			category: "Accessibility"
 		}
 	},
+	{
+		key: "react-doctor/html-no-invalid-paragraph-child",
+		id: "html-no-invalid-paragraph-child",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...htmlNoInvalidParagraphChild,
+			framework: "global",
+			category: "Correctness"
+		}
+	},
+	{
+		key: "react-doctor/html-no-invalid-table-nesting",
+		id: "html-no-invalid-table-nesting",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...htmlNoInvalidTableNesting,
+			framework: "global",
+			category: "Correctness"
+		}
+	},
+	{
+		key: "react-doctor/html-no-nested-interactive",
+		id: "html-no-nested-interactive",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...htmlNoNestedInteractive,
+			framework: "global",
+			category: "Correctness"
+		}
+	},
 	{
 		key: "react-doctor/iframe-has-title",
 		id: "iframe-has-title",
@@ -30874,6 +32328,50 @@ const reactDoctorRules = [
 			category: "Accessibility"
 		}
 	},
+	{
+		key: "react-doctor/jotai-derived-atom-returns-fresh-object",
+		id: "jotai-derived-atom-returns-fresh-object",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...jotaiDerivedAtomReturnsFreshObject,
+			framework: "global",
+			category: "State & Effects"
+		}
+	},
+	{
+		key: "react-doctor/jotai-select-atom-in-render-body",
+		id: "jotai-select-atom-in-render-body",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...jotaiSelectAtomInRenderBody,
+			framework: "global",
+			category: "State & Effects"
+		}
+	},
+	{
+		key: "react-doctor/jotai-tq-use-raw-query-atom",
+		id: "jotai-tq-use-raw-query-atom",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...jotaiTqUseRawQueryAtom,
+			framework: "global",
+			category: "State & Effects"
+		}
+	},
+	{
+		key: "react-doctor/js-async-reduce-without-awaited-acc",
+		id: "js-async-reduce-without-awaited-acc",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...jsAsyncReduceWithoutAwaitedAcc,
+			framework: "global",
+			category: "Performance"
+		}
+	},
 	{
 		key: "react-doctor/js-batch-dom-css",
 		id: "js-batch-dom-css",
@@ -32601,6 +34099,61 @@ const reactDoctorRules = [
 			category: "Architecture"
 		}
 	},
+	{
+		key: "react-doctor/preact-no-children-length",
+		id: "preact-no-children-length",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preactNoChildrenLength,
+			framework: "preact",
+			category: "Preact"
+		}
+	},
+	{
+		key: "react-doctor/preact-no-react-hooks-import",
+		id: "preact-no-react-hooks-import",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preactNoReactHooksImport,
+			framework: "preact",
+			category: "Preact"
+		}
+	},
+	{
+		key: "react-doctor/preact-no-render-arguments",
+		id: "preact-no-render-arguments",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preactNoRenderArguments,
+			framework: "preact",
+			category: "Preact"
+		}
+	},
+	{
+		key: "react-doctor/preact-prefer-ondblclick",
+		id: "preact-prefer-ondblclick",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preactPreferOndblclick,
+			framework: "preact",
+			category: "Preact"
+		}
+	},
+	{
+		key: "react-doctor/preact-prefer-oninput",
+		id: "preact-prefer-oninput",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preactPreferOninput,
+			framework: "preact",
+			category: "Preact"
+		}
+	},
 	{
 		key: "react-doctor/prefer-dynamic-import",
 		id: "prefer-dynamic-import",
@@ -32634,6 +34187,17 @@ const reactDoctorRules = [
 			category: "Architecture"
 		}
 	},
+	{
+		key: "react-doctor/prefer-html-dialog",
+		id: "prefer-html-dialog",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...preferHtmlDialog,
+			framework: "global",
+			category: "Accessibility"
+		}
+	},
 	{
 		key: "react-doctor/prefer-tag-over-role",
 		id: "prefer-tag-over-role",
@@ -33035,6 +34599,18 @@ const reactDoctorRules = [
 			tags: [...new Set(["react-native", ...rnListDataMapped.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/rn-list-missing-estimated-item-size",
+		id: "rn-list-missing-estimated-item-size",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnListMissingEstimatedItemSize,
+			framework: "react-native",
+			category: "React Native",
+			tags: [...new Set(["react-native", ...rnListMissingEstimatedItemSize.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/rn-list-recyclable-without-types",
 		id: "rn-list-recyclable-without-types",
@@ -33155,6 +34731,18 @@ const reactDoctorRules = [
 			tags: [...new Set(["react-native", ...rnNoRawText.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/rn-no-renderitem-key",
+		id: "rn-no-renderitem-key",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnNoRenderitemKey,
+			framework: "react-native",
+			category: "React Native",
+			tags: [...new Set(["react-native", ...rnNoRenderitemKey.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/rn-no-scroll-state",
 		id: "rn-no-scroll-state",
@@ -33227,6 +34815,18 @@ const reactDoctorRules = [
 			tags: [...new Set(["react-native", ...rnPreferPressable.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/rn-prefer-pressable-over-gesture-detector",
+		id: "rn-prefer-pressable-over-gesture-detector",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnPreferPressableOverGestureDetector,
+			framework: "react-native",
+			category: "React Native",
+			tags: [...new Set(["react-native", ...rnPreferPressableOverGestureDetector.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/rn-prefer-reanimated",
 		id: "rn-prefer-reanimated",
@@ -33263,6 +34863,18 @@ const reactDoctorRules = [
 			tags: [...new Set(["react-native", ...rnScrollviewDynamicPadding.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/rn-scrollview-flex-in-content-container",
+		id: "rn-scrollview-flex-in-content-container",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnScrollviewFlexInContentContainer,
+			framework: "react-native",
+			category: "React Native",
+			tags: [...new Set(["react-native", ...rnScrollviewFlexInContentContainer.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/rn-style-prefer-boxshadow",
 		id: "rn-style-prefer-boxshadow",
@@ -33696,7 +35308,7 @@ const appendNode = (builder, block, node) => {
 };
 const mapDescendantsToBlock = (builder, node, block) => {
 	builder.nodeBlock.set(node, block);
-	if (isFunctionLike(node)) return;
+	if (isFunctionLike$1(node)) return;
 	const record = node;
 	for (const key of Object.keys(record)) {
 		if (key === "parent") continue;
@@ -34034,7 +35646,7 @@ const analyzeControlFlow = (program) => {
 		body: program.body
 	});
 	const visit = (node) => {
-		if (isFunctionLike(node)) {
+		if (isFunctionLike$1(node)) {
 			const body = node.body;
 			if (body) buildFor(node, body);
 		}
@@ -34051,7 +35663,7 @@ const analyzeControlFlow = (program) => {
 	const enclosingFunction = (node) => {
 		let current = node;
 		while (current) {
-			if (isFunctionLike(current)) return current;
+			if (isFunctionLike$1(current)) return current;
 			if (isNodeOfType(current, "Program")) return current;
 			current = current.parent ?? null;
 		}
@@ -34273,6 +35885,7 @@ const NEXTJS_RULES = toRuleMap(toKeyedSeverity(collectReactDoctorRulesByFramewor
 const REACT_NATIVE_RULES = toRuleMap(toKeyedSeverity(collectReactDoctorRulesByFramework("react-native")));
 const TANSTACK_START_RULES = toRuleMap(toKeyedSeverity(collectReactDoctorRulesByFramework("tanstack-start")));
 const TANSTACK_QUERY_RULES = toRuleMap(toKeyedSeverity(collectReactDoctorRulesByFramework("tanstack-query")));
+const PREACT_RULES = toRuleMap(toKeyedSeverity(collectReactDoctorRulesByFramework("preact")));
 const ALL_REACT_DOCTOR_RULES = toRuleMap(toKeyedSeverity(REACT_DOCTOR_RULES));
 const ALL_REACT_DOCTOR_RULE_KEYS = new Set(REACT_DOCTOR_RULES.map((rule) => rule.key));
 const FRAMEWORK_SPECIFIC_RULE_KEYS = collectFrameworkSpecificRuleKeys();
@@ -34281,6 +35894,6 @@ const REACT_COMPILER_RULES = toRuleMap(collectExternalRulesBySource("react-compi
 //#region src/index.ts
 var src_default = plugin;
 //#endregion
-export { ALL_REACT_DOCTOR_RULES, ALL_REACT_DOCTOR_RULE_KEYS, EXTERNAL_RULES, FRAMEWORK_SPECIFIC_RULE_KEYS, MOTION_LIBRARY_PACKAGES, NEXTJS_RULES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, REACT_NATIVE_DEPENDENCY_NAMES, REACT_NATIVE_DEPENDENCY_PREFIXES, REACT_NATIVE_RULES, RECOMMENDED_RULES, RULES, TANSTACK_QUERY_RULES, TANSTACK_START_RULES, src_default as default, isReactNativeDependencyName };
+export { ALL_REACT_DOCTOR_RULES, ALL_REACT_DOCTOR_RULE_KEYS, EXTERNAL_RULES, FRAMEWORK_SPECIFIC_RULE_KEYS, MOTION_LIBRARY_PACKAGES, NEXTJS_RULES, PREACT_RULES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, REACT_NATIVE_DEPENDENCY_NAMES, REACT_NATIVE_DEPENDENCY_PREFIXES, REACT_NATIVE_RULES, RECOMMENDED_RULES, RULES, TANSTACK_QUERY_RULES, TANSTACK_START_RULES, src_default as default, isReactNativeDependencyName };
 
 //# sourceMappingURL=index.js.map