Merge remote-tracking branch 'upstream/dev' into mqtt_enum_flash

# Conflicts:
#	esphome/components/mqtt/mqtt_alarm_control_panel.cpp
#	esphome/components/mqtt/mqtt_component.cpp
#	esphome/components/mqtt/mqtt_component.h
#	esphome/components/mqtt/mqtt_cover.cpp
#	esphome/components/mqtt/mqtt_valve.cpp

.clang-tidy.hash

@@ -1 +1 @@
-a172e2f65981e98354cc6b5ecf69bdb055dd13602226042ab2c7acd037a2bf41
+d565b0589e35e692b5f2fc0c14723a99595b4828a3a3ef96c442e86a23176c00

esphome/components/bl0940/number/calibration_number.cpp

@@ -9,7 +9,7 @@ static const char *const TAG = "bl0940.number";
 void CalibrationNumber::setup() {
   float value = 0.0f;
   if (this->restore_value_) {
-    this->pref_ = this->make_entity_preference<float>();
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     if (!this->pref_.load(&value)) {
       value = 0.0f;
     }

esphome/components/climate/climate.cpp

@@ -360,7 +360,8 @@ void Climate::add_on_control_callback(std::function<void(ClimateCall &)> &&callb
 static const uint32_t RESTORE_STATE_VERSION = 0x848EA6ADUL;
 
 optional<ClimateDeviceRestoreState> Climate::restore_state_() {
-  this->rtc_ = this->make_entity_preference<ClimateDeviceRestoreState>(RESTORE_STATE_VERSION);
+  this->rtc_ = global_preferences->make_preference<ClimateDeviceRestoreState>(this->get_preference_hash() ^
+                                                                              RESTORE_STATE_VERSION);
   ClimateDeviceRestoreState recovered{};
   if (!this->rtc_.load(&recovered))
     return {};

esphome/components/cover/cover.cpp

@@ -187,7 +187,7 @@ void Cover::publish_state(bool save) {
   }
 }
 optional<CoverRestoreState> Cover::restore_state_() {
-  this->rtc_ = this->make_entity_preference<CoverRestoreState>();
+  this->rtc_ = global_preferences->make_preference<CoverRestoreState>(this->get_preference_hash());
   CoverRestoreState recovered{};
   if (!this->rtc_.load(&recovered))
     return {};

esphome/components/duty_time/duty_time_sensor.cpp

@@ -41,7 +41,7 @@ void DutyTimeSensor::setup() {
   uint32_t seconds = 0;
 
   if (this->restore_) {
-    this->pref_ = this->make_entity_preference<uint32_t>();
+    this->pref_ = global_preferences->make_preference<uint32_t>(this->get_preference_hash());
     this->pref_.load(&seconds);
   }
 

esphome/components/factory_reset/factory_reset.cpp

@@ -3,7 +3,6 @@
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 #include <cinttypes>
 
@@ -20,8 +19,7 @@ static bool was_power_cycled() {
 #endif
 #ifdef USE_ESP8266
   auto reset_reason = EspClass::getResetReason();
-  return ESPHOME_strcasecmp_P(reset_reason.c_str(), ESPHOME_PSTR("power On")) == 0 ||
-         ESPHOME_strcasecmp_P(reset_reason.c_str(), ESPHOME_PSTR("external system")) == 0;
+  return strcasecmp(reset_reason.c_str(), "power On") == 0 || strcasecmp(reset_reason.c_str(), "external system") == 0;
 #endif
 #ifdef USE_LIBRETINY
   auto reason = lt_get_reboot_reason();

esphome/components/fan/fan.cpp

@@ -227,7 +227,8 @@ void Fan::publish_state() {
 constexpr uint32_t RESTORE_STATE_VERSION = 0x71700ABA;
 optional<FanRestoreState> Fan::restore_state_() {
   FanRestoreState recovered{};
-  this->rtc_ = this->make_entity_preference<FanRestoreState>(RESTORE_STATE_VERSION);
+  this->rtc_ =
+      global_preferences->make_preference<FanRestoreState>(this->get_preference_hash() ^ RESTORE_STATE_VERSION);
   bool restored = this->rtc_.load(&recovered);
 
   switch (this->restore_mode_) {

esphome/components/haier/haier_base.cpp

@@ -350,7 +350,8 @@ ClimateTraits HaierClimateBase::traits() { return traits_; }
 
 void HaierClimateBase::initialization() {
   constexpr uint32_t restore_settings_version = 0xA77D21EF;
-  this->base_rtc_ = this->make_entity_preference<HaierBaseSettings>(restore_settings_version);
+  this->base_rtc_ =
+      global_preferences->make_preference<HaierBaseSettings>(this->get_preference_hash() ^ restore_settings_version);
   HaierBaseSettings recovered;
   if (!this->base_rtc_.load(&recovered)) {
     recovered = {false, true};

esphome/components/haier/hon_climate.cpp

@@ -515,7 +515,8 @@ haier_protocol::HaierMessage HonClimate::get_power_message(bool state) {
 void HonClimate::initialization() {
   HaierClimateBase::initialization();
   constexpr uint32_t restore_settings_version = 0x57EB59DDUL;
-  this->hon_rtc_ = this->make_entity_preference<HonSettings>(restore_settings_version);
+  this->hon_rtc_ =
+      global_preferences->make_preference<HonSettings>(this->get_preference_hash() ^ restore_settings_version);
   HonSettings recovered;
   if (this->hon_rtc_.load(&recovered)) {
     this->settings_ = recovered;

esphome/components/integration/integration_sensor.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "integration";
 
 void IntegrationSensor::setup() {
   if (this->restore_) {
-    this->pref_ = this->make_entity_preference<float>();
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     float preference_value = 0;
     this->pref_.load(&preference_value);
     this->result_ = preference_value;

esphome/components/ld2450/ld2450.cpp

@@ -184,7 +184,7 @@ static inline bool validate_header_footer(const uint8_t *header_footer, const ui
 void LD2450Component::setup() {
 #ifdef USE_NUMBER
   if (this->presence_timeout_number_ != nullptr) {
-    this->pref_ = this->presence_timeout_number_->make_entity_preference<float>();
+    this->pref_ = global_preferences->make_preference<float>(this->presence_timeout_number_->get_preference_hash());
     this->set_presence_timeout();
   }
 #endif

esphome/components/light/light_state.cpp

@@ -44,7 +44,7 @@ void LightState::setup() {
     case LIGHT_RESTORE_DEFAULT_ON:
     case LIGHT_RESTORE_INVERTED_DEFAULT_OFF:
     case LIGHT_RESTORE_INVERTED_DEFAULT_ON:
-      this->rtc_ = this->make_entity_preference<LightStateRTCState>();
+      this->rtc_ = global_preferences->make_preference<LightStateRTCState>(this->get_preference_hash());
       // Attempt to load from preferences, else fall back to default values
       if (!this->rtc_.load(&recovered)) {
         recovered.state = (this->restore_mode_ == LIGHT_RESTORE_DEFAULT_ON ||
@@ -57,7 +57,7 @@ void LightState::setup() {
       break;
     case LIGHT_RESTORE_AND_OFF:
     case LIGHT_RESTORE_AND_ON:
-      this->rtc_ = this->make_entity_preference<LightStateRTCState>();
+      this->rtc_ = global_preferences->make_preference<LightStateRTCState>(this->get_preference_hash());
       this->rtc_.load(&recovered);
       recovered.state = (this->restore_mode_ == LIGHT_RESTORE_AND_ON);
       break;

esphome/components/lvgl/number/lvgl_number.h

@@ -21,7 +21,7 @@ class LVGLNumber : public number::Number, public Component {
   void setup() override {
     float value = this->value_lambda_();
     if (this->restore_) {
-      this->pref_ = this->make_entity_preference<float>();
+      this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
       if (this->pref_.load(&value)) {
         this->control_lambda_(value);
       }

esphome/components/lvgl/select/lvgl_select.h

@@ -20,7 +20,7 @@ class LVGLSelect : public select::Select, public Component {
     this->set_options_();
     if (this->restore_) {
       size_t index;
-      this->pref_ = this->make_entity_preference<size_t>();
+      this->pref_ = global_preferences->make_preference<size_t>(this->get_preference_hash());
       if (this->pref_.load(&index))
         this->widget_->set_selected_index(index, LV_ANIM_OFF);
     }

esphome/components/mqtt/mqtt_alarm_control_panel.cpp

@@ -13,27 +13,54 @@ static const char *const TAG = "mqtt.alarm_control_panel";
 
 using namespace esphome::alarm_control_panel;
 
+static ProgmemStr alarm_state_to_mqtt_str(AlarmControlPanelState state) {
+  switch (state) {
+    case ACP_STATE_DISARMED:
+      return ESPHOME_F("disarmed");
+    case ACP_STATE_ARMED_HOME:
+      return ESPHOME_F("armed_home");
+    case ACP_STATE_ARMED_AWAY:
+      return ESPHOME_F("armed_away");
+    case ACP_STATE_ARMED_NIGHT:
+      return ESPHOME_F("armed_night");
+    case ACP_STATE_ARMED_VACATION:
+      return ESPHOME_F("armed_vacation");
+    case ACP_STATE_ARMED_CUSTOM_BYPASS:
+      return ESPHOME_F("armed_custom_bypass");
+    case ACP_STATE_PENDING:
+      return ESPHOME_F("pending");
+    case ACP_STATE_ARMING:
+      return ESPHOME_F("arming");
+    case ACP_STATE_DISARMING:
+      return ESPHOME_F("disarming");
+    case ACP_STATE_TRIGGERED:
+      return ESPHOME_F("triggered");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
 MQTTAlarmControlPanelComponent::MQTTAlarmControlPanelComponent(AlarmControlPanel *alarm_control_panel)
     : alarm_control_panel_(alarm_control_panel) {}
 void MQTTAlarmControlPanelComponent::setup() {
   this->alarm_control_panel_->add_on_state_callback([this]() { this->publish_state(); });
   this->subscribe(this->get_command_topic_(), [this](const std::string &topic, const std::string &payload) {
     auto call = this->alarm_control_panel_->make_call();
-    if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_AWAY")) == 0) {
+    if (strcasecmp(payload.c_str(), "ARM_AWAY") == 0) {
       call.arm_away();
-    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_HOME")) == 0) {
+    } else if (strcasecmp(payload.c_str(), "ARM_HOME") == 0) {
       call.arm_home();
-    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_NIGHT")) == 0) {
+    } else if (strcasecmp(payload.c_str(), "ARM_NIGHT") == 0) {
       call.arm_night();
-    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_VACATION")) == 0) {
+    } else if (strcasecmp(payload.c_str(), "ARM_VACATION") == 0) {
       call.arm_vacation();
-    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("ARM_CUSTOM_BYPASS")) == 0) {
+    } else if (strcasecmp(payload.c_str(), "ARM_CUSTOM_BYPASS") == 0) {
       call.arm_custom_bypass();
-    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("DISARM")) == 0) {
+    } else if (strcasecmp(payload.c_str(), "DISARM") == 0) {
       call.disarm();
-    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("PENDING")) == 0) {
+    } else if (strcasecmp(payload.c_str(), "PENDING") == 0) {
       call.pending();
-    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("TRIGGERED")) == 0) {
+    } else if (strcasecmp(payload.c_str(), "TRIGGERED") == 0) {
       call.triggered();
     } else {
       ESP_LOGW(TAG, "'%s': Received unknown command payload %s", this->friendly_name_().c_str(), payload.c_str());
@@ -85,43 +112,9 @@ const EntityBase *MQTTAlarmControlPanelComponent::get_entity() const { return th
 
 bool MQTTAlarmControlPanelComponent::send_initial_state() { return this->publish_state(); }
 bool MQTTAlarmControlPanelComponent::publish_state() {
-  const char *state_s;
-  switch (this->alarm_control_panel_->get_state()) {
-    case ACP_STATE_DISARMED:
-      state_s = "disarmed";
-      break;
-    case ACP_STATE_ARMED_HOME:
-      state_s = "armed_home";
-      break;
-    case ACP_STATE_ARMED_AWAY:
-      state_s = "armed_away";
-      break;
-    case ACP_STATE_ARMED_NIGHT:
-      state_s = "armed_night";
-      break;
-    case ACP_STATE_ARMED_VACATION:
-      state_s = "armed_vacation";
-      break;
-    case ACP_STATE_ARMED_CUSTOM_BYPASS:
-      state_s = "armed_custom_bypass";
-      break;
-    case ACP_STATE_PENDING:
-      state_s = "pending";
-      break;
-    case ACP_STATE_ARMING:
-      state_s = "arming";
-      break;
-    case ACP_STATE_DISARMING:
-      state_s = "disarming";
-      break;
-    case ACP_STATE_TRIGGERED:
-      state_s = "triggered";
-      break;
-    default:
-      state_s = "unknown";
-  }
   char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  return this->publish(this->get_state_topic_to_(topic_buf),
+                       alarm_state_to_mqtt_str(this->alarm_control_panel_->get_state()));
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_climate.cpp

@@ -1,5 +1,6 @@
 #include "mqtt_climate.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -12,6 +13,111 @@ static const char *const TAG = "mqtt.climate";
 
 using namespace esphome::climate;
 
+static ProgmemStr climate_mode_to_mqtt_str(ClimateMode mode) {
+  switch (mode) {
+    case CLIMATE_MODE_OFF:
+      return ESPHOME_F("off");
+    case CLIMATE_MODE_HEAT_COOL:
+      return ESPHOME_F("heat_cool");
+    case CLIMATE_MODE_AUTO:
+      return ESPHOME_F("auto");
+    case CLIMATE_MODE_COOL:
+      return ESPHOME_F("cool");
+    case CLIMATE_MODE_HEAT:
+      return ESPHOME_F("heat");
+    case CLIMATE_MODE_FAN_ONLY:
+      return ESPHOME_F("fan_only");
+    case CLIMATE_MODE_DRY:
+      return ESPHOME_F("dry");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
+static ProgmemStr climate_action_to_mqtt_str(ClimateAction action) {
+  switch (action) {
+    case CLIMATE_ACTION_OFF:
+      return ESPHOME_F("off");
+    case CLIMATE_ACTION_COOLING:
+      return ESPHOME_F("cooling");
+    case CLIMATE_ACTION_HEATING:
+      return ESPHOME_F("heating");
+    case CLIMATE_ACTION_IDLE:
+      return ESPHOME_F("idle");
+    case CLIMATE_ACTION_DRYING:
+      return ESPHOME_F("drying");
+    case CLIMATE_ACTION_FAN:
+      return ESPHOME_F("fan");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
+static ProgmemStr climate_fan_mode_to_mqtt_str(ClimateFanMode fan_mode) {
+  switch (fan_mode) {
+    case CLIMATE_FAN_ON:
+      return ESPHOME_F("on");
+    case CLIMATE_FAN_OFF:
+      return ESPHOME_F("off");
+    case CLIMATE_FAN_AUTO:
+      return ESPHOME_F("auto");
+    case CLIMATE_FAN_LOW:
+      return ESPHOME_F("low");
+    case CLIMATE_FAN_MEDIUM:
+      return ESPHOME_F("medium");
+    case CLIMATE_FAN_HIGH:
+      return ESPHOME_F("high");
+    case CLIMATE_FAN_MIDDLE:
+      return ESPHOME_F("middle");
+    case CLIMATE_FAN_FOCUS:
+      return ESPHOME_F("focus");
+    case CLIMATE_FAN_DIFFUSE:
+      return ESPHOME_F("diffuse");
+    case CLIMATE_FAN_QUIET:
+      return ESPHOME_F("quiet");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
+static ProgmemStr climate_swing_mode_to_mqtt_str(ClimateSwingMode swing_mode) {
+  switch (swing_mode) {
+    case CLIMATE_SWING_OFF:
+      return ESPHOME_F("off");
+    case CLIMATE_SWING_BOTH:
+      return ESPHOME_F("both");
+    case CLIMATE_SWING_VERTICAL:
+      return ESPHOME_F("vertical");
+    case CLIMATE_SWING_HORIZONTAL:
+      return ESPHOME_F("horizontal");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
+static ProgmemStr climate_preset_to_mqtt_str(ClimatePreset preset) {
+  switch (preset) {
+    case CLIMATE_PRESET_NONE:
+      return ESPHOME_F("none");
+    case CLIMATE_PRESET_HOME:
+      return ESPHOME_F("home");
+    case CLIMATE_PRESET_ECO:
+      return ESPHOME_F("eco");
+    case CLIMATE_PRESET_AWAY:
+      return ESPHOME_F("away");
+    case CLIMATE_PRESET_BOOST:
+      return ESPHOME_F("boost");
+    case CLIMATE_PRESET_COMFORT:
+      return ESPHOME_F("comfort");
+    case CLIMATE_PRESET_SLEEP:
+      return ESPHOME_F("sleep");
+    case CLIMATE_PRESET_ACTIVITY:
+      return ESPHOME_F("activity");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
 void MQTTClimateComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   auto traits = this->device_->get_traits();
@@ -260,34 +366,8 @@ const EntityBase *MQTTClimateComponent::get_entity() const { return this->device
 bool MQTTClimateComponent::publish_state_() {
   auto traits = this->device_->get_traits();
   // mode
-  const char *mode_s;
-  switch (this->device_->mode) {
-    case CLIMATE_MODE_OFF:
-      mode_s = "off";
-      break;
-    case CLIMATE_MODE_AUTO:
-      mode_s = "auto";
-      break;
-    case CLIMATE_MODE_COOL:
-      mode_s = "cool";
-      break;
-    case CLIMATE_MODE_HEAT:
-      mode_s = "heat";
-      break;
-    case CLIMATE_MODE_FAN_ONLY:
-      mode_s = "fan_only";
-      break;
-    case CLIMATE_MODE_DRY:
-      mode_s = "dry";
-      break;
-    case CLIMATE_MODE_HEAT_COOL:
-      mode_s = "heat_cool";
-      break;
-    default:
-      mode_s = "unknown";
-  }
   bool success = true;
-  if (!this->publish(this->get_mode_state_topic(), mode_s))
+  if (!this->publish(this->get_mode_state_topic(), climate_mode_to_mqtt_str(this->device_->mode)))
     success = false;
   int8_t target_accuracy = traits.get_target_temperature_accuracy_decimals();
   int8_t current_accuracy = traits.get_current_temperature_accuracy_decimals();
@@ -327,134 +407,37 @@ bool MQTTClimateComponent::publish_state_() {
   }
 
   if (traits.get_supports_presets() || !traits.get_supported_custom_presets().empty()) {
-    std::string payload;
-    if (this->device_->preset.has_value()) {
-      switch (this->device_->preset.value()) {
-        case CLIMATE_PRESET_NONE:
-          payload = "none";
-          break;
-        case CLIMATE_PRESET_HOME:
-          payload = "home";
-          break;
-        case CLIMATE_PRESET_AWAY:
-          payload = "away";
-          break;
-        case CLIMATE_PRESET_BOOST:
-          payload = "boost";
-          break;
-        case CLIMATE_PRESET_COMFORT:
-          payload = "comfort";
-          break;
-        case CLIMATE_PRESET_ECO:
-          payload = "eco";
-          break;
-        case CLIMATE_PRESET_SLEEP:
-          payload = "sleep";
-          break;
-        case CLIMATE_PRESET_ACTIVITY:
-          payload = "activity";
-          break;
-        default:
-          payload = "unknown";
-      }
-    }
-    if (this->device_->has_custom_preset())
-      payload = this->device_->get_custom_preset().c_str();
-    if (!this->publish(this->get_preset_state_topic(), payload))
+    if (this->device_->has_custom_preset()) {
+      if (!this->publish(this->get_preset_state_topic(), this->device_->get_custom_preset()))
+        success = false;
+    } else if (this->device_->preset.has_value()) {
+      if (!this->publish(this->get_preset_state_topic(), climate_preset_to_mqtt_str(this->device_->preset.value())))
+        success = false;
+    } else if (!this->publish(this->get_preset_state_topic(), "")) {
       success = false;
+    }
   }
 
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION)) {
-    const char *payload;
-    switch (this->device_->action) {
-      case CLIMATE_ACTION_OFF:
-        payload = "off";
-        break;
-      case CLIMATE_ACTION_COOLING:
-        payload = "cooling";
-        break;
-      case CLIMATE_ACTION_HEATING:
-        payload = "heating";
-        break;
-      case CLIMATE_ACTION_IDLE:
-        payload = "idle";
-        break;
-      case CLIMATE_ACTION_DRYING:
-        payload = "drying";
-        break;
-      case CLIMATE_ACTION_FAN:
-        payload = "fan";
-        break;
-      default:
-        payload = "unknown";
-    }
-    if (!this->publish(this->get_action_state_topic(), payload))
+    if (!this->publish(this->get_action_state_topic(), climate_action_to_mqtt_str(this->device_->action)))
       success = false;
   }
 
   if (traits.get_supports_fan_modes()) {
-    std::string payload;
-    if (this->device_->fan_mode.has_value()) {
-      switch (this->device_->fan_mode.value()) {
-        case CLIMATE_FAN_ON:
-          payload = "on";
-          break;
-        case CLIMATE_FAN_OFF:
-          payload = "off";
-          break;
-        case CLIMATE_FAN_AUTO:
-          payload = "auto";
-          break;
-        case CLIMATE_FAN_LOW:
-          payload = "low";
-          break;
-        case CLIMATE_FAN_MEDIUM:
-          payload = "medium";
-          break;
-        case CLIMATE_FAN_HIGH:
-          payload = "high";
-          break;
-        case CLIMATE_FAN_MIDDLE:
-          payload = "middle";
-          break;
-        case CLIMATE_FAN_FOCUS:
-          payload = "focus";
-          break;
-        case CLIMATE_FAN_DIFFUSE:
-          payload = "diffuse";
-          break;
-        case CLIMATE_FAN_QUIET:
-          payload = "quiet";
-          break;
-        default:
-          payload = "unknown";
-      }
-    }
-    if (this->device_->has_custom_fan_mode())
-      payload = this->device_->get_custom_fan_mode().c_str();
-    if (!this->publish(this->get_fan_mode_state_topic(), payload))
+    if (this->device_->has_custom_fan_mode()) {
+      if (!this->publish(this->get_fan_mode_state_topic(), this->device_->get_custom_fan_mode()))
+        success = false;
+    } else if (this->device_->fan_mode.has_value()) {
+      if (!this->publish(this->get_fan_mode_state_topic(),
+                         climate_fan_mode_to_mqtt_str(this->device_->fan_mode.value())))
+        success = false;
+    } else if (!this->publish(this->get_fan_mode_state_topic(), "")) {
       success = false;
+    }
   }
 
   if (traits.get_supports_swing_modes()) {
-    const char *payload;
-    switch (this->device_->swing_mode) {
-      case CLIMATE_SWING_OFF:
-        payload = "off";
-        break;
-      case CLIMATE_SWING_BOTH:
-        payload = "both";
-        break;
-      case CLIMATE_SWING_VERTICAL:
-        payload = "vertical";
-        break;
-      case CLIMATE_SWING_HORIZONTAL:
-        payload = "horizontal";
-        break;
-      default:
-        payload = "unknown";
-    }
-    if (!this->publish(this->get_swing_mode_state_topic(), payload))
+    if (!this->publish(this->get_swing_mode_state_topic(), climate_swing_mode_to_mqtt_str(this->device_->swing_mode)))
       success = false;
   }
 

esphome/components/mqtt/mqtt_component.cpp

@@ -5,6 +5,7 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include "esphome/core/version.h"
 
 #include "mqtt_const.h"
@@ -149,6 +150,22 @@ bool MQTTComponent::publish(const char *topic, const char *payload) {
   return this->publish(topic, payload, strlen(payload));
 }
 
+#ifdef USE_ESP8266
+bool MQTTComponent::publish(const std::string &topic, ProgmemStr payload) {
+  return this->publish(topic.c_str(), payload);
+}
+
+bool MQTTComponent::publish(const char *topic, ProgmemStr payload) {
+  if (topic[0] == '\0')
+    return false;
+  // On ESP8266, ProgmemStr is __FlashStringHelper* - need to copy from flash
+  char buf[64];
+  strncpy_P(buf, reinterpret_cast<const char *>(payload), sizeof(buf) - 1);
+  buf[sizeof(buf) - 1] = '\0';
+  return global_mqtt_client->publish(topic, buf, strlen(buf), this->qos_, this->retain_);
+}
+#endif
+
 bool MQTTComponent::publish_json(const std::string &topic, const json::json_build_t &f) {
   return this->publish_json(topic.c_str(), f);
 }

esphome/components/mqtt/mqtt_component.h

@@ -9,6 +9,7 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
+#include "esphome/core/progmem.h"
 #include "esphome/core/string_ref.h"
 #include "mqtt_client.h"
 
@@ -157,6 +158,15 @@ class MQTTComponent : public Component {
    */
   bool publish(const std::string &topic, const char *payload, size_t payload_length);
 
+  /** Send a MQTT message.
+   *
+   * @param topic The topic.
+   * @param payload The null-terminated payload.
+   */
+  bool publish(const std::string &topic, const char *payload) {
+    return this->publish(topic.c_str(), payload, strlen(payload));
+  }
+
   /** Send a MQTT message (no heap allocation for topic).
    *
    * @param topic The topic as C string.
@@ -189,6 +199,29 @@ class MQTTComponent : public Component {
    */
   bool publish(StringRef topic, const char *payload) { return this->publish(topic.c_str(), payload); }
 
+#ifdef USE_ESP8266
+  /** Send a MQTT message with a PROGMEM string payload.
+   *
+   * @param topic The topic.
+   * @param payload The payload (ProgmemStr - stored in flash on ESP8266).
+   */
+  bool publish(const std::string &topic, ProgmemStr payload);
+
+  /** Send a MQTT message with a PROGMEM string payload (no heap allocation for topic).
+   *
+   * @param topic The topic as C string.
+   * @param payload The payload (ProgmemStr - stored in flash on ESP8266).
+   */
+  bool publish(const char *topic, ProgmemStr payload);
+
+  /** Send a MQTT message with a PROGMEM string payload (no heap allocation for topic).
+   *
+   * @param topic The topic as StringRef (for use with get_state_topic_to_()).
+   * @param payload The payload (ProgmemStr - stored in flash on ESP8266).
+   */
+  bool publish(StringRef topic, ProgmemStr payload) { return this->publish(topic.c_str(), payload); }
+#endif
+
   /** Construct and send a JSON MQTT message.
    *
    * @param topic The topic.

esphome/components/mqtt/mqtt_cover.cpp

@@ -1,5 +1,6 @@
 #include "mqtt_cover.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -12,6 +13,20 @@ static const char *const TAG = "mqtt.cover";
 
 using namespace esphome::cover;
 
+static ProgmemStr cover_state_to_mqtt_str(CoverOperation operation, float position, bool supports_position) {
+  if (operation == COVER_OPERATION_OPENING)
+    return ESPHOME_F("opening");
+  if (operation == COVER_OPERATION_CLOSING)
+    return ESPHOME_F("closing");
+  if (position == COVER_CLOSED)
+    return ESPHOME_F("closed");
+  if (position == COVER_OPEN)
+    return ESPHOME_F("open");
+  if (supports_position)
+    return ESPHOME_F("open");
+  return ESPHOME_F("unknown");
+}
+
 MQTTCoverComponent::MQTTCoverComponent(Cover *cover) : cover_(cover) {}
 void MQTTCoverComponent::setup() {
   auto traits = this->cover_->get_traits();
@@ -109,14 +124,10 @@ bool MQTTCoverComponent::publish_state() {
     if (!this->publish(this->get_tilt_state_topic(), pos, len))
       success = false;
   }
-  const char *state_s = this->cover_->current_operation == COVER_OPERATION_OPENING   ? "opening"
-                        : this->cover_->current_operation == COVER_OPERATION_CLOSING ? "closing"
-                        : this->cover_->position == COVER_CLOSED                     ? "closed"
-                        : this->cover_->position == COVER_OPEN                       ? "open"
-                        : traits.get_supports_position()                             ? "open"
-                                                                                     : "unknown";
   char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
+  if (!this->publish(this->get_state_topic_to_(topic_buf),
+                     cover_state_to_mqtt_str(this->cover_->current_operation, this->cover_->position,
+                                             traits.get_supports_position())))
     success = false;
   return success;
 }

esphome/components/mqtt/mqtt_fan.cpp

@@ -1,5 +1,6 @@
 #include "mqtt_fan.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -12,6 +13,14 @@ static const char *const TAG = "mqtt.fan";
 
 using namespace esphome::fan;
 
+static ProgmemStr fan_direction_to_mqtt_str(FanDirection direction) {
+  return direction == FanDirection::FORWARD ? ESPHOME_F("forward") : ESPHOME_F("reverse");
+}
+
+static ProgmemStr fan_oscillation_to_mqtt_str(bool oscillating) {
+  return oscillating ? ESPHOME_F("oscillate_on") : ESPHOME_F("oscillate_off");
+}
+
 MQTTFanComponent::MQTTFanComponent(Fan *state) : state_(state) {}
 
 Fan *MQTTFanComponent::get_state() const { return this->state_; }
@@ -164,13 +173,12 @@ bool MQTTFanComponent::publish_state() {
   this->publish(this->get_state_topic_to_(topic_buf), state_s);
   bool failed = false;
   if (this->state_->get_traits().supports_direction()) {
-    bool success = this->publish(this->get_direction_state_topic(),
-                                 this->state_->direction == fan::FanDirection::FORWARD ? "forward" : "reverse");
+    bool success = this->publish(this->get_direction_state_topic(), fan_direction_to_mqtt_str(this->state_->direction));
     failed = failed || !success;
   }
   if (this->state_->get_traits().supports_oscillation()) {
-    bool success = this->publish(this->get_oscillation_state_topic(),
-                                 this->state_->oscillating ? "oscillate_on" : "oscillate_off");
+    bool success =
+        this->publish(this->get_oscillation_state_topic(), fan_oscillation_to_mqtt_str(this->state_->oscillating));
     failed = failed || !success;
   }
   auto traits = this->state_->get_traits();

esphome/components/mqtt/mqtt_lock.cpp

@@ -1,6 +1,5 @@
 #include "mqtt_lock.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -17,11 +16,11 @@ MQTTLockComponent::MQTTLockComponent(lock::Lock *a_lock) : lock_(a_lock) {}
 
 void MQTTLockComponent::setup() {
   this->subscribe(this->get_command_topic_(), [this](const std::string &topic, const std::string &payload) {
-    if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("LOCK")) == 0) {
+    if (strcasecmp(payload.c_str(), "LOCK") == 0) {
       this->lock_->lock();
-    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("UNLOCK")) == 0) {
+    } else if (strcasecmp(payload.c_str(), "UNLOCK") == 0) {
       this->lock_->unlock();
-    } else if (ESPHOME_strcasecmp_P(payload.c_str(), ESPHOME_PSTR("OPEN")) == 0) {
+    } else if (strcasecmp(payload.c_str(), "OPEN") == 0) {
       this->lock_->open();
     } else {
       ESP_LOGW(TAG, "'%s': Received unknown status payload: %s", this->friendly_name_().c_str(), payload.c_str());

esphome/components/mqtt/mqtt_valve.cpp

@@ -1,5 +1,6 @@
 #include "mqtt_valve.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -12,6 +13,20 @@ static const char *const TAG = "mqtt.valve";
 
 using namespace esphome::valve;
 
+static ProgmemStr valve_state_to_mqtt_str(ValveOperation operation, float position, bool supports_position) {
+  if (operation == VALVE_OPERATION_OPENING)
+    return ESPHOME_F("opening");
+  if (operation == VALVE_OPERATION_CLOSING)
+    return ESPHOME_F("closing");
+  if (position == VALVE_CLOSED)
+    return ESPHOME_F("closed");
+  if (position == VALVE_OPEN)
+    return ESPHOME_F("open");
+  if (supports_position)
+    return ESPHOME_F("open");
+  return ESPHOME_F("unknown");
+}
+
 MQTTValveComponent::MQTTValveComponent(Valve *valve) : valve_(valve) {}
 void MQTTValveComponent::setup() {
   auto traits = this->valve_->get_traits();
@@ -78,14 +93,10 @@ bool MQTTValveComponent::publish_state() {
     if (!this->publish(this->get_position_state_topic(), pos, len))
       success = false;
   }
-  const char *state_s = this->valve_->current_operation == VALVE_OPERATION_OPENING   ? "opening"
-                        : this->valve_->current_operation == VALVE_OPERATION_CLOSING ? "closing"
-                        : this->valve_->position == VALVE_CLOSED                     ? "closed"
-                        : this->valve_->position == VALVE_OPEN                       ? "open"
-                        : traits.get_supports_position()                             ? "open"
-                                                                                     : "unknown";
   char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
+  if (!this->publish(this->get_state_topic_to_(topic_buf),
+                     valve_state_to_mqtt_str(this->valve_->current_operation, this->valve_->position,
+                                             traits.get_supports_position())))
     success = false;
   return success;
 }

esphome/components/number/automation.cpp

@@ -14,7 +14,8 @@ void ValueRangeTrigger::setup() {
   float local_min = this->min_.value(0.0);
   float local_max = this->max_.value(0.0);
   convert hash = {.from = (local_max - local_min)};
-  this->rtc_ = this->parent_->make_entity_preference<bool>(hash.to);
+  uint32_t myhash = hash.to ^ this->parent_->get_preference_hash();
+  this->rtc_ = global_preferences->make_preference<bool>(myhash);
   bool initial_state;
   if (this->rtc_.load(&initial_state)) {
     this->previous_in_range_ = initial_state;

esphome/components/opentherm/number/opentherm_number.cpp

@@ -17,7 +17,7 @@ void OpenthermNumber::setup() {
   if (!this->restore_value_) {
     value = this->initial_value_;
   } else {
-    this->pref_ = this->make_entity_preference<float>();
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     if (!this->pref_.load(&value)) {
       if (!std::isnan(this->initial_value_)) {
         value = this->initial_value_;

esphome/components/rotary_encoder/rotary_encoder.cpp

@@ -132,7 +132,7 @@ void RotaryEncoderSensor::setup() {
   int32_t initial_value = 0;
   switch (this->restore_mode_) {
     case ROTARY_ENCODER_RESTORE_DEFAULT_ZERO:
-      this->rtc_ = this->make_entity_preference<int32_t>();
+      this->rtc_ = global_preferences->make_preference<int32_t>(this->get_preference_hash());
       if (!this->rtc_.load(&initial_value)) {
         initial_value = 0;
       }

esphome/components/rp2040/preferences.cpp

@@ -8,6 +8,7 @@
 #include "preferences.h"
 
 #include <cstring>
+#include <vector>
 
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -24,9 +25,6 @@ static bool s_flash_dirty = false;          // NOLINT(cppcoreguidelines-avoid-no
 
 static const uint32_t RP2040_FLASH_STORAGE_SIZE = 512;
 
-// Stack buffer size for preferences - covers virtually all real-world preferences without heap allocation
-static constexpr size_t PREF_BUFFER_SIZE = 64;
-
 extern "C" uint8_t _EEPROM_start;
 
 template<class It> uint8_t calculate_crc(It first, It last, uint32_t type) {
@@ -44,14 +42,12 @@ class RP2040PreferenceBackend : public ESPPreferenceBackend {
   uint32_t type = 0;
 
   bool save(const uint8_t *data, size_t len) override {
-    const size_t buffer_size = len + 1;
-    SmallBufferWithHeapFallback<PREF_BUFFER_SIZE> buffer_alloc(buffer_size);
-    uint8_t *buffer = buffer_alloc.get();
+    std::vector<uint8_t> buffer;
+    buffer.resize(len + 1);
+    memcpy(buffer.data(), data, len);
+    buffer[buffer.size() - 1] = calculate_crc(buffer.begin(), buffer.end() - 1, type);
 
-    memcpy(buffer, data, len);
-    buffer[len] = calculate_crc(buffer, buffer + len, type);
-
-    for (size_t i = 0; i < buffer_size; i++) {
+    for (uint32_t i = 0; i < len + 1; i++) {
       uint32_t j = offset + i;
       if (j >= RP2040_FLASH_STORAGE_SIZE)
         return false;
@@ -64,23 +60,22 @@ class RP2040PreferenceBackend : public ESPPreferenceBackend {
     return true;
   }
   bool load(uint8_t *data, size_t len) override {
-    const size_t buffer_size = len + 1;
-    SmallBufferWithHeapFallback<PREF_BUFFER_SIZE> buffer_alloc(buffer_size);
-    uint8_t *buffer = buffer_alloc.get();
+    std::vector<uint8_t> buffer;
+    buffer.resize(len + 1);
 
-    for (size_t i = 0; i < buffer_size; i++) {
+    for (size_t i = 0; i < len + 1; i++) {
       uint32_t j = offset + i;
       if (j >= RP2040_FLASH_STORAGE_SIZE)
         return false;
       buffer[i] = s_flash_storage[j];
     }
 
-    uint8_t crc = calculate_crc(buffer, buffer + len, type);
-    if (buffer[len] != crc) {
+    uint8_t crc = calculate_crc(buffer.begin(), buffer.end() - 1, type);
+    if (buffer[buffer.size() - 1] != crc) {
       return false;
     }
 
-    memcpy(data, buffer, len);
+    memcpy(data, buffer.data(), len);
     return true;
   }
 };

esphome/components/sensor/automation.h

@@ -39,7 +39,7 @@ class ValueRangeTrigger : public Trigger<float>, public Component {
   template<typename V> void set_max(V max) { this->max_ = max; }
 
   void setup() override {
-    this->rtc_ = this->parent_->make_entity_preference<bool>();
+    this->rtc_ = global_preferences->make_preference<bool>(this->parent_->get_preference_hash());
     bool initial_state;
     if (this->rtc_.load(&initial_state)) {
       this->previous_in_range_ = initial_state;

esphome/components/socket/lwip_raw_tcp_impl.cpp

@@ -29,14 +29,6 @@ void socket_delay(uint32_t ms) {
   // Use esp_delay with a callback that checks if socket data arrived.
   // This allows the delay to exit early when socket_wake() is called by
   // lwip recv_fn/accept_fn callbacks, reducing socket latency.
-  //
-  // When ms is 0, we must use delay(0) because esp_delay(0, callback)
-  // exits immediately without yielding, which can cause watchdog timeouts
-  // when the main loop runs in high-frequency mode (e.g., during light effects).
-  if (ms == 0) {
-    delay(0);
-    return;
-  }
   s_socket_woke = false;
   esp_delay(ms, []() { return !s_socket_woke; });
 }

esphome/components/speaker/media_player/speaker_media_player.cpp

@@ -55,7 +55,7 @@ void SpeakerMediaPlayer::setup() {
 
   this->media_control_command_queue_ = xQueueCreate(MEDIA_CONTROLS_QUEUE_LENGTH, sizeof(MediaCallCommand));
 
-  this->pref_ = this->make_entity_preference<VolumeRestoreState>();
+  this->pref_ = global_preferences->make_preference<VolumeRestoreState>(this->get_preference_hash());
 
   VolumeRestoreState volume_restore_state;
   if (this->pref_.load(&volume_restore_state)) {

esphome/components/sprinkler/sprinkler.cpp

@@ -16,7 +16,7 @@ void SprinklerControllerNumber::setup() {
   if (!this->restore_value_) {
     value = this->initial_value_;
   } else {
-    this->pref_ = this->make_entity_preference<float>();
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     if (!this->pref_.load(&value)) {
       if (!std::isnan(this->initial_value_)) {
         value = this->initial_value_;

esphome/components/switch/switch.cpp

@@ -34,7 +34,7 @@ optional<bool> Switch::get_initial_state() {
   if (!(restore_mode & RESTORE_MODE_PERSISTENT_MASK))
     return {};
 
-  this->rtc_ = this->make_entity_preference<bool>();
+  this->rtc_ = global_preferences->make_preference<bool>(this->get_preference_hash());
   bool initial_state;
   if (!this->rtc_.load(&initial_state))
     return {};

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -82,7 +82,7 @@ void TemplateAlarmControlPanel::setup() {
   this->current_state_ = ACP_STATE_DISARMED;
   if (this->restore_mode_ == ALARM_CONTROL_PANEL_RESTORE_DEFAULT_DISARMED) {
     uint8_t value;
-    this->pref_ = this->make_entity_preference<uint8_t>();
+    this->pref_ = global_preferences->make_preference<uint8_t>(this->get_preference_hash());
     if (this->pref_.load(&value)) {
       this->current_state_ = static_cast<alarm_control_panel::AlarmControlPanelState>(value);
     }

esphome/components/template/datetime/template_date.cpp

@@ -18,7 +18,8 @@ void TemplateDate::setup() {
     state = this->initial_value_;
   } else {
     datetime::DateEntityRestoreState temp;
-    this->pref_ = this->make_entity_preference<datetime::DateEntityRestoreState>(194434030U);
+    this->pref_ =
+        global_preferences->make_preference<datetime::DateEntityRestoreState>(194434030U ^ this->get_preference_hash());
     if (this->pref_.load(&temp)) {
       temp.apply(this);
       return;

esphome/components/template/datetime/template_datetime.cpp

@@ -18,7 +18,8 @@ void TemplateDateTime::setup() {
     state = this->initial_value_;
   } else {
     datetime::DateTimeEntityRestoreState temp;
-    this->pref_ = this->make_entity_preference<datetime::DateTimeEntityRestoreState>(194434090U);
+    this->pref_ = global_preferences->make_preference<datetime::DateTimeEntityRestoreState>(
+        194434090U ^ this->get_preference_hash());
     if (this->pref_.load(&temp)) {
       temp.apply(this);
       return;

esphome/components/template/datetime/template_time.cpp

@@ -18,7 +18,8 @@ void TemplateTime::setup() {
     state = this->initial_value_;
   } else {
     datetime::TimeEntityRestoreState temp;
-    this->pref_ = this->make_entity_preference<datetime::TimeEntityRestoreState>(194434060U);
+    this->pref_ =
+        global_preferences->make_preference<datetime::TimeEntityRestoreState>(194434060U ^ this->get_preference_hash());
     if (this->pref_.load(&temp)) {
       temp.apply(this);
       return;

esphome/components/template/number/template_number.cpp

@@ -13,7 +13,7 @@ void TemplateNumber::setup() {
   if (!this->restore_value_) {
     value = this->initial_value_;
   } else {
-    this->pref_ = this->make_entity_preference<float>();
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     if (!this->pref_.load(&value)) {
       if (!std::isnan(this->initial_value_)) {
         value = this->initial_value_;

esphome/components/template/select/template_select.cpp

@@ -11,7 +11,7 @@ void TemplateSelect::setup() {
 
   size_t index = this->initial_option_index_;
   if (this->restore_value_) {
-    this->pref_ = this->make_entity_preference<size_t>();
+    this->pref_ = global_preferences->make_preference<size_t>(this->get_preference_hash());
     size_t restored_index;
     if (this->pref_.load(&restored_index) && this->has_index(restored_index)) {
       index = restored_index;

esphome/components/template/text/template_text.cpp

@@ -20,14 +20,7 @@ void TemplateText::setup() {
 
   // Need std::string for pref_->setup() to fill from flash
   std::string value{this->initial_value_ != nullptr ? this->initial_value_ : ""};
-  // For future hash migration: use migrate_entity_preference_() with:
-  //   old_key = get_preference_hash() + extra
-  //   new_key = get_preference_hash_v2() + extra
-  // See: https://github.com/esphome/backlog/issues/85
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   uint32_t key = this->get_preference_hash();
-#pragma GCC diagnostic pop
   key += this->traits.get_min_length() << 2;
   key += this->traits.get_max_length() << 4;
   key += fnv1_hash(this->traits.get_pattern_c_str()) << 6;

esphome/components/total_daily_energy/total_daily_energy.cpp

@@ -10,7 +10,7 @@ void TotalDailyEnergy::setup() {
   float initial_value = 0;
 
   if (this->restore_) {
-    this->pref_ = this->make_entity_preference<float>();
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     this->pref_.load(&initial_value);
   }
   this->publish_state_and_save(initial_value);

esphome/components/tuya/number/tuya_number.cpp

@@ -8,7 +8,7 @@ static const char *const TAG = "tuya.number";
 
 void TuyaNumber::setup() {
   if (this->restore_value_) {
-    this->pref_ = this->make_entity_preference<float>();
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
   }
 
   this->parent_->register_listener(this->number_id_, [this](const TuyaDatapoint &datapoint) {

esphome/components/valve/valve.cpp

@@ -163,7 +163,7 @@ void Valve::publish_state(bool save) {
   }
 }
 optional<ValveRestoreState> Valve::restore_state_() {
-  this->rtc_ = this->make_entity_preference<ValveRestoreState>();
+  this->rtc_ = global_preferences->make_preference<ValveRestoreState>(this->get_preference_hash());
   ValveRestoreState recovered{};
   if (!this->rtc_.load(&recovered))
     return {};

esphome/components/water_heater/water_heater.cpp

@@ -185,7 +185,7 @@ void WaterHeater::publish_state() {
 }
 
 optional<WaterHeaterCall> WaterHeater::restore_state_() {
-  this->pref_ = this->make_entity_preference<SavedWaterHeaterState>();
+  this->pref_ = global_preferences->make_preference<SavedWaterHeaterState>(this->get_preference_hash());
   SavedWaterHeaterState recovered{};
   if (!this->pref_.load(&recovered))
     return {};

esphome/components/web_server_base/__init__.py

@@ -48,4 +48,4 @@ async def to_code(config):
         if CORE.is_libretiny:
             CORE.add_platformio_option("lib_ignore", ["ESPAsyncTCP", "RPAsyncTCP"])
         # https://github.com/ESP32Async/ESPAsyncWebServer/blob/main/library.json
-        cg.add_library("ESP32Async/ESPAsyncWebServer", "3.9.5")
+        cg.add_library("ESP32Async/ESPAsyncWebServer", "3.7.10")

esphome/components/wifi/wifi_component.cpp

@@ -746,32 +746,16 @@ void WiFiComponent::setup_ap_config_() {
     return;
 
   if (this->ap_.get_ssid().empty()) {
-    // Build AP SSID from app name without heap allocation
-    // WiFi SSID max is 32 bytes, with MAC suffix we keep first 25 + last 7
-    static constexpr size_t AP_SSID_MAX_LEN = 32;
-    static constexpr size_t AP_SSID_PREFIX_LEN = 25;
-    static constexpr size_t AP_SSID_SUFFIX_LEN = 7;
-
-    const std::string &app_name = App.get_name();
-    const char *name_ptr = app_name.c_str();
-    size_t name_len = app_name.length();
-
-    if (name_len <= AP_SSID_MAX_LEN) {
-      // Name fits, use directly
-      this->ap_.set_ssid(name_ptr);
-    } else {
-      // Name too long, need to truncate into stack buffer
-      char ssid_buf[AP_SSID_MAX_LEN + 1];
+    std::string name = App.get_name();
+    if (name.length() > 32) {
       if (App.is_name_add_mac_suffix_enabled()) {
         // Keep first 25 chars and last 7 chars (MAC suffix), remove middle
-        memcpy(ssid_buf, name_ptr, AP_SSID_PREFIX_LEN);
-        memcpy(ssid_buf + AP_SSID_PREFIX_LEN, name_ptr + name_len - AP_SSID_SUFFIX_LEN, AP_SSID_SUFFIX_LEN);
+        name.erase(25, name.length() - 32);
       } else {
-        memcpy(ssid_buf, name_ptr, AP_SSID_MAX_LEN);
+        name.resize(32);
       }
-      ssid_buf[AP_SSID_MAX_LEN] = '\0';
-      this->ap_.set_ssid(ssid_buf);
     }
+    this->ap_.set_ssid(name);
   }
   this->ap_setup_ = this->wifi_start_ap_(this->ap_);
 

esphome/core/entity_base.cpp

@@ -92,48 +92,6 @@ StringRef EntityBase::get_object_id_to(std::span<char, OBJECT_ID_MAX_LEN> buf) c
 
 uint32_t EntityBase::get_object_id_hash() { return this->object_id_hash_; }
 
-// Migrate preference data from old_key to new_key if they differ.
-// This helper is exposed so callers with custom key computation (like TextPrefs)
-// can use it for manual migration. See: https://github.com/esphome/backlog/issues/85
-//
-// FUTURE IMPLEMENTATION:
-// This will require raw load/save methods on ESPPreferenceObject that take uint8_t* and size.
-//   void EntityBase::migrate_entity_preference_(size_t size, uint32_t old_key, uint32_t new_key) {
-//     if (old_key == new_key)
-//       return;
-//     auto old_pref = global_preferences->make_preference(size, old_key);
-//     auto new_pref = global_preferences->make_preference(size, new_key);
-//     SmallBufferWithHeapFallback<64> buffer(size);
-//     if (old_pref.load(buffer.data(), size)) {
-//       new_pref.save(buffer.data(), size);
-//     }
-//   }
-
-ESPPreferenceObject EntityBase::make_entity_preference_(size_t size, uint32_t version) {
-  // This helper centralizes preference creation to enable fixing hash collisions.
-  // See: https://github.com/esphome/backlog/issues/85
-  //
-  // COLLISION PROBLEM: get_preference_hash() uses fnv1_hash on sanitized object_id.
-  // Multiple entity names can sanitize to the same object_id:
-  //   - "Living Room" and "living_room" both become "living_room"
-  //   - UTF-8 names like "温度" and "湿度" both become "__" (underscores)
-  // This causes entities to overwrite each other's stored preferences.
-  //
-  // FUTURE MIGRATION: When implementing get_preference_hash_v2() that hashes
-  // the original entity name (not sanitized object_id):
-  //
-  //   uint32_t old_key = this->get_preference_hash() ^ version;
-  //   uint32_t new_key = this->get_preference_hash_v2() ^ version;
-  //   this->migrate_entity_preference_(size, old_key, new_key);
-  //   return global_preferences->make_preference(size, new_key);
-  //
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  uint32_t key = this->get_preference_hash() ^ version;
-#pragma GCC diagnostic pop
-  return global_preferences->make_preference(size, key);
-}
-
 std::string EntityBase_DeviceClass::get_device_class() {
   if (this->device_class_ == nullptr) {
     return "";

esphome/core/entity_base.h

@@ -6,7 +6,6 @@
 #include "string_ref.h"
 #include "helpers.h"
 #include "log.h"
-#include "preferences.h"
 
 #ifdef USE_DEVICES
 #include "device.h"
@@ -139,12 +138,7 @@ class EntityBase {
    * from previous versions, so existing single-device configurations will continue to work.
    *
    * @return uint32_t The unique hash for preferences, including device_id if available.
-   * @deprecated Use make_entity_preference<T>() instead, or preferences won't be migrated.
-   * See https://github.com/esphome/backlog/issues/85
    */
-  ESPDEPRECATED("Use make_entity_preference<T>() instead, or preferences won't be migrated. "
-                "See https://github.com/esphome/backlog/issues/85. Will be removed in 2027.1.0.",
-                "2026.7.0")
   uint32_t get_preference_hash() {
 #ifdef USE_DEVICES
     // Combine object_id_hash with device_id to ensure uniqueness across devices
@@ -157,19 +151,7 @@ class EntityBase {
 #endif
   }
 
-  /// Create a preference object for storing this entity's state/settings.
-  /// @tparam T The type of data to store (must be trivially copyable)
-  /// @param version Optional version hash XORed with preference key (change when struct layout changes)
-  template<typename T> ESPPreferenceObject make_entity_preference(uint32_t version = 0) {
-    static_assert(std::is_trivially_copyable<T>::value, "T must be trivially copyable");
-    return this->make_entity_preference_(sizeof(T), version);
-  }
-
  protected:
-  /// Non-template helper for make_entity_preference() to avoid code bloat.
-  /// When preference hash algorithm changes, migration logic goes here.
-  ESPPreferenceObject make_entity_preference_(size_t size, uint32_t version);
-
   void calc_object_id_();
 
   StringRef name_;

esphome/core/helpers.h

@@ -655,11 +655,9 @@ inline uint32_t fnv1_hash_object_id(const char *str, size_t len) {
 }
 
 /// snprintf-like function returning std::string of maximum length \p len (excluding null terminator).
-/// @warning Allocates heap memory. Use snprintf() with a stack buffer instead.
 std::string __attribute__((format(printf, 1, 3))) str_snprintf(const char *fmt, size_t len, ...);
 
 /// sprintf-like function returning std::string.
-/// @warning Allocates heap memory. Use snprintf() with a stack buffer instead.
 std::string __attribute__((format(printf, 1, 2))) str_sprintf(const char *fmt, ...);
 
 #ifdef USE_ESP8266

platformio.ini

@@ -114,7 +114,7 @@ lib_deps =
     ESP8266WiFi                           ; wifi (Arduino built-in)
     Update                                ; ota (Arduino built-in)
     ESP32Async/ESPAsyncTCP@2.0.0          ; async_tcp
-    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.7.8    ; web_server_base
     makuna/NeoPixelBus@2.7.3              ; neopixelbus
     ESP8266HTTPClient                     ; http_request (Arduino built-in)
     ESP8266mDNS                           ; mdns (Arduino built-in)
@@ -201,7 +201,7 @@ framework = arduino
 lib_deps =
     ${common:arduino.lib_deps}
     bblanchon/ArduinoJson@7.4.2           ; json
-    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.7.8    ; web_server_base
 build_flags =
     ${common:arduino.build_flags}
     -DUSE_RP2040
@@ -217,7 +217,7 @@ framework = arduino
 lib_compat_mode = soft
 lib_deps =
     bblanchon/ArduinoJson@7.4.2           ; json
-    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.7.8    ; web_server_base
     droscy/esp_wireguard@0.4.2            ; wireguard
 build_flags =
     ${common:arduino.build_flags}

script/ci-custom.py

@@ -692,8 +692,6 @@ HEAP_ALLOCATING_HELPERS = {
     "str_truncate": "removal (function is unused)",
     "str_upper_case": "removal (function is unused)",
     "str_snake_case": "removal (function is unused)",
-    "str_sprintf": "snprintf() with a stack buffer",
-    "str_snprintf": "snprintf() with a stack buffer",
 }
 
 
@@ -712,9 +710,7 @@ HEAP_ALLOCATING_HELPERS = {
     r"str_sanitize(?!_)|"
     r"str_truncate|"
     r"str_upper_case|"
-    r"str_snake_case|"
-    r"str_sprintf|"
-    r"str_snprintf"
+    r"str_snake_case"
     r")\s*\(" + CPP_RE_EOL,
     include=cpp_include,
     exclude=[