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 @@
-cf3d341206b4184ec8b7fe85141aef4fe4696aa720c3f8a06d4e57930574bdab
+d565b0589e35e692b5f2fc0c14723a99595b4828a3a3ef96c442e86a23176c00

esphome/components/async_tcp/__init__.py

@@ -38,10 +38,8 @@ async def to_code(config):
         # https://github.com/ESP32Async/ESPAsyncTCP
         cg.add_library("ESP32Async/ESPAsyncTCP", "2.0.0")
     elif CORE.is_rp2040:
-        # https://github.com/ayushsharma82/RPAsyncTCP
-        # RPAsyncTCP is a drop-in replacement for AsyncTCP_RP2040W with better
-        # ESPAsyncWebServer compatibility
-        cg.add_library("ayushsharma82/RPAsyncTCP", "1.3.2")
+        # https://github.com/khoih-prog/AsyncTCP_RP2040W
+        cg.add_library("khoih-prog/AsyncTCP_RP2040W", "1.2.0")
     # Other platforms (host, etc) use socket-based implementation
 
 

esphome/components/async_tcp/async_tcp.h

@@ -8,8 +8,8 @@
 // Use ESPAsyncTCP library for ESP8266 (always Arduino)
 #include <ESPAsyncTCP.h>
 #elif defined(USE_RP2040)
-// Use RPAsyncTCP library for RP2040
-#include <RPAsyncTCP.h>
+// Use AsyncTCP_RP2040W library for RP2040
+#include <AsyncTCP_RP2040W.h>
 #else
 // Use socket-based implementation for other platforms
 #include "async_tcp_socket.h"

esphome/components/binary_sensor/binary_sensor.cpp

@@ -14,7 +14,10 @@ void log_binary_sensor(const char *tag, const char *prefix, const char *type, Bi
   }
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
-  LOG_ENTITY_DEVICE_CLASS(tag, prefix, *obj);
+
+  if (!obj->get_device_class_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
+  }
 }
 
 void BinarySensor::publish_state(bool new_state) {

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/button/button.cpp

@@ -12,7 +12,10 @@ void log_button(const char *tag, const char *prefix, const char *type, Button *o
   }
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
-  LOG_ENTITY_ICON(tag, prefix, *obj);
+
+  if (!obj->get_icon_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
+  }
 }
 
 void Button::press() {

esphome/components/captive_portal/captive_portal.cpp

@@ -96,16 +96,10 @@ void CaptivePortal::start() {
 }
 
 void CaptivePortal::handleRequest(AsyncWebServerRequest *req) {
-#ifdef USE_ESP32
-  char url_buf[AsyncWebServerRequest::URL_BUF_SIZE];
-  StringRef url = req->url_to(url_buf);
-#else
-  const auto &url = req->url();
-#endif
-  if (url == ESPHOME_F("/config.json")) {
+  if (req->url() == ESPHOME_F("/config.json")) {
     this->handle_config(req);
     return;
-  } else if (url == ESPHOME_F("/wifisave")) {
+  } else if (req->url() == ESPHOME_F("/wifisave")) {
     this->handle_wifisave(req);
     return;
   }

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/cover/cover.h

@@ -20,7 +20,9 @@ const extern float COVER_CLOSED;
     if (traits_.get_is_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \
     } \
-    LOG_ENTITY_DEVICE_CLASS(TAG, prefix, *(obj)); \
+    if (!(obj)->get_device_class_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class_ref().c_str()); \
+    } \
   }
 
 class Cover;

esphome/components/datetime/date_entity.h

@@ -15,7 +15,9 @@ namespace esphome::datetime {
 #define LOG_DATETIME_DATE(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    } \
   }
 
 class DateCall;

esphome/components/datetime/datetime_entity.h

@@ -15,7 +15,9 @@ namespace esphome::datetime {
 #define LOG_DATETIME_DATETIME(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    } \
   }
 
 class DateTimeCall;

esphome/components/datetime/time_entity.h

@@ -15,7 +15,9 @@ namespace esphome::datetime {
 #define LOG_DATETIME_TIME(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    } \
   }
 
 class TimeCall;

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/esp32/__init__.py

@@ -55,7 +55,6 @@ from .const import (  # noqa
     KEY_ESP32,
     KEY_EXTRA_BUILD_FILES,
     KEY_FLASH_SIZE,
-    KEY_FULL_CERT_BUNDLE,
     KEY_PATH,
     KEY_REF,
     KEY_REPO,
@@ -671,7 +670,6 @@ CONF_FREERTOS_IN_IRAM = "freertos_in_iram"
 CONF_RINGBUF_IN_IRAM = "ringbuf_in_iram"
 CONF_HEAP_IN_IRAM = "heap_in_iram"
 CONF_LOOP_TASK_STACK_SIZE = "loop_task_stack_size"
-CONF_USE_FULL_CERTIFICATE_BUNDLE = "use_full_certificate_bundle"
 
 # VFS requirement tracking
 # Components that need VFS features can call require_vfs_select() or require_vfs_dir()
@@ -697,18 +695,6 @@ def require_vfs_dir() -> None:
     CORE.data[KEY_VFS_DIR_REQUIRED] = True
 
 
-def require_full_certificate_bundle() -> None:
-    """Request the full certificate bundle instead of the common-CAs-only bundle.
-
-    By default, ESPHome uses CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN which
-    includes only CAs with >1% market share (~51 KB smaller than full bundle).
-    This covers ~99% of websites including Let's Encrypt, DigiCert, Google, Amazon.
-
-    Call this from components that need to connect to services using uncommon CAs.
-    """
-    CORE.data[KEY_ESP32][KEY_FULL_CERT_BUNDLE] = True
-
-
 def _parse_idf_component(value: str) -> ConfigType:
     """Parse IDF component shorthand syntax like 'owner/component^version'"""
     # Match operator followed by version-like string (digit or *)
@@ -790,9 +776,6 @@ FRAMEWORK_SCHEMA = cv.Schema(
                     min=8192, max=32768
                 ),
                 cv.Optional(CONF_ENABLE_OTA_ROLLBACK, default=True): cv.boolean,
-                cv.Optional(
-                    CONF_USE_FULL_CERTIFICATE_BUNDLE, default=False
-                ): cv.boolean,
             }
         ),
         cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -1065,19 +1048,6 @@ async def to_code(config):
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")
         if use_platformio:
             cg.add_platformio_option("framework", "espidf")
-
-        # Wrap std::__throw_* functions to abort immediately, eliminating ~3KB of
-        # exception class overhead. See throw_stubs.cpp for implementation.
-        # ESP-IDF already compiles with -fno-exceptions, so this code was dead anyway.
-        for mangled in [
-            "_ZSt20__throw_length_errorPKc",
-            "_ZSt19__throw_logic_errorPKc",
-            "_ZSt20__throw_out_of_rangePKc",
-            "_ZSt24__throw_out_of_range_fmtPKcz",
-            "_ZSt17__throw_bad_allocv",
-            "_ZSt25__throw_bad_function_callv",
-        ]:
-            cg.add_build_flag(f"-Wl,--wrap={mangled}")
     else:
         cg.add_build_flag("-DUSE_ARDUINO")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ARDUINO")
@@ -1110,18 +1080,6 @@ async def to_code(config):
 
     cg.add_build_flag("-Wno-nonnull-compare")
 
-    # Use CMN (common CAs) bundle by default to save ~51KB flash
-    # CMN covers CAs with >1% market share (~99% of websites)
-    # Components needing uncommon CAs can call require_full_certificate_bundle()
-    use_full_bundle = conf[CONF_ADVANCED].get(
-        CONF_USE_FULL_CERTIFICATE_BUNDLE, False
-    ) or CORE.data[KEY_ESP32].get(KEY_FULL_CERT_BUNDLE, False)
-    add_idf_sdkconfig_option(
-        "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL", use_full_bundle
-    )
-    if not use_full_bundle:
-        add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN", True)
-
     add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
     add_idf_sdkconfig_option(
         f"CONFIG_ESPTOOLPY_FLASHSIZE_{config[CONF_FLASH_SIZE]}", True

esphome/components/esp32/const.py

@@ -12,7 +12,6 @@ KEY_REFRESH = "refresh"
 KEY_PATH = "path"
 KEY_SUBMODULES = "submodules"
 KEY_EXTRA_BUILD_FILES = "extra_build_files"
-KEY_FULL_CERT_BUNDLE = "full_cert_bundle"
 
 VARIANT_ESP32 = "ESP32"
 VARIANT_ESP32C2 = "ESP32C2"

esphome/components/esp32/throw_stubs.cpp

@@ -1,57 +0,0 @@
-/*
- * Linker wrap stubs for std::__throw_* functions.
- *
- * ESP-IDF compiles with -fno-exceptions, so C++ exceptions always abort.
- * However, ESP-IDF only wraps low-level functions (__cxa_throw, etc.),
- * not the std::__throw_* functions that construct exception objects first.
- * This pulls in ~3KB of dead exception class code that can never run.
- *
- * ESP8266 Arduino already solved this: their toolchain rebuilds libstdc++
- * with throw functions that just call abort(). We achieve the same result
- * using linker --wrap without requiring toolchain changes.
- *
- * These stubs abort immediately with a descriptive message, allowing
- * the linker to dead-code eliminate the exception class infrastructure.
- *
- * Wrapped functions and their callers:
- * - std::__throw_length_error: std::string::reserve, std::vector::reserve
- * - std::__throw_logic_error: std::promise, std::packaged_task
- * - std::__throw_out_of_range: std::string::at, std::vector::at
- * - std::__throw_out_of_range_fmt: std::bitset::to_ulong
- * - std::__throw_bad_alloc: operator new
- * - std::__throw_bad_function_call: std::function::operator()
- */
-
-#ifdef USE_ESP_IDF
-#include "esp_system.h"
-
-namespace esphome::esp32 {}
-
-// Linker wraps for std::__throw_* - must be extern "C" at global scope.
-// Names must be __wrap_ + mangled name for the linker's --wrap option.
-
-// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-extern "C" {
-
-// std::__throw_length_error(char const*) - called when container size exceeds max_size()
-void __wrap__ZSt20__throw_length_errorPKc(const char *) { esp_system_abort("std::length_error"); }
-
-// std::__throw_logic_error(char const*) - called for logic errors (e.g., promise already satisfied)
-void __wrap__ZSt19__throw_logic_errorPKc(const char *) { esp_system_abort("std::logic_error"); }
-
-// std::__throw_out_of_range(char const*) - called by at() when index is out of bounds
-void __wrap__ZSt20__throw_out_of_rangePKc(const char *) { esp_system_abort("std::out_of_range"); }
-
-// std::__throw_out_of_range_fmt(char const*, ...) - called by bitset::to_ulong when value doesn't fit
-void __wrap__ZSt24__throw_out_of_range_fmtPKcz(const char *, ...) { esp_system_abort("std::out_of_range"); }
-
-// std::__throw_bad_alloc() - called when operator new fails
-void __wrap__ZSt17__throw_bad_allocv() { esp_system_abort("std::bad_alloc"); }
-
-// std::__throw_bad_function_call() - called when invoking empty std::function
-void __wrap__ZSt25__throw_bad_function_callv() { esp_system_abort("std::bad_function_call"); }
-
-}  // extern "C"
-// NOLINTEND(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-
-#endif  // USE_ESP_IDF

esphome/components/event/event.h

@@ -16,8 +16,12 @@ namespace event {
 #define LOG_EVENT(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
-    LOG_ENTITY_DEVICE_CLASS(TAG, prefix, *(obj)); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    } \
+    if (!(obj)->get_device_class_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class_ref().c_str()); \
+    } \
   }
 
 class Event : public EntityBase, public EntityBase_DeviceClass {

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/http_request/__init__.py

@@ -165,16 +165,6 @@ async def to_code(config):
                     ca_cert_content = f.read()
                 cg.add(var.set_ca_certificate(ca_cert_content))
             else:
-                # Uses the certificate bundle configured in esp32 component.
-                # By default, ESPHome uses the CMN (common CAs) bundle which covers
-                # ~99% of websites including GitHub, Let's Encrypt, DigiCert, etc.
-                # If connecting to services with uncommon CAs, components can call:
-                #   esp32.require_full_certificate_bundle()
-                # Or users can set in their config:
-                #   esp32:
-                #     framework:
-                #       advanced:
-                #         use_full_certificate_bundle: true
                 esp32.add_idf_sdkconfig_option(
                     "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True
                 )

esphome/components/hub75/boards/huidu.py

@@ -2,25 +2,6 @@
 
 from . import BoardConfig
 
-# Huidu HD-WF1
-BoardConfig(
-    "huidu-hd-wf1",
-    r1_pin=2,
-    g1_pin=6,
-    b1_pin=3,
-    r2_pin=4,
-    g2_pin=8,
-    b2_pin=5,
-    a_pin=39,
-    b_pin=38,
-    c_pin=37,
-    d_pin=36,
-    e_pin=12,
-    lat_pin=33,
-    oe_pin=35,
-    clk_pin=34,
-)
-
 # Huidu HD-WF2
 BoardConfig(
     "huidu-hd-wf2",

esphome/components/hub75/display.py

@@ -587,7 +587,7 @@ def _build_config_struct(
 async def to_code(config: ConfigType) -> None:
     add_idf_component(
         name="esphome/esp-hub75",
-        ref="0.3.2",
+        ref="0.3.0",
     )
 
     # Set compile-time configuration via build flags (so external library sees them)

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/lock/lock.h

@@ -14,7 +14,9 @@ class Lock;
 #define LOG_LOCK(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    } \
     if ((obj)->traits.get_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \
     } \

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/nextion/nextion.cpp

@@ -150,24 +150,27 @@ void Nextion::dump_config() {
 #ifdef USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
   ESP_LOGCONFIG(TAG, "  Skip handshake: YES");
 #else  // USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
-#ifdef USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
   ESP_LOGCONFIG(TAG,
+#ifdef USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
                 "  Device Model: %s\n"
                 "  FW Version: %s\n"
                 "  Serial Number: %s\n"
                 "  Flash Size: %s\n"
                 "  Max queue age: %u ms\n"
                 "  Startup override: %u ms\n",
-                this->device_model_.c_str(), this->firmware_version_.c_str(), this->serial_number_.c_str(),
-                this->flash_size_.c_str(), this->max_q_age_ms_, this->startup_override_ms_);
 #endif  // USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
 #ifdef USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START
-  ESP_LOGCONFIG(TAG, "  Exit reparse: YES\n");
+                "  Exit reparse: YES\n"
 #endif  // USE_NEXTION_CONFIG_EXIT_REPARSE_ON_START
-  ESP_LOGCONFIG(TAG,
                 "  Wake On Touch: %s\n"
                 "  Touch Timeout: %" PRIu16,
-                YESNO(this->connection_state_.auto_wake_on_touch_), this->touch_sleep_timeout_);
+#ifdef USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
+                this->device_model_.c_str(), this->firmware_version_.c_str(), this->serial_number_.c_str(),
+                this->flash_size_.c_str(), this->max_q_age_ms_,
+                this->startup_override_ms_
+#endif  // USE_NEXTION_CONFIG_DUMP_DEVICE_INFO
+                    YESNO(this->connection_state_.auto_wake_on_touch_),
+                this->touch_sleep_timeout_);
 #endif  // USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
 
 #ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP

esphome/components/nfc/binary_sensor/nfc_binary_sensor.cpp

@@ -40,7 +40,7 @@ void NfcTagBinarySensor::set_tag_name(const std::string &str) {
   this->match_tag_name_ = true;
 }
 
-void NfcTagBinarySensor::set_uid(const NfcTagUid &uid) { this->uid_ = uid; }
+void NfcTagBinarySensor::set_uid(const std::vector<uint8_t> &uid) { this->uid_ = uid; }
 
 bool NfcTagBinarySensor::tag_match_ndef_string(const std::shared_ptr<NdefMessage> &msg) {
   for (const auto &record : msg->get_records()) {
@@ -63,7 +63,7 @@ bool NfcTagBinarySensor::tag_match_tag_name(const std::shared_ptr<NdefMessage> &
   return false;
 }
 
-bool NfcTagBinarySensor::tag_match_uid(const NfcTagUid &data) {
+bool NfcTagBinarySensor::tag_match_uid(const std::vector<uint8_t> &data) {
   if (data.size() != this->uid_.size()) {
     return false;
   }

esphome/components/nfc/binary_sensor/nfc_binary_sensor.h

@@ -19,11 +19,11 @@ class NfcTagBinarySensor : public binary_sensor::BinarySensor,
 
   void set_ndef_match_string(const std::string &str);
   void set_tag_name(const std::string &str);
-  void set_uid(const NfcTagUid &uid);
+  void set_uid(const std::vector<uint8_t> &uid);
 
   bool tag_match_ndef_string(const std::shared_ptr<NdefMessage> &msg);
   bool tag_match_tag_name(const std::shared_ptr<NdefMessage> &msg);
-  bool tag_match_uid(const NfcTagUid &data);
+  bool tag_match_uid(const std::vector<uint8_t> &data);
 
   void tag_off(NfcTag &tag) override;
   void tag_on(NfcTag &tag) override;
@@ -31,7 +31,7 @@ class NfcTagBinarySensor : public binary_sensor::BinarySensor,
  protected:
   bool match_tag_name_{false};
   std::string match_string_;
-  NfcTagUid uid_;
+  std::vector<uint8_t> uid_;
 };
 
 }  // namespace nfc

esphome/components/nfc/nfc.cpp

@@ -8,23 +8,19 @@ namespace nfc {
 
 static const char *const TAG = "nfc";
 
-char *format_uid_to(char *buffer, std::span<const uint8_t> uid) {
+char *format_uid_to(char *buffer, const std::vector<uint8_t> &uid) {
   return format_hex_pretty_to(buffer, FORMAT_UID_BUFFER_SIZE, uid.data(), uid.size(), '-');
 }
 
-char *format_bytes_to(char *buffer, std::span<const uint8_t> bytes) {
+char *format_bytes_to(char *buffer, const std::vector<uint8_t> &bytes) {
   return format_hex_pretty_to(buffer, FORMAT_BYTES_BUFFER_SIZE, bytes.data(), bytes.size(), ' ');
 }
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 // Deprecated wrappers intentionally use heap-allocating version for backward compatibility
-std::string format_uid(std::span<const uint8_t> uid) {
-  return format_hex_pretty(uid.data(), uid.size(), '-', false);  // NOLINT
-}
-std::string format_bytes(std::span<const uint8_t> bytes) {
-  return format_hex_pretty(bytes.data(), bytes.size(), ' ', false);  // NOLINT
-}
+std::string format_uid(const std::vector<uint8_t> &uid) { return format_hex_pretty(uid, '-', false); }        // NOLINT
+std::string format_bytes(const std::vector<uint8_t> &bytes) { return format_hex_pretty(bytes, ' ', false); }  // NOLINT
 #pragma GCC diagnostic pop
 
 uint8_t guess_tag_type(uint8_t uid_length) {

esphome/components/nfc/nfc.h

@@ -6,7 +6,6 @@
 #include "ndef_record.h"
 #include "nfc_tag.h"
 
-#include <span>
 #include <vector>
 
 namespace esphome {
@@ -57,19 +56,19 @@ static const uint8_t MAD_KEY[6] = {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5};
 /// Max UID size is 10 bytes, formatted as "XX-XX-XX-XX-XX-XX-XX-XX-XX-XX\0" = 30 chars
 static constexpr size_t FORMAT_UID_BUFFER_SIZE = 30;
 /// Format UID to buffer with '-' separator (e.g., "04-11-22-33"). Returns buffer for inline use.
-char *format_uid_to(char *buffer, std::span<const uint8_t> uid);
+char *format_uid_to(char *buffer, const std::vector<uint8_t> &uid);
 
 /// Buffer size for format_bytes_to (64 bytes max = 192 chars with space separator)
 static constexpr size_t FORMAT_BYTES_BUFFER_SIZE = 192;
 /// Format bytes to buffer with ' ' separator (e.g., "04 11 22 33"). Returns buffer for inline use.
-char *format_bytes_to(char *buffer, std::span<const uint8_t> bytes);
+char *format_bytes_to(char *buffer, const std::vector<uint8_t> &bytes);
 
 // Remove before 2026.6.0
 ESPDEPRECATED("Use format_uid_to() with stack buffer instead. Removed in 2026.6.0", "2025.12.0")
-std::string format_uid(std::span<const uint8_t> uid);
+std::string format_uid(const std::vector<uint8_t> &uid);
 // Remove before 2026.6.0
 ESPDEPRECATED("Use format_bytes_to() with stack buffer instead. Removed in 2026.6.0", "2025.12.0")
-std::string format_bytes(std::span<const uint8_t> bytes);
+std::string format_bytes(const std::vector<uint8_t> &bytes);
 
 uint8_t guess_tag_type(uint8_t uid_length);
 uint8_t get_mifare_classic_ndef_start_index(std::vector<uint8_t> &data);

esphome/components/nfc/nfc_tag.h

@@ -10,27 +10,26 @@
 namespace esphome {
 namespace nfc {
 
-// NFC UIDs are 4, 7, or 10 bytes depending on tag type
-static constexpr size_t NFC_UID_MAX_LENGTH = 10;
-using NfcTagUid = StaticVector<uint8_t, NFC_UID_MAX_LENGTH>;
-
 class NfcTag {
  public:
-  NfcTag() { this->tag_type_ = "Unknown"; };
-  NfcTag(const NfcTagUid &uid) {
+  NfcTag() {
+    this->uid_ = {};
+    this->tag_type_ = "Unknown";
+  };
+  NfcTag(std::vector<uint8_t> &uid) {
     this->uid_ = uid;
     this->tag_type_ = "Unknown";
   };
-  NfcTag(const NfcTagUid &uid, const std::string &tag_type) {
+  NfcTag(std::vector<uint8_t> &uid, const std::string &tag_type) {
     this->uid_ = uid;
     this->tag_type_ = tag_type;
   };
-  NfcTag(const NfcTagUid &uid, const std::string &tag_type, std::unique_ptr<nfc::NdefMessage> ndef_message) {
+  NfcTag(std::vector<uint8_t> &uid, const std::string &tag_type, std::unique_ptr<nfc::NdefMessage> ndef_message) {
     this->uid_ = uid;
     this->tag_type_ = tag_type;
     this->ndef_message_ = std::move(ndef_message);
   };
-  NfcTag(const NfcTagUid &uid, const std::string &tag_type, std::vector<uint8_t> &ndef_data) {
+  NfcTag(std::vector<uint8_t> &uid, const std::string &tag_type, std::vector<uint8_t> &ndef_data) {
     this->uid_ = uid;
     this->tag_type_ = tag_type;
     this->ndef_message_ = make_unique<NdefMessage>(ndef_data);
@@ -42,14 +41,14 @@ class NfcTag {
       ndef_message_ = make_unique<NdefMessage>(*rhs.ndef_message_);
   }
 
-  NfcTagUid &get_uid() { return this->uid_; };
+  std::vector<uint8_t> &get_uid() { return this->uid_; };
   const std::string &get_tag_type() { return this->tag_type_; };
   bool has_ndef_message() { return this->ndef_message_ != nullptr; };
   const std::shared_ptr<NdefMessage> &get_ndef_message() { return this->ndef_message_; };
   void set_ndef_message(std::unique_ptr<NdefMessage> ndef_message) { this->ndef_message_ = std::move(ndef_message); };
 
  protected:
-  NfcTagUid uid_;
+  std::vector<uint8_t> uid_;
   std::string tag_type_;
   std::shared_ptr<NdefMessage> ndef_message_;
 };

esphome/components/nrf52/__init__.py

@@ -69,21 +69,9 @@ def set_core_data(config: ConfigType) -> ConfigType:
 
 
 def set_framework(config: ConfigType) -> ConfigType:
-    framework_ver = cv.Version.parse(
-        cv.version_number(config[CONF_FRAMEWORK][CONF_VERSION])
-    )
-    CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = framework_ver
-    if framework_ver < cv.Version(2, 9, 2):
-        return cv.require_framework_version(
-            nrf52_zephyr=cv.Version(2, 6, 1, "a"),
-        )(config)
-    if framework_ver < cv.Version(3, 2, 0):
-        return cv.require_framework_version(
-            nrf52_zephyr=cv.Version(2, 9, 2, "2"),
-        )(config)
-    return cv.require_framework_version(
-        nrf52_zephyr=cv.Version(3, 2, 0, "1"),
-    )(config)
+    version = cv.Version.parse(cv.version_number(config[CONF_FRAMEWORK][CONF_VERSION]))
+    CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = version
+    return config
 
 
 BOOTLOADERS = [
@@ -152,7 +140,7 @@ CONFIG_SCHEMA = cv.All(
                     cv.Optional(CONF_UICR_ERASE, default=False): cv.boolean,
                 }
             ),
-            cv.Optional(CONF_FRAMEWORK, default={CONF_VERSION: "2.6.1-a"}): cv.Schema(
+            cv.Optional(CONF_FRAMEWORK, default={CONF_VERSION: "2.6.1-7"}): cv.Schema(
                 {
                     cv.Required(CONF_VERSION): cv.string_strict,
                 }
@@ -193,12 +181,13 @@ async def to_code(config: ConfigType) -> None:
     cg.add_platformio_option(CONF_FRAMEWORK, CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK])
     cg.add_platformio_option(
         "platform",
-        "https://github.com/tomaszduda23/platform-nordicnrf52/archive/refs/tags/v10.3.0-5.zip",
+        "https://github.com/tomaszduda23/platform-nordicnrf52/archive/refs/tags/v10.3.0-1.zip",
     )
     cg.add_platformio_option(
         "platform_packages",
         [
             f"platformio/framework-zephyr@https://github.com/tomaszduda23/framework-sdk-nrf/archive/refs/tags/v{CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]}.zip",
+            "platformio/toolchain-gccarmnoneeabi@https://github.com/tomaszduda23/toolchain-sdk-ng/archive/refs/tags/v0.17.4-0.zip",
         ],
     )
 

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/number/number.cpp

@@ -14,9 +14,18 @@ void log_number(const char *tag, const char *prefix, const char *type, Number *o
   }
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
-  LOG_ENTITY_ICON(tag, prefix, *obj);
-  LOG_ENTITY_UNIT_OF_MEASUREMENT(tag, prefix, obj->traits);
-  LOG_ENTITY_DEVICE_CLASS(tag, prefix, obj->traits);
+
+  if (!obj->get_icon_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
+  }
+
+  if (!obj->traits.get_unit_of_measurement_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Unit of Measurement: '%s'", prefix, obj->traits.get_unit_of_measurement_ref().c_str());
+  }
+
+  if (!obj->traits.get_device_class_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->traits.get_device_class_ref().c_str());
+  }
 }
 
 void Number::publish_state(float 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/pn532/pn532.cpp

@@ -168,11 +168,11 @@ void PN532::loop() {
   }
 
   uint8_t nfcid_length = read[5];
-  if (nfcid_length > nfc::NFC_UID_MAX_LENGTH || read.size() < 6U + nfcid_length) {
+  std::vector<uint8_t> nfcid(read.begin() + 6, read.begin() + 6 + nfcid_length);
+  if (read.size() < 6U + nfcid_length) {
     // oops, pn532 returned invalid data
     return;
   }
-  nfc::NfcTagUid nfcid(read.begin() + 6, read.begin() + 6 + nfcid_length);
 
   bool report = true;
   for (auto *bin_sens : this->binary_sensors_) {
@@ -358,7 +358,7 @@ void PN532::turn_off_rf_() {
   });
 }
 
-std::unique_ptr<nfc::NfcTag> PN532::read_tag_(nfc::NfcTagUid &uid) {
+std::unique_ptr<nfc::NfcTag> PN532::read_tag_(std::vector<uint8_t> &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
 
   if (type == nfc::TAG_TYPE_MIFARE_CLASSIC) {
@@ -393,7 +393,7 @@ void PN532::write_mode(nfc::NdefMessage *message) {
   ESP_LOGD(TAG, "Waiting to write next tag");
 }
 
-bool PN532::clean_tag_(nfc::NfcTagUid &uid) {
+bool PN532::clean_tag_(std::vector<uint8_t> &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   if (type == nfc::TAG_TYPE_MIFARE_CLASSIC) {
     return this->format_mifare_classic_mifare_(uid);
@@ -404,7 +404,7 @@ bool PN532::clean_tag_(nfc::NfcTagUid &uid) {
   return false;
 }
 
-bool PN532::format_tag_(nfc::NfcTagUid &uid) {
+bool PN532::format_tag_(std::vector<uint8_t> &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   if (type == nfc::TAG_TYPE_MIFARE_CLASSIC) {
     return this->format_mifare_classic_ndef_(uid);
@@ -415,7 +415,7 @@ bool PN532::format_tag_(nfc::NfcTagUid &uid) {
   return false;
 }
 
-bool PN532::write_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message) {
+bool PN532::write_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   if (type == nfc::TAG_TYPE_MIFARE_CLASSIC) {
     return this->write_mifare_classic_tag_(uid, message);
@@ -448,7 +448,7 @@ void PN532::dump_config() {
   }
 }
 
-bool PN532BinarySensor::process(const nfc::NfcTagUid &data) {
+bool PN532BinarySensor::process(std::vector<uint8_t> &data) {
   if (data.size() != this->uid_.size())
     return false;
 

esphome/components/pn532/pn532.h

@@ -69,28 +69,28 @@ class PN532 : public PollingComponent {
   virtual bool read_data(std::vector<uint8_t> &data, uint8_t len) = 0;
   virtual bool read_response(uint8_t command, std::vector<uint8_t> &data) = 0;
 
-  std::unique_ptr<nfc::NfcTag> read_tag_(nfc::NfcTagUid &uid);
+  std::unique_ptr<nfc::NfcTag> read_tag_(std::vector<uint8_t> &uid);
 
-  bool format_tag_(nfc::NfcTagUid &uid);
-  bool clean_tag_(nfc::NfcTagUid &uid);
-  bool write_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message);
+  bool format_tag_(std::vector<uint8_t> &uid);
+  bool clean_tag_(std::vector<uint8_t> &uid);
+  bool write_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message);
 
-  std::unique_ptr<nfc::NfcTag> read_mifare_classic_tag_(nfc::NfcTagUid &uid);
+  std::unique_ptr<nfc::NfcTag> read_mifare_classic_tag_(std::vector<uint8_t> &uid);
   bool read_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t> &data);
   bool write_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t> &data);
-  bool auth_mifare_classic_block_(nfc::NfcTagUid &uid, uint8_t block_num, uint8_t key_num, const uint8_t *key);
-  bool format_mifare_classic_mifare_(nfc::NfcTagUid &uid);
-  bool format_mifare_classic_ndef_(nfc::NfcTagUid &uid);
-  bool write_mifare_classic_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message);
+  bool auth_mifare_classic_block_(std::vector<uint8_t> &uid, uint8_t block_num, uint8_t key_num, const uint8_t *key);
+  bool format_mifare_classic_mifare_(std::vector<uint8_t> &uid);
+  bool format_mifare_classic_ndef_(std::vector<uint8_t> &uid);
+  bool write_mifare_classic_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message);
 
-  std::unique_ptr<nfc::NfcTag> read_mifare_ultralight_tag_(nfc::NfcTagUid &uid);
+  std::unique_ptr<nfc::NfcTag> read_mifare_ultralight_tag_(std::vector<uint8_t> &uid);
   bool read_mifare_ultralight_bytes_(uint8_t start_page, uint16_t num_bytes, std::vector<uint8_t> &data);
   bool is_mifare_ultralight_formatted_(const std::vector<uint8_t> &page_3_to_6);
   uint16_t read_mifare_ultralight_capacity_();
   bool find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_to_6, uint8_t &message_length,
                                     uint8_t &message_start_index);
   bool write_mifare_ultralight_page_(uint8_t page_num, std::vector<uint8_t> &write_data);
-  bool write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message);
+  bool write_mifare_ultralight_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message);
   bool clean_mifare_ultralight_();
 
   bool updates_enabled_{true};
@@ -98,7 +98,7 @@ class PN532 : public PollingComponent {
   std::vector<PN532BinarySensor *> binary_sensors_;
   std::vector<nfc::NfcOnTagTrigger *> triggers_ontag_;
   std::vector<nfc::NfcOnTagTrigger *> triggers_ontagremoved_;
-  nfc::NfcTagUid current_uid_;
+  std::vector<uint8_t> current_uid_;
   nfc::NdefMessage *next_task_message_to_write_;
   uint32_t rd_start_time_{0};
   enum PN532ReadReady rd_ready_ { WOULDBLOCK };
@@ -118,9 +118,9 @@ class PN532 : public PollingComponent {
 
 class PN532BinarySensor : public binary_sensor::BinarySensor {
  public:
-  void set_uid(const nfc::NfcTagUid &uid) { uid_ = uid; }
+  void set_uid(const std::vector<uint8_t> &uid) { uid_ = uid; }
 
-  bool process(const nfc::NfcTagUid &data);
+  bool process(std::vector<uint8_t> &data);
 
   void on_scan_end() {
     if (!this->found_) {
@@ -130,7 +130,7 @@ class PN532BinarySensor : public binary_sensor::BinarySensor {
   }
 
  protected:
-  nfc::NfcTagUid uid_;
+  std::vector<uint8_t> uid_;
   bool found_{false};
 };
 

esphome/components/pn532/pn532_mifare_classic.cpp

@@ -8,7 +8,7 @@ namespace pn532 {
 
 static const char *const TAG = "pn532.mifare_classic";
 
-std::unique_ptr<nfc::NfcTag> PN532::read_mifare_classic_tag_(nfc::NfcTagUid &uid) {
+std::unique_ptr<nfc::NfcTag> PN532::read_mifare_classic_tag_(std::vector<uint8_t> &uid) {
   uint8_t current_block = 4;
   uint8_t message_start_index = 0;
   uint32_t message_length = 0;
@@ -82,7 +82,8 @@ bool PN532::read_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t> &
   return true;
 }
 
-bool PN532::auth_mifare_classic_block_(nfc::NfcTagUid &uid, uint8_t block_num, uint8_t key_num, const uint8_t *key) {
+bool PN532::auth_mifare_classic_block_(std::vector<uint8_t> &uid, uint8_t block_num, uint8_t key_num,
+                                       const uint8_t *key) {
   std::vector<uint8_t> data({
       PN532_COMMAND_INDATAEXCHANGE,
       0x01,       // One card
@@ -105,7 +106,7 @@ bool PN532::auth_mifare_classic_block_(nfc::NfcTagUid &uid, uint8_t block_num, u
   return true;
 }
 
-bool PN532::format_mifare_classic_mifare_(nfc::NfcTagUid &uid) {
+bool PN532::format_mifare_classic_mifare_(std::vector<uint8_t> &uid) {
   std::vector<uint8_t> blank_buffer(
       {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
   std::vector<uint8_t> trailer_buffer(
@@ -140,7 +141,7 @@ bool PN532::format_mifare_classic_mifare_(nfc::NfcTagUid &uid) {
   return !error;
 }
 
-bool PN532::format_mifare_classic_ndef_(nfc::NfcTagUid &uid) {
+bool PN532::format_mifare_classic_ndef_(std::vector<uint8_t> &uid) {
   std::vector<uint8_t> empty_ndef_message(
       {0x03, 0x03, 0xD0, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
   std::vector<uint8_t> blank_block(
@@ -215,7 +216,7 @@ bool PN532::write_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t>
   return true;
 }
 
-bool PN532::write_mifare_classic_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message) {
+bool PN532::write_mifare_classic_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message) {
   auto encoded = message->encode();
 
   uint32_t message_length = encoded.size();

esphome/components/pn532/pn532_mifare_ultralight.cpp

@@ -8,7 +8,7 @@ namespace pn532 {
 
 static const char *const TAG = "pn532.mifare_ultralight";
 
-std::unique_ptr<nfc::NfcTag> PN532::read_mifare_ultralight_tag_(nfc::NfcTagUid &uid) {
+std::unique_ptr<nfc::NfcTag> PN532::read_mifare_ultralight_tag_(std::vector<uint8_t> &uid) {
   std::vector<uint8_t> data;
   // pages 3 to 6 contain various info we are interested in -- do one read to grab it all
   if (!this->read_mifare_ultralight_bytes_(3, nfc::MIFARE_ULTRALIGHT_PAGE_SIZE * nfc::MIFARE_ULTRALIGHT_READ_SIZE,
@@ -114,7 +114,7 @@ bool PN532::find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_to_6
   return false;
 }
 
-bool PN532::write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message) {
+bool PN532::write_mifare_ultralight_tag_(std::vector<uint8_t> &uid, nfc::NdefMessage *message) {
   uint32_t capacity = this->read_mifare_ultralight_capacity_();
 
   auto encoded = message->encode();

esphome/components/pn7150/pn7150.cpp

@@ -478,7 +478,7 @@ uint8_t PN7150::read_endpoint_data_(nfc::NfcTag &tag) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7150::clean_endpoint_(nfc::NfcTagUid &uid) {
+uint8_t PN7150::clean_endpoint_(std::vector<uint8_t> &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -494,7 +494,7 @@ uint8_t PN7150::clean_endpoint_(nfc::NfcTagUid &uid) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7150::format_endpoint_(nfc::NfcTagUid &uid) {
+uint8_t PN7150::format_endpoint_(std::vector<uint8_t> &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -510,7 +510,7 @@ uint8_t PN7150::format_endpoint_(nfc::NfcTagUid &uid) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7150::write_endpoint_(nfc::NfcTagUid &uid, std::shared_ptr<nfc::NdefMessage> &message) {
+uint8_t PN7150::write_endpoint_(std::vector<uint8_t> &uid, std::shared_ptr<nfc::NdefMessage> &message) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -534,7 +534,7 @@ std::unique_ptr<nfc::NfcTag> PN7150::build_tag_(const uint8_t mode_tech, const s
         ESP_LOGE(TAG, "UID length cannot be zero");
         return nullptr;
       }
-      nfc::NfcTagUid uid(data.begin() + 3, data.begin() + 3 + uid_length);
+      std::vector<uint8_t> uid(data.begin() + 3, data.begin() + 3 + uid_length);
       const auto *tag_type_str =
           nfc::guess_tag_type(uid_length) == nfc::TAG_TYPE_MIFARE_CLASSIC ? nfc::MIFARE_CLASSIC : nfc::NFC_FORUM_TYPE_2;
       return make_unique<nfc::NfcTag>(uid, tag_type_str);
@@ -543,7 +543,7 @@ std::unique_ptr<nfc::NfcTag> PN7150::build_tag_(const uint8_t mode_tech, const s
   return nullptr;
 }
 
-optional<size_t> PN7150::find_tag_uid_(const nfc::NfcTagUid &uid) {
+optional<size_t> PN7150::find_tag_uid_(const std::vector<uint8_t> &uid) {
   if (!this->discovered_endpoint_.empty()) {
     for (size_t i = 0; i < this->discovered_endpoint_.size(); i++) {
       auto existing_tag_uid = this->discovered_endpoint_[i].tag->get_uid();

esphome/components/pn7150/pn7150.h

@@ -203,12 +203,12 @@ class PN7150 : public nfc::Nfcc, public Component {
   void select_endpoint_();
 
   uint8_t read_endpoint_data_(nfc::NfcTag &tag);
-  uint8_t clean_endpoint_(nfc::NfcTagUid &uid);
-  uint8_t format_endpoint_(nfc::NfcTagUid &uid);
-  uint8_t write_endpoint_(nfc::NfcTagUid &uid, std::shared_ptr<nfc::NdefMessage> &message);
+  uint8_t clean_endpoint_(std::vector<uint8_t> &uid);
+  uint8_t format_endpoint_(std::vector<uint8_t> &uid);
+  uint8_t write_endpoint_(std::vector<uint8_t> &uid, std::shared_ptr<nfc::NdefMessage> &message);
 
   std::unique_ptr<nfc::NfcTag> build_tag_(uint8_t mode_tech, const std::vector<uint8_t> &data);
-  optional<size_t> find_tag_uid_(const nfc::NfcTagUid &uid);
+  optional<size_t> find_tag_uid_(const std::vector<uint8_t> &uid);
   void purge_old_tags_();
   void erase_tag_(uint8_t tag_index);
 
@@ -251,7 +251,7 @@ class PN7150 : public nfc::Nfcc, public Component {
   uint8_t find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_to_6, uint8_t &message_length,
                                        uint8_t &message_start_index);
   uint8_t write_mifare_ultralight_page_(uint8_t page_num, std::vector<uint8_t> &write_data);
-  uint8_t write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::shared_ptr<nfc::NdefMessage> &message);
+  uint8_t write_mifare_ultralight_tag_(std::vector<uint8_t> &uid, const std::shared_ptr<nfc::NdefMessage> &message);
   uint8_t clean_mifare_ultralight_();
 
   enum NfcTask : uint8_t {

esphome/components/pn7150/pn7150_mifare_ultralight.cpp

@@ -115,7 +115,8 @@ uint8_t PN7150::find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7150::write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::shared_ptr<nfc::NdefMessage> &message) {
+uint8_t PN7150::write_mifare_ultralight_tag_(std::vector<uint8_t> &uid,
+                                             const std::shared_ptr<nfc::NdefMessage> &message) {
   uint32_t capacity = this->read_mifare_ultralight_capacity_();
 
   auto encoded = message->encode();

esphome/components/pn7160/pn7160.cpp

@@ -506,7 +506,7 @@ uint8_t PN7160::read_endpoint_data_(nfc::NfcTag &tag) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7160::clean_endpoint_(nfc::NfcTagUid &uid) {
+uint8_t PN7160::clean_endpoint_(std::vector<uint8_t> &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -522,7 +522,7 @@ uint8_t PN7160::clean_endpoint_(nfc::NfcTagUid &uid) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7160::format_endpoint_(nfc::NfcTagUid &uid) {
+uint8_t PN7160::format_endpoint_(std::vector<uint8_t> &uid) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -538,7 +538,7 @@ uint8_t PN7160::format_endpoint_(nfc::NfcTagUid &uid) {
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7160::write_endpoint_(nfc::NfcTagUid &uid, std::shared_ptr<nfc::NdefMessage> &message) {
+uint8_t PN7160::write_endpoint_(std::vector<uint8_t> &uid, std::shared_ptr<nfc::NdefMessage> &message) {
   uint8_t type = nfc::guess_tag_type(uid.size());
   switch (type) {
     case nfc::TAG_TYPE_MIFARE_CLASSIC:
@@ -562,7 +562,7 @@ std::unique_ptr<nfc::NfcTag> PN7160::build_tag_(const uint8_t mode_tech, const s
         ESP_LOGE(TAG, "UID length cannot be zero");
         return nullptr;
       }
-      nfc::NfcTagUid uid(data.begin() + 3, data.begin() + 3 + uid_length);
+      std::vector<uint8_t> uid(data.begin() + 3, data.begin() + 3 + uid_length);
       const auto *tag_type_str =
           nfc::guess_tag_type(uid_length) == nfc::TAG_TYPE_MIFARE_CLASSIC ? nfc::MIFARE_CLASSIC : nfc::NFC_FORUM_TYPE_2;
       return make_unique<nfc::NfcTag>(uid, tag_type_str);
@@ -571,7 +571,7 @@ std::unique_ptr<nfc::NfcTag> PN7160::build_tag_(const uint8_t mode_tech, const s
   return nullptr;
 }
 
-optional<size_t> PN7160::find_tag_uid_(const nfc::NfcTagUid &uid) {
+optional<size_t> PN7160::find_tag_uid_(const std::vector<uint8_t> &uid) {
   if (!this->discovered_endpoint_.empty()) {
     for (size_t i = 0; i < this->discovered_endpoint_.size(); i++) {
       auto existing_tag_uid = this->discovered_endpoint_[i].tag->get_uid();

esphome/components/pn7160/pn7160.h

@@ -220,12 +220,12 @@ class PN7160 : public nfc::Nfcc, public Component {
   void select_endpoint_();
 
   uint8_t read_endpoint_data_(nfc::NfcTag &tag);
-  uint8_t clean_endpoint_(nfc::NfcTagUid &uid);
-  uint8_t format_endpoint_(nfc::NfcTagUid &uid);
-  uint8_t write_endpoint_(nfc::NfcTagUid &uid, std::shared_ptr<nfc::NdefMessage> &message);
+  uint8_t clean_endpoint_(std::vector<uint8_t> &uid);
+  uint8_t format_endpoint_(std::vector<uint8_t> &uid);
+  uint8_t write_endpoint_(std::vector<uint8_t> &uid, std::shared_ptr<nfc::NdefMessage> &message);
 
   std::unique_ptr<nfc::NfcTag> build_tag_(uint8_t mode_tech, const std::vector<uint8_t> &data);
-  optional<size_t> find_tag_uid_(const nfc::NfcTagUid &uid);
+  optional<size_t> find_tag_uid_(const std::vector<uint8_t> &uid);
   void purge_old_tags_();
   void erase_tag_(uint8_t tag_index);
 
@@ -268,7 +268,7 @@ class PN7160 : public nfc::Nfcc, public Component {
   uint8_t find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_to_6, uint8_t &message_length,
                                        uint8_t &message_start_index);
   uint8_t write_mifare_ultralight_page_(uint8_t page_num, std::vector<uint8_t> &write_data);
-  uint8_t write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::shared_ptr<nfc::NdefMessage> &message);
+  uint8_t write_mifare_ultralight_tag_(std::vector<uint8_t> &uid, const std::shared_ptr<nfc::NdefMessage> &message);
   uint8_t clean_mifare_ultralight_();
 
   enum NfcTask : uint8_t {

esphome/components/pn7160/pn7160_mifare_ultralight.cpp

@@ -115,7 +115,8 @@ uint8_t PN7160::find_mifare_ultralight_ndef_(const std::vector<uint8_t> &page_3_
   return nfc::STATUS_FAILED;
 }
 
-uint8_t PN7160::write_mifare_ultralight_tag_(nfc::NfcTagUid &uid, const std::shared_ptr<nfc::NdefMessage> &message) {
+uint8_t PN7160::write_mifare_ultralight_tag_(std::vector<uint8_t> &uid,
+                                             const std::shared_ptr<nfc::NdefMessage> &message) {
   uint32_t capacity = this->read_mifare_ultralight_capacity_();
 
   auto encoded = message->encode();

esphome/components/prometheus/prometheus_handler.h

@@ -41,14 +41,12 @@ class PrometheusHandler : public AsyncWebHandler, public Component {
   void add_label_name(EntityBase *obj, const std::string &value) { relabel_map_name_.insert({obj, value}); }
 
   bool canHandle(AsyncWebServerRequest *request) const override {
-    if (request->method() != HTTP_GET)
-      return false;
-#ifdef USE_ESP32
-    char url_buf[AsyncWebServerRequest::URL_BUF_SIZE];
-    return request->url_to(url_buf) == "/metrics";
-#else
-    return request->url() == ESPHOME_F("/metrics");
-#endif
+    if (request->method() == HTTP_GET) {
+      if (request->url() == "/metrics")
+        return true;
+    }
+
+    return false;
   }
 
   void handleRequest(AsyncWebServerRequest *req) override;

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/rtl87xx/boards.py

@@ -23,10 +23,6 @@ RTL87XX_BOARDS = {
         "name": "WR2 Wi-Fi Module",
         "family": FAMILY_RTL8710B,
     },
-    "wbr3": {
-        "name": "WBR3 Wi-Fi Module",
-        "family": FAMILY_RTL8720C,
-    },
     "generic-rtl8710bn-2mb-468k": {
         "name": "Generic - RTL8710BN (2M/468k)",
         "family": FAMILY_RTL8710B,
@@ -83,10 +79,6 @@ RTL87XX_BOARDS = {
         "name": "T103_V1.0",
         "family": FAMILY_RTL8710B,
     },
-    "generic-rtl8720cf-2mb-896k": {
-        "name": "Generic - RTL8720CF (2M/896k)",
-        "family": FAMILY_RTL8720C,
-    },
     "generic-rtl8720cf-2mb-992k": {
         "name": "Generic - RTL8720CF (2M/992k)",
         "family": FAMILY_RTL8720C,
@@ -229,71 +221,6 @@ RTL87XX_BOARD_PINS = {
         "D9": 29,
         "A1": 41,
     },
-    "wbr3": {
-        "WIRE0_SCL_0": 11,
-        "WIRE0_SCL_1": 2,
-        "WIRE0_SCL_2": 19,
-        "WIRE0_SCL_3": 15,
-        "WIRE0_SDA_0": 3,
-        "WIRE0_SDA_1": 12,
-        "WIRE0_SDA_2": 16,
-        "SERIAL0_RX_0": 12,
-        "SERIAL0_RX_1": 13,
-        "SERIAL0_TX_0": 11,
-        "SERIAL0_TX_1": 14,
-        "SERIAL1_CTS": 4,
-        "SERIAL1_RX_0": 2,
-        "SERIAL1_RX_1": 0,
-        "SERIAL1_TX_0": 3,
-        "SERIAL1_TX_1": 1,
-        "SERIAL2_CTS": 19,
-        "SERIAL2_RX": 15,
-        "SERIAL2_TX": 16,
-        "CS0": 15,
-        "CTS1": 4,
-        "CTS2": 19,
-        "PA00": 0,
-        "PA0": 0,
-        "PA01": 1,
-        "PA1": 1,
-        "PA02": 2,
-        "PA2": 2,
-        "PA03": 3,
-        "PA3": 3,
-        "PA04": 4,
-        "PA4": 4,
-        "PA07": 7,
-        "PA7": 7,
-        "PA11": 11,
-        "PA12": 12,
-        "PA13": 13,
-        "PA14": 14,
-        "PA15": 15,
-        "PA16": 16,
-        "PA17": 17,
-        "PA18": 18,
-        "PA19": 19,
-        "PWM5": 17,
-        "PWM6": 18,
-        "RX2": 15,
-        "SDA0": 16,
-        "TX2": 16,
-        "D0": 7,
-        "D1": 11,
-        "D2": 2,
-        "D3": 3,
-        "D4": 4,
-        "D5": 12,
-        "D6": 16,
-        "D7": 17,
-        "D8": 18,
-        "D9": 19,
-        "D10": 13,
-        "D11": 14,
-        "D12": 15,
-        "D13": 0,
-        "D14": 1,
-    },
     "generic-rtl8710bn-2mb-468k": {
         "SPI0_CS": 19,
         "SPI0_MISO": 22,
@@ -1251,104 +1178,6 @@ RTL87XX_BOARD_PINS = {
         "A0": 19,
         "A1": 41,
     },
-    "generic-rtl8720cf-2mb-896k": {
-        "SPI0_CS_0": 2,
-        "SPI0_CS_1": 7,
-        "SPI0_CS_2": 15,
-        "SPI0_MISO_0": 10,
-        "SPI0_MISO_1": 20,
-        "SPI0_MOSI_0": 4,
-        "SPI0_MOSI_1": 9,
-        "SPI0_MOSI_2": 19,
-        "SPI0_SCK_0": 3,
-        "SPI0_SCK_1": 8,
-        "SPI0_SCK_2": 16,
-        "WIRE0_SCL_0": 2,
-        "WIRE0_SCL_1": 11,
-        "WIRE0_SCL_2": 15,
-        "WIRE0_SCL_3": 19,
-        "WIRE0_SDA_0": 3,
-        "WIRE0_SDA_1": 12,
-        "WIRE0_SDA_2": 16,
-        "WIRE0_SDA_3": 20,
-        "SERIAL0_CTS": 10,
-        "SERIAL0_RTS": 9,
-        "SERIAL0_RX_0": 12,
-        "SERIAL0_RX_1": 13,
-        "SERIAL0_TX_0": 11,
-        "SERIAL0_TX_1": 14,
-        "SERIAL1_CTS": 4,
-        "SERIAL1_RX_0": 0,
-        "SERIAL1_RX_1": 2,
-        "SERIAL1_TX_0": 1,
-        "SERIAL1_TX_1": 3,
-        "SERIAL2_CTS": 19,
-        "SERIAL2_RTS": 20,
-        "SERIAL2_RX": 15,
-        "SERIAL2_TX": 16,
-        "CS0": 15,
-        "CTS0": 10,
-        "CTS1": 4,
-        "CTS2": 19,
-        "MOSI0": 19,
-        "PA00": 0,
-        "PA0": 0,
-        "PA01": 1,
-        "PA1": 1,
-        "PA02": 2,
-        "PA2": 2,
-        "PA03": 3,
-        "PA3": 3,
-        "PA04": 4,
-        "PA4": 4,
-        "PA07": 7,
-        "PA7": 7,
-        "PA08": 8,
-        "PA8": 8,
-        "PA09": 9,
-        "PA9": 9,
-        "PA10": 10,
-        "PA11": 11,
-        "PA12": 12,
-        "PA13": 13,
-        "PA14": 14,
-        "PA15": 15,
-        "PA16": 16,
-        "PA17": 17,
-        "PA18": 18,
-        "PA19": 19,
-        "PA20": 20,
-        "PA23": 23,
-        "PWM0": 20,
-        "PWM5": 17,
-        "PWM6": 18,
-        "PWM7": 23,
-        "RTS0": 9,
-        "RTS2": 20,
-        "RX2": 15,
-        "SCK0": 16,
-        "TX2": 16,
-        "D0": 0,
-        "D1": 1,
-        "D2": 2,
-        "D3": 3,
-        "D4": 4,
-        "D5": 7,
-        "D6": 8,
-        "D7": 9,
-        "D8": 10,
-        "D9": 11,
-        "D10": 12,
-        "D11": 13,
-        "D12": 14,
-        "D13": 15,
-        "D14": 16,
-        "D15": 17,
-        "D16": 18,
-        "D17": 19,
-        "D18": 20,
-        "D19": 23,
-    },
     "generic-rtl8720cf-2mb-992k": {
         "SPI0_CS_0": 2,
         "SPI0_CS_1": 7,

esphome/components/runtime_stats/runtime_stats.cpp

@@ -27,61 +27,46 @@ void RuntimeStatsCollector::record_component_time(Component *component, uint32_t
 }
 
 void RuntimeStatsCollector::log_stats_() {
-  // First pass: count active components
-  size_t count = 0;
-  for (const auto &it : this->component_stats_) {
-    if (it.second.get_period_count() > 0) {
-      count++;
-    }
-  }
-
   ESP_LOGI(TAG,
            "Component Runtime Statistics\n"
-           " Period stats (last %" PRIu32 "ms): %zu active components",
-           this->log_interval_, count);
+           " Period stats (last %" PRIu32 "ms):",
+           this->log_interval_);
 
-  if (count == 0) {
-    return;
-  }
+  // First collect stats we want to display
+  std::vector<ComponentStatPair> stats_to_display;
 
-  // Stack buffer sized to actual active count (up to 256 = 1KB), heap fallback for larger
-  SmallBufferWithHeapFallback<256, Component *> buffer(count);
-  Component **sorted = buffer.get();
-
-  // Second pass: fill buffer with active components
-  size_t idx = 0;
   for (const auto &it : this->component_stats_) {
-    if (it.second.get_period_count() > 0) {
-      sorted[idx++] = it.first;
+    Component *component = it.first;
+    const ComponentRuntimeStats &stats = it.second;
+    if (stats.get_period_count() > 0) {
+      ComponentStatPair pair = {component, &stats};
+      stats_to_display.push_back(pair);
     }
   }
 
   // Sort by period runtime (descending)
-  std::sort(sorted, sorted + count, [this](Component *a, Component *b) {
-    return this->component_stats_[a].get_period_time_ms() > this->component_stats_[b].get_period_time_ms();
-  });
+  std::sort(stats_to_display.begin(), stats_to_display.end(), std::greater<ComponentStatPair>());
 
   // Log top components by period runtime
-  for (size_t i = 0; i < count; i++) {
-    const auto &stats = this->component_stats_[sorted[i]];
+  for (const auto &it : stats_to_display) {
     ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-             LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.get_period_count(), stats.get_period_avg_time_ms(),
-             stats.get_period_max_time_ms(), stats.get_period_time_ms());
+             LOG_STR_ARG(it.component->get_component_log_str()), it.stats->get_period_count(),
+             it.stats->get_period_avg_time_ms(), it.stats->get_period_max_time_ms(), it.stats->get_period_time_ms());
   }
 
-  // Log total stats since boot (only for active components - idle ones haven't changed)
-  ESP_LOGI(TAG, " Total stats (since boot): %zu active components", count);
+  // Log total stats since boot
+  ESP_LOGI(TAG, " Total stats (since boot):");
 
   // Re-sort by total runtime for all-time stats
-  std::sort(sorted, sorted + count, [this](Component *a, Component *b) {
-    return this->component_stats_[a].get_total_time_ms() > this->component_stats_[b].get_total_time_ms();
-  });
+  std::sort(stats_to_display.begin(), stats_to_display.end(),
+            [](const ComponentStatPair &a, const ComponentStatPair &b) {
+              return a.stats->get_total_time_ms() > b.stats->get_total_time_ms();
+            });
 
-  for (size_t i = 0; i < count; i++) {
-    const auto &stats = this->component_stats_[sorted[i]];
+  for (const auto &it : stats_to_display) {
     ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-             LOG_STR_ARG(sorted[i]->get_component_log_str()), stats.get_total_count(), stats.get_total_avg_time_ms(),
-             stats.get_total_max_time_ms(), stats.get_total_time_ms());
+             LOG_STR_ARG(it.component->get_component_log_str()), it.stats->get_total_count(),
+             it.stats->get_total_avg_time_ms(), it.stats->get_total_max_time_ms(), it.stats->get_total_time_ms());
   }
 }
 

esphome/components/runtime_stats/runtime_stats.h

@@ -77,6 +77,17 @@ class ComponentRuntimeStats {
   uint32_t total_max_time_ms_;
 };
 
+// For sorting components by run time
+struct ComponentStatPair {
+  Component *component;
+  const ComponentRuntimeStats *stats;
+
+  bool operator>(const ComponentStatPair &other) const {
+    // Sort by period time as that's what we're displaying in the logs
+    return stats->get_period_time_ms() > other.stats->get_period_time_ms();
+  }
+};
+
 class RuntimeStatsCollector {
  public:
   RuntimeStatsCollector();

esphome/components/select/select.h

@@ -12,7 +12,9 @@ namespace esphome::select {
 #define LOG_SELECT(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    } \
   }
 
 #define SUB_SELECT(name) \

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/sensor/sensor.cpp

@@ -22,8 +22,13 @@ void log_sensor(const char *tag, const char *prefix, const char *type, Sensor *o
                 LOG_STR_ARG(state_class_to_string(obj->get_state_class())), prefix,
                 obj->get_unit_of_measurement_ref().c_str(), prefix, obj->get_accuracy_decimals());
 
-  LOG_ENTITY_DEVICE_CLASS(tag, prefix, *obj);
-  LOG_ENTITY_ICON(tag, prefix, *obj);
+  if (!obj->get_device_class_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
+  }
+
+  if (!obj->get_icon_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
+  }
 
   if (obj->get_force_update()) {
     ESP_LOGV(tag, "%s  Force Update: YES", prefix);

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 {};
@@ -96,14 +96,18 @@ void log_switch(const char *tag, const char *prefix, const char *type, Switch *o
                   LOG_STR_ARG(onoff));
 
     // Add optional fields separately
-    LOG_ENTITY_ICON(tag, prefix, *obj);
+    if (!obj->get_icon_ref().empty()) {
+      ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
+    }
     if (obj->assumed_state()) {
       ESP_LOGCONFIG(tag, "%s  Assumed State: YES", prefix);
     }
     if (obj->is_inverted()) {
       ESP_LOGCONFIG(tag, "%s  Inverted: YES", prefix);
     }
-    LOG_ENTITY_DEVICE_CLASS(tag, prefix, *obj);
+    if (!obj->get_device_class_ref().empty()) {
+      ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
+    }
   }
 }
 

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/text/text.h

@@ -12,7 +12,9 @@ namespace text {
 #define LOG_TEXT(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
+    if (!(obj)->get_icon_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    } \
   }
 
 /** Base-class for all text inputs.

esphome/components/text_sensor/filter.cpp

@@ -9,18 +9,19 @@ namespace text_sensor {
 static const char *const TAG = "text_sensor.filter";
 
 // Filter
-void Filter::input(std::string value) {
+void Filter::input(const std::string &value) {
   ESP_LOGVV(TAG, "Filter(%p)::input(%s)", this, value.c_str());
-  if (this->new_value(value))
-    this->output(value);
+  optional<std::string> out = this->new_value(value);
+  if (out.has_value())
+    this->output(*out);
 }
-void Filter::output(std::string &value) {
+void Filter::output(const std::string &value) {
   if (this->next_ == nullptr) {
     ESP_LOGVV(TAG, "Filter(%p)::output(%s) -> SENSOR", this, value.c_str());
     this->parent_->internal_send_state_to_frontend(value);
   } else {
     ESP_LOGVV(TAG, "Filter(%p)::output(%s) -> %p", this, value.c_str(), this->next_);
-    this->next_->input(std::move(value));
+    this->next_->input(value);
   }
 }
 void Filter::initialize(TextSensor *parent, Filter *next) {
@@ -34,48 +35,43 @@ LambdaFilter::LambdaFilter(lambda_filter_t lambda_filter) : lambda_filter_(std::
 const lambda_filter_t &LambdaFilter::get_lambda_filter() const { return this->lambda_filter_; }
 void LambdaFilter::set_lambda_filter(const lambda_filter_t &lambda_filter) { this->lambda_filter_ = lambda_filter; }
 
-bool LambdaFilter::new_value(std::string &value) {
-  auto result = this->lambda_filter_(value);
-  if (result.has_value()) {
-    ESP_LOGVV(TAG, "LambdaFilter(%p)::new_value(%s) -> %s (continue)", this, value.c_str(), result->c_str());
-    value = std::move(*result);
-    return true;
-  }
-  ESP_LOGVV(TAG, "LambdaFilter(%p)::new_value(%s) -> (stop)", this, value.c_str());
-  return false;
+optional<std::string> LambdaFilter::new_value(std::string value) {
+  auto it = this->lambda_filter_(value);
+  ESP_LOGVV(TAG, "LambdaFilter(%p)::new_value(%s) -> %s", this, value.c_str(), it.value_or("").c_str());
+  return it;
 }
 
 // ToUpperFilter
-bool ToUpperFilter::new_value(std::string &value) {
+optional<std::string> ToUpperFilter::new_value(std::string value) {
   for (char &c : value)
     c = ::toupper(c);
-  return true;
+  return value;
 }
 
 // ToLowerFilter
-bool ToLowerFilter::new_value(std::string &value) {
+optional<std::string> ToLowerFilter::new_value(std::string value) {
   for (char &c : value)
     c = ::tolower(c);
-  return true;
+  return value;
 }
 
 // Append
-bool AppendFilter::new_value(std::string &value) {
+optional<std::string> AppendFilter::new_value(std::string value) {
   value.append(this->suffix_);
-  return true;
+  return value;
 }
 
 // Prepend
-bool PrependFilter::new_value(std::string &value) {
+optional<std::string> PrependFilter::new_value(std::string value) {
   value.insert(0, this->prefix_);
-  return true;
+  return value;
 }
 
 // Substitute
 SubstituteFilter::SubstituteFilter(const std::initializer_list<Substitution> &substitutions)
     : substitutions_(substitutions) {}
 
-bool SubstituteFilter::new_value(std::string &value) {
+optional<std::string> SubstituteFilter::new_value(std::string value) {
   for (const auto &sub : this->substitutions_) {
     // Compute lengths once per substitution (strlen is fast, called infrequently)
     const size_t from_len = strlen(sub.from);
@@ -88,20 +84,20 @@ bool SubstituteFilter::new_value(std::string &value) {
       pos += to_len;
     }
   }
-  return true;
+  return value;
 }
 
 // Map
 MapFilter::MapFilter(const std::initializer_list<Substitution> &mappings) : mappings_(mappings) {}
 
-bool MapFilter::new_value(std::string &value) {
+optional<std::string> MapFilter::new_value(std::string value) {
   for (const auto &mapping : this->mappings_) {
     if (value == mapping.from) {
       value.assign(mapping.to);
-      return true;
+      return value;
     }
   }
-  return true;  // Pass through if no match
+  return value;  // Pass through if no match
 }
 
 }  // namespace text_sensor

esphome/components/text_sensor/filter.h

@@ -17,20 +17,21 @@ class Filter {
  public:
   /** This will be called every time the filter receives a new value.
    *
-   * Modify the value in place. Return false to stop the filter chain
-   * (value will not be published), or true to continue.
+   * It can return an empty optional to indicate that the filter chain
+   * should stop, otherwise the value in the filter will be passed down
+   * the chain.
    *
-   * @param value The value to filter (modified in place).
-   * @return True to continue the filter chain, false to stop.
+   * @param value The new value.
+   * @return An optional string, the new value that should be pushed out.
    */
-  virtual bool new_value(std::string &value) = 0;
+  virtual optional<std::string> new_value(std::string value) = 0;
 
   /// Initialize this filter, please note this can be called more than once.
   virtual void initialize(TextSensor *parent, Filter *next);
 
-  void input(std::string value);
+  void input(const std::string &value);
 
-  void output(std::string &value);
+  void output(const std::string &value);
 
  protected:
   friend TextSensor;
@@ -44,14 +45,15 @@ using lambda_filter_t = std::function<optional<std::string>(std::string)>;
 /** This class allows for creation of simple template filters.
  *
  * The constructor accepts a lambda of the form std::string -> optional<std::string>.
- * Return a modified string to continue the chain, or return {} to stop
- * (value will not be published).
+ * It will be called with each new value in the filter chain and returns the modified
+ * value that shall be passed down the filter chain. Returning an empty Optional
+ * means that the value shall be discarded.
  */
 class LambdaFilter : public Filter {
  public:
   explicit LambdaFilter(lambda_filter_t lambda_filter);
 
-  bool new_value(std::string &value) override;
+  optional<std::string> new_value(std::string value) override;
 
   const lambda_filter_t &get_lambda_filter() const;
   void set_lambda_filter(const lambda_filter_t &lambda_filter);
@@ -69,14 +71,7 @@ class StatelessLambdaFilter : public Filter {
  public:
   explicit StatelessLambdaFilter(optional<std::string> (*lambda_filter)(std::string)) : lambda_filter_(lambda_filter) {}
 
-  bool new_value(std::string &value) override {
-    auto result = this->lambda_filter_(value);
-    if (result.has_value()) {
-      value = std::move(*result);
-      return true;
-    }
-    return false;
-  }
+  optional<std::string> new_value(std::string value) override { return this->lambda_filter_(value); }
 
  protected:
   optional<std::string> (*lambda_filter_)(std::string);
@@ -85,20 +80,20 @@ class StatelessLambdaFilter : public Filter {
 /// A simple filter that converts all text to uppercase
 class ToUpperFilter : public Filter {
  public:
-  bool new_value(std::string &value) override;
+  optional<std::string> new_value(std::string value) override;
 };
 
 /// A simple filter that converts all text to lowercase
 class ToLowerFilter : public Filter {
  public:
-  bool new_value(std::string &value) override;
+  optional<std::string> new_value(std::string value) override;
 };
 
 /// A simple filter that adds a string to the end of another string
 class AppendFilter : public Filter {
  public:
   explicit AppendFilter(const char *suffix) : suffix_(suffix) {}
-  bool new_value(std::string &value) override;
+  optional<std::string> new_value(std::string value) override;
 
  protected:
   const char *suffix_;
@@ -108,7 +103,7 @@ class AppendFilter : public Filter {
 class PrependFilter : public Filter {
  public:
   explicit PrependFilter(const char *prefix) : prefix_(prefix) {}
-  bool new_value(std::string &value) override;
+  optional<std::string> new_value(std::string value) override;
 
  protected:
   const char *prefix_;
@@ -123,7 +118,7 @@ struct Substitution {
 class SubstituteFilter : public Filter {
  public:
   explicit SubstituteFilter(const std::initializer_list<Substitution> &substitutions);
-  bool new_value(std::string &value) override;
+  optional<std::string> new_value(std::string value) override;
 
  protected:
   FixedVector<Substitution> substitutions_;
@@ -156,7 +151,7 @@ class SubstituteFilter : public Filter {
 class MapFilter : public Filter {
  public:
   explicit MapFilter(const std::initializer_list<Substitution> &mappings);
-  bool new_value(std::string &value) override;
+  optional<std::string> new_value(std::string value) override;
 
  protected:
   FixedVector<Substitution> mappings_;

esphome/components/text_sensor/text_sensor.cpp

@@ -15,8 +15,14 @@ void log_text_sensor(const char *tag, const char *prefix, const char *type, Text
   }
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
-  LOG_ENTITY_DEVICE_CLASS(tag, prefix, *obj);
-  LOG_ENTITY_ICON(tag, prefix, *obj);
+
+  if (!obj->get_device_class_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
+  }
+
+  if (!obj->get_icon_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
+  }
 }
 
 void TextSensor::publish_state(const std::string &state) { this->publish_state(state.data(), state.size()); }

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/valve/valve.h

@@ -20,7 +20,9 @@ const extern float VALVE_CLOSED;
     if (traits_.get_is_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \
     } \
-    LOG_ENTITY_DEVICE_CLASS(TAG, prefix, *(obj)); \
+    if (!(obj)->get_device_class_ref().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class_ref().c_str()); \
+    } \
   }
 
 class Valve;

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/__init__.py

@@ -31,7 +31,6 @@ from esphome.const import (
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
     PLATFORM_LN882X,
-    PLATFORM_RP2040,
     PLATFORM_RTL87XX,
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
@@ -214,7 +213,6 @@ CONFIG_SCHEMA = cv.All(
             PLATFORM_ESP8266,
             PLATFORM_BK72XX,
             PLATFORM_LN882X,
-            PLATFORM_RP2040,
             PLATFORM_RTL87XX,
         ]
     ),

esphome/components/web_server/ota/ota_web_server.cpp

@@ -32,15 +32,8 @@ class OTARequestHandler : public AsyncWebHandler {
   void handleUpload(AsyncWebServerRequest *request, const PlatformString &filename, size_t index, uint8_t *data,
                     size_t len, bool final) override;
   bool canHandle(AsyncWebServerRequest *request) const override {
-    if (request->method() != HTTP_POST)
-      return false;
-      // Check if this is an OTA update request
-#ifdef USE_ESP32
-    char url_buf[AsyncWebServerRequest::URL_BUF_SIZE];
-    bool is_ota_request = request->url_to(url_buf) == "/update";
-#else
-    bool is_ota_request = request->url() == ESPHOME_F("/update");
-#endif
+    // Check if this is an OTA update request
+    bool is_ota_request = request->url() == "/update" && request->method() == HTTP_POST;
 
 #if defined(USE_WEBSERVER_OTA_DISABLED) && defined(USE_CAPTIVE_PORTAL)
     // IMPORTANT: USE_WEBSERVER_OTA_DISABLED only disables OTA for the web_server component

esphome/components/web_server/web_server.cpp

@@ -531,19 +531,7 @@ static void set_json_id(JsonObject &root, EntityBase *obj, const char *prefix, J
   memcpy(p, name.c_str(), name_len);
   p[name_len] = '\0';
 
-  // name_id: new format {prefix}/{device?}/{name} - frontend should prefer this
-  // Remove in 2026.8.0 when id switches to new format permanently
-  root[ESPHOME_F("name_id")] = id_buf;
-
-  // id: old format {prefix}-{object_id} for backward compatibility
-  // Will switch to new format in 2026.8.0
-  char legacy_buf[ESPHOME_DOMAIN_MAX_LEN + 1 + OBJECT_ID_MAX_LEN];
-  char *lp = legacy_buf;
-  memcpy(lp, prefix, prefix_len);
-  lp += prefix_len;
-  *lp++ = '-';
-  obj->write_object_id_to(lp, sizeof(legacy_buf) - (lp - legacy_buf));
-  root[ESPHOME_F("id")] = legacy_buf;
+  root[ESPHOME_F("id")] = id_buf;
 
   if (start_config == DETAIL_ALL) {
     root[ESPHOME_F("domain")] = prefix;
@@ -2187,12 +2175,7 @@ std::string WebServer::update_json_(update::UpdateEntity *obj, JsonDetail start_
 #endif
 
 bool WebServer::canHandle(AsyncWebServerRequest *request) const {
-#ifdef USE_ESP32
-  char url_buf[AsyncWebServerRequest::URL_BUF_SIZE];
-  StringRef url = request->url_to(url_buf);
-#else
   const auto &url = request->url();
-#endif
   const auto method = request->method();
 
   // Static URL checks - use ESPHOME_F to keep strings in flash on ESP8266
@@ -2328,35 +2311,30 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   return false;
 }
 void WebServer::handleRequest(AsyncWebServerRequest *request) {
-#ifdef USE_ESP32
-  char url_buf[AsyncWebServerRequest::URL_BUF_SIZE];
-  StringRef url = request->url_to(url_buf);
-#else
   const auto &url = request->url();
-#endif
 
   // Handle static routes first
-  if (url == ESPHOME_F("/")) {
+  if (url == "/") {
     this->handle_index_request(request);
     return;
   }
 
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
-  if (url == ESPHOME_F("/events")) {
+  if (url == "/events") {
     this->events_.add_new_client(this, request);
     return;
   }
 #endif
 
 #ifdef USE_WEBSERVER_CSS_INCLUDE
-  if (url == ESPHOME_F("/0.css")) {
+  if (url == "/0.css") {
     this->handle_css_request(request);
     return;
   }
 #endif
 
 #ifdef USE_WEBSERVER_JS_INCLUDE
-  if (url == ESPHOME_F("/0.js")) {
+  if (url == "/0.js") {
     this->handle_js_request(request);
     return;
   }

esphome/components/web_server_base/__init__.py

@@ -47,10 +47,5 @@ async def to_code(config):
             cg.add_library("ESP8266WiFi", None)
         if CORE.is_libretiny:
             CORE.add_platformio_option("lib_ignore", ["ESPAsyncTCP", "RPAsyncTCP"])
-        if CORE.is_rp2040:
-            # Ignore bundled AsyncTCP libraries - we use RPAsyncTCP from async_tcp component
-            CORE.add_platformio_option(
-                "lib_ignore", ["ESPAsyncTCP", "AsyncTCP", "AsyncTCP_RP2040W"]
-            )
         # 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/web_server_idf/web_server_idf.cpp

@@ -246,16 +246,21 @@ optional<std::string> AsyncWebServerRequest::get_header(const char *name) const
   return request_get_header(*this, name);
 }
 
-StringRef AsyncWebServerRequest::url_to(std::span<char, URL_BUF_SIZE> buffer) const {
-  const char *uri = this->req_->uri;
-  const char *query_start = strchr(uri, '?');
-  size_t uri_len = query_start ? static_cast<size_t>(query_start - uri) : strlen(uri);
-  size_t copy_len = std::min(uri_len, URL_BUF_SIZE - 1);
-  memcpy(buffer.data(), uri, copy_len);
-  buffer[copy_len] = '\0';
+std::string AsyncWebServerRequest::url() const {
+  auto *query_start = strchr(this->req_->uri, '?');
+  std::string result;
+  if (query_start == nullptr) {
+    result = this->req_->uri;
+  } else {
+    result = std::string(this->req_->uri, query_start - this->req_->uri);
+  }
   // Decode URL-encoded characters in-place (e.g., %20 -> space)
-  size_t decoded_len = url_decode(buffer.data());
-  return StringRef(buffer.data(), decoded_len);
+  // This matches AsyncWebServer behavior on Arduino
+  if (!result.empty()) {
+    size_t new_len = url_decode(&result[0]);
+    result.resize(new_len);
+  }
+  return result;
 }
 
 std::string AsyncWebServerRequest::host() const { return this->get_header("Host").value(); }

esphome/components/web_server_idf/web_server_idf.h

@@ -3,14 +3,12 @@
 
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/string_ref.h"
 #include <esp_http_server.h>
 
 #include <atomic>
 #include <functional>
 #include <list>
 #include <map>
-#include <span>
 #include <string>
 #include <utility>
 #include <vector>
@@ -112,15 +110,7 @@ class AsyncWebServerRequest {
   ~AsyncWebServerRequest();
 
   http_method method() const { return static_cast<http_method>(this->req_->method); }
-  static constexpr size_t URL_BUF_SIZE = CONFIG_HTTPD_MAX_URI_LEN + 1;  ///< Buffer size for url_to()
-  /// Write URL (without query string) to buffer, returns StringRef pointing to buffer.
-  /// URL is decoded (e.g., %20 -> space).
-  StringRef url_to(std::span<char, URL_BUF_SIZE> buffer) const;
-  /// Get URL as std::string. Prefer url_to() to avoid heap allocation.
-  std::string url() const {
-    char buffer[URL_BUF_SIZE];
-    return std::string(this->url_to(buffer));
-  }
+  std::string url() const;
   std::string host() const;
   // NOLINTNEXTLINE(readability-identifier-naming)
   size_t contentLength() const { return this->req_->content_len; }
@@ -316,10 +306,7 @@ class AsyncEventSource : public AsyncWebHandler {
 
   // NOLINTNEXTLINE(readability-identifier-naming)
   bool canHandle(AsyncWebServerRequest *request) const override {
-    if (request->method() != HTTP_GET)
-      return false;
-    char url_buf[AsyncWebServerRequest::URL_BUF_SIZE];
-    return request->url_to(url_buf) == this->url_;
+    return request->method() == HTTP_GET && request->url() == this->url_;
   }
   // NOLINTNEXTLINE(readability-identifier-naming)
   void handleRequest(AsyncWebServerRequest *request) override;

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 "";
@@ -152,22 +110,4 @@ void EntityBase_UnitOfMeasurement::set_unit_of_measurement(const char *unit_of_m
   this->unit_of_measurement_ = unit_of_measurement;
 }
 
-void log_entity_icon(const char *tag, const char *prefix, const EntityBase &obj) {
-  if (!obj.get_icon_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj.get_icon_ref().c_str());
-  }
-}
-
-void log_entity_device_class(const char *tag, const char *prefix, const EntityBase_DeviceClass &obj) {
-  if (!obj.get_device_class_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj.get_device_class_ref().c_str());
-  }
-}
-
-void log_entity_unit_of_measurement(const char *tag, const char *prefix, const EntityBase_UnitOfMeasurement &obj) {
-  if (!obj.get_unit_of_measurement_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Unit of Measurement: '%s'", prefix, obj.get_unit_of_measurement_ref().c_str());
-  }
-}
-
 }  // namespace esphome

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_;
@@ -230,16 +212,6 @@ class EntityBase_UnitOfMeasurement {  // NOLINT(readability-identifier-naming)
   const char *unit_of_measurement_{nullptr};  ///< Unit of measurement override
 };
 
-/// Log entity icon if set (for use in dump_config)
-#define LOG_ENTITY_ICON(tag, prefix, obj) log_entity_icon(tag, prefix, obj)
-void log_entity_icon(const char *tag, const char *prefix, const EntityBase &obj);
-/// Log entity device class if set (for use in dump_config)
-#define LOG_ENTITY_DEVICE_CLASS(tag, prefix, obj) log_entity_device_class(tag, prefix, obj)
-void log_entity_device_class(const char *tag, const char *prefix, const EntityBase_DeviceClass &obj);
-/// Log entity unit of measurement if set (for use in dump_config)
-#define LOG_ENTITY_UNIT_OF_MEASUREMENT(tag, prefix, obj) log_entity_unit_of_measurement(tag, prefix, obj)
-void log_entity_unit_of_measurement(const char *tag, const char *prefix, const EntityBase_UnitOfMeasurement &obj);
-
 /**
  * An entity that has a state.
  * @tparam T The type of the state

esphome/core/helpers.h

@@ -148,25 +148,6 @@ template<typename T, size_t N> class StaticVector {
   size_t count_{0};
 
  public:
-  // Default constructor
-  StaticVector() = default;
-
-  // Iterator range constructor
-  template<typename InputIt> StaticVector(InputIt first, InputIt last) {
-    while (first != last && count_ < N) {
-      data_[count_++] = *first++;
-    }
-  }
-
-  // Initializer list constructor
-  StaticVector(std::initializer_list<T> init) {
-    for (const auto &val : init) {
-      if (count_ >= N)
-        break;
-      data_[count_++] = val;
-    }
-  }
-
   // Minimal vector-compatible interface - only what we actually use
   void push_back(const T &value) {
     if (count_ < N) {
@@ -174,17 +155,6 @@ template<typename T, size_t N> class StaticVector {
     }
   }
 
-  // Clear all elements
-  void clear() { count_ = 0; }
-
-  // Assign from iterator range
-  template<typename InputIt> void assign(InputIt first, InputIt last) {
-    count_ = 0;
-    while (first != last && count_ < N) {
-      data_[count_++] = *first++;
-    }
-  }
-
   // Return reference to next element and increment count (with bounds checking)
   T &emplace_next() {
     if (count_ >= N) {
@@ -216,10 +186,6 @@ template<typename T, size_t N> class StaticVector {
   reverse_iterator rend() { return reverse_iterator(begin()); }
   const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
   const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
-
-  // Conversion to std::span for compatibility with span-based APIs
-  operator std::span<T>() { return std::span<T>(data_.data(), count_); }
-  operator std::span<const T>() const { return std::span<const T>(data_.data(), count_); }
 };
 
 /// Fixed-capacity vector - allocates once at runtime, never reallocates
@@ -689,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