oxlint-plugin-react-doctor 0.8.1-dev.61bf03e → 0.8.1-dev.6fcd9c9

package/dist/index.d.ts

@@ -100,7 +100,7 @@ interface RuleContext extends Omit<BaseRuleContext, "getFilename"> {
 //#region src/plugin/utils/capability.d.ts
 declare const FRAMEWORK_TOKENS: readonly ["nextjs", "vite", "cra", "remix", "gatsby", "expo", "react-native", "tanstack-start", "preact", "unknown"];
 type FrameworkToken = (typeof FRAMEWORK_TOKENS)[number];
-type Capability = FrameworkToken | "react" | "remotion" | "pure-preact" | "react-native" | "server-actions" | "ssr" | "client-only" | "nextjs:static-export" | "nextjs:15" | "tailwind" | "tailwind:3.4" | "zod" | "zod:4" | "mobx" | "mobx-react" | "mobx-react-lite" | "mobx-react-binding" | "mobx-state-tree" | "mobx-react-observer" | "typescript" | "react-compiler" | "tanstack-query" | "valtio" | "pre-es2023" | `react:${number}` | `preact:${number}` | `remotion:${number}` | `valtio:${number}` | `mobx:${number}`;
+type Capability = FrameworkToken | "react" | "remotion" | "pure-preact" | "react-native" | "server-actions" | "ssr" | "client-only" | "nextjs:static-export" | "nextjs:15" | "tailwind" | "tailwind:3.4" | "zod" | "zod:4" | "mobx" | "mobx-react" | "mobx-react-lite" | "mobx-react-binding" | "mobx-state-tree" | "mobx-react-observer" | "zustand" | "typescript" | "react-compiler" | "tanstack-query" | "valtio" | "pre-es2023" | `react:${number}` | `preact:${number}` | `remotion:${number}` | `valtio:${number}` | `mobx:${number}` | `zustand:${number}`;
 type CapabilityQuery = (capability: Capability) => boolean;
 //#endregion
 //#region src/plugin/utils/file-scan.d.ts
@@ -9712,6 +9712,75 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/zustand-no-fresh-selector-result";
+  readonly id: "zustand-no-fresh-selector-result";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Performance";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zustand-no-get-during-initialization";
+  readonly id: "zustand-no-get-during-initialization";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zustand-no-whole-store-destructure";
+  readonly id: "zustand-no-whole-store-destructure";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }];
 declare const EXTERNAL_RULES: readonly [{
   readonly key: "react-hooks-js/set-state-in-render";
@@ -19323,6 +19392,75 @@ declare const RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/zustand-no-fresh-selector-result";
+  readonly id: "zustand-no-fresh-selector-result";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Performance";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zustand-no-get-during-initialization";
+  readonly id: "zustand-no-get-during-initialization";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zustand-no-whole-store-destructure";
+  readonly id: "zustand-no-whole-store-destructure";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-hooks-js/set-state-in-render";
   readonly source: "react-compiler";

package/dist/index.js

@@ -1953,13 +1953,13 @@ const getImportDeclaration = (node) => {
 	}
 	return null;
 };
-const getImportSource = (declaration) => typeof declaration.source.value === "string" ? declaration.source.value : null;
+const getImportSource$1 = (declaration) => typeof declaration.source.value === "string" ? declaration.source.value : null;
 const isNamedImport = (symbol, importedName, moduleSources) => {
 	if (symbol.kind !== "import") return false;
 	const declaration = symbol.declarationNode;
 	if (!isNodeOfType(declaration, "ImportSpecifier")) return false;
 	const importDeclaration = getImportDeclaration(declaration);
-	const source = importDeclaration ? getImportSource(importDeclaration) : null;
+	const source = importDeclaration ? getImportSource$1(importDeclaration) : null;
 	if (!source || !moduleSources.has(source)) return false;
 	const imported = declaration.imported;
 	return isNodeOfType(imported, "Identifier") && imported.name === importedName || isNodeOfType(imported, "Literal") && imported.value === importedName;
@@ -1968,7 +1968,7 @@ const isSatoriImport = (symbol) => {
 	if (symbol.kind !== "import") return false;
 	const declaration = symbol.declarationNode;
 	const importDeclaration = getImportDeclaration(declaration);
-	if (!importDeclaration || getImportSource(importDeclaration) !== "satori") return false;
+	if (!importDeclaration || getImportSource$1(importDeclaration) !== "satori") return false;
 	if (isNodeOfType(declaration, "ImportDefaultSpecifier")) return true;
 	if (!isNodeOfType(declaration, "ImportSpecifier")) return false;
 	const imported = declaration.imported;
@@ -1989,7 +1989,7 @@ const isGeneratedImageRendererCall = (node, scopes) => {
 	const declaration = symbol.declarationNode;
 	if (!isNodeOfType(declaration, "ImportNamespaceSpecifier")) return false;
 	const importDeclaration = getImportDeclaration(declaration);
-	const source = importDeclaration ? getImportSource(importDeclaration) : null;
+	const source = importDeclaration ? getImportSource$1(importDeclaration) : null;
 	return Boolean(source && IMAGE_RESPONSE_MODULES.has(source));
 };
 //#endregion
@@ -30225,17 +30225,20 @@ const catchClauseRethrowsCaught = (handler) => {
 	return didRethrow;
 };
 //#endregion
-//#region src/plugin/utils/is-immediately-invoked-function.ts
-const isImmediatelyInvokedFunction = (functionNode) => {
+//#region src/plugin/utils/find-immediately-invoked-call-expression.ts
+const findImmediatelyInvokedCallExpression = (functionNode) => {
 	let wrappedCallee = functionNode;
 	let enclosing = functionNode.parent;
 	while (enclosing && stripParenExpression(enclosing) === functionNode) {
 		wrappedCallee = enclosing;
 		enclosing = enclosing.parent ?? null;
 	}
-	return Boolean(enclosing && isNodeOfType(enclosing, "CallExpression") && enclosing.callee === wrappedCallee);
+	return enclosing && isNodeOfType(enclosing, "CallExpression") && enclosing.callee === wrappedCallee ? enclosing : null;
 };
 //#endregion
+//#region src/plugin/utils/is-immediately-invoked-function.ts
+const isImmediatelyInvokedFunction = (functionNode) => Boolean(findImmediatelyInvokedCallExpression(functionNode));
+//#endregion
 //#region src/plugin/utils/find-guarding-try-statement.ts
 const findGuardingTryStatement = (node) => {
 	let child = node;
@@ -59108,7 +59111,7 @@ const inlineUseSelectorFunction = (callNode, aliases) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/redux-useselector-inline-derivation.ts
-const ALLOCATING_ARRAY_METHODS = new Set([
+const ALLOCATING_ARRAY_METHODS$1 = new Set([
 	"filter",
 	"map",
 	"flatMap",
@@ -59144,7 +59147,7 @@ const getAllocatingCallSiteDescription = (expression) => {
 			method: methodName
 		};
 	}
-	if (ALLOCATING_ARRAY_METHODS.has(methodName)) return {
+	if (ALLOCATING_ARRAY_METHODS$1.has(methodName)) return {
 		kind: "method",
 		method: methodName
 	};
@@ -62232,6 +62235,85 @@ const isSetterCalledDuringRender = (root, setterName) => {
 	return found;
 };
 //#endregion
+//#region src/plugin/utils/is-descendant-without-function-boundary.ts
+const isDescendantWithoutFunctionBoundary = (descendant, ancestor) => {
+	let current = descendant;
+	while (current && current !== ancestor) {
+		if (current !== descendant && isFunctionLike$1(current)) return false;
+		current = current.parent;
+	}
+	return current === ancestor;
+};
+//#endregion
+//#region src/plugin/utils/can-execute-before-async-suspension.ts
+const collectSuspensionNodes = (functionNode, options) => {
+	const suspensionNodes = new Set(options.suspensionNodes);
+	walkAst(functionNode, (node) => {
+		if (node !== functionNode && isFunctionLike$1(node)) return false;
+		if (!options.suspensionNodes && isNodeOfType(node, "AwaitExpression") || isNodeOfType(node, "ForOfStatement") && node.await) suspensionNodes.add(node);
+	});
+	return suspensionNodes;
+};
+const isInsideForAwaitPostSuspensionRegion = (node, functionNode) => {
+	let current = node;
+	while (current && current !== functionNode) {
+		const parent = current.parent;
+		if (parent && isNodeOfType(parent, "ForOfStatement") && parent.await && (parent.left === current || parent.body === current)) return true;
+		current = parent;
+	}
+	return false;
+};
+const suspensionBlockNode = (suspensionNode) => isNodeOfType(suspensionNode, "ForOfStatement") ? suspensionNode.right : suspensionNode;
+const doesSuspensionOccurBeforeNode = (suspensionNode, node) => {
+	if (isNodeOfType(suspensionNode, "AwaitExpression")) {
+		if (isDescendantWithoutFunctionBoundary(node, suspensionNode.argument)) return false;
+	} else if (isNodeOfType(suspensionNode, "ForOfStatement") && isDescendantWithoutFunctionBoundary(node, suspensionNode.right)) return false;
+	if (isDescendantWithoutFunctionBoundary(suspensionNode, node)) return true;
+	const suspensionStart = getRangeStart(suspensionBlockNode(suspensionNode));
+	const nodeStart = getRangeStart(node);
+	return suspensionStart !== null && nodeStart !== null && suspensionStart < nodeStart;
+};
+const findExecutionNodeWithinFunction = (node, functionNode, context) => {
+	let executionNode = node;
+	let executionOwner = context.cfg.enclosingFunction(executionNode);
+	while (executionOwner && executionOwner !== functionNode) {
+		if (!isFunctionLike$1(executionOwner) || executionOwner.async || executionOwner.generator) return null;
+		const callExpression = findImmediatelyInvokedCallExpression(executionOwner);
+		if (!callExpression) return null;
+		executionNode = callExpression;
+		executionOwner = context.cfg.enclosingFunction(callExpression);
+	}
+	return executionOwner === functionNode ? executionNode : null;
+};
+const canExecuteBeforeAsyncSuspension = (node, functionNode, context, options = {}) => {
+	if (!isFunctionLike$1(functionNode) || !functionNode.async) return isNodeReachableWithinFunction(node, context);
+	const executionNode = findExecutionNodeWithinFunction(node, functionNode, context);
+	if (!executionNode || isInsideForAwaitPostSuspensionRegion(executionNode, functionNode)) return false;
+	const functionCfg = context.cfg.cfgFor(functionNode);
+	const targetBlock = functionCfg?.blockOf(executionNode);
+	if (!functionCfg || !targetBlock) return false;
+	const suspensionsByBlock = /* @__PURE__ */ new Map();
+	for (const suspensionNode of collectSuspensionNodes(functionNode, options)) {
+		const suspensionBlock = functionCfg.blockOf(suspensionBlockNode(suspensionNode));
+		if (!suspensionBlock) continue;
+		const blockSuspensions = suspensionsByBlock.get(suspensionBlock) ?? [];
+		blockSuspensions.push(suspensionNode);
+		suspensionsByBlock.set(suspensionBlock, blockSuspensions);
+	}
+	const visitedBlocks = /* @__PURE__ */ new Set();
+	const pendingBlocks = [functionCfg.entry];
+	while (pendingBlocks.length > 0) {
+		const block = pendingBlocks.pop();
+		if (!block || visitedBlocks.has(block)) continue;
+		visitedBlocks.add(block);
+		const blockSuspensions = suspensionsByBlock.get(block) ?? [];
+		if (block === targetBlock) return !blockSuspensions.some((suspensionNode) => doesSuspensionOccurBeforeNode(suspensionNode, executionNode));
+		if (blockSuspensions.length > 0) continue;
+		for (const edge of block.successors) if (edge.kind !== "throw") pendingBlocks.push(edge.to);
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/utils/create-external-location-invalidation-checker.ts
 const HISTORY_LOCATION_MUTATION_METHOD_NAMES = new Set(["pushState", "replaceState"]);
 const AGGREGATE_MUTATION_METHOD_NAMES = new Set([...MUTATING_ARRAY_METHODS, ...MUTATING_COLLECTION_METHODS]);
@@ -62424,14 +62506,6 @@ const buildLocationInvalidationIndex = (componentBody, componentFunction, contex
 	});
 	return index;
 };
-const isDescendantWithoutFunctionBoundary = (descendant, ancestor) => {
-	let current = descendant;
-	while (current && current !== ancestor) {
-		if (current !== descendant && isFunctionLike$1(current)) return false;
-		current = current.parent;
-	}
-	return current === ancestor;
-};
 const areInMutuallyExclusiveConditionalBranches = (firstNode, secondNode) => {
 	const firstBranches = /* @__PURE__ */ new Map();
 	let current = firstNode;
@@ -62743,39 +62817,7 @@ const canNodeReachNormalFunctionExit = (node, functionNode, index) => {
 	}
 	return false;
 };
-const canExecuteBeforeAsyncSuspension = (node, functionNode, index) => {
-	if (!isFunctionLike$1(functionNode) || !functionNode.async) return isNodeReachableWithinFunction(node, index.context);
-	const functionCfg = index.context.cfg.cfgFor(functionNode);
-	const targetBlock = functionCfg?.blockOf(node);
-	if (!functionCfg || !targetBlock) return false;
-	const awaitsByBlock = /* @__PURE__ */ new Map();
-	for (const awaitExpression of index.awaitExpressionsByOwner.get(functionNode) ?? []) {
-		const awaitBlock = functionCfg.blockOf(awaitExpression);
-		if (!awaitBlock) continue;
-		const blockAwaits = awaitsByBlock.get(awaitBlock) ?? [];
-		blockAwaits.push(awaitExpression);
-		awaitsByBlock.set(awaitBlock, blockAwaits);
-	}
-	const visitedBlocks = /* @__PURE__ */ new Set();
-	const pendingBlocks = [functionCfg.entry];
-	const targetStart = getRangeStart(node);
-	while (pendingBlocks.length > 0) {
-		const block = pendingBlocks.pop();
-		if (!block || visitedBlocks.has(block)) continue;
-		visitedBlocks.add(block);
-		const blockAwaits = awaitsByBlock.get(block) ?? [];
-		if (block === targetBlock) return !blockAwaits.some((awaitExpression) => {
-			if (isNodeOfType(awaitExpression, "AwaitExpression") && isDescendantWithoutFunctionBoundary(node, awaitExpression.argument)) return false;
-			if (isDescendantWithoutFunctionBoundary(awaitExpression, node)) return true;
-			const awaitStart = getRangeStart(awaitExpression);
-			return awaitStart !== null && targetStart !== null && awaitStart < targetStart;
-		});
-		if (blockAwaits.length > 0) continue;
-		for (const edge of block.successors) if (edge.kind !== "throw") pendingBlocks.push(edge.to);
-	}
-	return false;
-};
-const canReactBatchMutationAfterExecution = (executionNode, mutationNode, owner, index) => (isExclusiveIntrinsicReactEventHandler(owner, index) || index.effectCallbacks.has(owner)) && canNodeReachNode(executionNode, mutationNode, index) && canExecuteBeforeAsyncSuspension(mutationNode, owner, index) && canNodeReachNormalFunctionExit(mutationNode, owner, index);
+const canReactBatchMutationAfterExecution = (executionNode, mutationNode, owner, index) => (isExclusiveIntrinsicReactEventHandler(owner, index) || index.effectCallbacks.has(owner)) && canNodeReachNode(executionNode, mutationNode, index) && canExecuteBeforeAsyncSuspension(mutationNode, owner, index.context, { suspensionNodes: index.awaitExpressionsByOwner.get(owner) }) && canNodeReachNormalFunctionExit(mutationNode, owner, index);
 const functionMaySynchronouslyMutateLocation = (functionNode, index, visitingFunctions, cycleAffectedFunctions) => {
 	const cachedResult = index.synchronousMutationResultByFunction.get(functionNode);
 	if (cachedResult !== void 0) return cachedResult;
@@ -62789,7 +62831,7 @@ const functionMaySynchronouslyMutateLocation = (functionNode, index, visitingFun
 		return false;
 	}
 	visitingFunctions.add(functionNode);
-	const doesMutateSynchronously = [...collectLocationMutationExecutions(functionNode, index, visitingFunctions, cycleAffectedFunctions)].some((mutationExecution) => canExecuteBeforeAsyncSuspension(mutationExecution, functionNode, index) && canNodeReachNormalFunctionExit(mutationExecution, functionNode, index));
+	const doesMutateSynchronously = [...collectLocationMutationExecutions(functionNode, index, visitingFunctions, cycleAffectedFunctions)].some((mutationExecution) => canExecuteBeforeAsyncSuspension(mutationExecution, functionNode, index.context, { suspensionNodes: index.awaitExpressionsByOwner.get(functionNode) }) && canNodeReachNormalFunctionExit(mutationExecution, functionNode, index));
 	visitingFunctions.delete(functionNode);
 	if (doesMutateSynchronously || !cycleAffectedFunctions.has(functionNode)) index.synchronousMutationResultByFunction.set(functionNode, doesMutateSynchronously);
 	return doesMutateSynchronously;
@@ -62816,20 +62858,20 @@ const functionMustSynchronouslyRemoveLocationListener = (functionNode, registrat
 	for (const removal of index.listenerRemovals) {
 		if (!isDefinitelyMatchingLocationListenerRemoval(registration, removal)) continue;
 		if (index.context.cfg.enclosingFunction(removal.callExpression) !== functionNode) continue;
-		if (canExecuteBeforeAsyncSuspension(removal.callExpression, functionNode, index)) removalExecutions.push(removal.callExpression);
+		if (canExecuteBeforeAsyncSuspension(removal.callExpression, functionNode, index.context, { suspensionNodes: index.awaitExpressionsByOwner.get(functionNode) })) removalExecutions.push(removal.callExpression);
 	}
 	for (const expression of index.expressionsByOwner.get(functionNode) ?? []) {
 		const calledFunction = index.calledFunctionByExpression.get(expression);
-		if (calledFunction && canExecuteBeforeAsyncSuspension(expression, functionNode, index) && functionMustSynchronouslyRemoveLocationListener(calledFunction, registration, index, nextVisitingFunctions)) removalExecutions.push(expression);
+		if (calledFunction && canExecuteBeforeAsyncSuspension(expression, functionNode, index.context, { suspensionNodes: index.awaitExpressionsByOwner.get(functionNode) }) && functionMustSynchronouslyRemoveLocationListener(calledFunction, registration, index, nextVisitingFunctions)) removalExecutions.push(expression);
 	}
 	return doNodesCoverEveryPathFromFunctionEntry(functionNode, removalExecutions, index.context);
 };
 const collectSynchronousLocationListenerRemovalExecutions = (functionNode, registration, index) => {
 	const removalExecutions = /* @__PURE__ */ new Set();
-	for (const removal of index.listenerRemovals) if (isDefinitelyMatchingLocationListenerRemoval(registration, removal) && index.context.cfg.enclosingFunction(removal.callExpression) === functionNode && canExecuteBeforeAsyncSuspension(removal.callExpression, functionNode, index)) removalExecutions.add(removal.callExpression);
+	for (const removal of index.listenerRemovals) if (isDefinitelyMatchingLocationListenerRemoval(registration, removal) && index.context.cfg.enclosingFunction(removal.callExpression) === functionNode && canExecuteBeforeAsyncSuspension(removal.callExpression, functionNode, index.context, { suspensionNodes: index.awaitExpressionsByOwner.get(functionNode) })) removalExecutions.add(removal.callExpression);
 	for (const expression of index.expressionsByOwner.get(functionNode) ?? []) {
 		const calledFunction = index.calledFunctionByExpression.get(expression);
-		if (calledFunction && canExecuteBeforeAsyncSuspension(expression, functionNode, index) && functionMustSynchronouslyRemoveLocationListener(calledFunction, registration, index, /* @__PURE__ */ new Set())) removalExecutions.add(expression);
+		if (calledFunction && canExecuteBeforeAsyncSuspension(expression, functionNode, index.context, { suspensionNodes: index.awaitExpressionsByOwner.get(functionNode) }) && functionMustSynchronouslyRemoveLocationListener(calledFunction, registration, index, /* @__PURE__ */ new Set())) removalExecutions.add(expression);
 	}
 	return removalExecutions;
 };
@@ -73652,6 +73694,516 @@ const zodV4PreferTopLevelStringFormats = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/utils/function-returns-collection-at-path.ts
+const resolveImmutableInitializer = (expression, scopes, visitedSymbolIds) => {
+	const candidate = stripParenExpression(expression);
+	if (!isNodeOfType(candidate, "Identifier")) return candidate;
+	const symbol = scopes.symbolFor(candidate);
+	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return candidate;
+	visitedSymbolIds.add(symbol.id);
+	return resolveImmutableInitializer(symbol.initializer, scopes, visitedSymbolIds);
+};
+const expressionAtPropertyPath = (expression, propertyPath, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = resolveImmutableInitializer(expression, scopes, visitedSymbolIds);
+	const [propertyName, ...remainingPath] = propertyPath;
+	if (!propertyName) return candidate;
+	if (!isNodeOfType(candidate, "ObjectExpression")) return null;
+	for (const property of candidate.properties) {
+		if (!isNodeOfType(property, "Property")) continue;
+		if (getStaticPropertyKeyName(property) !== propertyName) continue;
+		return expressionAtPropertyPath(property.value, remainingPath, scopes, visitedSymbolIds);
+	}
+	return null;
+};
+const isGlobalConstructor = (expression, constructorNames, scopes) => {
+	const candidate = stripParenExpression(expression);
+	return isNodeOfType(candidate, "Identifier") && constructorNames.has(candidate.name) && scopes.isGlobalReference(candidate);
+};
+const isCollectionExpression = (expression, collectionKind, scopes) => {
+	const candidate = stripParenExpression(expression);
+	if (collectionKind === "array" && isNodeOfType(candidate, "ArrayExpression")) return true;
+	if (!isNodeOfType(candidate, "NewExpression")) return false;
+	return isGlobalConstructor(candidate.callee, collectionKind === "array" ? new Set(["Array"]) : new Set(["Map", "Set"]), scopes);
+};
+const functionReturnsCollectionAtPath = ({ collectionKind, functionNode, propertyPath, scopes }) => {
+	if (!isFunctionLike$1(functionNode)) return false;
+	const returnedExpressions = isNodeOfType(functionNode.body, "BlockStatement") ? collectFunctionReturnStatements(functionNode).flatMap((returnStatement) => returnStatement.argument ? [returnStatement.argument] : []) : [functionNode.body];
+	return returnedExpressions.length > 0 && returnedExpressions.every((returnedExpression) => {
+		const collectionExpression = expressionAtPropertyPath(returnedExpression, propertyPath, scopes);
+		return Boolean(collectionExpression && isCollectionExpression(collectionExpression, collectionKind, scopes));
+	});
+};
+//#endregion
+//#region src/plugin/utils/resolve-zustand-api.ts
+const ZUSTAND_APIS_BY_MODULE = new Map([
+	["zustand", new Set([
+		"create",
+		"createStore",
+		"useStore"
+	])],
+	["zustand/vanilla", new Set(["createStore"])],
+	["zustand/react", new Set(["useStore"])],
+	["zustand/traditional", new Set(["createWithEqualityFn", "useStoreWithEqualityFn"])],
+	["zustand/shallow", new Set(["shallow", "useShallow"])],
+	["zustand/react/shallow", new Set(["useShallow"])],
+	["zustand/middleware", new Set([
+		"combine",
+		"createJSONStorage",
+		"devtools",
+		"persist",
+		"redux",
+		"subscribeWithSelector"
+	])],
+	["zustand/middleware/immer", new Set(["immer"])]
+]);
+const STATE_CREATOR_MIDDLEWARE_ARGUMENT_INDEX = new Map([
+	["combine", 1],
+	["devtools", 0],
+	["immer", 0],
+	["persist", 0],
+	["subscribeWithSelector", 0]
+]);
+const toZustandApiName = (value) => {
+	switch (value) {
+		case "combine":
+		case "create":
+		case "createJSONStorage":
+		case "createStore":
+		case "createWithEqualityFn":
+		case "devtools":
+		case "immer":
+		case "persist":
+		case "redux":
+		case "shallow":
+		case "subscribeWithSelector":
+		case "useShallow":
+		case "useStore":
+		case "useStoreWithEqualityFn": return value;
+		default: return null;
+	}
+};
+const getImportSource = (symbol) => {
+	const declaration = getImportDeclarationForSymbol(symbol);
+	if (!declaration || isTypeOnlyImport(declaration) || isNodeOfType(symbol.declarationNode, "ImportSpecifier") && symbol.declarationNode.importKind === "type") return null;
+	return typeof declaration.source.value === "string" ? declaration.source.value : null;
+};
+const bindingFromImportSymbol = (symbol) => {
+	const moduleSource = getImportSource(symbol);
+	const supportedApiNames = moduleSource ? ZUSTAND_APIS_BY_MODULE.get(moduleSource) : null;
+	if (!moduleSource || !supportedApiNames) return null;
+	if (moduleSource === "zustand" && isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier")) return {
+		apiName: "create",
+		moduleSource
+	};
+	const importedName = getImportedName(symbol.declarationNode);
+	const apiName = importedName ? toZustandApiName(importedName) : null;
+	return apiName && supportedApiNames.has(apiName) ? {
+		apiName,
+		moduleSource
+	} : null;
+};
+const namespaceImportSource = (expression, scopes) => {
+	if (!isNodeOfType(expression, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(expression, scopes);
+	if (!symbol || !isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")) return null;
+	return getImportSource(symbol);
+};
+const resolveZustandApiBinding = (expression, scopes) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = resolveConstIdentifierAlias(candidate, scopes);
+		if (!symbol) return null;
+		if (symbol.kind === "import") return bindingFromImportSymbol(symbol);
+		if (symbol.kind !== "const" || !symbol.initializer) return null;
+		return resolveZustandApiBinding(symbol.initializer, scopes);
+	}
+	if (!isNodeOfType(candidate, "MemberExpression")) return null;
+	const propertyName = getStaticPropertyName(candidate);
+	const moduleSource = namespaceImportSource(stripParenExpression(candidate.object), scopes);
+	const supportedApiNames = moduleSource ? ZUSTAND_APIS_BY_MODULE.get(moduleSource) : null;
+	const apiName = propertyName ? toZustandApiName(propertyName) : null;
+	return apiName && moduleSource && supportedApiNames?.has(apiName) ? {
+		apiName,
+		moduleSource
+	} : null;
+};
+const resolveStateCreator = (expression, scopes, middlewareNames, visitedExpressions = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (visitedExpressions.has(candidate)) return null;
+	visitedExpressions.add(candidate);
+	const creatorFunction = resolveExactLocalFunction(expression, scopes);
+	if (isFunctionLike$1(creatorFunction)) return creatorFunction;
+	if (!isNodeOfType(candidate, "CallExpression")) return null;
+	const middleware = resolveZustandApiBinding(candidate.callee, scopes);
+	const creatorArgumentIndex = middleware ? STATE_CREATOR_MIDDLEWARE_ARGUMENT_INDEX.get(middleware.apiName) : null;
+	if (!middleware || creatorArgumentIndex === void 0 || creatorArgumentIndex === null) return null;
+	const creatorArgument = candidate.arguments[creatorArgumentIndex];
+	if (!creatorArgument || isNodeOfType(creatorArgument, "SpreadElement")) return null;
+	middlewareNames.add(middleware.apiName);
+	return resolveStateCreator(creatorArgument, scopes, middlewareNames, visitedExpressions);
+};
+const isStoreFactoryApi = (binding) => binding?.apiName === "create" || binding?.apiName === "createStore" || binding?.apiName === "createWithEqualityFn";
+const resolveCurriedStoreFactoryBinding = (expression, scopes) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = resolveConstIdentifierAlias(candidate, scopes);
+		if (symbol?.kind !== "const" || !symbol.initializer) return null;
+		return resolveCurriedStoreFactoryBinding(symbol.initializer, scopes);
+	}
+	if (!isNodeOfType(candidate, "CallExpression") || candidate.arguments.length > 0) return null;
+	const factoryBinding = resolveZustandApiBinding(candidate.callee, scopes);
+	return isStoreFactoryApi(factoryBinding) ? factoryBinding : null;
+};
+const resolveZustandStoreCreator = (callExpression, scopes) => {
+	const factoryCall = resolveZustandStoreFactoryCall(callExpression, scopes);
+	if (!factoryCall) return null;
+	const middlewareNames = /* @__PURE__ */ new Set();
+	const creatorFunction = resolveStateCreator(factoryCall.creatorArgument, scopes, middlewareNames);
+	if (!creatorFunction) return null;
+	return {
+		creatorFunction,
+		factoryApiName: factoryCall.factoryApiName,
+		middlewareNames
+	};
+};
+const resolveZustandStoreFactoryCall = (callExpression, scopes) => {
+	let factoryBinding = resolveZustandApiBinding(callExpression.callee, scopes);
+	if (!isStoreFactoryApi(factoryBinding)) {
+		factoryBinding = resolveCurriedStoreFactoryBinding(callExpression.callee, scopes);
+		if (!isStoreFactoryApi(factoryBinding)) return null;
+	}
+	const creatorArgument = callExpression.arguments[0];
+	if (!creatorArgument || isNodeOfType(creatorArgument, "SpreadElement")) return null;
+	return {
+		callExpression,
+		creatorArgument,
+		factoryApiName: factoryBinding.apiName
+	};
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/zustand-no-fresh-selector-result.ts
+const ALLOCATING_ARRAY_METHODS = new Set([
+	"filter",
+	"flat",
+	"flatMap",
+	"map",
+	"toReversed",
+	"toSorted",
+	"toSpliced",
+	"with"
+]);
+const SAME_REFERENCE_ARRAY_METHODS = new Set(["reverse", "sort"]);
+const ALLOCATING_NAMESPACE_METHOD_KINDS = new Map([["Array", new Map([["from", "array"], ["of", "array"]])], ["Object", new Map([
+	["create", "object"],
+	["entries", "array"],
+	["fromEntries", "object"],
+	["keys", "array"],
+	["values", "array"]
+])]]);
+const isNullishEqualityArgument = (argument, scopes) => {
+	const candidate = stripParenExpression(argument);
+	return isNodeOfType(candidate, "Identifier") && candidate.name === "undefined" && scopes.isGlobalReference(candidate) || isNodeOfType(candidate, "Literal") && candidate.value === null || isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "void";
+};
+const hasExplicitEqualityArgument = (argumentsList, equalityArgumentIndex, scopes) => {
+	const equalityArgument = argumentsList[equalityArgumentIndex];
+	if (!equalityArgument) return false;
+	if (isNodeOfType(equalityArgument, "SpreadElement")) return true;
+	return !isNullishEqualityArgument(equalityArgument, scopes);
+};
+const resolveZustandStoreCreation = (expression, scopes) => {
+	const candidate = stripParenExpression(expression);
+	if (!isNodeOfType(candidate, "CallExpression")) return null;
+	const factoryCall = resolveZustandStoreFactoryCall(candidate, scopes);
+	if (!factoryCall || factoryCall.factoryApiName !== "create" && factoryCall.factoryApiName !== "createWithEqualityFn") return null;
+	return {
+		creatorFunction: resolveZustandStoreCreator(candidate, scopes)?.creatorFunction ?? null,
+		hasDefaultEquality: factoryCall.factoryApiName === "createWithEqualityFn" && hasExplicitEqualityArgument(candidate.arguments, 1, scopes),
+		supportsEqualityArgument: factoryCall.factoryApiName === "createWithEqualityFn"
+	};
+};
+const resolveZustandBoundStore = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (!isNodeOfType(candidate, "Identifier")) return null;
+	const symbol = scopes.symbolFor(candidate);
+	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return null;
+	visitedSymbolIds.add(symbol.id);
+	return resolveZustandStoreCreation(symbol.initializer, scopes) ?? resolveZustandBoundStore(symbol.initializer, scopes, visitedSymbolIds);
+};
+const getZustandSelectorCall = (callExpression, scopes) => {
+	const apiBinding = resolveZustandApiBinding(callExpression.callee, scopes);
+	if (apiBinding?.apiName === "useStore" || apiBinding?.apiName === "useStoreWithEqualityFn") {
+		const selector = callExpression.arguments[1];
+		if (!selector || isNodeOfType(selector, "SpreadElement")) return null;
+		if (apiBinding.apiName === "useStoreWithEqualityFn" && hasExplicitEqualityArgument(callExpression.arguments, 2, scopes)) return null;
+		return {
+			selector,
+			storeCreatorFunction: null
+		};
+	}
+	const boundStore = resolveZustandBoundStore(callExpression.callee, scopes);
+	const selector = callExpression.arguments[0];
+	if (!boundStore || !selector || isNodeOfType(selector, "SpreadElement")) return null;
+	if (boundStore.hasDefaultEquality || boundStore.supportsEqualityArgument && hasExplicitEqualityArgument(callExpression.arguments, 1, scopes)) return null;
+	return {
+		selector,
+		storeCreatorFunction: boundStore.creatorFunction
+	};
+};
+const isUseShallowCall = (callExpression, scopes) => resolveZustandApiBinding(callExpression.callee, scopes)?.apiName === "useShallow";
+const resolveSelectorFunction = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isFunctionLike$1(candidate)) return candidate;
+	if (isNodeOfType(candidate, "CallExpression")) {
+		if (isUseShallowCall(candidate, scopes)) return null;
+		if (!isReactApiCall(candidate, "useCallback", scopes, {
+			allowGlobalReactNamespace: true,
+			resolveNamedAliases: true
+		})) return null;
+		const callback = candidate.arguments[0];
+		if (!callback || isNodeOfType(callback, "SpreadElement")) return null;
+		return resolveSelectorFunction(callback, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(candidate, "Identifier")) return null;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return null;
+	if (symbol.kind === "function" && isFunctionLike$1(symbol.declarationNode)) return symbol.declarationNode;
+	if (symbol.kind !== "const" || !symbol.initializer) return null;
+	visitedSymbolIds.add(symbol.id);
+	return resolveSelectorFunction(symbol.initializer, scopes, visitedSymbolIds);
+};
+const selectorStatePropertyPath = (expression, analysis, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = analysis.scopes.symbolFor(candidate);
+		const selectorParameter = isFunctionLike$1(analysis.selectorFunction) ? analysis.selectorFunction.params[0] : null;
+		if (selectorParameter && isNodeOfType(selectorParameter, "Identifier") && symbol?.id === analysis.scopes.symbolFor(selectorParameter)?.id) return [];
+		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return null;
+		visitedSymbolIds.add(symbol.id);
+		return selectorStatePropertyPath(symbol.initializer, analysis, visitedSymbolIds);
+	}
+	if (!isNodeOfType(candidate, "MemberExpression")) return null;
+	const propertyName = getStaticPropertyName(candidate);
+	const objectPath = selectorStatePropertyPath(candidate.object, analysis, visitedSymbolIds);
+	return propertyName && objectPath ? [...objectPath, propertyName] : null;
+};
+const freshResultFromAllocatingCall = (expression, analysis, visitedSymbolIds) => {
+	const callee = stripParenExpression(expression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	const methodName = getStaticPropertyName(callee);
+	if (!methodName) return null;
+	const receiver = stripParenExpression(callee.object);
+	if (isNodeOfType(receiver, "Identifier") && analysis.scopes.isGlobalReference(receiver)) {
+		const resultKind = ALLOCATING_NAMESPACE_METHOD_KINDS.get(receiver.name)?.get(methodName);
+		if (resultKind) return {
+			kind: resultKind,
+			node: expression
+		};
+		if (receiver.name === "Object" && methodName === "assign") {
+			const target = expression.arguments[0];
+			if (!target || isNodeOfType(target, "SpreadElement")) return null;
+			const freshTarget = resolveFreshSelectorResult(target, analysis, new Set(visitedSymbolIds));
+			return freshTarget ? {
+				kind: freshTarget.kind,
+				node: expression
+			} : null;
+		}
+	}
+	if (ALLOCATING_ARRAY_METHODS.has(methodName)) {
+		if (resolveFreshSelectorResult(receiver, analysis, new Set(visitedSymbolIds))?.kind === "array") return {
+			kind: "array",
+			node: expression
+		};
+		const receiverPath = selectorStatePropertyPath(receiver, analysis);
+		if (receiverPath && analysis.storeCreatorFunction && functionReturnsCollectionAtPath({
+			collectionKind: "array",
+			functionNode: analysis.storeCreatorFunction,
+			propertyPath: receiverPath,
+			scopes: analysis.scopes
+		})) return {
+			kind: "array",
+			node: expression
+		};
+		return null;
+	}
+	if (!SAME_REFERENCE_ARRAY_METHODS.has(methodName)) return null;
+	return resolveFreshSelectorResult(receiver, analysis, new Set(visitedSymbolIds)) ? {
+		kind: "array",
+		node: expression
+	} : null;
+};
+const resolveFreshSelectorResult = (expression, analysis, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const freshRenderValue = resolveFreshRenderValue(expression, analysis.scopes);
+	if (freshRenderValue?.kind === "array" || freshRenderValue?.kind === "function" || freshRenderValue?.kind === "instance" || freshRenderValue?.kind === "object") return {
+		kind: freshRenderValue.kind,
+		node: expression
+	};
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "CallExpression")) return freshResultFromAllocatingCall(candidate, analysis, visitedSymbolIds);
+	if (isNodeOfType(candidate, "ConditionalExpression")) return resolveFreshSelectorResult(candidate.consequent, analysis, new Set(visitedSymbolIds)) ?? resolveFreshSelectorResult(candidate.alternate, analysis, new Set(visitedSymbolIds));
+	if (isNodeOfType(candidate, "LogicalExpression")) {
+		if (candidate.operator === "&&") return resolveFreshSelectorResult(candidate.right, analysis, visitedSymbolIds);
+		return resolveFreshSelectorResult(candidate.left, analysis, new Set(visitedSymbolIds)) ?? resolveFreshSelectorResult(candidate.right, analysis, new Set(visitedSymbolIds));
+	}
+	if (isNodeOfType(candidate, "SequenceExpression")) {
+		const returnedExpression = candidate.expressions[candidate.expressions.length - 1];
+		return returnedExpression ? resolveFreshSelectorResult(returnedExpression, analysis, visitedSymbolIds) : null;
+	}
+	if (!isNodeOfType(candidate, "Identifier")) return null;
+	const symbol = analysis.scopes.symbolFor(candidate);
+	if (symbol?.kind !== "const" || symbol.scope.kind === "module" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return null;
+	visitedSymbolIds.add(symbol.id);
+	return resolveFreshSelectorResult(symbol.initializer, analysis, visitedSymbolIds);
+};
+const findFreshSelectorReturn = (selectorFunction, scopes, storeCreatorFunction) => {
+	if (!isFunctionLike$1(selectorFunction) || !selectorFunction.body) return null;
+	const analysis = {
+		scopes,
+		selectorFunction,
+		storeCreatorFunction
+	};
+	if (!isNodeOfType(selectorFunction.body, "BlockStatement")) return resolveFreshSelectorResult(selectorFunction.body, analysis);
+	let freshResult = null;
+	walkAst(selectorFunction.body, (candidate) => {
+		if (freshResult) return false;
+		if (candidate !== selectorFunction.body && isFunctionLike$1(candidate)) return false;
+		if (!isNodeOfType(candidate, "ReturnStatement") || !candidate.argument) return;
+		freshResult = resolveFreshSelectorResult(candidate.argument, analysis);
+		return freshResult ? false : void 0;
+	});
+	return freshResult;
+};
+const zustandNoFreshSelectorResult = defineRule({
+	id: "zustand-no-fresh-selector-result",
+	title: "Zustand selector returns a fresh value",
+	severity: "error",
+	category: "Performance",
+	requires: ["zustand", "zustand:5"],
+	recommendation: "Select a stable store field, split the selector, or wrap a collection selector with `useShallow`.",
+	create: (context) => ({ CallExpression(node) {
+		const selectorCall = getZustandSelectorCall(node, context.scopes);
+		if (!selectorCall) return;
+		const selectorFunction = resolveSelectorFunction(selectorCall.selector, context.scopes);
+		if (!selectorFunction) return;
+		const freshResult = findFreshSelectorReturn(selectorFunction, context.scopes, selectorCall.storeCreatorFunction);
+		if (!freshResult) return;
+		context.report({
+			node: freshResult.node,
+			message: "This Zustand selector creates a new reference whenever the store is read, so Object.is never sees a stable snapshot and Zustand v5 can repeatedly render or hit maximum update depth. Select a stable field or use `useShallow`."
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/state-and-effects/zustand-no-get-during-initialization.ts
+const findGetParameterIdentifier = (parameter) => {
+	if (!parameter) return null;
+	if (isNodeOfType(parameter, "Identifier")) return parameter;
+	if (isNodeOfType(parameter, "AssignmentPattern") && isNodeOfType(parameter.left, "Identifier")) return parameter.left;
+	return null;
+};
+const isGetParameterCall = (callExpression, getParameterSymbol, context) => {
+	const callee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	return resolveConstIdentifierAlias(callee, context.scopes)?.id === getParameterSymbol.id;
+};
+const reportEagerGetCalls = (creatorFunction, getParameterSymbol, context) => {
+	const visitedFunctions = /* @__PURE__ */ new Set();
+	const reportFunctionReads = (functionNode) => {
+		if (!isFunctionLike$1(functionNode) || functionNode.generator || visitedFunctions.has(functionNode)) return;
+		visitedFunctions.add(functionNode);
+		walkAst(functionNode, (node) => {
+			if (node !== functionNode && isFunctionLike$1(node)) return false;
+			if (!isNodeOfType(node, "CallExpression")) return;
+			if (isGetParameterCall(node, getParameterSymbol, context)) {
+				if (!canExecuteBeforeAsyncSuspension(node, functionNode, context)) return;
+				context.report({
+					node,
+					message: "`get()` runs before Zustand installs the initial state, so it returns `undefined` here."
+				});
+				return;
+			}
+			if (!canExecuteBeforeAsyncSuspension(node, functionNode, context)) return;
+			const calledFunction = resolveExactLocalFunction(node.callee, context.scopes);
+			if (!calledFunction || calledFunction === functionNode) return;
+			reportFunctionReads(calledFunction);
+		});
+	};
+	reportFunctionReads(creatorFunction);
+};
+const zustandNoGetDuringInitialization = defineRule({
+	id: "zustand-no-get-during-initialization",
+	title: "Zustand get() called during store initialization",
+	severity: "error",
+	category: "Correctness",
+	recommendation: "Move the read into a deferred store action or derive the initial value without calling `get()`.",
+	requires: ["zustand", "zustand:1"],
+	create: (context) => {
+		const creatorFunctions = /* @__PURE__ */ new Set();
+		return {
+			CallExpression(node) {
+				const creator = resolveZustandStoreCreator(node, context.scopes);
+				if (creator) creatorFunctions.add(creator.creatorFunction);
+			},
+			"Program:exit"() {
+				for (const creatorFunction of creatorFunctions) {
+					if (creatorFunction.generator) continue;
+					const parameterIdentifier = findGetParameterIdentifier(creatorFunction.params[1]);
+					const getParameterSymbol = parameterIdentifier ? context.scopes.symbolFor(parameterIdentifier) : null;
+					if (!getParameterSymbol) continue;
+					reportEagerGetCalls(creatorFunction, getParameterSymbol, context);
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/state-and-effects/zustand-no-whole-store-destructure.ts
+const BOUND_STORE_FACTORY_APIS = new Set(["create", "createWithEqualityFn"]);
+const VANILLA_STORE_FACTORY_APIS = new Set(["createStore"]);
+const isStoreFactoryValue = (rawValue, factoryApiNames, scopes) => {
+	const value = stripParenExpression(rawValue);
+	if (!isNodeOfType(value, "CallExpression")) return false;
+	const factoryCall = resolveZustandStoreFactoryCall(value, scopes);
+	return Boolean(factoryCall && factoryApiNames.has(factoryCall.factoryApiName));
+};
+const isStoreValue = (rawValue, factoryApiNames, scopes) => {
+	const value = stripParenExpression(rawValue);
+	if (isStoreFactoryValue(value, factoryApiNames, scopes)) return true;
+	if (!isNodeOfType(value, "Identifier")) return false;
+	const symbol = resolveConstIdentifierAlias(value, scopes);
+	return Boolean(symbol?.kind === "const" && symbol.initializer && isStoreFactoryValue(symbol.initializer, factoryApiNames, scopes));
+};
+const isBoundStoreCall = (node, scopes) => {
+	const callee = stripParenExpression(node.callee);
+	return isNodeOfType(callee, "Identifier") && isStoreValue(callee, BOUND_STORE_FACTORY_APIS, scopes);
+};
+const isVanillaStoreHookCall = (node, scopes) => {
+	if (node.arguments.length !== 1) return false;
+	const hook = resolveZustandApiBinding(node.callee, scopes);
+	if (hook?.apiName !== "useStore" && hook?.apiName !== "useStoreWithEqualityFn") return false;
+	return isStoreValue(node.arguments[0], VANILLA_STORE_FACTORY_APIS, scopes);
+};
+const isDirectReactRenderCall = (node, context) => {
+	const renderFunction = findRenderPhaseComponentOrHook(node, context.scopes);
+	if (!renderFunction || findEnclosingFunction$1(node) !== renderFunction) return false;
+	const displayName = componentOrHookDisplayNameForFunction(renderFunction);
+	return Boolean(displayName && (isReactHookName(displayName) || functionHasReactComponentEvidence(renderFunction, context.scopes, context.cfg)));
+};
+const zustandNoWholeStoreDestructure = defineRule({
+	id: "zustand-no-whole-store-destructure",
+	title: "Whole Zustand store subscribed during render",
+	severity: "warn",
+	requires: ["zustand:1"],
+	recommendation: "Pass a selector to the Zustand hook so this component rerenders only when the state it reads changes.",
+	create: (context) => ({ CallExpression(node) {
+		if (!isDirectReactRenderCall(node, context)) return;
+		if (!(node.arguments.length === 0 && isBoundStoreCall(node, context.scopes)) && !isVanillaStoreHookCall(node, context.scopes)) return;
+		context.report({
+			node,
+			message: "This hook subscribes to the whole Zustand store, so every store update rerenders this component. Pass a selector for the state it reads."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rule-registry.ts
 const reactDoctorRules = [
 	{
@@ -78494,6 +79046,42 @@ const reactDoctorRules = [
 			framework: "global",
 			category: "Maintainability"
 		}
+	},
+	{
+		key: "react-doctor/zustand-no-fresh-selector-result",
+		id: "zustand-no-fresh-selector-result",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...zustandNoFreshSelectorResult,
+			framework: "global",
+			category: "Performance",
+			requires: [...new Set(["react", ...zustandNoFreshSelectorResult.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/zustand-no-get-during-initialization",
+		id: "zustand-no-get-during-initialization",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...zustandNoGetDuringInitialization,
+			framework: "global",
+			category: "Bugs",
+			requires: [...new Set(["react", ...zustandNoGetDuringInitialization.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/zustand-no-whole-store-destructure",
+		id: "zustand-no-whole-store-destructure",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...zustandNoWholeStoreDestructure,
+			framework: "global",
+			category: "Bugs",
+			requires: [...new Set(["react", ...zustandNoWholeStoreDestructure.requires ?? []])]
+		}
 	}
 ];
 const ruleRegistry = Object.fromEntries(reactDoctorRules.map((rule) => [rule.id, rule.rule]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.8.1-dev.61bf03e",
+  "version": "0.8.1-dev.6fcd9c9",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",