fix trigge on preset mode cleared

baseline for https://github.com/esphome/esphome/pull/11483

esphome/components/api/api.proto

@@ -1000,9 +1000,9 @@ message ListEntitiesClimateResponse {
   bool supports_action = 12; // Deprecated: use feature_flags
   repeated ClimateFanMode supported_fan_modes = 13 [(container_pointer_no_template) = "climate::ClimateFanModeMask"];
   repeated ClimateSwingMode supported_swing_modes = 14 [(container_pointer_no_template) = "climate::ClimateSwingModeMask"];
-  repeated string supported_custom_fan_modes = 15 [(container_pointer_no_template) = "std::vector<const char *>"];
+  repeated string supported_custom_fan_modes = 15 [(container_pointer) = "std::vector"];
   repeated ClimatePreset supported_presets = 16 [(container_pointer_no_template) = "climate::ClimatePresetMask"];
-  repeated string supported_custom_presets = 17 [(container_pointer_no_template) = "std::vector<const char *>"];
+  repeated string supported_custom_presets = 17 [(container_pointer) = "std::vector"];
   bool disabled_by_default = 18;
   string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 20;

esphome/components/api/api_connection.cpp

@@ -410,8 +410,8 @@ uint16_t APIConnection::try_send_fan_state(EntityBase *entity, APIConnection *co
   }
   if (traits.supports_direction())
     msg.direction = static_cast<enums::FanDirection>(fan->direction);
-  if (traits.supports_preset_modes())
-    msg.set_preset_mode(StringRef(fan->preset_mode));
+  if (traits.supports_preset_modes() && fan->has_preset_mode())
+    msg.set_preset_mode(StringRef(fan->get_preset_mode()));
   return fill_and_encode_entity_state(fan, msg, FanStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -637,14 +637,14 @@ uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection
   }
   if (traits.get_supports_fan_modes() && climate->fan_mode.has_value())
     resp.fan_mode = static_cast<enums::ClimateFanMode>(climate->fan_mode.value());
-  if (!traits.get_supported_custom_fan_modes().empty() && climate->has_custom_fan_mode()) {
-    resp.set_custom_fan_mode(StringRef(climate->get_custom_fan_mode()));
+  if (!traits.get_supported_custom_fan_modes().empty() && climate->custom_fan_mode.has_value()) {
+    resp.set_custom_fan_mode(StringRef(climate->custom_fan_mode.value()));
   }
   if (traits.get_supports_presets() && climate->preset.has_value()) {
     resp.preset = static_cast<enums::ClimatePreset>(climate->preset.value());
   }
-  if (!traits.get_supported_custom_presets().empty() && climate->has_custom_preset()) {
-    resp.set_custom_preset(StringRef(climate->get_custom_preset()));
+  if (!traits.get_supported_custom_presets().empty() && climate->custom_preset.has_value()) {
+    resp.set_custom_preset(StringRef(climate->custom_preset.value()));
   }
   if (traits.get_supports_swing_modes())
     resp.swing_mode = static_cast<enums::ClimateSwingMode>(climate->swing_mode);
@@ -877,7 +877,7 @@ uint16_t APIConnection::try_send_select_state(EntityBase *entity, APIConnection
                                               bool is_single) {
   auto *select = static_cast<select::Select *>(entity);
   SelectStateResponse resp;
-  resp.set_state(StringRef(select->current_option()));
+  resp.set_state(StringRef(select->state));
   resp.missing_state = !select->has_state();
   return fill_and_encode_entity_state(select, resp, SelectStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }

esphome/components/api/api_pb2.cpp

@@ -1179,14 +1179,14 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   for (const auto &it : *this->supported_swing_modes) {
     buffer.encode_uint32(14, static_cast<uint32_t>(it), true);
   }
-  for (const char *it : *this->supported_custom_fan_modes) {
-    buffer.encode_string(15, it, strlen(it), true);
+  for (const auto &it : *this->supported_custom_fan_modes) {
+    buffer.encode_string(15, it, true);
   }
   for (const auto &it : *this->supported_presets) {
     buffer.encode_uint32(16, static_cast<uint32_t>(it), true);
   }
-  for (const char *it : *this->supported_custom_presets) {
-    buffer.encode_string(17, it, strlen(it), true);
+  for (const auto &it : *this->supported_custom_presets) {
+    buffer.encode_string(17, it, true);
   }
   buffer.encode_bool(18, this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
@@ -1229,8 +1229,8 @@ void ListEntitiesClimateResponse::calculate_size(ProtoSize &size) const {
     }
   }
   if (!this->supported_custom_fan_modes->empty()) {
-    for (const char *it : *this->supported_custom_fan_modes) {
-      size.add_length_force(1, strlen(it));
+    for (const auto &it : *this->supported_custom_fan_modes) {
+      size.add_length_force(1, it.size());
     }
   }
   if (!this->supported_presets->empty()) {
@@ -1239,8 +1239,8 @@ void ListEntitiesClimateResponse::calculate_size(ProtoSize &size) const {
     }
   }
   if (!this->supported_custom_presets->empty()) {
-    for (const char *it : *this->supported_custom_presets) {
-      size.add_length_force(2, strlen(it));
+    for (const auto &it : *this->supported_custom_presets) {
+      size.add_length_force(2, it.size());
     }
   }
   size.add_bool(2, this->disabled_by_default);

esphome/components/api/api_pb2.h

@@ -1384,9 +1384,9 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
   bool supports_action{false};
   const climate::ClimateFanModeMask *supported_fan_modes{};
   const climate::ClimateSwingModeMask *supported_swing_modes{};
-  const std::vector<const char *> *supported_custom_fan_modes{};
+  const std::vector<std::string> *supported_custom_fan_modes{};
   const climate::ClimatePresetMask *supported_presets{};
-  const std::vector<const char *> *supported_custom_presets{};
+  const std::vector<std::string> *supported_custom_presets{};
   float visual_current_temperature_step{0.0f};
   bool supports_current_humidity{false};
   bool supports_target_humidity{false};

esphome/components/bedjet/bedjet_const.h

@@ -100,6 +100,7 @@ enum BedjetCommand : uint8_t {
 static const uint8_t BEDJET_FAN_SPEED_COUNT = 20;
 
 static constexpr const char *const BEDJET_FAN_STEP_NAMES[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
+static const std::string BEDJET_FAN_STEP_NAME_STRINGS[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
 
 }  // namespace bedjet
 }  // namespace esphome

esphome/components/bedjet/climate/bedjet_climate.cpp

@@ -8,15 +8,15 @@ namespace bedjet {
 
 using namespace esphome::climate;
 
-static const char *bedjet_fan_step_to_fan_mode(const uint8_t fan_step) {
+static const std::string *bedjet_fan_step_to_fan_mode(const uint8_t fan_step) {
   if (fan_step < BEDJET_FAN_SPEED_COUNT)
-    return BEDJET_FAN_STEP_NAMES[fan_step];
+    return &BEDJET_FAN_STEP_NAME_STRINGS[fan_step];
   return nullptr;
 }
 
-static uint8_t bedjet_fan_speed_to_step(const char *fan_step_percent) {
+static uint8_t bedjet_fan_speed_to_step(const std::string &fan_step_percent) {
   for (int i = 0; i < BEDJET_FAN_SPEED_COUNT; i++) {
-    if (strcmp(BEDJET_FAN_STEP_NAMES[i], fan_step_percent) == 0) {
+    if (fan_step_percent == BEDJET_FAN_STEP_NAME_STRINGS[i]) {
       return i;
     }
   }
@@ -48,7 +48,7 @@ void BedJetClimate::dump_config() {
     ESP_LOGCONFIG(TAG, "   - %s", LOG_STR_ARG(climate_fan_mode_to_string(mode)));
   }
   for (const auto &mode : traits.get_supported_custom_fan_modes()) {
-    ESP_LOGCONFIG(TAG, "   - %s (c)", mode);
+    ESP_LOGCONFIG(TAG, "   - %s (c)", mode.c_str());
   }
 
   ESP_LOGCONFIG(TAG, "  Supported presets:");
@@ -56,7 +56,7 @@ void BedJetClimate::dump_config() {
     ESP_LOGCONFIG(TAG, "   - %s", LOG_STR_ARG(climate_preset_to_string(preset)));
   }
   for (const auto &preset : traits.get_supported_custom_presets()) {
-    ESP_LOGCONFIG(TAG, "   - %s (c)", preset);
+    ESP_LOGCONFIG(TAG, "   - %s (c)", preset.c_str());
   }
 }
 
@@ -79,7 +79,7 @@ void BedJetClimate::reset_state_() {
   this->target_temperature = NAN;
   this->current_temperature = NAN;
   this->preset.reset();
-  this->clear_custom_preset_();
+  this->custom_preset.reset();
   this->publish_state();
 }
 
@@ -120,7 +120,7 @@ void BedJetClimate::control(const ClimateCall &call) {
     if (button_result) {
       this->mode = mode;
       // We're using (custom) preset for Turbo, EXT HT, & M1-3 presets, so changing climate mode will clear those
-      this->clear_custom_preset_();
+      this->custom_preset.reset();
       this->preset.reset();
     }
   }
@@ -144,7 +144,8 @@ void BedJetClimate::control(const ClimateCall &call) {
 
       if (result) {
         this->mode = CLIMATE_MODE_HEAT;
-        this->set_preset_(CLIMATE_PRESET_BOOST);
+        this->preset = CLIMATE_PRESET_BOOST;
+        this->custom_preset.reset();
       }
     } else if (preset == CLIMATE_PRESET_NONE && this->preset.has_value()) {
       if (this->mode == CLIMATE_MODE_HEAT && this->preset == CLIMATE_PRESET_BOOST) {
@@ -152,7 +153,7 @@ void BedJetClimate::control(const ClimateCall &call) {
         result = this->parent_->send_button(heat_button(this->heating_mode_));
         if (result) {
           this->preset.reset();
-          this->clear_custom_preset_();
+          this->custom_preset.reset();
         }
       } else {
         ESP_LOGD(TAG, "Ignoring preset '%s' call; with current mode '%s' and preset '%s'",
@@ -163,27 +164,28 @@ void BedJetClimate::control(const ClimateCall &call) {
       ESP_LOGW(TAG, "Unsupported preset: %d", preset);
       return;
     }
-  } else if (call.has_custom_preset()) {
-    const char *preset = call.get_custom_preset();
+  } else if (call.get_custom_preset().has_value()) {
+    std::string preset = *call.get_custom_preset();
     bool result;
 
-    if (strcmp(preset, "M1") == 0) {
+    if (preset == "M1") {
       result = this->parent_->button_memory1();
-    } else if (strcmp(preset, "M2") == 0) {
+    } else if (preset == "M2") {
       result = this->parent_->button_memory2();
-    } else if (strcmp(preset, "M3") == 0) {
+    } else if (preset == "M3") {
       result = this->parent_->button_memory3();
-    } else if (strcmp(preset, "LTD HT") == 0) {
+    } else if (preset == "LTD HT") {
       result = this->parent_->button_heat();
-    } else if (strcmp(preset, "EXT HT") == 0) {
+    } else if (preset == "EXT HT") {
       result = this->parent_->button_ext_heat();
     } else {
-      ESP_LOGW(TAG, "Unsupported preset: %s", preset);
+      ESP_LOGW(TAG, "Unsupported preset: %s", preset.c_str());
       return;
     }
 
     if (result) {
-      this->set_custom_preset_(preset);
+      this->custom_preset = preset;
+      this->preset.reset();
     }
   }
 
@@ -205,16 +207,19 @@ void BedJetClimate::control(const ClimateCall &call) {
     }
 
     if (result) {
-      this->set_fan_mode_(fan_mode);
+      this->fan_mode = fan_mode;
+      this->custom_fan_mode.reset();
     }
-  } else if (call.has_custom_fan_mode()) {
-    const char *fan_mode = call.get_custom_fan_mode();
+  } else if (call.get_custom_fan_mode().has_value()) {
+    auto fan_mode = *call.get_custom_fan_mode();
     auto fan_index = bedjet_fan_speed_to_step(fan_mode);
     if (fan_index <= 19) {
-      ESP_LOGV(TAG, "[%s] Converted fan mode %s to bedjet fan step %d", this->get_name().c_str(), fan_mode, fan_index);
+      ESP_LOGV(TAG, "[%s] Converted fan mode %s to bedjet fan step %d", this->get_name().c_str(), fan_mode.c_str(),
+               fan_index);
       bool result = this->parent_->set_fan_index(fan_index);
       if (result) {
-        this->set_custom_fan_mode_(fan_mode);
+        this->custom_fan_mode = fan_mode;
+        this->fan_mode.reset();
       }
     }
   }
@@ -240,7 +245,7 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
 
   const auto *fan_mode_name = bedjet_fan_step_to_fan_mode(data->fan_step);
   if (fan_mode_name != nullptr) {
-    this->set_custom_fan_mode_(fan_mode_name);
+    this->custom_fan_mode = *fan_mode_name;
   }
 
   // TODO: Get biorhythm data to determine which preset (M1-3) is running, if any.
@@ -250,7 +255,7 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
       this->mode = CLIMATE_MODE_OFF;
       this->action = CLIMATE_ACTION_IDLE;
       this->fan_mode = CLIMATE_FAN_OFF;
-      this->clear_custom_preset_();
+      this->custom_preset.reset();
       this->preset.reset();
       break;
 
@@ -261,7 +266,7 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
       if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
         this->set_custom_preset_("LTD HT");
       } else {
-        this->clear_custom_preset_();
+        this->custom_preset.reset();
       }
       break;
 
@@ -270,7 +275,7 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
       this->action = CLIMATE_ACTION_HEATING;
       this->preset.reset();
       if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
-        this->clear_custom_preset_();
+        this->custom_preset.reset();
       } else {
         this->set_custom_preset_("EXT HT");
       }
@@ -279,19 +284,20 @@ void BedJetClimate::on_status(const BedjetStatusPacket *data) {
     case MODE_COOL:
       this->mode = CLIMATE_MODE_FAN_ONLY;
       this->action = CLIMATE_ACTION_COOLING;
-      this->clear_custom_preset_();
+      this->custom_preset.reset();
       this->preset.reset();
       break;
 
     case MODE_DRY:
       this->mode = CLIMATE_MODE_DRY;
       this->action = CLIMATE_ACTION_DRYING;
-      this->clear_custom_preset_();
+      this->custom_preset.reset();
       this->preset.reset();
       break;
 
     case MODE_TURBO:
-      this->set_preset_(CLIMATE_PRESET_BOOST);
+      this->preset = CLIMATE_PRESET_BOOST;
+      this->custom_preset.reset();
       this->mode = CLIMATE_MODE_HEAT;
       this->action = CLIMATE_ACTION_HEATING;
       break;

esphome/components/bedjet/climate/bedjet_climate.h

@@ -50,13 +50,21 @@ class BedJetClimate : public climate::Climate, public BedJetClient, public Polli
         // Climate doesn't have a "TURBO" mode, but we can use the BOOST preset instead.
         climate::CLIMATE_PRESET_BOOST,
     });
-    // String literals are stored in rodata and valid for program lifetime
     traits.set_supported_custom_presets({
-        this->heating_mode_ == HEAT_MODE_EXTENDED ? "LTD HT" : "EXT HT",
+        // We could fetch biodata from bedjet and set these names that way.
+        // But then we have to invert the lookup in order to send the right preset.
+        // For now, we can leave them as M1-3 to match the remote buttons.
+        // EXT HT added to match remote button.
+        "EXT HT",
         "M1",
         "M2",
         "M3",
     });
+    if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+      traits.add_supported_custom_preset("LTD HT");
+    } else {
+      traits.add_supported_custom_preset("EXT HT");
+    }
     traits.set_visual_min_temperature(19.0);
     traits.set_visual_max_temperature(43.0);
     traits.set_visual_temperature_step(1.0);

esphome/components/climate/climate.cpp

@@ -50,21 +50,21 @@ void ClimateCall::perform() {
     const LogString *mode_s = climate_mode_to_string(*this->mode_);
     ESP_LOGD(TAG, "  Mode: %s", LOG_STR_ARG(mode_s));
   }
-  if (this->custom_fan_mode_ != nullptr) {
+  if (this->custom_fan_mode_.has_value()) {
     this->fan_mode_.reset();
-    ESP_LOGD(TAG, " Custom Fan: %s", this->custom_fan_mode_);
+    ESP_LOGD(TAG, " Custom Fan: %s", this->custom_fan_mode_.value().c_str());
   }
   if (this->fan_mode_.has_value()) {
-    this->custom_fan_mode_ = nullptr;
+    this->custom_fan_mode_.reset();
     const LogString *fan_mode_s = climate_fan_mode_to_string(*this->fan_mode_);
     ESP_LOGD(TAG, "  Fan: %s", LOG_STR_ARG(fan_mode_s));
   }
-  if (this->custom_preset_ != nullptr) {
+  if (this->custom_preset_.has_value()) {
     this->preset_.reset();
-    ESP_LOGD(TAG, " Custom Preset: %s", this->custom_preset_);
+    ESP_LOGD(TAG, " Custom Preset: %s", this->custom_preset_.value().c_str());
   }
   if (this->preset_.has_value()) {
-    this->custom_preset_ = nullptr;
+    this->custom_preset_.reset();
     const LogString *preset_s = climate_preset_to_string(*this->preset_);
     ESP_LOGD(TAG, "  Preset: %s", LOG_STR_ARG(preset_s));
   }
@@ -96,10 +96,11 @@ void ClimateCall::validate_() {
       this->mode_.reset();
     }
   }
-  if (this->custom_fan_mode_ != nullptr) {
-    if (!traits.supports_custom_fan_mode(this->custom_fan_mode_)) {
-      ESP_LOGW(TAG, "  Fan Mode %s not supported", this->custom_fan_mode_);
-      this->custom_fan_mode_ = nullptr;
+  if (this->custom_fan_mode_.has_value()) {
+    auto custom_fan_mode = *this->custom_fan_mode_;
+    if (!traits.supports_custom_fan_mode(custom_fan_mode)) {
+      ESP_LOGW(TAG, "  Fan Mode %s not supported", custom_fan_mode.c_str());
+      this->custom_fan_mode_.reset();
     }
   } else if (this->fan_mode_.has_value()) {
     auto fan_mode = *this->fan_mode_;
@@ -108,10 +109,11 @@ void ClimateCall::validate_() {
       this->fan_mode_.reset();
     }
   }
-  if (this->custom_preset_ != nullptr) {
-    if (!traits.supports_custom_preset(this->custom_preset_)) {
-      ESP_LOGW(TAG, "  Preset %s not supported", this->custom_preset_);
-      this->custom_preset_ = nullptr;
+  if (this->custom_preset_.has_value()) {
+    auto custom_preset = *this->custom_preset_;
+    if (!traits.supports_custom_preset(custom_preset)) {
+      ESP_LOGW(TAG, "  Preset %s not supported", custom_preset.c_str());
+      this->custom_preset_.reset();
     }
   } else if (this->preset_.has_value()) {
     auto preset = *this->preset_;
@@ -184,29 +186,26 @@ ClimateCall &ClimateCall::set_mode(const std::string &mode) {
 
 ClimateCall &ClimateCall::set_fan_mode(ClimateFanMode fan_mode) {
   this->fan_mode_ = fan_mode;
-  this->custom_fan_mode_ = nullptr;
+  this->custom_fan_mode_.reset();
   return *this;
 }
 
-ClimateCall &ClimateCall::set_fan_mode(const char *custom_fan_mode) {
-  // Check if it's a standard enum mode first
+ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) {
   for (const auto &mode_entry : CLIMATE_FAN_MODES_BY_STR) {
-    if (str_equals_case_insensitive(custom_fan_mode, mode_entry.str)) {
-      return this->set_fan_mode(static_cast<ClimateFanMode>(mode_entry.value));
+    if (str_equals_case_insensitive(fan_mode, mode_entry.str)) {
+      this->set_fan_mode(static_cast<ClimateFanMode>(mode_entry.value));
+      return *this;
     }
   }
-  // Find the matching pointer from parent climate device
-  if (const char *mode_ptr = this->parent_->find_custom_fan_mode_(custom_fan_mode)) {
-    this->custom_fan_mode_ = mode_ptr;
+  if (this->parent_->get_traits().supports_custom_fan_mode(fan_mode)) {
+    this->custom_fan_mode_ = fan_mode;
     this->fan_mode_.reset();
-    return *this;
+  } else {
+    ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %s", this->parent_->get_name().c_str(), fan_mode.c_str());
   }
-  ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %s", this->parent_->get_name().c_str(), custom_fan_mode);
   return *this;
 }
 
-ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) { return this->set_fan_mode(fan_mode.c_str()); }
-
 ClimateCall &ClimateCall::set_fan_mode(optional<std::string> fan_mode) {
   if (fan_mode.has_value()) {
     this->set_fan_mode(fan_mode.value());
@@ -216,29 +215,26 @@ ClimateCall &ClimateCall::set_fan_mode(optional<std::string> fan_mode) {
 
 ClimateCall &ClimateCall::set_preset(ClimatePreset preset) {
   this->preset_ = preset;
-  this->custom_preset_ = nullptr;
+  this->custom_preset_.reset();
   return *this;
 }
 
-ClimateCall &ClimateCall::set_preset(const char *custom_preset) {
-  // Check if it's a standard enum preset first
+ClimateCall &ClimateCall::set_preset(const std::string &preset) {
   for (const auto &preset_entry : CLIMATE_PRESETS_BY_STR) {
-    if (str_equals_case_insensitive(custom_preset, preset_entry.str)) {
-      return this->set_preset(static_cast<ClimatePreset>(preset_entry.value));
+    if (str_equals_case_insensitive(preset, preset_entry.str)) {
+      this->set_preset(static_cast<ClimatePreset>(preset_entry.value));
+      return *this;
     }
   }
-  // Find the matching pointer from parent climate device
-  if (const char *preset_ptr = this->parent_->find_custom_preset_(custom_preset)) {
-    this->custom_preset_ = preset_ptr;
+  if (this->parent_->get_traits().supports_custom_preset(preset)) {
+    this->custom_preset_ = preset;
     this->preset_.reset();
-    return *this;
+  } else {
+    ESP_LOGW(TAG, "'%s' - Unrecognized preset %s", this->parent_->get_name().c_str(), preset.c_str());
   }
-  ESP_LOGW(TAG, "'%s' - Unrecognized preset %s", this->parent_->get_name().c_str(), custom_preset);
   return *this;
 }
 
-ClimateCall &ClimateCall::set_preset(const std::string &preset) { return this->set_preset(preset.c_str()); }
-
 ClimateCall &ClimateCall::set_preset(optional<std::string> preset) {
   if (preset.has_value()) {
     this->set_preset(preset.value());
@@ -291,6 +287,8 @@ const optional<ClimateMode> &ClimateCall::get_mode() const { return this->mode_;
 const optional<ClimateFanMode> &ClimateCall::get_fan_mode() const { return this->fan_mode_; }
 const optional<ClimateSwingMode> &ClimateCall::get_swing_mode() const { return this->swing_mode_; }
 const optional<ClimatePreset> &ClimateCall::get_preset() const { return this->preset_; }
+const optional<std::string> &ClimateCall::get_custom_fan_mode() const { return this->custom_fan_mode_; }
+const optional<std::string> &ClimateCall::get_custom_preset() const { return this->custom_preset_; }
 
 ClimateCall &ClimateCall::set_target_temperature_high(optional<float> target_temperature_high) {
   this->target_temperature_high_ = target_temperature_high;
@@ -319,13 +317,13 @@ ClimateCall &ClimateCall::set_mode(optional<ClimateMode> mode) {
 
 ClimateCall &ClimateCall::set_fan_mode(optional<ClimateFanMode> fan_mode) {
   this->fan_mode_ = fan_mode;
-  this->custom_fan_mode_ = nullptr;
+  this->custom_fan_mode_.reset();
   return *this;
 }
 
 ClimateCall &ClimateCall::set_preset(optional<ClimatePreset> preset) {
   this->preset_ = preset;
-  this->custom_preset_ = nullptr;
+  this->custom_preset_.reset();
   return *this;
 }
 
@@ -384,13 +382,13 @@ void Climate::save_state_() {
     state.uses_custom_fan_mode = false;
     state.fan_mode = this->fan_mode.value();
   }
-  if (!traits.get_supported_custom_fan_modes().empty() && this->has_custom_fan_mode()) {
+  if (!traits.get_supported_custom_fan_modes().empty() && custom_fan_mode.has_value()) {
     state.uses_custom_fan_mode = true;
     const auto &supported = traits.get_supported_custom_fan_modes();
     // std::vector maintains insertion order
     size_t i = 0;
-    for (const char *mode : supported) {
-      if (strcmp(mode, this->custom_fan_mode_) == 0) {
+    for (const auto &mode : supported) {
+      if (mode == custom_fan_mode) {
         state.custom_fan_mode = i;
         break;
       }
@@ -401,13 +399,13 @@ void Climate::save_state_() {
     state.uses_custom_preset = false;
     state.preset = this->preset.value();
   }
-  if (!traits.get_supported_custom_presets().empty() && this->has_custom_preset()) {
+  if (!traits.get_supported_custom_presets().empty() && custom_preset.has_value()) {
     state.uses_custom_preset = true;
     const auto &supported = traits.get_supported_custom_presets();
     // std::vector maintains insertion order
     size_t i = 0;
-    for (const char *preset : supported) {
-      if (strcmp(preset, this->custom_preset_) == 0) {
+    for (const auto &preset : supported) {
+      if (preset == custom_preset) {
         state.custom_preset = i;
         break;
       }
@@ -432,14 +430,14 @@ void Climate::publish_state() {
   if (traits.get_supports_fan_modes() && this->fan_mode.has_value()) {
     ESP_LOGD(TAG, "  Fan Mode: %s", LOG_STR_ARG(climate_fan_mode_to_string(this->fan_mode.value())));
   }
-  if (!traits.get_supported_custom_fan_modes().empty() && this->has_custom_fan_mode()) {
-    ESP_LOGD(TAG, "  Custom Fan Mode: %s", this->custom_fan_mode_);
+  if (!traits.get_supported_custom_fan_modes().empty() && this->custom_fan_mode.has_value()) {
+    ESP_LOGD(TAG, "  Custom Fan Mode: %s", this->custom_fan_mode.value().c_str());
   }
   if (traits.get_supports_presets() && this->preset.has_value()) {
     ESP_LOGD(TAG, "  Preset: %s", LOG_STR_ARG(climate_preset_to_string(this->preset.value())));
   }
-  if (!traits.get_supported_custom_presets().empty() && this->has_custom_preset()) {
-    ESP_LOGD(TAG, "  Custom Preset: %s", this->custom_preset_);
+  if (!traits.get_supported_custom_presets().empty() && this->custom_preset.has_value()) {
+    ESP_LOGD(TAG, "  Custom Preset: %s", this->custom_preset.value().c_str());
   }
   if (traits.get_supports_swing_modes()) {
     ESP_LOGD(TAG, "  Swing Mode: %s", LOG_STR_ARG(climate_swing_mode_to_string(this->swing_mode)));
@@ -529,7 +527,7 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   if (this->uses_custom_fan_mode) {
     if (this->custom_fan_mode < traits.get_supported_custom_fan_modes().size()) {
       call.fan_mode_.reset();
-      call.custom_fan_mode_ = traits.get_supported_custom_fan_modes()[this->custom_fan_mode];
+      call.custom_fan_mode_ = *std::next(traits.get_supported_custom_fan_modes().cbegin(), this->custom_fan_mode);
     }
   } else if (traits.supports_fan_mode(this->fan_mode)) {
     call.set_fan_mode(this->fan_mode);
@@ -537,7 +535,7 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   if (this->uses_custom_preset) {
     if (this->custom_preset < traits.get_supported_custom_presets().size()) {
       call.preset_.reset();
-      call.custom_preset_ = traits.get_supported_custom_presets()[this->custom_preset];
+      call.custom_preset_ = *std::next(traits.get_supported_custom_presets().cbegin(), this->custom_preset);
     }
   } else if (traits.supports_preset(this->preset)) {
     call.set_preset(this->preset);
@@ -564,20 +562,20 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   if (this->uses_custom_fan_mode) {
     if (this->custom_fan_mode < traits.get_supported_custom_fan_modes().size()) {
       climate->fan_mode.reset();
-      climate->custom_fan_mode_ = traits.get_supported_custom_fan_modes()[this->custom_fan_mode];
+      climate->custom_fan_mode = *std::next(traits.get_supported_custom_fan_modes().cbegin(), this->custom_fan_mode);
     }
   } else if (traits.supports_fan_mode(this->fan_mode)) {
     climate->fan_mode = this->fan_mode;
-    climate->clear_custom_fan_mode_();
+    climate->custom_fan_mode.reset();
   }
   if (this->uses_custom_preset) {
     if (this->custom_preset < traits.get_supported_custom_presets().size()) {
       climate->preset.reset();
-      climate->custom_preset_ = traits.get_supported_custom_presets()[this->custom_preset];
+      climate->custom_preset = *std::next(traits.get_supported_custom_presets().cbegin(), this->custom_preset);
     }
   } else if (traits.supports_preset(this->preset)) {
     climate->preset = this->preset;
-    climate->clear_custom_preset_();
+    climate->custom_preset.reset();
   }
   if (traits.supports_swing_mode(this->swing_mode)) {
     climate->swing_mode = this->swing_mode;
@@ -585,107 +583,28 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   climate->publish_state();
 }
 
-/** Template helper for setting primary modes (fan_mode, preset) with mutual exclusion.
- *
- * Climate devices have mutually exclusive mode pairs:
- *   - fan_mode (enum) vs custom_fan_mode_ (const char*)
- *   - preset (enum) vs custom_preset_ (const char*)
- *
- * Only one mode in each pair can be active at a time. This helper ensures setting a primary
- * mode automatically clears its corresponding custom mode.
- *
- * Example state transitions:
- *   Before: custom_fan_mode_="Turbo", fan_mode=nullopt
- *   Call:   set_fan_mode_(CLIMATE_FAN_HIGH)
- *   After:  custom_fan_mode_=nullptr,   fan_mode=CLIMATE_FAN_HIGH
- *
- * @param primary The primary mode optional (fan_mode or preset)
- * @param custom_ptr Reference to the custom mode pointer (custom_fan_mode_ or custom_preset_)
- * @param value The new primary mode value to set
- * @return true if state changed, false if already set to this value
- */
-template<typename T> bool set_primary_mode(optional<T> &primary, const char *&custom_ptr, T value) {
-  // Clear the custom mode (mutual exclusion)
-  bool changed = custom_ptr != nullptr;
-  custom_ptr = nullptr;
-  // Set the primary mode
-  if (changed || !primary.has_value() || primary.value() != value) {
-    primary = value;
-    return true;
+template<typename T1, typename T2> bool set_alternative(optional<T1> &dst, optional<T2> &alt, const T1 &src) {
+  bool is_changed = alt.has_value();
+  alt.reset();
+  if (is_changed || dst != src) {
+    dst = src;
+    is_changed = true;
   }
-  return false;
-}
-
-/** Template helper for setting custom modes (custom_fan_mode_, custom_preset_) with mutual exclusion.
- *
- * This helper ensures setting a custom mode automatically clears its corresponding primary mode.
- * It also validates that the custom mode exists in the device's supported modes (lifetime safety).
- *
- * Example state transitions:
- *   Before: fan_mode=CLIMATE_FAN_HIGH, custom_fan_mode_=nullptr
- *   Call:   set_custom_fan_mode_("Turbo")
- *   After:  fan_mode=nullopt,          custom_fan_mode_="Turbo" (pointer from traits)
- *
- * Lifetime Safety:
- *   - found_ptr must come from traits.find_custom_*_mode_()
- *   - Only pointers found in traits are stored, ensuring they remain valid
- *   - Prevents dangling pointers from temporary strings
- *
- * @param custom_ptr Reference to the custom mode pointer to set
- * @param primary The primary mode optional to clear
- * @param found_ptr The validated pointer from traits (nullptr if not found)
- * @param has_custom Whether a custom mode is currently active
- * @return true if state changed, false otherwise
- */
-template<typename T>
-bool set_custom_mode(const char *&custom_ptr, optional<T> &primary, const char *found_ptr, bool has_custom) {
-  if (found_ptr != nullptr) {
-    // Clear the primary mode (mutual exclusion)
-    bool changed = primary.has_value();
-    primary.reset();
-    // Set the custom mode (pointer is validated by caller from traits)
-    if (changed || custom_ptr != found_ptr) {
-      custom_ptr = found_ptr;
-      return true;
-    }
-    return false;
-  }
-  // Mode not found in supported modes, clear it if currently set
-  if (has_custom) {
-    custom_ptr = nullptr;
-    return true;
-  }
-  return false;
+  return is_changed;
 }
 
 bool Climate::set_fan_mode_(ClimateFanMode mode) {
-  return set_primary_mode(this->fan_mode, this->custom_fan_mode_, mode);
+  return set_alternative(this->fan_mode, this->custom_fan_mode, mode);
 }
 
-bool Climate::set_custom_fan_mode_(const char *mode) {
-  auto traits = this->get_traits();
-  return set_custom_mode<ClimateFanMode>(this->custom_fan_mode_, this->fan_mode, traits.find_custom_fan_mode_(mode),
-                                         this->has_custom_fan_mode());
+bool Climate::set_custom_fan_mode_(const std::string &mode) {
+  return set_alternative(this->custom_fan_mode, this->fan_mode, mode);
 }
 
-void Climate::clear_custom_fan_mode_() { this->custom_fan_mode_ = nullptr; }
+bool Climate::set_preset_(ClimatePreset preset) { return set_alternative(this->preset, this->custom_preset, preset); }
 
-bool Climate::set_preset_(ClimatePreset preset) { return set_primary_mode(this->preset, this->custom_preset_, preset); }
-
-bool Climate::set_custom_preset_(const char *preset) {
-  auto traits = this->get_traits();
-  return set_custom_mode<ClimatePreset>(this->custom_preset_, this->preset, traits.find_custom_preset_(preset),
-                                        this->has_custom_preset());
-}
-
-void Climate::clear_custom_preset_() { this->custom_preset_ = nullptr; }
-
-const char *Climate::find_custom_fan_mode_(const char *custom_fan_mode) {
-  return this->get_traits().find_custom_fan_mode_(custom_fan_mode);
-}
-
-const char *Climate::find_custom_preset_(const char *custom_preset) {
-  return this->get_traits().find_custom_preset_(custom_preset);
+bool Climate::set_custom_preset_(const std::string &preset) {
+  return set_alternative(this->custom_preset, this->preset, preset);
 }
 
 void Climate::dump_traits_(const char *tag) {
@@ -737,8 +656,8 @@ void Climate::dump_traits_(const char *tag) {
   }
   if (!traits.get_supported_custom_fan_modes().empty()) {
     ESP_LOGCONFIG(tag, "  Supported custom fan modes:");
-    for (const char *s : traits.get_supported_custom_fan_modes())
-      ESP_LOGCONFIG(tag, "  - %s", s);
+    for (const std::string &s : traits.get_supported_custom_fan_modes())
+      ESP_LOGCONFIG(tag, "  - %s", s.c_str());
   }
   if (!traits.get_supported_presets().empty()) {
     ESP_LOGCONFIG(tag, "  Supported presets:");
@@ -747,8 +666,8 @@ void Climate::dump_traits_(const char *tag) {
   }
   if (!traits.get_supported_custom_presets().empty()) {
     ESP_LOGCONFIG(tag, "  Supported custom presets:");
-    for (const char *s : traits.get_supported_custom_presets())
-      ESP_LOGCONFIG(tag, "  - %s", s);
+    for (const std::string &s : traits.get_supported_custom_presets())
+      ESP_LOGCONFIG(tag, "  - %s", s.c_str());
   }
   if (!traits.get_supported_swing_modes().empty()) {
     ESP_LOGCONFIG(tag, "  Supported swing modes:");

esphome/components/climate/climate.h

@@ -77,8 +77,6 @@ class ClimateCall {
   ClimateCall &set_fan_mode(const std::string &fan_mode);
   /// Set the fan mode of the climate device based on a string.
   ClimateCall &set_fan_mode(optional<std::string> fan_mode);
-  /// Set the custom fan mode of the climate device.
-  ClimateCall &set_fan_mode(const char *custom_fan_mode);
   /// Set the swing mode of the climate device.
   ClimateCall &set_swing_mode(ClimateSwingMode swing_mode);
   /// Set the swing mode of the climate device.
@@ -93,8 +91,6 @@ class ClimateCall {
   ClimateCall &set_preset(const std::string &preset);
   /// Set the preset of the climate device based on a string.
   ClimateCall &set_preset(optional<std::string> preset);
-  /// Set the custom preset of the climate device.
-  ClimateCall &set_preset(const char *custom_preset);
 
   void perform();
 
@@ -107,10 +103,8 @@ class ClimateCall {
   const optional<ClimateFanMode> &get_fan_mode() const;
   const optional<ClimateSwingMode> &get_swing_mode() const;
   const optional<ClimatePreset> &get_preset() const;
-  const char *get_custom_fan_mode() const { return this->custom_fan_mode_; }
-  const char *get_custom_preset() const { return this->custom_preset_; }
-  bool has_custom_fan_mode() const { return this->custom_fan_mode_ != nullptr; }
-  bool has_custom_preset() const { return this->custom_preset_ != nullptr; }
+  const optional<std::string> &get_custom_fan_mode() const;
+  const optional<std::string> &get_custom_preset() const;
 
  protected:
   void validate_();
@@ -124,10 +118,8 @@ class ClimateCall {
   optional<ClimateFanMode> fan_mode_;
   optional<ClimateSwingMode> swing_mode_;
   optional<ClimatePreset> preset_;
-
- private:
-  const char *custom_fan_mode_{nullptr};
-  const char *custom_preset_{nullptr};
+  optional<std::string> custom_fan_mode_;
+  optional<std::string> custom_preset_;
 };
 
 /// Struct used to save the state of the climate device in restore memory.
@@ -220,12 +212,6 @@ class Climate : public EntityBase {
   void set_visual_min_humidity_override(float visual_min_humidity_override);
   void set_visual_max_humidity_override(float visual_max_humidity_override);
 
-  /// Check if a custom fan mode is currently active.
-  bool has_custom_fan_mode() const { return this->custom_fan_mode_ != nullptr; }
-
-  /// Check if a custom preset is currently active.
-  bool has_custom_preset() const { return this->custom_preset_ != nullptr; }
-
   /// The current temperature of the climate device, as reported from the integration.
   float current_temperature{NAN};
 
@@ -252,6 +238,12 @@ class Climate : public EntityBase {
   /// The active preset of the climate device.
   optional<ClimatePreset> preset;
 
+  /// The active custom fan mode of the climate device.
+  optional<std::string> custom_fan_mode;
+
+  /// The active custom preset mode of the climate device.
+  optional<std::string> custom_preset;
+
   /// The active mode of the climate device.
   ClimateMode mode{CLIMATE_MODE_OFF};
 
@@ -261,37 +253,20 @@ class Climate : public EntityBase {
   /// The active swing mode of the climate device.
   ClimateSwingMode swing_mode{CLIMATE_SWING_OFF};
 
-  /// Get the active custom fan mode (read-only access).
-  const char *get_custom_fan_mode() const { return this->custom_fan_mode_; }
-
-  /// Get the active custom preset (read-only access).
-  const char *get_custom_preset() const { return this->custom_preset_; }
-
  protected:
   friend ClimateCall;
-  friend struct ClimateDeviceRestoreState;
 
   /// Set fan mode. Reset custom fan mode. Return true if fan mode has been changed.
   bool set_fan_mode_(ClimateFanMode mode);
 
   /// Set custom fan mode. Reset primary fan mode. Return true if fan mode has been changed.
-  bool set_custom_fan_mode_(const char *mode);
-  /// Clear custom fan mode.
-  void clear_custom_fan_mode_();
+  bool set_custom_fan_mode_(const std::string &mode);
 
   /// Set preset. Reset custom preset. Return true if preset has been changed.
   bool set_preset_(ClimatePreset preset);
 
   /// Set custom preset. Reset primary preset. Return true if preset has been changed.
-  bool set_custom_preset_(const char *preset);
-  /// Clear custom preset.
-  void clear_custom_preset_();
-
-  /// Find and return the matching custom fan mode pointer from traits, or nullptr if not found.
-  const char *find_custom_fan_mode_(const char *custom_fan_mode);
-
-  /// Find and return the matching custom preset pointer from traits, or nullptr if not found.
-  const char *find_custom_preset_(const char *custom_preset);
+  bool set_custom_preset_(const std::string &preset);
 
   /** Get the default traits of this climate device.
    *
@@ -328,21 +303,6 @@ class Climate : public EntityBase {
   optional<float> visual_current_temperature_step_override_{};
   optional<float> visual_min_humidity_override_{};
   optional<float> visual_max_humidity_override_{};
-
- private:
-  /** The active custom fan mode (private - enforces use of safe setters).
-   *
-   * Points to an entry in traits.supported_custom_fan_modes_ or nullptr.
-   * Use get_custom_fan_mode() to read, set_custom_fan_mode_() to modify.
-   */
-  const char *custom_fan_mode_{nullptr};
-
-  /** The active custom preset (private - enforces use of safe setters).
-   *
-   * Points to an entry in traits.supported_custom_presets_ or nullptr.
-   * Use get_custom_preset() to read, set_custom_preset_() to modify.
-   */
-  const char *custom_preset_{nullptr};
 };
 
 }  // namespace climate

esphome/components/climate/climate_traits.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <cstring>
 #include <vector>
 #include "climate_mode.h"
 #include "esphome/core/finite_set_mask.h"
@@ -19,25 +18,16 @@ using ClimateSwingModeMask =
     FiniteSetMask<ClimateSwingMode, DefaultBitPolicy<ClimateSwingMode, CLIMATE_SWING_HORIZONTAL + 1>>;
 using ClimatePresetMask = FiniteSetMask<ClimatePreset, DefaultBitPolicy<ClimatePreset, CLIMATE_PRESET_ACTIVITY + 1>>;
 
-// Lightweight linear search for small vectors (1-20 items) of const char* pointers
+// Lightweight linear search for small vectors (1-20 items)
 // Avoids std::find template overhead
-inline bool vector_contains(const std::vector<const char *> &vec, const char *value) {
-  for (const char *item : vec) {
-    if (strcmp(item, value) == 0)
+template<typename T> inline bool vector_contains(const std::vector<T> &vec, const T &value) {
+  for (const auto &item : vec) {
+    if (item == value)
       return true;
   }
   return false;
 }
 
-// Find and return matching pointer from vector, or nullptr if not found
-inline const char *vector_find(const std::vector<const char *> &vec, const char *value) {
-  for (const char *item : vec) {
-    if (strcmp(item, value) == 0)
-      return item;
-  }
-  return nullptr;
-}
-
 /** This class contains all static data for climate devices.
  *
  * All climate devices must support these features:
@@ -65,11 +55,7 @@ inline const char *vector_find(const std::vector<const char *> &vec, const char
  *  - temperature step - the step with which to increase/decrease target temperature.
  *     This also affects with how many decimal places the temperature is shown
  */
-class Climate;  // Forward declaration
-
 class ClimateTraits {
-  friend class Climate;  // Allow Climate to access protected find methods
-
  public:
   /// Get/set feature flags (see ClimateFeatures enum in climate_mode.h)
   uint32_t get_feature_flags() const { return this->feature_flags_; }
@@ -142,60 +128,46 @@ class ClimateTraits {
 
   void set_supported_fan_modes(ClimateFanModeMask modes) { this->supported_fan_modes_ = modes; }
   void add_supported_fan_mode(ClimateFanMode mode) { this->supported_fan_modes_.insert(mode); }
+  void add_supported_custom_fan_mode(const std::string &mode) { this->supported_custom_fan_modes_.push_back(mode); }
   bool supports_fan_mode(ClimateFanMode fan_mode) const { return this->supported_fan_modes_.count(fan_mode); }
   bool get_supports_fan_modes() const {
     return !this->supported_fan_modes_.empty() || !this->supported_custom_fan_modes_.empty();
   }
   const ClimateFanModeMask &get_supported_fan_modes() const { return this->supported_fan_modes_; }
 
-  void set_supported_custom_fan_modes(std::initializer_list<const char *> modes) {
-    this->supported_custom_fan_modes_ = modes;
+  void set_supported_custom_fan_modes(std::vector<std::string> supported_custom_fan_modes) {
+    this->supported_custom_fan_modes_ = std::move(supported_custom_fan_modes);
   }
-  void set_supported_custom_fan_modes(const std::vector<const char *> &modes) {
+  void set_supported_custom_fan_modes(std::initializer_list<std::string> modes) {
     this->supported_custom_fan_modes_ = modes;
   }
   template<size_t N> void set_supported_custom_fan_modes(const char *const (&modes)[N]) {
     this->supported_custom_fan_modes_.assign(modes, modes + N);
   }
-
-  // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
-  void set_supported_custom_fan_modes(const std::vector<std::string> &modes) = delete;
-  void set_supported_custom_fan_modes(std::initializer_list<std::string> modes) = delete;
-
-  const std::vector<const char *> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
-  bool supports_custom_fan_mode(const char *custom_fan_mode) const {
-    return vector_contains(this->supported_custom_fan_modes_, custom_fan_mode);
-  }
+  const std::vector<std::string> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
   bool supports_custom_fan_mode(const std::string &custom_fan_mode) const {
-    return this->supports_custom_fan_mode(custom_fan_mode.c_str());
+    return vector_contains(this->supported_custom_fan_modes_, custom_fan_mode);
   }
 
   void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
   void add_supported_preset(ClimatePreset preset) { this->supported_presets_.insert(preset); }
+  void add_supported_custom_preset(const std::string &preset) { this->supported_custom_presets_.push_back(preset); }
   bool supports_preset(ClimatePreset preset) const { return this->supported_presets_.count(preset); }
   bool get_supports_presets() const { return !this->supported_presets_.empty(); }
   const ClimatePresetMask &get_supported_presets() const { return this->supported_presets_; }
 
-  void set_supported_custom_presets(std::initializer_list<const char *> presets) {
-    this->supported_custom_presets_ = presets;
+  void set_supported_custom_presets(std::vector<std::string> supported_custom_presets) {
+    this->supported_custom_presets_ = std::move(supported_custom_presets);
   }
-  void set_supported_custom_presets(const std::vector<const char *> &presets) {
+  void set_supported_custom_presets(std::initializer_list<std::string> presets) {
     this->supported_custom_presets_ = presets;
   }
   template<size_t N> void set_supported_custom_presets(const char *const (&presets)[N]) {
     this->supported_custom_presets_.assign(presets, presets + N);
   }
-
-  // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
-  void set_supported_custom_presets(const std::vector<std::string> &presets) = delete;
-  void set_supported_custom_presets(std::initializer_list<std::string> presets) = delete;
-
-  const std::vector<const char *> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
-  bool supports_custom_preset(const char *custom_preset) const {
-    return vector_contains(this->supported_custom_presets_, custom_preset);
-  }
+  const std::vector<std::string> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
   bool supports_custom_preset(const std::string &custom_preset) const {
-    return this->supports_custom_preset(custom_preset.c_str());
+    return vector_contains(this->supported_custom_presets_, custom_preset);
   }
 
   void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
@@ -255,18 +227,6 @@ class ClimateTraits {
     }
   }
 
-  /// Find and return the matching custom fan mode pointer from supported modes, or nullptr if not found
-  /// This is protected as it's an implementation detail - use Climate::find_custom_fan_mode_() instead
-  const char *find_custom_fan_mode_(const char *custom_fan_mode) const {
-    return vector_find(this->supported_custom_fan_modes_, custom_fan_mode);
-  }
-
-  /// Find and return the matching custom preset pointer from supported presets, or nullptr if not found
-  /// This is protected as it's an implementation detail - use Climate::find_custom_preset_() instead
-  const char *find_custom_preset_(const char *custom_preset) const {
-    return vector_find(this->supported_custom_presets_, custom_preset);
-  }
-
   uint32_t feature_flags_{0};
   float visual_min_temperature_{10};
   float visual_max_temperature_{30};
@@ -279,17 +239,8 @@ class ClimateTraits {
   climate::ClimateFanModeMask supported_fan_modes_;
   climate::ClimateSwingModeMask supported_swing_modes_;
   climate::ClimatePresetMask supported_presets_;
-
-  /** Custom mode storage using const char* pointers to eliminate std::string overhead.
-   *
-   * Pointers must remain valid for the ClimateTraits lifetime. Safe patterns:
-   *  - String literals: set_supported_custom_fan_modes({"Turbo", "Silent"})
-   *  - Static const data: static const char* MODE = "Eco";
-   *
-   * Climate class setters validate pointers are from these vectors before storing.
-   */
-  std::vector<const char *> supported_custom_fan_modes_;
-  std::vector<const char *> supported_custom_presets_;
+  std::vector<std::string> supported_custom_fan_modes_;
+  std::vector<std::string> supported_custom_presets_;
 };
 
 }  // namespace climate

esphome/components/copy/fan/copy_fan.cpp

@@ -12,7 +12,7 @@ void CopyFan::setup() {
     this->oscillating = source_->oscillating;
     this->speed = source_->speed;
     this->direction = source_->direction;
-    this->preset_mode = source_->preset_mode;
+    this->set_preset_mode_(source_->get_preset_mode());
     this->publish_state();
   });
 
@@ -20,7 +20,7 @@ void CopyFan::setup() {
   this->oscillating = source_->oscillating;
   this->speed = source_->speed;
   this->direction = source_->direction;
-  this->preset_mode = source_->preset_mode;
+  this->set_preset_mode_(source_->get_preset_mode());
   this->publish_state();
 }
 
@@ -49,7 +49,7 @@ void CopyFan::control(const fan::FanCall &call) {
     call2.set_speed(*call.get_speed());
   if (call.get_direction().has_value())
     call2.set_direction(*call.get_direction());
-  if (!call.get_preset_mode().empty())
+  if (call.has_preset_mode())
     call2.set_preset_mode(call.get_preset_mode());
   call2.perform();
 }

esphome/components/copy/select/copy_select.cpp

@@ -7,19 +7,19 @@ namespace copy {
 static const char *const TAG = "copy.select";
 
 void CopySelect::setup() {
-  source_->add_on_state_callback([this](const std::string &value, size_t index) { this->publish_state(index); });
+  source_->add_on_state_callback([this](const std::string &value, size_t index) { this->publish_state(value); });
 
   traits.set_options(source_->traits.get_options());
 
   if (source_->has_state())
-    this->publish_state(source_->active_index().value());
+    this->publish_state(source_->state);
 }
 
 void CopySelect::dump_config() { LOG_SELECT("", "Copy Select", this); }
 
-void CopySelect::control(size_t index) {
+void CopySelect::control(const std::string &value) {
   auto call = source_->make_call();
-  call.set_index(index);
+  call.set_option(value);
   call.perform();
 }
 

esphome/components/copy/select/copy_select.h

@@ -13,7 +13,7 @@ class CopySelect : public select::Select, public Component {
   void dump_config() override;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 
   select::Select *source_;
 };

esphome/components/debug/debug_zephyr.cpp

@@ -8,7 +8,8 @@
 
 #define BOOTLOADER_VERSION_REGISTER NRF_TIMER2->CC[0]
 
-namespace esphome::debug {
+namespace esphome {
+namespace debug {
 
 static const char *const TAG = "debug";
 constexpr std::uintptr_t MBR_PARAM_PAGE_ADDR = 0xFFC;
@@ -280,18 +281,14 @@ void DebugComponent::get_device_info_(std::string &device_info) {
            NRF_FICR->INFO.VARIANT & 0xFF, package(NRF_FICR->INFO.PACKAGE));
   ESP_LOGD(TAG, "RAM: %ukB, Flash: %ukB, production test: %sdone", NRF_FICR->INFO.RAM, NRF_FICR->INFO.FLASH,
            (NRF_FICR->PRODTEST[0] == 0xBB42319F ? "" : "not "));
-  bool n_reset_enabled = NRF_UICR->PSELRESET[0] == NRF_UICR->PSELRESET[1] &&
-                         (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_CONNECT_Msk) == UICR_PSELRESET_CONNECT_Connected
-                                                                                      << UICR_PSELRESET_CONNECT_Pos;
   ESP_LOGD(
       TAG, "GPIO as NFC pins: %s, GPIO as nRESET pin: %s",
       YESNO((NRF_UICR->NFCPINS & UICR_NFCPINS_PROTECT_Msk) == (UICR_NFCPINS_PROTECT_NFC << UICR_NFCPINS_PROTECT_Pos)),
-      YESNO(n_reset_enabled));
-  if (n_reset_enabled) {
-    uint8_t port = (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_PORT_Msk) >> UICR_PSELRESET_PORT_Pos;
-    uint8_t pin = (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_PIN_Msk) >> UICR_PSELRESET_PIN_Pos;
-    ESP_LOGD(TAG, "nRESET port P%u.%02u", port, pin);
-  }
+      YESNO(((NRF_UICR->PSELRESET[0] & UICR_PSELRESET_CONNECT_Msk) !=
+             (UICR_PSELRESET_CONNECT_Connected << UICR_PSELRESET_CONNECT_Pos)) ||
+            ((NRF_UICR->PSELRESET[1] & UICR_PSELRESET_CONNECT_Msk) !=
+             (UICR_PSELRESET_CONNECT_Connected << UICR_PSELRESET_CONNECT_Pos))));
+
 #ifdef USE_BOOTLOADER_MCUBOOT
   ESP_LOGD(TAG, "bootloader: mcuboot");
 #else
@@ -325,22 +322,10 @@ void DebugComponent::get_device_info_(std::string &device_info) {
 #endif
   }
 #endif
-  auto uicr = [](volatile uint32_t *data, uint8_t size) {
-    std::string res;
-    char buf[sizeof(uint32_t) * 2 + 1];
-    for (size_t i = 0; i < size; i++) {
-      if (i > 0) {
-        res += ' ';
-      }
-      res += format_hex_pretty<uint32_t>(data[i], '\0', false);
-    }
-    return res;
-  };
-  ESP_LOGD(TAG, "NRFFW %s", uicr(NRF_UICR->NRFFW, 13).c_str());
-  ESP_LOGD(TAG, "NRFHW %s", uicr(NRF_UICR->NRFHW, 12).c_str());
 }
 
 void DebugComponent::update_platform_() {}
 
-}  // namespace esphome::debug
+}  // namespace debug
+}  // namespace esphome
 #endif

esphome/components/demo/demo_climate.h

@@ -28,16 +28,16 @@ class DemoClimate : public climate::Climate, public Component {
         this->mode = climate::CLIMATE_MODE_AUTO;
         this->action = climate::CLIMATE_ACTION_COOLING;
         this->fan_mode = climate::CLIMATE_FAN_HIGH;
-        this->set_custom_preset_("My Preset");
+        this->custom_preset = {"My Preset"};
         break;
       case DemoClimateType::TYPE_3:
         this->current_temperature = 21.5;
         this->target_temperature_low = 21.0;
         this->target_temperature_high = 22.5;
         this->mode = climate::CLIMATE_MODE_HEAT_COOL;
-        this->set_custom_fan_mode_("Auto Low");
+        this->custom_fan_mode = {"Auto Low"};
         this->swing_mode = climate::CLIMATE_SWING_HORIZONTAL;
-        this->set_preset_(climate::CLIMATE_PRESET_AWAY);
+        this->preset = climate::CLIMATE_PRESET_AWAY;
         break;
     }
     this->publish_state();
@@ -58,19 +58,23 @@ class DemoClimate : public climate::Climate, public Component {
       this->target_temperature_high = *call.get_target_temperature_high();
     }
     if (call.get_fan_mode().has_value()) {
-      this->set_fan_mode_(*call.get_fan_mode());
+      this->fan_mode = *call.get_fan_mode();
+      this->custom_fan_mode.reset();
     }
     if (call.get_swing_mode().has_value()) {
       this->swing_mode = *call.get_swing_mode();
     }
-    if (call.has_custom_fan_mode()) {
-      this->set_custom_fan_mode_(call.get_custom_fan_mode());
+    if (call.get_custom_fan_mode().has_value()) {
+      this->custom_fan_mode = *call.get_custom_fan_mode();
+      this->fan_mode.reset();
     }
     if (call.get_preset().has_value()) {
-      this->set_preset_(*call.get_preset());
+      this->preset = *call.get_preset();
+      this->custom_preset.reset();
     }
-    if (call.has_custom_preset()) {
-      this->set_custom_preset_(call.get_custom_preset());
+    if (call.get_custom_preset().has_value()) {
+      this->custom_preset = *call.get_custom_preset();
+      this->preset.reset();
     }
     this->publish_state();
   }

esphome/components/demo/demo_select.h

@@ -8,7 +8,7 @@ namespace demo {
 
 class DemoSelect : public select::Select, public Component {
  protected:
-  void control(size_t index) override { this->publish_state(index); }
+  void control(const std::string &value) override { this->publish_state(value); }
 };
 
 }  // namespace demo

esphome/components/display_menu_base/menu_item.cpp

@@ -42,7 +42,7 @@ std::string MenuItemSelect::get_value_text() const {
     result = this->value_getter_.value()(this);
   } else {
     if (this->select_var_ != nullptr) {
-      result = this->select_var_->current_option();
+      result = this->select_var_->state;
     }
   }
 

esphome/components/es8388/select/adc_input_mic_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace es8388 {
 
-void ADCInputMicSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_adc_input_mic(static_cast<AdcInputMicLine>(index));
+void ADCInputMicSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_adc_input_mic(static_cast<AdcInputMicLine>(this->index_of(value).value()));
 }
 
 }  // namespace es8388

esphome/components/es8388/select/adc_input_mic_select.h

@@ -8,7 +8,7 @@ namespace es8388 {
 
 class ADCInputMicSelect : public select::Select, public Parented<ES8388> {
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace es8388

esphome/components/es8388/select/dac_output_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace es8388 {
 
-void DacOutputSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_dac_output(static_cast<DacOutputLine>(index));
+void DacOutputSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_dac_output(static_cast<DacOutputLine>(this->index_of(value).value()));
 }
 
 }  // namespace es8388

esphome/components/es8388/select/dac_output_select.h

@@ -8,7 +8,7 @@ namespace es8388 {
 
 class DacOutputSelect : public select::Select, public Parented<ES8388> {
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace es8388

esphome/components/esp32_ble/ble.cpp

@@ -581,17 +581,9 @@ void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_pa
     GAP_ADV_COMPLETE_EVENTS:
     // Connection events - used by ble_client
     case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT:
-      enqueue_ble_event(event, param);
-      return;
-
     // Security events - used by ble_client and bluetooth_proxy
-    // These are rare but interactive (pairing/bonding), so notify immediately
     GAP_SECURITY_EVENTS:
       enqueue_ble_event(event, param);
-      // Wake up main loop to process security event immediately
-#ifdef USE_SOCKET_SELECT_SUPPORT
-      global_ble->notify_main_loop_();
-#endif
       return;
 
     // Ignore these GAP events as they are not relevant for our use case

esphome/components/fan/automation.h

@@ -212,18 +212,19 @@ class FanPresetSetTrigger : public Trigger<std::string> {
  public:
   FanPresetSetTrigger(Fan *state) {
     state->add_on_state_callback([this, state]() {
-      auto preset_mode = state->preset_mode;
+      const auto *preset_mode = state->get_preset_mode();
       auto should_trigger = preset_mode != this->last_preset_mode_;
       this->last_preset_mode_ = preset_mode;
       if (should_trigger) {
-        this->trigger(preset_mode);
+        // Trigger with empty string when nullptr to maintain backward compatibility
+        this->trigger(preset_mode != nullptr ? preset_mode : "");
       }
     });
-    this->last_preset_mode_ = state->preset_mode;
+    this->last_preset_mode_ = state->get_preset_mode();
   }
 
  protected:
-  std::string last_preset_mode_;
+  const char *last_preset_mode_{nullptr};
 };
 
 }  // namespace fan

esphome/components/fan/fan.cpp

@@ -17,6 +17,27 @@ const LogString *fan_direction_to_string(FanDirection direction) {
   }
 }
 
+FanCall &FanCall::set_preset_mode(const std::string &preset_mode) { return this->set_preset_mode(preset_mode.c_str()); }
+
+FanCall &FanCall::set_preset_mode(const char *preset_mode) {
+  if (preset_mode == nullptr || strlen(preset_mode) == 0) {
+    this->preset_mode_ = nullptr;
+    return *this;
+  }
+
+  // Find and validate pointer from traits immediately
+  auto traits = this->parent_.get_traits();
+  const char *validated_mode = traits.find_preset_mode(preset_mode);
+  if (validated_mode != nullptr) {
+    this->preset_mode_ = validated_mode;  // Store pointer from traits
+  } else {
+    // Preset mode not found in traits - log warning and don't set
+    ESP_LOGW(TAG, "%s: Preset mode '%s' not supported", this->parent_.get_name().c_str(), preset_mode);
+    this->preset_mode_ = nullptr;
+  }
+  return *this;
+}
+
 void FanCall::perform() {
   ESP_LOGD(TAG, "'%s' - Setting:", this->parent_.get_name().c_str());
   this->validate_();
@@ -32,8 +53,8 @@ void FanCall::perform() {
   if (this->direction_.has_value()) {
     ESP_LOGD(TAG, "  Direction: %s", LOG_STR_ARG(fan_direction_to_string(*this->direction_)));
   }
-  if (!this->preset_mode_.empty()) {
-    ESP_LOGD(TAG, "  Preset Mode: %s", this->preset_mode_.c_str());
+  if (this->has_preset_mode()) {
+    ESP_LOGD(TAG, "  Preset Mode: %s", this->preset_mode_);
   }
   this->parent_.control(*this);
 }
@@ -46,30 +67,15 @@ void FanCall::validate_() {
 
     // https://developers.home-assistant.io/docs/core/entity/fan/#preset-modes
     // "Manually setting a speed must disable any set preset mode"
-    this->preset_mode_.clear();
-  }
-
-  if (!this->preset_mode_.empty()) {
-    const auto &preset_modes = traits.supported_preset_modes();
-    bool found = false;
-    for (const auto &mode : preset_modes) {
-      if (strcmp(mode, this->preset_mode_.c_str()) == 0) {
-        found = true;
-        break;
-      }
-    }
-    if (!found) {
-      ESP_LOGW(TAG, "%s: Preset mode '%s' not supported", this->parent_.get_name().c_str(), this->preset_mode_.c_str());
-      this->preset_mode_.clear();
-    }
+    this->preset_mode_ = nullptr;
   }
 
   // when turning on...
   if (!this->parent_.state && this->binary_state_.has_value() &&
       *this->binary_state_
       // ..,and no preset mode will be active...
-      && this->preset_mode_.empty() &&
-      this->parent_.preset_mode.empty()
+      && !this->has_preset_mode() &&
+      this->parent_.get_preset_mode() == nullptr
       // ...and neither current nor new speed is available...
       && traits.supports_speed() && this->parent_.speed == 0 && !this->speed_.has_value()) {
     // ...set speed to 100%
@@ -117,12 +123,13 @@ void FanRestoreState::apply(Fan &fan) {
 
   auto traits = fan.get_traits();
   if (traits.supports_preset_modes()) {
-    // Use stored preset index to get preset name
+    // Use stored preset index to get preset name from traits
     const auto &preset_modes = traits.supported_preset_modes();
     if (this->preset_mode < preset_modes.size()) {
-      fan.preset_mode = preset_modes[this->preset_mode];
+      fan.set_preset_mode_(preset_modes[this->preset_mode]);
     }
   }
+
   fan.publish_state();
 }
 
@@ -131,6 +138,29 @@ FanCall Fan::turn_off() { return this->make_call().set_state(false); }
 FanCall Fan::toggle() { return this->make_call().set_state(!this->state); }
 FanCall Fan::make_call() { return FanCall(*this); }
 
+const char *Fan::find_preset_mode_(const char *preset_mode) { return this->get_traits().find_preset_mode(preset_mode); }
+
+bool Fan::set_preset_mode_(const char *preset_mode) {
+  if (preset_mode == nullptr) {
+    // Treat nullptr as clearing the preset mode
+    if (this->preset_mode_ == nullptr) {
+      return false;  // No change
+    }
+    this->clear_preset_mode_();
+    return true;
+  }
+  const char *validated = this->find_preset_mode_(preset_mode);
+  if (validated == nullptr || this->preset_mode_ == validated) {
+    return false;  // Preset mode not supported or no change
+  }
+  this->preset_mode_ = validated;
+  return true;
+}
+
+bool Fan::set_preset_mode_(const std::string &preset_mode) { return this->set_preset_mode_(preset_mode.c_str()); }
+
+void Fan::clear_preset_mode_() { this->preset_mode_ = nullptr; }
+
 void Fan::add_on_state_callback(std::function<void()> &&callback) { this->state_callback_.add(std::move(callback)); }
 void Fan::publish_state() {
   auto traits = this->get_traits();
@@ -146,8 +176,9 @@ void Fan::publish_state() {
   if (traits.supports_direction()) {
     ESP_LOGD(TAG, "  Direction: %s", LOG_STR_ARG(fan_direction_to_string(this->direction)));
   }
-  if (traits.supports_preset_modes() && !this->preset_mode.empty()) {
-    ESP_LOGD(TAG, "  Preset Mode: %s", this->preset_mode.c_str());
+  const char *preset = this->get_preset_mode();
+  if (preset != nullptr) {
+    ESP_LOGD(TAG, "  Preset Mode: %s", preset);
   }
   this->state_callback_.call();
   this->save_state_();
@@ -199,16 +230,15 @@ void Fan::save_state_() {
   state.speed = this->speed;
   state.direction = this->direction;
 
-  if (traits.supports_preset_modes() && !this->preset_mode.empty()) {
+  const char *preset = this->get_preset_mode();
+  if (preset != nullptr) {
     const auto &preset_modes = traits.supported_preset_modes();
-    // Store index of current preset mode
-    size_t i = 0;
-    for (const auto &mode : preset_modes) {
-      if (strcmp(mode, this->preset_mode.c_str()) == 0) {
+    // Find index of current preset mode (pointer comparison is safe since preset is from traits)
+    for (size_t i = 0; i < preset_modes.size(); i++) {
+      if (preset_modes[i] == preset) {
         state.preset_mode = i;
         break;
       }
-      i++;
     }
   }
 

esphome/components/fan/fan.h

@@ -70,11 +70,10 @@ class FanCall {
     return *this;
   }
   optional<FanDirection> get_direction() const { return this->direction_; }
-  FanCall &set_preset_mode(const std::string &preset_mode) {
-    this->preset_mode_ = preset_mode;
-    return *this;
-  }
-  std::string get_preset_mode() const { return this->preset_mode_; }
+  FanCall &set_preset_mode(const std::string &preset_mode);
+  FanCall &set_preset_mode(const char *preset_mode);
+  const char *get_preset_mode() const { return this->preset_mode_; }
+  bool has_preset_mode() const { return this->preset_mode_ != nullptr; }
 
   void perform();
 
@@ -86,7 +85,7 @@ class FanCall {
   optional<bool> oscillating_;
   optional<int> speed_;
   optional<FanDirection> direction_{};
-  std::string preset_mode_{};
+  const char *preset_mode_{nullptr};  // Pointer to string in traits (after validation)
 };
 
 struct FanRestoreState {
@@ -112,8 +111,6 @@ class Fan : public EntityBase {
   int speed{0};
   /// The current direction of the fan
   FanDirection direction{FanDirection::FORWARD};
-  // The current preset mode of the fan
-  std::string preset_mode{};
 
   FanCall turn_on();
   FanCall turn_off();
@@ -130,8 +127,15 @@ class Fan : public EntityBase {
   /// Set the restore mode of this fan.
   void set_restore_mode(FanRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
 
+  /// Get the current preset mode (returns pointer to string stored in traits, or nullptr if not set)
+  const char *get_preset_mode() const { return this->preset_mode_; }
+
+  /// Check if a preset mode is currently active
+  bool has_preset_mode() const { return this->preset_mode_ != nullptr; }
+
  protected:
   friend FanCall;
+  friend struct FanRestoreState;
 
   virtual void control(const FanCall &call) = 0;
 
@@ -140,9 +144,21 @@ class Fan : public EntityBase {
 
   void dump_traits_(const char *tag, const char *prefix);
 
+  /// Set the preset mode (finds and stores pointer from traits). Returns true if changed.
+  bool set_preset_mode_(const char *preset_mode);
+  /// Set the preset mode (finds and stores pointer from traits). Returns true if changed.
+  bool set_preset_mode_(const std::string &preset_mode);
+  /// Clear the preset mode
+  void clear_preset_mode_();
+  /// Find and return the matching preset mode pointer from traits, or nullptr if not found.
+  const char *find_preset_mode_(const char *preset_mode);
+
   CallbackManager<void()> state_callback_{};
   ESPPreferenceObject rtc_;
   FanRestoreMode restore_mode_;
+
+ private:
+  const char *preset_mode_{nullptr};
 };
 
 }  // namespace fan

esphome/components/fan/fan_traits.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstring>
 #include <vector>
 #include <initializer_list>
 
@@ -44,6 +45,17 @@ class FanTraits {
 
   /// Return if preset modes are supported
   bool supports_preset_modes() const { return !this->preset_modes_.empty(); }
+  /// Find and return the matching preset mode pointer from supported modes, or nullptr if not found.
+  const char *find_preset_mode(const char *preset_mode) const {
+    if (preset_mode == nullptr)
+      return nullptr;
+    for (const char *mode : this->preset_modes_) {
+      if (strcmp(mode, preset_mode) == 0) {
+        return mode;  // Return pointer from traits
+      }
+    }
+    return nullptr;
+  }
 
  protected:
   bool oscillation_{false};

esphome/components/hbridge/fan/hbridge_fan.cpp

@@ -57,7 +57,7 @@ void HBridgeFan::control(const fan::FanCall &call) {
     this->oscillating = *call.get_oscillating();
   if (call.get_direction().has_value())
     this->direction = *call.get_direction();
-  this->preset_mode = call.get_preset_mode();
+  this->set_preset_mode_(call.get_preset_mode());
 
   this->write_state_();
   this->publish_state();

esphome/components/ld2410/ld2410.cpp

@@ -121,9 +121,9 @@ constexpr Uint8ToString OUT_PIN_LEVELS_BY_UINT[] = {
 };
 
 // Helper functions for lookups
-template<size_t N> uint8_t find_uint8(const StringToUint8 (&arr)[N], const char *str) {
+template<size_t N> uint8_t find_uint8(const StringToUint8 (&arr)[N], const std::string &str) {
   for (const auto &entry : arr) {
-    if (strcmp(str, entry.str) == 0)
+    if (str == entry.str)
       return entry.value;
   }
   return 0xFF;  // Not found
@@ -441,7 +441,7 @@ bool LD2410Component::handle_ack_data_() {
       ESP_LOGV(TAG, "Baud rate change");
 #ifdef USE_SELECT
       if (this->baud_rate_select_ != nullptr) {
-        ESP_LOGE(TAG, "Change baud rate to %s and reinstall", this->baud_rate_select_->current_option());
+        ESP_LOGE(TAG, "Change baud rate to %s and reinstall", this->baud_rate_select_->state.c_str());
       }
 #endif
       break;
@@ -626,14 +626,14 @@ void LD2410Component::set_bluetooth(bool enable) {
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
 }
 
-void LD2410Component::set_distance_resolution(const char *state) {
+void LD2410Component::set_distance_resolution(const std::string &state) {
   this->set_config_mode_(true);
   const uint8_t cmd_value[2] = {find_uint8(DISTANCE_RESOLUTIONS_BY_STR, state), 0x00};
   this->send_command_(CMD_SET_DISTANCE_RESOLUTION, cmd_value, sizeof(cmd_value));
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
 }
 
-void LD2410Component::set_baud_rate(const char *state) {
+void LD2410Component::set_baud_rate(const std::string &state) {
   this->set_config_mode_(true);
   const uint8_t cmd_value[2] = {find_uint8(BAUD_RATES_BY_STR, state), 0x00};
   this->send_command_(CMD_SET_BAUD_RATE, cmd_value, sizeof(cmd_value));
@@ -759,10 +759,10 @@ void LD2410Component::set_light_out_control() {
 #endif
 #ifdef USE_SELECT
   if (this->light_function_select_ != nullptr && this->light_function_select_->has_state()) {
-    this->light_function_ = find_uint8(LIGHT_FUNCTIONS_BY_STR, this->light_function_select_->current_option());
+    this->light_function_ = find_uint8(LIGHT_FUNCTIONS_BY_STR, this->light_function_select_->state);
   }
   if (this->out_pin_level_select_ != nullptr && this->out_pin_level_select_->has_state()) {
-    this->out_pin_level_ = find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_select_->current_option());
+    this->out_pin_level_ = find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_select_->state);
   }
 #endif
   this->set_config_mode_(true);

esphome/components/ld2410/ld2410.h

@@ -98,8 +98,8 @@ class LD2410Component : public Component, public uart::UARTDevice {
   void read_all_info();
   void restart_and_read_all_info();
   void set_bluetooth(bool enable);
-  void set_distance_resolution(const char *state);
-  void set_baud_rate(const char *state);
+  void set_distance_resolution(const std::string &state);
+  void set_baud_rate(const std::string &state);
   void factory_reset();
 
  protected:

esphome/components/ld2410/select/baud_rate_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace ld2410 {
 
-void BaudRateSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_baud_rate(this->option_at(index));
+void BaudRateSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_baud_rate(state);
 }
 
 }  // namespace ld2410

esphome/components/ld2410/select/baud_rate_select.h

@@ -11,7 +11,7 @@ class BaudRateSelect : public select::Select, public Parented<LD2410Component> {
   BaudRateSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace ld2410

esphome/components/ld2410/select/distance_resolution_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace ld2410 {
 
-void DistanceResolutionSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_distance_resolution(this->option_at(index));
+void DistanceResolutionSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_distance_resolution(state);
 }
 
 }  // namespace ld2410

esphome/components/ld2410/select/distance_resolution_select.h

@@ -11,7 +11,7 @@ class DistanceResolutionSelect : public select::Select, public Parented<LD2410Co
   DistanceResolutionSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace ld2410

esphome/components/ld2410/select/light_out_control_select.cpp

@@ -3,8 +3,8 @@
 namespace esphome {
 namespace ld2410 {
 
-void LightOutControlSelect::control(size_t index) {
-  this->publish_state(index);
+void LightOutControlSelect::control(const std::string &value) {
+  this->publish_state(value);
   this->parent_->set_light_out_control();
 }
 

esphome/components/ld2410/select/light_out_control_select.h

@@ -11,7 +11,7 @@ class LightOutControlSelect : public select::Select, public Parented<LD2410Compo
   LightOutControlSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace ld2410

esphome/components/ld2412/ld2412.cpp

@@ -132,9 +132,9 @@ constexpr Uint8ToString OUT_PIN_LEVELS_BY_UINT[] = {
 };
 
 // Helper functions for lookups
-template<size_t N> uint8_t find_uint8(const StringToUint8 (&arr)[N], const char *str) {
+template<size_t N> uint8_t find_uint8(const StringToUint8 (&arr)[N], const std::string &str) {
   for (const auto &entry : arr) {
-    if (strcmp(str, entry.str) == 0) {
+    if (str == entry.str) {
       return entry.value;
     }
   }
@@ -485,7 +485,7 @@ bool LD2412Component::handle_ack_data_() {
       ESP_LOGV(TAG, "Baud rate change");
 #ifdef USE_SELECT
       if (this->baud_rate_select_ != nullptr) {
-        ESP_LOGW(TAG, "Change baud rate to %s and reinstall", this->baud_rate_select_->current_option());
+        ESP_LOGW(TAG, "Change baud rate to %s and reinstall", this->baud_rate_select_->state.c_str());
       }
 #endif
       break;
@@ -699,14 +699,14 @@ void LD2412Component::set_bluetooth(bool enable) {
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
 }
 
-void LD2412Component::set_distance_resolution(const char *state) {
+void LD2412Component::set_distance_resolution(const std::string &state) {
   this->set_config_mode_(true);
   const uint8_t cmd_value[6] = {find_uint8(DISTANCE_RESOLUTIONS_BY_STR, state), 0x00, 0x00, 0x00, 0x00, 0x00};
   this->send_command_(CMD_SET_DISTANCE_RESOLUTION, cmd_value, sizeof(cmd_value));
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
 }
 
-void LD2412Component::set_baud_rate(const char *state) {
+void LD2412Component::set_baud_rate(const std::string &state) {
   this->set_config_mode_(true);
   const uint8_t cmd_value[2] = {find_uint8(BAUD_RATES_BY_STR, state), 0x00};
   this->send_command_(CMD_SET_BAUD_RATE, cmd_value, sizeof(cmd_value));
@@ -783,7 +783,7 @@ void LD2412Component::set_basic_config() {
       1,    TOTAL_GATES, DEFAULT_PRESENCE_TIMEOUT, 0,
 #endif
 #ifdef USE_SELECT
-      find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_select_->current_option()),
+      find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_select_->state),
 #else
       0x01,  // Default value if not using select
 #endif
@@ -837,7 +837,7 @@ void LD2412Component::set_light_out_control() {
 #endif
 #ifdef USE_SELECT
   if (this->light_function_select_ != nullptr && this->light_function_select_->has_state()) {
-    this->light_function_ = find_uint8(LIGHT_FUNCTIONS_BY_STR, this->light_function_select_->current_option());
+    this->light_function_ = find_uint8(LIGHT_FUNCTIONS_BY_STR, this->light_function_select_->state);
   }
 #endif
   uint8_t value[2] = {this->light_function_, this->light_threshold_};

esphome/components/ld2412/ld2412.h

@@ -99,8 +99,8 @@ class LD2412Component : public Component, public uart::UARTDevice {
   void read_all_info();
   void restart_and_read_all_info();
   void set_bluetooth(bool enable);
-  void set_distance_resolution(const char *state);
-  void set_baud_rate(const char *state);
+  void set_distance_resolution(const std::string &state);
+  void set_baud_rate(const std::string &state);
   void factory_reset();
   void start_dynamic_background_correction();
 

esphome/components/ld2412/select/baud_rate_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace ld2412 {
 
-void BaudRateSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_baud_rate(this->option_at(index));
+void BaudRateSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_baud_rate(state);
 }
 
 }  // namespace ld2412

esphome/components/ld2412/select/baud_rate_select.h

@@ -11,7 +11,7 @@ class BaudRateSelect : public select::Select, public Parented<LD2412Component> {
   BaudRateSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace ld2412

esphome/components/ld2412/select/distance_resolution_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace ld2412 {
 
-void DistanceResolutionSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_distance_resolution(this->option_at(index));
+void DistanceResolutionSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_distance_resolution(state);
 }
 
 }  // namespace ld2412

esphome/components/ld2412/select/distance_resolution_select.h

@@ -11,7 +11,7 @@ class DistanceResolutionSelect : public select::Select, public Parented<LD2412Co
   DistanceResolutionSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace ld2412

esphome/components/ld2412/select/light_out_control_select.cpp

@@ -3,8 +3,8 @@
 namespace esphome {
 namespace ld2412 {
 
-void LightOutControlSelect::control(size_t index) {
-  this->publish_state(index);
+void LightOutControlSelect::control(const std::string &value) {
+  this->publish_state(value);
   this->parent_->set_light_out_control();
 }
 

esphome/components/ld2412/select/light_out_control_select.h

@@ -11,7 +11,7 @@ class LightOutControlSelect : public select::Select, public Parented<LD2412Compo
   LightOutControlSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace ld2412

esphome/components/ld2420/ld2420.cpp

@@ -131,8 +131,8 @@ static const uint8_t CMD_FRAME_STATUS = 7;
 static const uint8_t CMD_ERROR_WORD = 8;
 static const uint8_t ENERGY_SENSOR_START = 9;
 static const uint8_t CALIBRATE_REPORT_INTERVAL = 4;
-static const char *const OP_NORMAL_MODE_STRING = "Normal";
-static const char *const OP_SIMPLE_MODE_STRING = "Simple";
+static const std::string OP_NORMAL_MODE_STRING = "Normal";
+static const std::string OP_SIMPLE_MODE_STRING = "Simple";
 
 // Memory-efficient lookup tables
 struct StringToUint8 {
@@ -379,7 +379,7 @@ void LD2420Component::report_gate_data() {
   ESP_LOGI(TAG, "Total samples: %d", this->total_sample_number_counter);
 }
 
-void LD2420Component::set_operating_mode(const char *state) {
+void LD2420Component::set_operating_mode(const std::string &state) {
   // If unsupported firmware ignore mode select
   if (ld2420::get_firmware_int(firmware_ver_) >= CALIBRATE_VERSION_MIN) {
     this->current_operating_mode = find_uint8(OP_MODE_BY_STR, state);

esphome/components/ld2420/ld2420.h

@@ -107,7 +107,7 @@ class LD2420Component : public Component, public uart::UARTDevice {
   int send_cmd_from_array(CmdFrameT cmd_frame);
   void report_gate_data();
   void handle_cmd_error(uint8_t error);
-  void set_operating_mode(const char *state);
+  void set_operating_mode(const std::string &state);
   void auto_calibrate_sensitivity();
   void update_radar_data(uint16_t const *gate_energy, uint8_t sample_number);
   uint8_t set_config_mode(bool enable);

esphome/components/ld2420/select/operating_mode_select.cpp

@@ -7,9 +7,9 @@ namespace ld2420 {
 
 static const char *const TAG = "ld2420.select";
 
-void LD2420Select::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_operating_mode(this->option_at(index));
+void LD2420Select::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_operating_mode(value);
 }
 
 }  // namespace ld2420

esphome/components/ld2420/select/operating_mode_select.h

@@ -11,7 +11,7 @@ class LD2420Select : public Component, public select::Select, public Parented<LD
   LD2420Select() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace ld2420

esphome/components/ld2450/ld2450.cpp

@@ -380,7 +380,7 @@ void LD2450Component::read_all_info() {
   this->set_config_mode_(false);
 #ifdef USE_SELECT
   const auto baud_rate = std::to_string(this->parent_->get_baud_rate());
-  if (this->baud_rate_select_ != nullptr && strcmp(this->baud_rate_select_->current_option(), baud_rate.c_str()) != 0) {
+  if (this->baud_rate_select_ != nullptr && this->baud_rate_select_->state != baud_rate) {
     this->baud_rate_select_->publish_state(baud_rate);
   }
   this->publish_zone_type();
@@ -635,7 +635,7 @@ bool LD2450Component::handle_ack_data_() {
       ESP_LOGV(TAG, "Baud rate change");
 #ifdef USE_SELECT
       if (this->baud_rate_select_ != nullptr) {
-        ESP_LOGE(TAG, "Change baud rate to %s and reinstall", this->baud_rate_select_->current_option());
+        ESP_LOGE(TAG, "Change baud rate to %s and reinstall", this->baud_rate_select_->state.c_str());
       }
 #endif
       break;
@@ -716,7 +716,7 @@ bool LD2450Component::handle_ack_data_() {
       this->publish_zone_type();
 #ifdef USE_SELECT
       if (this->zone_type_select_ != nullptr) {
-        ESP_LOGV(TAG, "Change zone type to: %s", this->zone_type_select_->current_option());
+        ESP_LOGV(TAG, "Change zone type to: %s", this->zone_type_select_->state.c_str());
       }
 #endif
       if (this->buffer_data_[10] == 0x00) {
@@ -790,7 +790,7 @@ void LD2450Component::set_bluetooth(bool enable) {
 }
 
 // Set Baud rate
-void LD2450Component::set_baud_rate(const char *state) {
+void LD2450Component::set_baud_rate(const std::string &state) {
   this->set_config_mode_(true);
   const uint8_t cmd_value[2] = {find_uint8(BAUD_RATES_BY_STR, state), 0x00};
   this->send_command_(CMD_SET_BAUD_RATE, cmd_value, sizeof(cmd_value));
@@ -798,8 +798,8 @@ void LD2450Component::set_baud_rate(const char *state) {
 }
 
 // Set Zone Type - one of: Disabled, Detection, Filter
-void LD2450Component::set_zone_type(const char *state) {
-  ESP_LOGV(TAG, "Set zone type: %s", state);
+void LD2450Component::set_zone_type(const std::string &state) {
+  ESP_LOGV(TAG, "Set zone type: %s", state.c_str());
   uint8_t zone_type = find_uint8(ZONE_TYPE_BY_STR, state);
   this->zone_type_ = zone_type;
   this->send_set_zone_command_();

esphome/components/ld2450/ld2450.h

@@ -115,8 +115,8 @@ class LD2450Component : public Component, public uart::UARTDevice {
   void restart_and_read_all_info();
   void set_bluetooth(bool enable);
   void set_multi_target(bool enable);
-  void set_baud_rate(const char *state);
-  void set_zone_type(const char *state);
+  void set_baud_rate(const std::string &state);
+  void set_zone_type(const std::string &state);
   void publish_zone_type();
   void factory_reset();
 #ifdef USE_TEXT_SENSOR

esphome/components/ld2450/select/baud_rate_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace ld2450 {
 
-void BaudRateSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_baud_rate(this->option_at(index));
+void BaudRateSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_baud_rate(state);
 }
 
 }  // namespace ld2450

esphome/components/ld2450/select/baud_rate_select.h

@@ -11,7 +11,7 @@ class BaudRateSelect : public select::Select, public Parented<LD2450Component> {
   BaudRateSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace ld2450

esphome/components/ld2450/select/zone_type_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace ld2450 {
 
-void ZoneTypeSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_zone_type(this->option_at(index));
+void ZoneTypeSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_zone_type(state);
 }
 
 }  // namespace ld2450

esphome/components/ld2450/select/zone_type_select.h

@@ -11,7 +11,7 @@ class ZoneTypeSelect : public select::Select, public Parented<LD2450Component> {
   ZoneTypeSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace ld2450

esphome/components/logger/select/logger_level_select.cpp

@@ -3,10 +3,10 @@
 namespace esphome::logger {
 
 void LoggerLevelSelect::publish_state(int level) {
-  auto index = level_to_index(level);
-  if (!this->has_index(index))
+  const auto &option = this->at(level_to_index(level));
+  if (!option)
     return;
-  Select::publish_state(index);
+  Select::publish_state(option.value());
 }
 
 void LoggerLevelSelect::setup() {
@@ -14,6 +14,11 @@ void LoggerLevelSelect::setup() {
   this->publish_state(this->parent_->get_log_level());
 }
 
-void LoggerLevelSelect::control(size_t index) { this->parent_->set_log_level(index_to_level(index)); }
+void LoggerLevelSelect::control(const std::string &value) {
+  const auto index = this->index_of(value);
+  if (!index)
+    return;
+  this->parent_->set_log_level(index_to_level(index.value()));
+}
 
 }  // namespace esphome::logger

esphome/components/logger/select/logger_level_select.h

@@ -9,7 +9,7 @@ class LoggerLevelSelect : public Component, public select::Select, public Parent
  public:
   void publish_state(int level);
   void setup() override;
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 
  protected:
   // Convert log level to option index (skip CONFIG at level 4)

esphome/components/lvgl/select/lvgl_select.h

@@ -41,16 +41,16 @@ class LVGLSelect : public select::Select, public Component {
   }
 
   void publish() {
-    auto index = this->widget_->get_selected_index();
-    this->publish_state(index);
+    this->publish_state(this->widget_->get_selected_text());
     if (this->restore_) {
+      auto index = this->widget_->get_selected_index();
       this->pref_.save(&index);
     }
   }
 
  protected:
-  void control(size_t index) override {
-    this->widget_->set_selected_index(index, this->anim_);
+  void control(const std::string &value) override {
+    this->widget_->set_selected_text(value, this->anim_);
     this->publish();
   }
   void set_options_() {

esphome/components/midea/ac_adapter.cpp

@@ -8,9 +8,9 @@ namespace midea {
 namespace ac {
 
 const char *const Constants::TAG = "midea";
-const char *const Constants::FREEZE_PROTECTION = "freeze protection";
-const char *const Constants::SILENT = "silent";
-const char *const Constants::TURBO = "turbo";
+const std::string Constants::FREEZE_PROTECTION = "freeze protection";
+const std::string Constants::SILENT = "silent";
+const std::string Constants::TURBO = "turbo";
 
 ClimateMode Converters::to_climate_mode(MideaMode mode) {
   switch (mode) {
@@ -108,7 +108,7 @@ bool Converters::is_custom_midea_fan_mode(MideaFanMode mode) {
   }
 }
 
-const char *Converters::to_custom_climate_fan_mode(MideaFanMode mode) {
+const std::string &Converters::to_custom_climate_fan_mode(MideaFanMode mode) {
   switch (mode) {
     case MideaFanMode::FAN_SILENT:
       return Constants::SILENT;
@@ -117,8 +117,8 @@ const char *Converters::to_custom_climate_fan_mode(MideaFanMode mode) {
   }
 }
 
-MideaFanMode Converters::to_midea_fan_mode(const char *mode) {
-  if (strcmp(mode, Constants::SILENT) == 0)
+MideaFanMode Converters::to_midea_fan_mode(const std::string &mode) {
+  if (mode == Constants::SILENT)
     return MideaFanMode::FAN_SILENT;
   return MideaFanMode::FAN_TURBO;
 }
@@ -151,9 +151,9 @@ ClimatePreset Converters::to_climate_preset(MideaPreset preset) {
 
 bool Converters::is_custom_midea_preset(MideaPreset preset) { return preset == MideaPreset::PRESET_FREEZE_PROTECTION; }
 
-const char *Converters::to_custom_climate_preset(MideaPreset preset) { return Constants::FREEZE_PROTECTION; }
+const std::string &Converters::to_custom_climate_preset(MideaPreset preset) { return Constants::FREEZE_PROTECTION; }
 
-MideaPreset Converters::to_midea_preset(const char *preset) { return MideaPreset::PRESET_FREEZE_PROTECTION; }
+MideaPreset Converters::to_midea_preset(const std::string &preset) { return MideaPreset::PRESET_FREEZE_PROTECTION; }
 
 void Converters::to_climate_traits(ClimateTraits &traits, const dudanov::midea::ac::Capabilities &capabilities) {
   if (capabilities.supportAutoMode())
@@ -169,7 +169,7 @@ void Converters::to_climate_traits(ClimateTraits &traits, const dudanov::midea::
   if (capabilities.supportEcoPreset())
     traits.add_supported_preset(ClimatePreset::CLIMATE_PRESET_ECO);
   if (capabilities.supportFrostProtectionPreset())
-    traits.set_supported_custom_presets({Constants::FREEZE_PROTECTION});
+    traits.add_supported_custom_preset(Constants::FREEZE_PROTECTION);
 }
 
 }  // namespace ac

esphome/components/midea/ac_adapter.h

@@ -20,9 +20,9 @@ using MideaPreset = dudanov::midea::ac::Preset;
 class Constants {
  public:
   static const char *const TAG;
-  static const char *const FREEZE_PROTECTION;
-  static const char *const SILENT;
-  static const char *const TURBO;
+  static const std::string FREEZE_PROTECTION;
+  static const std::string SILENT;
+  static const std::string TURBO;
 };
 
 class Converters {
@@ -32,15 +32,15 @@ class Converters {
   static MideaSwingMode to_midea_swing_mode(ClimateSwingMode mode);
   static ClimateSwingMode to_climate_swing_mode(MideaSwingMode mode);
   static MideaPreset to_midea_preset(ClimatePreset preset);
-  static MideaPreset to_midea_preset(const char *preset);
+  static MideaPreset to_midea_preset(const std::string &preset);
   static bool is_custom_midea_preset(MideaPreset preset);
   static ClimatePreset to_climate_preset(MideaPreset preset);
-  static const char *to_custom_climate_preset(MideaPreset preset);
+  static const std::string &to_custom_climate_preset(MideaPreset preset);
   static MideaFanMode to_midea_fan_mode(ClimateFanMode fan_mode);
-  static MideaFanMode to_midea_fan_mode(const char *fan_mode);
+  static MideaFanMode to_midea_fan_mode(const std::string &fan_mode);
   static bool is_custom_midea_fan_mode(MideaFanMode fan_mode);
   static ClimateFanMode to_climate_fan_mode(MideaFanMode fan_mode);
-  static const char *to_custom_climate_fan_mode(MideaFanMode fan_mode);
+  static const std::string &to_custom_climate_fan_mode(MideaFanMode fan_mode);
   static void to_climate_traits(ClimateTraits &traits, const dudanov::midea::ac::Capabilities &capabilities);
 };
 

esphome/components/midea/air_conditioner.cpp

@@ -64,13 +64,13 @@ void AirConditioner::control(const ClimateCall &call) {
     ctrl.mode = Converters::to_midea_mode(call.get_mode().value());
   if (call.get_preset().has_value()) {
     ctrl.preset = Converters::to_midea_preset(call.get_preset().value());
-  } else if (call.has_custom_preset()) {
-    ctrl.preset = Converters::to_midea_preset(call.get_custom_preset());
+  } else if (call.get_custom_preset().has_value()) {
+    ctrl.preset = Converters::to_midea_preset(call.get_custom_preset().value());
   }
   if (call.get_fan_mode().has_value()) {
     ctrl.fanMode = Converters::to_midea_fan_mode(call.get_fan_mode().value());
-  } else if (call.has_custom_fan_mode()) {
-    ctrl.fanMode = Converters::to_midea_fan_mode(call.get_custom_fan_mode());
+  } else if (call.get_custom_fan_mode().has_value()) {
+    ctrl.fanMode = Converters::to_midea_fan_mode(call.get_custom_fan_mode().value());
   }
   this->base_.control(ctrl);
 }
@@ -84,10 +84,8 @@ ClimateTraits AirConditioner::traits() {
   traits.set_supported_modes(this->supported_modes_);
   traits.set_supported_swing_modes(this->supported_swing_modes_);
   traits.set_supported_presets(this->supported_presets_);
-  if (!this->supported_custom_presets_.empty())
-    traits.set_supported_custom_presets(this->supported_custom_presets_);
-  if (!this->supported_custom_fan_modes_.empty())
-    traits.set_supported_custom_fan_modes(this->supported_custom_fan_modes_);
+  traits.set_supported_custom_presets(this->supported_custom_presets_);
+  traits.set_supported_custom_fan_modes(this->supported_custom_fan_modes_);
   /* + MINIMAL SET OF CAPABILITIES */
   traits.add_supported_fan_mode(ClimateFanMode::CLIMATE_FAN_AUTO);
   traits.add_supported_fan_mode(ClimateFanMode::CLIMATE_FAN_LOW);

esphome/components/midea/air_conditioner.h

@@ -46,8 +46,8 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   void set_supported_modes(ClimateModeMask modes) { this->supported_modes_ = modes; }
   void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
   void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
-  void set_custom_presets(std::initializer_list<const char *> presets) { this->supported_custom_presets_ = presets; }
-  void set_custom_fan_modes(std::initializer_list<const char *> modes) { this->supported_custom_fan_modes_ = modes; }
+  void set_custom_presets(const std::vector<std::string> &presets) { this->supported_custom_presets_ = presets; }
+  void set_custom_fan_modes(const std::vector<std::string> &modes) { this->supported_custom_fan_modes_ = modes; }
 
  protected:
   void control(const ClimateCall &call) override;
@@ -55,8 +55,8 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   ClimateModeMask supported_modes_{};
   ClimateSwingModeMask supported_swing_modes_{};
   ClimatePresetMask supported_presets_{};
-  std::vector<const char *> supported_custom_presets_{};
-  std::vector<const char *> supported_custom_fan_modes_{};
+  std::vector<std::string> supported_custom_presets_{};
+  std::vector<std::string> supported_custom_fan_modes_{};
   Sensor *outdoor_sensor_{nullptr};
   Sensor *humidity_sensor_{nullptr};
   Sensor *power_sensor_{nullptr};

esphome/components/modbus_controller/select/modbus_select.cpp

@@ -28,9 +28,8 @@ void ModbusSelect::parse_and_publish(const std::vector<uint8_t> &data) {
 
     if (map_it != this->mapping_.cend()) {
       size_t idx = std::distance(this->mapping_.cbegin(), map_it);
-      ESP_LOGV(TAG, "Found option %s for value %lld", this->option_at(idx), value);
-      this->publish_state(idx);
-      return;
+      new_state = std::string(this->option_at(idx));
+      ESP_LOGV(TAG, "Found option %s for value %lld", new_state->c_str(), value);
     } else {
       ESP_LOGE(TAG, "No option found for mapping %lld", value);
     }
@@ -41,16 +40,19 @@ void ModbusSelect::parse_and_publish(const std::vector<uint8_t> &data) {
   }
 }
 
-void ModbusSelect::control(size_t index) {
-  optional<int64_t> mapval = this->mapping_[index];
-  const char *option = this->option_at(index);
-  ESP_LOGD(TAG, "Found value %lld for option '%s'", *mapval, option);
+void ModbusSelect::control(const std::string &value) {
+  auto idx = this->index_of(value);
+  if (!idx.has_value()) {
+    ESP_LOGW(TAG, "Invalid option '%s'", value.c_str());
+    return;
+  }
+  optional<int64_t> mapval = this->mapping_[idx.value()];
+  ESP_LOGD(TAG, "Found value %lld for option '%s'", *mapval, value.c_str());
 
   std::vector<uint16_t> data;
 
   if (this->write_transform_func_.has_value()) {
-    // Transform func requires string parameter for backward compatibility
-    auto val = (*this->write_transform_func_)(this, std::string(option), *mapval, data);
+    auto val = (*this->write_transform_func_)(this, value, *mapval, data);
     if (val.has_value()) {
       mapval = *val;
       ESP_LOGV(TAG, "write_lambda returned mapping value %lld", *mapval);
@@ -83,7 +85,7 @@ void ModbusSelect::control(size_t index) {
   this->parent_->queue_command(write_cmd);
 
   if (this->optimistic_)
-    this->publish_state(index);
+    this->publish_state(value);
 }
 
 }  // namespace modbus_controller

esphome/components/modbus_controller/select/modbus_select.h

@@ -38,7 +38,7 @@ class ModbusSelect : public Component, public select::Select, public SensorItem
 
   void dump_config() override;
   void parse_and_publish(const std::vector<uint8_t> &data) override;
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 
  protected:
   std::vector<int64_t> mapping_{};

esphome/components/mqtt/mqtt_climate.cpp

@@ -357,8 +357,8 @@ bool MQTTClimateComponent::publish_state_() {
           payload = "unknown";
       }
     }
-    if (this->device_->has_custom_preset())
-      payload = this->device_->get_custom_preset();
+    if (this->device_->custom_preset.has_value())
+      payload = this->device_->custom_preset.value();
     if (!this->publish(this->get_preset_state_topic(), payload))
       success = false;
   }
@@ -429,8 +429,8 @@ bool MQTTClimateComponent::publish_state_() {
           payload = "unknown";
       }
     }
-    if (this->device_->has_custom_fan_mode())
-      payload = this->device_->get_custom_fan_mode();
+    if (this->device_->custom_fan_mode.has_value())
+      payload = this->device_->custom_fan_mode.value();
     if (!this->publish(this->get_fan_mode_state_topic(), payload))
       success = false;
   }

esphome/components/mqtt/mqtt_select.cpp

@@ -21,8 +21,7 @@ void MQTTSelectComponent::setup() {
     call.set_option(state);
     call.perform();
   });
-  this->select_->add_on_state_callback(
-      [this](const std::string &state, size_t index) { this->publish_state(this->select_->option_at(index)); });
+  this->select_->add_on_state_callback([this](const std::string &state, size_t index) { this->publish_state(state); });
 }
 
 void MQTTSelectComponent::dump_config() {
@@ -45,7 +44,7 @@ void MQTTSelectComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryCon
 }
 bool MQTTSelectComponent::send_initial_state() {
   if (this->select_->has_state()) {
-    return this->publish_state(this->select_->current_option());
+    return this->publish_state(this->select_->state);
   } else {
     return true;
   }

esphome/components/seeed_mr24hpc1/seeed_mr24hpc1.cpp

@@ -435,12 +435,12 @@ void MR24HPC1Component::r24_frame_parse_open_underlying_information_(uint8_t *da
   } else if ((this->existence_boundary_select_ != nullptr) &&
              ((data[FRAME_COMMAND_WORD_INDEX] == 0x0a) || (data[FRAME_COMMAND_WORD_INDEX] == 0x8a))) {
     if (this->existence_boundary_select_->has_index(data[FRAME_DATA_INDEX] - 1)) {
-      this->existence_boundary_select_->publish_state(data[FRAME_DATA_INDEX] - 1);
+      this->existence_boundary_select_->publish_state(S_BOUNDARY_STR[data[FRAME_DATA_INDEX] - 1]);
     }
   } else if ((this->motion_boundary_select_ != nullptr) &&
              ((data[FRAME_COMMAND_WORD_INDEX] == 0x0b) || (data[FRAME_COMMAND_WORD_INDEX] == 0x8b))) {
     if (this->motion_boundary_select_->has_index(data[FRAME_DATA_INDEX] - 1)) {
-      this->motion_boundary_select_->publish_state(data[FRAME_DATA_INDEX] - 1);
+      this->motion_boundary_select_->publish_state(S_BOUNDARY_STR[data[FRAME_DATA_INDEX] - 1]);
     }
   } else if ((this->motion_trigger_number_ != nullptr) &&
              ((data[FRAME_COMMAND_WORD_INDEX] == 0x0c) || (data[FRAME_COMMAND_WORD_INDEX] == 0x8c))) {
@@ -515,7 +515,7 @@ void MR24HPC1Component::r24_frame_parse_work_status_(uint8_t *data) {
     ESP_LOGD(TAG, "Reply: get radar init status 0x%02X", data[FRAME_DATA_INDEX]);
   } else if (data[FRAME_COMMAND_WORD_INDEX] == 0x07) {
     if ((this->scene_mode_select_ != nullptr) && (this->scene_mode_select_->has_index(data[FRAME_DATA_INDEX]))) {
-      this->scene_mode_select_->publish_state(data[FRAME_DATA_INDEX]);
+      this->scene_mode_select_->publish_state(S_SCENE_STR[data[FRAME_DATA_INDEX]]);
     } else {
       ESP_LOGD(TAG, "Select has index offset %d Error", data[FRAME_DATA_INDEX]);
     }
@@ -538,7 +538,7 @@ void MR24HPC1Component::r24_frame_parse_work_status_(uint8_t *data) {
     ESP_LOGD(TAG, "Reply: get radar init status 0x%02X", data[FRAME_DATA_INDEX]);
   } else if (data[FRAME_COMMAND_WORD_INDEX] == 0x87) {
     if ((this->scene_mode_select_ != nullptr) && (this->scene_mode_select_->has_index(data[FRAME_DATA_INDEX]))) {
-      this->scene_mode_select_->publish_state(data[FRAME_DATA_INDEX]);
+      this->scene_mode_select_->publish_state(S_SCENE_STR[data[FRAME_DATA_INDEX]]);
     } else {
       ESP_LOGD(TAG, "Select has index offset %d Error", data[FRAME_DATA_INDEX]);
     }
@@ -581,7 +581,7 @@ void MR24HPC1Component::r24_frame_parse_human_information_(uint8_t *data) {
              ((data[FRAME_COMMAND_WORD_INDEX] == 0x0A) || (data[FRAME_COMMAND_WORD_INDEX] == 0x8A))) {
     // none:0x00  1s:0x01 30s:0x02 1min:0x03 2min:0x04 5min:0x05 10min:0x06 30min:0x07 1hour:0x08
     if (data[FRAME_DATA_INDEX] < 9) {
-      this->unman_time_select_->publish_state(data[FRAME_DATA_INDEX]);
+      this->unman_time_select_->publish_state(S_UNMANNED_TIME_STR[data[FRAME_DATA_INDEX]]);
     }
   } else if ((this->keep_away_text_sensor_ != nullptr) &&
              ((data[FRAME_COMMAND_WORD_INDEX] == 0x0B) || (data[FRAME_COMMAND_WORD_INDEX] == 0x8B))) {

esphome/components/seeed_mr24hpc1/select/existence_boundary_select.cpp

@@ -3,9 +3,12 @@
 namespace esphome {
 namespace seeed_mr24hpc1 {
 
-void ExistenceBoundarySelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_existence_boundary(index);
+void ExistenceBoundarySelect::control(const std::string &value) {
+  this->publish_state(value);
+  auto index = this->index_of(value);
+  if (index.has_value()) {
+    this->parent_->set_existence_boundary(index.value());
+  }
 }
 
 }  // namespace seeed_mr24hpc1

esphome/components/seeed_mr24hpc1/select/existence_boundary_select.h

@@ -11,7 +11,7 @@ class ExistenceBoundarySelect : public select::Select, public Parented<MR24HPC1C
   ExistenceBoundarySelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace seeed_mr24hpc1

esphome/components/seeed_mr24hpc1/select/motion_boundary_select.cpp

@@ -3,9 +3,12 @@
 namespace esphome {
 namespace seeed_mr24hpc1 {
 
-void MotionBoundarySelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_motion_boundary(index);
+void MotionBoundarySelect::control(const std::string &value) {
+  this->publish_state(value);
+  auto index = this->index_of(value);
+  if (index.has_value()) {
+    this->parent_->set_motion_boundary(index.value());
+  }
 }
 
 }  // namespace seeed_mr24hpc1

esphome/components/seeed_mr24hpc1/select/motion_boundary_select.h

@@ -11,7 +11,7 @@ class MotionBoundarySelect : public select::Select, public Parented<MR24HPC1Comp
   MotionBoundarySelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace seeed_mr24hpc1

esphome/components/seeed_mr24hpc1/select/scene_mode_select.cpp

@@ -3,9 +3,12 @@
 namespace esphome {
 namespace seeed_mr24hpc1 {
 
-void SceneModeSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_scene_mode(index);
+void SceneModeSelect::control(const std::string &value) {
+  this->publish_state(value);
+  auto index = this->index_of(value);
+  if (index.has_value()) {
+    this->parent_->set_scene_mode(index.value());
+  }
 }
 
 }  // namespace seeed_mr24hpc1

esphome/components/seeed_mr24hpc1/select/scene_mode_select.h

@@ -11,7 +11,7 @@ class SceneModeSelect : public select::Select, public Parented<MR24HPC1Component
   SceneModeSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace seeed_mr24hpc1

esphome/components/seeed_mr24hpc1/select/unman_time_select.cpp

@@ -3,9 +3,12 @@
 namespace esphome {
 namespace seeed_mr24hpc1 {
 
-void UnmanTimeSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_unman_time(index);
+void UnmanTimeSelect::control(const std::string &value) {
+  this->publish_state(value);
+  auto index = this->index_of(value);
+  if (index.has_value()) {
+    this->parent_->set_unman_time(index.value());
+  }
 }
 
 }  // namespace seeed_mr24hpc1

esphome/components/seeed_mr24hpc1/select/unman_time_select.h

@@ -11,7 +11,7 @@ class UnmanTimeSelect : public select::Select, public Parented<MR24HPC1Component
   UnmanTimeSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace seeed_mr24hpc1

esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp

@@ -292,7 +292,7 @@ void MR60FDA2Component::process_frame_() {
 
         install_height_float = bit_cast<float>(current_install_height_int);
         uint32_t select_index = find_nearest_index(install_height_float, INSTALL_HEIGHT, 7);
-        this->install_height_select_->publish_state(select_index);
+        this->install_height_select_->publish_state(this->install_height_select_->at(select_index).value());
       }
 
       if (this->height_threshold_select_ != nullptr) {
@@ -301,7 +301,7 @@ void MR60FDA2Component::process_frame_() {
 
         height_threshold_float = bit_cast<float>(current_height_threshold_int);
         size_t select_index = find_nearest_index(height_threshold_float, HEIGHT_THRESHOLD, 7);
-        this->height_threshold_select_->publish_state(select_index);
+        this->height_threshold_select_->publish_state(this->height_threshold_select_->at(select_index).value());
       }
 
       if (this->sensitivity_select_ != nullptr) {
@@ -309,7 +309,7 @@ void MR60FDA2Component::process_frame_() {
             encode_uint32(current_data_buf_[11], current_data_buf_[10], current_data_buf_[9], current_data_buf_[8]);
 
         uint32_t select_index = find_nearest_index(current_sensitivity, SENSITIVITY, 3);
-        this->sensitivity_select_->publish_state(select_index);
+        this->sensitivity_select_->publish_state(this->sensitivity_select_->at(select_index).value());
       }
 
       ESP_LOGD(TAG, "Mounting height: %.2f, Height threshold: %.2f, Sensitivity: %" PRIu32, install_height_float,

esphome/components/seeed_mr60fda2/select/height_threshold_select.cpp

@@ -3,9 +3,12 @@
 namespace esphome {
 namespace seeed_mr60fda2 {
 
-void HeightThresholdSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_height_threshold(index);
+void HeightThresholdSelect::control(const std::string &value) {
+  this->publish_state(value);
+  auto index = this->index_of(value);
+  if (index.has_value()) {
+    this->parent_->set_height_threshold(index.value());
+  }
 }
 
 }  // namespace seeed_mr60fda2

esphome/components/seeed_mr60fda2/select/height_threshold_select.h

@@ -11,7 +11,7 @@ class HeightThresholdSelect : public select::Select, public Parented<MR60FDA2Com
   HeightThresholdSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace seeed_mr60fda2

esphome/components/seeed_mr60fda2/select/install_height_select.cpp

@@ -3,9 +3,12 @@
 namespace esphome {
 namespace seeed_mr60fda2 {
 
-void InstallHeightSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_install_height(index);
+void InstallHeightSelect::control(const std::string &value) {
+  this->publish_state(value);
+  auto index = this->index_of(value);
+  if (index.has_value()) {
+    this->parent_->set_install_height(index.value());
+  }
 }
 
 }  // namespace seeed_mr60fda2

esphome/components/seeed_mr60fda2/select/install_height_select.h

@@ -11,7 +11,7 @@ class InstallHeightSelect : public select::Select, public Parented<MR60FDA2Compo
   InstallHeightSelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace seeed_mr60fda2

esphome/components/seeed_mr60fda2/select/sensitivity_select.cpp

@@ -3,9 +3,12 @@
 namespace esphome {
 namespace seeed_mr60fda2 {
 
-void SensitivitySelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_sensitivity(index);
+void SensitivitySelect::control(const std::string &value) {
+  this->publish_state(value);
+  auto index = this->index_of(value);
+  if (index.has_value()) {
+    this->parent_->set_sensitivity(index.value());
+  }
 }
 
 }  // namespace seeed_mr60fda2

esphome/components/seeed_mr60fda2/select/sensitivity_select.h

@@ -11,7 +11,7 @@ class SensitivitySelect : public select::Select, public Parented<MR60FDA2Compone
   SensitivitySelect() = default;
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace seeed_mr60fda2

esphome/components/select/select.cpp

@@ -7,43 +7,24 @@ namespace select {
 
 static const char *const TAG = "select";
 
-void Select::publish_state(const std::string &state) { this->publish_state(state.c_str()); }
-
-void Select::publish_state(const char *state) {
+void Select::publish_state(const std::string &state) {
   auto index = this->index_of(state);
+  const auto *name = this->get_name().c_str();
   if (index.has_value()) {
-    this->publish_state(index.value());
+    this->set_has_state(true);
+    this->state = state;
+    ESP_LOGD(TAG, "'%s': Sending state %s (index %zu)", name, state.c_str(), index.value());
+    this->state_callback_.call(state, index.value());
   } else {
-    ESP_LOGE(TAG, "'%s': Invalid option %s", this->get_name().c_str(), state);
+    ESP_LOGE(TAG, "'%s': invalid state for publish_state(): %s", name, state.c_str());
   }
 }
 
-void Select::publish_state(size_t index) {
-  if (!this->has_index(index)) {
-    ESP_LOGE(TAG, "'%s': Invalid index %zu", this->get_name().c_str(), index);
-    return;
-  }
-  const char *option = this->option_at(index);
-  this->set_has_state(true);
-  this->active_index_ = index;
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  this->state = option;  // Update deprecated member for backward compatibility
-#pragma GCC diagnostic pop
-  ESP_LOGD(TAG, "'%s': Sending state %s (index %zu)", this->get_name().c_str(), option, index);
-  // Callback signature requires std::string, create temporary for compatibility
-  this->state_callback_.call(std::string(option), index);
-}
-
-const char *Select::current_option() const { return this->has_state() ? this->option_at(this->active_index_) : ""; }
-
 void Select::add_on_state_callback(std::function<void(std::string, size_t)> &&callback) {
   this->state_callback_.add(std::move(callback));
 }
 
-bool Select::has_option(const std::string &option) const { return this->index_of(option.c_str()).has_value(); }
-
-bool Select::has_option(const char *option) const { return this->index_of(option).has_value(); }
+bool Select::has_option(const std::string &option) const { return this->index_of(option).has_value(); }
 
 bool Select::has_index(size_t index) const { return index < this->size(); }
 
@@ -52,12 +33,10 @@ size_t Select::size() const {
   return options.size();
 }
 
-optional<size_t> Select::index_of(const std::string &option) const { return this->index_of(option.c_str()); }
-
-optional<size_t> Select::index_of(const char *option) const {
+optional<size_t> Select::index_of(const std::string &option) const {
   const auto &options = traits.get_options();
   for (size_t i = 0; i < options.size(); i++) {
-    if (strcmp(options[i], option) == 0) {
+    if (strcmp(options[i], option.c_str()) == 0) {
       return i;
     }
   }
@@ -66,17 +45,19 @@ optional<size_t> Select::index_of(const char *option) const {
 
 optional<size_t> Select::active_index() const {
   if (this->has_state()) {
-    return this->active_index_;
+    return this->index_of(this->state);
+  } else {
+    return {};
   }
-  return {};
 }
 
 optional<std::string> Select::at(size_t index) const {
   if (this->has_index(index)) {
     const auto &options = traits.get_options();
     return std::string(options.at(index));
+  } else {
+    return {};
   }
-  return {};
 }
 
 const char *Select::option_at(size_t index) const { return traits.get_options().at(index); }

esphome/components/select/select.h

@@ -30,31 +30,16 @@ namespace select {
  */
 class Select : public EntityBase {
  public:
+  std::string state;
   SelectTraits traits;
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  /// @deprecated Use current_option() instead. This member will be removed in ESPHome 2026.5.0.
-  __attribute__((deprecated("Use current_option() instead of .state. Will be removed in 2026.5.0")))
-  std::string state{};
-
-  Select() = default;
-  ~Select() = default;
-#pragma GCC diagnostic pop
-
   void publish_state(const std::string &state);
-  void publish_state(const char *state);
-  void publish_state(size_t index);
-
-  /// Return the currently selected option (as const char* from flash).
-  const char *current_option() const;
 
   /// Instantiate a SelectCall object to modify this select component's state.
   SelectCall make_call() { return SelectCall(this); }
 
   /// Return whether this select component contains the provided option.
   bool has_option(const std::string &option) const;
-  bool has_option(const char *option) const;
 
   /// Return whether this select component contains the provided index offset.
   bool has_index(size_t index) const;
@@ -64,7 +49,6 @@ class Select : public EntityBase {
 
   /// Find the (optional) index offset of the provided option value.
   optional<size_t> index_of(const std::string &option) const;
-  optional<size_t> index_of(const char *option) const;
 
   /// Return the (optional) index offset of the currently active option.
   optional<size_t> active_index() const;
@@ -80,36 +64,13 @@ class Select : public EntityBase {
  protected:
   friend class SelectCall;
 
-  size_t active_index_{0};
-
-  /** Set the value of the select by index, this is an optional virtual method.
+  /** Set the value of the select, this is a virtual method that each select integration must implement.
    *
-   * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.
-   * Overriding this index-based version is PREFERRED as it avoids string conversions.
+   * This method is called by the SelectCall.
    *
-   * This method is called by the SelectCall when the index is already known.
-   * Default implementation converts to string and calls control(const std::string&).
-   *
-   * @param index The index as validated by the SelectCall.
+   * @param value The value as validated by the SelectCall.
    */
-  virtual void control(size_t index) { this->control(this->option_at(index)); }
-
-  /** Set the value of the select, this is a virtual method that each select integration can implement.
-   *
-   * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.
-   * Overriding control(size_t) is PREFERRED as it avoids string conversions.
-   *
-   * This method is called by control(size_t) when not overridden, or directly by external code.
-   * Default implementation converts to index and calls control(size_t).
-   *
-   * @param value The value as validated by the caller.
-   */
-  virtual void control(const std::string &value) {
-    auto index = this->index_of(value);
-    if (index.has_value()) {
-      this->control(index.value());
-    }
-  }
+  virtual void control(const std::string &value) = 0;
 
   CallbackManager<void(std::string, size_t)> state_callback_;
 };

esphome/components/select/select_call.cpp

@@ -7,21 +7,19 @@ namespace select {
 
 static const char *const TAG = "select";
 
-SelectCall &SelectCall::set_option(const std::string &option) { return this->with_option(option); }
-
-SelectCall &SelectCall::set_option(const char *option) { return this->with_option(option); }
-
-SelectCall &SelectCall::set_index(size_t index) { return this->with_index(index); }
-
-SelectCall &SelectCall::select_next(bool cycle) { return this->with_operation(SELECT_OP_NEXT).with_cycle(cycle); }
-
-SelectCall &SelectCall::select_previous(bool cycle) {
-  return this->with_operation(SELECT_OP_PREVIOUS).with_cycle(cycle);
+SelectCall &SelectCall::set_option(const std::string &option) {
+  return with_operation(SELECT_OP_SET).with_option(option);
 }
 
-SelectCall &SelectCall::select_first() { return this->with_operation(SELECT_OP_FIRST); }
+SelectCall &SelectCall::set_index(size_t index) { return with_operation(SELECT_OP_SET_INDEX).with_index(index); }
 
-SelectCall &SelectCall::select_last() { return this->with_operation(SELECT_OP_LAST); }
+SelectCall &SelectCall::select_next(bool cycle) { return with_operation(SELECT_OP_NEXT).with_cycle(cycle); }
+
+SelectCall &SelectCall::select_previous(bool cycle) { return with_operation(SELECT_OP_PREVIOUS).with_cycle(cycle); }
+
+SelectCall &SelectCall::select_first() { return with_operation(SELECT_OP_FIRST); }
+
+SelectCall &SelectCall::select_last() { return with_operation(SELECT_OP_LAST); }
 
 SelectCall &SelectCall::with_operation(SelectOperation operation) {
   this->operation_ = operation;
@@ -33,96 +31,89 @@ SelectCall &SelectCall::with_cycle(bool cycle) {
   return *this;
 }
 
-SelectCall &SelectCall::with_option(const std::string &option) { return this->with_option(option.c_str()); }
-
-SelectCall &SelectCall::with_option(const char *option) {
-  this->operation_ = SELECT_OP_SET;
-  // Find the option index - this validates the option exists
-  this->index_ = this->parent_->index_of(option);
+SelectCall &SelectCall::with_option(const std::string &option) {
+  this->option_ = option;
   return *this;
 }
 
 SelectCall &SelectCall::with_index(size_t index) {
-  this->operation_ = SELECT_OP_SET;
-  if (index >= this->parent_->size()) {
-    ESP_LOGW(TAG, "'%s' - Index value %zu out of bounds", this->parent_->get_name().c_str(), index);
-    this->index_ = {};  // Store nullopt for invalid index
-  } else {
-    this->index_ = index;
-  }
+  this->index_ = index;
   return *this;
 }
 
-optional<size_t> SelectCall::calculate_target_index_(const char *name) {
-  const auto &options = this->parent_->traits.get_options();
-  if (options.empty()) {
-    ESP_LOGW(TAG, "'%s' - Select has no options", name);
-    return {};
-  }
-
-  if (this->operation_ == SELECT_OP_FIRST) {
-    return 0;
-  }
-
-  if (this->operation_ == SELECT_OP_LAST) {
-    return options.size() - 1;
-  }
-
-  if (this->operation_ == SELECT_OP_SET) {
-    ESP_LOGD(TAG, "'%s' - Setting", name);
-    if (!this->index_.has_value()) {
-      ESP_LOGW(TAG, "'%s' - No option set", name);
-      return {};
-    }
-    return this->index_.value();
-  }
-
-  // SELECT_OP_NEXT or SELECT_OP_PREVIOUS
-  ESP_LOGD(TAG, "'%s' - Selecting %s, with%s cycling", name,
-           this->operation_ == SELECT_OP_NEXT ? LOG_STR_LITERAL("next") : LOG_STR_LITERAL("previous"),
-           this->cycle_ ? LOG_STR_LITERAL("") : LOG_STR_LITERAL("out"));
-
-  const auto size = options.size();
-  if (!this->parent_->has_state()) {
-    return this->operation_ == SELECT_OP_NEXT ? 0 : size - 1;
-  }
-
-  // Use cached active_index_ instead of index_of() lookup
-  const auto active_index = this->parent_->active_index_;
-  if (this->cycle_) {
-    return (size + active_index + (this->operation_ == SELECT_OP_NEXT ? +1 : -1)) % size;
-  }
-
-  if (this->operation_ == SELECT_OP_PREVIOUS && active_index > 0) {
-    return active_index - 1;
-  }
-
-  if (this->operation_ == SELECT_OP_NEXT && active_index < size - 1) {
-    return active_index + 1;
-  }
-
-  return {};  // Can't navigate further without cycling
-}
-
 void SelectCall::perform() {
   auto *parent = this->parent_;
   const auto *name = parent->get_name().c_str();
+  const auto &traits = parent->traits;
+  const auto &options = traits.get_options();
 
   if (this->operation_ == SELECT_OP_NONE) {
     ESP_LOGW(TAG, "'%s' - SelectCall performed without selecting an operation", name);
     return;
   }
-
-  // Calculate target index (with_index() and with_option() already validate bounds/existence)
-  auto target_index = this->calculate_target_index_(name);
-  if (!target_index.has_value()) {
+  if (options.empty()) {
+    ESP_LOGW(TAG, "'%s' - Cannot perform SelectCall, select has no options", name);
     return;
   }
 
-  auto idx = target_index.value();
-  // All operations use indices, call control() by index to avoid string conversion
-  ESP_LOGD(TAG, "'%s' - Set selected option to: %s", name, parent->option_at(idx));
-  parent->control(idx);
+  std::string target_value;
+
+  if (this->operation_ == SELECT_OP_SET) {
+    ESP_LOGD(TAG, "'%s' - Setting", name);
+    if (!this->option_.has_value()) {
+      ESP_LOGW(TAG, "'%s' - No option value set for SelectCall", name);
+      return;
+    }
+    target_value = this->option_.value();
+  } else if (this->operation_ == SELECT_OP_SET_INDEX) {
+    if (!this->index_.has_value()) {
+      ESP_LOGW(TAG, "'%s' - No index value set for SelectCall", name);
+      return;
+    }
+    if (this->index_.value() >= options.size()) {
+      ESP_LOGW(TAG, "'%s' - Index value %zu out of bounds", name, this->index_.value());
+      return;
+    }
+    target_value = options[this->index_.value()];
+  } else if (this->operation_ == SELECT_OP_FIRST) {
+    target_value = options.front();
+  } else if (this->operation_ == SELECT_OP_LAST) {
+    target_value = options.back();
+  } else if (this->operation_ == SELECT_OP_NEXT || this->operation_ == SELECT_OP_PREVIOUS) {
+    auto cycle = this->cycle_;
+    ESP_LOGD(TAG, "'%s' - Selecting %s, with%s cycling", name, this->operation_ == SELECT_OP_NEXT ? "next" : "previous",
+             cycle ? "" : "out");
+    if (!parent->has_state()) {
+      target_value = this->operation_ == SELECT_OP_NEXT ? options.front() : options.back();
+    } else {
+      auto index = parent->index_of(parent->state);
+      if (index.has_value()) {
+        auto size = options.size();
+        if (cycle) {
+          auto use_index = (size + index.value() + (this->operation_ == SELECT_OP_NEXT ? +1 : -1)) % size;
+          target_value = options[use_index];
+        } else {
+          if (this->operation_ == SELECT_OP_PREVIOUS && index.value() > 0) {
+            target_value = options[index.value() - 1];
+          } else if (this->operation_ == SELECT_OP_NEXT && index.value() < options.size() - 1) {
+            target_value = options[index.value() + 1];
+          } else {
+            return;
+          }
+        }
+      } else {
+        target_value = this->operation_ == SELECT_OP_NEXT ? options.front() : options.back();
+      }
+    }
+  }
+
+  if (!parent->has_option(target_value)) {
+    ESP_LOGW(TAG, "'%s' - Option %s is not a valid option", name, target_value.c_str());
+    return;
+  }
+
+  ESP_LOGD(TAG, "'%s' - Set selected option to: %s", name, target_value.c_str());
+  parent->control(target_value);
 }
 
 }  // namespace select

esphome/components/select/select_call.h

@@ -10,6 +10,7 @@ class Select;
 enum SelectOperation {
   SELECT_OP_NONE,
   SELECT_OP_SET,
+  SELECT_OP_SET_INDEX,
   SELECT_OP_NEXT,
   SELECT_OP_PREVIOUS,
   SELECT_OP_FIRST,
@@ -22,7 +23,6 @@ class SelectCall {
   void perform();
 
   SelectCall &set_option(const std::string &option);
-  SelectCall &set_option(const char *option);
   SelectCall &set_index(size_t index);
 
   SelectCall &select_next(bool cycle);
@@ -33,13 +33,11 @@ class SelectCall {
   SelectCall &with_operation(SelectOperation operation);
   SelectCall &with_cycle(bool cycle);
   SelectCall &with_option(const std::string &option);
-  SelectCall &with_option(const char *option);
   SelectCall &with_index(size_t index);
 
  protected:
-  __attribute__((always_inline)) inline optional<size_t> calculate_target_index_(const char *name);
-
   Select *const parent_;
+  optional<std::string> option_;
   optional<size_t> index_;
   SelectOperation operation_{SELECT_OP_NONE};
   bool cycle_;

esphome/components/speed/fan/speed_fan.cpp

@@ -29,7 +29,7 @@ void SpeedFan::control(const fan::FanCall &call) {
     this->oscillating = *call.get_oscillating();
   if (call.get_direction().has_value())
     this->direction = *call.get_direction();
-  this->preset_mode = call.get_preset_mode();
+  this->set_preset_mode_(call.get_preset_mode());
 
   this->write_state_();
   this->publish_state();

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -42,21 +42,23 @@ static const LogString *sensor_type_to_string(AlarmSensorType type) {
 #endif
 
 void TemplateAlarmControlPanel::dump_config() {
+  ESP_LOGCONFIG(TAG, "TemplateAlarmControlPanel:");
   ESP_LOGCONFIG(TAG,
-                "TemplateAlarmControlPanel:\n"
                 "  Current State: %s\n"
-                "  Number of Codes: %u\n"
-                "  Requires Code To Arm: %s\n"
-                "  Arming Away Time: %" PRIu32 "s\n"
-                "  Arming Home Time: %" PRIu32 "s\n"
-                "  Arming Night Time: %" PRIu32 "s\n"
+                "  Number of Codes: %u",
+                LOG_STR_ARG(alarm_control_panel_state_to_string(this->current_state_)), this->codes_.size());
+  if (!this->codes_.empty())
+    ESP_LOGCONFIG(TAG, "  Requires Code To Arm: %s", YESNO(this->requires_code_to_arm_));
+  ESP_LOGCONFIG(TAG, "  Arming Away Time: %" PRIu32 "s", (this->arming_away_time_ / 1000));
+  if (this->arming_home_time_ != 0)
+    ESP_LOGCONFIG(TAG, "  Arming Home Time: %" PRIu32 "s", (this->arming_home_time_ / 1000));
+  if (this->arming_night_time_ != 0)
+    ESP_LOGCONFIG(TAG, "  Arming Night Time: %" PRIu32 "s", (this->arming_night_time_ / 1000));
+  ESP_LOGCONFIG(TAG,
                 "  Pending Time: %" PRIu32 "s\n"
                 "  Trigger Time: %" PRIu32 "s\n"
                 "  Supported Features: %" PRIu32,
-                LOG_STR_ARG(alarm_control_panel_state_to_string(this->current_state_)), this->codes_.size(),
-                YESNO(!this->codes_.empty() && this->requires_code_to_arm_), (this->arming_away_time_ / 1000),
-                (this->arming_home_time_ / 1000), (this->arming_night_time_ / 1000), (this->pending_time_ / 1000),
-                (this->trigger_time_ / 1000), this->get_supported_features());
+                (this->pending_time_ / 1000), (this->trigger_time_ / 1000), this->get_supported_features());
 #ifdef USE_BINARY_SENSOR
   for (auto const &[sensor, info] : this->sensor_map_) {
     ESP_LOGCONFIG(TAG,

esphome/components/template/fan/template_fan.cpp

@@ -29,7 +29,7 @@ void TemplateFan::control(const fan::FanCall &call) {
     this->oscillating = *call.get_oscillating();
   if (call.get_direction().has_value() && this->has_direction_)
     this->direction = *call.get_direction();
-  this->preset_mode = call.get_preset_mode();
+  this->set_preset_mode_(call.get_preset_mode());
 
   this->publish_state();
 }

esphome/components/template/select/template_select.cpp

@@ -24,7 +24,7 @@ void TemplateSelect::setup() {
     ESP_LOGD(TAG, "State from initial: %s", this->option_at(index));
   }
 
-  this->publish_state(index);
+  this->publish_state(this->at(index).value());
 }
 
 void TemplateSelect::update() {
@@ -41,14 +41,16 @@ void TemplateSelect::update() {
   }
 }
 
-void TemplateSelect::control(size_t index) {
-  this->set_trigger_->trigger(std::string(this->option_at(index)));
+void TemplateSelect::control(const std::string &value) {
+  this->set_trigger_->trigger(value);
 
   if (this->optimistic_)
-    this->publish_state(index);
+    this->publish_state(value);
 
-  if (this->restore_value_)
-    this->pref_.save(&index);
+  if (this->restore_value_) {
+    auto index = this->index_of(value);
+    this->pref_.save(&index.value());
+  }
 }
 
 void TemplateSelect::dump_config() {

esphome/components/template/select/template_select.h

@@ -24,7 +24,7 @@ class TemplateSelect : public select::Select, public PollingComponent {
   void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
   bool optimistic_ = false;
   size_t initial_option_index_{0};
   bool restore_value_ = false;

esphome/components/thermostat/thermostat_climate.cpp

@@ -54,7 +54,7 @@ void ThermostatClimate::setup() {
     if (this->default_preset_ != climate::ClimatePreset::CLIMATE_PRESET_NONE) {
       this->change_preset_(this->default_preset_);
     } else if (!this->default_custom_preset_.empty()) {
-      this->change_custom_preset_(this->default_custom_preset_.c_str());
+      this->change_custom_preset_(this->default_custom_preset_);
     }
   }
 
@@ -218,13 +218,12 @@ void ThermostatClimate::control(const climate::ClimateCall &call) {
       this->preset = call.get_preset().value();
     }
   }
-  if (call.has_custom_preset()) {
+  if (call.get_custom_preset().has_value()) {
     // setup_complete_ blocks modifying/resetting the temps immediately after boot
     if (this->setup_complete_) {
-      this->change_custom_preset_(call.get_custom_preset());
+      this->change_custom_preset_(call.get_custom_preset().value());
     } else {
-      // Use the base class method which handles pointer lookup internally
-      this->set_custom_preset_(call.get_custom_preset());
+      this->custom_preset = call.get_custom_preset().value();
     }
   }
 
@@ -322,17 +321,9 @@ climate::ClimateTraits ThermostatClimate::traits() {
   for (auto &it : this->preset_config_) {
     traits.add_supported_preset(it.first);
   }
-
-  // Extract custom preset names from the custom_preset_config_ map
-  if (!this->custom_preset_config_.empty()) {
-    std::vector<const char *> custom_preset_names;
-    custom_preset_names.reserve(this->custom_preset_config_.size());
-    for (const auto &it : this->custom_preset_config_) {
-      custom_preset_names.push_back(it.first.c_str());
-    }
-    traits.set_supported_custom_presets(custom_preset_names);
+  for (auto &it : this->custom_preset_config_) {
+    traits.add_supported_custom_preset(it.first);
   }
-
   return traits;
 }
 
@@ -1162,7 +1153,7 @@ void ThermostatClimate::change_preset_(climate::ClimatePreset preset) {
         this->preset.value() != preset) {
       // Fire any preset changed trigger if defined
       Trigger<> *trig = this->preset_change_trigger_;
-      this->set_preset_(preset);
+      this->preset = preset;
       if (trig != nullptr) {
         trig->trigger();
       }
@@ -1172,36 +1163,36 @@ void ThermostatClimate::change_preset_(climate::ClimatePreset preset) {
     } else {
       ESP_LOGI(TAG, "No changes required to apply preset %s", LOG_STR_ARG(climate::climate_preset_to_string(preset)));
     }
+    this->custom_preset.reset();
+    this->preset = preset;
   } else {
     ESP_LOGW(TAG, "Preset %s not configured; ignoring", LOG_STR_ARG(climate::climate_preset_to_string(preset)));
   }
 }
 
-void ThermostatClimate::change_custom_preset_(const char *custom_preset) {
+void ThermostatClimate::change_custom_preset_(const std::string &custom_preset) {
   auto config = this->custom_preset_config_.find(custom_preset);
 
   if (config != this->custom_preset_config_.end()) {
-    ESP_LOGV(TAG, "Custom preset %s requested", custom_preset);
-    if (this->change_preset_internal_(config->second) || !this->has_custom_preset() ||
-        strcmp(this->get_custom_preset(), custom_preset) != 0) {
+    ESP_LOGV(TAG, "Custom preset %s requested", custom_preset.c_str());
+    if (this->change_preset_internal_(config->second) || (!this->custom_preset.has_value()) ||
+        this->custom_preset.value() != custom_preset) {
       // Fire any preset changed trigger if defined
       Trigger<> *trig = this->preset_change_trigger_;
-      // Use the base class method which handles pointer lookup and preset reset internally
-      this->set_custom_preset_(custom_preset);
+      this->custom_preset = custom_preset;
       if (trig != nullptr) {
         trig->trigger();
       }
 
       this->refresh();
-      ESP_LOGI(TAG, "Custom preset %s applied", custom_preset);
+      ESP_LOGI(TAG, "Custom preset %s applied", custom_preset.c_str());
     } else {
-      ESP_LOGI(TAG, "No changes required to apply custom preset %s", custom_preset);
-      // Note: set_custom_preset_() above handles preset.reset() and custom_preset_ assignment internally.
-      // The old code had these lines here unconditionally, which was a bug (double assignment, state modification
-      // even when no changes were needed). Now properly handled by the protected setter with mutual exclusion.
+      ESP_LOGI(TAG, "No changes required to apply custom preset %s", custom_preset.c_str());
     }
+    this->preset.reset();
+    this->custom_preset = custom_preset;
   } else {
-    ESP_LOGW(TAG, "Custom preset %s not configured; ignoring", custom_preset);
+    ESP_LOGW(TAG, "Custom preset %s not configured; ignoring", custom_preset.c_str());
   }
 }
 

esphome/components/thermostat/thermostat_climate.h

@@ -199,7 +199,7 @@ class ThermostatClimate : public climate::Climate, public Component {
   /// Change to a provided preset setting; will reset temperature, mode, fan, and swing modes accordingly
   void change_preset_(climate::ClimatePreset preset);
   /// Change to a provided custom preset setting; will reset temperature, mode, fan, and swing modes accordingly
-  void change_custom_preset_(const char *custom_preset);
+  void change_custom_preset_(const std::string &custom_preset);
 
   /// Applies the temperature, mode, fan, and swing modes of the provided config.
   /// This is agnostic of custom vs built in preset

esphome/components/tuya/select/tuya_select.cpp

@@ -17,21 +17,28 @@ void TuyaSelect::setup() {
       return;
     }
     size_t mapping_idx = std::distance(mappings.cbegin(), it);
-    this->publish_state(mapping_idx);
+    auto value = this->at(mapping_idx);
+    this->publish_state(value.value());
   });
 }
 
-void TuyaSelect::control(size_t index) {
+void TuyaSelect::control(const std::string &value) {
   if (this->optimistic_)
-    this->publish_state(index);
+    this->publish_state(value);
 
-  uint8_t mapping = this->mappings_.at(index);
-  ESP_LOGV(TAG, "Setting %u datapoint value to %u:%s", this->select_id_, mapping, this->option_at(index));
-  if (this->is_int_) {
-    this->parent_->set_integer_datapoint_value(this->select_id_, mapping);
-  } else {
-    this->parent_->set_enum_datapoint_value(this->select_id_, mapping);
+  auto idx = this->index_of(value);
+  if (idx.has_value()) {
+    uint8_t mapping = this->mappings_.at(idx.value());
+    ESP_LOGV(TAG, "Setting %u datapoint value to %u:%s", this->select_id_, mapping, value.c_str());
+    if (this->is_int_) {
+      this->parent_->set_integer_datapoint_value(this->select_id_, mapping);
+    } else {
+      this->parent_->set_enum_datapoint_value(this->select_id_, mapping);
+    }
+    return;
   }
+
+  ESP_LOGW(TAG, "Invalid value %s", value.c_str());
 }
 
 void TuyaSelect::dump_config() {

esphome/components/tuya/select/tuya_select.h

@@ -23,7 +23,7 @@ class TuyaSelect : public select::Select, public Component {
   void set_select_mappings(std::vector<uint8_t> mappings) { this->mappings_ = std::move(mappings); }
 
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 
   Tuya *parent_;
   bool optimistic_ = false;

esphome/components/web_server/web_server.cpp

@@ -1188,7 +1188,7 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
 
     if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
-      std::string data = this->select_json(obj, obj->has_state() ? obj->current_option() : "", detail);
+      std::string data = this->select_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1208,14 +1208,12 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
   request->send(404);
 }
 std::string WebServer::select_state_json_generator(WebServer *web_server, void *source) {
-  auto *obj = (select::Select *) (source);
-  return web_server->select_json(obj, obj->has_state() ? obj->current_option() : "", DETAIL_STATE);
+  return web_server->select_json((select::Select *) (source), ((select::Select *) (source))->state, DETAIL_STATE);
 }
 std::string WebServer::select_all_json_generator(WebServer *web_server, void *source) {
-  auto *obj = (select::Select *) (source);
-  return web_server->select_json(obj, obj->has_state() ? obj->current_option() : "", DETAIL_ALL);
+  return web_server->select_json((select::Select *) (source), ((select::Select *) (source))->state, DETAIL_ALL);
 }
-std::string WebServer::select_json(select::Select *obj, const char *value, JsonDetail start_config) {
+std::string WebServer::select_json(select::Select *obj, const std::string &value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1317,7 +1315,7 @@ std::string WebServer::climate_json(climate::Climate *obj, JsonDetail start_conf
       for (climate::ClimatePreset m : traits.get_supported_presets())
         opt.add(PSTR_LOCAL(climate::climate_preset_to_string(m)));
     }
-    if (!traits.get_supported_custom_presets().empty() && obj->has_custom_preset()) {
+    if (!traits.get_supported_custom_presets().empty() && obj->custom_preset.has_value()) {
       JsonArray opt = root["custom_presets"].to<JsonArray>();
       for (auto const &custom_preset : traits.get_supported_custom_presets())
         opt.add(custom_preset);
@@ -1338,14 +1336,14 @@ std::string WebServer::climate_json(climate::Climate *obj, JsonDetail start_conf
   if (traits.get_supports_fan_modes() && obj->fan_mode.has_value()) {
     root["fan_mode"] = PSTR_LOCAL(climate_fan_mode_to_string(obj->fan_mode.value()));
   }
-  if (!traits.get_supported_custom_fan_modes().empty() && obj->has_custom_fan_mode()) {
-    root["custom_fan_mode"] = obj->get_custom_fan_mode();
+  if (!traits.get_supported_custom_fan_modes().empty() && obj->custom_fan_mode.has_value()) {
+    root["custom_fan_mode"] = obj->custom_fan_mode.value().c_str();
   }
   if (traits.get_supports_presets() && obj->preset.has_value()) {
     root["preset"] = PSTR_LOCAL(climate_preset_to_string(obj->preset.value()));
   }
-  if (!traits.get_supported_custom_presets().empty() && obj->has_custom_preset()) {
-    root["custom_preset"] = obj->get_custom_preset();
+  if (!traits.get_supported_custom_presets().empty() && obj->custom_preset.has_value()) {
+    root["custom_preset"] = obj->custom_preset.value().c_str();
   }
   if (traits.get_supports_swing_modes()) {
     root["swing_mode"] = PSTR_LOCAL(climate_swing_mode_to_string(obj->swing_mode));

esphome/components/web_server/web_server.h

@@ -410,7 +410,7 @@ class WebServer : public Controller, public Component, public AsyncWebHandler {
   static std::string select_state_json_generator(WebServer *web_server, void *source);
   static std::string select_all_json_generator(WebServer *web_server, void *source);
   /// Dump the select state with its value as a JSON string.
-  std::string select_json(select::Select *obj, const char *value, JsonDetail start_config);
+  std::string select_json(select::Select *obj, const std::string &value, JsonDetail start_config);
 #endif
 
 #ifdef USE_CLIMATE

requirements.txt

@@ -12,7 +12,7 @@ platformio==6.1.18  # When updating platformio, also update /docker/Dockerfile
 esptool==5.1.0
 click==8.1.7
 esphome-dashboard==20251013.0
-aioesphomeapi==42.6.0
+aioesphomeapi==42.5.0
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.18.16 # dashboard_import

script/api_protobuf/api_protobuf.py

@@ -1610,9 +1610,8 @@ class RepeatedTypeInfo(TypeInfo):
             # Other types need the actual value
             # Special handling for const char* elements
             if self._use_pointer and "const char" in self._container_no_template:
-                field_id_size = self.calculate_field_id_size()
                 o += f"  for (const char *it : {container_ref}) {{\n"
-                o += f"    size.add_length_force({field_id_size}, strlen(it));\n"
+                o += "    size.add_length_force(1, strlen(it));\n"
             else:
                 auto_ref = "" if self._ti_is_bool else "&"
                 o += f"  for (const auto {auto_ref}it : {container_ref}) {{\n"

tests/integration/fixtures/climate_custom_fan_modes_and_presets.yaml

@@ -1,40 +0,0 @@
-esphome:
-  name: climate-custom-modes-test
-host:
-api:
-logger:
-
-sensor:
-  - platform: template
-    id: thermostat_sensor
-    lambda: "return 22.0;"
-
-climate:
-  - platform: thermostat
-    id: test_thermostat
-    name: Test Thermostat Custom Modes
-    sensor: thermostat_sensor
-    preset:
-      - name: Away
-        default_target_temperature_low: 16°C
-        default_target_temperature_high: 20°C
-      - name: Eco Plus
-        default_target_temperature_low: 18°C
-        default_target_temperature_high: 22°C
-      - name: Super Saver
-        default_target_temperature_low: 20°C
-        default_target_temperature_high: 24°C
-      - name: Vacation Mode
-        default_target_temperature_low: 15°C
-        default_target_temperature_high: 18°C
-    idle_action:
-      - logger.log: idle_action
-    cool_action:
-      - logger.log: cool_action
-    heat_action:
-      - logger.log: heat_action
-    min_cooling_off_time: 10s
-    min_cooling_run_time: 10s
-    min_heating_off_time: 10s
-    min_heating_run_time: 10s
-    min_idle_time: 10s

tests/integration/test_climate_custom_modes.py

@@ -1,42 +0,0 @@
-"""Integration test for climate custom presets."""
-
-from __future__ import annotations
-
-from aioesphomeapi import ClimateInfo, ClimatePreset
-import pytest
-
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-
-@pytest.mark.asyncio
-async def test_climate_custom_fan_modes_and_presets(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    """Test that custom presets are properly exposed via API."""
-    async with run_compiled(yaml_config), api_client_connected() as client:
-        # Get entities and services
-        entities, services = await client.list_entities_services()
-        climate_infos = [e for e in entities if isinstance(e, ClimateInfo)]
-        assert len(climate_infos) == 1, "Expected exactly 1 climate entity"
-
-        test_climate = climate_infos[0]
-
-        # Verify enum presets are exposed (from preset: config map)
-        assert ClimatePreset.AWAY in test_climate.supported_presets, (
-            "Expected AWAY in enum presets"
-        )
-
-        # Verify custom string presets are exposed (non-standard preset names from preset map)
-        custom_presets = test_climate.supported_custom_presets
-        assert len(custom_presets) == 3, (
-            f"Expected 3 custom presets, got {len(custom_presets)}: {custom_presets}"
-        )
-        assert "Eco Plus" in custom_presets, "Expected 'Eco Plus' in custom presets"
-        assert "Super Saver" in custom_presets, (
-            "Expected 'Super Saver' in custom presets"
-        )
-        assert "Vacation Mode" in custom_presets, (
-            "Expected 'Vacation Mode' in custom presets"
-        )