oxlint-plugin-react-doctor 0.6.1 → 0.6.2-dev.173cc0a

package/dist/index.js

@@ -212,8 +212,16 @@ const sliceBelowSourceRoot = (filename) => {
 	if (cutAt < 0) return filename;
 	return filename.slice(cutAt);
 };
+let lastFilename;
+let lastResult = false;
 const isTestlikeFilename = (rawFilename) => {
 	if (!rawFilename) return false;
+	if (rawFilename === lastFilename) return lastResult;
+	lastFilename = rawFilename;
+	lastResult = computeIsTestlikeFilename(rawFilename);
+	return lastResult;
+};
+const computeIsTestlikeFilename = (rawFilename) => {
 	const filename = rawFilename.replaceAll("\\", "/");
 	const lastSlash = filename.lastIndexOf("/");
 	const basename = lastSlash === -1 ? filename : filename.slice(lastSlash + 1);
@@ -286,15 +294,38 @@ const defineRule = (rule) => {
 };
 //#endregion
 //#region src/plugin/rules/security-scan/utils/get-location-at-index.ts
+let lastContentLineIndex;
+const buildLineStartOffsets = (content) => {
+	const lineStartOffsets = [0];
+	for (let newlineIndex = content.indexOf("\n"); newlineIndex !== -1; newlineIndex = content.indexOf("\n", newlineIndex + 1)) lineStartOffsets.push(newlineIndex + 1);
+	return lineStartOffsets;
+};
+const getLineStartOffsets = (content) => {
+	if (lastContentLineIndex?.content === content) return lastContentLineIndex.lineStartOffsets;
+	const lineStartOffsets = buildLineStartOffsets(content);
+	lastContentLineIndex = {
+		content,
+		lineStartOffsets
+	};
+	return lineStartOffsets;
+};
 const getLocationAtIndex = (content, matchIndex) => {
-	if (matchIndex < 0) return {
+	if (Number.isNaN(matchIndex) || matchIndex < 0) return {
 		line: 1,
 		column: 1
 	};
-	const lines = content.slice(0, matchIndex).split(/\r?\n/);
+	const lineStartOffsets = getLineStartOffsets(content);
+	const boundedIndex = Math.min(Math.trunc(matchIndex), content.length);
+	let lowLineIndex = 0;
+	let highLineIndex = lineStartOffsets.length - 1;
+	while (lowLineIndex < highLineIndex) {
+		const midLineIndex = lowLineIndex + highLineIndex + 1 >> 1;
+		if (lineStartOffsets[midLineIndex] <= boundedIndex) lowLineIndex = midLineIndex;
+		else highLineIndex = midLineIndex - 1;
+	}
 	return {
-		line: lines.length,
-		column: (lines[lines.length - 1]?.length ?? 0) + 1
+		line: lowLineIndex + 1,
+		column: boundedIndex - lineStartOffsets[lowLineIndex] + 1
 	};
 };
 //#endregion
@@ -347,13 +378,18 @@ const isBrowserArtifactPath = (relativePath, isGeneratedBundle) => {
 const isConfigOrCiPath = (relativePath) => /(?:^|\/)(?:package\.json|Dockerfile|docker-compose\.ya?ml|\.github\/workflows\/[^/]+\.ya?ml|vercel\.json|next\.config\.[cm]?[jt]s|netlify\.toml)$/i.test(relativePath);
 //#endregion
 //#region src/plugin/rules/security-scan/utils/is-production-file-path.ts
+const classificationCacheByPattern = /* @__PURE__ */ new Map();
 const isProductionFilePath = (relativePath, sourceFilePattern) => {
-	if (!sourceFilePattern.test(relativePath)) return false;
-	if (TEST_CONTEXT_PATTERN.test(relativePath)) return false;
-	if (BUILD_SCRIPT_CONTEXT_PATTERN.test(relativePath)) return false;
-	if (DOCUMENTATION_CONTEXT_PATTERN.test(relativePath)) return false;
-	if (GENERATED_SOURCE_CONTEXT_PATTERN.test(relativePath)) return false;
-	return true;
+	let classificationByPath = classificationCacheByPattern.get(sourceFilePattern);
+	if (!classificationByPath) {
+		classificationByPath = /* @__PURE__ */ new Map();
+		classificationCacheByPattern.set(sourceFilePattern, classificationByPath);
+	}
+	const cached = classificationByPath.get(relativePath);
+	if (cached !== void 0) return cached;
+	const isProduction = sourceFilePattern.test(relativePath) && !TEST_CONTEXT_PATTERN.test(relativePath) && !BUILD_SCRIPT_CONTEXT_PATTERN.test(relativePath) && !DOCUMENTATION_CONTEXT_PATTERN.test(relativePath) && !GENERATED_SOURCE_CONTEXT_PATTERN.test(relativePath);
+	classificationByPath.set(relativePath, isProduction);
+	return isProduction;
 };
 //#endregion
 //#region src/plugin/rules/security-scan/utils/is-production-source-path.ts
@@ -552,7 +588,7 @@ 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 HOOK_NAME_PATTERN = /^use[A-Z]/;
+const HOOK_NAME_PATTERN$1 = /^use[A-Z]/;
 const HANDLER_FUNCTION_NAME_PATTERN = /^(?:on|handle)[A-Z]/;
 const EFFECT_HOOK_NAMES$1 = new Set(["useEffect", "useLayoutEffect"]);
 const HOOKS_WITH_DEPS = new Set([
@@ -752,24 +788,6 @@ const collectChildComponentNames = (element, into) => {
 		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;
@@ -779,6 +797,36 @@ const countEffectHookCalls = (body) => {
 	});
 	return count;
 };
+const componentEffectIndexCache = /* @__PURE__ */ new WeakMap();
+const getComponentEffectIndex = (programRoot) => {
+	const cached = componentEffectIndexCache.get(programRoot);
+	if (cached) return cached;
+	const bodyByName = /* @__PURE__ */ new Map();
+	walkAst(programRoot, (node) => {
+		if (isNodeOfType(node, "FunctionDeclaration") && node.id && !bodyByName.has(node.id.name)) {
+			bodyByName.set(node.id.name, node.body);
+			return;
+		}
+		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && !bodyByName.has(node.id.name)) {
+			const initializer = node.init;
+			if (isNodeOfType(initializer, "ArrowFunctionExpression") || isNodeOfType(initializer, "FunctionExpression")) bodyByName.set(node.id.name, initializer.body);
+		}
+	});
+	const index = {
+		bodyByName,
+		effectCountByName: /* @__PURE__ */ new Map()
+	};
+	componentEffectIndexCache.set(programRoot, index);
+	return index;
+};
+const getSameFileComponentEffectCount = (programRoot, componentName) => {
+	const index = getComponentEffectIndex(programRoot);
+	const cachedCount = index.effectCountByName.get(componentName);
+	if (cachedCount !== void 0) return cachedCount;
+	const count = countEffectHookCalls(index.bodyByName.get(componentName) ?? null);
+	index.effectCountByName.set(componentName, count);
+	return count;
+};
 const activityWrapsEffectHeavySubtree = defineRule({
 	id: "activity-wraps-effect-heavy-subtree",
 	title: "Activity wraps an effect-heavy subtree",
@@ -835,9 +883,7 @@ const activityWrapsEffectHeavySubtree = defineRule({
 				let totalEffects = 0;
 				const effectfulChildren = [];
 				for (const componentName of childComponentNames) {
-					const body = findSameFileComponentBody(programRoot, componentName);
-					if (!body) continue;
-					const effectCount = countEffectHookCalls(body);
+					const effectCount = getSameFileComponentEffectCount(programRoot, componentName);
 					if (effectCount === 0) continue;
 					totalEffects += effectCount;
 					effectfulChildren.push(`<${componentName}>`);
@@ -983,16 +1029,8 @@ const buildBindingIndex = (root) => {
 				}
 			}
 		}
-		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(root);
+	walkAst(root, visit);
 	return out;
 };
 const programRootCache = /* @__PURE__ */ new WeakMap();
@@ -1394,11 +1432,16 @@ const hasJsxPropIgnoreCase = (attributes, targetProp) => {
 };
 //#endregion
 //#region src/plugin/utils/get-element-type.ts
+const EMPTY_JSX_A11Y_SETTINGS = Object.freeze({});
+const jsxA11ySettingsCache = /* @__PURE__ */ new WeakMap();
 const readJsxA11ySettings = (settings) => {
-	if (!settings) return {};
+	if (!settings) return EMPTY_JSX_A11Y_SETTINGS;
+	const cachedSettings = jsxA11ySettingsCache.get(settings);
+	if (cachedSettings) return cachedSettings;
 	const block = settings["jsx-a11y"];
-	if (!block || typeof block !== "object") return {};
-	return block;
+	const a11ySettings = block && typeof block === "object" ? block : EMPTY_JSX_A11Y_SETTINGS;
+	jsxA11ySettingsCache.set(settings, a11ySettings);
+	return a11ySettings;
 };
 const flattenJsxName$2 = (name) => {
 	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
@@ -1406,8 +1449,7 @@ const flattenJsxName$2 = (name) => {
 	if (isNodeOfType(name, "JSXNamespacedName")) return `${name.namespace.name}:${name.name.name}`;
 	return "";
 };
-const getElementType = (openingElement, settings) => {
-	const a11ySettings = readJsxA11ySettings(settings);
+const computeElementType = (openingElement, a11ySettings) => {
 	const baseName = flattenJsxName$2(openingElement.name);
 	if (a11ySettings.polymorphicPropName) {
 		const polymorphicAttribute = hasJsxPropIgnoreCase(openingElement.attributes, a11ySettings.polymorphicPropName);
@@ -1419,53 +1461,61 @@ const getElementType = (openingElement, settings) => {
 	if (a11ySettings.components && baseName in a11ySettings.components) return a11ySettings.components[baseName];
 	return baseName;
 };
+const elementTypeCache = /* @__PURE__ */ new WeakMap();
+const getElementType = (openingElement, settings) => {
+	const cachedEntry = elementTypeCache.get(openingElement);
+	if (cachedEntry && cachedEntry.settings === settings) return cachedEntry.elementType;
+	const elementType = computeElementType(openingElement, readJsxA11ySettings(settings));
+	elementTypeCache.set(openingElement, {
+		settings,
+		elementType
+	});
+	return elementType;
+};
+//#endregion
+//#region src/plugin/utils/has-jsx-a11y-settings.ts
+const hasJsxA11ySettings = (settings) => {
+	const block = settings?.["jsx-a11y"];
+	return typeof block === "object" && block !== null;
+};
 //#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, {
+	const bodyStatements = programRoot.body ?? [];
+	for (const node of bodyStatements) {
+		if (node.type !== "ImportDeclaration" || !("source" in node) || !node.source) continue;
+		const source = node.source.value;
+		if (typeof source !== "string") continue;
+		if (!("specifiers" in node) || !Array.isArray(node.specifiers)) continue;
+		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: null,
+					imported: importedName,
 					isDefault: false,
-					isNamespace: true
+					isNamespace: false
 				});
-				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();
@@ -1479,6 +1529,12 @@ const getImportLookup = (node) => {
 	}
 	return cached;
 };
+const hasImportFromModules = (contextNode, moduleSources) => {
+	const lookup = getImportLookup(contextNode);
+	if (!lookup) return false;
+	for (const info of lookup.values()) if (moduleSources.includes(info.source)) return true;
+	return false;
+};
 const isImportedFromModule = (contextNode, localIdentifierName, moduleSource) => {
 	const lookup = getImportLookup(contextNode);
 	if (!lookup) return false;
@@ -1626,11 +1682,12 @@ const isNextjsMetadataImageRouteFilename = (rawFilename) => {
 };
 //#endregion
 //#region src/plugin/utils/normalize-filename.ts
-const normalizeFilename = (filename) => filename.replaceAll("\\", "/");
+const normalizeFilename = (filename) => filename.includes("\\") ? filename.replaceAll("\\", "/") : filename;
 //#endregion
 //#region src/plugin/utils/is-generated-image-render-context.ts
 const IMAGE_RESPONSE_MODULES = ["next/og", "@vercel/og"];
 const SATORI_MODULE = "satori";
+const GENERATED_IMAGE_MODULES = [...IMAGE_RESPONSE_MODULES, SATORI_MODULE];
 const generatedImageJsxCache = /* @__PURE__ */ new WeakMap();
 const isGeneratedImageRenderFilename = (rawFilename) => {
 	if (!rawFilename) return false;
@@ -1774,7 +1831,7 @@ const collectGeneratedImageJsxNodes = (programRoot) => {
 	const cached = generatedImageJsxCache.get(programRoot);
 	if (cached) return cached;
 	const generatedImageJsxNodes = /* @__PURE__ */ new WeakSet();
-	walkAst(programRoot, (descendantNode) => {
+	if (hasImportFromModules(programRoot, GENERATED_IMAGE_MODULES)) walkAst(programRoot, (descendantNode) => {
 		if (!isGeneratedImageRendererCall(descendantNode)) return;
 		for (const argument of descendantNode.arguments) markGeneratedImageExpression(argument, programRoot, generatedImageJsxNodes, /* @__PURE__ */ new Set());
 	});
@@ -1974,7 +2031,12 @@ const altText = defineRule({
 		const objectAliases = new Set(settings.object ?? []);
 		const areaAliases = new Set(settings.area ?? []);
 		const inputImageAliases = new Set(settings["input[type=\"image\"]"] ?? []);
+		const fileHasJsxA11ySettings = hasJsxA11ySettings(context.settings);
 		return { JSXOpeningElement(node) {
+			if (!fileHasJsxA11ySettings && isNodeOfType(node.name, "JSXIdentifier")) {
+				const rawName = node.name.name;
+				if (rawName !== "img" && rawName !== "object" && rawName !== "area" && rawName.toLowerCase() !== "input" && !imgAliases.has(rawName) && !objectAliases.has(rawName) && !areaAliases.has(rawName) && !inputImageAliases.has(rawName)) return;
+			}
 			if (isGeneratedImageRenderContext(context, node)) return;
 			const tag = getElementType(node, context.settings);
 			if (checkImg && (tag === "img" || imgAliases.has(tag))) {
@@ -2157,7 +2219,9 @@ const anchorIsValid = defineRule({
 	category: "Accessibility",
 	create: (context) => {
 		const settings = resolveSettings$50(context.settings);
+		const fileHasJsxA11ySettings = hasJsxA11ySettings(context.settings);
 		return { JSXOpeningElement(node) {
+			if (!fileHasJsxA11ySettings && (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a")) return;
 			if (getElementType(node, context.settings) !== "a") return;
 			let hrefAttribute;
 			for (const attributeName of settings.hrefAttributeNames) {
@@ -3460,7 +3524,7 @@ const SECRET_UNAMBIGUOUS_PLACEHOLDER_VALUE_PATTERNS = [
 ];
 const SECRET_CONTEXTUAL_PLACEHOLDER_VALUE_PATTERNS = [/(?:^|[_\-\s])(?:example|sample|dummy)(?:$|[_\-\s])/i];
 const SECRET_PLACEHOLDER_CONTEXT_PATTERN = /(?:placeholder|example|sample|dummy|masked|redacted|mask)/i;
-const SECRET_VARIABLE_PATTERN = /(?:api_?key|secret|token|password|credential|auth)/i;
+const SECRET_VARIABLE_PATTERN = /(?:api_?key|secret|token|password|credential|auth(?!or(?!i[sz])))/i;
 const SECRET_TOOLING_FILE_PATTERN = /(?:^|\/)[^/]+\.config\.[cm]?[jt]s$/;
 const SECRET_TOOLING_RC_FILE_PATTERN = /(?:^|\/)(?:\.[a-z-]+rc|[a-z-]+\.rc)\.[cm]?[jt]s$/;
 const SECRET_TEST_FILE_PATTERN = /(?:^|\/)[^/]+\.(?:test|spec|stories|story|fixture|fixtures)\.[cm]?[jt]sx?$/;
@@ -3583,8 +3647,9 @@ const SECRET_FALSE_POSITIVE_SUFFIXES = new Set([
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 //#endregion
 //#region src/plugin/rules/security-scan/utils/find-suspicious-public-env-secret-name.ts
+const PUBLIC_ENV_SECRET_NAME_GLOBAL_PATTERN = new RegExp(PUBLIC_ENV_SECRET_NAME_PATTERN.source, "gi");
 const findSuspiciousPublicEnvSecretNamePattern = (content) => {
-	for (const match of content.matchAll(new RegExp(PUBLIC_ENV_SECRET_NAME_PATTERN.source, "gi"))) {
+	for (const match of content.matchAll(PUBLIC_ENV_SECRET_NAME_GLOBAL_PATTERN)) {
 		const value = match[0] ?? "";
 		if (!TRUSTED_PUBLIC_SECRET_NAME_PATTERN.test(value)) return new RegExp(escapeRegExp(value));
 	}
@@ -3967,9 +4032,11 @@ const collectScopedReferenceIdentifierNames = (node, into, shadowed) => {
 		return;
 	}
 	if (typeof node.type === "string" && node.type.startsWith("TS")) return;
-	for (const [key, child] of Object.entries(node)) {
+	const nodeRecord = node;
+	for (const key of Object.keys(nodeRecord)) {
 		if (key === "parent") continue;
 		if (TYPE_POSITION_CHILD_KEYS.has(key)) continue;
+		const child = nodeRecord[key];
 		if (Array.isArray(child)) {
 			for (const item of child) if (isAstNode(item)) collectScopedReferenceIdentifierNames(item, into, shadowed);
 		} else if (isAstNode(child)) collectScopedReferenceIdentifierNames(child, into, shadowed);
@@ -4049,62 +4116,56 @@ const collectPatternIdentifiers = (pattern, target) => {
 		for (const element of pattern.elements ?? []) if (element) collectPatternIdentifiers(element, target);
 	} else if (isNodeOfType(pattern, "AssignmentPattern") && pattern.left) collectPatternIdentifiers(pattern.left, target);
 };
-const collectAssignedIdentifiers = (block) => {
-	const assigned = /* @__PURE__ */ new Set();
-	walkAst(block, (child) => {
-		if (isInlineFunctionExpression(child) || isNodeOfType(child, "FunctionDeclaration")) return false;
-		if (isNodeOfType(child, "AssignmentExpression") && child.left) collectPatternIdentifiers(child.left, assigned);
-	});
-	return assigned;
-};
-const collectAwaitedArgIdentifiers = (block) => {
-	const referenced = /* @__PURE__ */ new Set();
-	walkAst(block, (child) => {
-		if (isInlineFunctionExpression(child) || isNodeOfType(child, "FunctionDeclaration")) return false;
-		if (!isNodeOfType(child, "AwaitExpression") || !child.argument) return;
-		collectReferenceIdentifierNames(child.argument, referenced);
-	});
-	return referenced;
-};
 const ARRAY_MUTATION_METHOD_NAMES = new Set([
 	"push",
 	"unshift",
 	"splice"
 ]);
-const collectMutatedArrayNames = (block) => {
-	const mutated = /* @__PURE__ */ new Set();
+const addDerivedBindings = (block, names) => {
+	const declaratorBindings = [];
 	walkAst(block, (child) => {
 		if (child !== block && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = child.callee;
-		if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && ARRAY_MUTATION_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier")) mutated.add(callee.object.name);
+		if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
+		if (!isNodeOfType(child.id, "Identifier")) return;
+		const referencedNames = /* @__PURE__ */ new Set();
+		collectReferenceIdentifierNames(child.init, referencedNames);
+		declaratorBindings.push({
+			declaredName: child.id.name,
+			referencedNames
+		});
 	});
-	return mutated;
-};
-const addDerivedBindings = (block, names) => {
 	let didGrow = true;
 	while (didGrow) {
 		didGrow = false;
-		walkAst(block, (child) => {
-			if (child !== block && isFunctionLike$1(child)) return false;
-			if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
-			if (!isNodeOfType(child.id, "Identifier") || names.has(child.id.name)) return;
-			const initReferences = /* @__PURE__ */ new Set();
-			collectReferenceIdentifierNames(child.init, initReferences);
-			for (const referenced of initReferences) if (names.has(referenced)) {
-				names.add(child.id.name);
+		for (const { declaredName, referencedNames } of declaratorBindings) {
+			if (names.has(declaredName)) continue;
+			for (const referenced of referencedNames) if (names.has(referenced)) {
+				names.add(declaredName);
 				didGrow = true;
 				break;
 			}
-		});
+		}
 	}
 };
 const hasLoopCarriedDependency = (block) => {
-	const carried = collectAssignedIdentifiers(block);
-	for (const name of collectMutatedArrayNames(block)) carried.add(name);
+	const carried = /* @__PURE__ */ new Set();
+	const awaitedReferences = /* @__PURE__ */ new Set();
+	walkAst(block, (child) => {
+		if (child !== block && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "AssignmentExpression") && child.left) {
+			collectPatternIdentifiers(child.left, carried);
+			return;
+		}
+		if (isNodeOfType(child, "AwaitExpression") && child.argument) {
+			collectReferenceIdentifierNames(child.argument, awaitedReferences);
+			return;
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = child.callee;
+		if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && ARRAY_MUTATION_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier")) carried.add(callee.object.name);
+	});
 	if (carried.size === 0) return false;
 	addDerivedBindings(block, carried);
-	const awaitedReferences = collectAwaitedArgIdentifiers(block);
 	for (const name of carried) if (awaitedReferences.has(name)) return true;
 	return false;
 };
@@ -4782,7 +4843,8 @@ const FORM_CONTROL_TAGS = new Set([
 ]);
 const resolveSettings$48 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
-	return { inputComponents: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.autocompleteValid ?? {} : {}).inputComponents ?? [] };
+	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.autocompleteValid ?? {} : {};
+	return { inputComponents: new Set(ruleSettings.inputComponents ?? []) };
 };
 const autocompleteValid = defineRule({
 	id: "autocomplete-valid",
@@ -4795,7 +4857,7 @@ const autocompleteValid = defineRule({
 		const settings = resolveSettings$48(context.settings);
 		return { JSXOpeningElement: (node) => {
 			const tag = getElementType(node, context.settings);
-			if (!FORM_CONTROL_TAGS.has(tag) && !settings.inputComponents.includes(tag)) return;
+			if (!FORM_CONTROL_TAGS.has(tag) && !settings.inputComponents.has(tag)) return;
 			const attribute = hasJsxPropIgnoreCase(node.attributes, "autoComplete");
 			if (!attribute) return;
 			const value = getJsxPropStringValue(attribute);
@@ -4839,9 +4901,8 @@ const isCreateElementCall = (node) => {
 	const callee = node.callee;
 	if (isNodeOfType(callee, "Identifier")) return callee.name === "createElement";
 	if (isNodeOfType(callee, "MemberExpression")) {
-		if (memberChainContainsDocument(callee.object)) return false;
-		if (callee.computed) return isNodeOfType(callee.property, "Literal") && callee.property.value === "createElement";
-		return isNodeOfType(callee.property, "Identifier") && callee.property.name === "createElement";
+		if (!(callee.computed ? isNodeOfType(callee.property, "Literal") && callee.property.value === "createElement" : isNodeOfType(callee.property, "Identifier") && callee.property.name === "createElement")) return false;
+		return !memberChainContainsDocument(callee.object);
 	}
 	return false;
 };
@@ -4867,7 +4928,8 @@ const isValidTypeValue = (rawValue, settings) => {
 	if (rawValue === "reset") return settings.reset;
 	return false;
 };
-const isProvenValidExpression = (expression, settings, resolvedBindings = /* @__PURE__ */ new Set()) => {
+const isProvenValidExpression = (rawExpression, settings, resolvedBindings = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(rawExpression);
 	if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return isValidTypeValue(expression.value, settings);
 	if (isNodeOfType(expression, "TemplateLiteral")) {
 		const staticValue = getStaticTemplateLiteralValue(expression);
@@ -5034,11 +5096,20 @@ const resolveSettings$46 = (settings) => {
 		ignoreExclusiveCheckedAttribute: ruleSettings.ignoreExclusiveCheckedAttribute ?? false
 	};
 };
+const isTruthyDisabledJsxValue = (attribute) => {
+	if (!attribute.value) return true;
+	if (isNodeOfType(attribute.value, "JSXExpressionContainer")) {
+		const expression = attribute.value.expression;
+		return isNodeOfType(expression, "Literal") && expression.value === true;
+	}
+	return false;
+};
 const collectFromJsxAttributes = (attributes) => {
 	let checkedNode = null;
 	let defaultCheckedNode = null;
 	let hasOnChangeOrReadOnly = false;
 	let hasSpread = false;
+	let hasTruthyDisabled = false;
 	for (const attribute of attributes) {
 		if (isNodeOfType(attribute, "JSXSpreadAttribute")) {
 			hasSpread = true;
@@ -5049,12 +5120,14 @@ const collectFromJsxAttributes = (attributes) => {
 		if (name === "checked") checkedNode = attribute;
 		else if (name === "defaultChecked" && !defaultCheckedNode) defaultCheckedNode = attribute;
 		else if (name === "onChange" || name === "readOnly") hasOnChangeOrReadOnly = true;
+		else if (name === "disabled" && isTruthyDisabledJsxValue(attribute)) hasTruthyDisabled = true;
 	}
 	return {
 		checkedNode,
 		defaultCheckedNode,
 		hasOnChangeOrReadOnly,
-		hasSpread
+		hasSpread,
+		hasTruthyDisabled
 	};
 };
 const collectFromObjectProperties = (objectExpression) => {
@@ -5062,6 +5135,7 @@ const collectFromObjectProperties = (objectExpression) => {
 	let defaultCheckedNode = null;
 	let hasOnChangeOrReadOnly = false;
 	let hasSpread = false;
+	let hasTruthyDisabled = false;
 	for (const property of objectExpression.properties) {
 		if (isNodeOfType(property, "SpreadElement")) {
 			hasSpread = true;
@@ -5076,12 +5150,17 @@ const collectFromObjectProperties = (objectExpression) => {
 		if (propertyName === "checked") checkedNode = property;
 		else if (propertyName === "defaultChecked" && !defaultCheckedNode) defaultCheckedNode = property;
 		else if (propertyName === "onChange" || propertyName === "readOnly") hasOnChangeOrReadOnly = true;
+		else if (propertyName === "disabled") {
+			const propertyValue = property.value;
+			if (isNodeOfType(propertyValue, "Literal") && propertyValue.value === true) hasTruthyDisabled = true;
+		}
 	}
 	return {
 		checkedNode,
 		defaultCheckedNode,
 		hasOnChangeOrReadOnly,
-		hasSpread
+		hasSpread,
+		hasTruthyDisabled
 	};
 };
 const checkedRequiresOnchangeOrReadonly = defineRule({
@@ -5097,7 +5176,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 				node: presence.checkedNode,
 				message: EXCLUSIVE_MESSAGE
 			});
-			if (presence.checkedNode && !presence.hasOnChangeOrReadOnly && !presence.hasSpread && !settings.ignoreMissingProperties) context.report({
+			if (presence.checkedNode && !presence.hasOnChangeOrReadOnly && !presence.hasSpread && !presence.hasTruthyDisabled && !settings.ignoreMissingProperties) context.report({
 				node: presence.checkedNode,
 				message: MISSING_MESSAGE$1
 			});
@@ -5658,12 +5737,20 @@ const getTemplateInterpolations = (valueTail) => {
 	return interpolations === null ? "" : interpolations.join(" ");
 };
 const isInertParseTarget = (target, fileContent) => {
+	const fileHasCreateElement = fileContent.includes("createElement");
+	const fileHasIsolatedDocument = fileContent.includes("createHTMLDocument");
+	if (!fileHasCreateElement && !fileHasIsolatedDocument) return false;
 	const escapedTarget = escapeRegExp(target);
 	const escapedRoot = escapeRegExp(target.split(".")[0] ?? target);
 	if (new RegExp(`\\b${escapedRoot}\\s*=\\s*[^\\n;]*(?:getElementById|querySelector|getElementsBy|\\.current\\b|document\\.(?:body|head|documentElement))`).test(fileContent)) return false;
-	if (new RegExp(`${escapedTarget}\\s*=\\s*document\\.createElement\\(\\s*["'\`]template["'\`]`).test(fileContent)) return true;
-	if (new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateElement\\(\\s*["'\`](?:style|textarea)["'\`]`).test(fileContent)) return true;
-	if (new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateHTMLDocument\\s*\\(`).test(fileContent)) return true;
+	if (fileHasCreateElement) {
+		if (new RegExp(`${escapedTarget}\\s*=\\s*document\\.createElement\\(\\s*["'\`]template["'\`]`).test(fileContent)) return true;
+		if (new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateElement\\(\\s*["'\`](?:style|textarea)["'\`]`).test(fileContent)) return true;
+	}
+	if (fileHasIsolatedDocument) {
+		if (new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateHTMLDocument\\s*\\(`).test(fileContent)) return true;
+	}
+	if (!fileHasCreateElement) return false;
 	if (!new RegExp(`${escapedRoot}\\s*=\\s*[^\\n;]*\\bcreateElement\\s*\\(`).test(fileContent)) return false;
 	const attachedToLiveTreePattern = new RegExp(`${LIVE_DOM_ATTACH_PATTERN.source}[^)]*\\b${escapedRoot}\\b`);
 	const returnedAsNodePattern = new RegExp(`\\breturn\\b[^\\n]*\\b${escapedRoot}\\b(?!\\s*\\.\\s*(?:textContent|innerText|innerHTML|outerHTML))`);
@@ -5756,10 +5843,9 @@ const dangerousHtmlSink = defineRule({
 				const valueIdentifier = valueExpression.match(/^[\w$]+/)?.[0];
 				if (valueIdentifier !== void 0) {
 					const escapedIdentifier = escapeRegExp(valueIdentifier);
-					const fromSerializer = new RegExp(`\\b${escapedIdentifier}\\b\\s*${SERIALIZER_ASSIGNMENT_PATTERN.source}`, "i");
-					const fromSanitizer = new RegExp(`\\b${escapedIdentifier}\\b\\s*${SANITIZED_ASSIGNMENT_PATTERN.source}`, "i");
-					const fromDomContent = new RegExp(`\\b${escapedIdentifier}\\b\\s*${DOM_CONTENT_ASSIGNMENT_PATTERN.source}`);
-					if (fromSerializer.test(file.content) || fromSanitizer.test(file.content) || fromDomContent.test(file.content)) continue;
+					if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${SERIALIZER_ASSIGNMENT_PATTERN.source}`, "i").test(file.content)) continue;
+					if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${SANITIZED_ASSIGNMENT_PATTERN.source}`, "i").test(file.content)) continue;
+					if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${DOM_CONTENT_ASSIGNMENT_PATTERN.source}`).test(file.content)) continue;
 				}
 			}
 			const sinkTargetMatch = INNERHTML_TARGET_PATTERN.exec(line);
@@ -5908,6 +5994,7 @@ const noRedundantPaddingAxes = defineRule({
 		if (!isNodeOfType(jsxAttribute.name, "JSXIdentifier") || jsxAttribute.name.name !== "className") return;
 		const classNameLiteral = getClassNameLiteral(jsxAttribute);
 		if (!classNameLiteral) return;
+		if (!classNameLiteral.includes("px-") || !classNameLiteral.includes("py-")) return;
 		if (hasResponsivePrefix(classNameLiteral, "px") || hasResponsivePrefix(classNameLiteral, "py")) return;
 		const matchedPairs = collectAxisShorthandPairs(classNameLiteral, PADDING_HORIZONTAL_AXIS_PATTERN, PADDING_VERTICAL_AXIS_PATTERN);
 		if (matchedPairs.length === 0) return;
@@ -5932,6 +6019,7 @@ const noRedundantSizeAxes = defineRule({
 		if (!isNodeOfType(jsxAttribute.name, "JSXIdentifier") || jsxAttribute.name.name !== "className") return;
 		const classNameLiteral = getClassNameLiteral(jsxAttribute);
 		if (!classNameLiteral) return;
+		if (!classNameLiteral.includes("w-") || !classNameLiteral.includes("h-")) return;
 		if (hasResponsivePrefix(classNameLiteral, "w") || hasResponsivePrefix(classNameLiteral, "h")) return;
 		const matchedPairs = collectAxisShorthandPairs(classNameLiteral, SIZE_WIDTH_AXIS_PATTERN, SIZE_HEIGHT_AXIS_PATTERN);
 		if (matchedPairs.length === 0) return;
@@ -5956,6 +6044,7 @@ const noSpaceOnFlexChildren = defineRule({
 		if (!isNodeOfType(jsxAttribute.name, "JSXIdentifier") || jsxAttribute.name.name !== "className") return;
 		const classNameLiteral = getClassNameLiteral(jsxAttribute);
 		if (!classNameLiteral) return;
+		if (!classNameLiteral.includes("space-")) return;
 		const tokens = tokenizeClassName(classNameLiteral);
 		let hasFlexOrGridLayout = false;
 		for (const token of tokens) {
@@ -6147,7 +6236,10 @@ const isReactVersionAtLeast$1 = (version, major, minor) => {
 	const actualMinor = Number(match[2]);
 	return actualMajor > major || actualMajor === major && actualMinor >= minor;
 };
+const containsJsxCache = /* @__PURE__ */ new WeakMap();
 const containsJsx$1 = (root) => {
+	const cached = containsJsxCache.get(root);
+	if (cached !== void 0) return cached;
 	let found = false;
 	const visit = (node) => {
 		if (found) return;
@@ -6170,6 +6262,7 @@ const containsJsx$1 = (root) => {
 		}
 	};
 	visit(root);
+	containsJsxCache.set(root, found);
 	return found;
 };
 const getStaticMemberName = (node) => {
@@ -6261,27 +6354,6 @@ const hasDisplayNameMember = (classNode) => {
 	for (const member of members) if ((isNodeOfType(member, "PropertyDefinition") || isNodeOfType(member, "MethodDefinition")) && "static" in member && member.static && isNodeOfType(member.key, "Identifier") && member.key.name === "displayName") return true;
 	return false;
 };
-const hasDisplayNameAssignment = (className, programRoot) => {
-	let found = false;
-	const visit = (node) => {
-		if (found) return;
-		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && isNodeOfType(node.left.object, "Identifier") && node.left.object.name === className && getStaticMemberName(node.left) === "displayName") {
-			found = true;
-			return;
-		}
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-			if (found) return;
-		}
-	};
-	visit(programRoot);
-	return found;
-};
 const memberExpressionPath = (node) => {
 	if (isNodeOfType(node, "Identifier")) return [node.name];
 	if (!isNodeOfType(node, "MemberExpression")) return [];
@@ -6289,15 +6361,16 @@ const memberExpressionPath = (node) => {
 	const propertyName = getStaticMemberName(node);
 	return propertyName ? [...objectPath, propertyName] : objectPath;
 };
-const hasDisplayNameAssignmentForProperty = (propertyName, programRoot) => {
-	let found = false;
+const displayNameAssignmentIndexCache = /* @__PURE__ */ new WeakMap();
+const getDisplayNameAssignmentIndex = (programRoot) => {
+	const cached = displayNameAssignmentIndexCache.get(programRoot);
+	if (cached) return cached;
+	const identifierTargets = /* @__PURE__ */ new Set();
+	const memberPathSegments = /* @__PURE__ */ new Set();
 	const visit = (node) => {
-		if (found) return;
 		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName(node.left) === "displayName") {
-			if (memberExpressionPath(node.left.object).includes(propertyName)) {
-				found = true;
-				return;
-			}
+			if (isNodeOfType(node.left.object, "Identifier")) identifierTargets.add(node.left.object.name);
+			for (const segment of memberExpressionPath(node.left.object)) memberPathSegments.add(segment);
 		}
 		const record = node;
 		for (const key of Object.keys(record)) {
@@ -6306,12 +6379,18 @@ const hasDisplayNameAssignmentForProperty = (propertyName, programRoot) => {
 			if (Array.isArray(child)) {
 				for (const item of child) if (isAstNode(item)) visit(item);
 			} else if (isAstNode(child)) visit(child);
-			if (found) return;
 		}
 	};
 	visit(programRoot);
-	return found;
+	const index = {
+		identifierTargets,
+		memberPathSegments
+	};
+	displayNameAssignmentIndexCache.set(programRoot, index);
+	return index;
 };
+const hasDisplayNameAssignment = (className, programRoot) => getDisplayNameAssignmentIndex(programRoot).identifierTargets.has(className);
+const hasDisplayNameAssignmentForProperty = (propertyName, programRoot) => getDisplayNameAssignmentIndex(programRoot).memberPathSegments.has(propertyName);
 const displayName = defineRule({
 	id: "display-name",
 	title: "Component missing display name",
@@ -6371,7 +6450,7 @@ const displayName = defineRule({
 			},
 			ArrowFunctionExpression(node) {
 				if (!containsJsx$1(node)) return;
-				if (isNodeOfType(node.parent, "ArrowFunctionExpression")) {
+				if (isNodeOfType(node.parent, "ArrowFunctionExpression") || isNodeOfType(node.parent, "ReturnStatement")) {
 					reportAt(node);
 					return;
 				}
@@ -7183,27 +7262,8 @@ const isDescendantScope = (inner, outer) => {
 	return false;
 };
 //#endregion
-//#region src/plugin/utils/is-ast-descendant.ts
-/**
-* True when `inner` is `outer` itself or any descendant in the AST
-* `parent` chain. Walks `inner.parent` upward and stops at either a
-* match (`true`) or the chain's root (`false`).
-*
-* Was duplicated byte-identical in:
-* - exhaustive-deps-symbol-stability.ts
-* - semantic/closure-captures.ts
-*/
-const isAstDescendant = (inner, outer) => {
-	let current = inner;
-	while (current) {
-		if (current === outer) return true;
-		current = current.parent ?? null;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/semantic/closure-captures.ts
-const closureCaptures = (functionNode, scopes) => {
+const computeClosureCaptures = (functionNode, scopes) => {
 	const functionScope = scopes.ownScopeFor(functionNode) ?? scopes.scopeFor(functionNode);
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -7238,7 +7298,20 @@ const closureCaptures = (functionNode, scopes) => {
 		}
 	};
 	visit(functionNode);
-	return out.filter((reference) => isAstDescendant(reference.identifier, functionNode));
+	return out;
+};
+const capturesByAnalysis = /* @__PURE__ */ new WeakMap();
+const closureCaptures = (functionNode, scopes) => {
+	let capturesByFunction = capturesByAnalysis.get(scopes);
+	if (!capturesByFunction) {
+		capturesByFunction = /* @__PURE__ */ new WeakMap();
+		capturesByAnalysis.set(scopes, capturesByFunction);
+	}
+	const memoizedCaptures = capturesByFunction.get(functionNode);
+	if (memoizedCaptures) return memoizedCaptures;
+	const computedCaptures = computeClosureCaptures(functionNode, scopes);
+	capturesByFunction.set(functionNode, computedCaptures);
+	return computedCaptures;
 };
 //#endregion
 //#region src/plugin/utils/is-react-hook-name.ts
@@ -7294,7 +7367,7 @@ const TRANSPARENT_WRAPPER_TYPES = new Set([
 	"ParenthesizedExpression",
 	"ChainExpression"
 ]);
-const unwrapExpression$2 = (node) => {
+const unwrapExpression$3 = (node) => {
 	let current = node;
 	while (TRANSPARENT_WRAPPER_TYPES.has(current.type)) {
 		const inner = current.expression;
@@ -7367,6 +7440,25 @@ const resolveExhaustiveDepsSettings = (settings) => {
 	};
 };
 //#endregion
+//#region src/plugin/utils/is-ast-descendant.ts
+/**
+* True when `inner` is `outer` itself or any descendant in the AST
+* `parent` chain. Walks `inner.parent` upward and stops at either a
+* match (`true`) or the chain's root (`false`).
+*
+* Was duplicated byte-identical in:
+* - exhaustive-deps-symbol-stability.ts
+* - semantic/closure-captures.ts
+*/
+const isAstDescendant = (inner, outer) => {
+	let current = inner;
+	while (current) {
+		if (current === outer) return true;
+		current = current.parent ?? null;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-symbol-stability.ts
 /**
 * Symbol-stability helpers consumed by the `exhaustive-deps` rule.
@@ -7401,7 +7493,7 @@ const symbolHasStableHookOrigin = (symbol) => {
 	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
 	const initializerRaw = declarator.init;
 	if (!initializerRaw) return false;
-	const initializer = unwrapExpression$2(initializerRaw);
+	const initializer = unwrapExpression$3(initializerRaw);
 	if (symbol.kind === "const") {
 		if (isNodeOfType(initializer, "Literal") && (initializer.value === null || typeof initializer.value === "number" || typeof initializer.value === "string" || typeof initializer.value === "boolean")) return true;
 		if (isNodeOfType(initializer, "TemplateLiteral") && getStaticTemplateLiteralValue(initializer) !== null) return true;
@@ -7421,13 +7513,13 @@ const symbolHasStableHookOrigin = (symbol) => {
 	return false;
 };
 const symbolHasUseEffectEventOrigin = (symbol) => {
-	const initializer = symbol.initializer ? unwrapExpression$2(symbol.initializer) : null;
+	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
 	return getHookName(initializer.callee) === "useEffectEvent";
 };
 const getFunctionValueNode = (symbol) => {
 	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return symbol.declarationNode;
-	const initializer = symbol.initializer ? unwrapExpression$2(symbol.initializer) : null;
+	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
 	if (initializer && (isNodeOfType(initializer, "FunctionExpression") || isNodeOfType(initializer, "ArrowFunctionExpression"))) return initializer;
 	return null;
 };
@@ -7523,6 +7615,14 @@ const flattenReferenceRootName = (reference) => {
 	if (isNodeOfType(referencedIdentifier, "JSXIdentifier")) return referencedIdentifier.name;
 	return "";
 };
+const REF_CURRENT_SEGMENT = ".current";
+const truncateAtRefCurrent = (chain) => {
+	const refCurrentIndex = chain.indexOf(REF_CURRENT_SEGMENT);
+	if (refCurrentIndex === -1) return chain;
+	const segmentEndIndex = refCurrentIndex + 8;
+	if (segmentEndIndex === chain.length || chain[segmentEndIndex] === ".") return chain.slice(0, refCurrentIndex);
+	return chain;
+};
 const computeDepKey = (reference) => {
 	const referencedIdentifier = reference.identifier;
 	let parent = referencedIdentifier.parent ?? null;
@@ -7553,21 +7653,22 @@ const computeDepKey = (reference) => {
 	const declarator = outermost.parent;
 	if (declarator && isNodeOfType(declarator, "VariableDeclarator") && declarator.init === outermost) {
 		const destructuredPath = getDestructuredPropertyPath(declarator.id);
-		if (destructuredPath) return `${fullName}.${destructuredPath}`;
+		if (destructuredPath) return truncateAtRefCurrent(`${fullName}.${destructuredPath}`);
 	}
+	const truncatedName = truncateAtRefCurrent(fullName);
+	if (truncatedName !== fullName) return truncatedName;
 	if (reference.flag !== "read") {
 		const lastDotIndex = fullName.lastIndexOf(".");
 		if (lastDotIndex !== -1) return fullName.slice(0, lastDotIndex);
 	}
-	if (fullName.endsWith(".current")) return fullName.slice(0, -8);
 	return fullName;
 };
 const computeDeclaredDepKey = (entry) => {
-	const stripped = unwrapExpression$2(entry);
+	const stripped = unwrapExpression$3(entry);
 	if (isNodeOfType(stripped, "Identifier")) return stripped.name;
 	if (isNodeOfType(stripped, "MemberExpression")) return stringifyMemberChain(stripped);
 	if (isNodeOfType(stripped, "CallExpression") && (stripped.arguments?.length ?? 0) === 0) {
-		const callee = unwrapExpression$2(stripped.callee);
+		const callee = unwrapExpression$3(stripped.callee);
 		if (isNodeOfType(callee, "Identifier")) return callee.name;
 		if (isNodeOfType(callee, "MemberExpression") && !hasComputedMemberExpression(callee)) return stringifyMemberChain(callee);
 	}
@@ -7575,16 +7676,16 @@ const computeDeclaredDepKey = (entry) => {
 };
 const depsArrayContainsIdentifier = (depsArgument, identifierName) => {
 	if (!depsArgument) return false;
-	const strippedDepsArgument = unwrapExpression$2(depsArgument);
+	const strippedDepsArgument = unwrapExpression$3(depsArgument);
 	if (!isNodeOfType(strippedDepsArgument, "ArrayExpression")) return false;
 	return strippedDepsArgument.elements.some((element) => {
 		if (!element) return false;
-		const strippedElement = unwrapExpression$2(element);
+		const strippedElement = unwrapExpression$3(element);
 		return isNodeOfType(strippedElement, "Identifier") && strippedElement.name === identifierName;
 	});
 };
 const stringifyMemberChain = (node) => {
-	const stripped = unwrapExpression$2(node);
+	const stripped = unwrapExpression$3(node);
 	if (isNodeOfType(stripped, "Identifier")) return stripped.name;
 	if (isNodeOfType(stripped, "ThisExpression")) return "this";
 	if (isNodeOfType(stripped, "MemberExpression")) {
@@ -7626,13 +7727,13 @@ const hasBroaderDeclaredDependency = (declaredKey, declaredKeys) => {
 	return false;
 };
 const getMemberRootIdentifier = (node) => {
-	const stripped = unwrapExpression$2(node);
+	const stripped = unwrapExpression$3(node);
 	if (isNodeOfType(stripped, "Identifier")) return stripped;
 	if (isNodeOfType(stripped, "MemberExpression")) return getMemberRootIdentifier(stripped.object);
 	return null;
 };
 const hasComputedMemberExpression = (node) => {
-	const stripped = unwrapExpression$2(node);
+	const stripped = unwrapExpression$3(node);
 	if (!isNodeOfType(stripped, "MemberExpression")) return false;
 	if (stripped.computed) return true;
 	return hasComputedMemberExpression(stripped.object);
@@ -7648,7 +7749,7 @@ const getRootSymbol = (node, scopes) => {
 	return rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
 };
 const getDeclaredDepSymbolSource = (node) => {
-	const stripped = unwrapExpression$2(node);
+	const stripped = unwrapExpression$3(node);
 	if (isNodeOfType(stripped, "CallExpression") && (stripped.arguments?.length ?? 0) === 0) return stripped.callee;
 	return node;
 };
@@ -7658,7 +7759,7 @@ const isRegExpLiteral = (node) => {
 };
 const isUnstableInitializer = (node) => {
 	if (!node) return false;
-	const stripped = unwrapExpression$2(node);
+	const stripped = unwrapExpression$3(node);
 	if (isRegExpLiteral(stripped)) return true;
 	if (isNodeOfType(stripped, "ConditionalExpression")) return isUnstableInitializer(stripped.consequent) || isUnstableInitializer(stripped.alternate);
 	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left) || isUnstableInitializer(stripped.right);
@@ -7750,9 +7851,9 @@ const findRefCurrentInCleanup = (callback, scopes) => {
 	};
 	findReturn(callback);
 	if (!cleanupFunction) return null;
-	let refCurrentName = null;
+	let found = null;
 	const visitCleanup = (node) => {
-		if (refCurrentName) return;
+		if (found) return;
 		if (isNodeOfType(node, "MemberExpression")) {
 			const candidateName = getRefCurrentNameFromMemberExpression(node);
 			if (candidateName) {
@@ -7760,7 +7861,10 @@ const findRefCurrentInCleanup = (callback, scopes) => {
 				const symbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
 				const callbackScope = scopes.ownScopeFor(callback) ?? scopes.scopeFor(callback);
 				if (!symbol || !isDescendantScope(symbol.scope, callbackScope)) {
-					refCurrentName = candidateName;
+					found = {
+						refCurrentName: candidateName,
+						refSymbol: symbol
+					};
 					return;
 				}
 			}
@@ -7775,7 +7879,19 @@ const findRefCurrentInCleanup = (callback, scopes) => {
 		}
 	};
 	visitCleanup(cleanupFunction);
-	return refCurrentName;
+	return found;
+};
+const hasRefCurrentAssignmentInComponent = (refSymbol) => {
+	if (!refSymbol) return false;
+	for (const reference of refSymbol.references) {
+		const memberParent = reference.identifier.parent;
+		if (!memberParent || !isNodeOfType(memberParent, "MemberExpression")) continue;
+		if (memberParent.object !== reference.identifier) continue;
+		if (getRefCurrentNameFromMemberExpression(memberParent) === null) continue;
+		const assignmentParent = memberParent.parent;
+		if (assignmentParent && isNodeOfType(assignmentParent, "AssignmentExpression") && assignmentParent.left === memberParent) return true;
+	}
+	return false;
 };
 const hasRefCurrentAssignment = (callback, refCurrentName) => {
 	let didAssignRefCurrent = false;
@@ -7814,9 +7930,21 @@ const hasMemberCallForRoot = (node, rootName) => {
 	const visit = (current) => {
 		if (didFindMemberCall) return;
 		if (isNodeOfType(current, "CallExpression")) {
-			if (getMemberRootIdentifier(unwrapExpression$2(current.callee))?.name === rootName) {
-				didFindMemberCall = true;
-				return;
+			const callee = unwrapExpression$3(current.callee);
+			if (isNodeOfType(callee, "MemberExpression")) {
+				let chainObject = unwrapExpression$3(callee.object);
+				let doesChainPassThroughCurrent = false;
+				while (chainObject && isNodeOfType(chainObject, "MemberExpression")) {
+					if (isNodeOfType(chainObject.property, "Identifier") && chainObject.property.name === "current") {
+						doesChainPassThroughCurrent = true;
+						break;
+					}
+					chainObject = unwrapExpression$3(chainObject.object);
+				}
+				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName) {
+					didFindMemberCall = true;
+					return;
+				}
 			}
 		}
 		const record = current;
@@ -7877,7 +8005,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				return;
 			}
 			const depsArgumentRaw = node.arguments[depsArgumentIndex];
-			const callbackExpression = unwrapExpression$2(callbackArgument);
+			const callbackExpression = unwrapExpression$3(callbackArgument);
 			let callbackToAnalyze = null;
 			const forcedCaptureKeys = /* @__PURE__ */ new Set();
 			if (isNodeOfType(callbackExpression, "ArrowFunctionExpression") || isNodeOfType(callbackExpression, "FunctionExpression")) callbackToAnalyze = callbackExpression;
@@ -7885,7 +8013,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				const callbackSymbol = context.scopes.symbolFor(callbackExpression);
 				const functionValueNode = callbackSymbol ? getFunctionValueNode(callbackSymbol) : null;
 				if (functionValueNode) callbackToAnalyze = functionValueNode;
-				else if (callbackSymbol?.initializer && isNodeOfType(unwrapExpression$2(callbackSymbol.initializer), "CallExpression")) forcedCaptureKeys.add(callbackExpression.name);
+				else if (callbackSymbol?.initializer && isNodeOfType(unwrapExpression$3(callbackSymbol.initializer), "CallExpression")) forcedCaptureKeys.add(callbackExpression.name);
 				else if (depsArgumentRaw) {
 					if (depsArrayContainsIdentifier(depsArgumentRaw, callbackExpression.name)) return;
 					context.report({
@@ -7918,11 +8046,11 @@ If the missing value is recreated every render, move it inside the hook or stabi
 					message: buildAssignmentMessage(assignment.name)
 				});
 				if (outerAssignments.length > 0) return;
-				const refCurrentName = findRefCurrentInCleanup(callbackToAnalyze, context.scopes);
+				const refCurrentInCleanup = findRefCurrentInCleanup(callbackToAnalyze, context.scopes);
 				const shouldCheckRefCleanup = EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) || Boolean(additionalHooksRegex && additionalHooksRegex.test(hookName));
-				if (refCurrentName && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentName)) context.report({
+				if (refCurrentInCleanup && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) && !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol)) context.report({
 					node: callbackToAnalyze,
-					message: buildRefCleanupMessage(refCurrentName)
+					message: buildRefCleanupMessage(refCurrentInCleanup.refCurrentName)
 				});
 			}
 			if (!depsArgumentRaw) {
@@ -7942,8 +8070,16 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				});
 				return;
 			}
-			const depsArgument = unwrapExpression$2(depsArgumentRaw);
-			if (isNodeOfType(depsArgument, "Literal") && depsArgument.value === null || isNodeOfType(depsArgument, "Identifier") && depsArgument.name === "undefined") {
+			const depsArgument = unwrapExpression$3(depsArgumentRaw);
+			if (isNodeOfType(depsArgument, "Identifier") && depsArgument.name === "undefined") {
+				if (isAutoDependenciesHook(hookName)) return;
+				if (HOOKS_REQUIRING_DEPS_ARRAY.has(hookName)) context.report({
+					node: depsArgument,
+					message: buildMissingDepArrayMessage(hookName)
+				});
+				return;
+			}
+			if (isNodeOfType(depsArgument, "Literal") && depsArgument.value === null) {
 				if (isAutoDependenciesHook(hookName)) return;
 				if (HOOKS_REQUIRING_DEPS_ARRAY.has(hookName)) {
 					context.report({
@@ -7952,19 +8088,6 @@ If the missing value is recreated every render, move it inside the hook or stabi
 					});
 					return;
 				}
-				const nonArrayCaptureKeys = callbackToAnalyze !== null ? new Set(collectCaptureDepKeys(callbackToAnalyze, context.scopes).keys) : /* @__PURE__ */ new Set();
-				for (const forcedCaptureKey of forcedCaptureKeys) nonArrayCaptureKeys.add(forcedCaptureKey);
-				if (nonArrayCaptureKeys.size > 0) {
-					context.report({
-						node: depsArgument,
-						message: buildNonArrayDepsMessage(hookName)
-					});
-					context.report({
-						node: depsArgument,
-						message: buildMissingDepMessage(hookName, [...nonArrayCaptureKeys].join(", "))
-					});
-				}
-				return;
 			}
 			if (!isNodeOfType(depsArgument, "ArrayExpression")) {
 				context.report({
@@ -7983,11 +8106,11 @@ If the missing value is recreated every render, move it inside the hook or stabi
 			for (const forcedCaptureKey of forcedCaptureKeys) captureKeys.add(forcedCaptureKey);
 			const hasLiteralDepElement = depsArgument.elements.some((element) => {
 				if (!element) return false;
-				return isLiteralOrEmptyTemplate(unwrapExpression$2(element));
+				return isLiteralOrEmptyTemplate(unwrapExpression$3(element));
 			});
 			const hasNonStringLiteralDep = depsArgument.elements.some((element) => {
 				if (!element) return false;
-				return isNonStringLiteral(unwrapExpression$2(element));
+				return isNonStringLiteral(unwrapExpression$3(element));
 			});
 			if (hasNonStringLiteralDep) context.report({
 				node: depsArgument,
@@ -8008,7 +8131,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 					});
 					continue;
 				}
-				const stripped = unwrapExpression$2(elementNode);
+				const stripped = unwrapExpression$3(elementNode);
 				if (isLiteralOrEmptyTemplate(stripped)) continue;
 				if (isNodeOfType(stripped, "Identifier")) {
 					const depSymbol = context.scopes.symbolFor(stripped);
@@ -8150,7 +8273,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (missingCaptureKeys.length > 0 && isOuterFunctionScopeDep(reportNode, callbackToAnalyze ?? callbackArgument, context.scopes)) continue;
 				const rootSymbol = getRootSymbol(reportNode, context.scopes);
 				if (rootSymbol && missingCaptureKeys.length > 0 && isRecursiveInitializerCapture(rootSymbol, callbackToAnalyze ?? callbackArgument)) continue;
-				if (isNodeOfType(unwrapExpression$2(reportNode), "CallExpression")) {
+				if (isNodeOfType(unwrapExpression$3(reportNode), "CallExpression")) {
 					context.report({
 						node: reportNode,
 						message: buildComplexDepMessage(hookName)
@@ -8266,9 +8389,14 @@ const firebaseQueryFilterAsAuth = defineRule({
 * `*Handler`), so the cheap escape-then-replace shape is enough
 * and avoids pulling picomatch into the per-file rule path.
 */
+const compiledGlobs = /* @__PURE__ */ new Map();
 const compileGlob = (pattern) => {
+	const cached = compiledGlobs.get(pattern);
+	if (cached) return cached;
 	const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*");
-	return new RegExp(`^${escaped}$`);
+	const compiled = new RegExp(`^${escaped}$`);
+	compiledGlobs.set(pattern, compiled);
+	return compiled;
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-component-props.ts
@@ -8558,7 +8686,7 @@ const DEFAULT_HEADING_TAGS = [
 const resolveSettings$40 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.headingHasContent ?? {} : {};
-	return { headingTags: [...DEFAULT_HEADING_TAGS, ...ruleSettings.components ?? []] };
+	return { headingTags: new Set([...DEFAULT_HEADING_TAGS, ...ruleSettings.components ?? []]) };
 };
 const headingHasContent = defineRule({
 	id: "heading-has-content",
@@ -8571,7 +8699,7 @@ const headingHasContent = defineRule({
 		const settings = resolveSettings$40(context.settings);
 		return { JSXOpeningElement(node) {
 			const elementType = getElementType(node, context.settings);
-			if (!settings.headingTags.includes(elementType)) return;
+			if (!settings.headingTags.has(elementType)) return;
 			const parent = node.parent;
 			if (parent && isNodeOfType(parent, "JSXElement")) {
 				if (objectHasAccessibleChild(parent, context.settings)) return;
@@ -9169,9 +9297,9 @@ const resolveSettings$37 = (settings) => {
 	};
 };
 const isWordBoundary = (text, start, end) => {
-	const isAlphanumeric = (charCode) => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122;
-	const startsBoundary = start === 0 || !isAlphanumeric(text.charCodeAt(start - 1));
-	const endsBoundary = end === text.length || !isAlphanumeric(text.charCodeAt(end));
+	const isWordCharacter = (charCode) => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || charCode === 45 || charCode === 95;
+	const startsBoundary = start === 0 || !isWordCharacter(text.charCodeAt(start - 1));
+	const endsBoundary = end === text.length || !isWordCharacter(text.charCodeAt(end));
 	return startsBoundary && endsBoundary;
 };
 const containsRedundantWord = (altText, words) => {
@@ -9210,10 +9338,10 @@ const imgRedundantAlt = defineRule({
 		if (isGeneratedImageRenderContext(context)) return {};
 		const settings = resolveSettings$37(context.settings);
 		return { JSXOpeningElement(node) {
-			if (isGeneratedImageRenderContext(context, node)) return;
 			const tag = getElementType(node, context.settings);
 			if (!settings.components.includes(tag)) return;
 			if (isHiddenFromScreenReader(node, context.settings)) return;
+			if (isGeneratedImageRenderContext(context, node)) return;
 			const altAttribute = hasJsxPropIgnoreCase(node.attributes, "alt");
 			if (!altAttribute) return;
 			if (altValueRedundant(altAttribute, settings.words)) context.report({
@@ -9268,6 +9396,7 @@ const SECURITY_RANDOM_CONTEXT_PATTERN = /token|secret|password|nonce|salt|csrf|c
 const UI_NONCE_CONTEXT_PATTERN = /(?:focus|render|refresh|remount|redraw|animation|layout|cache|update)[-_]?nonce/i;
 const MATH_RANDOM_CALL_PATTERN = /Math\.random\s*\(/g;
 const SECURITY_CONTEXT_WINDOW_CHARS = 250;
+const CRYPTO_SURFACE_TRIGGER_PATTERN = /createHash|md5|cipher|encrypt|decrypt|crypto|signature|Math\.random/i;
 const findMatchIndexNearContext = (content, pattern, contextPattern, excludeContextPattern) => {
 	for (const callMatch of content.matchAll(pattern)) {
 		const surroundingText = content.slice(Math.max(0, callMatch.index - SECURITY_CONTEXT_WINDOW_CHARS), callMatch.index + SECURITY_CONTEXT_WINDOW_CHARS);
@@ -9297,6 +9426,7 @@ const insecureCryptoRisk = defineRule({
 		if (!isProductionSourcePath(file.relativePath)) return [];
 		if (DEMO_CONTEXT_PATTERN.test(file.relativePath)) return [];
 		if (PROTOCOL_MANDATED_HASH_CONTEXT_PATTERN.test(file.relativePath)) return [];
+		if (!CRYPTO_SURFACE_TRIGGER_PATTERN.test(file.content)) return [];
 		const content = getScannableContent(file);
 		let matchIndex = findMatchIndexNearContext(content, WEAK_HASH_PATTERN, SECURITY_CONTEXT_PATTERN, PROTOCOL_MANDATED_HASH_CONTEXT_PATTERN);
 		if (matchIndex < 0) matchIndex = content.search(WEAK_CIPHER_ALGORITHM_PATTERN);
@@ -9475,6 +9605,7 @@ const KEYBOARD_EVENT_HANDLERS = [
 	"onKeyUp"
 ];
 const ALL_EVENT_HANDLERS = [...MOUSE_EVENT_HANDLERS, ...KEYBOARD_EVENT_HANDLERS];
+const ALL_EVENT_HANDLERS_LOWER = new Set(ALL_EVENT_HANDLERS.map((handlerName) => handlerName.toLowerCase()));
 //#endregion
 //#region src/plugin/utils/is-disabled-element.ts
 const isDisabledElement = (openingElement) => {
@@ -9529,15 +9660,25 @@ const interactiveSupportsFocus = defineRule({
 		const settings = resolveSettings$36(context.settings);
 		const tabbableSet = new Set(settings.tabbable);
 		return { JSXOpeningElement(node) {
+			if (node.attributes.length === 0) return;
 			if (hasJsxSpreadAttribute$1(node.attributes)) return;
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 			const role = roleAttribute ? getJsxPropStringValue(roleAttribute) : null;
+			if (!role) return;
+			let hasInteractiveHandler = false;
+			for (const attribute of node.attributes) {
+				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+				const attributeName = getJsxAttributeName(attribute.name);
+				if (attributeName && ALL_EVENT_HANDLERS_LOWER.has(attributeName.toLowerCase())) {
+					hasInteractiveHandler = true;
+					break;
+				}
+			}
+			if (!hasInteractiveHandler) return;
 			const elementType = getElementType(node, context.settings);
 			if (!HTML_TAGS.has(elementType)) return;
-			const hasInteractiveHandler = ALL_EVENT_HANDLERS.some((handler) => Boolean(hasJsxPropIgnoreCase(node.attributes, handler)));
+			if (isDisabledElement(node) || isHiddenFromScreenReader(node, context.settings) || isPresentationRole(node)) return;
 			const hasTabIndex = Boolean(hasJsxPropIgnoreCase(node.attributes, "tabIndex"));
-			if (!hasInteractiveHandler || isDisabledElement(node) || isHiddenFromScreenReader(node, context.settings) || isPresentationRole(node)) return;
-			if (!role) return;
 			if (!isInteractiveRole(role) || isInteractiveElement(elementType, node) || isNonInteractiveRole(role) || isNonInteractiveElement(elementType, node) || hasTabIndex) return;
 			const message = tabbableSet.has(role) ? buildTabbableMessage(role) : buildFocusableMessage(role);
 			context.report({
@@ -9555,7 +9696,7 @@ const isAtomFromJotai = (callExpression) => {
 	if (!isImportedFromModule(callExpression, localName, "jotai")) return false;
 	return getImportedNameFromModule(callExpression, localName, "jotai") === "atom";
 };
-const isFunctionExpressionLike$1 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
+const isFunctionExpressionLike$2 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
 const getFirstParameterName = (fn) => {
 	const parameters = fn.params ?? [];
 	if (parameters.length !== 1) return null;
@@ -9688,7 +9829,7 @@ const jotaiDerivedAtomReturnsFreshObject = defineRule({
 		const args = node.arguments ?? [];
 		if (args.length === 0) return;
 		const reader = args[0];
-		if (!isFunctionExpressionLike$1(reader)) return;
+		if (!isFunctionExpressionLike$2(reader)) return;
 		const getParameterName = getFirstParameterName(reader);
 		if (!getParameterName) return;
 		const freshReturn = getFreshReturnForFunction(reader);
@@ -9786,14 +9927,14 @@ const getHandlerNamedBindingName = (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);
+		return COMPONENT_NAME_PATTERN.test(declaredName) || HOOK_NAME_PATTERN$1.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);
+	return COMPONENT_NAME_PATTERN.test(cursor.id.name) || HOOK_NAME_PATTERN$1.test(cursor.id.name);
 };
 const isBindingInvokedOnRenderPath = (root, bindingName) => {
 	let didFindRenderPathInvocation = false;
@@ -10176,8 +10317,6 @@ const jsCachePropertyAccess = defineRule({
 			walkAst(loopBody, (child) => {
 				if (isNodeOfType(child, "AssignmentExpression")) recordWriteTarget(child.left);
 				if (isNodeOfType(child, "UpdateExpression")) recordWriteTarget(child.argument);
-			});
-			walkAst(loopBody, (child) => {
 				if (!isNodeOfType(child, "MemberExpression")) return;
 				if (child.computed) return;
 				if (isNodeOfType(child.parent, "MemberExpression") && child.parent.object === child) return;
@@ -10439,10 +10578,15 @@ const jsCombineIterations = defineRule({
 	severity: "warn",
 	recommendation: "Combine `.map().filter()` style chains into one pass with `.reduce()` or a `for...of` loop, so you only loop over the list once",
 	create: (context) => {
-		let generatorNamesInFile = /* @__PURE__ */ new Set();
+		let programNode = null;
+		let generatorNamesInFile = null;
+		const getGeneratorNamesInFile = () => {
+			generatorNamesInFile ??= programNode ? collectGeneratorNames(programNode) : /* @__PURE__ */ new Set();
+			return generatorNamesInFile;
+		};
 		return {
-			Program(programNode) {
-				generatorNamesInFile = collectGeneratorNames(programNode);
+			Program(node) {
+				programNode = node;
 			},
 			CallExpression(node) {
 				if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return;
@@ -10464,7 +10608,7 @@ const jsCombineIterations = defineRule({
 					if (isNullFilteringPredicate(filterArgument)) return;
 					if (isTypePredicateArrow(filterArgument)) return;
 				}
-				if (isReceiverChainIteratorRooted(innerCall.callee.object, generatorNamesInFile)) return;
+				if (isReceiverChainIteratorRooted(innerCall.callee.object, getGeneratorNamesInFile())) return;
 				if (isSmallLiteralArrayRootedChain(innerCall.callee.object)) return;
 				if (isStringSplitRootedChain(innerCall.callee.object)) return;
 				context.report({
@@ -10632,7 +10776,6 @@ const jsHoistIntl = defineRule({
 	recommendation: "Move `new Intl.NumberFormat(...)` to the top of the file or wrap it in `useMemo`. Building one is slow, so don't redo it on every call",
 	create: (context) => ({ NewExpression(node) {
 		if (!isIntlNewExpression(node)) return;
-		if (isInsideCacheMemo(node)) return;
 		let cursor = node.parent ?? null;
 		let inFunctionBody = false;
 		while (cursor) {
@@ -10649,6 +10792,7 @@ const jsHoistIntl = defineRule({
 			cursor = cursor.parent ?? null;
 		}
 		if (!inFunctionBody) return;
+		if (isInsideCacheMemo(node)) return;
 		const className = isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") ? node.callee.property.name : "Intl";
 		context.report({
 			node,
@@ -10723,7 +10867,11 @@ const isSingleFieldEqualityPredicate = (node) => {
 	if (!isNodeOfType(predicate, "BinaryExpression") || predicate.operator !== "===" && predicate.operator !== "==") return false;
 	return referencesParameter(predicate.left, firstParameter.name) || referencesParameter(predicate.right, firstParameter.name);
 };
-const collectLoopBoundNames = (loop, names) => {
+const loopBoundNamesCache = /* @__PURE__ */ new WeakMap();
+const getLoopBoundNames = (loop) => {
+	const cached = loopBoundNamesCache.get(loop);
+	if (cached) return cached;
+	const names = /* @__PURE__ */ new Set();
 	if ((isNodeOfType(loop, "ForOfStatement") || isNodeOfType(loop, "ForInStatement")) && loop.left) walkAst(loop.left, (child) => {
 		if (isNodeOfType(child, "Identifier")) names.add(child.name);
 	});
@@ -10740,6 +10888,8 @@ const collectLoopBoundNames = (loop, names) => {
 			if (targetRoot) names.add(targetRoot);
 		}
 	});
+	loopBoundNamesCache.set(loop, names);
+	return names;
 };
 const hasLoopBoundComputedIndex = (receiver, loopBoundNames) => {
 	let cursor = receiver;
@@ -10765,7 +10915,7 @@ const isLoopVariantReceiver = (node) => {
 	const loopBoundNames = /* @__PURE__ */ new Set();
 	let ancestor = node.parent;
 	while (ancestor) {
-		if (LOOP_TYPES.includes(ancestor.type)) collectLoopBoundNames(ancestor, loopBoundNames);
+		if (LOOP_TYPES.includes(ancestor.type)) for (const name of getLoopBoundNames(ancestor)) loopBoundNames.add(name);
 		ancestor = ancestor.parent;
 	}
 	if (loopBoundNames.has(receiverRoot)) return true;
@@ -12524,6 +12674,7 @@ const KNOWN_SLOT_PROP_NAMES = new Set([
 	"bottomContent",
 	"leftContent",
 	"rightContent",
+	"config",
 	"value",
 	"currentValue",
 	"form",
@@ -12662,6 +12813,10 @@ const SLOT_PROP_SUFFIXES = [
 	"Panel",
 	"Overlay",
 	"Shape",
+	"Avatar",
+	"Text",
+	"State",
+	"Zone",
 	"Override",
 	"Overrides",
 	"Items",
@@ -12678,6 +12833,8 @@ const SLOT_PROP_SUFFIXES = [
 ];
 const isSlotPropName = (propName) => {
 	if (KNOWN_SLOT_PROP_NAMES.has(propName)) return true;
+	const decapitalized = propName.charAt(0).toLowerCase() + propName.slice(1);
+	if (decapitalized !== propName && KNOWN_SLOT_PROP_NAMES.has(decapitalized)) return true;
 	for (const suffix of SLOT_PROP_SUFFIXES) if (propName.length > suffix.length && propName.endsWith(suffix)) return true;
 	return false;
 };
@@ -14366,14 +14523,14 @@ const keyLifecycleRisk = defineRule({
 //#region src/plugin/rules/a11y/label-has-associated-control.ts
 const MESSAGE_NO_LABEL = "Blind users can't identify this field because screen readers find no label text, so add visible text, `aria-label`, or `aria-labelledby`.";
 const MESSAGE_NO_CONTROL = "Screen reader users can't tell which input this label names because it's tied to none, so add `htmlFor` or wrap the input inside it.";
-const DEFAULT_CONTROL_COMPONENTS = [
+const DEFAULT_CONTROL_COMPONENTS = new Set([
 	"input",
 	"meter",
 	"output",
 	"progress",
 	"select",
 	"textarea"
-];
+]);
 const DEFAULT_LABEL_ATTRIBUTES = [
 	"alt",
 	"aria-label",
@@ -14385,8 +14542,8 @@ const resolveSettings$24 = (settings) => {
 	const jsxA11y = settings?.["jsx-a11y"];
 	const forAttributes = (typeof jsxA11y === "object" && jsxA11y !== null ? jsxA11y : {}).attributes?.for ?? ["htmlFor"];
 	return {
-		labelComponents: ["label", ...ruleSettings.labelComponents ?? []].sort(),
-		labelAttributes: [...new Set([...DEFAULT_LABEL_ATTRIBUTES, ...ruleSettings.labelAttributes ?? []])].sort(),
+		labelComponents: new Set(["label", ...ruleSettings.labelComponents ?? []]),
+		labelAttributes: new Set([...DEFAULT_LABEL_ATTRIBUTES, ...ruleSettings.labelAttributes ?? []]),
 		controlComponents: ruleSettings.controlComponents ?? [],
 		assert: ruleSettings.assert ?? "either",
 		depth: Math.min(ruleSettings.depth ?? 5, 25),
@@ -14394,7 +14551,7 @@ const resolveSettings$24 = (settings) => {
 	};
 };
 const isControlComponent = (tagName, controlComponents) => {
-	if (DEFAULT_CONTROL_COMPONENTS.includes(tagName)) return true;
+	if (DEFAULT_CONTROL_COMPONENTS.has(tagName)) return true;
 	return controlComponents.some((pattern) => compileGlob(pattern).test(tagName));
 };
 const searchForNestedControl = (child, currentDepth, searchContext) => {
@@ -14420,7 +14577,7 @@ const searchForAccessibleLabel = (child, currentDepth, searchContext) => {
 			const attributeName = attribute.name;
 			if (!isNodeOfType(attributeName, "JSXIdentifier")) continue;
 			const propName = getJsxAttributeName(attributeName);
-			if (!propName || !searchContext.labelAttributes.includes(propName)) continue;
+			if (!propName || !searchContext.labelAttributes.has(propName)) continue;
 			const attributeValue = attribute.value;
 			if (!attributeValue) continue;
 			if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") {
@@ -14442,7 +14599,7 @@ const hasAccessibleLabel = (element, searchContext) => {
 		const attributeName = attribute.name;
 		if (!isNodeOfType(attributeName, "JSXIdentifier")) continue;
 		const propName = getJsxAttributeName(attributeName);
-		if (propName && searchContext.labelAttributes.includes(propName)) return true;
+		if (propName && searchContext.labelAttributes.has(propName)) return true;
 	}
 	for (const child of element.children) if (searchForAccessibleLabel(child, 1, searchContext)) return true;
 	return false;
@@ -14465,7 +14622,7 @@ const labelHasAssociatedControl = defineRule({
 			if (isTestlikeFile) return;
 			const opening = node.openingElement;
 			const tagName = getElementType(opening, context.settings);
-			if (!settings.labelComponents.includes(tagName)) return;
+			if (!settings.labelComponents.has(tagName)) return;
 			const hasHtmlFor = settings.forAttributes.some((attributeName) => Boolean(hasJsxPropIgnoreCase(opening.attributes, attributeName)));
 			const searchContext = {
 				depth: settings.depth,
@@ -15054,9 +15211,9 @@ const resolveSettings$23 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.mediaHasCaption ?? {} : {};
 	return {
-		audio: [...DEFAULT_AUDIO, ...ruleSettings.audio ?? []],
-		video: [...DEFAULT_VIDEO, ...ruleSettings.video ?? []],
-		track: [...DEFAULT_TRACK, ...ruleSettings.track ?? []]
+		audio: new Set([...DEFAULT_AUDIO, ...ruleSettings.audio ?? []]),
+		video: new Set([...DEFAULT_VIDEO, ...ruleSettings.video ?? []]),
+		track: new Set([...DEFAULT_TRACK, ...ruleSettings.track ?? []])
 	};
 };
 const evaluateMuted = (attribute) => {
@@ -15085,7 +15242,7 @@ const childMayRenderTrack = (child, trackTags, settings) => {
 	let rendersCaptionTrack = false;
 	walkAst(expression, (inner) => {
 		if (rendersCaptionTrack) return false;
-		if (isNodeOfType(inner, "JSXElement") && trackTags.includes(getElementType(inner.openingElement, settings)) && trackKindMightBeCaptions(inner.openingElement)) {
+		if (isNodeOfType(inner, "JSXElement") && trackTags.has(getElementType(inner.openingElement, settings)) && trackKindMightBeCaptions(inner.openingElement)) {
 			rendersCaptionTrack = true;
 			return false;
 		}
@@ -15103,7 +15260,7 @@ const mediaHasCaption = defineRule({
 		const settings = resolveSettings$23(context.settings);
 		return { JSXOpeningElement(node) {
 			const tag = getElementType(node, context.settings);
-			if (!(settings.audio.includes(tag) || settings.video.includes(tag))) return;
+			if (!(settings.audio.has(tag) || settings.video.has(tag))) return;
 			if (evaluateMuted(hasJsxPropIgnoreCase(node.attributes, "muted")) === true) return;
 			const parent = node.parent;
 			if (!parent || !isNodeOfType(parent, "JSXElement")) {
@@ -15118,7 +15275,7 @@ const mediaHasCaption = defineRule({
 				if (!isNodeOfType(child, "JSXElement")) return false;
 				const opening = child.openingElement;
 				const childTag = getElementType(opening, context.settings);
-				if (!settings.track.includes(childTag)) return false;
+				if (!settings.track.has(childTag)) return false;
 				const kindAttribute = hasJsxPropIgnoreCase(opening.attributes, "kind");
 				if (!kindAttribute) return false;
 				let kindValue = kindAttribute.value;
@@ -15429,16 +15586,30 @@ const stripJsComments = (sourceText) => sourceText.replace(BLOCK_COMMENT_PATTERN
 const DEFAULT_EXPORT_DECLARATION_PATTERN = /^\s*export\s+default\b/m;
 const NAMED_EXPORT_DECLARATION_PATTERN = /^\s*export\s+(?:declare\s+)?(?:(?:async\s+)?function|(?:abstract\s+)?class|const|let|var|enum|interface|type)\s+([\w$]+)/gm;
 const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1 = /^\s*export\s+(?:type\s+)?\{([\s\S]*?)\}(?:\s+from\s+["'][^"']+["'])?\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const doesSourceTextExportName = (sourceText, exportedName) => {
+const collectSourceTextExportNames = (sourceText) => {
 	const strippedSource = stripJsComments(sourceText);
-	if (exportedName === "default" && DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) return true;
-	for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) if (match[1] === exportedName) return true;
-	for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1)) if (parseExportSpecifiers(match[1] ?? "", false).map((specifier) => specifier.exportedName).includes(exportedName)) return true;
-	return false;
+	const exportedNames = /* @__PURE__ */ new Set();
+	if (DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) exportedNames.add("default");
+	for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) if (match[1]) exportedNames.add(match[1]);
+	for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1)) {
+		const specifiersText = match[1] ?? "";
+		for (const specifier of parseExportSpecifiers(specifiersText, false)) exportedNames.add(specifier.exportedName);
+	}
+	return exportedNames;
 };
+const exportNamesCache = /* @__PURE__ */ new Map();
 const doesModuleExportName = (filePath, exportedName) => {
 	try {
-		return doesSourceTextExportName(fs.readFileSync(filePath, "utf8"), exportedName);
+		const fileStat = fs.statSync(filePath);
+		const cached = exportNamesCache.get(filePath);
+		if (cached && cached.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) return cached.exportedNames.has(exportedName);
+		const exportedNames = collectSourceTextExportNames(fs.readFileSync(filePath, "utf8"));
+		exportNamesCache.set(filePath, {
+			mtimeMs: fileStat.mtimeMs,
+			size: fileStat.size,
+			exportedNames
+		});
+		return exportedNames.has(exportedName);
 	} catch {
 		return false;
 	}
@@ -15477,6 +15648,7 @@ const nextjsMissingMetadata = defineRule({
 		const filename = normalizeFilename(context.filename ?? "");
 		if (!PAGE_FILE_PATTERN.test(filename)) return;
 		if (INTERNAL_PAGE_PATH_PATTERN.test(filename)) return;
+		if ((programNode.body ?? []).some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === "use client")) return;
 		if (programNode.body?.some((statement) => {
 			if (!isNodeOfType(statement, "ExportNamedDeclaration")) return false;
 			const declaration = statement.declaration;
@@ -15583,8 +15755,12 @@ const containsFetchCall = (node, options) => {
 	const effectInvokedFunctions = options?.stopAtFunctionBoundary ? collectEffectInvokedFunctions(node) : null;
 	let didFindFetchCall = false;
 	walkAst(node, (child) => {
+		if (didFindFetchCall) return false;
 		if (effectInvokedFunctions && child !== node && isFunctionLike$1(child) && !effectInvokedFunctions.has(child)) return false;
-		if (isFetchCall$1(child)) didFindFetchCall = true;
+		if (isFetchCall$1(child)) {
+			didFindFetchCall = true;
+			return false;
+		}
 	});
 	return didFindFetchCall;
 };
@@ -15598,6 +15774,8 @@ const nextjsNoClientFetchForServerData = defineRule({
 	severity: "warn",
 	recommendation: "Remove 'use client' and fetch directly in the Server Component. No API round-trip, and secrets stay on the server.",
 	create: (context) => {
+		const filename = normalizeFilename(context.filename ?? "");
+		if (!(PAGE_OR_LAYOUT_FILE_PATTERN.test(filename) || isInProjectDirectory(context, "pages"))) return {};
 		let fileHasUseClient = false;
 		return {
 			Program(programNode) {
@@ -15607,8 +15785,7 @@ const nextjsNoClientFetchForServerData = defineRule({
 				if (!fileHasUseClient || !isHookCall$1(node, EFFECT_HOOK_NAMES$1)) return;
 				const callback = getEffectCallback(node);
 				if (!callback || !containsFetchCall(callback, { stopAtFunctionBoundary: true })) return;
-				const filename = normalizeFilename(context.filename ?? "");
-				if (PAGE_OR_LAYOUT_FILE_PATTERN.test(filename) || isInProjectDirectory(context, "pages")) context.report({
+				context.report({
 					node,
 					message: "useEffect + fetch in a page/layout makes your users wait through an extra round trip & loading spinner."
 				});
@@ -16273,16 +16450,18 @@ const nextjsNoSideEffectInGetHandler = defineRule({
 	recommendation: "GET requests can be prefetched and are open to CSRF. Move the side effect to a POST handler.",
 	create: (context) => {
 		let resolveBinding = () => null;
+		let isRouteHandlerFile = false;
+		let mutatingSegment = null;
 		return {
 			Program(node) {
 				resolveBinding = buildProgramBindingLookup(node);
+				const filename = normalizeFilename(context.filename ?? "");
+				isRouteHandlerFile = ROUTE_HANDLER_FILE_PATTERN.test(filename) && !CRON_ROUTE_PATTERN.test(filename);
+				mutatingSegment = isRouteHandlerFile ? extractMutatingRouteSegment(filename) : null;
 			},
 			ExportNamedDeclaration(node) {
-				const filename = normalizeFilename(context.filename ?? "");
-				if (!ROUTE_HANDLER_FILE_PATTERN.test(filename)) return;
-				if (CRON_ROUTE_PATTERN.test(filename)) return;
+				if (!isRouteHandlerFile) return;
 				if (!isExportedGetHandler(node)) return;
-				const mutatingSegment = extractMutatingRouteSegment(filename);
 				const handlerBodies = resolveGetHandlerBodies(node, resolveBinding);
 				for (const handlerBody of handlerBodies) {
 					const bodiesToScan = [handlerBody, ...collectCalledSameFileHelperBodies(handlerBody, resolveBinding)];
@@ -17199,14 +17378,38 @@ const resolvesToRefFactoryCall = (identifier) => {
 	});
 	return found;
 };
-const isRefLikeReceiver = (receiver) => {
+const unwrapExpression$2 = (node) => {
+	if (!node) return null;
+	if (isNodeOfType(node, "ChainExpression")) return unwrapExpression$2(node.expression);
+	if (isNodeOfType(node, "TSNonNullExpression")) return unwrapExpression$2(node.expression);
+	return node;
+};
+const resolvesToRefCurrentAlias = (identifier, visitedAliasNames) => {
+	if (visitedAliasNames.has(identifier.name)) return false;
+	const root = findProgramRoot(identifier);
+	if (!root) return false;
+	const nextVisited = new Set([...visitedAliasNames, identifier.name]);
+	let found = false;
+	walkAst(root, (child) => {
+		if (found) return false;
+		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.id.name === identifier.name) {
+			const init = unwrapExpression$2(child.init);
+			if (init && isNodeOfType(init, "MemberExpression") && isNodeOfType(init.property, "Identifier") && init.property.name === "current" && isRefLikeReceiver(init.object, nextVisited)) {
+				found = true;
+				return false;
+			}
+		}
+	});
+	return found;
+};
+const isRefLikeReceiver = (receiver, visitedAliasNames = /* @__PURE__ */ new Set()) => {
 	if (!receiver) return false;
-	if (isNodeOfType(receiver, "ChainExpression")) return isRefLikeReceiver(receiver.expression);
-	if (isNodeOfType(receiver, "TSNonNullExpression")) return isRefLikeReceiver(receiver.expression);
-	if (isNodeOfType(receiver, "Identifier")) return hasRefLikeName(receiver.name) || resolvesToRefFactoryCall(receiver);
+	if (isNodeOfType(receiver, "ChainExpression")) return isRefLikeReceiver(receiver.expression, visitedAliasNames);
+	if (isNodeOfType(receiver, "TSNonNullExpression")) return isRefLikeReceiver(receiver.expression, visitedAliasNames);
+	if (isNodeOfType(receiver, "Identifier")) return hasRefLikeName(receiver.name) || resolvesToRefFactoryCall(receiver) || resolvesToRefCurrentAlias(receiver, visitedAliasNames);
 	if (isNodeOfType(receiver, "MemberExpression") && isNodeOfType(receiver.property, "Identifier")) {
 		if (hasRefLikeName(receiver.property.name)) return true;
-		if (receiver.property.name === "current") return isRefLikeReceiver(receiver.object);
+		if (receiver.property.name === "current") return isRefLikeReceiver(receiver.object, visitedAliasNames);
 	}
 	return false;
 };
@@ -17314,8 +17517,15 @@ const getProgramAnalysis = (anyNode) => {
 	programToAnalysis.set(programNode, analysis);
 	return analysis;
 };
+const scopeByNodeCache = /* @__PURE__ */ new WeakMap();
 const getScopeForNode = (node, manager) => {
 	if (!node.range) return null;
+	let scopeByNode = scopeByNodeCache.get(manager);
+	if (!scopeByNode) {
+		scopeByNode = /* @__PURE__ */ new WeakMap();
+		scopeByNodeCache.set(manager, scopeByNode);
+	}
+	if (scopeByNode.has(node)) return scopeByNode.get(node) ?? null;
 	let bestScope = null;
 	let bestSize = Infinity;
 	for (const scope of manager.scopes) {
@@ -17328,11 +17538,25 @@ const getScopeForNode = (node, manager) => {
 			bestScope = scope;
 		}
 	}
+	scopeByNode.set(node, bestScope);
 	return bestScope;
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/ast.ts
 const getChildKeys = (node) => VISITOR_KEYS[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
+const HOOK_NAME_PATTERN = /^use[A-Z0-9]/;
+const isInsideCallbackArgumentOf = (identifier, initializer) => {
+	if (!isNodeOfType(initializer, "CallExpression") && !isNodeOfType(initializer, "NewExpression")) return false;
+	if (isNodeOfType(initializer, "CallExpression") && isNodeOfType(initializer.callee, "Identifier") && HOOK_NAME_PATTERN.test(initializer.callee.name)) return false;
+	const callbackArguments = (initializer.arguments ?? []).filter((argument) => isFunctionLike$1(argument));
+	if (callbackArguments.length === 0) return false;
+	let node = identifier;
+	while (node && node !== initializer) {
+		if (callbackArguments.includes(node)) return true;
+		node = node.parent;
+	}
+	return false;
+};
 const ascend = (analysis, ref, visit, visited = /* @__PURE__ */ new Set()) => {
 	if (visited.has(ref)) return;
 	const result = visit(ref);
@@ -17345,7 +17569,10 @@ const ascend = (analysis, ref, visit, visited = /* @__PURE__ */ new Set()) => {
 		const defNode = def.node;
 		const next = defNode.init ?? defNode.body;
 		if (!next) continue;
-		for (const innerRef of getDownstreamRefs(analysis, next)) ascend(analysis, innerRef, visit, visited);
+		for (const innerRef of getDownstreamRefs(analysis, next)) {
+			if (isInsideCallbackArgumentOf(innerRef.identifier, next)) continue;
+			ascend(analysis, innerRef, visit, visited);
+		}
 	}
 };
 const descend = (node, visit, visited = /* @__PURE__ */ new Set()) => {
@@ -17362,11 +17589,20 @@ const descend = (node, visit, visited = /* @__PURE__ */ new Set()) => {
 		} else if (isAstNode(child)) descend(child, visit, visited);
 	}
 };
+const upstreamRefsCache = /* @__PURE__ */ new WeakMap();
 const getUpstreamRefs = (analysis, ref) => {
+	let upstreamByRef = upstreamRefsCache.get(analysis);
+	if (!upstreamByRef) {
+		upstreamByRef = /* @__PURE__ */ new WeakMap();
+		upstreamRefsCache.set(analysis, upstreamByRef);
+	}
+	const cached = upstreamByRef.get(ref);
+	if (cached) return cached;
 	const refs = [];
 	ascend(analysis, ref, (upRef) => {
 		refs.push(upRef);
 	});
+	upstreamByRef.set(ref, refs);
 	return refs;
 };
 const findDownstreamNodes = (topNode, type) => {
@@ -17376,11 +17612,24 @@ const findDownstreamNodes = (topNode, type) => {
 	});
 	return nodes;
 };
+const refByIdentifierCache = /* @__PURE__ */ new WeakMap();
 const getRef = (analysis, identifier) => {
+	let refByIdentifier = refByIdentifierCache.get(analysis);
+	if (!refByIdentifier) {
+		refByIdentifier = /* @__PURE__ */ new WeakMap();
+		refByIdentifierCache.set(analysis, refByIdentifier);
+	}
+	if (refByIdentifier.has(identifier)) return refByIdentifier.get(identifier) ?? null;
+	let resolvedReference = null;
 	const scope = getScopeForNode(identifier, analysis.scopeManager);
-	if (!scope) return null;
-	for (const reference of scope.references) if (reference.identifier === identifier) return reference;
-	return null;
+	if (scope) {
+		for (const reference of scope.references) if (reference.identifier === identifier) {
+			resolvedReference = reference;
+			break;
+		}
+	}
+	refByIdentifier.set(identifier, resolvedReference);
+	return resolvedReference;
 };
 const downstreamRefsCache = /* @__PURE__ */ new WeakMap();
 const getDownstreamRefs = (analysis, node) => {
@@ -17455,22 +17704,6 @@ const isEventualCallTo = (analysis, ref, predicate) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/react.ts
-const getOuterScopeContaining = (analysis, node) => {
-	if (!node.range) return null;
-	let best = null;
-	let bestSize = Infinity;
-	for (const scope of analysis.scopeManager.scopes) {
-		const block = scope.block;
-		if (!block?.range) continue;
-		if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
-		const size = block.range[1] - block.range[0];
-		if (size <= bestSize) {
-			bestSize = size;
-			best = scope;
-		}
-	}
-	return best;
-};
 const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
 const isReactFunctionalComponent = (node) => {
@@ -17501,7 +17734,7 @@ const isReactFunctionalHOC = (analysis, node) => {
 	const isWrappedSeparately = () => {
 		if (!isNodeOfType(node.id, "Identifier")) return false;
 		const bindingName = node.id.name;
-		const containingScope = getOuterScopeContaining(analysis, node);
+		const containingScope = getScopeForNode(node, analysis.scopeManager);
 		if (!containingScope) return false;
 		const variable = containingScope.variables.find((v) => v.name === bindingName);
 		if (!variable) return false;
@@ -17788,7 +18021,8 @@ const noAriaHiddenOnFocusable = defineRule({
 			if (isNodeOfType(value, "Literal") && value.value !== "true") return;
 			if (isNodeOfType(value, "JSXExpressionContainer")) {
 				const expression = value.expression;
-				if (isNodeOfType(expression, "Literal") && !expression.value) return;
+				if (!isNodeOfType(expression, "Literal")) return;
+				if (expression.value !== true && expression.value !== "true") return;
 			}
 		}
 		const tag = getElementType(node, context.settings);
@@ -18043,10 +18277,30 @@ const isArrayFromCall = (node) => {
 *
 * Used both for `<receiver>.map(...)` and for `Array.from(<length>, fn)`.
 */
-const isStaticPlaceholderReceiver = (receiver) => {
+const isBindingReassigned = (referenceNode, bindingName) => {
+	const programRoot = findProgramRoot(referenceNode);
+	if (!programRoot) return false;
+	let didFindReassignment = false;
+	walkAst(programRoot, (child) => {
+		if (didFindReassignment) return false;
+		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.left, "Identifier") && child.left.name === bindingName) {
+			didFindReassignment = true;
+			return false;
+		}
+	});
+	return didFindReassignment;
+};
+const isStaticPlaceholderReceiver = (receiver, depth = 0) => {
 	if (isArrayFromCall(receiver)) return true;
 	if (isArrayConstructorCallWithNumericLength(receiver)) return true;
 	if (isAllLiteralArrayExpression(receiver)) return true;
+	if (isNodeOfType(receiver, "Identifier")) {
+		if (depth >= TYPE_RESOLUTION_DEPTH_LIMIT) return false;
+		const binding = findVariableInitializer(receiver, receiver.name);
+		if (!binding?.initializer) return false;
+		if (isBindingReassigned(receiver, receiver.name)) return false;
+		return isStaticPlaceholderReceiver(binding.initializer, depth + 1);
+	}
 	if (isNodeOfType(receiver, "CallExpression")) {
 		const callee = receiver.callee;
 		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "fill" && isArrayConstructorCallWithNumericLength(callee.object)) return true;
@@ -18072,6 +18326,7 @@ const isArrayFromLengthObjectCall = (node) => {
 		if (!(isNodeOfType(key, "Identifier") && key.name === "length" || isNodeOfType(key, "Literal") && key.value === "length")) continue;
 		if (isNumericLiteralOrUndefined(prop.value)) return true;
 		if (isNodeOfType(prop.value, "Identifier")) return true;
+		if (isNodeOfType(prop.value, "MemberExpression") && isNodeOfType(prop.value.property, "Identifier") && prop.value.property.name === "length") return true;
 	}
 	return false;
 };
@@ -18180,10 +18435,11 @@ const isInsideStaticPlaceholderMap = (node) => isInsideIteratorMapMatching(node,
 /**
 * Walk up from a JSXAttribute node looking for the enclosing iterator
 * callback (`.map(cb)`, `.flatMap(cb)`, `.forEach(cb)`, `Array.from(_, cb)`)
-* and return the first parameter's name. The first param is the per-item
-* value, e.g. `item` in `arr.map((item, index) => …)`.
+* and return the names bound by the first parameter — `item` in
+* `arr.map((item, index) => …)`, or every destructured field in
+* `arr.map(({ id, label }, index) => …)`.
 */
-const findIteratorItemName$1 = (node) => {
+const findIteratorItemNames = (node) => {
 	let current = node;
 	while (current.parent) {
 		const parent = current.parent;
@@ -18193,18 +18449,20 @@ const findIteratorItemName$1 = (node) => {
 			const isArrayFromCallback = isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current;
 			if (isIteratorMethodCall || isArrayFromCallback) {
 				const first = (current.params ?? [])[0];
-				if (first && isNodeOfType(first, "Identifier")) return first.name;
-				return null;
+				if (!first) return null;
+				const names = /* @__PURE__ */ new Set();
+				collectPatternNames(first, names);
+				return names.size > 0 ? names : null;
 			}
 		}
 		current = parent;
 	}
 	return null;
 };
-const templateLiteralHasIteratorIdentity = (template, itemName) => {
+const templateLiteralHasIteratorIdentity = (template, itemNames) => {
 	for (const expression of template.expressions ?? []) {
-		if (isNodeOfType(expression, "Identifier") && expression.name === itemName) return true;
-		if (isNodeOfType(expression, "MemberExpression") && isNodeOfType(expression.object, "Identifier") && expression.object.name === itemName) return true;
+		const rootName = getRootIdentifierName(expression, { followCallChains: true });
+		if (rootName !== null && itemNames.has(rootName)) return true;
 	}
 	return false;
 };
@@ -18217,9 +18475,32 @@ const templateLiteralHasIteratorIdentity = (template, itemName) => {
 const isCompositeKeyWithIteratorIdentity = (keyExpression, attributeNode) => {
 	if (!isNodeOfType(keyExpression, "TemplateLiteral")) return false;
 	if ((keyExpression.expressions ?? []).length < 2) return false;
-	const itemName = findIteratorItemName$1(attributeNode);
-	if (!itemName) return false;
-	return templateLiteralHasIteratorIdentity(keyExpression, itemName);
+	const itemNames = findIteratorItemNames(attributeNode);
+	if (!itemNames) return false;
+	return templateLiteralHasIteratorIdentity(keyExpression, itemNames);
+};
+const forLoopTestReadsDataLength = (test) => {
+	let didFindLengthRead = false;
+	walkAst(test, (child) => {
+		if (didFindLengthRead) return false;
+		if (isNodeOfType(child, "MemberExpression") && isNodeOfType(child.property, "Identifier") && child.property.name === "length") {
+			didFindLengthRead = true;
+			return false;
+		}
+	});
+	return didFindLengthRead;
+};
+const isNumericForLoopCounter = (attributeNode, indexName) => {
+	const binding = findVariableInitializer(attributeNode, indexName);
+	if (!binding) return false;
+	const declarator = binding.bindingIdentifier.parent;
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
+	const declaration = declarator.parent;
+	if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) return false;
+	const forStatement = declaration.parent;
+	if (!forStatement || !isNodeOfType(forStatement, "ForStatement") || forStatement.init !== declaration || !declarator.init || !isNodeOfType(declarator.init, "Literal") || typeof declarator.init.value !== "number") return false;
+	if (forStatement.test && forLoopTestReadsDataLength(forStatement.test)) return false;
+	return true;
 };
 const noArrayIndexAsKey = defineRule({
 	id: "no-array-index-as-key",
@@ -18231,6 +18512,7 @@ const noArrayIndexAsKey = defineRule({
 		if (!node.value || !isNodeOfType(node.value, "JSXExpressionContainer")) return;
 		const indexName = extractIndexName(node.value.expression);
 		if (!indexName) return;
+		if (isNumericForLoopCounter(node, indexName)) return;
 		if (isInsideStaticPlaceholderMap(node)) return;
 		if (isInsideStringDerivedMap(node)) return;
 		if (isCompositeKeyWithIteratorIdentity(node.value.expression, node)) return;
@@ -18851,7 +19133,17 @@ const containsRenderOutput = (node, rootNode, scopes) => {
 	}
 	return false;
 };
-const functionContainsReactRenderOutput = (functionNode, scopes) => containsRenderOutput(functionNode, functionNode, scopes);
+const renderOutputCache = /* @__PURE__ */ new WeakMap();
+const functionContainsReactRenderOutput = (functionNode, scopes) => {
+	const cachedEntry = renderOutputCache.get(functionNode);
+	if (cachedEntry && cachedEntry.scopes === scopes) return cachedEntry.hasRenderOutput;
+	const hasRenderOutput = containsRenderOutput(functionNode, functionNode, scopes);
+	renderOutputCache.set(functionNode, {
+		scopes,
+		hasRenderOutput
+	});
+	return hasRenderOutput;
+};
 //#endregion
 //#region src/plugin/utils/is-component-declaration.ts
 const isComponentDeclaration = (node) => isNodeOfType(node, "FunctionDeclaration") && node.id !== null && Boolean(node.id?.name) && isUppercaseName(node.id.name);
@@ -19356,8 +19648,8 @@ const CONTEXT_MODULES = [
 ];
 const isCreateContextCallee = (callee) => {
 	if (isNodeOfType(callee, "Identifier")) {
-		for (const moduleName of CONTEXT_MODULES) if (getImportedNameFromModule(callee, callee.name, moduleName) === "createContext") return true;
-		return false;
+		const binding = getImportBindingForName(callee, callee.name);
+		return binding !== null && binding.exportedName === "createContext" && CONTEXT_MODULES.includes(binding.source);
 	}
 	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
 		const namespaceIdentifier = callee.object;
@@ -19367,8 +19659,8 @@ const isCreateContextCallee = (callee) => {
 		if (propertyIdentifier.name !== "createContext") return false;
 		const namespaceName = namespaceIdentifier.name;
 		if (isCanonicalReactNamespaceName(namespaceName)) return true;
-		for (const moduleName of CONTEXT_MODULES) if (isImportedFromModule(namespaceIdentifier, namespaceName, moduleName)) return true;
-		return false;
+		const importSource = getImportSourceForName(namespaceIdentifier, namespaceName);
+		return importSource !== null && CONTEXT_MODULES.includes(importSource);
 	}
 	return false;
 };
@@ -19770,38 +20062,44 @@ const convertHslToRgb = (hueDegrees, saturationPercent, lightnessPercent) => {
 };
 const parseColorToRgb = (value) => {
 	const trimmed = value.trim().toLowerCase().replace(/_/g, " ");
-	const hex8Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})[0-9a-f]{2}$/);
-	if (hex8Match) return {
-		red: parseInt(hex8Match[1], 16),
-		green: parseInt(hex8Match[2], 16),
-		blue: parseInt(hex8Match[3], 16)
-	};
-	const hex6Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/);
-	if (hex6Match) return {
-		red: parseInt(hex6Match[1], 16),
-		green: parseInt(hex6Match[2], 16),
-		blue: parseInt(hex6Match[3], 16)
-	};
-	const hex4Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])[0-9a-f]$/);
-	if (hex4Match) return {
-		red: parseInt(hex4Match[1] + hex4Match[1], 16),
-		green: parseInt(hex4Match[2] + hex4Match[2], 16),
-		blue: parseInt(hex4Match[3] + hex4Match[3], 16)
-	};
-	const hex3Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/);
-	if (hex3Match) return {
-		red: parseInt(hex3Match[1] + hex3Match[1], 16),
-		green: parseInt(hex3Match[2] + hex3Match[2], 16),
-		blue: parseInt(hex3Match[3] + hex3Match[3], 16)
-	};
-	const rgbMatch = trimmed.match(/rgba?\(\s*(\d+)[\s,]+(\d+)[\s,]+(\d+)/);
-	if (rgbMatch) return {
-		red: parseInt(rgbMatch[1], 10),
-		green: parseInt(rgbMatch[2], 10),
-		blue: parseInt(rgbMatch[3], 10)
-	};
-	const hslMatch = trimmed.match(/hsla?\(\s*([\d.]+)(?:deg)?[\s,]+([\d.]+)%[\s,]+([\d.]+)%/);
-	if (hslMatch) return convertHslToRgb(parseFloat(hslMatch[1]), parseFloat(hslMatch[2]), parseFloat(hslMatch[3]));
+	if (trimmed.startsWith("#")) {
+		const hex8Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})[0-9a-f]{2}$/);
+		if (hex8Match) return {
+			red: parseInt(hex8Match[1], 16),
+			green: parseInt(hex8Match[2], 16),
+			blue: parseInt(hex8Match[3], 16)
+		};
+		const hex6Match = trimmed.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/);
+		if (hex6Match) return {
+			red: parseInt(hex6Match[1], 16),
+			green: parseInt(hex6Match[2], 16),
+			blue: parseInt(hex6Match[3], 16)
+		};
+		const hex4Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])[0-9a-f]$/);
+		if (hex4Match) return {
+			red: parseInt(hex4Match[1] + hex4Match[1], 16),
+			green: parseInt(hex4Match[2] + hex4Match[2], 16),
+			blue: parseInt(hex4Match[3] + hex4Match[3], 16)
+		};
+		const hex3Match = trimmed.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/);
+		if (hex3Match) return {
+			red: parseInt(hex3Match[1] + hex3Match[1], 16),
+			green: parseInt(hex3Match[2] + hex3Match[2], 16),
+			blue: parseInt(hex3Match[3] + hex3Match[3], 16)
+		};
+	}
+	if (trimmed.includes("rgb")) {
+		const rgbMatch = trimmed.match(/rgba?\(\s*(\d+)[\s,]+(\d+)[\s,]+(\d+)/);
+		if (rgbMatch) return {
+			red: parseInt(rgbMatch[1], 10),
+			green: parseInt(rgbMatch[2], 10),
+			blue: parseInt(rgbMatch[3], 10)
+		};
+	}
+	if (trimmed.includes("hsl")) {
+		const hslMatch = trimmed.match(/hsla?\(\s*([\d.]+)(?:deg)?[\s,]+([\d.]+)%[\s,]+([\d.]+)%/);
+		if (hslMatch) return convertHslToRgb(parseFloat(hslMatch[1]), parseFloat(hslMatch[2]), parseFloat(hslMatch[3]));
+	}
 	return null;
 };
 //#endregion
@@ -19829,9 +20127,18 @@ const extractColorFromShadowLayer = (layer) => {
 	if (hexMatch) return parseColorToRgb(`#${hexMatch[1]}`);
 	return null;
 };
+const RGB_FUNCTION_PATTERN = /rgba?\([^)]*\)/g;
+const HEX_COLOR_PATTERN = /#[0-9a-f]{3,8}\b/gi;
+const NUMERIC_TOKEN_PATTERN = /(\d+(?:\.\d+)?)(px)?/g;
+const SHADOW_BLUR_TOKEN_INDEX = 2;
 const parseShadowLayerBlur = (layer) => {
-	const numericTokens = [...layer.replace(/rgba?\([^)]*\)/g, "").replace(/#[0-9a-f]{3,8}\b/gi, "").matchAll(/(\d+(?:\.\d+)?)(px)?/g)].map((match) => parseFloat(match[1]));
-	return numericTokens.length >= 3 ? numericTokens[2] : 0;
+	const withoutColors = layer.replace(RGB_FUNCTION_PATTERN, "").replace(HEX_COLOR_PATTERN, "");
+	let tokenIndex = 0;
+	for (const match of withoutColors.matchAll(NUMERIC_TOKEN_PATTERN)) {
+		if (tokenIndex === SHADOW_BLUR_TOKEN_INDEX) return parseFloat(match[1]);
+		tokenIndex += 1;
+	}
+	return 0;
 };
 const hasColoredGlowShadow = (shadowValue) => {
 	for (const layer of splitShadowLayers(shadowValue)) {
@@ -19951,7 +20258,10 @@ const isIntrinsicJsxAttribute = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/is-controlled-prop-mirror.ts
+const componentPropNamesCache = /* @__PURE__ */ new WeakMap();
 const collectComponentPropNames = (componentFunction) => {
+	const cached = componentPropNamesCache.get(componentFunction);
+	if (cached) return cached;
 	const propNames = /* @__PURE__ */ new Set();
 	if (!isFunctionLike$1(componentFunction)) return propNames;
 	const propsObjectParamNames = /* @__PURE__ */ new Set();
@@ -19965,27 +20275,23 @@ const collectComponentPropNames = (componentFunction) => {
 		if (child !== componentBody && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "ObjectPattern") && isNodeOfType(child.init, "Identifier") && propsObjectParamNames.has(child.init.name)) collectPatternNames(child.id, propNames);
 	});
+	componentPropNamesCache.set(componentFunction, propNames);
 	return propNames;
 };
-const declaresBindingNamed = (functionNode, bindingName) => {
+const ownScopeBoundNamesCache = /* @__PURE__ */ new WeakMap();
+const getOwnScopeBoundNames = (functionNode) => {
+	const cached = ownScopeBoundNamesCache.get(functionNode);
+	if (cached) return cached;
 	const boundNames = /* @__PURE__ */ new Set();
 	if (isFunctionLike$1(functionNode)) for (const param of functionNode.params ?? []) collectPatternNames(param, boundNames);
-	if (boundNames.has(bindingName)) return true;
-	let declaresName = false;
 	walkAst(functionNode, (child) => {
-		if (declaresName) return false;
 		if (child !== functionNode && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "VariableDeclarator")) {
-			const declaratorNames = /* @__PURE__ */ new Set();
-			collectPatternNames(child.id, declaratorNames);
-			if (declaratorNames.has(bindingName)) {
-				declaresName = true;
-				return false;
-			}
-		}
+		if (isNodeOfType(child, "VariableDeclarator")) collectPatternNames(child.id, boundNames);
 	});
-	return declaresName;
+	ownScopeBoundNamesCache.set(functionNode, boundNames);
+	return boundNames;
 };
+const declaresBindingNamed = (functionNode, bindingName) => getOwnScopeBoundNames(functionNode).has(bindingName);
 const isPropertyNamePosition = (identifier) => {
 	const parent = identifier.parent;
 	if (!parent) return false;
@@ -20408,36 +20714,28 @@ const isHandlerShapedReseed = (setterCall, componentFunction) => {
 	}
 	return hasNestedFunction;
 };
-const isReseededDraftBuffer = (useStateCall, isPropName) => {
-	const setterName = getStateSetterName(useStateCall);
-	if (!setterName) return false;
-	const componentFunction = findEnclosingFunction(useStateCall);
-	if (!componentFunction) return false;
-	let isReseeded = false;
-	walkAst(componentFunction, (child) => {
-		if (isReseeded) return false;
-		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName && isPropDerivedArgument(child.arguments?.[0], isPropName) && isHandlerShapedReseed(child, componentFunction)) {
-			isReseeded = true;
-			return false;
-		}
-	});
-	return isReseeded;
+const isInRenderScope = (node, componentFunction) => {
+	let cursor = node.parent ?? null;
+	while (cursor && cursor !== componentFunction) {
+		if (isFunctionLike$1(cursor)) return false;
+		cursor = cursor.parent ?? null;
+	}
+	return true;
 };
-const isAdjustedDuringRender = (useStateCall, isPropName) => {
+const isDraftReseedOrRenderAdjusted = (useStateCall, isPropName) => {
 	const setterName = getStateSetterName(useStateCall);
 	if (!setterName) return false;
 	const componentFunction = findEnclosingFunction(useStateCall);
 	if (!componentFunction) return false;
-	let isAdjusted = false;
+	let isExempt = false;
 	walkAst(componentFunction, (child) => {
-		if (isAdjusted) return false;
-		if (child !== componentFunction && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName && isPropDerivedArgument(child.arguments?.[0], isPropName)) {
-			isAdjusted = true;
+		if (isExempt) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName && isPropDerivedArgument(child.arguments?.[0], isPropName) && (isHandlerShapedReseed(child, componentFunction) || isInRenderScope(child, componentFunction))) {
+			isExempt = true;
 			return false;
 		}
 	});
-	return isAdjusted;
+	return isExempt;
 };
 const noDerivedUseState = defineRule({
 	id: "no-derived-useState",
@@ -20454,8 +20752,7 @@ const noDerivedUseState = defineRule({
 				const initializer = node.arguments[0];
 				if (isNodeOfType(initializer, "Identifier") && propStackTracker.isPropName(initializer.name)) {
 					if (isInitialOnlyPropName(initializer.name)) return;
-					if (isReseededDraftBuffer(node, propStackTracker.isPropName)) return;
-					if (isAdjustedDuringRender(node, propStackTracker.isPropName)) return;
+					if (isDraftReseedOrRenderAdjusted(node, propStackTracker.isPropName)) return;
 					context.report({
 						node,
 						message: `Your users see a stale value when prop "${initializer.name}" changes because useState copies it once.`
@@ -20466,8 +20763,7 @@ const noDerivedUseState = defineRule({
 					const rootIdentifierName = getRootIdentifierName(initializer);
 					if (rootIdentifierName && propStackTracker.isPropName(rootIdentifierName)) {
 						if (isNodeOfType(initializer.property, "Identifier") && isInitialOnlyPropName(initializer.property.name)) return;
-						if (isReseededDraftBuffer(node, propStackTracker.isPropName)) return;
-						if (isAdjustedDuringRender(node, propStackTracker.isPropName)) return;
+						if (isDraftReseedOrRenderAdjusted(node, propStackTracker.isPropName)) return;
 						context.report({
 							node,
 							message: `Your users see a stale value when prop "${rootIdentifierName}" changes because useState copies it once.`
@@ -20582,7 +20878,7 @@ const isStateMemberExpression = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/no-direct-mutation-state.ts
-const MESSAGE$24 = "Your users see stale data because mutating `this.state` by hand never redraws & gets overwritten.";
+const MESSAGE$24 = "Mutating `this.state` by hand never triggers a redraw on its own & a later setState can overwrite it, so use `this.setState` instead.";
 const shouldIgnoreMutation = (node) => {
 	let isConstructor = false;
 	let isInsideCallExpression = false;
@@ -20676,6 +20972,18 @@ const initializerMarksPlainState = (initializerArgument) => {
 	}
 	return producesPlainStateValue(unwrapped);
 };
+const collectCallbackRefSetterNames = (componentBody) => {
+	const callbackRefSetterNames = /* @__PURE__ */ new Set();
+	walkAst(componentBody, (node) => {
+		if (!isNodeOfType(node, "JSXAttribute")) return;
+		const attributeName = node.name;
+		if (isNodeOfType(attributeName, "JSXIdentifier") && attributeName.name === "ref" && node.value && isNodeOfType(node.value, "JSXExpressionContainer")) {
+			const expression = stripParenExpression(node.value.expression);
+			if (isNodeOfType(expression, "Identifier")) callbackRefSetterNames.add(expression.name);
+		}
+	});
+	return callbackRefSetterNames;
+};
 const collectFunctionLocalBindings = (functionNode) => {
 	const localBindings = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return localBindings;
@@ -20718,8 +21026,10 @@ const noDirectStateMutation = defineRule({
 			const bindings = collectUseStateBindings(componentBody);
 			if (bindings.length === 0) return;
 			const stateValueToSetter = new Map(bindings.map((binding) => [binding.valueName, binding.setterName]));
+			const callbackRefSetterNames = collectCallbackRefSetterNames(componentBody);
 			const plainObjectStateValueNames = /* @__PURE__ */ new Set();
 			for (const binding of bindings) {
+				if (callbackRefSetterNames.has(binding.setterName)) continue;
 				if (!isNodeOfType(binding.declarator.init, "CallExpression")) continue;
 				if (initializerMarksPlainState(binding.declarator.init.arguments?.[0])) plainObjectStateValueNames.add(binding.valueName);
 			}
@@ -20732,7 +21042,7 @@ const noDirectStateMutation = defineRule({
 					if (currentlyShadowed.has(rootName)) return;
 					context.report({
 						node: child,
-						message: `Your screen won't update because you change "${rootName}" in place.`
+						message: `React can't tell you changed "${rootName}" in place, so this update can be skipped or lost.`
 					});
 					return;
 				}
@@ -20748,7 +21058,7 @@ const noDirectStateMutation = defineRule({
 					if (currentlyShadowed.has(rootName)) return;
 					context.report({
 						node: child,
-						message: `Your screen won't update because .${methodName}() changes "${rootName}" in place.`
+						message: `React can't tell .${methodName}() changed "${rootName}" in place, so this update can be skipped or lost.`
 					});
 				}
 			});
@@ -22166,20 +22476,20 @@ const getTriggerGuardRootName = (testNode) => {
 	return null;
 };
 const collectHandlerOnlyWriteStateNames = (componentBody, useStateBindings, handlerBindingNames) => {
+	const setterNames = new Set(useStateBindings.map((binding) => binding.setterName));
+	const settersWithAnyCall = /* @__PURE__ */ new Set();
+	const settersWithNonHandlerCall = /* @__PURE__ */ new Set();
+	walkAst(componentBody, (child) => {
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!isNodeOfType(child.callee, "Identifier")) return;
+		const setterName = child.callee.name;
+		if (!setterNames.has(setterName)) return;
+		settersWithAnyCall.add(setterName);
+		if (settersWithNonHandlerCall.has(setterName)) return;
+		if (!isInsideEventHandler(child, handlerBindingNames)) settersWithNonHandlerCall.add(setterName);
+	});
 	const handlerOnlyWriteStateNames = /* @__PURE__ */ new Set();
-	for (const binding of useStateBindings) {
-		let didFindAnySetterCall = false;
-		let areAllSetterCallsInHandlers = true;
-		walkAst(componentBody, (child) => {
-			if (!areAllSetterCallsInHandlers) return false;
-			if (!isNodeOfType(child, "CallExpression")) return;
-			if (!isNodeOfType(child.callee, "Identifier")) return;
-			if (child.callee.name !== binding.setterName) return;
-			didFindAnySetterCall = true;
-			if (!isInsideEventHandler(child, handlerBindingNames)) areAllSetterCallsInHandlers = false;
-		});
-		if (didFindAnySetterCall && areAllSetterCallsInHandlers) handlerOnlyWriteStateNames.add(binding.valueName);
-	}
+	for (const binding of useStateBindings) if (settersWithAnyCall.has(binding.setterName) && !settersWithNonHandlerCall.has(binding.setterName)) handlerOnlyWriteStateNames.add(binding.valueName);
 	return handlerOnlyWriteStateNames;
 };
 const noEventTriggerState = defineRule({
@@ -22519,6 +22829,10 @@ const COLORED_BG_PATTERN = /^bg-(?:red|orange|amber|yellow|lime|green|emerald|te
 const TEXT_COLOR_PATTERN = /^text-(?:white|black|transparent|current|inherit|\[|(?:gray|slate|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-)/;
 const BG_COLOR_PATTERN = /^bg-(?:white|black|transparent|current|inherit|\[|(?:gray|slate|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-)/;
 const splitVariantScope = (token) => {
+	if (!token.includes(":")) return {
+		scope: "",
+		utility: token.startsWith("!") ? token.slice(1) : token
+	};
 	const segments = token.split(":");
 	const rawUtility = segments[segments.length - 1];
 	return {
@@ -22542,6 +22856,7 @@ const noGrayOnColoredBackground = defineRule({
 		const bgColorScopes = /* @__PURE__ */ new Set();
 		for (const token of classStr.split(/\s+/)) {
 			if (!token) continue;
+			if (!token.includes("text-") && !token.includes("bg-")) continue;
 			const { scope, utility } = splitVariantScope(token);
 			if (TEXT_COLOR_PATTERN.test(utility)) textColorScopes.add(scope);
 			if (BG_COLOR_PATTERN.test(utility)) bgColorScopes.add(scope);
@@ -22612,11 +22927,16 @@ const NON_DETERMINISTIC_ID_GENERATOR_NAMES = new Set([
 	"ulid",
 	"createId"
 ]);
+const isZeroArgDateConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Date" && (node.arguments?.length ?? 0) === 0;
 const containsNonDeterministicSource = (root) => {
 	let found = false;
 	walkAst(root, (child) => {
 		if (found) return false;
 		if (isFunctionLike$1(child)) return false;
+		if (isZeroArgDateConstruction(child)) {
+			found = true;
+			return false;
+		}
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const callee = child.callee;
 		if (isNodeOfType(callee, "Identifier") && NON_DETERMINISTIC_ID_GENERATOR_NAMES.has(callee.name)) {
@@ -22677,6 +22997,53 @@ const argumentReadsPostMountMeasurement = (argument, effectFn, visitedLocalNames
 	});
 	return found;
 };
+const isResourceLikeInitializer = (initializer) => {
+	if (isNodeOfType(initializer, "AwaitExpression")) return isResourceLikeInitializer(initializer.argument);
+	return isNodeOfType(initializer, "NewExpression") || isNodeOfType(initializer, "CallExpression");
+};
+const collectArgumentSourceLocalNames = (argument, effectFn, sourceLocalNames = /* @__PURE__ */ new Set()) => {
+	walkAst(argument, (child) => {
+		if (!isNodeOfType(child, "Identifier")) return;
+		if (sourceLocalNames.has(child.name)) return;
+		const localInitializer = findEffectLocalInitializer(effectFn, child.name);
+		if (!localInitializer || !isResourceLikeInitializer(localInitializer)) return;
+		sourceLocalNames.add(child.name);
+		collectArgumentSourceLocalNames(localInitializer, effectFn, sourceLocalNames);
+	});
+	return sourceLocalNames;
+};
+const isFunctionExpressionLike$1 = (node) => isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression");
+const findCleanupFunction = (effectFn) => {
+	if (!isNodeOfType(effectFn, "ArrowFunctionExpression") && !isNodeOfType(effectFn, "FunctionExpression")) return null;
+	const body = effectFn.body;
+	if (!isNodeOfType(body, "BlockStatement")) return null;
+	let cleanupFunction = null;
+	walkAst(body, (child) => {
+		if (cleanupFunction) return false;
+		if (isNodeOfType(child, "ReturnStatement")) {
+			if (child.argument && isFunctionExpressionLike$1(child.argument)) cleanupFunction = child.argument;
+			return false;
+		}
+		if (child !== body && isFunctionExpressionLike$1(child)) return false;
+		if (isNodeOfType(child, "FunctionDeclaration")) return false;
+	});
+	return cleanupFunction;
+};
+const cleanupDisposesArgumentSource = (argument, effectFn) => {
+	const cleanupFunction = findCleanupFunction(effectFn);
+	if (!cleanupFunction) return false;
+	const sourceLocalNames = collectArgumentSourceLocalNames(argument, effectFn);
+	if (sourceLocalNames.size === 0) return false;
+	let referencesSource = false;
+	walkAst(cleanupFunction, (child) => {
+		if (referencesSource) return false;
+		if (isNodeOfType(child, "Identifier") && sourceLocalNames.has(child.name)) {
+			referencesSource = true;
+			return false;
+		}
+	});
+	return referencesSource;
+};
 const noInitializeState = defineRule({
 	id: "no-initialize-state",
 	title: "State initialized from a mount effect",
@@ -22699,6 +23066,7 @@ const noInitializeState = defineRule({
 			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
 			if (callExpr.arguments?.some((argument) => Boolean(argument) && containsNonDeterministicSource(argument))) continue;
 			if (callExpr.arguments?.some((argument) => Boolean(argument) && argumentReadsPostMountMeasurement(argument, effectFn))) continue;
+			if (callExpr.arguments?.some((argument) => Boolean(argument) && cleanupDisposesArgumentSource(argument, effectFn))) continue;
 			const useStateDecl = getUseStateDecl(analysis, ref);
 			if (!useStateDecl || !isNodeOfType(useStateDecl, "VariableDeclarator")) continue;
 			if (!isNodeOfType(useStateDecl.id, "ArrayPattern")) continue;
@@ -23271,6 +23639,8 @@ const hasInfiniteIterationCount = (properties) => properties.some((property) =>
 	return isNodeOfType(property, "Property") && isNodeOfType(property.value, "Identifier") && property.value.name === "Infinity";
 });
 const isInfiniteAnimationSegment = (segment) => segment.trim().split(/\s+/).includes("infinite");
+const DURATION_SEGMENT_PATTERN = /^([\d.]+)(m?s)$/;
+const FIRST_TIME_TOKEN_PATTERN = /(?<![a-zA-Z\d])([\d.]+)(m?s)(?![a-zA-Z\d-])/;
 const noLongTransitionDuration = defineRule({
 	id: "no-long-transition-duration",
 	title: "Transition duration too long",
@@ -23294,11 +23664,10 @@ const noLongTransitionDuration = defineRule({
 			if (key === "transitionDuration" || key === "animationDuration") {
 				let longestDurationPropertyMs = 0;
 				for (const segment of value.split(",")) {
-					const trimmedSegment = segment.trim();
-					const msMatch = trimmedSegment.match(/^([\d.]+)ms$/);
-					const secondsMatch = trimmedSegment.match(/^([\d.]+)s$/);
-					if (msMatch) longestDurationPropertyMs = Math.max(longestDurationPropertyMs, parseFloat(msMatch[1]));
-					else if (secondsMatch) longestDurationPropertyMs = Math.max(longestDurationPropertyMs, parseFloat(secondsMatch[1]) * 1e3);
+					const durationMatch = segment.trim().match(DURATION_SEGMENT_PATTERN);
+					if (!durationMatch) continue;
+					const segmentDurationMs = durationMatch[2] === "ms" ? parseFloat(durationMatch[1]) : parseFloat(durationMatch[1]) * 1e3;
+					longestDurationPropertyMs = Math.max(longestDurationPropertyMs, segmentDurationMs);
 				}
 				if (longestDurationPropertyMs > 0) durationMs = longestDurationPropertyMs;
 			}
@@ -23306,7 +23675,7 @@ const noLongTransitionDuration = defineRule({
 				let longestDurationMs = 0;
 				for (const segment of value.split(",")) {
 					if (key === "animation" && isInfiniteAnimationSegment(segment)) continue;
-					const firstTimeMatch = segment.match(/(?<![a-zA-Z\d])([\d.]+)(m?s)(?![a-zA-Z\d-])/);
+					const firstTimeMatch = segment.match(FIRST_TIME_TOKEN_PATTERN);
 					if (!firstTimeMatch) continue;
 					const segmentDurationMs = firstTimeMatch[2] === "ms" ? parseFloat(firstTimeMatch[1]) : parseFloat(firstTimeMatch[1]) * 1e3;
 					longestDurationMs = Math.max(longestDurationMs, segmentDurationMs);
@@ -24478,14 +24847,14 @@ const collectRoleBranches = (expression, out) => {
 	out.hasOpaqueBranch = true;
 };
 const buildMessage$12 = (tag) => `Keyboard & screen reader users can't trigger this \`<${tag}>\` because it isn't interactive, so use a button or link or add an interactive role.`;
-const INTERACTIVE_HANDLERS = [
+const INTERACTIVE_HANDLERS_LOWER = new Set([
 	"onClick",
 	"onMouseDown",
 	"onMouseUp",
 	"onKeyDown",
 	"onKeyPress",
 	"onKeyUp"
-];
+].map((handlerName) => handlerName.toLowerCase()));
 const noNoninteractiveElementInteractions = defineRule({
 	id: "no-noninteractive-element-interactions",
 	title: "Handler on non-interactive element",
@@ -24500,7 +24869,16 @@ const noNoninteractiveElementInteractions = defineRule({
 			const tag = getElementType(node, context.settings);
 			if (!NON_INTERACTIVE_ELEMENTS.has(tag)) return;
 			if (tag === "label") return;
-			if (!INTERACTIVE_HANDLERS.some((handler) => hasJsxPropIgnoreCase(node.attributes, handler))) return;
+			let hasHandler = false;
+			for (const attribute of node.attributes) {
+				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+				const attributeName = getJsxAttributeName(attribute.name);
+				if (attributeName && INTERACTIVE_HANDLERS_LOWER.has(attributeName.toLowerCase())) {
+					hasHandler = true;
+					break;
+				}
+			}
+			if (!hasHandler) return;
 			if (isHiddenFromScreenReader(node, context.settings)) return;
 			const roleAttr = hasJsxPropIgnoreCase(node.attributes, "role");
 			if (roleAttr) {
@@ -24606,6 +24984,18 @@ const KEYBOARD_HANDLER_PROP_NAMES = [
 	"onKeyPress"
 ];
 const isKeyboardOperable = (node) => KEYBOARD_HANDLER_PROP_NAMES.some((propName) => Boolean(hasJsxPropIgnoreCase(node.attributes, propName)));
+const parseNumericBranch = (expression) => {
+	if (isNodeOfType(expression, "Literal") && typeof expression.value === "number") return expression.value;
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "-" && isNodeOfType(expression.argument, "Literal") && typeof expression.argument.value === "number") return -expression.argument.value;
+	return null;
+};
+const isRovingTabindexValue = (value) => {
+	if (!isNodeOfType(value, "JSXExpressionContainer")) return false;
+	const expression = value.expression;
+	if (!isNodeOfType(expression, "ConditionalExpression")) return false;
+	if (isNodeOfType(expression.test, "Literal")) return false;
+	return [parseNumericBranch(expression.consequent), parseNumericBranch(expression.alternate)].some((branchValue) => branchValue !== null && branchValue < 0);
+};
 const resolveSettings$14 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noNoninteractiveTabindex ?? {} : {};
@@ -24629,6 +25019,7 @@ const noNoninteractiveTabindex = defineRule({
 			if (!tabIndex) return;
 			const tabIndexValue = tabIndex.value;
 			if (!tabIndexValue) return;
+			if (isRovingTabindexValue(tabIndexValue)) return;
 			const numeric = parseJsxValue(tabIndexValue);
 			if (numeric === null) {
 				if (isNodeOfType(tabIndexValue, "JSXExpressionContainer") && !settings.allowExpressionValues && !isKeyboardOperable(node)) context.report({
@@ -25813,16 +26204,22 @@ const ELEMENT_ROLE_PAIRS = [
 	["tr", "row"],
 	["ul", "list"]
 ];
-const getElementImplicitRoles = (tag) => {
-	const out = [];
-	for (const [element, role] of ELEMENT_ROLE_PAIRS) if (element === tag && !out.includes(role)) out.push(role);
-	return out;
-};
-const getTagsForRole = (role) => {
-	const out = [];
-	for (const [element, r] of ELEMENT_ROLE_PAIRS) if (r === role && !out.includes(element)) out.push(element);
-	return out;
+const EMPTY_ROLE_LIST = [];
+const buildLookup = (pairs, keyIndex) => {
+	const lookup = /* @__PURE__ */ new Map();
+	for (const pair of pairs) {
+		const key = pair[keyIndex];
+		const value = pair[keyIndex === 0 ? 1 : 0];
+		const values = lookup.get(key);
+		if (!values) lookup.set(key, [value]);
+		else if (!values.includes(value)) values.push(value);
+	}
+	return lookup;
 };
+const IMPLICIT_ROLES_BY_TAG = buildLookup(ELEMENT_ROLE_PAIRS, 0);
+const TAGS_BY_ROLE = buildLookup(ELEMENT_ROLE_PAIRS, 1);
+const getElementImplicitRoles = (tag) => IMPLICIT_ROLES_BY_TAG.get(tag) ?? EMPTY_ROLE_LIST;
+const getTagsForRole = (role) => TAGS_BY_ROLE.get(role) ?? EMPTY_ROLE_LIST;
 //#endregion
 //#region src/plugin/utils/get-implicit-role.ts
 const getImplicitRole = (node, elementType) => {
@@ -26059,22 +26456,22 @@ const noRenderInRender = defineRule({
 	title: "Component rendered by inline function call",
 	severity: "warn",
 	tags: ["test-noise"],
-	recommendation: "Make it a named component so React preserves its identity and does not remount its state.",
+	recommendation: "Make it a named component rendered as JSX so React can track it and preserve its state.",
 	create: (context) => ({ JSXExpressionContainer(node) {
 		const expression = node.expression;
 		if (!isNodeOfType(expression, "CallExpression")) return;
 		let calleeName = null;
+		if (isNodeOfType(expression.callee, "Identifier")) calleeName = expression.callee.name;
+		else if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.property, "Identifier")) calleeName = expression.callee.property.name;
+		if (!calleeName || !RENDER_FUNCTION_PATTERN.test(calleeName)) return;
 		if (isNodeOfType(expression.callee, "Identifier")) {
 			if (tracesToPropOrParameter(context.scopes.symbolFor(expression.callee), context.scopes)) return;
-			calleeName = expression.callee.name;
-		} else if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.property, "Identifier")) {
+		} else if (isNodeOfType(expression.callee, "MemberExpression")) {
 			if (rootsInProps(expression.callee.object, context.scopes)) return;
-			calleeName = expression.callee.property.name;
 		}
-		if (!calleeName || !RENDER_FUNCTION_PATTERN.test(calleeName)) return;
 		context.report({
 			node: expression,
-			message: `Your users lose state because "${calleeName}()" builds UI from an inline call that React remounts, so pull it into its own component instead.`
+			message: `"${calleeName}()" hides a component behind an inline call, so pull it into its own component and render it as JSX so React can track it.`
 		});
 	} })
 });
@@ -26177,8 +26574,8 @@ const countUseStates = (analysis, componentNode) => {
 	for (const ref of getDownstreamRefs(analysis, componentNode)) if (isState(analysis, ref)) stateVariables.add(ref.resolved);
 	return stateVariables.size;
 };
-const findPropUsedToResetAllState = (analysis, effectFnRefs, depsRefs, useEffectNode) => {
-	const stateSetterRefs = effectFnRefs.filter((ref) => isStateSetterCall(analysis, ref));
+const findPropUsedToResetAllState = (analysis, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
+	const stateSetterRefs = effectFnRefs.filter((ref) => isSyncStateSetterCall(analysis, ref, effectFn));
 	if (stateSetterRefs.length === 0) return null;
 	if (!stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, ref))) return null;
 	const containing = findContainingNode(analysis, useEffectNode);
@@ -26201,7 +26598,9 @@ const noResetAllStateOnPropChange = defineRule({
 		if (!effectFnRefs || !depsRefs) return;
 		const containing = findContainingNode(analysis, node);
 		if (containing && isCustomHook(containing)) return;
-		if (!findPropUsedToResetAllState(analysis, effectFnRefs, depsRefs, node)) return;
+		const effectFn = getEffectFn(analysis, node);
+		if (!effectFn) return;
+		if (!findPropUsedToResetAllState(analysis, effectFnRefs, depsRefs, node, effectFn)) return;
 		context.report({
 			node,
 			message: `Your users briefly see stale state when a prop changes because this useEffect clears all state.`
@@ -26322,6 +26721,7 @@ const TANSTACK_ROUTE_PROPERTY_ORDER = [
 	"headers",
 	"remountDeps"
 ];
+const TANSTACK_ROUTE_PROPERTY_INDEX = new Map(TANSTACK_ROUTE_PROPERTY_ORDER.map((propertyName, orderIndex) => [propertyName, orderIndex]));
 const TANSTACK_ROUTE_CREATION_FUNCTIONS = new Set([
 	"createFileRoute",
 	"createRoute",
@@ -26337,6 +26737,7 @@ const TANSTACK_MIDDLEWARE_METHOD_ORDER = [
 	"server",
 	"handler"
 ];
+const TANSTACK_MIDDLEWARE_METHOD_INDEX = new Map(TANSTACK_MIDDLEWARE_METHOD_ORDER.map((methodName, orderIndex) => [methodName, orderIndex]));
 const TANSTACK_REDIRECT_FUNCTIONS = new Set(["redirect", "notFound"]);
 const TANSTACK_SERVER_FN_FILE_PATTERN = /\.functions(\.[jt]sx?)?$/;
 const TANSTACK_QUERY_HOOKS = new Set([
@@ -27041,14 +27442,21 @@ const noStaticElementInteractions = defineRule({
 	category: "Accessibility",
 	create: (context) => {
 		const settings = resolveSettings$12(context.settings);
+		const handlersLower = new Set(settings.handlers.map((handlerName) => handlerName.toLowerCase()));
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return { JSXOpeningElement(node) {
 			if (isTestlikeFile) return;
 			let hasNonBlockerHandler = false;
 			let hasAnyHandler = false;
-			for (const handler of settings.handlers) {
-				const attribute = hasJsxPropIgnoreCase(node.attributes, handler);
-				if (!attribute) continue;
+			let seenHandlerNames = null;
+			for (const attribute of node.attributes) {
+				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+				const attributeName = getJsxAttributeName(attribute.name);
+				if (!attributeName) continue;
+				const handlerNameLower = attributeName.toLowerCase();
+				if (!handlersLower.has(handlerNameLower)) continue;
+				if (seenHandlerNames?.has(handlerNameLower)) continue;
+				(seenHandlerNames ??= /* @__PURE__ */ new Set()).add(handlerNameLower);
 				if (isNullValue(attribute)) continue;
 				hasAnyHandler = true;
 				if (!isPureEventBlockerHandler(attribute)) {
@@ -27060,6 +27468,7 @@ const noStaticElementInteractions = defineRule({
 			if (!hasNonBlockerHandler) return;
 			const elementType = getElementType(node, context.settings);
 			if (!HTML_TAGS.has(elementType)) return;
+			if (elementType === "svg") return;
 			if (isHiddenFromScreenReader(node, context.settings)) return;
 			if (isPresentationRole(node)) return;
 			if (isInteractiveElement(elementType, node)) return;
@@ -27073,7 +27482,8 @@ const noStaticElementInteractions = defineRule({
 				});
 				return;
 			}
-			const attributeValue = roleAttribute.value;
+			let attributeValue = roleAttribute.value;
+			if (isNodeOfType(attributeValue, "JSXExpressionContainer") && isNodeOfType(attributeValue.expression, "Literal") && typeof attributeValue.expression.value === "string") attributeValue = attributeValue.expression;
 			if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") {
 				const firstRole = attributeValue.value.toLowerCase().trim().split(/\s+/)[0];
 				if (firstRole && (isInteractiveRole(firstRole) || isNonInteractiveRole(firstRole))) return;
@@ -28229,13 +28639,13 @@ const DOM_ATTRIBUTES_TO_CAMEL = new Map([
 	["xml:lang", "xmlLang"],
 	["xml:space", "xmlSpace"]
 ]);
-const DOM_PROPERTIES_IGNORE_CASE = [
+const DOM_PROPERTIES_IGNORE_CASE_BY_LOWER = new Map([
 	"charset",
 	"allowFullScreen",
 	"webkitAllowFullScreen",
 	"mozAllowFullScreen",
 	"webkitDirectory"
-];
+].map((name) => [name.toLowerCase(), name]));
 //#endregion
 //#region src/plugin/constants/dom-property-tags.ts
 const DOM_PROPERTY_TO_ALLOWED_TAGS = new Map([
@@ -28439,10 +28849,7 @@ const matchesHtmlTagConventions = (tagName) => {
 	if (!(firstCharacter >= 97 && firstCharacter <= 122)) return false;
 	return !tagName.includes("-");
 };
-const normalizeAttributeCase = (name) => {
-	for (const ignoreCaseName of DOM_PROPERTIES_IGNORE_CASE) if (ignoreCaseName.toLowerCase() === name.toLowerCase()) return ignoreCaseName;
-	return name;
-};
+const normalizeAttributeCase = (name) => DOM_PROPERTIES_IGNORE_CASE_BY_LOWER.get(name.toLowerCase()) ?? name;
 const hasUppercaseChar = (input) => /[A-Z]/.test(input);
 const INVALID_PROP_ON_TAG = (propName, allowedTags) => `React ignores \`${propName}\` here because it only works on these tags: ${allowedTags}.`;
 const DATA_LOWERCASE_REQUIRED = () => `React drops this \`data-*\` prop because of its capital letters.`;
@@ -28786,32 +29193,26 @@ const isFirstArgumentOfHocCall = (node) => {
 	if (!isHocCallee$1(parent)) return false;
 	return parent.arguments[0] === node;
 };
+const MAP_LIKE_METHOD_NAMES = new Set([
+	"map",
+	"forEach",
+	"filter",
+	"flatMap",
+	"reduce",
+	"reduceRight"
+]);
 const isReturnOfMapCallback = (node) => {
 	const parent = node.parent;
 	if (!parent) return false;
 	if (isNodeOfType(parent, "CallExpression")) {
 		const callee = parent.callee;
-		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return [
-			"map",
-			"forEach",
-			"filter",
-			"flatMap",
-			"reduce",
-			"reduceRight"
-		].includes(callee.property.name);
+		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return MAP_LIKE_METHOD_NAMES.has(callee.property.name);
 	}
 	if (isNodeOfType(parent, "ArrowFunctionExpression") || isNodeOfType(parent, "FunctionExpression")) {
 		const callbackParent = parent.parent;
 		if (callbackParent && isNodeOfType(callbackParent, "CallExpression")) {
 			const callee = callbackParent.callee;
-			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return [
-				"map",
-				"forEach",
-				"filter",
-				"flatMap",
-				"reduce",
-				"reduceRight"
-			].includes(callee.property.name);
+			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return MAP_LIKE_METHOD_NAMES.has(callee.property.name);
 		}
 	}
 	return false;
@@ -28847,10 +29248,10 @@ const isRenderFlowingReadReference = (identifier) => {
 				valueNode = parent;
 				parent = parent.parent;
 				continue;
-			case "VariableDeclarator": return parent.init === valueNode && isNodeOfType(parent.id, "Identifier") && isUppercaseName(parent.id.name);
+			case "VariableDeclarator": return parent.init === valueNode && isNodeOfType(parent.id, "Identifier") && isReactComponentName(parent.id.name);
 			case "AssignmentExpression": {
 				const assignmentTarget = parent.left;
-				return parent.right === valueNode && isNodeOfType(assignmentTarget, "Identifier") && isUppercaseName(assignmentTarget.name);
+				return parent.right === valueNode && isNodeOfType(assignmentTarget, "Identifier") && isReactComponentName(assignmentTarget.name);
 			}
 			case "Property":
 				if (parent.value !== valueNode) return false;
@@ -28943,14 +29344,14 @@ const noUnstableNestedComponents = defineRule({
 		};
 		return {
 			JSXOpeningElement(node) {
-				if (isNodeOfType(node.name, "JSXIdentifier") && isUppercaseName(node.name.name)) {
+				if (isNodeOfType(node.name, "JSXIdentifier") && isReactComponentName(node.name.name)) {
 					recordInstantiation(node.name, node.name.name);
 					return;
 				}
 				if (isNodeOfType(node.name, "JSXMemberExpression")) recordMemberChainInstantiation(node.name);
 			},
 			Identifier(node) {
-				if (!isUppercaseName(node.name)) return;
+				if (!isReactComponentName(node.name)) return;
 				if (!isRenderFlowingReadReference(node)) return;
 				recordInstantiation(node, node.name);
 			},
@@ -29521,21 +29922,18 @@ const classifyExport = (name, reportNode, isFunction, initializer, state) => {
 		reportNode
 	};
 };
-const collectAllNodes = (programRoot) => {
-	const out = [];
-	const visit = (node) => {
-		out.push(node);
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-		}
+const collectRelevantNodes = (programRoot) => {
+	const exportNodes = [];
+	const componentCandidates = [];
+	walkAst(programRoot, (child) => {
+		const childType = child.type;
+		if (childType === "ExportAllDeclaration" || childType === "ExportDefaultDeclaration" || childType === "ExportNamedDeclaration") exportNodes.push(child);
+		else if (childType === "FunctionDeclaration" || childType === "VariableDeclarator") componentCandidates.push(child);
+	});
+	return {
+		exportNodes,
+		componentCandidates
 	};
-	visit(programRoot);
-	return out;
 };
 const isEntryPointFile = (filename) => {
 	const lastSlash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
@@ -29582,13 +29980,13 @@ const onlyExportComponents = defineRule({
 		};
 		return { Program(node) {
 			if (!isFileNameAllowed(normalizeFilename(context.filename ?? ""), settings.checkJS)) return;
-			const allNodes = collectAllNodes(node);
+			const { exportNodes, componentCandidates } = collectRelevantNodes(node);
 			const exports = [];
 			let hasReactExport = false;
 			let hasAnyExports = false;
 			const localComponents = [];
 			const isExportedNodeIds = /* @__PURE__ */ new WeakSet();
-			for (const child of allNodes) {
+			for (const child of exportNodes) {
 				if (isNodeOfType(child, "ExportAllDeclaration")) {
 					if (child.exportKind === "type") continue;
 					hasAnyExports = true;
@@ -29724,12 +30122,12 @@ const onlyExportComponents = defineRule({
 				}
 				return false;
 			};
-			for (const child of allNodes) {
+			for (const child of componentCandidates) {
 				if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-					if (isReactComponentName(child.id.name) && !isInsideExport(child)) localComponents.push(child.id);
+					if (isReactComponentName(child.id.name) && !isInsideExport(child) && !isInsideFunctionScope(child)) localComponents.push(child.id);
 				}
 				if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
-					if (isReactComponentName(child.id.name) && canBeReactFunctionComponent(child.init, state) && !isInsideExport(child)) localComponents.push(child.id);
+					if (isReactComponentName(child.id.name) && canBeReactFunctionComponent(child.init, state) && !isInsideExport(child) && !isInsideFunctionScope(child)) localComponents.push(child.id);
 				}
 			}
 			if (hasAnyExports && hasReactExport) for (const entry of exports) {
@@ -29884,7 +30282,7 @@ const containsVnodeFactoryCall = (root) => {
 };
 const isComponentLikeFunction = (functionNode) => {
 	const bindingName = getFunctionBindingName(functionNode);
-	if (bindingName && (isReactComponentName(bindingName) || HOOK_NAME_PATTERN.test(bindingName))) return true;
+	if (bindingName && (isReactComponentName(bindingName) || HOOK_NAME_PATTERN$1.test(bindingName))) return true;
 	const body = "body" in functionNode ? functionNode.body : null;
 	if (!body || !isAstNode(body)) return false;
 	return containsJsxElement(body) || containsVnodeFactoryCall(body);
@@ -30763,13 +31161,13 @@ const preferStableEmptyFallback = defineRule({
 				memoRegistry = buildSameFileMemoRegistry(node);
 			},
 			JSXAttribute(node) {
-				if (!isInsideFunctionScope(node)) return;
-				if (isJsxAttributeOnIntrinsicHtmlElement(node)) return;
 				if (!node.value) return;
 				if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
 				const innerExpression = node.value.expression;
 				if (!innerExpression) return;
 				if (innerExpression.type === "JSXEmptyExpression") return;
+				if (!isInsideFunctionScope(node)) return;
+				if (isJsxAttributeOnIntrinsicHtmlElement(node)) return;
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
@@ -31341,7 +31739,7 @@ const queryMutationMissingInvalidation = defineRule({
 		});
 		if (!hasCacheUpdate) context.report({
 			node,
-			message: "useMutation with no cache update leaves your users looking at stale data after it runs."
+			message: "useMutation with no cache update here can leave your users looking at stale data after it runs."
 		});
 	} })
 });
@@ -31990,6 +32388,7 @@ const renderingHydrationMismatchTime = defineRule({
 		return { JSXExpressionContainer(node) {
 			if (isTestlikeFile) return;
 			if (!node.expression) return;
+			if (isGeneratedImageRenderContext(context, findOpeningElementOfChild(node) ?? node)) return;
 			const matched = NONDETERMINISTIC_RENDER_PATTERNS.find((pattern) => pattern.matches(node.expression));
 			if (matched) {
 				if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
@@ -32141,41 +32540,11 @@ const callsIdentifier = (root, identifierName) => {
 	});
 	return found;
 };
-const setterIsCalledInAsyncContext = (componentBody, setterName) => {
-	if (!componentBody) return false;
-	let found = false;
-	walkAst(componentBody, (child) => {
-		if (found) return;
-		if (!isFunctionLike$1(child)) return;
-		const functionBody = child.body;
-		if (!(Boolean(child.async) || hasOwnAwait(functionBody))) return;
-		if (callsIdentifier(functionBody, setterName)) found = true;
-	});
-	return found;
-};
 const PROMISE_CHAIN_METHOD_NAMES = new Set([
 	"then",
 	"catch",
 	"finally"
 ]);
-const setterIsCalledInPromiseChain = (componentBody, setterName) => {
-	if (!componentBody) return false;
-	let found = false;
-	walkAst(componentBody, (child) => {
-		if (found) return;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = child.callee;
-		if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier") || !PROMISE_CHAIN_METHOD_NAMES.has(callee.property.name)) return;
-		for (const argument of child.arguments ?? []) {
-			if (!isFunctionLike$1(argument)) continue;
-			if (callsIdentifier(argument.body, setterName)) {
-				found = true;
-				return;
-			}
-		}
-	});
-	return found;
-};
 const ASYNC_DATA_CALLEE_NAMES = new Set([
 	"useApolloClient",
 	"useMutation",
@@ -32188,20 +32557,36 @@ const ASYNC_DATA_CALLEE_NAMES = new Set([
 	"fetch",
 	"axios"
 ]);
-const referencesAsyncDataApi = (body) => {
-	if (!body) return false;
+const hasAsyncLoadingWork = (fnBody, setterName) => {
 	let found = false;
-	walkAst(body, (child) => {
-		if (found) return;
+	walkAst(fnBody, (child) => {
+		if (found) return false;
 		if (isNodeOfType(child, "CallExpression")) {
 			const callee = child.callee;
 			if (isNodeOfType(callee, "Identifier") && ASYNC_DATA_CALLEE_NAMES.has(callee.name)) {
 				found = true;
-				return;
+				return false;
+			}
+			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
+				if (ASYNC_DATA_CALLEE_NAMES.has(callee.property.name)) {
+					found = true;
+					return false;
+				}
+				if (setterName !== null && PROMISE_CHAIN_METHOD_NAMES.has(callee.property.name)) for (const argument of child.arguments ?? []) {
+					if (!isFunctionLike$1(argument)) continue;
+					if (callsIdentifier(argument.body, setterName)) {
+						found = true;
+						return false;
+					}
+				}
 			}
-			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ASYNC_DATA_CALLEE_NAMES.has(callee.property.name)) {
+			return;
+		}
+		if (setterName !== null && isFunctionLike$1(child)) {
+			const functionBody = child.body;
+			if ((Boolean(child.async) || hasOwnAwait(functionBody)) && callsIdentifier(functionBody, setterName)) {
 				found = true;
-				return;
+				return false;
 			}
 		}
 	});
@@ -32226,7 +32611,7 @@ const renderingUsetransitionLoading = defineRule({
 		const secondBinding = node.id.elements[1];
 		const setterName = isNodeOfType(secondBinding, "Identifier") ? secondBinding.name : null;
 		const fnBody = enclosingFunctionBody(node);
-		if (fnBody && (setterName && setterIsCalledInAsyncContext(fnBody, setterName) || setterName && setterIsCalledInPromiseChain(fnBody, setterName) || referencesAsyncDataApi(fnBody))) return;
+		if (fnBody && hasAsyncLoadingWork(fnBody, setterName)) return;
 		context.report({
 			node: node.init,
 			message: `This adds an extra render because useState for "${stateVariableName}" re-renders just for the loading flag, so if it's a state change & not a data fetch, use useTransition instead`
@@ -33020,17 +33405,17 @@ const rerenderStateOnlyInHandlers = defineRule({
 			const effectTriggerNames = /* @__PURE__ */ new Set();
 			for (const dependencyName of collectDependencyArrayNames(componentBody)) if (!(stateValueNames.has(dependencyName) && effectCallbackReadNames.has(dependencyName))) effectTriggerNames.add(dependencyName);
 			for (const reachableName of expandTransitiveDependencies(effectTriggerNames, dependencyGraph)) renderReachableNames.add(reachableName);
+			const setterNames = new Set(bindings.map((binding) => binding.setterName));
+			const calledSetterNames = /* @__PURE__ */ new Set();
+			walkAst(componentBody, (child) => {
+				if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && setterNames.has(child.callee.name)) calledSetterNames.add(child.callee.name);
+			});
 			for (const binding of bindings) {
 				if (renderReachableNames.has(binding.valueName)) continue;
 				if (binding.valueName === "_" || binding.valueName.startsWith("_")) continue;
 				const setterSuffix = binding.setterName.slice(3);
 				if (/^(TriggerRender|ForceUpdate|Rerender|ForceRender|Tick|Bump|BumpVersion|InvalidateRender|Refresh|Repaint)$/i.test(setterSuffix)) continue;
-				let setterCalled = false;
-				walkAst(componentBody, (child) => {
-					if (setterCalled) return;
-					if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === binding.setterName) setterCalled = true;
-				});
-				if (!setterCalled) continue;
+				if (!calledSetterNames.has(binding.setterName)) continue;
 				if (isSetterCalledDuringRender(componentBody, binding.setterName)) continue;
 				context.report({
 					node: binding.declarator,
@@ -33362,6 +33747,7 @@ const RECYCLABLE_LIST_PACKAGES = {
 	FlashList: ["@shopify/flash-list"],
 	LegendList: ["@legendapp/list"]
 };
+const RECYCLABLE_LIST_PACKAGE_SOURCES = Object.values(RECYCLABLE_LIST_PACKAGES).flat();
 const REACT_NATIVE_LIST_COMPONENTS = new Set([...REACT_NATIVE_BUILTIN_LIST_COMPONENTS, ...Object.keys(RECYCLABLE_LIST_PACKAGES)]);
 const RENDER_ITEM_PROP_NAMES = new Set([
 	"renderItem",
@@ -33604,33 +33990,42 @@ const rnListMissingEstimatedItemSize = defineRule({
 	requires: ["react-native"],
 	severity: "warn",
 	recommendation: "Without `estimatedItemSize` the list guesses row height and can flash blank cells on fast scroll. Add `estimatedItemSize={<avg-row-height-in-px>}` so it matches your rows.",
-	create: (context) => ({ JSXOpeningElement(node) {
-		const localElementName = resolveJsxElementName(node);
-		if (!localElementName) return;
-		const canonicalRecyclerName = resolveImportedRecyclerName(node, localElementName);
-		if (canonicalRecyclerName === null) return;
-		if (canonicalRecyclerName === "FlashList" && isFlashListV2OrNewer(context)) 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;
+	create: (context) => {
+		let fileImportsRecycler = false;
+		return {
+			Program(node) {
+				fileImportsRecycler = hasImportFromModules(node, RECYCLABLE_LIST_PACKAGE_SOURCES);
+			},
+			JSXOpeningElement(node) {
+				if (!fileImportsRecycler) return;
+				const localElementName = resolveJsxElementName(node);
+				if (!localElementName) return;
+				const canonicalRecyclerName = resolveImportedRecyclerName(node, localElementName);
+				if (canonicalRecyclerName === null) return;
+				if (canonicalRecyclerName === "FlashList" && isFlashListV2OrNewer(context)) 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: `Your users see blank cells flash on fast scroll when <${localElementName}> has no \`estimatedItemSize\`.`
+				});
 			}
-		}
-		if (hasSizingHint) return;
-		if (dataIsEmptyLiteral) return;
-		if (!hasDataProp) return;
-		context.report({
-			node,
-			message: `Your users see blank cells flash on fast scroll when <${localElementName}> has no \`estimatedItemSize\`.`
-		});
-	} })
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-list-recyclable-without-types.ts
@@ -33641,25 +34036,34 @@ const rnListRecyclableWithoutTypes = defineRule({
 	requires: ["react-native"],
 	severity: "warn",
 	recommendation: "When rows have different shapes, reused cells can show the wrong layout. Add `getItemType={item => item.kind}` so FlashList keeps a separate pool per row type.",
-	create: (context) => ({ JSXOpeningElement(node) {
-		const elementName = resolveJsxElementName(node);
-		if (!elementName) return;
-		if (resolveImportedRecyclerName(node, elementName, { allowNamespaceMemberAccess: true }) === null) return;
-		let hasRecycleItemsEnabled = false;
-		let hasGetItemType = false;
-		for (const attr of node.attributes ?? []) {
-			if (!isNodeOfType(attr, "JSXAttribute")) continue;
-			if (!isNodeOfType(attr.name, "JSXIdentifier")) continue;
-			if (attr.name.name === "recycleItems") if (!attr.value) hasRecycleItemsEnabled = true;
-			else if (isNodeOfType(attr.value, "JSXExpressionContainer") && isNodeOfType(attr.value.expression, "Literal")) hasRecycleItemsEnabled = attr.value.expression.value === true;
-			else hasRecycleItemsEnabled = true;
-			if (attr.name.name === "getItemType") hasGetItemType = true;
-		}
-		if (hasRecycleItemsEnabled && !hasGetItemType) context.report({
-			node,
-			message: `Your users see rows of different shapes reuse the wrong cells when <${elementName} recycleItems> has no \`getItemType\`.`
-		});
-	} })
+	create: (context) => {
+		let fileImportsRecycler = false;
+		return {
+			Program(node) {
+				fileImportsRecycler = hasImportFromModules(node, RECYCLABLE_LIST_PACKAGE_SOURCES);
+			},
+			JSXOpeningElement(node) {
+				if (!fileImportsRecycler) return;
+				const elementName = resolveJsxElementName(node);
+				if (!elementName) return;
+				if (resolveImportedRecyclerName(node, elementName, { allowNamespaceMemberAccess: true }) === null) return;
+				let hasRecycleItemsEnabled = false;
+				let hasGetItemType = false;
+				for (const attr of node.attributes ?? []) {
+					if (!isNodeOfType(attr, "JSXAttribute")) continue;
+					if (!isNodeOfType(attr.name, "JSXIdentifier")) continue;
+					if (attr.name.name === "recycleItems") if (!attr.value) hasRecycleItemsEnabled = true;
+					else if (isNodeOfType(attr.value, "JSXExpressionContainer") && isNodeOfType(attr.value.expression, "Literal")) hasRecycleItemsEnabled = attr.value.expression.value === true;
+					else hasRecycleItemsEnabled = true;
+					if (attr.name.name === "getItemType") hasGetItemType = true;
+				}
+				if (hasRecycleItemsEnabled && !hasGetItemType) context.report({
+					node,
+					message: `Your users see rows of different shapes reuse the wrong cells when <${elementName} recycleItems> has no \`getItemType\`.`
+				});
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-no-deep-imports.ts
@@ -33800,7 +34204,7 @@ const rnNoDimensionsGet = defineRule({
 		if (binding !== null && !isBindingReactNativeDimensions(node, binding)) return;
 		if (isMemberProperty(node.callee, "get")) context.report({
 			node,
-			message: "Your users see a stale layout on rotation or resize because Dimensions.get() does not update."
+			message: "Dimensions.get() reads the size once and never updates, so layouts built from it go stale on rotation or resize."
 		});
 		if (isMemberProperty(node.callee, "addEventListener")) context.report({
 			node,
@@ -34622,7 +35026,10 @@ const isExpoUiComponentElement = (openingElement, contextNode, componentName) =>
 };
 //#endregion
 //#region src/plugin/rules/react-native/rn-no-raw-text.ts
-const truncateText = (text) => text.length > 30 ? `${text.slice(0, 30)}...` : text;
+const truncateText = (text) => {
+	const collapsedText = text.replace(/\s+/g, " ");
+	return collapsedText.length > 30 ? `${collapsedText.slice(0, 30)}...` : collapsedText;
+};
 const isRawTextContent = (child) => {
 	if (isNodeOfType(child, "JSXText")) return Boolean(child.value?.trim());
 	if (!isNodeOfType(child, "JSXExpressionContainer") || !child.expression) return false;
@@ -34643,9 +35050,10 @@ const resolveTextBoundaryName = (openingElement) => {
 	if (isNodeOfType(openingElement.name, "JSXNamespacedName")) return openingElement.name.namespace.name;
 	return resolveJsxElementName(openingElement);
 };
+const TEXT_COMPONENT_KEYWORDS = [...REACT_NATIVE_TEXT_COMPONENT_KEYWORDS];
 const isTextHandlingComponent = (elementName) => {
 	if (REACT_NATIVE_TEXT_COMPONENTS.has(elementName)) return true;
-	return [...REACT_NATIVE_TEXT_COMPONENT_KEYWORDS].some((keyword) => elementName.includes(keyword));
+	return TEXT_COMPONENT_KEYWORDS.some((keyword) => elementName.includes(keyword));
 };
 const isTransparentTextWrapper = (elementName) => elementName !== null && REACT_NATIVE_TEXT_TRANSPARENT_COMPONENTS.has(elementName);
 const isInsideTextHandlingComponent = (node) => {
@@ -34689,6 +35097,7 @@ const rnNoRawText = defineRule({
 		return {
 			Program(programNode) {
 				isDomComponentFile = hasDirective(programNode, "use dom");
+				if (!containsJsxElement(programNode)) return;
 				const childrenForwarding = collectTextWrapperComponents(programNode, isTextHandlingComponent, isNonTextHostName);
 				autoDetectedTextWrappers = childrenForwarding.textWrappers;
 				autoDetectedNonTextWrappers = childrenForwarding.nonTextWrappers;
@@ -38643,14 +39052,7 @@ const roleSupportsAriaProps = defineRule({
 	recommendation: "Only use `aria-*` attributes that the element's role supports.",
 	category: "Accessibility",
 	create: (context) => ({ JSXOpeningElement(node) {
-		const elementType = getElementType(node, context.settings);
-		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
-		const role = roleAttribute ? getJsxPropStringValue(roleAttribute) : getImplicitRole(node, elementType);
-		if (!role) return;
-		if (!VALID_ARIA_ROLES.has(role)) return;
-		const isImplicit = !roleAttribute;
-		const supported = ROLE_SUPPORTS_ARIA_PROPS[role];
-		if (!supported) return;
+		let ariaAttributes = null;
 		for (const attribute of node.attributes) {
 			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
 			const attributeNode = attribute;
@@ -38660,6 +39062,21 @@ const roleSupportsAriaProps = defineRule({
 			const propName = propRawName.toLowerCase();
 			if (!propName.startsWith("aria-")) continue;
 			if (!ARIA_PROPERTIES.has(propName)) continue;
+			(ariaAttributes ??= []).push({
+				attribute,
+				propName
+			});
+		}
+		if (!ariaAttributes) return;
+		const elementType = getElementType(node, context.settings);
+		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
+		const role = roleAttribute ? getJsxPropStringValue(roleAttribute) : getImplicitRole(node, elementType);
+		if (!role) return;
+		if (!VALID_ARIA_ROLES.has(role)) return;
+		const isImplicit = !roleAttribute;
+		const supported = ROLE_SUPPORTS_ARIA_PROPS[role];
+		if (!supported) return;
+		for (const { attribute, propName } of ariaAttributes) {
 			if (supported.has(propName)) continue;
 			context.report({
 				node: attribute,
@@ -38881,7 +39298,7 @@ const isInsideClassComponent = (node) => {
 const hasShortCircuitAncestor = (descendant, ancestor) => {
 	let current = descendant.parent;
 	while (current && current !== ancestor) {
-		if (isNodeOfType(current, "ConditionalExpression")) return true;
+		if (isNodeOfType(current, "ConditionalExpression") && (isWithinRange(descendant, current.consequent) || isWithinRange(descendant, current.alternate))) return true;
 		if (isNodeOfType(current, "LogicalExpression") && (current.operator === "&&" || current.operator === "||" || current.operator === "??") && isWithinRange(descendant, current.right)) return true;
 		current = current.parent ?? null;
 	}
@@ -39007,6 +39424,7 @@ const rulesOfHooks = defineRule({
 						if (parentInfo.isComponentOrHook) isInsideComponentOrHook = true;
 					}
 					if (!isInsideComponentOrHook) {
+						if (!enclosing.hasResolvedName) return;
 						if (isLocalNonHookFunctionCallee(node, context.scopes, settings)) return;
 						context.report({
 							node: node.callee,
@@ -39497,6 +39915,7 @@ const serverCacheWithObjectLiteral = defineRule({
 				cachedFunctionNames.add(node.id.name);
 			},
 			CallExpression(node) {
+				if (cachedFunctionNames.size === 0) return;
 				if (!isNodeOfType(node.callee, "Identifier")) return;
 				if (!cachedFunctionNames.has(node.callee.name)) return;
 				const firstArg = node.arguments?.[0];
@@ -39580,6 +39999,14 @@ const objectExpressionHasCachingConfig = (objectExpression) => (objectExpression
 const objectExpressionHasSpread = (objectExpression) => (objectExpression.properties ?? []).some((property) => isNodeOfType(property, "SpreadElement"));
 const APP_ROUTER_FILE_PATTERN = new RegExp(`/app/(?:[^/]+/)*(?:route|page|layout|template|loading|error|default)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
 const NON_PROJECT_PATH_PATTERN = /\/(?:node_modules|dist|build|\.next)\//;
+const REMIX_IMPORT_SOURCE_PATTERN = /^(?:@remix-run\/|@react-router\/|react-router(?:-dom)?$)/;
+const programImportsRemixRouter = (programNode) => (programNode.body ?? []).some((statement) => isNodeOfType(statement, "ImportDeclaration") && !isTypeOnlyImport(statement) && typeof statement.source?.value === "string" && REMIX_IMPORT_SOURCE_PATTERN.test(statement.source.value));
+const isImportMetaUrlAssetArgument = (urlArg) => {
+	if (!isNodeOfType(urlArg, "NewExpression")) return false;
+	if (!isNodeOfType(urlArg.callee, "Identifier") || urlArg.callee.name !== "URL") return false;
+	const baseArg = urlArg.arguments?.[1];
+	return isNodeOfType(baseArg, "MemberExpression") && isNodeOfType(baseArg.object, "MetaProperty") && isNodeOfType(baseArg.property, "Identifier") && baseArg.property.name === "url";
+};
 const serverFetchWithoutRevalidate = defineRule({
 	id: "server-fetch-without-revalidate",
 	title: "Fetch without revalidate",
@@ -39599,7 +40026,7 @@ const serverFetchWithoutRevalidate = defineRule({
 					isServerSideFile = false;
 					return;
 				}
-				isServerSideFile = !(node.body ?? []).some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === "use client");
+				isServerSideFile = !(node.body ?? []).some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === "use client") && !programImportsRemixRouter(node);
 			},
 			CallExpression(node) {
 				if (!isServerSideFile) return;
@@ -39612,6 +40039,7 @@ const serverFetchWithoutRevalidate = defineRule({
 					if (objectExpressionHasSpread(optionsArg)) return;
 				}
 				const urlArg = node.arguments?.[0];
+				if (isImportMetaUrlAssetArgument(urlArg)) return;
 				const urlText = isNodeOfType(urlArg, "Literal") && typeof urlArg.value === "string" ? `"${urlArg.value}"` : "url";
 				context.report({
 					node,
@@ -39840,7 +40268,7 @@ const serverNoMutableModuleState = defineRule({
 					if (node.kind === "let" || node.kind === "var") {
 						context.report({
 							node: declarator,
-							message: `Module-scoped ${node.kind} "${variableName}" leaks state between your users, since every request shares it.`
+							message: `Module-scoped ${node.kind} "${variableName}" is shared by every request, so any write to it leaks state between your users.`
 						});
 						continue;
 					}
@@ -39901,25 +40329,29 @@ const GATE_LEADING_VERBS = new Set([
 	"authorize",
 	"authenticate"
 ]);
-const isStartedPromiseBinding = (name, statements, beforeIndex) => {
-	for (let index = 0; index < beforeIndex; index++) {
-		const statement = statements[index];
-		if (!isNodeOfType(statement, "VariableDeclaration")) continue;
-		for (const declarator of statement.declarations ?? []) {
-			if (!isNodeOfType(declarator.id, "Identifier")) continue;
-			if (declarator.id.name !== name) continue;
-			if (declarator.init && !isNodeOfType(declarator.init, "AwaitExpression")) return true;
-		}
+const declarationAwaitsExistingPromise = (declaration) => {
+	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
+	for (const declarator of declaration.declarations ?? []) {
+		const init = declarator.init;
+		if (!isNodeOfType(init, "AwaitExpression")) continue;
+		const argument = init.argument;
+		if (isNodeOfType(argument, "Identifier") || isNodeOfType(argument, "MemberExpression")) return true;
 	}
 	return false;
 };
-const declarationAwaitsStartedPromise = (declaration, statements, declarationIndex) => {
+const REQUEST_SCOPED_IMPORT_SOURCES = ["next/headers", "next-intl/server"];
+const isRequestScopedCallee = (callee) => {
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	if (REQUEST_SCOPED_IMPORT_SOURCES.some((moduleSource) => getImportedNameFromModule(callee, callee.name, moduleSource) !== null)) return true;
+	return getImportedNameFromModule(callee, callee.name, "next/server") === "connection";
+};
+const declarationAwaitsRequestScopedCall = (declaration) => {
 	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
 	for (const declarator of declaration.declarations ?? []) {
 		const init = declarator.init;
 		if (!isNodeOfType(init, "AwaitExpression")) continue;
 		const argument = init.argument;
-		if (isNodeOfType(argument, "Identifier") && isStartedPromiseBinding(argument.name, statements, declarationIndex)) return true;
+		if (isNodeOfType(argument, "CallExpression") && isRequestScopedCallee(argument.callee)) return true;
 	}
 	return false;
 };
@@ -39954,7 +40386,8 @@ const serverSequentialIndependentAwait = defineRule({
 				if (!isNodeOfType(nextStatement, "VariableDeclaration")) continue;
 				if (!declarationStartsWithAwait(nextStatement)) continue;
 				if (declarationReadsAnyName(nextStatement, declaredNames)) continue;
-				if (declarationAwaitsStartedPromise(nextStatement, statements, statementIndex + 1)) continue;
+				if (declarationAwaitsExistingPromise(nextStatement)) continue;
+				if (declarationAwaitsRequestScopedCall(currentStatement) || declarationAwaitsRequestScopedCall(nextStatement)) continue;
 				if (declarationAwaitsGate(currentStatement)) continue;
 				context.report({
 					node: nextStatement,
@@ -40423,7 +40856,16 @@ const supabaseRlsPolicyRisk = defineRule({
 //#endregion
 //#region src/plugin/rules/security-scan/supabase-table-missing-rls.ts
 const CREATE_PUBLIC_TABLE_PATTERN = /create\s+(?:unlogged\s+)?table\s+(?:if\s+not\s+exists\s+)?(?!(?:auth|storage|realtime|vault|extensions|graphql|graphql_public|pgbouncer|net|supabase_functions|supabase_migrations|cron|pgsodium|pgmq|information_schema|pg_catalog|pg_temp|private|internal)\s*\.)(?:public\s*\.\s*)?["`]?([A-Za-z_][\w$]*)["`]?(?:\s*\(|\s+as\b)/gi;
-const enableRlsForTablePattern = (tableName) => new RegExp(`alter\\s+table\\s+(?:if\\s+exists\\s+)?(?:only\\s+)?(?:public\\s*\\.\\s*)?["\`]?${escapeRegExp(tableName)}["\`]?\\s+(?:force\\s+)?enable\\s+row\\s+level\\s+security`, "i");
+const ENABLE_RLS_PATTERN = /alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?(?:public\s*\.\s*)?["`]?([A-Za-z_][\w$]*)["`]?\s+(?:force\s+)?enable\s+row\s+level\s+security/gi;
+const collectLastEnableRlsIndexByTable = (content) => {
+	const lastEnableIndexByTable = /* @__PURE__ */ new Map();
+	for (const match of content.matchAll(ENABLE_RLS_PATTERN)) {
+		const tableName = match[1];
+		if (tableName === void 0) continue;
+		lastEnableIndexByTable.set(tableName.toLowerCase(), match.index);
+	}
+	return lastEnableIndexByTable;
+};
 const supabaseTableMissingRls = defineRule({
 	id: "supabase-table-missing-rls",
 	title: "Supabase table created without Row Level Security",
@@ -40434,11 +40876,13 @@ const supabaseTableMissingRls = defineRule({
 		const content = sanitizeSqlForScan(file.content);
 		if (!/create\s+(?:unlogged\s+)?table/i.test(content)) return [];
 		const findings = [];
+		const lastEnableIndexByTable = collectLastEnableRlsIndexByTable(content);
 		CREATE_PUBLIC_TABLE_PATTERN.lastIndex = 0;
 		for (let match = CREATE_PUBLIC_TABLE_PATTERN.exec(content); match !== null; match = CREATE_PUBLIC_TABLE_PATTERN.exec(content)) {
 			const tableName = match[1];
 			if (tableName === void 0) continue;
-			if (enableRlsForTablePattern(tableName).test(content.slice(match.index))) continue;
+			const lastEnableIndex = lastEnableIndexByTable.get(tableName.toLowerCase());
+			if (lastEnableIndex !== void 0 && lastEnableIndex >= match.index) continue;
 			const location = getLocationAtIndex(content, match.index);
 			findings.push({
 				message: "Supabase migration creates a public table but never enables Row Level Security, leaving every row exposed to the anon key.",
@@ -40714,6 +41158,7 @@ const tanstackStartMissingHeadContent = defineRule({
 	severity: "warn",
 	recommendation: "Add `<HeadContent />` inside `<head>` in your __root route. Without it, route `head()` meta tags are dropped.",
 	create: (context) => {
+		if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(context.filename ?? "")) return {};
 		let hasHeadContentElement = false;
 		let hasDocumentHeadElement = false;
 		let hasCustomHeadChildElement = false;
@@ -40750,8 +41195,6 @@ const tanstackStartMissingHeadContent = defineRule({
 		};
 		return {
 			Program(node) {
-				const filename = context.filename ?? "";
-				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
 				const statements = node.body ?? [];
 				for (const statement of statements) collectImportBindings(statement);
 				for (const statement of statements) {
@@ -40760,18 +41203,12 @@ const tanstackStartMissingHeadContent = defineRule({
 				}
 			},
 			ImportDeclaration(node) {
-				const filename = context.filename ?? "";
-				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
 				collectImportBindings(node);
 			},
 			VariableDeclarator(node) {
-				const filename = context.filename ?? "";
-				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
 				collectVariableAlias(node);
 			},
 			JSXOpeningElement(node) {
-				const filename = normalizeFilename(context.filename ?? "");
-				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier")) {
 					if (node.name.name === DOCUMENT_HEAD_ELEMENT_NAME) hasDocumentHeadElement = true;
 					if (headContentComponentNames.has(node.name.name)) hasHeadContentElement = true;
@@ -40785,8 +41222,6 @@ const tanstackStartMissingHeadContent = defineRule({
 				if (isInsideDocumentHeadElement(node) && isCustomJsxElementName(node.name)) hasCustomHeadChildElement = true;
 			},
 			"Program:exit"(programNode) {
-				const filename = normalizeFilename(context.filename ?? "");
-				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
 				if (hasDocumentHeadElement && !hasHeadContentElement && !hasCustomHeadChildElement) context.report({
 					node: programNode,
 					message: "Without <HeadContent /> in the __root route, your route head() meta tags never render."
@@ -40810,27 +41245,29 @@ const tanstackStartNoAnchorElement = defineRule({
 	requires: ["tanstack-start"],
 	severity: "warn",
 	recommendation: "Use `Link` from `@tanstack/react-router` so internal navigation keeps client state, preloading, and typed routes.",
-	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isInProjectDirectory(context, "routes")) return;
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
-		const attributes = node.attributes ?? [];
-		const hrefAttribute = findJsxAttribute(attributes, "href");
-		if (!hrefAttribute?.value) return;
-		let hrefValue = null;
-		if (isNodeOfType(hrefAttribute.value, "Literal")) hrefValue = hrefAttribute.value.value;
-		else if (isNodeOfType(hrefAttribute.value, "JSXExpressionContainer") && isNodeOfType(hrefAttribute.value.expression, "Literal")) hrefValue = hrefAttribute.value.expression.value;
-		if (typeof hrefValue !== "string" || !hrefValue.startsWith("/")) return;
-		if (hrefValue.startsWith("//")) return;
-		const pathname = hrefValue.split(/[?#]/)[0] ?? hrefValue;
-		if (pathname.startsWith("/api/")) return;
-		if (/\.[a-z0-9]{1,8}$/i.test(pathname)) return;
-		if (findJsxAttribute(attributes, "download")) return;
-		if (getAttributeStringValue(findJsxAttribute(attributes, "target")) === "_blank") return;
-		context.report({
-			node,
-			message: "Plain <a> reloads the whole page for internal navigation, so TanStack Router loses client state and preloading."
-		});
-	} })
+	create: (context) => {
+		if (!isInProjectDirectory(context, "routes")) return {};
+		return { JSXOpeningElement(node) {
+			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
+			const attributes = node.attributes ?? [];
+			const hrefAttribute = findJsxAttribute(attributes, "href");
+			if (!hrefAttribute?.value) return;
+			let hrefValue = null;
+			if (isNodeOfType(hrefAttribute.value, "Literal")) hrefValue = hrefAttribute.value.value;
+			else if (isNodeOfType(hrefAttribute.value, "JSXExpressionContainer") && isNodeOfType(hrefAttribute.value.expression, "Literal")) hrefValue = hrefAttribute.value.expression.value;
+			if (typeof hrefValue !== "string" || !hrefValue.startsWith("/")) return;
+			if (hrefValue.startsWith("//")) return;
+			const pathname = hrefValue.split(/[?#]/)[0] ?? hrefValue;
+			if (pathname.startsWith("/api/")) return;
+			if (/\.[a-z0-9]{1,8}$/i.test(pathname)) return;
+			if (findJsxAttribute(attributes, "download")) return;
+			if (getAttributeStringValue(findJsxAttribute(attributes, "target")) === "_blank") return;
+			context.report({
+				node,
+				message: "Plain <a> reloads the whole page for internal navigation, so TanStack Router loses client state and preloading."
+			});
+		} };
+	}
 });
 //#endregion
 //#region src/plugin/rules/tanstack-start/tanstack-start-no-direct-fetch-in-loader.ts
@@ -40894,7 +41331,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 	severity: "warn",
 	recommendation: "Use `throw redirect({ to: '/path' })` in `beforeLoad` or `loader`. navigate() during render causes hydration issues.",
 	create: (context) => {
-		const isRouteFile = isInProjectDirectory(context, "routes");
+		if (!isInProjectDirectory(context, "routes")) return {};
 		let deferredCallbackDepth = 0;
 		let eventHandlerDepth = 0;
 		const isDeferredHookCall = (node) => isHookCall$1(node, EFFECT_HOOK_NAMES$1) || isHookCall$1(node, "useCallback") || isHookCall$1(node, "useMemo");
@@ -40903,7 +41340,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 			if (!isNodeOfType(callParent, "CallExpression")) return false;
 			if (callParent.callee === functionNode) return false;
 			if (isNodeOfType(callParent.callee, "MemberExpression") && !callParent.callee.computed && isNodeOfType(callParent.callee.property, "Identifier") && PROMISE_CONTINUATION_METHODS.has(callParent.callee.property.name)) return true;
-			return isNodeOfType(callParent.callee, "Identifier") && HOOK_NAME_PATTERN.test(callParent.callee.name) && !RENDER_SYNCHRONOUS_HOOK_NAMES.has(callParent.callee.name) && callParent.arguments?.[0] === functionNode;
+			return isNodeOfType(callParent.callee, "Identifier") && HOOK_NAME_PATTERN$1.test(callParent.callee.name) && !RENDER_SYNCHRONOUS_HOOK_NAMES.has(callParent.callee.name) && callParent.arguments?.[0] === functionNode;
 		};
 		const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && REACT_HANDLER_PROP_PATTERN.test(node.name.name);
 		const isEventHandlerNamedProperty = (node) => isNodeOfType(node, "Property") && (isNodeOfType(node.key, "Identifier") && typeof node.key.name === "string" && REACT_HANDLER_PROP_PATTERN.test(node.key.name) || isNodeOfType(node.key, "Literal") && typeof node.key.value === "string" && REACT_HANDLER_PROP_PATTERN.test(node.key.value));
@@ -40931,11 +41368,11 @@ const tanstackStartNoNavigateInRender = defineRule({
 			if (isNodeOfType(parent, "ReturnStatement")) {
 				const outerFunction = findEnclosingFunction(parent);
 				const hookName = outerFunction ? getFunctionBindingName(outerFunction) : null;
-				return Boolean(hookName && HOOK_NAME_PATTERN.test(hookName));
+				return Boolean(hookName && HOOK_NAME_PATTERN$1.test(hookName));
 			}
 			if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === functionNode) {
 				const hookName = getFunctionBindingName(parent);
-				return Boolean(hookName && HOOK_NAME_PATTERN.test(hookName));
+				return Boolean(hookName && HOOK_NAME_PATTERN$1.test(hookName));
 			}
 			return false;
 		};
@@ -40958,7 +41395,6 @@ const tanstackStartNoNavigateInRender = defineRule({
 		};
 		return {
 			CallExpression(node) {
-				if (!isRouteFile) return;
 				if (isDeferredHookCall(node)) deferredCallbackDepth++;
 				if (deferredCallbackDepth > 0 || eventHandlerDepth > 0) return;
 				if (isNodeOfType(node.callee, "Identifier") && node.callee.name === "navigate" && (node.arguments?.length ?? 0) > 0) {
@@ -40970,39 +41406,30 @@ const tanstackStartNoNavigateInRender = defineRule({
 				}
 			},
 			"CallExpression:exit"(node) {
-				if (!isRouteFile) return;
 				if (isDeferredHookCall(node)) deferredCallbackDepth = Math.max(0, deferredCallbackDepth - 1);
 			},
 			JSXAttribute(node) {
-				if (!isRouteFile) return;
 				if (isEventHandlerAttribute(node)) eventHandlerDepth++;
 			},
 			"JSXAttribute:exit"(node) {
-				if (!isRouteFile) return;
 				if (isEventHandlerAttribute(node)) eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
 			},
 			Property(node) {
-				if (!isRouteFile) return;
 				if (isEventHandlerProperty(node)) eventHandlerDepth++;
 			},
 			"Property:exit"(node) {
-				if (!isRouteFile) return;
 				if (isEventHandlerProperty(node)) eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
 			},
 			VariableDeclarator(node) {
-				if (!isRouteFile) return;
 				if (isHandlerNamedVariableDeclarator(node)) eventHandlerDepth++;
 			},
 			"VariableDeclarator:exit"(node) {
-				if (!isRouteFile) return;
 				if (isHandlerNamedVariableDeclarator(node)) eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
 			},
 			FunctionDeclaration(node) {
-				if (!isRouteFile) return;
 				if (isHandlerNamedFunctionDeclaration(node)) eventHandlerDepth++;
 			},
 			"FunctionDeclaration:exit"(node) {
-				if (!isRouteFile) return;
 				if (isHandlerNamedFunctionDeclaration(node)) eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
 			}
 		};
@@ -41086,23 +41513,25 @@ const tanstackStartNoUseEffectFetch = defineRule({
 	requires: ["tanstack-start"],
 	severity: "warn",
 	recommendation: "Fetch data in the route `loader` instead. The router loads it before rendering and avoids waterfalls.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isInProjectDirectory(context, "routes")) return;
-		if (!isHookCall$1(node, EFFECT_HOOK_NAMES$1)) return;
-		const callback = node.arguments?.[0];
-		if (!callback) return;
-		let hasFetchCall = false;
-		const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
-		walkAst(callback, (child) => {
-			if (hasFetchCall) return false;
-			if (child !== callback && isFunctionLike$1(child) && !effectInvokedFunctions.has(child)) return false;
-			if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === "fetch") hasFetchCall = true;
-		});
-		if (hasFetchCall) context.report({
-			node,
-			message: "fetch() inside useEffect makes your users wait through a loading spinner after render."
-		});
-	} })
+	create: (context) => {
+		if (!isInProjectDirectory(context, "routes")) return {};
+		return { CallExpression(node) {
+			if (!isHookCall$1(node, EFFECT_HOOK_NAMES$1)) return;
+			const callback = node.arguments?.[0];
+			if (!callback) return;
+			let hasFetchCall = false;
+			const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
+			walkAst(callback, (child) => {
+				if (hasFetchCall) return false;
+				if (child !== callback && isFunctionLike$1(child) && !effectInvokedFunctions.has(child)) return false;
+				if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === "fetch") hasFetchCall = true;
+			});
+			if (hasFetchCall) context.report({
+				node,
+				message: "fetch() inside useEffect makes your users wait through a loading spinner after render."
+			});
+		} };
+	}
 });
 //#endregion
 //#region src/plugin/rules/tanstack-start/tanstack-start-redirect-in-try-catch.ts
@@ -41143,10 +41572,10 @@ const tanstackStartRoutePropertyOrder = defineRule({
 			const propertyName = getPropertyKeyName(property);
 			if (propertyName !== null) orderedPropertyNames.push(propertyName);
 		}
-		const sensitiveProperties = orderedPropertyNames.filter((propertyName) => TANSTACK_ROUTE_PROPERTY_ORDER.includes(propertyName));
+		const sensitiveProperties = orderedPropertyNames.filter((propertyName) => TANSTACK_ROUTE_PROPERTY_INDEX.has(propertyName));
 		let lastIndex = -1;
 		for (const propertyName of sensitiveProperties) {
-			const currentIndex = TANSTACK_ROUTE_PROPERTY_ORDER.indexOf(propertyName);
+			const currentIndex = TANSTACK_ROUTE_PROPERTY_INDEX.get(propertyName) ?? -1;
 			if (currentIndex < lastIndex) {
 				const expectedBefore = TANSTACK_ROUTE_PROPERTY_ORDER[lastIndex];
 				context.report({
@@ -41183,10 +41612,10 @@ const tanstackStartServerFnMethodOrder = defineRule({
 		} else return;
 		const ownMethodName = isNodeOfType(node.callee.property, "Identifier") ? node.callee.property.name : null;
 		if (methodNames[methodNames.length - 1] !== ownMethodName) return;
-		const orderSensitiveMethods = methodNames.filter((name) => TANSTACK_MIDDLEWARE_METHOD_ORDER.includes(toMethodOrderToken(name)));
+		const orderSensitiveMethods = methodNames.filter((name) => TANSTACK_MIDDLEWARE_METHOD_INDEX.has(toMethodOrderToken(name)));
 		let lastIndex = -1;
 		for (const methodName of orderSensitiveMethods) {
-			const currentIndex = TANSTACK_MIDDLEWARE_METHOD_ORDER.indexOf(toMethodOrderToken(methodName));
+			const currentIndex = TANSTACK_MIDDLEWARE_METHOD_INDEX.get(toMethodOrderToken(methodName)) ?? -1;
 			if (currentIndex < lastIndex) {
 				const expectedBefore = TANSTACK_MIDDLEWARE_METHOD_ORDER[lastIndex];
 				context.report({
@@ -41470,13 +41899,21 @@ const webhookSignatureRisk = defineRule({
 //#endregion
 //#region src/plugin/rules/zod/utils/zod-ast.ts
 const ZOD_MODULE = "zod";
+const ZOD_MODULE_SOURCES = [ZOD_MODULE];
 const getStaticPropertyName = (member) => {
 	const property = member.property;
 	if (!member.computed && isNodeOfType(property, "Identifier")) return property.name;
 	if (member.computed && isNodeOfType(property, "Literal") && typeof property.value === "string") return property.value;
 	return null;
 };
+const importInfoCache = /* @__PURE__ */ new WeakMap();
 const getImportInfoForIdentifier = (identifier) => {
+	if (importInfoCache.has(identifier)) return importInfoCache.get(identifier) ?? null;
+	const importInfo = computeImportInfoForIdentifier(identifier);
+	importInfoCache.set(identifier, importInfo);
+	return importInfo;
+};
+const computeImportInfoForIdentifier = (identifier) => {
 	const specifier = findVariableInitializer(identifier, identifier.name)?.initializer;
 	if (!specifier) return null;
 	const declaration = specifier.parent;
@@ -41613,25 +42050,33 @@ const zodV4NoDeprecatedErrorApis = defineRule({
 	tags: ["migration-hint"],
 	severity: "warn",
 	recommendation: "Use the Zod 4 helpers instead: `z.treeifyError()`, `z.flattenError()`, `z.prettifyError()`, or read `error.issues` directly.",
-	create: (context) => ({
-		CallExpression(node) {
-			if (isZodErrorCreateCall(node) && isReceiverOfDeprecatedZodErrorMember(node)) return;
-			if (!isZodErrorCreateCall(node) && !isDeprecatedZodErrorMemberAccess(node.callee)) return;
-			context.report({
-				node,
-				message: ZOD_ERROR_API_MESSAGE
-			});
-		},
-		MemberExpression(node) {
-			const parent = node.parent;
-			if (parent && isNodeOfType(parent, "CallExpression") && stripParenExpression(parent.callee) === node) return;
-			if (!isDeprecatedZodErrorMemberAccess(node)) return;
-			context.report({
-				node,
-				message: ZOD_ERROR_API_MESSAGE
-			});
-		}
-	})
+	create: (context) => {
+		let fileImportsZod = false;
+		return {
+			Program(node) {
+				fileImportsZod = hasImportFromModules(node, ZOD_MODULE_SOURCES);
+			},
+			CallExpression(node) {
+				if (!fileImportsZod) return;
+				if (isZodErrorCreateCall(node) && isReceiverOfDeprecatedZodErrorMember(node)) return;
+				if (!isZodErrorCreateCall(node) && !isDeprecatedZodErrorMemberAccess(node.callee)) return;
+				context.report({
+					node,
+					message: ZOD_ERROR_API_MESSAGE
+				});
+			},
+			MemberExpression(node) {
+				if (!fileImportsZod) return;
+				const parent = node.parent;
+				if (parent && isNodeOfType(parent, "CallExpression") && stripParenExpression(parent.callee) === node) return;
+				if (!isDeprecatedZodErrorMemberAccess(node)) return;
+				context.report({
+					node,
+					message: ZOD_ERROR_API_MESSAGE
+				});
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rules/zod/zod-v4-no-deprecated-error-customization.ts
@@ -41823,16 +42268,24 @@ const zodV4NoDeprecatedSchemaApis = defineRule({
 	tags: ["migration-hint"],
 	severity: "warn",
 	recommendation: "Switch to the Zod 4 versions: top-level factories like `z.enum()`, object helpers like `z.strictObject()`, the new `z.function({ input, output })` form, and explicit key/value schemas for `z.record()`.",
-	create: (context) => ({
-		CallExpression(node) {
-			if (isCallToDeprecatedTopLevelFactory(node) || isCallToDroppedCreateFactory(node) || isSingleArgumentRecordCall(node) || isLiteralSymbolCall(node) || isDeprecatedFunctionChainCall(node) || isDirectMethodCallOnZodFactory(node, OBJECT_FACTORY, OBJECT_METHODS) || isDirectMethodCallOnZodFactory(node, NUMBER_FACTORY, NUMBER_METHODS) || isRefineSecondArgumentFunction(node)) reportSchemaMigration(context, node);
-		},
-		MemberExpression(node) {
-			const parent = node.parent;
-			if (parent && isNodeOfType(parent, "CallExpression") && stripParenExpression(parent.callee) === node) return;
-			if (isDroppedEnumAliasAccess(node) || isZodNamespaceImportMemberCreate(node)) reportSchemaMigration(context, node);
-		}
-	})
+	create: (context) => {
+		let fileImportsZod = false;
+		return {
+			Program(node) {
+				fileImportsZod = hasImportFromModules(node, ZOD_MODULE_SOURCES);
+			},
+			CallExpression(node) {
+				if (!fileImportsZod) return;
+				if (isCallToDeprecatedTopLevelFactory(node) || isCallToDroppedCreateFactory(node) || isSingleArgumentRecordCall(node) || isLiteralSymbolCall(node) || isDeprecatedFunctionChainCall(node) || isDirectMethodCallOnZodFactory(node, OBJECT_FACTORY, OBJECT_METHODS) || isDirectMethodCallOnZodFactory(node, NUMBER_FACTORY, NUMBER_METHODS) || isRefineSecondArgumentFunction(node)) reportSchemaMigration(context, node);
+			},
+			MemberExpression(node) {
+				if (!fileImportsZod) return;
+				const parent = node.parent;
+				if (parent && isNodeOfType(parent, "CallExpression") && stripParenExpression(parent.callee) === node) return;
+				if (isDroppedEnumAliasAccess(node) || isZodNamespaceImportMemberCreate(node)) reportSchemaMigration(context, node);
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rules/zod/zod-v4-prefer-top-level-string-formats.ts
@@ -41867,13 +42320,22 @@ const zodV4PreferTopLevelStringFormats = defineRule({
 	tags: ["migration-hint"],
 	severity: "warn",
 	recommendation: "Use the Zod 4 top-level format checks like `z.email()`, `z.uuid()`, or `z.ipv4()` instead of `z.string().<format>()`.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isDirectMethodCallOnZodFactory(node, ZOD_STRING_FACTORY, STRING_FORMAT_METHODS)) return;
-		context.report({
-			node,
-			message: "This `z.string().<format>()` check is deprecated in Zod 4, so it can break during the upgrade."
-		});
-	} })
+	create: (context) => {
+		let fileImportsZod = false;
+		return {
+			Program(node) {
+				fileImportsZod = hasImportFromModules(node, ZOD_MODULE_SOURCES);
+			},
+			CallExpression(node) {
+				if (!fileImportsZod) return;
+				if (!isDirectMethodCallOnZodFactory(node, ZOD_STRING_FACTORY, STRING_FORMAT_METHODS)) return;
+				context.report({
+					node,
+					message: "This `z.string().<format>()` check is deprecated in Zod 4, so it can break during the upgrade."
+				});
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rule-registry.ts
@@ -46841,23 +47303,29 @@ const FALLBACK_CFG = {
 	enclosingFunction: () => null,
 	isUnconditionalFromEntry: () => false
 };
+const scopesByProgram = /* @__PURE__ */ new WeakMap();
+const cfgByProgram = /* @__PURE__ */ new WeakMap();
 const wrapWithSemanticContext = (rule) => ({
 	...rule,
 	create: (baseContext) => {
 		let programRoot = null;
-		let cachedScopes = null;
-		let cachedCfg = null;
 		const getScopes = () => {
-			if (cachedScopes) return cachedScopes;
 			if (!programRoot) return buildFallbackScopes();
-			cachedScopes = analyzeScopes(programRoot);
-			return cachedScopes;
+			let scopes = scopesByProgram.get(programRoot);
+			if (!scopes) {
+				scopes = analyzeScopes(programRoot);
+				scopesByProgram.set(programRoot, scopes);
+			}
+			return scopes;
 		};
 		const getCfg = () => {
-			if (cachedCfg) return cachedCfg;
 			if (!programRoot) return FALLBACK_CFG;
-			cachedCfg = analyzeControlFlow(programRoot);
-			return cachedCfg;
+			let cfg = cfgByProgram.get(programRoot);
+			if (!cfg) {
+				cfg = analyzeControlFlow(programRoot);
+				cfgByProgram.set(programRoot, cfg);
+			}
+			return cfg;
 		};
 		const enrichedContext = {
 			report: baseContext.report,
@@ -46872,23 +47340,18 @@ const wrapWithSemanticContext = (rule) => ({
 				return getCfg();
 			}
 		};
-		const captureRootIfNeeded = (node) => {
-			if (programRoot) return;
-			programRoot = findProgramRoot(node);
-		};
 		const visitors = rule.create(enrichedContext);
-		const wrappedVisitors = {};
+		const passthroughVisitors = {};
 		for (const [nodeType, handler] of Object.entries(visitors)) {
 			if (typeof handler !== "function") continue;
-			wrappedVisitors[nodeType] = ((node) => {
-				captureRootIfNeeded(node);
-				handler(node);
-			});
+			passthroughVisitors[nodeType] = handler;
 		}
-		if (!visitors.Program) wrappedVisitors.Program = (node) => {
-			captureRootIfNeeded(node);
-		};
-		return wrappedVisitors;
+		const innerProgramHandler = passthroughVisitors.Program;
+		passthroughVisitors.Program = ((node) => {
+			programRoot = node;
+			if (innerProgramHandler) innerProgramHandler(node);
+		});
+		return passthroughVisitors;
 	}
 });
 //#endregion