oxlint-plugin-react-doctor 0.7.6-dev.4fb3694 → 0.7.6-dev.543ebfe

package/dist/index.js

@@ -1180,8 +1180,8 @@ const stripParenExpression = (node) => {
 	return current;
 };
 //#endregion
-//#region src/plugin/utils/get-root-identifier-name.ts
-const getRootIdentifierName = (node, options) => {
+//#region src/plugin/utils/get-root-identifier.ts
+const getRootIdentifier$1 = (node, options) => {
 	if (!node) return null;
 	const followCallChains = options?.followCallChains === true;
 	let cursor = node;
@@ -1192,16 +1192,18 @@ const getRootIdentifierName = (node, options) => {
 			continue;
 		}
 		if (followCallChains && isNodeOfType(cursor, "CallExpression")) {
-			const callee = cursor.callee;
-			if (!isNodeOfType(callee, "MemberExpression")) return null;
-			cursor = callee.object;
+			if (!isNodeOfType(cursor.callee, "MemberExpression")) return null;
+			cursor = cursor.callee.object;
 			continue;
 		}
 		break;
 	}
-	return isNodeOfType(cursor, "Identifier") ? cursor.name : null;
+	return isNodeOfType(cursor, "Identifier") ? cursor : null;
 };
 //#endregion
+//#region src/plugin/utils/get-root-identifier-name.ts
+const getRootIdentifierName = (node, options) => getRootIdentifier$1(node, options)?.name ?? null;
+//#endregion
 //#region src/plugin/rules/state-and-effects/advanced-event-handler-refs.ts
 const STABLE_HANDLER_HOOK_NAMES = new Set([
 	"useCallback",
@@ -5962,7 +5964,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 //#endregion
 //#region src/plugin/utils/get-static-property-key-name.ts
 const getStaticPropertyKeyName = (node, options = {}) => {
-	if (!isNodeOfType(node, "Property")) return null;
+	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition")) return null;
 	if (node.computed) {
 		if (options.allowComputedString && isNodeOfType(node.key, "Literal") && typeof node.key.value === "string") return node.key.value;
 		return null;
@@ -6021,7 +6023,7 @@ const isPureEventBlockerHandler = (attribute) => {
 //#endregion
 //#region src/plugin/utils/resolve-const-identifier-alias.ts
 const resolveConstIdentifierAlias = (identifier, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return null;
+	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
 	const visitedSymbolIds = /* @__PURE__ */ new Set();
 	let symbol = scopes.symbolFor(identifier);
 	while (symbol?.kind === "const") {
@@ -6296,6 +6298,131 @@ const isGlobalMethodCall = (node, objectName, methodName) => {
 	return isNodeOfType(receiver, "Identifier") && receiver.name === objectName && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
 };
 //#endregion
+//#region src/plugin/utils/collect-safely-validated-local-storage-keys.ts
+const isLocalStorageCall = (node, methodName) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === "localStorage" && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
+};
+const catchReturnsFallback = (tryStatement) => {
+	const handler = tryStatement.handler;
+	if (!handler) return false;
+	let hasReturn = false;
+	let hasThrow = false;
+	walkAst(handler.body, (child) => {
+		if (isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "ReturnStatement")) hasReturn = true;
+		if (isNodeOfType(child, "ThrowStatement")) hasThrow = true;
+	});
+	return hasReturn && !hasThrow;
+};
+const resolveValidatorFunction = (callee, scopes) => {
+	const unwrappedCallee = stripParenExpression(callee);
+	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
+	const symbol = scopes.symbolFor(unwrappedCallee);
+	if (!symbol) return null;
+	const candidate = symbol.kind === "function" ? symbol.declarationNode : symbol.initializer;
+	return isFunctionLike$1(candidate) ? candidate : null;
+};
+const validatorChecksPayloadProperties = (validatorFunction, scopes) => {
+	if (!isFunctionLike$1(validatorFunction)) return false;
+	const firstParameter = validatorFunction.params?.[0];
+	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
+	const parameterSymbol = scopes.symbolFor(firstParameter);
+	if (!parameterSymbol) return false;
+	const payloadSymbolIds = new Set([parameterSymbol.id]);
+	let hasPropertyTypeCheck = false;
+	walkAst(validatorFunction.body, (child) => {
+		if (isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.init) {
+			const initializer = stripParenExpression(child.init);
+			if (isNodeOfType(initializer, "Identifier")) {
+				const initializerSymbol = scopes.symbolFor(initializer);
+				if (initializerSymbol && payloadSymbolIds.has(initializerSymbol.id)) {
+					const aliasSymbol = scopes.symbolFor(child.id);
+					if (aliasSymbol) payloadSymbolIds.add(aliasSymbol.id);
+				}
+			}
+		}
+		if (!isNodeOfType(child, "UnaryExpression") || child.operator !== "typeof") return;
+		const checkedValue = stripParenExpression(child.argument);
+		if (!isNodeOfType(checkedValue, "MemberExpression")) return;
+		const receiver = stripParenExpression(checkedValue.object);
+		if (!isNodeOfType(receiver, "Identifier")) return;
+		const receiverSymbol = scopes.symbolFor(receiver);
+		if (receiverSymbol && payloadSymbolIds.has(receiverSymbol.id)) hasPropertyTypeCheck = true;
+	});
+	return hasPropertyTypeCheck;
+};
+const incrementCount = (counts, keyValue) => {
+	counts.set(keyValue, (counts.get(keyValue) ?? 0) + 1);
+};
+const isReturnedExpression = (expression) => {
+	const parent = expression.parent;
+	return Boolean(parent && isNodeOfType(parent, "ReturnStatement") && parent.argument === expression);
+};
+const collectSafelyValidatedLocalStorageKeys = ({ programNode, scopes, resolveKey }) => {
+	const readCountsByKey = /* @__PURE__ */ new Map();
+	const safeReadCountsByKey = /* @__PURE__ */ new Map();
+	const safeReadSymbolIds = /* @__PURE__ */ new Set();
+	walkAst(programNode, (child) => {
+		if (!isNodeOfType(child, "CallExpression") || !isLocalStorageCall(child, "getItem")) return;
+		const keyArgument = child.arguments?.[0];
+		if (!keyArgument) return;
+		const keyValue = resolveKey(keyArgument);
+		if (keyValue !== null) incrementCount(readCountsByKey, keyValue);
+	});
+	walkAst(programNode, (child) => {
+		if (!isNodeOfType(child, "TryStatement") || !catchReturnsFallback(child)) return;
+		const rawValueKeys = /* @__PURE__ */ new Map();
+		const parsedValueSources = /* @__PURE__ */ new Map();
+		walkAst(child.block, (tryChild) => {
+			if (isFunctionLike$1(tryChild)) return false;
+			if (isNodeOfType(tryChild, "VariableDeclarator") && isNodeOfType(tryChild.id, "Identifier") && tryChild.init) {
+				const initializer = stripParenExpression(tryChild.init);
+				if (isNodeOfType(initializer, "CallExpression") && isLocalStorageCall(initializer, "getItem")) {
+					const keyArgument = initializer.arguments?.[0];
+					const bindingSymbol = scopes.symbolFor(tryChild.id);
+					if (keyArgument && bindingSymbol) {
+						const keyValue = resolveKey(keyArgument);
+						if (keyValue !== null) rawValueKeys.set(bindingSymbol.id, keyValue);
+					}
+				}
+				if (isNodeOfType(initializer, "CallExpression") && isGlobalMethodCall(initializer, "JSON", "parse")) {
+					const rawValueArgument = initializer.arguments?.[0];
+					const parsedValueSymbol = scopes.symbolFor(tryChild.id);
+					if (rawValueArgument && isNodeOfType(rawValueArgument, "Identifier") && parsedValueSymbol) {
+						const rawValueSymbol = scopes.symbolFor(rawValueArgument);
+						if (rawValueSymbol && rawValueKeys.has(rawValueSymbol.id)) parsedValueSources.set(parsedValueSymbol.id, rawValueSymbol.id);
+					}
+				}
+			}
+			if (!isNodeOfType(tryChild, "ConditionalExpression") || !isReturnedExpression(tryChild)) return;
+			const test = stripParenExpression(tryChild.test);
+			if (!isNodeOfType(test, "CallExpression")) return;
+			const testedValue = test.arguments?.[0];
+			if (!testedValue || !isNodeOfType(testedValue, "Identifier")) return;
+			const parsedValueSymbol = scopes.symbolFor(testedValue);
+			if (!parsedValueSymbol) return;
+			const rawValueSymbolId = parsedValueSources.get(parsedValueSymbol.id);
+			if (rawValueSymbolId === void 0) return;
+			const returnedValue = stripParenExpression(tryChild.consequent);
+			if (!isNodeOfType(returnedValue, "Identifier") || scopes.symbolFor(returnedValue)?.id !== parsedValueSymbol.id) return;
+			const validatorFunction = resolveValidatorFunction(test.callee, scopes);
+			if (!validatorFunction || !validatorChecksPayloadProperties(validatorFunction, scopes)) return;
+			const keyValue = rawValueKeys.get(rawValueSymbolId);
+			if (keyValue === void 0 || safeReadSymbolIds.has(rawValueSymbolId)) return;
+			safeReadSymbolIds.add(rawValueSymbolId);
+			incrementCount(safeReadCountsByKey, keyValue);
+		});
+	});
+	const safeKeys = /* @__PURE__ */ new Set();
+	for (const [keyValue, readCount] of readCountsByKey) if (safeReadCountsByKey.get(keyValue) === readCount) safeKeys.add(keyValue);
+	return safeKeys;
+};
+//#endregion
 //#region src/plugin/rules/client/client-localstorage-no-version.ts
 const VERSIONED_KEY_PATTERN = /(?:[._:-]v\d+|@\d+|\bv\d+\b)/i;
 const CAMEL_CASE_VERSIONED_KEY_PATTERN = /[a-z]V\d+/;
@@ -6317,26 +6444,39 @@ const clientLocalstorageNoVersion = defineRule({
 	severity: "warn",
 	category: "Correctness",
 	recommendation: "Put a version in the storage key (e.g. \"myKey:v1\"). If you change the data shape later, old saved data can be ignored instead of crashing the app.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isNodeOfType(node.callee, "MemberExpression")) return;
-		const receiver = stripParenExpression(node.callee.object);
-		if (!isNodeOfType(receiver, "Identifier")) return;
-		if (receiver.name !== "localStorage") return;
-		if (!isNodeOfType(node.callee.property, "Identifier")) return;
-		if (node.callee.property.name !== "setItem") return;
-		const keyArg = node.arguments?.[0];
-		if (!keyArg) return;
-		const keyValue = resolveStringKey(keyArg, context);
-		if (keyValue === null) return;
-		if (isVersionedKey(keyValue)) return;
-		const valueArg = node.arguments?.[1];
-		if (!valueArg) return;
-		if (!isJsonStringifyCall(valueArg)) return;
-		context.report({
-			node: keyArg,
-			message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
-		});
-	} })
+	create: (context) => {
+		let safelyValidatedStorageKeys = /* @__PURE__ */ new Set();
+		return {
+			Program(node) {
+				safelyValidatedStorageKeys = collectSafelyValidatedLocalStorageKeys({
+					programNode: node,
+					scopes: context.scopes,
+					resolveKey: (keyNode) => resolveStringKey(keyNode, context)
+				});
+			},
+			CallExpression(node) {
+				if (!isNodeOfType(node.callee, "MemberExpression")) return;
+				const receiver = stripParenExpression(node.callee.object);
+				if (!isNodeOfType(receiver, "Identifier")) return;
+				if (receiver.name !== "localStorage") return;
+				if (!isNodeOfType(node.callee.property, "Identifier")) return;
+				if (node.callee.property.name !== "setItem") return;
+				const keyArg = node.arguments?.[0];
+				if (!keyArg) return;
+				const keyValue = resolveStringKey(keyArg, context);
+				if (keyValue === null) return;
+				if (isVersionedKey(keyValue)) return;
+				if (safelyValidatedStorageKeys.has(keyValue)) return;
+				const valueArg = node.arguments?.[1];
+				if (!valueArg) return;
+				if (!isJsonStringifyCall(valueArg)) return;
+				context.report({
+					node: keyArg,
+					message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
+				});
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rules/client/client-passive-event-listeners.ts
@@ -15972,14 +16112,21 @@ const jsxFilenameExtension = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/is-jsx-fragment-element.ts
-const isJsxFragmentElement = (node) => {
+const isJsxFragmentElement = (node, scopes) => {
 	if (!isNodeOfType(node, "JSXOpeningElement")) return false;
 	const elementName = node.name;
-	if (isNodeOfType(elementName, "JSXIdentifier")) return elementName.name === "Fragment";
+	if (isNodeOfType(elementName, "JSXIdentifier")) {
+		if (!scopes) return elementName.name === "Fragment";
+		const symbol = resolveConstIdentifierAlias(elementName, scopes);
+		if (!symbol) return elementName.name === "Fragment" && scopes.isGlobalReference(elementName);
+		return isImportedFromReact(symbol) && getImportedName(symbol.declarationNode) === "Fragment";
+	}
 	if (isNodeOfType(elementName, "JSXMemberExpression")) {
 		if (!isNodeOfType(elementName.object, "JSXIdentifier")) return false;
-		if (elementName.object.name !== "React") return false;
-		return elementName.property.name === "Fragment";
+		if (elementName.property.name !== "Fragment") return false;
+		if (!scopes) return elementName.object.name === "React";
+		if (isReactNamespaceImport(elementName.object, scopes)) return true;
+		return elementName.object.name === "React" && scopes.isGlobalReference(elementName.object);
 	}
 	return false;
 };
@@ -16005,7 +16152,7 @@ const jsxFragments = defineRule({
 				if (mode !== "syntax") return;
 				if (!node.closingElement) return;
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement)) return;
+				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
 				if (openingElement.attributes.length > 0) return;
 				context.report({
 					node: openingElement,
@@ -19146,7 +19293,7 @@ const jsxNoUselessFragment = defineRule({
 		return {
 			JSXElement(node) {
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement)) return;
+				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
 				if (hasJsxKeyAttribute(openingElement)) return;
 				if (checkChildren(node, openingElement, node.children)) return;
 				if (isChildOfHtmlElement(node)) context.report({
@@ -20388,8 +20535,24 @@ const hasDirective = (programNode, directive) => {
 	return Boolean(programNode.body?.some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === directive));
 };
 //#endregion
-//#region src/plugin/utils/is-component-assignment.ts
-const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
+//#region src/plugin/utils/unwrap-object-integrity-expression.ts
+const OBJECT_INTEGRITY_METHOD_NAMES = new Set([
+	"freeze",
+	"seal",
+	"preventExtensions"
+]);
+const OBJECT_FREEZE_OR_SEAL_METHOD_NAMES = new Set(["freeze", "seal"]);
+const unwrapObjectIntegrityExpression = (node, scopes, methodNames = OBJECT_INTEGRITY_METHOD_NAMES) => {
+	let expression = stripParenExpression(node);
+	while (isNodeOfType(expression, "CallExpression")) {
+		const callee = stripParenExpression(expression.callee);
+		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || callee.object.name !== "Object" || !scopes.isGlobalReference(callee.object) || !isNodeOfType(callee.property, "Identifier") || !methodNames.has(callee.property.name)) break;
+		const wrappedExpression = expression.arguments[0];
+		if (!wrappedExpression || isNodeOfType(wrappedExpression, "SpreadElement")) break;
+		expression = stripParenExpression(wrappedExpression);
+	}
+	return expression;
+};
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-async-client-component.ts
 const nextjsAsyncClientComponent = defineRule({
@@ -20415,10 +20578,10 @@ const nextjsAsyncClientComponent = defineRule({
 			},
 			VariableDeclarator(node) {
 				if (!fileHasUseClient) return;
-				if (!isComponentAssignment(node)) return;
-				if (!isInlineFunctionExpression(node.init)) return;
-				if (!node.init.async) return;
 				if (!isNodeOfType(node.id, "Identifier")) return;
+				if (!isUppercaseName(node.id.name) || !node.init) return;
+				const componentFunction = unwrapObjectIntegrityExpression(node.init, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES);
+				if (!isInlineFunctionExpression(componentFunction) || !componentFunction.async) return;
 				context.report({
 					node,
 					message: `Async client component "${node.id.name}" fails to render because client components can't be async.`
@@ -26154,6 +26317,9 @@ const functionContainsReactRenderOutput = (functionNode, scopes) => {
 	return hasRenderOutput;
 };
 //#endregion
+//#region src/plugin/utils/is-component-assignment.ts
+const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
+//#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);
 //#endregion
@@ -31795,6 +31961,26 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/react-ref-origin.ts
+const resolveReactRefSymbol = (memberExpression, scopes) => {
+	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
+	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticPropertyName(memberExpression) !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(receiver, scopes);
+	if (!symbol?.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	if (!isNodeOfType(initializer, "CallExpression")) return null;
+	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
+};
+const hasReactRefCurrentOrigin = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (resolveReactRefSymbol(expression, scopes)) return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = resolveConstIdentifierAlias(expression, scopes);
+	if (!symbol?.initializer || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return hasReactRefCurrentOrigin(symbol.initializer, scopes, visitedSymbolIds);
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-impure-state-updater.ts
 const TIMER_FUNCTION_NAMES = new Set([
 	"cancelAnimationFrame",
@@ -31826,6 +32012,33 @@ const NOTIFICATION_METHOD_NAMES = new Set([
 	"success",
 	"warning"
 ]);
+const NOTIFICATION_MODULE_SOURCES = new Set([
+	"@chakra-ui/react",
+	"@heroui/react",
+	"@mantine/notifications",
+	"antd",
+	"react-hot-toast",
+	"react-toastify",
+	"sonner"
+]);
+const SYNCHRONOUS_ARRAY_METHOD_NAMES = new Set([
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"flatMap",
+	"forEach",
+	"map",
+	"reduce",
+	"reduceRight",
+	"some",
+	"sort"
+]);
+const isNotificationModuleSource = (source) => {
+	if (!source) return false;
+	for (const moduleSource of NOTIFICATION_MODULE_SOURCES) if (source === moduleSource || source.startsWith(`${moduleSource}/`)) return true;
+	return /(?:^|[/_.-])(?:notification|toast)s?(?:$|[/_.-])/i.test(source);
+};
 const getMemberCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	if (!isNodeOfType(node.callee, "MemberExpression") || node.callee.computed) return null;
@@ -31837,27 +32050,37 @@ const getMemberCall = (node) => {
 };
 const isNotificationReceiver = (receiver, scopes) => {
 	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (!NOTIFICATION_RECEIVER_NAMES.has(receiver.name)) return false;
+	const importBinding = getImportBindingForName(receiver, receiver.name);
+	if (importBinding) return isNotificationModuleSource(importBinding.source) && (importBinding.exportedName === "default" || importBinding.exportedName !== null && NOTIFICATION_RECEIVER_NAMES.has(importBinding.exportedName));
 	const symbol = scopes.symbolFor(receiver);
-	if (symbol?.kind === "import") return true;
 	if (!isNodeOfType(symbol?.initializer, "CallExpression")) return false;
 	const callee = symbol.initializer.callee;
-	return isNodeOfType(callee, "Identifier") && /^use(?:Message|Notification|Toast)$/.test(callee.name);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const hookImport = getImportBindingForName(callee, callee.name);
+	return Boolean(hookImport && isNotificationModuleSource(hookImport.source) && hookImport.exportedName !== null && /^use(?:Message|Notification|Toast)$/.test(hookImport.exportedName));
+};
+const isKnownGlobalObject = (node, expectedName, scopes) => isNodeOfType(node, "Identifier") && node.name === expectedName && scopes.isGlobalReference(node);
+const isGlobalMember = (node, expectedPropertyName, scopes) => isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.property, "Identifier") && node.property.name === expectedPropertyName && (isKnownGlobalObject(node.object, "window", scopes) || isKnownGlobalObject(node.object, "globalThis", scopes));
+const isStorageReceiver = (node, scopes) => {
+	if (isNodeOfType(node, "Identifier") && STORAGE_RECEIVER_NAMES.has(node.name) && scopes.isGlobalReference(node)) return true;
+	for (const receiverName of STORAGE_RECEIVER_NAMES) if (isGlobalMember(node, receiverName, scopes)) return true;
+	return false;
 };
 const getKnownImpureCall = (callExpression, scopes) => {
 	if (isNodeOfType(callExpression.callee, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.name) && scopes.isGlobalReference(callExpression.callee)) return `${callExpression.callee.name}()`;
+	if (isNodeOfType(callExpression.callee, "MemberExpression") && !callExpression.callee.computed && isNodeOfType(callExpression.callee.property, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.property.name) && (isKnownGlobalObject(callExpression.callee.object, "window", scopes) || isKnownGlobalObject(callExpression.callee.object, "globalThis", scopes))) return `${callExpression.callee.property.name}()`;
 	const memberCall = getMemberCall(callExpression);
 	if (!memberCall) return null;
 	const { methodName, receiver } = memberCall;
-	if (STORAGE_MUTATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && STORAGE_RECEIVER_NAMES.has(receiver.name) && scopes.isGlobalReference(receiver)) return `${receiver.name}.${methodName}()`;
-	if (EXTERNAL_READ_METHOD_NAMES.has(methodName)) return `.${methodName}()`;
-	if (NOTIFICATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && isNotificationReceiver(receiver, scopes)) return `${receiver.name}.${methodName}()`;
+	if (STORAGE_MUTATION_METHOD_NAMES.has(methodName) && isStorageReceiver(receiver, scopes)) return `${methodName}()`;
+	if (EXTERNAL_READ_METHOD_NAMES.has(methodName) && hasReactRefCurrentOrigin(receiver, scopes)) return `.${methodName}()`;
+	const receiverRoot = getRootIdentifier$1(receiver);
+	if (EXTERNAL_READ_METHOD_NAMES.has(methodName) && receiverRoot !== null && isKnownGlobalObject(receiverRoot, "document", scopes)) return `.${methodName}()`;
+	if (NOTIFICATION_METHOD_NAMES.has(methodName) && isNotificationReceiver(receiver, scopes)) return `${methodName}()`;
 	return null;
 };
 const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) => {
-	let rootIdentifier = null;
-	if (isNodeOfType(assignmentTarget, "Identifier")) rootIdentifier = assignmentTarget;
-	else if (isNodeOfType(assignmentTarget, "MemberExpression") && isNodeOfType(assignmentTarget.object, "Identifier")) rootIdentifier = assignmentTarget.object;
+	const rootIdentifier = getRootIdentifier$1(assignmentTarget);
 	if (!rootIdentifier) return null;
 	const updaterScope = scopes.ownScopeFor(updater);
 	if (!updaterScope) return null;
@@ -31866,12 +32089,26 @@ const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) =>
 	if (symbol.kind === "parameter" && symbol.scope === updaterScope) return `the updater argument "${rootIdentifier.name}"`;
 	return isDescendantScope(symbol.scope, updaterScope) ? null : `the captured value "${rootIdentifier.name}"`;
 };
+const isArrayValue = (node, scopes) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "ArrayExpression")) return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	return isNodeOfType(resolveConstIdentifierAlias(expression, scopes)?.initializer, "ArrayExpression");
+};
+const isDefinitelySynchronousCallback = (callback, scopes) => {
+	const parent = callback.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "CallExpression") && parent.callee === callback) return true;
+	if (!isNodeOfType(parent, "CallExpression") || !parent.arguments?.some((argument) => argument === callback)) return false;
+	if (isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ARRAY_METHOD_NAMES.has(parent.callee.property.name) && isArrayValue(parent.callee.object, scopes)) return true;
+	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.object, "Identifier") && parent.callee.object.name === "Array" && scopes.isGlobalReference(parent.callee.object) && isNodeOfType(parent.callee.property, "Identifier") && parent.callee.property.name === "from" && parent.arguments[1] === callback;
+};
 const findImpureUpdaterOperation = (updater, scopes) => {
 	const analysis = getProgramAnalysis(updater);
 	let operation = null;
 	walkAst(updater, (child) => {
 		if (operation) return false;
-		if (child !== updater && isFunctionLike$1(child) && !executesDuringRender(child, scopes)) return false;
+		if (child !== updater && isFunctionLike$1(child) && !isDefinitelySynchronousCallback(child, scopes)) return false;
 		if (isNodeOfType(child, "CallExpression")) {
 			if (isNodeOfType(child.callee, "Identifier") && analysis) {
 				const calleeReference = getRef(analysis, child.callee);
@@ -31903,18 +32140,25 @@ const noImpureStateUpdater = defineRule({
 	severity: "error",
 	recommendation: "Keep state updater callbacks pure and return only the next state. Move notifications, storage, timers, ref writes, and other external work into the event or effect that queues the update.",
 	create: (context) => ({ CallExpression(node) {
-		const updater = node.arguments?.[0];
-		if (!updater || !isFunctionLike$1(updater)) return;
+		const updaterArgument = node.arguments?.[0];
+		if (!updaterArgument) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis || !isNodeOfType(node.callee, "Identifier")) return;
 		const calleeReference = getRef(analysis, node.callee);
 		if (!calleeReference || !isStateSetterCall(analysis, calleeReference)) return;
 		const stateDeclarator = getUseStateDecl(analysis, calleeReference);
 		if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression") || !isReactApiCall(stateDeclarator.init, "useState", context.scopes, { allowGlobalReactNamespace: true })) return;
+		let updater = null;
+		if (isFunctionLike$1(updaterArgument)) updater = updaterArgument;
+		else if (isNodeOfType(updaterArgument, "Identifier")) {
+			const updaterReference = getRef(analysis, updaterArgument);
+			if (updaterReference) updater = resolveToFunction(updaterReference);
+		}
+		if (!updater) return;
 		const operation = findImpureUpdaterOperation(updater, context.scopes);
 		if (!operation) return;
 		context.report({
-			node: updater,
+			node: updaterArgument,
 			message: `This state updater performs ${operation}. React may run updater functions more than once, so side effects here can repeat or observe inconsistent external state.`
 		});
 	} })
@@ -32203,11 +32447,12 @@ const isMemoCall = (node) => {
 };
 const isDefaultEquivalentComparator = (comparator) => isNodeOfType(comparator, "Identifier") && (comparator.name === "undefined" || comparator.name === "shallowEqual");
 const hasCustomComparator = (node) => isNodeOfType(node, "CallExpression") && (node.arguments?.length ?? 0) >= 2 && !isDefaultEquivalentComparator(node.arguments?.[1]);
-const isInlineReference = (node) => {
-	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "bind") return "functions";
-	if (isNodeOfType(node, "ObjectExpression")) return "objects";
-	if (isNodeOfType(node, "ArrayExpression")) return "Arrays";
-	if (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")) return "JSX";
+const isInlineReference = (node, scopes) => {
+	const referenceNode = unwrapObjectIntegrityExpression(node, scopes);
+	if (isNodeOfType(referenceNode, "ArrowFunctionExpression") || isNodeOfType(referenceNode, "FunctionExpression") || isNodeOfType(referenceNode, "CallExpression") && isNodeOfType(referenceNode.callee, "MemberExpression") && isNodeOfType(referenceNode.callee.property, "Identifier") && referenceNode.callee.property.name === "bind") return "functions";
+	if (isNodeOfType(referenceNode, "ObjectExpression")) return "objects";
+	if (isNodeOfType(referenceNode, "ArrayExpression")) return "Arrays";
+	if (isNodeOfType(referenceNode, "JSXElement") || isNodeOfType(referenceNode, "JSXFragment")) return "JSX";
 	return null;
 };
 const noInlinePropOnMemoComponent = defineRule({
@@ -32237,7 +32482,7 @@ const noInlinePropOnMemoComponent = defineRule({
 				let elementName = null;
 				if (isNodeOfType(openingElement.name, "JSXIdentifier")) elementName = openingElement.name.name;
 				if (!elementName || !memoizedComponentNames.has(elementName)) return;
-				const propType = isInlineReference(node.value.expression);
+				const propType = isInlineReference(node.value.expression, context.scopes);
 				if (propType) context.report({
 					node: node.value.expression,
 					message: `This redraws ${elementName} on every render because the prop is ${propType} built right here, so memo() can't skip it. Move it to a stable value with useMemo, useCallback, or module scope`
@@ -32758,6 +33003,18 @@ const INTL_FORMAT_METHOD_NAMES = new Set([
 	"formatToParts",
 	"formatRange"
 ]);
+const ABSENT_PROPERTY_PROOF = { status: "absent" };
+const PRESENT_PROPERTY_PROOF = { status: "present" };
+const UNDEFINED_PROPERTY_PROOF = { status: "undefined" };
+const UNKNOWN_PROPERTY_PROOF = { status: "unknown" };
+const READ_ONLY_OBJECT_METHOD_NAMES = new Set([
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable",
+	"toLocaleString",
+	"toString",
+	"valueOf"
+]);
 const isProvableDateExpression = (expression) => {
 	if (!expression) return false;
 	const unwrapped = stripParenExpression(expression);
@@ -32772,32 +33029,290 @@ const receiverNameLooksDateFlavored = (expression) => {
 	if (isNodeOfType(unwrapped, "CallExpression")) return receiverNameLooksDateFlavored(unwrapped.callee);
 	return false;
 };
-const objectLiteralHasProperty = (objectExpression, propertyName) => {
-	if (!objectExpression) return false;
-	const unwrapped = stripParenExpression(objectExpression);
-	if (!isNodeOfType(unwrapped, "ObjectExpression")) return false;
-	for (const property of unwrapped.properties ?? []) {
-		if (!isNodeOfType(property, "Property")) continue;
-		if (property.computed) continue;
-		if (isNodeOfType(property.key, "Identifier") && property.key.name === propertyName) return true;
-		if (isNodeOfType(property.key, "Literal") && property.key.value === propertyName) return true;
+const isStaticUndefined = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	if (expression.name === "undefined" && scopes.isGlobalReference(expression)) return true;
+	const symbol = scopes.symbolFor(expression);
+	if (symbol?.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier") || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isStaticUndefined(symbol.initializer, scopes, visitedSymbolIds);
+};
+const isNestedAssignmentTarget = (expression) => {
+	let target = expression;
+	let parent = target.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "AssignmentExpression")) return parent.left === target;
+		if (isNodeOfType(parent, "ForInStatement") || isNodeOfType(parent, "ForOfStatement")) return parent.left === target;
+		if (isNodeOfType(parent, "AssignmentPattern")) {
+			if (parent.left !== target) return false;
+		} else if (isNodeOfType(parent, "RestElement")) {
+			if (parent.argument !== target) return false;
+		} else if (isNodeOfType(parent, "ArrayPattern")) {
+			if (!parent.elements?.some((element) => element === target)) return false;
+		} else if (isNodeOfType(parent, "Property")) {
+			if (parent.value !== target || !isNodeOfType(parent.parent, "ObjectPattern")) return false;
+		} else if (isNodeOfType(parent, "ObjectPattern")) {
+			if (!parent.properties?.some((property) => property === target)) return false;
+		} else return false;
+		target = parent;
+		parent = target.parent;
+	}
+	return false;
+};
+const isPotentialMutationReference = (identifier, readNode) => {
+	let expression = identifier;
+	let parent = expression.parent;
+	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === expression) {
+		expression = parent;
+		parent = expression.parent;
+	}
+	const rootExpression = expression;
+	let memberDepth = 0;
+	while (parent && isNodeOfType(parent, "MemberExpression") && parent.object === expression) {
+		memberDepth += 1;
+		expression = parent;
+		parent = expression.parent;
+		while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === expression) {
+			expression = parent;
+			parent = expression.parent;
+		}
+	}
+	if (!parent || isAstDescendant(identifier, readNode)) return false;
+	if (isNestedAssignmentTarget(expression)) return true;
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.left === expression) return true;
+	if (isNodeOfType(parent, "UpdateExpression") && parent.argument === expression) return true;
+	if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === expression) return true;
+	if (isNodeOfType(parent, "CallExpression")) {
+		if (parent.callee === expression) {
+			if (memberDepth === 0) return true;
+			const memberExpression = stripParenExpression(expression);
+			return memberDepth === 1 && isNodeOfType(memberExpression, "MemberExpression") && !READ_ONLY_OBJECT_METHOD_NAMES.has(getStaticPropertyName(memberExpression) ?? "");
+		}
+		return memberDepth === 0 && parent.arguments?.some((argument) => argument === rootExpression);
 	}
+	if (isNodeOfType(parent, "NewExpression")) return memberDepth === 0 && parent.arguments?.some((argument) => argument === rootExpression);
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === rootExpression) return true;
 	return false;
 };
-const hasExplicitLocaleArgument = (argument) => {
+const getSimpleAlias = (identifier, scopes) => {
+	let expression = identifier;
+	let parent = expression.parent;
+	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === expression) {
+		expression = parent;
+		parent = expression.parent;
+	}
+	if (!isNodeOfType(parent, "VariableDeclarator") || parent.init !== expression || !isNodeOfType(parent.id, "Identifier")) return null;
+	const symbol = scopes.symbolFor(parent.id);
+	return symbol ? {
+		symbol,
+		readNode: parent.id
+	} : null;
+};
+const getDirectCallForExpression = (expression) => {
+	let callee = expression;
+	let parent = callee.parent;
+	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === callee) {
+		callee = parent;
+		parent = callee.parent;
+	}
+	return isNodeOfType(parent, "CallExpression") && parent.callee === callee ? parent : null;
+};
+const getMethodOwner = (functionNode, scopes) => {
+	const methodNode = functionNode.parent;
+	if (isNodeOfType(methodNode, "Property") && methodNode.value === functionNode && isNodeOfType(methodNode.parent, "ObjectExpression")) {
+		const objectParent = methodNode.parent.parent;
+		if (!isNodeOfType(objectParent, "VariableDeclarator") || objectParent.init !== methodNode.parent || !isNodeOfType(objectParent.id, "Identifier")) return null;
+		const ownerSymbol = scopes.symbolFor(objectParent.id);
+		const methodName = getStaticPropertyKeyName(methodNode, { allowComputedString: true });
+		return ownerSymbol && methodName ? {
+			methodName,
+			ownerKind: "object",
+			ownerSymbol,
+			isStatic: false
+		} : null;
+	}
+	if (!isNodeOfType(methodNode, "MethodDefinition") || methodNode.value !== functionNode || !isNodeOfType(methodNode.parent, "ClassBody")) return null;
+	const classNode = methodNode.parent.parent;
+	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression")) return null;
+	let bindingIdentifier = isNodeOfType(classNode.id, "Identifier") ? classNode.id : null;
+	if (!bindingIdentifier && isNodeOfType(classNode.parent, "VariableDeclarator")) bindingIdentifier = isNodeOfType(classNode.parent.id, "Identifier") ? classNode.parent.id : null;
+	if (!bindingIdentifier) return null;
+	const ownerSymbol = scopes.symbolFor(bindingIdentifier);
+	const methodName = getStaticPropertyKeyName(methodNode, { allowComputedString: true });
+	return ownerSymbol && methodName ? {
+		methodName,
+		ownerKind: "class",
+		ownerSymbol,
+		isStatic: Boolean(methodNode.static)
+	} : null;
+};
+const doesSymbolResolveToOwner = (symbol, ownerSymbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!symbol) return false;
+	if (symbol.declarationNode === ownerSymbol.declarationNode) return true;
+	if (symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	const initializer = stripParenExpression(symbol.initializer);
+	return isNodeOfType(initializer, "Identifier") && doesSymbolResolveToOwner(scopes.symbolFor(initializer), ownerSymbol, scopes, visitedSymbolIds);
+};
+const isClassInstanceExpression = (expression, ownerSymbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "NewExpression") && isNodeOfType(candidate.callee, "Identifier")) return doesSymbolResolveToOwner(scopes.symbolFor(candidate.callee), ownerSymbol, scopes);
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = scopes.symbolFor(candidate);
+	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isClassInstanceExpression(symbol.initializer, ownerSymbol, scopes, visitedSymbolIds);
+};
+const getMethodCalls = (functionNode, scopes) => {
+	const owner = getMethodOwner(functionNode, scopes);
+	if (!owner) return [];
+	const calls = [];
+	walkAst(scopes.rootScope.node, (child) => {
+		if (!isNodeOfType(child, "MemberExpression")) return;
+		if (getStaticPropertyName(child) !== owner.methodName) return;
+		const receiver = stripParenExpression(child.object);
+		let doesReceiverMatch = isNodeOfType(receiver, "Identifier") && doesSymbolResolveToOwner(scopes.symbolFor(receiver), owner.ownerSymbol, scopes);
+		if (owner.ownerKind === "class" && !owner.isStatic) doesReceiverMatch = isClassInstanceExpression(receiver, owner.ownerSymbol, scopes);
+		if (!doesReceiverMatch) return;
+		const call = getDirectCallForExpression(child);
+		if (call) calls.push(call);
+	});
+	return calls;
+};
+const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, scopes, visitedSymbolIds, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
+	if (visitedFunctionNodes.has(functionNode)) return false;
+	visitedFunctionNodes.add(functionNode);
+	const usageFunction = findEnclosingFunction(usageNode);
+	const immediateCall = getDirectCallForExpression(functionNode);
+	if (immediateCall) {
+		const immediateCallFunction = findEnclosingFunction(immediateCall);
+		if (immediateCallFunction === usageFunction) {
+			const immediateCallStart = getRangeStart(immediateCall);
+			return immediateCallStart === null || immediateCallStart < usageBoundary;
+		}
+		if (!immediateCallFunction) return usageFunction !== null;
+		return isFunctionInvokedBeforeUsage(immediateCallFunction, usageNode, usageBoundary, scopes, visitedSymbolIds, new Set(visitedFunctionNodes));
+	}
+	for (const methodCall of getMethodCalls(functionNode, scopes)) {
+		const methodCallFunction = findEnclosingFunction(methodCall);
+		if (methodCallFunction === usageFunction) {
+			const methodCallStart = getRangeStart(methodCall);
+			if (methodCallStart === null || methodCallStart < usageBoundary) return true;
+			continue;
+		}
+		if (!methodCallFunction) {
+			if (usageFunction) return true;
+			continue;
+		}
+		if (isFunctionInvokedBeforeUsage(methodCallFunction, usageNode, usageBoundary, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes))) return true;
+	}
+	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	if (!bindingIdentifier) return false;
+	const symbol = scopes.symbolFor(bindingIdentifier);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	let wasInvokedBeforeUsage = false;
+	walkAst(scopes.rootScope.node, (child) => {
+		if (wasInvokedBeforeUsage || !isNodeOfType(child, "Identifier")) return;
+		if (scopes.symbolFor(child)?.declarationNode !== symbol.declarationNode) return;
+		const call = getDirectCallForExpression(child);
+		if (!call) return false;
+		const callFunction = findEnclosingFunction(call);
+		if (callFunction === usageFunction) {
+			const callStart = getRangeStart(call);
+			wasInvokedBeforeUsage = callStart === null || callStart < usageBoundary;
+			return;
+		}
+		if (!callFunction) {
+			wasInvokedBeforeUsage = usageFunction !== null;
+			return;
+		}
+		wasInvokedBeforeUsage = isFunctionInvokedBeforeUsage(callFunction, usageNode, usageBoundary, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes));
+	});
+	return wasInvokedBeforeUsage;
+};
+const getMutationUsageBoundary = (usageNode, readNode) => {
+	const readStart = getRangeStart(readNode);
+	let readExpression = readNode;
+	let readParent = readExpression.parent;
+	while (readParent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(readParent.type) && "expression" in readParent && readParent.expression === readExpression) {
+		readExpression = readParent;
+		readParent = readExpression.parent;
+	}
+	if ((isNodeOfType(usageNode, "CallExpression") || isNodeOfType(usageNode, "NewExpression")) && usageNode.arguments?.some((argument) => argument === readExpression)) return usageNode.range?.[1] ?? null;
+	if (isAstDescendant(readNode, usageNode)) return readStart;
+	return getRangeStart(usageNode);
+};
+const wasMutatedBeforeUsage = (symbol, usageNode, readNode, scopes, visitedMutationSymbolIds = /* @__PURE__ */ new Set(), inheritedUsageBoundary, readNodesBySymbolId = /* @__PURE__ */ new Map()) => {
+	if (visitedMutationSymbolIds.has(symbol.id)) return false;
+	visitedMutationSymbolIds.add(symbol.id);
+	const usageBoundary = inheritedUsageBoundary === void 0 ? getMutationUsageBoundary(usageNode, readNode) : inheritedUsageBoundary;
+	if (typeof usageBoundary !== "number") return true;
+	const usageFunction = findEnclosingFunction(usageNode);
+	return symbol.references.some((reference) => {
+		const referenceStart = getRangeStart(reference.identifier);
+		const simpleAlias = getSimpleAlias(reference.identifier, scopes);
+		if (simpleAlias) return wasMutatedBeforeUsage(simpleAlias.symbol, usageNode, readNodesBySymbolId.get(simpleAlias.symbol.id) ?? simpleAlias.readNode, scopes, new Set(visitedMutationSymbolIds), usageBoundary, readNodesBySymbolId);
+		if (!isPotentialMutationReference(reference.identifier, readNode)) return false;
+		if (referenceStart === null) return true;
+		const mutationFunction = findEnclosingFunction(reference.identifier);
+		if (mutationFunction === usageFunction) return referenceStart < usageBoundary;
+		if (!mutationFunction) return usageFunction !== null;
+		if (usageFunction && isAstDescendant(usageFunction, mutationFunction)) return true;
+		return isFunctionInvokedBeforeUsage(mutationFunction, usageNode, usageBoundary, scopes, /* @__PURE__ */ new Set());
+	});
+};
+const getObjectPropertyProof = (objectExpression, propertyName, scopes, usageNode, visitedSymbolIds = /* @__PURE__ */ new Set(), inheritedUsageBoundary, readNodesBySymbolId = /* @__PURE__ */ new Map()) => {
+	if (!objectExpression) return ABSENT_PROPERTY_PROOF;
+	const unwrapped = stripParenExpression(objectExpression);
+	if (isNodeOfType(unwrapped, "Literal") || isStaticUndefined(unwrapped, scopes)) return ABSENT_PROPERTY_PROOF;
+	if (isNodeOfType(unwrapped, "Identifier")) {
+		const symbol = scopes.symbolFor(unwrapped);
+		const nextReadNodesBySymbolId = new Map(readNodesBySymbolId);
+		if (symbol) nextReadNodesBySymbolId.set(symbol.id, unwrapped);
+		const usageBoundary = inheritedUsageBoundary === void 0 ? getMutationUsageBoundary(usageNode, unwrapped) : inheritedUsageBoundary;
+		if (symbol?.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier") || visitedSymbolIds.has(symbol.id) || wasMutatedBeforeUsage(symbol, usageNode, unwrapped, scopes, /* @__PURE__ */ new Set(), usageBoundary, nextReadNodesBySymbolId)) return UNKNOWN_PROPERTY_PROOF;
+		visitedSymbolIds.add(symbol.id);
+		return getObjectPropertyProof(symbol.initializer, propertyName, scopes, usageNode, visitedSymbolIds, usageBoundary, nextReadNodesBySymbolId);
+	}
+	if (isNodeOfType(unwrapped, "ConditionalExpression")) {
+		const consequent = getObjectPropertyProof(unwrapped.consequent, propertyName, scopes, usageNode, new Set(visitedSymbolIds), inheritedUsageBoundary, new Map(readNodesBySymbolId));
+		const alternate = getObjectPropertyProof(unwrapped.alternate, propertyName, scopes, usageNode, new Set(visitedSymbolIds), inheritedUsageBoundary, new Map(readNodesBySymbolId));
+		return consequent.status === alternate.status ? consequent : UNKNOWN_PROPERTY_PROOF;
+	}
+	if (isNodeOfType(unwrapped, "CallExpression") && isNodeOfType(unwrapped.callee, "MemberExpression") && !unwrapped.callee.computed && isNodeOfType(unwrapped.callee.object, "Identifier") && unwrapped.callee.object.name === "Object" && scopes.isGlobalReference(unwrapped.callee.object) && isNodeOfType(unwrapped.callee.property, "Identifier") && unwrapped.callee.property.name === "freeze") return getObjectPropertyProof(unwrapped.arguments?.[0], propertyName, scopes, usageNode, visitedSymbolIds, inheritedUsageBoundary, readNodesBySymbolId);
+	if (!isNodeOfType(unwrapped, "ObjectExpression")) return UNKNOWN_PROPERTY_PROOF;
+	const properties = unwrapped.properties ?? [];
+	for (let propertyIndex = properties.length - 1; propertyIndex >= 0; propertyIndex -= 1) {
+		const property = properties[propertyIndex];
+		if (!property) continue;
+		if (isNodeOfType(property, "SpreadElement")) {
+			const spreadProof = getObjectPropertyProof(property.argument, propertyName, scopes, unwrapped, new Set(visitedSymbolIds), void 0);
+			if (spreadProof.status !== "absent") return spreadProof;
+			continue;
+		}
+		if (!isNodeOfType(property, "Property") || getStaticPropertyKeyName(property) !== propertyName) continue;
+		return isStaticUndefined(property.value, scopes) ? UNDEFINED_PROPERTY_PROOF : PRESENT_PROPERTY_PROOF;
+	}
+	return ABSENT_PROPERTY_PROOF;
+};
+const objectHasExplicitProperty = (objectExpression, propertyName, scopes, usageNode) => getObjectPropertyProof(objectExpression, propertyName, scopes, usageNode).status === "present";
+const hasExplicitLocaleArgument = (argument, scopes) => {
 	if (!argument) return false;
 	const unwrapped = stripParenExpression(argument);
-	if (isNodeOfType(unwrapped, "Identifier") && unwrapped.name === "undefined") return false;
+	if (isNodeOfType(unwrapped, "Identifier") && unwrapped.name === "undefined" && scopes.isGlobalReference(unwrapped) || isNodeOfType(unwrapped, "UnaryExpression") && unwrapped.operator === "void") return false;
 	return true;
 };
-const isDeterministicLocaleMethodCall = (call, methodName, receiverIsProvablyDate) => {
+const isDeterministicLocaleMethodCall = (call, methodName, receiverIsProvablyDate, scopes) => {
 	const localeArgument = call.arguments?.[0];
-	if (!hasExplicitLocaleArgument(localeArgument)) return false;
+	if (!hasExplicitLocaleArgument(localeArgument, scopes)) return false;
 	const optionsArgument = call.arguments?.[1];
-	if (objectLiteralHasProperty(optionsArgument, "timeZone")) return true;
+	if (objectHasExplicitProperty(optionsArgument, "timeZone", scopes, call)) return true;
 	return !DATE_ONLY_LOCALE_METHOD_NAMES.has(methodName) && !receiverIsProvablyDate;
 };
-const matchLocaleMethodCall = (call) => {
+const matchLocaleMethodCall = (call, scopes) => {
 	const callee = call.callee;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return null;
 	if (!isNodeOfType(callee.property, "Identifier")) return null;
@@ -32805,7 +33320,7 @@ const matchLocaleMethodCall = (call) => {
 	if (!LOCALE_FORMAT_METHOD_NAMES.has(methodName)) return null;
 	const receiverIsProvablyDate = isProvableDateExpression(callee.object);
 	if (methodName === "toLocaleString" && !receiverIsProvablyDate && !receiverNameLooksDateFlavored(callee.object)) return null;
-	if (isDeterministicLocaleMethodCall(call, methodName, receiverIsProvablyDate)) return null;
+	if (isDeterministicLocaleMethodCall(call, methodName, receiverIsProvablyDate, scopes)) return null;
 	return {
 		node: call,
 		display: `${methodName}()`
@@ -32821,13 +33336,13 @@ const getIntlFormatterName = (expression) => {
 	if (!isNodeOfType(callee.property, "Identifier")) return null;
 	return INTL_FORMATTER_NAMES.has(callee.property.name) ? callee.property.name : null;
 };
-const isDeterministicIntlConstruction = (construction, formatterName) => {
+const isDeterministicIntlConstruction = (construction, formatterName, scopes) => {
 	if (!isNodeOfType(construction, "CallExpression") && !isNodeOfType(construction, "NewExpression")) return false;
-	if (!hasExplicitLocaleArgument(construction.arguments?.[0])) return false;
+	if (!hasExplicitLocaleArgument(construction.arguments?.[0], scopes)) return false;
 	if (formatterName !== "DateTimeFormat") return true;
-	return objectLiteralHasProperty(construction.arguments?.[1], "timeZone");
+	return objectHasExplicitProperty(construction.arguments?.[1], "timeZone", scopes, construction);
 };
-const matchIntlFormatCall = (call) => {
+const matchIntlFormatCall = (call, scopes) => {
 	const callee = call.callee;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return null;
 	if (!isNodeOfType(callee.property, "Identifier")) return null;
@@ -32840,7 +33355,7 @@ const matchIntlFormatCall = (call) => {
 	if (!construction) return null;
 	const formatterName = getIntlFormatterName(construction);
 	if (!formatterName) return null;
-	if (isDeterministicIntlConstruction(construction, formatterName)) return null;
+	if (isDeterministicIntlConstruction(construction, formatterName, scopes)) return null;
 	return {
 		node: call,
 		display: `Intl.${formatterName}().${callee.property.name}()`
@@ -32909,7 +33424,7 @@ const noLocaleFormatInRender = defineRule({
 				fileIsEmailTemplate = hasEmailTemplateImport(node);
 			},
 			CallExpression(node) {
-				const match = matchLocaleMethodCall(node) ?? matchIntlFormatCall(node) ?? matchDateDefaultStringification(node);
+				const match = matchLocaleMethodCall(node, context.scopes) ?? matchIntlFormatCall(node, context.scopes) ?? matchDateDefaultStringification(node);
 				if (match) reportIfRenderPhase(match);
 			},
 			TemplateLiteral(node) {
@@ -32929,7 +33444,7 @@ const noLocaleFormatInRender = defineRule({
 				walkAst(helperNode.body ?? helperNode, (child) => {
 					if (isFunctionLike$1(child)) return false;
 					if (!isNodeOfType(child, "CallExpression")) return;
-					const match = matchLocaleMethodCall(child) ?? matchIntlFormatCall(child);
+					const match = matchLocaleMethodCall(child, context.scopes) ?? matchIntlFormatCall(child, context.scopes);
 					if (!match || reportedNodes.has(match.node)) return;
 					if (fileIsEmailTemplate) return;
 					if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
@@ -36755,28 +37270,85 @@ const noRedundantShouldComponentUpdate = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
-const resolveReactRefSymbol = (memberExpression, scopes) => {
-	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
-	if (!isNodeOfType(memberExpression, "MemberExpression") || memberExpression.computed || !isNodeOfType(memberExpression.property, "Identifier") || memberExpression.property.name !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
-	const symbol = resolveConstIdentifierAlias(receiver, scopes);
-	if (!symbol?.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
-};
+const REPEATED_ANCESTOR_TYPES = new Set([
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"WhileStatement"
+]);
 const isSameRefCurrentMember = (node, refSymbol, scopes) => {
-	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return false;
+	if (!isNodeOfType(node, "MemberExpression") || getStaticPropertyName(node) !== "current") return false;
 	const receiver = stripParenExpression(node.object);
 	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
 };
+const isSameRefCurrentAlias = (node, refSymbol, scopes) => {
+	if (isSameRefCurrentMember(node, refSymbol, scopes)) return true;
+	if (!isNodeOfType(node, "Identifier")) return false;
+	const aliasSymbol = scopes.symbolFor(node);
+	return aliasSymbol?.kind === "const" && aliasSymbol.initializer !== null && isSameRefCurrentMember(stripParenExpression(aliasSymbol.initializer), refSymbol, scopes);
+};
+const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined" && scopes.isGlobalReference(node);
+const hasRepeatedExecutionAncestor = (node, stop) => {
+	let ancestor = node.parent;
+	while (ancestor && ancestor !== stop) {
+		if (isFunctionLike$1(ancestor) || REPEATED_ANCESTOR_TYPES.has(ancestor.type)) return true;
+		ancestor = ancestor.parent;
+	}
+	return ancestor !== stop;
+};
+const getBranchConstraints = (node, branchRoot) => {
+	const constraints = /* @__PURE__ */ new Map();
+	let descendant = node;
+	let ancestor = descendant.parent;
+	while (ancestor && descendant !== branchRoot) {
+		if (isNodeOfType(ancestor, "IfStatement")) {
+			if (ancestor.consequent === descendant) constraints.set(ancestor, true);
+			if (ancestor.alternate === descendant) constraints.set(ancestor, false);
+		}
+		descendant = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return constraints;
+};
+const canExecuteTogether = (firstConstraints, secondConstraints) => {
+	for (const [statement, branch] of firstConstraints) {
+		const otherBranch = secondConstraints.get(statement);
+		if (otherBranch !== void 0 && otherBranch !== branch) return false;
+	}
+	return true;
+};
+const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol, scopes) => {
+	const assignmentConstraints = getBranchConstraints(assignmentExpression, branchRoot);
+	const assignmentStart = getRangeStart(assignmentExpression);
+	let hasCoExecutableWrite = false;
+	walkAst(branchRoot, (child) => {
+		if (hasCoExecutableWrite) return false;
+		const childStart = getRangeStart(child);
+		if (child === assignmentExpression || !isNodeOfType(child, "AssignmentExpression") || assignmentStart === null || childStart === null || childStart >= assignmentStart || resolveReactRefSymbol(child.left, scopes)?.id !== refSymbol.id || hasRepeatedExecutionAncestor(child, branchRoot)) return;
+		if (canExecuteTogether(assignmentConstraints, getBranchConstraints(child, branchRoot))) {
+			hasCoExecutableWrite = true;
+			return false;
+		}
+	});
+	return !hasCoExecutableWrite;
+};
 const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
-	if (assignmentExpression.operator !== "=" || !isNodeOfType(assignmentExpression.right, "NewExpression")) return false;
+	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return true;
+	if (assignmentExpression.operator !== "=") return false;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
-		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant && isNodeOfType(ancestor.test, "BinaryExpression") && (ancestor.test.operator === "===" || ancestor.test.operator === "==")) {
+		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(ancestor.test, "BinaryExpression") && [
+			"===",
+			"==",
+			"!==",
+			"!="
+		].includes(ancestor.test.operator)) {
 			const { left, right } = ancestor.test;
-			if (isSameRefCurrentMember(left, refSymbol, scopes) && isNodeOfType(right, "Literal") && right.value === null || isSameRefCurrentMember(right, refSymbol, scopes) && isNodeOfType(left, "Literal") && left.value === null) return true;
+			const comparesEmptySentinel = isSameRefCurrentAlias(left, refSymbol, scopes) && isEmptySentinel(right, scopes) || isSameRefCurrentAlias(right, refSymbol, scopes) && isEmptySentinel(left, scopes);
+			const guardedBranch = ancestor.test.operator === "===" || ancestor.test.operator === "==" ? ancestor.consequent : ancestor.alternate;
+			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && hasNoPriorCoExecutableWrite(assignmentExpression, guardedBranch, refSymbol, scopes)) return true;
 		}
 		descendant = ancestor;
 		ancestor = descendant.parent;
@@ -43685,13 +44257,13 @@ const resolveTanstackQueryHookName = (callExpression) => {
 	}
 	return null;
 };
-const resolveHookNameFromInitializer = (initializer) => {
+const resolveHookNameFromInitializer = (initializer, scopes) => {
 	if (isNodeOfType(initializer, "CallExpression")) return resolveTanstackQueryHookName(initializer);
 	if (!isNodeOfType(initializer, "Identifier")) return null;
-	const binding = findVariableInitializer(initializer, initializer.name);
-	if (!binding?.initializer || !isConstDeclaredBinding(binding)) return null;
-	if (!isNodeOfType(binding.initializer, "CallExpression")) return null;
-	return resolveTanstackQueryHookName(binding.initializer);
+	const resolvedSymbol = resolveConstIdentifierAlias(initializer, scopes);
+	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
+	if (!isNodeOfType(resolvedSymbol.initializer, "CallExpression")) return null;
+	return resolveTanstackQueryHookName(resolvedSymbol.initializer);
 };
 const queryNoRestDestructuring = defineRule({
 	id: "query-no-rest-destructuring",
@@ -43704,7 +44276,7 @@ const queryNoRestDestructuring = defineRule({
 		if (!isNodeOfType(node.id, "ObjectPattern")) return;
 		if (!node.init) return;
 		if (!node.id.properties?.some((property) => isNodeOfType(property, "RestElement"))) return;
-		const hookName = resolveHookNameFromInitializer(node.init);
+		const hookName = resolveHookNameFromInitializer(node.init, context.scopes);
 		if (!hookName) return;
 		context.report({
 			node: node.id,
@@ -45059,7 +45631,7 @@ const DEFERRABLE_HOOK_NAMES = new Set([
 	"useParams",
 	"usePathname"
 ]);
-const findHookCallBindings = (componentBody) => {
+const findHookCallBindings = (componentBody, scopes) => {
 	const bindings = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return bindings;
 	for (const statement of componentBody.body ?? []) {
@@ -45070,8 +45642,10 @@ const findHookCallBindings = (componentBody) => {
 			const callee = declarator.init.callee;
 			if (!isNodeOfType(callee, "Identifier")) continue;
 			if (!DEFERRABLE_HOOK_NAMES.has(callee.name)) continue;
+			const valueSymbol = scopes.symbolFor(declarator.id);
+			if (!valueSymbol) continue;
 			bindings.push({
-				valueName: declarator.id.name,
+				valueSymbol,
 				hookName: callee.name,
 				declarator
 			});
@@ -45079,6 +45653,49 @@ const findHookCallBindings = (componentBody) => {
 	}
 	return bindings;
 };
+const collectExactAliasSymbols = (componentBody, sourceSymbol, scopes) => {
+	const symbols = [sourceSymbol];
+	const symbolIds = new Set([sourceSymbol.id]);
+	const aliasSourceIdentifiers = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(componentBody, "BlockStatement")) return {
+		symbols,
+		aliasSourceIdentifiers
+	};
+	let didFindAlias = true;
+	while (didFindAlias) {
+		didFindAlias = false;
+		for (const statement of componentBody.body ?? []) {
+			if (!isNodeOfType(statement, "VariableDeclaration") || statement.kind !== "const") continue;
+			for (const declarator of statement.declarations ?? []) {
+				let aliasIdentifier = null;
+				let sourceIdentifier = null;
+				const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
+				const arrayBinding = isNodeOfType(declarator.id, "ArrayPattern") ? declarator.id.elements[0] : null;
+				const arrayValueNode = isNodeOfType(initializer, "ArrayExpression") ? initializer.elements[0] : null;
+				const arrayValue = arrayValueNode && !isNodeOfType(arrayValueNode, "SpreadElement") ? stripParenExpression(arrayValueNode) : null;
+				if (isNodeOfType(declarator.id, "Identifier") && isNodeOfType(initializer, "Identifier")) {
+					aliasIdentifier = declarator.id;
+					sourceIdentifier = initializer;
+				} else if (isNodeOfType(declarator.id, "ArrayPattern") && declarator.id.elements.length === 1 && isNodeOfType(arrayBinding, "Identifier") && isNodeOfType(initializer, "ArrayExpression") && initializer.elements.length === 1 && isNodeOfType(arrayValue, "Identifier")) {
+					aliasIdentifier = arrayBinding;
+					sourceIdentifier = arrayValue;
+				}
+				if (!aliasIdentifier || !sourceIdentifier) continue;
+				const referencedSymbol = scopes.symbolFor(sourceIdentifier);
+				const aliasSymbol = scopes.symbolFor(aliasIdentifier);
+				if (!referencedSymbol || !symbolIds.has(referencedSymbol.id) || !aliasSymbol || aliasSymbol.kind !== "const" || symbolIds.has(aliasSymbol.id)) continue;
+				symbolIds.add(aliasSymbol.id);
+				symbols.push(aliasSymbol);
+				aliasSourceIdentifiers.add(sourceIdentifier);
+				didFindAlias = true;
+			}
+		}
+	}
+	return {
+		symbols,
+		aliasSourceIdentifiers
+	};
+};
 const rerenderDeferReadsHook = defineRule({
 	id: "rerender-defer-reads-hook",
 	title: "URL hook value only read in handlers",
@@ -45089,15 +45706,13 @@ const rerenderDeferReadsHook = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = findHookCallBindings(componentBody);
+			const bindings = findHookCallBindings(componentBody, context.scopes);
 			if (bindings.length === 0) return;
 			const handlerBindingNames = collectHandlerBindingNames(componentBody);
 			for (const binding of bindings) {
+				const { symbols, aliasSourceIdentifiers } = collectExactAliasSymbols(componentBody, binding.valueSymbol, context.scopes);
 				const referenceLocations = [];
-				walkAst(componentBody, (child) => {
-					if (isNodeOfType(binding.declarator, "VariableDeclarator") && child === binding.declarator.id) return;
-					if (isNodeOfType(child, "Identifier") && child.name === binding.valueName) referenceLocations.push(child);
-				});
+				for (const symbol of symbols) for (const reference of symbol.references) if (!aliasSourceIdentifiers.has(reference.identifier)) referenceLocations.push(reference.identifier);
 				if (referenceLocations.length === 0) continue;
 				if (!referenceLocations.every((ref) => isInsideEventHandler(ref, handlerBindingNames))) continue;
 				context.report({
@@ -53046,7 +53661,8 @@ const serverCacheWithObjectLiteral = defineRule({
 				if (!isNodeOfType(node.callee, "Identifier")) return;
 				if (!cachedFunctionNames.has(node.callee.name)) return;
 				const firstArg = node.arguments?.[0];
-				if (!isNodeOfType(firstArg, "ObjectExpression")) return;
+				if (!firstArg || isNodeOfType(firstArg, "SpreadElement")) return;
+				if (!isNodeOfType(unwrapObjectIntegrityExpression(firstArg, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES), "ObjectExpression")) return;
 				context.report({
 					node,
 					message: `Passing a new object to React.cache() each render misses the cache, so it refetches every request.`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.6-dev.4fb3694",
+  "version": "0.7.6-dev.543ebfe",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",