From 705d548435d648eda29e044c43d538034df7f98d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 18 Mar 2026 09:39:26 -1000
Subject: [PATCH 01/60] Bump aioesphomeapi from 44.5.2 to 44.6.0 (#14927)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index da95dd5a13..f8f60f1932 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -12,7 +12,7 @@ platformio==6.1.19
 esptool==5.2.0
 click==8.3.1
 esphome-dashboard==20260210.0
-aioesphomeapi==44.5.2
+aioesphomeapi==44.6.0
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.19.1 # dashboard_import

From 99d968f80a5057ec653e9fba8a55f2aa9ec5ee14 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Wed, 18 Mar 2026 14:06:41 -1000
Subject: [PATCH 02/60] [http_request] Prevent double update task launch
 (#14910)

---
 .../components/http_request/update/http_request_update.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/esphome/components/http_request/update/http_request_update.cpp b/esphome/components/http_request/update/http_request_update.cpp
index a15dc61675..1c52a28105 100644
--- a/esphome/components/http_request/update/http_request_update.cpp
+++ b/esphome/components/http_request/update/http_request_update.cpp
@@ -74,6 +74,10 @@ void HttpRequestUpdate::update() {
   }
   this->cancel_interval(INITIAL_CHECK_INTERVAL_ID);
 #ifdef USE_ESP32
+  if (this->update_task_handle_ != nullptr) {
+    ESP_LOGW(TAG, "Update check already in progress");
+    return;
+  }
   xTaskCreate(HttpRequestUpdate::update_task, "update_task", 8192, (void *) this, 1, &this->update_task_handle_);
 #else
   this->update_task(this);
@@ -204,6 +208,9 @@ defer:
   // both success and error paths to avoid multiple std::function instantiations.
   // Lambda captures only 2 pointers (8 bytes) — fits in std::function SBO on supported toolchains.
   this_update->defer([this_update, result]() {
+#ifdef USE_ESP32
+    this_update->update_task_handle_ = nullptr;
+#endif
     if (result->error_str != nullptr) {
       this_update->status_set_error(result->error_str);
       delete result;

From 8af0991590f27f870d3544e0b2bd6798380d9564 Mon Sep 17 00:00:00 2001
From: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Date: Wed, 18 Mar 2026 20:10:42 -0400
Subject: [PATCH 03/60] [ble_client] Fix RSSI sensor reporting same value for
 all clients (#14939)

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 esphome/components/ble_client/sensor/ble_rssi_sensor.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp b/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp
index dc032a7a98..715298e592 100644
--- a/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp
+++ b/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp
@@ -47,6 +47,8 @@ void BLEClientRSSISensor::gap_event_handler(esp_gap_ble_cb_event_t event, esp_bl
   switch (event) {
     // server response on RSSI request:
     case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT:
+      if (!this->parent()->check_addr(param->read_rssi_cmpl.remote_addr))
+        return;
       if (param->read_rssi_cmpl.status == ESP_BT_STATUS_SUCCESS) {
         int8_t rssi = param->read_rssi_cmpl.rssi;
         ESP_LOGI(TAG, "ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT RSSI: %d", rssi);

From 729d3d4bc22718d0116f3dd1d47eea7d12362ef9 Mon Sep 17 00:00:00 2001
From: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Date: Wed, 18 Mar 2026 21:23:47 -0400
Subject: [PATCH 04/60] [openthread] Guard InstanceLock against uninitialized
 semaphore (#14940)

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 esphome/components/openthread/openthread.h    |  4 ++++
 .../components/openthread/openthread_esp.cpp  | 22 ++++++++++++++++++-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/esphome/components/openthread/openthread.h b/esphome/components/openthread/openthread.h
index 75d8fe11fd..bd10774fcf 100644
--- a/esphome/components/openthread/openthread.h
+++ b/esphome/components/openthread/openthread.h
@@ -11,6 +11,7 @@
 #include <openthread/instance.h>
 #include <openthread/thread.h>
 
+#include <atomic>
 #include <optional>
 #include <vector>
 
@@ -28,6 +29,8 @@ class OpenThreadComponent : public Component {
   float get_setup_priority() const override { return setup_priority::WIFI; }
 
   bool is_connected() const { return this->connected_; }
+  /// Returns true once esp_openthread_init() has completed and the OT lock is usable.
+  bool is_lock_initialized() const { return this->lock_initialized_; }
   network::IPAddresses get_ip_addresses();
   std::optional<otIp6Address> get_omr_address();
   void ot_main();
@@ -51,6 +54,7 @@ class OpenThreadComponent : public Component {
   uint32_t poll_period_{0};
 #endif
   std::optional<int8_t> output_power_{};
+  std::atomic<bool> lock_initialized_{false};
   bool teardown_started_{false};
   bool teardown_complete_{false};
   bool connected_{false};
diff --git a/esphome/components/openthread/openthread_esp.cpp b/esphome/components/openthread/openthread_esp.cpp
index 9cc9223b52..27712bd86a 100644
--- a/esphome/components/openthread/openthread_esp.cpp
+++ b/esphome/components/openthread/openthread_esp.cpp
@@ -8,6 +8,7 @@
 #include "esp_openthread_lock.h"
 
 #include "esp_task_wdt.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
@@ -81,6 +82,9 @@ void OpenThreadComponent::ot_main() {
   // Initialize the OpenThread stack
   // otLoggingSetLevel(OT_LOG_LEVEL_DEBG);
   ESP_ERROR_CHECK(esp_openthread_init(&config));
+  // Mark lock as initialized so InstanceLock callers know it's safe to acquire.
+  // Must be set after esp_openthread_init() which creates the internal semaphore.
+  this->lock_initialized_ = true;
   // Fetch OT instance once to avoid repeated call into OT stack
   otInstance *instance = esp_openthread_get_instance();
 
@@ -180,7 +184,8 @@ void OpenThreadComponent::ot_main() {
 
   esp_openthread_launch_mainloop();
 
-  // Clean up
+  // Clean up - reset lock flag before deinit destroys the semaphore
+  this->lock_initialized_ = false;
   esp_openthread_deinit();
   esp_openthread_netif_glue_deinit();
   esp_netif_destroy(openthread_netif);
@@ -210,6 +215,9 @@ network::IPAddresses OpenThreadComponent::get_ip_addresses() {
 otInstance *OpenThreadComponent::get_openthread_instance_() { return esp_openthread_get_instance(); }
 
 std::optional<InstanceLock> InstanceLock::try_acquire(int delay) {
+  if (!global_openthread_component->is_lock_initialized()) {
+    return {};
+  }
   if (esp_openthread_lock_acquire(delay)) {
     return InstanceLock();
   }
@@ -217,6 +225,18 @@ std::optional<InstanceLock> InstanceLock::try_acquire(int delay) {
 }
 
 InstanceLock InstanceLock::acquire() {
+  // Wait for the lock to be created by ot_main() before attempting to acquire it.
+  // esp_openthread_lock_acquire() will assert-crash if called before esp_openthread_init().
+  constexpr uint32_t lock_init_timeout_ms = 10000;
+  uint32_t start = millis();
+  while (!global_openthread_component->is_lock_initialized()) {
+    if (millis() - start > lock_init_timeout_ms) {
+      ESP_LOGE(TAG, "OpenThread lock not initialized after %" PRIu32 "ms, aborting", lock_init_timeout_ms);
+      abort();
+    }
+    delay(10);
+    esp_task_wdt_reset();
+  }
   while (!esp_openthread_lock_acquire(100)) {
     esp_task_wdt_reset();
   }

From 5cbe9362569e17447c661e2cf5ad9a528b2a7ef7 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 18 Mar 2026 23:43:50 -1000
Subject: [PATCH 05/60] Bump aioesphomeapi from 44.6.0 to 44.6.1 (#14954)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index f8f60f1932..9e2f4efe3e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -12,7 +12,7 @@ platformio==6.1.19
 esptool==5.2.0
 click==8.3.1
 esphome-dashboard==20260210.0
-aioesphomeapi==44.6.0
+aioesphomeapi==44.6.1
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.19.1 # dashboard_import

From 08cab43548fb7546690cdabd07cda2f7a0c0e74a Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 19 Mar 2026 08:44:35 -1000
Subject: [PATCH 06/60] [time] Fix lookup of top-level IANA timezone keys like
 UTC and GMT (#14952)

---
 esphome/components/time/__init__.py | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/esphome/components/time/__init__.py b/esphome/components/time/__init__.py
index 7ffa408db9..9821046a73 100644
--- a/esphome/components/time/__init__.py
+++ b/esphome/components/time/__init__.py
@@ -59,15 +59,20 @@ _DST_RULE_TYPE_MAP = {
 
 def _load_tzdata(iana_key: str) -> bytes | None:
     # From https://tzdata.readthedocs.io/en/latest/#examples
+    if not iana_key:
+        return None
     try:
         package_loc, resource = iana_key.rsplit("/", 1)
     except ValueError:
-        return None
-    package = "tzdata.zoneinfo." + package_loc.replace("/", ".")
+        # Handle top-level timezone entries like "UTC", "GMT"
+        package = "tzdata.zoneinfo"
+        resource = iana_key
+    else:
+        package = "tzdata.zoneinfo." + package_loc.replace("/", ".")
 
     try:
         return (resources.files(package) / resource).read_bytes()
-    except (FileNotFoundError, ModuleNotFoundError):
+    except (FileNotFoundError, ModuleNotFoundError, IsADirectoryError):
         return None
 
 

From daf3502e1527dde0a919f39898ca9cc61849dc8b Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 19 Mar 2026 14:11:49 -1000
Subject: [PATCH 07/60] [logger] Fix ESP8266 crash with VERY_VERBOSE log level
 (#14980)

---
 esphome/components/logger/__init__.py | 29 ++++++++++++++++++---------
 esphome/core/config.py                |  4 +++-
 esphome/coroutine.py                  | 10 +++++++--
 esphome/writer.py                     |  3 +++
 4 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/esphome/components/logger/__init__.py b/esphome/components/logger/__init__.py
index 675f9a2ca4..a5601e6a8f 100644
--- a/esphome/components/logger/__init__.py
+++ b/esphome/components/logger/__init__.py
@@ -56,6 +56,7 @@ from esphome.const import (
     PlatformFramework,
 )
 from esphome.core import CORE, CoroPriority, Lambda, coroutine_with_priority
+from esphome.types import ConfigType
 
 CODEOWNERS = ["@esphome/core"]
 logger_ns = cg.esphome_ns.namespace("logger")
@@ -323,12 +324,11 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(CoroPriority.DIAGNOSTICS)
-async def to_code(config):
-    baud_rate = config[CONF_BAUD_RATE]
+@coroutine_with_priority(CoroPriority.EARLY_INIT)
+async def to_code(config: ConfigType) -> None:
+    baud_rate: int = config[CONF_BAUD_RATE]
     level = config[CONF_LEVEL]
     CORE.data.setdefault(CONF_LOGGER, {})[CONF_LEVEL] = level
-    initial_level = LOG_LEVELS[config.get(CONF_INITIAL_LEVEL, level)]
     tx_buffer_size = config[CONF_TX_BUFFER_SIZE]
     cg.add_define("ESPHOME_LOGGER_TX_BUFFER_SIZE", tx_buffer_size)
     log = cg.new_Pvariable(
@@ -347,10 +347,23 @@ async def to_code(config):
                 HARDWARE_UART_TO_UART_SELECTION[config[CONF_HARDWARE_UART]]
             )
         )
-    # pre_setup() must be called before init_log_buffer() because
-    # init_log_buffer() calls disable_loop() which may log at VV level,
-    # and global_logger must be set before any logging occurs.
+    # pre_setup() sets global_logger and must run before any other code
+    # that may call ESP_LOG* (e.g. setup_preferences contains ESP_LOGVV).
     cg.add(log.pre_setup())
+    initial_level = LOG_LEVELS[config.get(CONF_INITIAL_LEVEL, level)]
+    cg.add(log.set_log_level(initial_level))
+
+    # Schedule the rest of logger setup at DIAGNOSTICS priority, after
+    # Application is constructed (CORE priority) but before most components.
+    CORE.add_job(_late_logger_init, config)
+
+
+@coroutine_with_priority(CoroPriority.DIAGNOSTICS)
+async def _late_logger_init(config: ConfigType) -> None:
+    """Finish logger setup after Application is constructed."""
+    log = await cg.get_variable(config[CONF_ID])
+    level = config[CONF_LEVEL]
+    baud_rate: int = config[CONF_BAUD_RATE]
     if CORE.is_esp32 or CORE.is_libretiny or CORE.is_nrf52:
         task_log_buffer_size = config[CONF_TASK_LOG_BUFFER_SIZE]
         if task_log_buffer_size > 0:
@@ -363,8 +376,6 @@ async def to_code(config):
         cg.add_define("USE_ESPHOME_TASK_LOG_BUFFER")
         cg.add(log.init_log_buffer(64))  # Fixed 64 slots for host
 
-    cg.add(log.set_log_level(initial_level))
-
     # Enable runtime tag levels if logs are configured or explicitly enabled
     logs_config = config[CONF_LOGS]
     if logs_config or config[CONF_RUNTIME_TAG_LEVELS]:
diff --git a/esphome/core/config.py b/esphome/core/config.py
index d4a839cb79..bdfb1cc417 100644
--- a/esphome/core/config.py
+++ b/esphome/core/config.py
@@ -587,7 +587,9 @@ async def _add_looping_components() -> None:
 
 @coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config: ConfigType) -> None:
-    cg.add_global(cg.global_ns.namespace("esphome").using)
+    # using namespace esphome is hardcoded in writer.py to guarantee it
+    # precedes all variable declarations regardless of coroutine priority.
+
     # These can be used by user lambdas, put them to default scope
     cg.add_global(cg.RawExpression("using std::isnan"))
     cg.add_global(cg.RawExpression("using std::min"))
diff --git a/esphome/coroutine.py b/esphome/coroutine.py
index f5d512e510..3ce94cc979 100644
--- a/esphome/coroutine.py
+++ b/esphome/coroutine.py
@@ -63,7 +63,13 @@ class CoroPriority(enum.IntEnum):
     resolution during code generation.
     """
 
-    # Platform initialization - must run first
+    # Early init - runs before platform init and before Application exists.
+    # Currently used only to connect logging so ESP_LOG* calls work
+    # immediately in all subsequent phases.
+    # Examples: logger (1100)
+    EARLY_INIT = 1100
+
+    # Platform initialization
     # Examples: esp32, esp8266, rp2040
     PLATFORM = 1000
 
@@ -83,7 +89,7 @@ class CoroPriority(enum.IntEnum):
     CORE = 100
 
     # Diagnostic and debugging systems
-    # Examples: logger (90)
+    # Examples: debug component (90)
     DIAGNOSTICS = 90
 
     # Status and monitoring systems
diff --git a/esphome/writer.py b/esphome/writer.py
index fd4c811fb3..69a35d00e3 100644
--- a/esphome/writer.py
+++ b/esphome/writer.py
@@ -381,7 +381,10 @@ def write_cpp(code_s):
         code_format = CPP_BASE_FORMAT
 
     copy_src_tree()
+    # using namespace esphome must precede all variable declarations since
+    # codegen types assume this namespace is in scope (esphome_ns = global_ns).
     global_s = '#include "esphome.h"\n'
+    global_s += "using namespace esphome;\n"
     global_s += CORE.cpp_global_section
 
     full_file = f"{code_format[0] + CPP_INCLUDE_BEGIN}\n{global_s}{CPP_INCLUDE_END}"

From 08187a01b1de0897a9e42f7bf9b4eb5e577c5275 Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Fri, 20 Mar 2026 11:39:10 +1000
Subject: [PATCH 08/60] [sdl] Fix get_width()/height() when rotation used
 (#14950)

---
 esphome/components/sdl/sdl_esphome.cpp | 37 ++++++++++++++++++++++++++
 esphome/components/sdl/sdl_esphome.h   |  4 +--
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/esphome/components/sdl/sdl_esphome.cpp b/esphome/components/sdl/sdl_esphome.cpp
index f235e4e68c..74ca2ce39a 100644
--- a/esphome/components/sdl/sdl_esphome.cpp
+++ b/esphome/components/sdl/sdl_esphome.cpp
@@ -5,6 +5,30 @@
 namespace esphome {
 namespace sdl {
 
+int Sdl::get_width() {
+  switch (this->rotation_) {
+    case display::DISPLAY_ROTATION_90_DEGREES:
+    case display::DISPLAY_ROTATION_270_DEGREES:
+      return this->get_height_internal();
+    case display::DISPLAY_ROTATION_0_DEGREES:
+    case display::DISPLAY_ROTATION_180_DEGREES:
+    default:
+      return this->get_width_internal();
+  }
+}
+
+int Sdl::get_height() {
+  switch (this->rotation_) {
+    case display::DISPLAY_ROTATION_0_DEGREES:
+    case display::DISPLAY_ROTATION_180_DEGREES:
+      return this->get_height_internal();
+    case display::DISPLAY_ROTATION_90_DEGREES:
+    case display::DISPLAY_ROTATION_270_DEGREES:
+    default:
+      return this->get_width_internal();
+  }
+}
+
 void Sdl::setup() {
   SDL_Init(SDL_INIT_VIDEO);
   this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
@@ -49,6 +73,19 @@ void Sdl::draw_pixel_at(int x, int y, Color color) {
   if (!this->get_clipping().inside(x, y))
     return;
 
+  if (this->rotation_ == display::DISPLAY_ROTATION_180_DEGREES) {
+    x = this->width_ - x - 1;
+    y = this->height_ - y - 1;
+  } else if (this->rotation_ == display::DISPLAY_ROTATION_90_DEGREES) {
+    auto tmp = x;
+    x = this->width_ - y - 1;
+    y = tmp;
+  } else if (this->rotation_ == display::DISPLAY_ROTATION_270_DEGREES) {
+    auto tmp = y;
+    y = this->height_ - x - 1;
+    x = tmp;
+  }
+
   SDL_Rect rect{x, y, 1, 1};
   auto data = (display::ColorUtil::color_to_565(color, display::COLOR_ORDER_RGB));
   SDL_UpdateTexture(this->texture_, &rect, &data, 2);
diff --git a/esphome/components/sdl/sdl_esphome.h b/esphome/components/sdl/sdl_esphome.h
index bf5fde1428..968434a04f 100644
--- a/esphome/components/sdl/sdl_esphome.h
+++ b/esphome/components/sdl/sdl_esphome.h
@@ -33,8 +33,8 @@ class Sdl : public display::Display {
     this->pos_x_ = pos_x;
     this->pos_y_ = pos_y;
   }
-  int get_width() override { return this->width_; }
-  int get_height() override { return this->height_; }
+  int get_width() override;
+  int get_height() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
   void dump_config() override { LOG_DISPLAY("", "SDL", this); }
   void add_key_listener(int32_t keycode, std::function<void(bool)> &&callback) {

From d4f7cb984cdc2510a676f65bc5ca7f70f5eba903 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 19 Mar 2026 20:56:51 -1000
Subject: [PATCH 09/60] [uart] Fix UART0 default pin IOMUX loopback on ESP32
 (#14978)

---
 .../uart/uart_component_esp_idf.cpp           | 33 ++++++++++++++++---
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/esphome/components/uart/uart_component_esp_idf.cpp b/esphome/components/uart/uart_component_esp_idf.cpp
index 47ddf1a38d..8168e49805 100644
--- a/esphome/components/uart/uart_component_esp_idf.cpp
+++ b/esphome/components/uart/uart_component_esp_idf.cpp
@@ -7,7 +7,9 @@
 #include "esphome/core/log.h"
 #include "esphome/core/gpio.h"
 #include "driver/gpio.h"
+#include "esp_private/gpio.h"
 #include "soc/gpio_num.h"
+#include "soc/uart_pins.h"
 
 #ifdef USE_UART_WAKE_LOOP_ON_RX
 #include "esphome/core/application.h"
@@ -21,6 +23,20 @@ namespace esphome::uart {
 
 static const char *const TAG = "uart.idf";
 
+/// Check if a pin number matches one of the default UART0 GPIO pins.
+/// These pins may have residual IOMUX state from the ROM bootloader that
+/// must be cleared before UART reconfiguration.
+///
+/// ESP-IDF's uart_set_pin() has an asymmetry: when routing TX via GPIO matrix,
+/// it calls gpio_func_sel(PIN_FUNC_GPIO) to clear IOMUX, but for RX it only
+/// calls gpio_input_enable() which does NOT clear the IOMUX function select.
+/// If a default UART0 TX pin (configured as TX via IOMUX during boot) is later
+/// reassigned as RX via GPIO matrix, the old IOMUX TX function remains active,
+/// causing TX data to loop back into RX on the same pin.
+static constexpr bool is_default_uart0_pin(int8_t pin_num) {
+  return pin_num == U0TXD_GPIO_NUM || pin_num == U0RXD_GPIO_NUM;
+}
+
 uart_config_t IDFUARTComponent::get_config_() {
   uart_parity_t parity = UART_PARITY_DISABLE;
   if (this->parity_ == UART_CONFIG_PARITY_EVEN) {
@@ -131,6 +147,19 @@ void IDFUARTComponent::load_settings(bool dump_config) {
     return;
   }
 
+  int8_t tx = this->tx_pin_ != nullptr ? this->tx_pin_->get_pin() : -1;
+  int8_t rx = this->rx_pin_ != nullptr ? this->rx_pin_->get_pin() : -1;
+  int8_t flow_control = this->flow_control_pin_ != nullptr ? this->flow_control_pin_->get_pin() : -1;
+
+  // Clear residual IOMUX function on UART0 default pins left by the ROM bootloader.
+  // See is_default_uart0_pin() comment for details on the ESP-IDF uart_set_pin() bug.
+  if (is_default_uart0_pin(tx)) {
+    gpio_func_sel(static_cast<gpio_num_t>(tx), PIN_FUNC_GPIO);
+  }
+  if (is_default_uart0_pin(rx)) {
+    gpio_func_sel(static_cast<gpio_num_t>(rx), PIN_FUNC_GPIO);
+  }
+
   auto setup_pin_if_needed = [](InternalGPIOPin *pin) {
     if (!pin) {
       return;
@@ -146,10 +175,6 @@ void IDFUARTComponent::load_settings(bool dump_config) {
     setup_pin_if_needed(this->tx_pin_);
   }
 
-  int8_t tx = this->tx_pin_ != nullptr ? this->tx_pin_->get_pin() : -1;
-  int8_t rx = this->rx_pin_ != nullptr ? this->rx_pin_->get_pin() : -1;
-  int8_t flow_control = this->flow_control_pin_ != nullptr ? this->flow_control_pin_->get_pin() : -1;
-
   uint32_t invert = 0;
   if (this->tx_pin_ != nullptr && this->tx_pin_->is_inverted()) {
     invert |= UART_SIGNAL_TXD_INV;

From 0297260a5773d38a2a65ade6cf35333f9aff09f4 Mon Sep 17 00:00:00 2001
From: Keith Roehrenbeck <kroehre@users.noreply.github.com>
Date: Fri, 20 Mar 2026 15:11:57 -0500
Subject: [PATCH 10/60] [ld2450] Fix zone target counts including untracked
 ghost targets (#15026)

---
 esphome/components/ld2450/ld2450.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/esphome/components/ld2450/ld2450.cpp b/esphome/components/ld2450/ld2450.cpp
index f9701cbdf6..1946831ca8 100644
--- a/esphome/components/ld2450/ld2450.cpp
+++ b/esphome/components/ld2450/ld2450.cpp
@@ -534,10 +534,11 @@ void LD2450Component::handle_periodic_data_() {
     }
 #endif
 
-    // Store target info for zone target count
-    this->target_info_[index].x = tx;
-    this->target_info_[index].y = ty;
-    this->target_info_[index].is_moving = is_moving;
+    // Store target info for zone target count. Zero out untracked targets (td==0)
+    // so stale coordinates don't produce ghost counts in count_targets_in_zone_().
+    this->target_info_[index].x = (td > 0) ? tx : 0;
+    this->target_info_[index].y = (td > 0) ? ty : 0;
+    this->target_info_[index].is_moving = (td > 0) && is_moving;
 
   }  // End loop thru targets
 

From 28e8250b69e7ae9662e166a6bcf69085f5e3d48f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 20 Mar 2026 11:10:40 -1000
Subject: [PATCH 11/60] Bump aioesphomeapi from 44.6.1 to 44.6.2 (#15027)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index 9e2f4efe3e..10e56c3b49 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -12,7 +12,7 @@ platformio==6.1.19
 esptool==5.2.0
 click==8.3.1
 esphome-dashboard==20260210.0
-aioesphomeapi==44.6.1
+aioesphomeapi==44.6.2
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.19.1 # dashboard_import

From 12eed0d38407c77c70179b2dcbb9c969c06a79c3 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Fri, 20 Mar 2026 12:06:23 -1000
Subject: [PATCH 12/60] [api] Increase noise handshake timeout to 60s for slow
 WiFi environments (#15022)

---
 esphome/components/api/api_connection.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index dea3ba5460..d97ef97762 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -64,7 +64,11 @@ static constexpr uint32_t KEEPALIVE_DISCONNECT_TIMEOUT = (KEEPALIVE_TIMEOUT_MS *
 // A stalled handshake from a buggy client or network glitch holds a connection
 // slot, which can prevent legitimate clients from reconnecting. Also hardens
 // against the less likely case of intentional connection slot exhaustion.
-static constexpr uint32_t HANDSHAKE_TIMEOUT_MS = 15000;
+//
+// 60s is intentionally high: on ESP8266 with power_save_mode: LIGHT and weak
+// WiFi (-70 dBm+), TCP retransmissions push real-world handshake times to
+// 28-30s. See https://github.com/esphome/esphome/issues/14999
+static constexpr uint32_t HANDSHAKE_TIMEOUT_MS = 60000;
 
 static constexpr auto ESPHOME_VERSION_REF = StringRef::from_lit(ESPHOME_VERSION);
 

From 3fe84eadef1e5448f6bae7c5f88ac74154e9f6d1 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Fri, 20 Mar 2026 12:13:49 -1000
Subject: [PATCH 13/60] [wifi] Fix ESP8266 power_save_mode mapping (LIGHT/HIGH
 were swapped) (#15029)

---
 esphome/components/wifi/wifi_component_esp8266.cpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/esphome/components/wifi/wifi_component_esp8266.cpp b/esphome/components/wifi/wifi_component_esp8266.cpp
index 0bf7934878..5514f1c6be 100644
--- a/esphome/components/wifi/wifi_component_esp8266.cpp
+++ b/esphome/components/wifi/wifi_component_esp8266.cpp
@@ -92,13 +92,23 @@ bool WiFiComponent::wifi_mode_(optional<bool> sta, optional<bool> ap) {
   return ret;
 }
 bool WiFiComponent::wifi_apply_power_save_() {
+  // ESP8266 sleep types have confusing names — LIGHT_SLEEP_T is the MORE aggressive mode.
+  // SDK enum: NONE_SLEEP_T=0, LIGHT_SLEEP_T=1, MODEM_SLEEP_T=2
+  //   https://github.com/esp8266/Arduino/blob/3.1.2/tools/sdk/include/user_interface.h#L447-L451
+  // Arduino ESP32 compat confirms: WIFI_PS_MIN_MODEM=MODEM_SLEEP, WIFI_PS_MAX_MODEM=LIGHT_SLEEP
+  //   https://github.com/esp8266/Arduino/blob/3.1.2/libraries/ESP8266WiFi/src/ESP8266WiFiType.h#L53-L55
   sleep_type_t power_save;
   switch (this->power_save_) {
     case WIFI_POWER_SAVE_LIGHT:
-      power_save = LIGHT_SLEEP_T;
+      // MODEM_SLEEP_T: only the WiFi modem sleeps between DTIM beacons, CPU stays active.
+      // Matches ESP32's WIFI_PS_MIN_MODEM.
+      power_save = MODEM_SLEEP_T;
       break;
     case WIFI_POWER_SAVE_HIGH:
-      power_save = MODEM_SLEEP_T;
+      // LIGHT_SLEEP_T: both WiFi modem AND CPU suspend between DTIM beacons.
+      // Most aggressive — prevents TCP processing during sleep. Matches ESP32's WIFI_PS_MAX_MODEM.
+      // See https://github.com/esphome/esphome/issues/14999
+      power_save = LIGHT_SLEEP_T;
       break;
     case WIFI_POWER_SAVE_NONE:
     default:

From 0bf6e1e8398a3793d5b28b50de20459ec183c132 Mon Sep 17 00:00:00 2001
From: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Date: Fri, 20 Mar 2026 19:53:02 -0400
Subject: [PATCH 14/60] [esp32_touch] Fix initial state never published when
 sensor untouched (#15032)

---
 esphome/components/esp32_touch/esp32_touch.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/esphome/components/esp32_touch/esp32_touch.cpp b/esphome/components/esp32_touch/esp32_touch.cpp
index e7124ce92f..0d331b29d6 100644
--- a/esphome/components/esp32_touch/esp32_touch.cpp
+++ b/esphome/components/esp32_touch/esp32_touch.cpp
@@ -360,11 +360,16 @@ void ESP32TouchComponent::loop() {
   }
 
   // Publish initial OFF state for sensors that haven't received events yet
+  bool all_initial_published = true;
   for (auto *child : this->children_) {
     this->publish_initial_state_if_needed_(child, now);
+    if (!child->initial_state_published_) {
+      all_initial_published = false;
+    }
   }
 
-  if (!this->setup_mode_) {
+  // Only disable loop once all initial states are published
+  if (!this->setup_mode_ && all_initial_published) {
     this->disable_loop();
   }
 }

From 98b4e1ea15c8badd9e701e225dc59a5de12a3824 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Fri, 20 Mar 2026 13:57:51 -1000
Subject: [PATCH 15/60] [web_server] Increase httpd task stack size to prevent
 stack overflow (#14997)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 esphome/components/web_server_idf/web_server_idf.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/esphome/components/web_server_idf/web_server_idf.cpp b/esphome/components/web_server_idf/web_server_idf.cpp
index f18570965b..45ee711b1e 100644
--- a/esphome/components/web_server_idf/web_server_idf.cpp
+++ b/esphome/components/web_server_idf/web_server_idf.cpp
@@ -120,7 +120,10 @@ void AsyncWebServer::begin() {
   if (this->server_) {
     this->end();
   }
+  // Default httpd stack is defined by ESP-IDF. Increase to accommodate SerializationBuffer's
+  // 640-byte stack buffer used by web_server JSON request handlers.
   httpd_config_t config = HTTPD_DEFAULT_CONFIG();
+  config.stack_size = config.stack_size + 256;
   config.server_port = this->port_;
   config.uri_match_fn = [](const char * /*unused*/, const char * /*unused*/, size_t /*unused*/) { return true; };
   // Always enable LRU purging to handle socket exhaustion gracefully.

From 06cc5a29a733c1078ead4bdf7f6dfc46c5bbe57d Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Fri, 20 Mar 2026 13:58:02 -1000
Subject: [PATCH 16/60] [core] Add copy() method to StringRef for std::string
 compatibility (#15028)

---
 esphome/core/string_ref.h | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/esphome/core/string_ref.h b/esphome/core/string_ref.h
index 6047202753..34ba2474b2 100644
--- a/esphome/core/string_ref.h
+++ b/esphome/core/string_ref.h
@@ -76,6 +76,15 @@ class StringRef {
   constexpr bool empty() const { return len_ == 0; }
   constexpr const_reference operator[](size_type pos) const { return *(base_ + pos); }
 
+  /// Copy characters to destination buffer (std::string::copy-like, but returns 0 instead of throwing on out-of-range)
+  size_type copy(char *dest, size_type count, size_type pos = 0) const {
+    if (pos >= len_)
+      return 0;
+    size_type actual = (count > len_ - pos) ? len_ - pos : count;
+    std::memcpy(dest, base_ + pos, actual);
+    return actual;
+  }
+
   std::string str() const { return std::string(base_, len_); }
   const uint8_t *byte() const { return reinterpret_cast<const uint8_t *>(base_); }
 

From 42da28185456200efbf886da2e4cdad2e670bc97 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Fri, 20 Mar 2026 13:58:14 -1000
Subject: [PATCH 17/60] [time] Fix timezone_offset() and
 recalc_timestamp_local() always returning UTC (#14996)

---
 esphome/core/time.cpp | 16 ++++++----------
 esphome/core/time.h   |  2 ++
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/esphome/core/time.cpp b/esphome/core/time.cpp
index 73ba0a9be7..6add82e7d1 100644
--- a/esphome/core/time.cpp
+++ b/esphome/core/time.cpp
@@ -283,19 +283,15 @@ void ESPTime::recalc_timestamp_local() {
   bool dst_valid = time::is_in_dst(utc_if_dst, tz);
   bool std_valid = !time::is_in_dst(utc_if_std, tz);
 
-  if (dst_valid && std_valid) {
-    // Ambiguous time (repeated hour during fall-back) - prefer standard time
-    this->timestamp = utc_if_std;
-  } else if (dst_valid) {
+  if (dst_valid && !std_valid) {
     // Only DST interpretation is valid
     this->timestamp = utc_if_dst;
-  } else if (std_valid) {
-    // Only standard interpretation is valid
-    this->timestamp = utc_if_std;
   } else {
-    // Invalid time (skipped hour during spring-forward)
-    // libc normalizes forward: 02:30 CST -> 08:30 UTC -> 03:30 CDT
-    // Using std offset achieves this since the UTC result falls during DST
+    // All other cases use standard offset:
+    // - Both valid (ambiguous fall-back repeated hour): prefer standard time
+    // - Only standard valid: straightforward
+    // - Neither valid (spring-forward skipped hour): std offset normalizes
+    //   forward to match libc mktime(), e.g. 02:30 CST -> 03:30 CDT
     this->timestamp = utc_if_std;
   }
 #else
diff --git a/esphome/core/time.h b/esphome/core/time.h
index 874f0db4b4..1716c51ffd 100644
--- a/esphome/core/time.h
+++ b/esphome/core/time.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "esphome/core/defines.h"
+
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>

From 77264de3f6a17c2f5f0f1bb62bee0f75febab28f Mon Sep 17 00:00:00 2001
From: Samuel Sieb <samuel-github@sieb.net>
Date: Sat, 21 Mar 2026 11:13:08 -0700
Subject: [PATCH 18/60] [analog_threshhold] add missing header (#15058)

---
 .../components/analog_threshold/analog_threshold_binary_sensor.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/esphome/components/analog_threshold/analog_threshold_binary_sensor.h b/esphome/components/analog_threshold/analog_threshold_binary_sensor.h
index 9ea95d8570..dd70768105 100644
--- a/esphome/components/analog_threshold/analog_threshold_binary_sensor.h
+++ b/esphome/components/analog_threshold/analog_threshold_binary_sensor.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #include "esphome/components/sensor/sensor.h"

From 2352c732de79b76bb277dc6e1927f73105de12ba Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sat, 21 Mar 2026 15:33:42 -1000
Subject: [PATCH 19/60] [mqtt] Rate-limit component resends to prevent task WDT
 on reconnect (#15061)

---
 esphome/components/mqtt/mqtt_client.cpp  | 17 ++++++++++++++---
 esphome/components/mqtt/mqtt_component.h |  3 +++
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/esphome/components/mqtt/mqtt_client.cpp b/esphome/components/mqtt/mqtt_client.cpp
index 38daf8f8f6..ab665e2579 100644
--- a/esphome/components/mqtt/mqtt_client.cpp
+++ b/esphome/components/mqtt/mqtt_client.cpp
@@ -28,6 +28,10 @@ namespace esphome::mqtt {
 
 static const char *const TAG = "mqtt";
 
+// Maximum number of MQTT component resends per loop iteration.
+// Limits work to avoid triggering the task watchdog on reconnect.
+static constexpr uint8_t MAX_RESENDS_PER_LOOP = 8;
+
 // Disconnect reason strings indexed by MQTTClientDisconnectReason enum (0-8)
 PROGMEM_STRING_TABLE(MQTTDisconnectReasonStrings, "TCP disconnected", "Unacceptable Protocol Version",
                      "Identifier Rejected", "Server Unavailable", "Malformed Credentials", "Not Authorized",
@@ -396,9 +400,16 @@ void MQTTClientComponent::loop() {
         this->resubscribe_subscriptions_();
 
         // Process pending resends for all MQTT components centrally
-        // This is more efficient than each component polling in its own loop
-        for (MQTTComponent *component : this->children_) {
-          component->process_resend();
+        // Limit work per loop iteration to avoid triggering task WDT on reconnect
+        {
+          uint8_t resend_count = 0;
+          for (MQTTComponent *component : this->children_) {
+            if (component->is_resend_pending()) {
+              component->process_resend();
+              if (++resend_count >= MAX_RESENDS_PER_LOOP)
+                break;
+            }
+          }
         }
       }
       break;
diff --git a/esphome/components/mqtt/mqtt_component.h b/esphome/components/mqtt/mqtt_component.h
index 2403ef64ea..7983e04870 100644
--- a/esphome/components/mqtt/mqtt_component.h
+++ b/esphome/components/mqtt/mqtt_component.h
@@ -147,6 +147,9 @@ class MQTTComponent : public Component {
   /// Internal method for the MQTT client base to schedule a resend of the state on reconnect.
   void schedule_resend_state();
 
+  /// Check if a resend is pending (called by MQTTClientComponent to rate-limit work)
+  bool is_resend_pending() const { return this->resend_state_; }
+
   /// Process pending resend if needed (called by MQTTClientComponent)
   void process_resend();
 

From b5880df93c6830003b46d106181a26516a4fac07 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 10:14:52 -1000
Subject: [PATCH 20/60] [light] Fix constant_brightness broken by gamma LUT
 refactor (#15048)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 esphome/components/light/light_color_values.h |  10 +
 esphome/components/light/light_state.cpp      |  47 ++++-
 .../fixtures/light_constant_brightness.yaml   |  57 ++++++
 .../test_light_constant_brightness.py         | 188 ++++++++++++++++++
 4 files changed, 296 insertions(+), 6 deletions(-)
 create mode 100644 tests/integration/fixtures/light_constant_brightness.yaml
 create mode 100644 tests/integration/test_light_constant_brightness.py

diff --git a/esphome/components/light/light_color_values.h b/esphome/components/light/light_color_values.h
index 3a9ca8c8c2..a2c2dbca46 100644
--- a/esphome/components/light/light_color_values.h
+++ b/esphome/components/light/light_color_values.h
@@ -154,6 +154,16 @@ class LightColorValues {
   }
 
   /// Convert these light color values to an CWWW representation with the given parameters.
+  ///
+  /// Note on gamma and constant_brightness: This method operates on the raw/internal channel
+  /// values stored in this object. For cold_white_ and warm_white_ specifically, these
+  /// may already be gamma-uncorrected when derived from a color_temperature value.
+  /// For constant_brightness=false, additional gamma for the output can be applied after
+  /// this method since gamma commutes with simple multiplication. For constant_brightness=true,
+  /// the caller (LightState::current_values_as_cwww) must apply gamma to the individual
+  /// channel values BEFORE the balancing formula, because the nonlinear max/sum ratio does
+  /// not commute with gamma. See LightState::current_values_as_cwww() for the correct
+  /// implementation.
   void as_cwww(float *cold_white, float *warm_white, bool constant_brightness = false) const {
     if (this->color_mode_ & ColorCapability::COLD_WARM_WHITE) {
       const float cw_level = this->cold_white_;
diff --git a/esphome/components/light/light_state.cpp b/esphome/components/light/light_state.cpp
index 161092532a..1b736d84f6 100644
--- a/esphome/components/light/light_state.cpp
+++ b/esphome/components/light/light_state.cpp
@@ -223,12 +223,11 @@ void LightState::current_values_as_rgbw(float *red, float *green, float *blue, f
 }
 void LightState::current_values_as_rgbww(float *red, float *green, float *blue, float *cold_white, float *warm_white,
                                          bool constant_brightness) {
-  this->current_values.as_rgbww(red, green, blue, cold_white, warm_white, constant_brightness);
+  this->current_values.as_rgb(red, green, blue);
   *red = this->gamma_correct_lut(*red);
   *green = this->gamma_correct_lut(*green);
   *blue = this->gamma_correct_lut(*blue);
-  *cold_white = this->gamma_correct_lut(*cold_white);
-  *warm_white = this->gamma_correct_lut(*warm_white);
+  this->current_values_as_cwww(cold_white, warm_white, constant_brightness);
 }
 void LightState::current_values_as_rgbct(float *red, float *green, float *blue, float *color_temperature,
                                          float *white_brightness) {
@@ -241,9 +240,45 @@ void LightState::current_values_as_rgbct(float *red, float *green, float *blue,
   *white_brightness = this->gamma_correct_lut(*white_brightness);
 }
 void LightState::current_values_as_cwww(float *cold_white, float *warm_white, bool constant_brightness) {
-  this->current_values.as_cwww(cold_white, warm_white, constant_brightness);
-  *cold_white = this->gamma_correct_lut(*cold_white);
-  *warm_white = this->gamma_correct_lut(*warm_white);
+  if (!constant_brightness) {
+    // Without constant_brightness, gamma commutes with simple multiplication:
+    //   gamma(white_level * cw) = gamma(white_level) * gamma(cw)
+    // (since gamma(a*b) = (a*b)^g = a^g * b^g = gamma(a) * gamma(b))
+    // so applying gamma after is mathematically equivalent and simpler.
+    this->current_values.as_cwww(cold_white, warm_white, false);
+    *cold_white = this->gamma_correct_lut(*cold_white);
+    *warm_white = this->gamma_correct_lut(*warm_white);
+    return;
+  }
+
+  // For constant_brightness mode, gamma MUST be applied to the individual
+  // channel values BEFORE the balancing formula (max/sum ratio), not after.
+  //
+  // Why: The cold_white_ and warm_white_ values stored in LightColorValues
+  // are gamma-uncorrected (see transform_parameters_() which applies
+  // gamma_uncorrect to the linear CW/WW fractions derived from color
+  // temperature). Applying gamma_correct here recovers the original linear
+  // fractions, which the constant_brightness formula then uses to distribute
+  // power evenly. The max/sum formula ensures cold+warm PWM output sums to
+  // a constant, keeping total power (and perceived brightness) the same
+  // across all color temperatures.
+  //
+  // Applying gamma AFTER the formula would be incorrect because gamma is
+  // nonlinear: gamma(a/b) != gamma(a)/gamma(b), so the carefully balanced
+  // ratio would be distorted, causing a severe brightness dip at mid-range
+  // color temperatures.
+  const auto &v = this->current_values;
+  if (!(v.get_color_mode() & ColorCapability::COLD_WARM_WHITE)) {
+    *cold_white = *warm_white = 0;
+    return;
+  }
+
+  const float cw_level = this->gamma_correct_lut(v.get_cold_white());
+  const float ww_level = this->gamma_correct_lut(v.get_warm_white());
+  const float white_level = this->gamma_correct_lut(v.get_state() * v.get_brightness());
+  const float sum = cw_level > 0 || ww_level > 0 ? cw_level + ww_level : 1;  // Don't divide by zero.
+  *cold_white = white_level * std::max(cw_level, ww_level) * cw_level / sum;
+  *warm_white = white_level * std::max(cw_level, ww_level) * ww_level / sum;
 }
 void LightState::current_values_as_ct(float *color_temperature, float *white_brightness) {
   auto traits = this->get_traits();
diff --git a/tests/integration/fixtures/light_constant_brightness.yaml b/tests/integration/fixtures/light_constant_brightness.yaml
new file mode 100644
index 0000000000..4357a16d58
--- /dev/null
+++ b/tests/integration/fixtures/light_constant_brightness.yaml
@@ -0,0 +1,57 @@
+esphome:
+  name: light-cb-test
+host:
+api:  # Port will be automatically injected
+logger:
+  level: DEBUG
+
+output:
+  - platform: template
+    id: cb_cold_white_output
+    type: float
+    write_action:
+      - logger.log:
+          format: "CB_CW_OUTPUT:%.6f"
+          args: [state]
+  - platform: template
+    id: cb_warm_white_output
+    type: float
+    write_action:
+      - logger.log:
+          format: "CB_WW_OUTPUT:%.6f"
+          args: [state]
+  - platform: template
+    id: ncb_cold_white_output
+    type: float
+    write_action:
+      - logger.log:
+          format: "NCB_CW_OUTPUT:%.6f"
+          args: [state]
+  - platform: template
+    id: ncb_warm_white_output
+    type: float
+    write_action:
+      - logger.log:
+          format: "NCB_WW_OUTPUT:%.6f"
+          args: [state]
+
+light:
+  - platform: cwww
+    name: "Test CB Light"
+    id: test_cb_light
+    cold_white: cb_cold_white_output
+    warm_white: cb_warm_white_output
+    cold_white_color_temperature: 6536 K
+    warm_white_color_temperature: 2000 K
+    constant_brightness: true
+    gamma_correct: 2.8
+
+  - platform: cwww
+    name: "Test NCB Light"
+    id: test_ncb_light
+    cold_white: ncb_cold_white_output
+    warm_white: ncb_warm_white_output
+    cold_white_color_temperature: 6536 K
+    warm_white_color_temperature: 2000 K
+    constant_brightness: false
+    gamma_correct: 2.8
diff --git a/tests/integration/test_light_constant_brightness.py b/tests/integration/test_light_constant_brightness.py
new file mode 100644
index 0000000000..622dc0e065
--- /dev/null
+++ b/tests/integration/test_light_constant_brightness.py
@@ -0,0 +1,188 @@
+"""Integration test for constant_brightness with gamma correction.
+
+Tests both constant_brightness: true and false cwww lights with gamma
+correction in a single compilation to verify:
+- constant_brightness: true maintains constant total CW+WW power output
+- constant_brightness: false correctly varies total power across color temps
+
+This is a regression test for https://github.com/esphome/esphome/issues/15040
+where the gamma LUT refactor (#14123) broke constant_brightness by applying
+gamma after the balancing formula instead of before it.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+from typing import Any
+
+from aioesphomeapi import EntityState, LightInfo, LightState
+import pytest
+
+from .state_utils import InitialStateHelper
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_light_constant_brightness(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test constant_brightness true and false behavior with gamma correction."""
+    # Track output values for both lights from log lines
+    cb_cw_pattern = re.compile(r"(?<!N)CB_CW_OUTPUT:([\d.]+)")
+    cb_ww_pattern = re.compile(r"(?<!N)CB_WW_OUTPUT:([\d.]+)")
+    ncb_cw_pattern = re.compile(r"NCB_CW_OUTPUT:([\d.]+)")
+    ncb_ww_pattern = re.compile(r"NCB_WW_OUTPUT:([\d.]+)")
+
+    latest: dict[str, float] = {
+        "cb_cw": 0.0,
+        "cb_ww": 0.0,
+        "ncb_cw": 0.0,
+        "ncb_ww": 0.0,
+    }
+
+    def on_log_line(line: str) -> None:
+        for pattern, key in [
+            (cb_cw_pattern, "cb_cw"),
+            (cb_ww_pattern, "cb_ww"),
+            (ncb_cw_pattern, "ncb_cw"),
+            (ncb_ww_pattern, "ncb_ww"),
+        ]:
+            match = pattern.search(line)
+            if match:
+                latest[key] = float(match.group(1))
+
+    loop = asyncio.get_running_loop()
+
+    async with (
+        run_compiled(yaml_config, line_callback=on_log_line),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+        lights = [e for e in entities if isinstance(e, LightInfo)]
+        cb_light = next(e for e in lights if e.object_id.endswith("cb_light"))
+        ncb_light = next(e for e in lights if e.object_id.endswith("ncb_light"))
+
+        # Use InitialStateHelper to wait for initial state broadcast
+        initial_state_helper = InitialStateHelper(entities)
+
+        # Track state changes per light key
+        state_futures: dict[int, asyncio.Future[EntityState]] = {}
+
+        def on_state(state: EntityState) -> None:
+            if isinstance(state, LightState) and state.key in state_futures:
+                future = state_futures[state.key]
+                if not future.done():
+                    future.set_result(state)
+
+        client.subscribe_states(initial_state_helper.on_state_wrapper(on_state))
+
+        try:
+            await initial_state_helper.wait_for_initial_states()
+        except TimeoutError:
+            pytest.fail("Timeout waiting for initial states")
+
+        async def send_and_wait(
+            light_key: int, timeout: float = 5.0, **kwargs: Any
+        ) -> LightState:
+            """Send a light command and wait for the state response."""
+            state_futures[light_key] = loop.create_future()
+            client.light_command(key=light_key, **kwargs)
+            try:
+                return await asyncio.wait_for(state_futures[light_key], timeout=timeout)
+            except TimeoutError:
+                pytest.fail(f"Timeout waiting for light state after command: {kwargs}")
+
+        # --- Test constant_brightness: true ---
+
+        # Turn on CB light at full brightness
+        await send_and_wait(
+            cb_light.key,
+            state=True,
+            brightness=1.0,
+            color_temperature=153.0,
+            transition_length=0,
+        )
+
+        test_mireds = [
+            153.0,  # Pure cold white
+            200.0,  # Mostly cold
+            280.0,  # Mixed
+            326.5,  # Midpoint
+            400.0,  # Mostly warm
+            500.0,  # Pure warm white
+        ]
+
+        cb_totals: list[tuple[float, float, float]] = []
+        for mireds in test_mireds:
+            await send_and_wait(
+                cb_light.key, color_temperature=mireds, transition_length=0
+            )
+            cb_totals.append((mireds, latest["cb_cw"], latest["cb_ww"]))
+
+        # All totals should be approximately equal (constant brightness)
+        reference_total = next((cw + ww for _, cw, ww in cb_totals if cw + ww > 0), 0)
+        assert reference_total > 0, (
+            f"Reference total power is zero, CB light outputs not working. "
+            f"Values: {cb_totals}"
+        )
+
+        for mireds, cw, ww in cb_totals:
+            total = cw + ww
+            assert total == pytest.approx(reference_total, rel=0.05), (
+                f"constant_brightness: Total power at {mireds} mireds "
+                f"({total:.4f}) differs from reference ({reference_total:.4f}) "
+                f"by more than 5%. CW={cw:.4f}, WW={ww:.4f}. "
+                f"All values: {cb_totals}"
+            )
+
+        # --- Test constant_brightness: false ---
+
+        # Turn on NCB light at full brightness
+        await send_and_wait(
+            ncb_light.key,
+            state=True,
+            brightness=1.0,
+            color_temperature=153.0,
+            transition_length=0,
+        )
+
+        ncb_totals: list[tuple[float, float, float]] = []
+        for mireds in test_mireds:
+            await send_and_wait(
+                ncb_light.key, color_temperature=mireds, transition_length=0
+            )
+            ncb_totals.append((mireds, latest["ncb_cw"], latest["ncb_ww"]))
+
+        extreme_cw = ncb_totals[0]  # 153 mireds - pure cold
+        extreme_ww = ncb_totals[-1]  # 500 mireds - pure warm
+        midpoint = ncb_totals[3]  # 326.5 mireds - midpoint
+
+        # At pure cold white, WW should be ~0
+        assert extreme_cw[2] == pytest.approx(0.0, abs=0.01), (
+            f"Pure cold white should have WW~0, got WW={extreme_cw[2]:.4f}"
+        )
+        # At pure warm white, CW should be ~0
+        assert extreme_ww[1] == pytest.approx(0.0, abs=0.01), (
+            f"Pure warm white should have CW~0, got CW={extreme_ww[1]:.4f}"
+        )
+
+        # At midpoint, both channels should be non-zero
+        assert midpoint[1] > 0.05, f"Midpoint CW should be >0.05, got {midpoint[1]:.4f}"
+        assert midpoint[2] > 0.05, f"Midpoint WW should be >0.05, got {midpoint[2]:.4f}"
+
+        # Total power at midpoint should be higher than at the extremes
+        midpoint_total = midpoint[1] + midpoint[2]
+        extreme_cw_total = extreme_cw[1] + extreme_cw[2]
+        extreme_ww_total = extreme_ww[1] + extreme_ww[2]
+
+        assert midpoint_total > extreme_cw_total, (
+            f"Midpoint total ({midpoint_total:.4f}) should be > pure CW total "
+            f"({extreme_cw_total:.4f}). All values: {ncb_totals}"
+        )
+        assert midpoint_total > extreme_ww_total, (
+            f"Midpoint total ({midpoint_total:.4f}) should be > pure WW total "
+            f"({extreme_ww_total:.4f}). All values: {ncb_totals}"
+        )

From 9abc112f7606870ae868954f07547769e0040b83 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 10:16:46 -1000
Subject: [PATCH 21/60] [sht4x] Fix heater causing measurement jitter (#15030)

---
 esphome/components/sht4x/sht4x.cpp | 40 ++++++++++++++++--------------
 esphome/components/sht4x/sht4x.h   |  3 ++-
 tests/components/sht4x/common.yaml |  4 +++
 3 files changed, 28 insertions(+), 19 deletions(-)

diff --git a/esphome/components/sht4x/sht4x.cpp b/esphome/components/sht4x/sht4x.cpp
index 42be326202..43c2436a56 100644
--- a/esphome/components/sht4x/sht4x.cpp
+++ b/esphome/components/sht4x/sht4x.cpp
@@ -9,14 +9,12 @@ static const char *const TAG = "sht4x";
 static const uint8_t MEASURECOMMANDS[] = {0xFD, 0xF6, 0xE0};
 static const uint8_t SERIAL_NUMBER_COMMAND = 0x89;
 
-void SHT4XComponent::start_heater_() {
-  uint8_t cmd[] = {this->heater_command_};
-
-  ESP_LOGD(TAG, "Heater turning on");
-  if (this->write(cmd, 1) != i2c::ERROR_OK) {
-    this->status_set_error(LOG_STR("Failed to turn on heater"));
-  }
-}
+// Conversion constants from SHT4x datasheet
+static constexpr float TEMPERATURE_OFFSET = -45.0f;
+static constexpr float TEMPERATURE_SPAN = 175.0f;
+static constexpr float HUMIDITY_OFFSET = -6.0f;
+static constexpr float HUMIDITY_SPAN = 125.0f;
+static constexpr float RAW_MAX = 65535.0f;
 
 void SHT4XComponent::read_serial_number_() {
   uint16_t buffer[2];
@@ -39,8 +37,8 @@ void SHT4XComponent::setup() {
   this->read_serial_number_();
 
   if (std::isfinite(this->duty_cycle_) && this->duty_cycle_ > 0.0f) {
-    uint32_t heater_interval = static_cast<uint32_t>(static_cast<uint16_t>(this->heater_time_) / this->duty_cycle_);
-    ESP_LOGD(TAG, "Heater interval: %" PRIu32, heater_interval);
+    this->heater_interval_ = static_cast<uint32_t>(static_cast<uint16_t>(this->heater_time_) / this->duty_cycle_);
+    ESP_LOGD(TAG, "Heater interval: %" PRIu32, this->heater_interval_);
 
     if (this->heater_power_ == SHT4X_HEATERPOWER_HIGH) {
       if (this->heater_time_ == SHT4X_HEATERTIME_LONG) {
@@ -62,8 +60,6 @@ void SHT4XComponent::setup() {
       }
     }
     ESP_LOGD(TAG, "Heater command: %x", this->heater_command_);
-
-    this->set_interval(heater_interval, std::bind(&SHT4XComponent::start_heater_, this));
   }
 }
 
@@ -106,19 +102,27 @@ void SHT4XComponent::update() {
     // Evaluate and publish measurements
     if (this->temp_sensor_ != nullptr) {
       // Temp is contained in the first result word
-      float sensor_value_temp = buffer[0];
-      float temp = -45 + 175 * sensor_value_temp / 65535;
-
+      float temp = TEMPERATURE_OFFSET + TEMPERATURE_SPAN * static_cast<float>(buffer[0]) / RAW_MAX;
       this->temp_sensor_->publish_state(temp);
     }
 
     if (this->humidity_sensor_ != nullptr) {
       // Relative humidity is in the second result word
-      float sensor_value_rh = buffer[1];
-      float rh = -6 + 125 * sensor_value_rh / 65535;
-
+      float rh = HUMIDITY_OFFSET + HUMIDITY_SPAN * static_cast<float>(buffer[1]) / RAW_MAX;
       this->humidity_sensor_->publish_state(rh);
     }
+
+    // Fire heater after measurement to maximize cooldown time before the next reading.
+    // The heater command produces a measurement that we don't need (datasheet 4.9).
+    if (this->heater_interval_ > 0) {
+      uint32_t now = millis();
+      if (now - this->last_heater_millis_ >= this->heater_interval_) {
+        ESP_LOGD(TAG, "Heater turning on");
+        if (this->write_command(this->heater_command_)) {
+          this->last_heater_millis_ = now;
+        }
+      }
+    }
   });
 }
 
diff --git a/esphome/components/sht4x/sht4x.h b/esphome/components/sht4x/sht4x.h
index aec0f3d7f8..51f473fe3f 100644
--- a/esphome/components/sht4x/sht4x.h
+++ b/esphome/components/sht4x/sht4x.h
@@ -35,9 +35,10 @@ class SHT4XComponent : public PollingComponent, public sensirion_common::Sensiri
   SHT4XHEATERTIME heater_time_;
   float duty_cycle_;
 
-  void start_heater_();
   void read_serial_number_();
   uint8_t heater_command_;
+  uint32_t heater_interval_{0};
+  uint32_t last_heater_millis_{0};
   uint32_t serial_number_;
 
   sensor::Sensor *temp_sensor_{nullptr};
diff --git a/tests/components/sht4x/common.yaml b/tests/components/sht4x/common.yaml
index 50d5ad8ca4..bec192d6db 100644
--- a/tests/components/sht4x/common.yaml
+++ b/tests/components/sht4x/common.yaml
@@ -6,4 +6,8 @@ sensor:
     humidity:
       name: SHT4X Humidity
     address: 0x44
+    precision: High
+    heater_max_duty: 0.02
+    heater_power: High
+    heater_time: Long
     update_interval: 15s

From 67ab2e143c8c549bcdbc1fe0f05c2e488075b661 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 10:17:59 -1000
Subject: [PATCH 22/60] [uart] Fix RTL87xx compilation failure due to SUCCESS
 macro collision (#15054)

---
 esphome/components/uart/uart_component.h    |  5 +++++
 tests/components/uart/test.rtl87xx-ard.yaml | 14 ++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 tests/components/uart/test.rtl87xx-ard.yaml

diff --git a/esphome/components/uart/uart_component.h b/esphome/components/uart/uart_component.h
index 853de719fe..7b61501d44 100644
--- a/esphome/components/uart/uart_component.h
+++ b/esphome/components/uart/uart_component.h
@@ -30,12 +30,17 @@ enum UARTDirection {
 const LogString *parity_to_str(UARTParityOptions parity);
 
 /// Result of a flush() call.
+// Some vendor SDKs (e.g., Realtek) define SUCCESS as a macro.
+// Save and restore around the enum to avoid collisions with our scoped enum value.
+#pragma push_macro("SUCCESS")
+#undef SUCCESS
 enum class FlushResult {
   SUCCESS,          ///< Confirmed: all bytes left the TX FIFO.
   TIMEOUT,          ///< Confirmed: timed out before TX completed.
   FAILED,           ///< Confirmed: driver or hardware error.
   ASSUMED_SUCCESS,  ///< Platform cannot report result; success is assumed.
 };
+#pragma pop_macro("SUCCESS")
 
 class UARTComponent {
  public:
diff --git a/tests/components/uart/test.rtl87xx-ard.yaml b/tests/components/uart/test.rtl87xx-ard.yaml
new file mode 100644
index 0000000000..414bf1f14d
--- /dev/null
+++ b/tests/components/uart/test.rtl87xx-ard.yaml
@@ -0,0 +1,14 @@
+uart:
+  - id: uart_id
+    tx_pin: PA23
+    rx_pin: PA18
+    baud_rate: 9600
+    data_bits: 8
+    parity: NONE
+    stop_bits: 1
+
+switch:
+  - platform: uart
+    name: "UART Switch"
+    uart_id: uart_id
+    data: [0x01, 0x02, 0x03]

From de3292c828c2116713dafddf86e725e6f2b69fc4 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 10:19:28 -1000
Subject: [PATCH 23/60] [light] Fix gamma LUT quantizing small brightness to
 zero (#15060)

---
 esphome/components/light/__init__.py          |  28 +++--
 tests/unit_tests/components/light/__init__.py |   0
 .../components/light/test_gamma_table.py      | 117 ++++++++++++++++++
 3 files changed, 138 insertions(+), 7 deletions(-)
 create mode 100644 tests/unit_tests/components/light/__init__.py
 create mode 100644 tests/unit_tests/components/light/test_gamma_table.py

diff --git a/esphome/components/light/__init__.py b/esphome/components/light/__init__.py
index 4403281116..64452e4282 100644
--- a/esphome/components/light/__init__.py
+++ b/esphome/components/light/__init__.py
@@ -81,18 +81,32 @@ def _get_data() -> LightData:
     return CORE.data[DOMAIN]
 
 
+def generate_gamma_table(gamma_correct: float) -> list[HexInt]:
+    """Generate a 256-entry uint16 gamma lookup table.
+
+    For gamma > 0, non-zero indices are clamped to a minimum of 1 to preserve
+    the invariant that non-zero input always produces non-zero output. Without
+    this, small brightness values (e.g. 1%) get quantized to exactly 0.0,
+    which breaks zero_means_zero logic in FloatOutput.
+    """
+    if gamma_correct > 0:
+        return [
+            HexInt(
+                max(1, min(65535, int(round((i / 255.0) ** gamma_correct * 65535))))
+                if i > 0
+                else HexInt(0)
+            )
+            for i in range(256)
+        ]
+    return [HexInt(int(round(i / 255.0 * 65535))) for i in range(256)]
+
+
 def _get_or_create_gamma_table(gamma_correct):
     data = _get_data()
     if gamma_correct in data.gamma_tables:
         return data.gamma_tables[gamma_correct]
 
-    if gamma_correct > 0:
-        forward = [
-            HexInt(min(65535, int(round((i / 255.0) ** gamma_correct * 65535))))
-            for i in range(256)
-        ]
-    else:
-        forward = [HexInt(int(round(i / 255.0 * 65535))) for i in range(256)]
+    forward = generate_gamma_table(gamma_correct)
 
     gamma_str = f"{gamma_correct}".replace(".", "_")
     fwd_id = ID(f"gamma_{gamma_str}_fwd", is_declaration=True, type=cg.uint16)
diff --git a/tests/unit_tests/components/light/__init__.py b/tests/unit_tests/components/light/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/unit_tests/components/light/test_gamma_table.py b/tests/unit_tests/components/light/test_gamma_table.py
new file mode 100644
index 0000000000..a302a355dc
--- /dev/null
+++ b/tests/unit_tests/components/light/test_gamma_table.py
@@ -0,0 +1,117 @@
+"""Tests for the gamma LUT table generation."""
+
+import pytest
+
+from esphome.components.light import generate_gamma_table
+
+
+def _simulate_gamma_correct_lut(table: list[int], value: float) -> float:
+    """Simulate the C++ gamma_correct_lut interpolation from light_state.cpp."""
+    if value <= 0.0:
+        return 0.0
+    if value >= 1.0:
+        return 1.0
+    scaled = value * 255.0
+    idx = int(scaled)
+    if idx >= 255:
+        return table[255] / 65535.0
+    frac = scaled - idx
+    a = float(table[idx])
+    b = float(table[idx + 1])
+    return (a + frac * (b - a)) / 65535.0
+
+
+def test_table_length() -> None:
+    """Table must always have exactly 256 entries."""
+    table = generate_gamma_table(2.8)
+    assert len(table) == 256
+
+
+def test_index_zero_is_zero() -> None:
+    """Index 0 must be 0 so true off remains off."""
+    for gamma in (1.0, 2.0, 2.2, 2.8, 3.0):
+        table = generate_gamma_table(gamma)
+        assert table[0] == 0, f"gamma={gamma}"
+
+
+def test_index_255_is_max() -> None:
+    """Index 255 must be 65535 (full on)."""
+    for gamma in (1.0, 2.0, 2.2, 2.8, 3.0):
+        table = generate_gamma_table(gamma)
+        assert table[255] == 65535, f"gamma={gamma}"
+
+
+@pytest.mark.parametrize("gamma", [1.0, 2.0, 2.2, 2.8, 3.0])
+def test_nonzero_indices_are_nonzero(gamma: float) -> None:
+    """All indices > 0 must produce non-zero values.
+
+    This prevents zero_means_zero breakage: non-zero input must always
+    produce non-zero output so FloatOutput applies min_power scaling.
+    """
+    table = generate_gamma_table(gamma)
+    for i in range(1, 256):
+        assert table[i] >= 1, f"gamma={gamma}, index {i}: got {table[i]}"
+
+
+@pytest.mark.parametrize("gamma", [1.0, 2.0, 2.2, 2.8, 3.0])
+def test_table_monotonically_nondecreasing(gamma: float) -> None:
+    """The gamma table must be monotonically non-decreasing."""
+    table = generate_gamma_table(gamma)
+    for i in range(1, 256):
+        assert table[i] >= table[i - 1], (
+            f"gamma={gamma}: table[{i}]={table[i]} < table[{i - 1}]={table[i - 1]}"
+        )
+
+
+def test_linear_gamma() -> None:
+    """With gamma=0 (linear), table should be evenly spaced."""
+    table = generate_gamma_table(0)
+    assert table[0] == 0
+    assert table[128] == round(128 / 255.0 * 65535)
+    assert table[255] == 65535
+
+
+@pytest.mark.parametrize("brightness", [0.01, 0.005, 0.001, 1 / 255])
+def test_small_brightness_nonzero_after_lut(brightness: float) -> None:
+    """Small but non-zero brightness must produce non-zero output through the LUT.
+
+    Regression test for #15055: with zero_means_zero=true, a gamma-corrected
+    value of exactly 0.0 causes FloatOutput to skip min_power scaling, turning
+    the LED off instead of to minimum brightness.
+    """
+    table = generate_gamma_table(2.8)
+    result = _simulate_gamma_correct_lut(table, brightness)
+    assert result > 0.0, (
+        f"brightness={brightness}: gamma LUT returned 0.0, would break zero_means_zero"
+    )
+
+
+@pytest.mark.parametrize("gamma", [1.0, 2.0, 2.2, 2.8, 3.0])
+def test_small_brightness_nonzero_all_gammas(gamma: float) -> None:
+    """1% brightness must be non-zero for all common gamma values."""
+    table = generate_gamma_table(gamma)
+    result = _simulate_gamma_correct_lut(table, 0.01)
+    assert result > 0.0, f"gamma={gamma}: 1% brightness returned 0.0"
+
+
+def test_lut_zero_returns_zero() -> None:
+    """LUT with input 0.0 must return 0.0."""
+    table = generate_gamma_table(2.8)
+    assert _simulate_gamma_correct_lut(table, 0.0) == 0.0
+
+
+def test_lut_one_returns_one() -> None:
+    """LUT with input 1.0 must return 1.0."""
+    table = generate_gamma_table(2.8)
+    assert _simulate_gamma_correct_lut(table, 1.0) == 1.0
+
+
+def test_lut_output_monotonically_nondecreasing() -> None:
+    """LUT output must be monotonically non-decreasing across the full range."""
+    table = generate_gamma_table(2.8)
+    prev = 0.0
+    for i in range(1001):
+        value = i / 1000.0
+        result = _simulate_gamma_correct_lut(table, value)
+        assert result >= prev, f"value={value}: result {result} < previous {prev}"
+        prev = result

From bbfe324dd6da2ffddcc98fe67d9655bccb854f6d Mon Sep 17 00:00:00 2001
From: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Date: Sun, 22 Mar 2026 16:19:46 -0400
Subject: [PATCH 24/60] [ultrasonic] Fix ISR edge detection with debounce and
 trigger filtering (#15014)

---
 .../ultrasonic/ultrasonic_sensor.cpp          | 29 +++++++++----------
 .../components/ultrasonic/ultrasonic_sensor.h |  3 +-
 2 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/esphome/components/ultrasonic/ultrasonic_sensor.cpp b/esphome/components/ultrasonic/ultrasonic_sensor.cpp
index d3f7e69444..a354b198b4 100644
--- a/esphome/components/ultrasonic/ultrasonic_sensor.cpp
+++ b/esphome/components/ultrasonic/ultrasonic_sensor.cpp
@@ -6,11 +6,17 @@ namespace esphome::ultrasonic {
 
 static const char *const TAG = "ultrasonic.sensor";
 
+static constexpr uint32_t DEBOUNCE_US = 50;          // Ignore edges within 50us of each other (noise filtering)
+static constexpr uint32_t START_DELAY_US = 100;      // Ignore edges within 100us of trigger (filters bleed-through)
 static constexpr uint32_t START_TIMEOUT_US = 40000;  // Maximum time to wait for echo pulse to start
 
 void IRAM_ATTR UltrasonicSensorStore::gpio_intr(UltrasonicSensorStore *arg) {
   uint32_t now = micros();
-  if (arg->echo_pin_isr.digital_read()) {
+  // Ignore edges after measurement complete or too soon after trigger pulse
+  if (arg->echo_end || (now - arg->measurement_start_us) <= START_DELAY_US) {
+    return;
+  }
+  if (!arg->echo_start || (now - arg->echo_start_us) <= DEBOUNCE_US) {
     arg->echo_start_us = now;
     arg->echo_start = true;
   } else {
@@ -21,15 +27,14 @@ void IRAM_ATTR UltrasonicSensorStore::gpio_intr(UltrasonicSensorStore *arg) {
 
 void IRAM_ATTR UltrasonicSensorComponent::send_trigger_pulse_() {
   InterruptLock lock;
-  this->store_.echo_start_us = 0;
-  this->store_.echo_end_us = 0;
   this->store_.echo_start = false;
   this->store_.echo_end = false;
+  this->store_.measurement_start_us = micros();
   this->trigger_pin_isr_.digital_write(true);
   delayMicroseconds(this->pulse_time_us_);
   this->trigger_pin_isr_.digital_write(false);
   this->measurement_pending_ = true;
-  this->measurement_start_us_ = micros();
+  this->measurement_start_us_ = this->store_.measurement_start_us;
 }
 
 void UltrasonicSensorComponent::setup() {
@@ -37,7 +42,6 @@ void UltrasonicSensorComponent::setup() {
   this->trigger_pin_->digital_write(false);
   this->trigger_pin_isr_ = this->trigger_pin_->to_isr();
   this->echo_pin_->setup();
-  this->store_.echo_pin_isr = this->echo_pin_->to_isr();
   this->echo_pin_->attach_interrupt(UltrasonicSensorStore::gpio_intr, &this->store_, gpio::INTERRUPT_ANY_EDGE);
 }
 
@@ -77,17 +81,10 @@ void UltrasonicSensorComponent::loop() {
   }
 
   if (this->store_.echo_end) {
-    float result;
-    if (this->store_.echo_start) {
-      uint32_t pulse_duration = this->store_.echo_end_us - this->store_.echo_start_us;
-      ESP_LOGV(TAG, "pulse start took %" PRIu32 "us, echo took %" PRIu32 "us",
-               this->store_.echo_start_us - this->measurement_start_us_, pulse_duration);
-      result = UltrasonicSensorComponent::us_to_m(pulse_duration);
-      ESP_LOGD(TAG, "'%s' - Got distance: %.3f m", this->name_.c_str(), result);
-    } else {
-      ESP_LOGW(TAG, "'%s' - pulse end before pulse start, does the echo pin need to be inverted?", this->name_.c_str());
-      result = NAN;
-    }
+    uint32_t pulse_duration = this->store_.echo_end_us - this->store_.echo_start_us;
+    ESP_LOGV(TAG, "Echo took %" PRIu32 "us", pulse_duration);
+    float result = UltrasonicSensorComponent::us_to_m(pulse_duration);
+    ESP_LOGD(TAG, "'%s' - Got distance: %.3f m", this->name_.c_str(), result);
     this->publish_state(result);
     this->measurement_pending_ = false;
     return;
diff --git a/esphome/components/ultrasonic/ultrasonic_sensor.h b/esphome/components/ultrasonic/ultrasonic_sensor.h
index 541f7d2b70..7d333a1b24 100644
--- a/esphome/components/ultrasonic/ultrasonic_sensor.h
+++ b/esphome/components/ultrasonic/ultrasonic_sensor.h
@@ -11,8 +11,7 @@ namespace esphome::ultrasonic {
 struct UltrasonicSensorStore {
   static void gpio_intr(UltrasonicSensorStore *arg);
 
-  ISRInternalGPIOPin echo_pin_isr;
-  volatile uint32_t wait_start_us{0};
+  volatile uint32_t measurement_start_us{0};
   volatile uint32_t echo_start_us{0};
   volatile uint32_t echo_end_us{0};
   volatile bool echo_start{false};

From 036be63f7b022023a7ab36f138dbd6e7df1dde84 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 10:20:28 -1000
Subject: [PATCH 25/60] [logger] Fix race condition in task log buffer
 initialization (#15071)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>
---
 esphome/components/logger/__init__.py | 39 ++++++++++++++++-----------
 esphome/components/logger/logger.cpp  | 20 ++++++--------
 esphome/components/logger/logger.h    |  5 ++--
 3 files changed, 35 insertions(+), 29 deletions(-)

diff --git a/esphome/components/logger/__init__.py b/esphome/components/logger/__init__.py
index a5601e6a8f..3da81e12a0 100644
--- a/esphome/components/logger/__init__.py
+++ b/esphome/components/logger/__init__.py
@@ -331,11 +331,27 @@ async def to_code(config: ConfigType) -> None:
     CORE.data.setdefault(CONF_LOGGER, {})[CONF_LEVEL] = level
     tx_buffer_size = config[CONF_TX_BUFFER_SIZE]
     cg.add_define("ESPHOME_LOGGER_TX_BUFFER_SIZE", tx_buffer_size)
-    log = cg.new_Pvariable(
-        config[CONF_ID],
-        baud_rate,
-    )
-    if CORE.is_esp32:
+    # Determine task log buffer size and define USE_ESPHOME_TASK_LOG_BUFFER early
+    # so the constructor can allocate the buffer immediately, preventing a race
+    # where another task logs before the buffer is initialized.
+    task_log_buffer_size = 0
+    if CORE.is_esp32 or CORE.is_libretiny or CORE.is_nrf52:
+        task_log_buffer_size = config[CONF_TASK_LOG_BUFFER_SIZE]
+    elif CORE.is_host:
+        task_log_buffer_size = 64  # Fixed 64 slots for host
+    if task_log_buffer_size > 0:
+        cg.add_define("USE_ESPHOME_TASK_LOG_BUFFER")
+        log = cg.new_Pvariable(
+            config[CONF_ID],
+            baud_rate,
+            task_log_buffer_size,
+        )
+    else:
+        log = cg.new_Pvariable(
+            config[CONF_ID],
+            baud_rate,
+        )
+    if CORE.is_esp32 or CORE.is_host:
         cg.add(log.create_pthread_key())
     # set_uart_selection() must be called before pre_setup() because
     # pre_setup() switches on uart_ to decide which hardware to initialize
@@ -364,17 +380,10 @@ async def _late_logger_init(config: ConfigType) -> None:
     log = await cg.get_variable(config[CONF_ID])
     level = config[CONF_LEVEL]
     baud_rate: int = config[CONF_BAUD_RATE]
-    if CORE.is_esp32 or CORE.is_libretiny or CORE.is_nrf52:
-        task_log_buffer_size = config[CONF_TASK_LOG_BUFFER_SIZE]
+    if CORE.using_zephyr:
+        task_log_buffer_size = config.get(CONF_TASK_LOG_BUFFER_SIZE, 0)
         if task_log_buffer_size > 0:
-            cg.add_define("USE_ESPHOME_TASK_LOG_BUFFER")
-            cg.add(log.init_log_buffer(task_log_buffer_size))
-            if CORE.using_zephyr:
-                zephyr_add_prj_conf("MPSC_PBUF", True)
-    elif CORE.is_host:
-        cg.add(log.create_pthread_key())
-        cg.add_define("USE_ESPHOME_TASK_LOG_BUFFER")
-        cg.add(log.init_log_buffer(64))  # Fixed 64 slots for host
+            zephyr_add_prj_conf("MPSC_PBUF", True)
 
     # Enable runtime tag levels if logs are configured or explicitly enabled
     logs_config = config[CONF_LOGS]
diff --git a/esphome/components/logger/logger.cpp b/esphome/components/logger/logger.cpp
index 497809cd2e..ceacded775 100644
--- a/esphome/components/logger/logger.cpp
+++ b/esphome/components/logger/logger.cpp
@@ -152,29 +152,25 @@ inline uint8_t Logger::level_for(const char *tag) {
   return this->current_level_;
 }
 
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+Logger::Logger(uint32_t baud_rate, size_t task_log_buffer_size) : baud_rate_(baud_rate) {
+#else
 Logger::Logger(uint32_t baud_rate) : baud_rate_(baud_rate) {
+#endif
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   this->main_task_ = xTaskGetCurrentTaskHandle();
 #elif defined(USE_ZEPHYR)
   this->main_task_ = k_current_get();
 #elif defined(USE_HOST)
-  this->main_thread_ = pthread_self();
+this->main_thread_ = pthread_self();
 #endif
-}
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
-void Logger::init_log_buffer(size_t total_buffer_size) {
-  // Host uses slot count instead of byte size
   // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) - allocated once, never freed
-  this->log_buffer_ = new logger::TaskLogBuffer(total_buffer_size);
-
-#if !(defined(USE_ZEPHYR) && defined(USE_LOGGER_UART_SELECTION_USB_CDC))
-  // Start with loop disabled when using task buffer
-  // The loop will be enabled automatically when messages arrive
-  // Zephyr with USB CDC needs loop active to poll port readiness via cdc_loop_()
-  this->disable_loop_when_buffer_empty_();
+  this->log_buffer_ = new logger::TaskLogBuffer(task_log_buffer_size);
+  // Note: we don't disable loop here because the component isn't registered with App yet.
+  // The loop self-disables on its first iteration when it finds no messages to process.
 #endif
 }
-#endif
 
 #if defined(USE_ESPHOME_TASK_LOG_BUFFER) || (defined(USE_ZEPHYR) && defined(USE_LOGGER_UART_SELECTION_USB_CDC))
 void Logger::loop() {
diff --git a/esphome/components/logger/logger.h b/esphome/components/logger/logger.h
index 263d12b444..fdb330c133 100644
--- a/esphome/components/logger/logger.h
+++ b/esphome/components/logger/logger.h
@@ -143,9 +143,10 @@ enum UARTSelection : uint8_t {
  */
 class Logger final : public Component {
  public:
-  explicit Logger(uint32_t baud_rate);
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
-  void init_log_buffer(size_t total_buffer_size);
+  explicit Logger(uint32_t baud_rate, size_t task_log_buffer_size);
+#else
+  explicit Logger(uint32_t baud_rate);
 #endif
 #if defined(USE_ESPHOME_TASK_LOG_BUFFER) || (defined(USE_ZEPHYR) && defined(USE_LOGGER_UART_SELECTION_USB_CDC))
   void loop() override;

From a3c483edf3838ba12fb83a927e9d4b1a744d9364 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jason=20K=C3=B6lker?= <jason@koelker.net>
Date: Sun, 22 Mar 2026 20:21:08 +0000
Subject: [PATCH 26/60] [pmsx003] Keep active-mode reads aligned (#14832)

---
 esphome/components/pmsx003/pmsx003.cpp | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/esphome/components/pmsx003/pmsx003.cpp b/esphome/components/pmsx003/pmsx003.cpp
index 114ecf435e..6275ff60c2 100644
--- a/esphome/components/pmsx003/pmsx003.cpp
+++ b/esphome/components/pmsx003/pmsx003.cpp
@@ -95,10 +95,6 @@ void PMSX003Component::loop() {
         // Just go ahead and read stuff
         break;
     }
-  } else if (now - this->last_update_ < this->update_interval_) {
-    // Otherwise just leave the sensor powered up and come back when we hit the update
-    // time
-    return;
   }
 
   if (now - this->last_transmission_ >= 500) {
@@ -114,10 +110,11 @@ void PMSX003Component::loop() {
     this->read_byte(&this->data_[this->data_index_]);
     auto check = this->check_byte_();
     if (!check.has_value()) {
-      // finished
-      this->parse_data_();
+      if (this->update_interval_ > STABILISING_MS || now - this->last_update_ >= this->update_interval_) {
+        this->parse_data_();
+        this->last_update_ = now;
+      }
       this->data_index_ = 0;
-      this->last_update_ = now;
     } else if (!*check) {
       // wrong data
       this->data_index_ = 0;
@@ -138,7 +135,7 @@ optional<bool> PMSX003Component::check_byte_() {
       return true;
     }
 
-    ESP_LOGW(TAG, "Start character %u mismatch: 0x%02X != 0x%02X", index + 1, byte, START_CHARACTER_1);
+    ESP_LOGW(TAG, "Start character %u mismatch: 0x%02X != 0x%02X", index + 1, byte, start_char);
     return false;
   }
 

From 320474b62d26fd4d8e6d55eba84b6c76e5bad48c Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Mon, 23 Mar 2026 09:28:58 +1300
Subject: [PATCH 27/60] Bump version to 2026.3.1

---
 Doxyfile         | 2 +-
 esphome/const.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Doxyfile b/Doxyfile
index d8a030536e..d86894435f 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2026.3.0
+PROJECT_NUMBER         = 2026.3.1
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
diff --git a/esphome/const.py b/esphome/const.py
index 756ad69464..52ac7acd22 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2026.3.0"
+__version__ = "2026.3.1"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

From 45c0e6ef7f3cf29ff1934cc8d94f8dcb9217df09 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 10:52:46 -1000
Subject: [PATCH 28/60] [logger] Fix unit test Logger constructor call (#15086)

---
 tests/components/main.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/components/main.cpp b/tests/components/main.cpp
index 373fde7151..622b1f107b 100644
--- a/tests/components/main.cpp
+++ b/tests/components/main.cpp
@@ -22,7 +22,7 @@ void original_setup() {
 void setup() {
   // Log functions call global_logger->log_vprintf_() without a null check,
   // so we must set up a Logger before any test that triggers logging.
-  static esphome::logger::Logger test_logger(0);
+  static esphome::logger::Logger test_logger(0, 64);
   test_logger.set_log_level(ESPHOME_LOG_LEVEL);
   test_logger.pre_setup();
 

From 6d16c57747773431da0484b0e10e10e5129fed39 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 11:54:54 -1000
Subject: [PATCH 29/60] [sht4x] Add missing hal.h include for millis() on
 ESP-IDF (#15087)

---
 esphome/components/sht4x/sht4x.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/esphome/components/sht4x/sht4x.cpp b/esphome/components/sht4x/sht4x.cpp
index 43c2436a56..b1dbde22a4 100644
--- a/esphome/components/sht4x/sht4x.cpp
+++ b/esphome/components/sht4x/sht4x.cpp
@@ -1,4 +1,5 @@
 #include "sht4x.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 
 namespace esphome {

From 83d02c602a911181ad0e0ef89ef50fde17ef0bd7 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 14:06:00 -1000
Subject: [PATCH 30/60] [logger] Fix dummy_main.cpp Logger constructor for
 clang-tidy (#15088)

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 tests/dummy_main.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/dummy_main.cpp b/tests/dummy_main.cpp
index 6fa0c08aa3..329286e2fa 100644
--- a/tests/dummy_main.cpp
+++ b/tests/dummy_main.cpp
@@ -15,7 +15,7 @@ void setup() {
   static char name[] = "livingroom";
   static char friendly_name[] = "LivingRoom";
   App.pre_setup(name, sizeof(name) - 1, friendly_name, sizeof(friendly_name) - 1);
-  auto *log = new logger::Logger(115200);  // NOLINT
+  auto *log = new logger::Logger(115200, 512);  // NOLINT
   log->pre_setup();
   log->set_uart_selection(logger::UART_SELECTION_UART0);
   App.register_component_(log);

From 6992219e341b4eca9f2bfdf28474cbf45883bd08 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 16:27:07 -1000
Subject: [PATCH 31/60] [core] Attribute placement new storage symbols to
 components (#15092)

---
 esphome/analyze_memory/__init__.py            | 29 ++++++
 esphome/analyze_memory/cli.py                 | 48 +++++++---
 esphome/cpp_generator.py                      | 11 ++-
 .../deep_sleep/test_deep_sleep.py             |  2 +-
 tests/component_tests/image/test_init.py      |  4 +-
 .../mipi_dsi/test_mipi_dsi_config.py          |  4 +-
 .../status_led/test_status_led.py             |  4 +-
 .../test_pstorage_attribution.py              | 90 +++++++++++++++++++
 8 files changed, 171 insertions(+), 21 deletions(-)
 create mode 100644 tests/unit_tests/analyze_memory/test_pstorage_attribution.py

diff --git a/esphome/analyze_memory/__init__.py b/esphome/analyze_memory/__init__.py
index 48ecf2c1dc..f56d720ec2 100644
--- a/esphome/analyze_memory/__init__.py
+++ b/esphome/analyze_memory/__init__.py
@@ -56,6 +56,10 @@ _COMPONENT_PREFIX_LIB = "[lib]"
 _COMPONENT_CORE = f"{_COMPONENT_PREFIX_ESPHOME}core"
 _COMPONENT_API = f"{_COMPONENT_PREFIX_ESPHOME}api"
 
+# Placement new storage suffix (generated by codegen Pvariable)
+_PSTORAGE_SUFFIX = "__pstorage"
+
+
 # C++ namespace prefixes
 _NAMESPACE_ESPHOME = "esphome::"
 _NAMESPACE_STD = "std::"
@@ -332,6 +336,13 @@ class MemoryAnalyzer:
         # Demangle C++ names if needed
         demangled = self._demangle_symbol(symbol_name)
 
+        # Check for placement new storage symbols (generated by codegen)
+        # Format: {component}__{id}__pstorage
+        if demangled.endswith(_PSTORAGE_SUFFIX) and (
+            component := self._match_pstorage_component(demangled)
+        ):
+            return component
+
         # Check for special component classes first (before namespace pattern)
         # This handles cases like esphome::ESPHomeOTAComponent which should map to ota
         if _NAMESPACE_ESPHOME in demangled:
@@ -399,6 +410,24 @@ class MemoryAnalyzer:
         # Track uncategorized symbols for analysis
         return "other"
 
+    def _match_pstorage_component(self, symbol_name: str) -> str | None:
+        """Match a __pstorage symbol to its ESPHome component.
+
+        Symbol format: {component}__{id}__pstorage
+        The component namespace is embedded by codegen before the double underscore.
+        """
+        prefix = symbol_name[: -len(_PSTORAGE_SUFFIX)]
+        # Extract component namespace before the first double underscore
+        dunder_pos = prefix.find("__")
+        if dunder_pos == -1:
+            return None
+        component_name = prefix[:dunder_pos]
+        if component_name in get_esphome_components():
+            return f"{_COMPONENT_PREFIX_ESPHOME}{component_name}"
+        if component_name in self.external_components:
+            return f"{_COMPONENT_PREFIX_EXTERNAL}{component_name}"
+        return None
+
     def _batch_demangle_symbols(self, symbols: list[str]) -> None:
         """Batch demangle C++ symbol names for efficiency."""
         if not symbols:
diff --git a/esphome/analyze_memory/cli.py b/esphome/analyze_memory/cli.py
index acaf5f4562..b7561e8ffc 100644
--- a/esphome/analyze_memory/cli.py
+++ b/esphome/analyze_memory/cli.py
@@ -15,6 +15,7 @@ from . import (
     _COMPONENT_PREFIX_ESPHOME,
     _COMPONENT_PREFIX_EXTERNAL,
     _COMPONENT_PREFIX_LIB,
+    _PSTORAGE_SUFFIX,
     RAM_SECTIONS,
     MemoryAnalyzer,
 )
@@ -23,6 +24,17 @@ if TYPE_CHECKING:
     from . import ComponentMemory
 
 
+def _format_pstorage_name(name: str) -> str:
+    """Format a __pstorage symbol as 'storage for {id}'."""
+    if not name.endswith(_PSTORAGE_SUFFIX):
+        return name
+    prefix = name[: -len(_PSTORAGE_SUFFIX)]
+    # Strip component namespace prefix: {component}__{id} -> {id}
+    dunder_pos = prefix.find("__")
+    var_id = prefix[dunder_pos + 2 :] if dunder_pos != -1 else prefix
+    return f"storage for {var_id}"
+
+
 class MemoryAnalyzerCLI(MemoryAnalyzer):
     """Memory analyzer with CLI-specific report generation."""
 
@@ -148,11 +160,14 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
         If section is one of the RAM sections (.data or .bss), a label like
         " [data]" or " [bss]" is appended. For non-RAM sections or when
         section is None, no section label is added.
+
+        Placement new storage symbols are formatted as "storage for {id}".
         """
+        display_name = _format_pstorage_name(demangled)
         section_label = ""
         if section in RAM_SECTIONS:
             section_label = f" [{section[1:]}]"  # .data -> [data], .bss -> [bss]
-        return f"{demangled} ({size:,} B){section_label}"
+        return f"{display_name} ({size:,} B){section_label}"
 
     def _add_top_symbols(self, lines: list[str]) -> None:
         """Add a section showing the top largest symbols in the binary."""
@@ -175,11 +190,13 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
         for i, (_, demangled, size, section, component) in enumerate(top_symbols):
             # Format section label
             section_label = f"[{section[1:]}]" if section else ""
-            # Truncate demangled name if too long
+            # Format storage symbols readably
+            display_name = _format_pstorage_name(demangled)
+            # Truncate if too long
             demangled_display = (
-                f"{demangled[:truncate_limit]}..."
-                if len(demangled) > self.COL_TOP_SYMBOL_NAME
-                else demangled
+                f"{display_name[:truncate_limit]}..."
+                if len(display_name) > self.COL_TOP_SYMBOL_NAME
+                else display_name
             )
             lines.append(
                 f"{i + 1:>2}. {size:>7,} B {section_label:<8} {demangled_display:<{self.COL_TOP_SYMBOL_NAME}} {component}"
@@ -573,15 +590,16 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 lines.append(f"Total size: {comp_mem.flash_total:,} B")
                 lines.append("")
 
-                # Show all symbols above threshold for better visibility
+                # Show symbols above threshold, always include storage symbols
                 large_symbols = [
                     (sym, dem, size, sec)
                     for sym, dem, size, sec in sorted_symbols
                     if size > self.SYMBOL_SIZE_THRESHOLD
+                    or dem.endswith(_PSTORAGE_SUFFIX)
                 ]
 
                 lines.append(
-                    f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_symbols)} symbols):"
+                    f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B & storage ({len(large_symbols)} symbols):"
                 )
                 for i, (symbol, demangled, size, section) in enumerate(large_symbols):
                     lines.append(
@@ -604,7 +622,10 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
             # Sort by size descending
             sorted_ram_syms = sorted(ram_syms, key=lambda x: x[2], reverse=True)
             large_ram_syms = [
-                s for s in sorted_ram_syms if s[2] > self.RAM_SYMBOL_SIZE_THRESHOLD
+                s
+                for s in sorted_ram_syms
+                if s[2] > self.RAM_SYMBOL_SIZE_THRESHOLD
+                or s[1].endswith(_PSTORAGE_SUFFIX)
             ]
 
             lines.append(f"{name} ({mem.ram_total:,} B total RAM):")
@@ -622,13 +643,14 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 for symbol, demangled, size, section in large_ram_syms[:10]:
                     # Format section label consistently by stripping leading dot
                     section_label = section.lstrip(".") if section else ""
+                    display_name = _format_pstorage_name(demangled)
                     # Add ellipsis if name is truncated
-                    demangled_display = (
-                        f"{demangled[:70]}..." if len(demangled) > 70 else demangled
-                    )
-                    lines.append(
-                        f"    {size:>6,} B [{section_label}] {demangled_display}"
+                    display_name = (
+                        f"{display_name[:70]}..."
+                        if len(display_name) > 70
+                        else display_name
                     )
+                    lines.append(f"    {size:>6,} B [{section_label}] {display_name}")
                 if len(large_ram_syms) > 10:
                     lines.append(f"    ... and {len(large_ram_syms) - 10} more")
             lines.append("")
diff --git a/esphome/cpp_generator.py b/esphome/cpp_generator.py
index 3ed5d0ba37..e97bd71a48 100644
--- a/esphome/cpp_generator.py
+++ b/esphome/cpp_generator.py
@@ -584,7 +584,16 @@ def Pvariable(id_: ID, rhs: SafeExpType, type_: "MockObj" = None) -> "MockObj":
         # For 'new' allocations, use placement new into static storage
         # to avoid heap fragmentation on embedded devices.
         the_type = id_.type
-        storage_name = f"{id_.id}__pstorage"
+        # Extract component namespace from type for memory analysis attribution
+        type_str = str(the_type)
+        # Strip leading esphome:: to get the component namespace
+        # e.g. esphome::dsmr::Dsmr -> dsmr, logger::Logger -> logger
+        bare = type_str.removeprefix("esphome::")
+        if "::" in bare:
+            component_ns = bare.split("::", maxsplit=1)[0].rstrip("_")
+        else:
+            component_ns = "esphome"
+        storage_name = f"{component_ns}__{id_.id}__pstorage"
 
         # Declare aligned byte array for the object storage
         CORE.add_global(
diff --git a/tests/component_tests/deep_sleep/test_deep_sleep.py b/tests/component_tests/deep_sleep/test_deep_sleep.py
index 212f61e44b..8c1278a332 100644
--- a/tests/component_tests/deep_sleep/test_deep_sleep.py
+++ b/tests/component_tests/deep_sleep/test_deep_sleep.py
@@ -8,7 +8,7 @@ def test_deep_sleep_setup(generate_main):
     main_cpp = generate_main("tests/component_tests/deep_sleep/test_deep_sleep1.yaml")
 
     assert (
-        "static deep_sleep::DeepSleepComponent *const deepsleep = reinterpret_cast<deep_sleep::DeepSleepComponent *>(deepsleep__pstorage);"
+        "static deep_sleep::DeepSleepComponent *const deepsleep = reinterpret_cast<deep_sleep::DeepSleepComponent *>(deep_sleep__deepsleep__pstorage);"
         in main_cpp
     )
     assert "new(deepsleep) deep_sleep::DeepSleepComponent();" in main_cpp
diff --git a/tests/component_tests/image/test_init.py b/tests/component_tests/image/test_init.py
index 9003a4ee5d..6f73888c7d 100644
--- a/tests/component_tests/image/test_init.py
+++ b/tests/component_tests/image/test_init.py
@@ -242,11 +242,11 @@ def test_image_generation(
     main_cpp = generate_main(component_config_path("image_test.yaml"))
     assert "uint8_t_id[] PROGMEM = {0x24, 0x21, 0x24, 0x21" in main_cpp
     assert (
-        "alignas(image::Image) static unsigned char cat_img__pstorage[sizeof(image::Image)];"
+        "alignas(image::Image) static unsigned char image__cat_img__pstorage[sizeof(image::Image)];"
         in main_cpp
     )
     assert (
-        "static image::Image *const cat_img = reinterpret_cast<image::Image *>(cat_img__pstorage);"
+        "static image::Image *const cat_img = reinterpret_cast<image::Image *>(image__cat_img__pstorage);"
         in main_cpp
     )
     assert (
diff --git a/tests/component_tests/mipi_dsi/test_mipi_dsi_config.py b/tests/component_tests/mipi_dsi/test_mipi_dsi_config.py
index e6f344b086..1ae8cc644e 100644
--- a/tests/component_tests/mipi_dsi/test_mipi_dsi_config.py
+++ b/tests/component_tests/mipi_dsi/test_mipi_dsi_config.py
@@ -119,11 +119,11 @@ def test_code_generation(
 
     main_cpp = generate_main(component_fixture_path("mipi_dsi.yaml"))
     assert (
-        "alignas(mipi_dsi::MIPI_DSI) static unsigned char p4_nano__pstorage[sizeof(mipi_dsi::MIPI_DSI)];"
+        "alignas(mipi_dsi::MIPI_DSI) static unsigned char mipi_dsi__p4_nano__pstorage[sizeof(mipi_dsi::MIPI_DSI)];"
         in main_cpp
     )
     assert (
-        "static mipi_dsi::MIPI_DSI *const p4_nano = reinterpret_cast<mipi_dsi::MIPI_DSI *>(p4_nano__pstorage);"
+        "static mipi_dsi::MIPI_DSI *const p4_nano = reinterpret_cast<mipi_dsi::MIPI_DSI *>(mipi_dsi__p4_nano__pstorage);"
         in main_cpp
     )
     assert (
diff --git a/tests/component_tests/status_led/test_status_led.py b/tests/component_tests/status_led/test_status_led.py
index 0e96e631f5..f7e0a9de86 100644
--- a/tests/component_tests/status_led/test_status_led.py
+++ b/tests/component_tests/status_led/test_status_led.py
@@ -13,11 +13,11 @@ def test_status_led_generation(
     """Test status_led generation."""
     main_cpp = generate_main(component_config_path("status_led_test.yaml"))
     assert (
-        "alignas(status_led::StatusLED) static unsigned char status_led_statusled_id__pstorage[sizeof(status_led::StatusLED)];"
+        "alignas(status_led::StatusLED) static unsigned char status_led__status_led_statusled_id__pstorage[sizeof(status_led::StatusLED)];"
         in main_cpp
     )
     assert (
-        "static status_led::StatusLED *const status_led_statusled_id = reinterpret_cast<status_led::StatusLED *>(status_led_statusled_id__pstorage);"
+        "static status_led::StatusLED *const status_led_statusled_id = reinterpret_cast<status_led::StatusLED *>(status_led__status_led_statusled_id__pstorage);"
         in main_cpp
     )
     assert "new(status_led_statusled_id) status_led::StatusLED(" in main_cpp
diff --git a/tests/unit_tests/analyze_memory/test_pstorage_attribution.py b/tests/unit_tests/analyze_memory/test_pstorage_attribution.py
new file mode 100644
index 0000000000..a57b283f44
--- /dev/null
+++ b/tests/unit_tests/analyze_memory/test_pstorage_attribution.py
@@ -0,0 +1,90 @@
+"""Tests for __pstorage symbol attribution in memory analyzer."""
+
+from unittest.mock import patch
+
+from esphome.analyze_memory import _PSTORAGE_SUFFIX, MemoryAnalyzer
+
+
+def _make_analyzer(external_components: set[str] | None = None) -> MemoryAnalyzer:
+    """Create a MemoryAnalyzer with mocked dependencies."""
+    with patch.object(MemoryAnalyzer, "__init__", lambda self, *a, **kw: None):
+        analyzer = MemoryAnalyzer.__new__(MemoryAnalyzer)
+        analyzer.external_components = external_components or set()
+    return analyzer
+
+
+def test_pstorage_suffix_constant() -> None:
+    """Verify the suffix constant matches what codegen produces."""
+    assert _PSTORAGE_SUFFIX == "__pstorage"
+
+
+def test_match_pstorage_simple_component() -> None:
+    """Simple component name like 'logger'."""
+    analyzer = _make_analyzer()
+    result = analyzer._match_pstorage_component("logger__logger_id__pstorage")
+    assert result == "[esphome]logger"
+
+
+def test_match_pstorage_underscore_component() -> None:
+    """Component with underscore like 'web_server'."""
+    analyzer = _make_analyzer()
+    result = analyzer._match_pstorage_component("web_server__webserver_id__pstorage")
+    assert result == "[esphome]web_server"
+
+
+def test_match_pstorage_api() -> None:
+    """API component."""
+    analyzer = _make_analyzer()
+    result = analyzer._match_pstorage_component("api__apiserver_id__pstorage")
+    assert result == "[esphome]api"
+
+
+def test_match_pstorage_deep_sleep() -> None:
+    """Component with underscore: deep_sleep."""
+    analyzer = _make_analyzer()
+    result = analyzer._match_pstorage_component("deep_sleep__deepsleep__pstorage")
+    assert result == "[esphome]deep_sleep"
+
+
+def test_match_pstorage_status_led() -> None:
+    """Component with underscore: status_led."""
+    analyzer = _make_analyzer()
+    result = analyzer._match_pstorage_component("status_led__statusled_id__pstorage")
+    assert result == "[esphome]status_led"
+
+
+def test_match_pstorage_external_component() -> None:
+    """External component should be attributed correctly."""
+    analyzer = _make_analyzer(external_components={"my_custom"})
+    result = analyzer._match_pstorage_component("my_custom__thing_id__pstorage")
+    assert result == "[external]my_custom"
+
+
+def test_match_pstorage_no_dunder_returns_none() -> None:
+    """Symbol without double underscore separator returns None."""
+    analyzer = _make_analyzer()
+    result = analyzer._match_pstorage_component("something__pstorage")
+    assert result is None
+
+
+def test_match_pstorage_unknown_component_returns_none() -> None:
+    """Unknown component namespace returns None."""
+    analyzer = _make_analyzer()
+    result = analyzer._match_pstorage_component("nonexistent__thing_id__pstorage")
+    assert result is None
+
+
+def test_match_pstorage_esphome_component() -> None:
+    """esphome:: namespace types map to the esphome component."""
+    analyzer = _make_analyzer()
+    result = analyzer._match_pstorage_component(
+        "esphome__esphomeotacomponent_id__pstorage"
+    )
+    assert result == "[esphome]esphome"
+
+
+def test_match_pstorage_user_id_with_component_prefix() -> None:
+    """User-chosen ID that happens to contain a component name."""
+    analyzer = _make_analyzer()
+    result = analyzer._match_pstorage_component("logger__relay1__pstorage")
+    assert result == "[esphome]logger"

From 98d9fd76b35f995e14fca86e07515317f2220d22 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 16:27:20 -1000
Subject: [PATCH 32/60] [mqtt] Fix const-correctness for trigger constructors
 (#15093)

---
 esphome/components/mqtt/mqtt_client.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/esphome/components/mqtt/mqtt_client.h b/esphome/components/mqtt/mqtt_client.h
index 0d52d98d2f..14473f737a 100644
--- a/esphome/components/mqtt/mqtt_client.h
+++ b/esphome/components/mqtt/mqtt_client.h
@@ -366,14 +366,14 @@ class MQTTJsonMessageTrigger : public Trigger<JsonObjectConst> {
 
 class MQTTConnectTrigger : public Trigger<bool> {
  public:
-  explicit MQTTConnectTrigger(MQTTClientComponent *&client) {
+  explicit MQTTConnectTrigger(MQTTClientComponent *client) {
     client->set_on_connect([this](bool session_present) { this->trigger(session_present); });
   }
 };
 
 class MQTTDisconnectTrigger : public Trigger<MQTTClientDisconnectReason> {
  public:
-  explicit MQTTDisconnectTrigger(MQTTClientComponent *&client) {
+  explicit MQTTDisconnectTrigger(MQTTClientComponent *client) {
     client->set_on_disconnect([this](MQTTClientDisconnectReason reason) { this->trigger(reason); });
   }
 };

From 8a3b5a8defe9d2f58ce9b1ca4447e2d0bfe8f77e Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 17:09:23 -1000
Subject: [PATCH 33/60] [core] Fix placement new storage name for templated
 types (#15096)

---
 esphome/cpp_generator.py         | 32 ++++++++++++++++++++++++--------
 tests/unit_tests/test_codegen.py | 27 +++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 8 deletions(-)

diff --git a/esphome/cpp_generator.py b/esphome/cpp_generator.py
index e97bd71a48..a8efe96cce 100644
--- a/esphome/cpp_generator.py
+++ b/esphome/cpp_generator.py
@@ -565,6 +565,29 @@ def new_variable(
     return obj
 
 
+def _extract_component_ns(type_str: str) -> str:
+    """Extract the component namespace from a fully-qualified C++ type string.
+
+    Strips leading ``esphome::`` and template arguments, then returns
+    the first namespace segment.  Falls back to ``"esphome"`` when the
+    type has no namespace qualifier (after stripping templates).
+
+    Examples::
+
+        esphome::dsmr::Dsmr                                        -> dsmr
+        esphome::logger::Logger                                     -> logger
+        esphome::Automation<std::optional<bool>, std::optional<bool>> -> esphome
+        Logger                                                      -> esphome
+    """
+    bare = type_str.removeprefix("esphome::")
+    # Strip template arguments before namespace extraction to avoid
+    # matching :: inside template params (e.g. Automation<std::optional<bool>>)
+    bare_no_template = bare.split("<", maxsplit=1)[0]
+    if "::" in bare_no_template:
+        return bare_no_template.split("::", maxsplit=1)[0].rstrip("_")
+    return "esphome"
+
+
 def Pvariable(id_: ID, rhs: SafeExpType, type_: "MockObj" = None) -> "MockObj":
     """Declare a new pointer variable in the code generation.
 
@@ -585,14 +608,7 @@ def Pvariable(id_: ID, rhs: SafeExpType, type_: "MockObj" = None) -> "MockObj":
         # to avoid heap fragmentation on embedded devices.
         the_type = id_.type
         # Extract component namespace from type for memory analysis attribution
-        type_str = str(the_type)
-        # Strip leading esphome:: to get the component namespace
-        # e.g. esphome::dsmr::Dsmr -> dsmr, logger::Logger -> logger
-        bare = type_str.removeprefix("esphome::")
-        if "::" in bare:
-            component_ns = bare.split("::", maxsplit=1)[0].rstrip("_")
-        else:
-            component_ns = "esphome"
+        component_ns = _extract_component_ns(str(the_type))
         storage_name = f"{component_ns}__{id_.id}__pstorage"
 
         # Declare aligned byte array for the object storage
diff --git a/tests/unit_tests/test_codegen.py b/tests/unit_tests/test_codegen.py
index 3f32a117ff..8d01fef7c2 100644
--- a/tests/unit_tests/test_codegen.py
+++ b/tests/unit_tests/test_codegen.py
@@ -1,6 +1,7 @@
 import pytest
 
 from esphome import codegen as cg
+from esphome.cpp_generator import _extract_component_ns
 
 
 # Test interface remains the same.
@@ -75,3 +76,29 @@ from esphome import codegen as cg
 )
 def test_exists(attr):
     assert hasattr(cg, attr)
+
+
+@pytest.mark.parametrize(
+    ("type_str", "expected"),
+    (
+        ("esphome::dsmr::Dsmr", "dsmr"),
+        ("esphome::logger::Logger", "logger"),
+        ("esphome::web_server::WebServer", "web_server"),
+        ("esphome::deep_sleep::DeepSleep", "deep_sleep"),
+        ("esphome::Component", "esphome"),
+        ("Logger", "esphome"),
+        # Template types with :: in template args must not confuse extraction
+        (
+            "esphome::Automation<std::optional<bool>, std::optional<bool>>",
+            "esphome",
+        ),
+        (
+            "esphome::StatelessLambdaAction<std::optional<bool>, std::optional<bool>>",
+            "esphome",
+        ),
+        # Namespaced template type
+        ("esphome::sensor::Sensor<std::string>", "sensor"),
+    ),
+)
+def test_extract_component_ns(type_str, expected):
+    assert _extract_component_ns(type_str) == expected

From 597bb185432ac4b5c069bf7936ff9a425af94641 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 17:30:57 -1000
Subject: [PATCH 34/60] [benchmark] Add binary sensor publish and sensor filter
 benchmarks (#15035)

---
 .../components/binary_sensor/__init__.py      |  5 ++
 .../bench_binary_sensor_publish.cpp           | 61 +++++++++++++++
 .../components/binary_sensor/benchmark.yaml   |  1 +
 .../benchmarks/components/sensor/__init__.py  | 12 +++
 .../components/sensor/bench_sensor_filter.cpp | 78 +++++++++++++++++++
 .../components/sensor/benchmark.yaml          |  1 +
 6 files changed, 158 insertions(+)
 create mode 100644 tests/benchmarks/components/binary_sensor/__init__.py
 create mode 100644 tests/benchmarks/components/binary_sensor/bench_binary_sensor_publish.cpp
 create mode 100644 tests/benchmarks/components/binary_sensor/benchmark.yaml
 create mode 100644 tests/benchmarks/components/sensor/__init__.py
 create mode 100644 tests/benchmarks/components/sensor/bench_sensor_filter.cpp
 create mode 100644 tests/benchmarks/components/sensor/benchmark.yaml

diff --git a/tests/benchmarks/components/binary_sensor/__init__.py b/tests/benchmarks/components/binary_sensor/__init__.py
new file mode 100644
index 0000000000..b08f67a095
--- /dev/null
+++ b/tests/benchmarks/components/binary_sensor/__init__.py
@@ -0,0 +1,5 @@
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    manifest.enable_codegen()
diff --git a/tests/benchmarks/components/binary_sensor/bench_binary_sensor_publish.cpp b/tests/benchmarks/components/binary_sensor/bench_binary_sensor_publish.cpp
new file mode 100644
index 0000000000..8bae943e2e
--- /dev/null
+++ b/tests/benchmarks/components/binary_sensor/bench_binary_sensor_publish.cpp
@@ -0,0 +1,61 @@
+#include <benchmark/benchmark.h>
+
+#include "esphome/components/binary_sensor/binary_sensor.h"
+
+namespace esphome::binary_sensor::benchmarks {
+
+static constexpr int kInnerIterations = 2000;
+
+// Benchmark: publish_state with alternating values (forces state change every time)
+static void BinarySensorPublish_Alternating(benchmark::State &state) {
+  BinarySensor sensor;
+
+  // First publish to establish initial state
+  sensor.publish_initial_state(false);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      sensor.publish_state(i % 2 == 0);
+    }
+    benchmark::DoNotOptimize(sensor.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(BinarySensorPublish_Alternating);
+
+// Benchmark: publish_state with same value (tests dedup fast path)
+static void BinarySensorPublish_NoChange(benchmark::State &state) {
+  BinarySensor sensor;
+
+  sensor.publish_initial_state(true);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      sensor.publish_state(true);
+    }
+    benchmark::DoNotOptimize(sensor.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(BinarySensorPublish_NoChange);
+
+// Benchmark: publish_state with a callback registered
+static void BinarySensorPublish_WithCallback(benchmark::State &state) {
+  BinarySensor sensor;
+
+  int callback_count = 0;
+  sensor.add_on_state_callback([&callback_count](bool) { callback_count++; });
+
+  sensor.publish_initial_state(false);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      sensor.publish_state(i % 2 == 0);
+    }
+    benchmark::DoNotOptimize(callback_count);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(BinarySensorPublish_WithCallback);
+
+}  // namespace esphome::binary_sensor::benchmarks
diff --git a/tests/benchmarks/components/binary_sensor/benchmark.yaml b/tests/benchmarks/components/binary_sensor/benchmark.yaml
new file mode 100644
index 0000000000..fc0db6c52c
--- /dev/null
+++ b/tests/benchmarks/components/binary_sensor/benchmark.yaml
@@ -0,0 +1 @@
+binary_sensor:
diff --git a/tests/benchmarks/components/sensor/__init__.py b/tests/benchmarks/components/sensor/__init__.py
new file mode 100644
index 0000000000..5a593aa8c2
--- /dev/null
+++ b/tests/benchmarks/components/sensor/__init__.py
@@ -0,0 +1,12 @@
+import esphome.codegen as cg
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # Sensor filter benchmarks need USE_SENSOR_FILTER defined.
+    # We use a custom to_code instead of enable_codegen() to avoid
+    # pulling in the full sensor component setup.
+    async def to_code(config):
+        cg.add_define("USE_SENSOR_FILTER")
+
+    manifest.to_code = to_code
diff --git a/tests/benchmarks/components/sensor/bench_sensor_filter.cpp b/tests/benchmarks/components/sensor/bench_sensor_filter.cpp
new file mode 100644
index 0000000000..e4aa397690
--- /dev/null
+++ b/tests/benchmarks/components/sensor/bench_sensor_filter.cpp
@@ -0,0 +1,78 @@
+#include <benchmark/benchmark.h>
+
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/sensor/filter.h"
+
+namespace esphome::sensor::benchmarks {
+
+static constexpr int kInnerIterations = 2000;
+
+// Benchmark: sensor publish through a SlidingWindowMovingAverageFilter (window=5, send_every=1)
+static void SensorFilter_SlidingWindowAvg(benchmark::State &state) {
+  Sensor sensor;
+
+  // Create filter: window_size=5, send_every=1, send_first_at=1
+  auto *filter = new SlidingWindowMovingAverageFilter(5, 1, 1);
+  sensor.add_filter(filter);
+
+  float value = 0.0f;
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      sensor.publish_state(value);
+      value += 0.1f;
+      if (value > 1000.0f)
+        value = 0.0f;
+    }
+    benchmark::DoNotOptimize(sensor.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(SensorFilter_SlidingWindowAvg);
+
+// Benchmark: sensor publish through ExponentialMovingAverageFilter
+static void SensorFilter_ExponentialMovingAvg(benchmark::State &state) {
+  Sensor sensor;
+
+  // alpha=0.1, send_every=1, send_first_at=1
+  auto *filter = new ExponentialMovingAverageFilter(0.1f, 1, 1);
+  sensor.add_filter(filter);
+
+  float value = 0.0f;
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      sensor.publish_state(value);
+      value += 0.1f;
+      if (value > 1000.0f)
+        value = 0.0f;
+    }
+    benchmark::DoNotOptimize(sensor.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(SensorFilter_ExponentialMovingAvg);
+
+// Benchmark: sensor publish through a chain of 3 filters (offset + multiply + sliding window)
+static void SensorFilter_Chain3(benchmark::State &state) {
+  Sensor sensor;
+
+  sensor.add_filters({
+      new OffsetFilter(1.0f),
+      new MultiplyFilter(2.0f),
+      new SlidingWindowMovingAverageFilter(5, 1, 1),
+  });
+
+  float value = 0.0f;
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      sensor.publish_state(value);
+      value += 0.1f;
+      if (value > 1000.0f)
+        value = 0.0f;
+    }
+    benchmark::DoNotOptimize(sensor.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(SensorFilter_Chain3);
+
+}  // namespace esphome::sensor::benchmarks
diff --git a/tests/benchmarks/components/sensor/benchmark.yaml b/tests/benchmarks/components/sensor/benchmark.yaml
new file mode 100644
index 0000000000..e1fb52cdd6
--- /dev/null
+++ b/tests/benchmarks/components/sensor/benchmark.yaml
@@ -0,0 +1 @@
+sensor:

From 0de2c758aa1c42d6b9734fb410244c18bf7156f7 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 17:31:27 -1000
Subject: [PATCH 35/60] [scheduler] Use placement-new for std::function move in
 set_timer_common_ (#14757)

---
 esphome/core/scheduler.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/esphome/core/scheduler.cpp b/esphome/core/scheduler.cpp
index 51cbfb208e..9ee3b2fdd2 100644
--- a/esphome/core/scheduler.cpp
+++ b/esphome/core/scheduler.cpp
@@ -166,7 +166,13 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
   item->component = component;
   item->set_name(name_type, static_name, hash_or_id);
   item->type = type;
-  item->callback = std::move(func);
+  // Use destroy + placement-new instead of move-assignment.
+  // GCC's std::function::operator=(function&&) does a full swap dance even when the
+  // target is empty. Since recycled/new items always have an empty callback, we can
+  // destroy the empty one (no-op) and move-construct directly, saving ~40 bytes of
+  // swap/destructor code on Xtensa.
+  item->callback.~function();
+  new (&item->callback) std::function<void()>(std::move(func));
   // Reset remove flag - recycled items may have been cancelled (remove=true) in previous use
   this->set_item_removed_(item, false);
   item->is_retry = is_retry;

From baf365404cb2b2d9a359718661a31f1c8d2604f5 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 18:18:43 -1000
Subject: [PATCH 36/60] [network] Inline get_use_address() to eliminate
 function call overhead (#14942)

---
 .../ethernet/ethernet_component.cpp           |  6 -----
 .../components/ethernet/ethernet_component.h  |  4 ++--
 esphome/components/network/util.cpp           | 24 -------------------
 esphome/components/network/util.h             | 24 ++++++++++++++++++-
 esphome/components/openthread/openthread.cpp  |  6 -----
 esphome/components/openthread/openthread.h    |  4 ++--
 esphome/components/wifi/wifi_component.cpp    |  4 ----
 esphome/components/wifi/wifi_component.h      |  4 ++--
 8 files changed, 29 insertions(+), 47 deletions(-)

diff --git a/esphome/components/ethernet/ethernet_component.cpp b/esphome/components/ethernet/ethernet_component.cpp
index 4421a1c7aa..42cb0b3cfc 100644
--- a/esphome/components/ethernet/ethernet_component.cpp
+++ b/esphome/components/ethernet/ethernet_component.cpp
@@ -18,12 +18,6 @@ void EthernetComponent::set_type(EthernetType type) { this->type_ = type; }
 void EthernetComponent::set_manual_ip(const ManualIP &manual_ip) { this->manual_ip_ = manual_ip; }
 #endif
 
-// set_use_address() is guaranteed to be called during component setup by Python code generation,
-// so use_address_ will always be valid when get_use_address() is called - no fallback needed.
-const char *EthernetComponent::get_use_address() const { return this->use_address_; }
-
-void EthernetComponent::set_use_address(const char *use_address) { this->use_address_ = use_address; }
-
 #ifdef USE_ETHERNET_IP_STATE_LISTENERS
 void EthernetComponent::notify_ip_state_listeners_() {
   auto ips = this->get_ip_addresses();
diff --git a/esphome/components/ethernet/ethernet_component.h b/esphome/components/ethernet/ethernet_component.h
index 88a86bc043..b6699e8020 100644
--- a/esphome/components/ethernet/ethernet_component.h
+++ b/esphome/components/ethernet/ethernet_component.h
@@ -103,8 +103,8 @@ class EthernetComponent final : public Component {
 
   network::IPAddresses get_ip_addresses();
   network::IPAddress get_dns_address(uint8_t num);
-  const char *get_use_address() const;
-  void set_use_address(const char *use_address);
+  const char *get_use_address() const { return this->use_address_; }
+  void set_use_address(const char *use_address) { this->use_address_ = use_address; }
   void get_eth_mac_address_raw(uint8_t *mac);
   // Remove before 2026.9.0
   ESPDEPRECATED("Use get_eth_mac_address_pretty_into_buffer() instead. Removed in 2026.9.0", "2026.3.0")
diff --git a/esphome/components/network/util.cpp b/esphome/components/network/util.cpp
index 226b11b8cd..79ddd3844c 100644
--- a/esphome/components/network/util.cpp
+++ b/esphome/components/network/util.cpp
@@ -42,29 +42,5 @@ network::IPAddresses get_ip_addresses() {
   return {};
 }
 
-const char *get_use_address() {
-  // Global component pointers are guaranteed to be set by component constructors when USE_* is defined
-#ifdef USE_ETHERNET
-  return ethernet::global_eth_component->get_use_address();
-#endif
-
-#ifdef USE_MODEM
-  return modem::global_modem_component->get_use_address();
-#endif
-
-#ifdef USE_WIFI
-  return wifi::global_wifi_component->get_use_address();
-#endif
-
-#ifdef USE_OPENTHREAD
-  return openthread::global_openthread_component->get_use_address();
-#endif
-
-#if !defined(USE_ETHERNET) && !defined(USE_MODEM) && !defined(USE_WIFI) && !defined(USE_OPENTHREAD)
-  // Fallback when no network component is defined (e.g., host platform)
-  return "";
-#endif
-}
-
 }  // namespace esphome::network
 #endif
diff --git a/esphome/components/network/util.h b/esphome/components/network/util.h
index 4b700fe74c..e4e8a01f8c 100644
--- a/esphome/components/network/util.h
+++ b/esphome/components/network/util.h
@@ -54,7 +54,29 @@ ESPHOME_ALWAYS_INLINE inline bool is_connected() {
 /// Return whether the network is disabled (only wifi for now)
 bool is_disabled();
 /// Get the active network hostname
-const char *get_use_address();
+ESPHOME_ALWAYS_INLINE inline const char *get_use_address() {
+  // Global component pointers are guaranteed to be set by component constructors when USE_* is defined
+#ifdef USE_ETHERNET
+  return ethernet::global_eth_component->get_use_address();
+#endif
+
+#ifdef USE_MODEM
+  return modem::global_modem_component->get_use_address();
+#endif
+
+#ifdef USE_WIFI
+  return wifi::global_wifi_component->get_use_address();
+#endif
+
+#ifdef USE_OPENTHREAD
+  return openthread::global_openthread_component->get_use_address();
+#endif
+
+#if !defined(USE_ETHERNET) && !defined(USE_MODEM) && !defined(USE_WIFI) && !defined(USE_OPENTHREAD)
+  // Fallback when no network component is defined (e.g., host platform)
+  return "";
+#endif
+}
 IPAddresses get_ip_addresses();
 
 }  // namespace esphome::network
diff --git a/esphome/components/openthread/openthread.cpp b/esphome/components/openthread/openthread.cpp
index 1596b6e990..7c9a308303 100644
--- a/esphome/components/openthread/openthread.cpp
+++ b/esphome/components/openthread/openthread.cpp
@@ -257,11 +257,5 @@ void OpenThreadComponent::on_factory_reset(std::function<void()> callback) {
   ESP_LOGD(TAG, "Waiting on Confirmation Removal SRP Host and Services");
 }
 
-// set_use_address() is guaranteed to be called during component setup by Python code generation,
-// so use_address_ will always be valid when get_use_address() is called - no fallback needed.
-const char *OpenThreadComponent::get_use_address() const { return this->use_address_; }
-
-void OpenThreadComponent::set_use_address(const char *use_address) { this->use_address_ = use_address; }
-
 }  // namespace esphome::openthread
 #endif
diff --git a/esphome/components/openthread/openthread.h b/esphome/components/openthread/openthread.h
index bd10774fcf..b42fdd2d30 100644
--- a/esphome/components/openthread/openthread.h
+++ b/esphome/components/openthread/openthread.h
@@ -37,8 +37,8 @@ class OpenThreadComponent : public Component {
   void on_factory_reset(std::function<void()> callback);
   void defer_factory_reset_external_callback();
 
-  const char *get_use_address() const;
-  void set_use_address(const char *use_address);
+  const char *get_use_address() const { return this->use_address_; }
+  void set_use_address(const char *use_address) { this->use_address_ = use_address; }
 #if CONFIG_OPENTHREAD_MTD
   void set_poll_period(uint32_t poll_period) { this->poll_period_ = poll_period; }
 #endif
diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp
index 08065a7544..0fd1385258 100644
--- a/esphome/components/wifi/wifi_component.cpp
+++ b/esphome/components/wifi/wifi_component.cpp
@@ -891,10 +891,6 @@ network::IPAddress WiFiComponent::get_dns_address(int num) {
     return this->wifi_dns_ip_(num);
   return {};
 }
-// set_use_address() is guaranteed to be called during component setup by Python code generation,
-// so use_address_ will always be valid when get_use_address() is called - no fallback needed.
-const char *WiFiComponent::get_use_address() const { return this->use_address_; }
-void WiFiComponent::set_use_address(const char *use_address) { this->use_address_ = use_address; }
 
 #ifdef USE_WIFI_AP
 void WiFiComponent::setup_ap_config_() {
diff --git a/esphome/components/wifi/wifi_component.h b/esphome/components/wifi/wifi_component.h
index bd202604d6..718f4a6e12 100644
--- a/esphome/components/wifi/wifi_component.h
+++ b/esphome/components/wifi/wifi_component.h
@@ -481,8 +481,8 @@ class WiFiComponent final : public Component {
 
   network::IPAddress get_dns_address(int num);
   network::IPAddresses get_ip_addresses();
-  const char *get_use_address() const;
-  void set_use_address(const char *use_address);
+  const char *get_use_address() const { return this->use_address_; }
+  void set_use_address(const char *use_address) { this->use_address_ = use_address; }
 
   const wifi_scan_vector_t<WiFiScanResult> &get_scan_result() const { return scan_result_; }
 

From e67b5a78d0b4fd4d06ddc347141eb4e19c7d4f10 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 20:51:40 -1000
Subject: [PATCH 37/60] [esp32] Patch DRAM segment for testing mode to fix
 grouped component test overflow (#15102)

---
 esphome/components/esp32/iram_fix.py.script | 70 ++++++++++++---------
 1 file changed, 42 insertions(+), 28 deletions(-)

diff --git a/esphome/components/esp32/iram_fix.py.script b/esphome/components/esp32/iram_fix.py.script
index 0d23f9a81b..b656d7d1a6 100644
--- a/esphome/components/esp32/iram_fix.py.script
+++ b/esphome/components/esp32/iram_fix.py.script
@@ -4,12 +4,40 @@ import re
 # pylint: disable=E0602
 Import("env")  # noqa
 
-# IRAM size for testing mode (2MB - large enough to accommodate grouped tests)
-TESTING_IRAM_SIZE = 0x200000
+# Memory sizes for testing mode (large enough to accommodate grouped tests)
+TESTING_IRAM_SIZE = 0x200000  # 2MB
+TESTING_DRAM_SIZE = 0x200000  # 2MB
+
+
+def patch_segment(content, segment_name, new_size):
+    """Patch a memory segment's length in linker script content.
+
+    Handles both single-line and multi-line segment definitions, e.g.:
+      iram0_0_seg (RX) : org = 0x40080000, len = 0x20000 + 0x0
+    or split across lines:
+      dram0_0_seg (RW) : org = 0x3FFB0000 + 0xdb5c,
+                                       len = 0x2c200 - 0xdb5c
+
+    Args:
+        content: Full linker script content as string
+        segment_name: Name of the segment (e.g., 'iram0_0_seg')
+        new_size: New size as integer
+
+    Returns:
+        Tuple of (new_content, was_patched)
+    """
+    # Match segment name through to "len = <value>" allowing newlines between org and len
+    pattern = rf'({re.escape(segment_name)}\s*\([^)]*\)\s*:\s*org\s*=\s*.+?,\s*len\s*=\s*)(\S+[^\n]*)'
+    if match := re.search(pattern, content, re.DOTALL):
+        replacement = f"{match.group(1)}{new_size:#x}"
+        new_content = content[:match.start()] + replacement + content[match.end():]
+        if new_content != content:
+            return new_content, True
+    return content, False
 
 
 def patch_idf_linker_script(source, target, env):
-    """Patch ESP-IDF linker script to increase IRAM size for testing mode."""
+    """Patch ESP-IDF linker script to increase IRAM and DRAM size for testing mode."""
     # Check if we're in testing mode by looking for the define
     build_flags = env.get("BUILD_FLAGS", [])
     testing_mode = any("-DESPHOME_TESTING_MODE" in flag for flag in build_flags)
@@ -34,36 +62,22 @@ def patch_idf_linker_script(source, target, env):
         print(f"ESPHome: Error reading linker script: {e}")
         return
 
-    # Check if this file contains iram0_0_seg
-    if 'iram0_0_seg' not in content:
-        print(f"ESPHome: Warning - iram0_0_seg not found in {memory_ld}")
-        return
+    patches = []
 
-    # Look for iram0_0_seg definition and increase its length
-    # ESP-IDF format can be:
-    #   iram0_0_seg (RX) : org = 0x40080000, len = 0x20000 + 0x0
-    # or more complex with nested parentheses:
-    #   iram0_0_seg (RX) : org = (0x40370000 + 0x4000), len = (((0x403CB700 - (0x40378000 - 0x3FC88000)) - 0x3FC88000) + 0x8000 - 0x4000)
-    # We want to change len to TESTING_IRAM_SIZE for testing
+    content, patched = patch_segment(content, 'iram0_0_seg', TESTING_IRAM_SIZE)
+    if patched:
+        patches.append(f"IRAM={TESTING_IRAM_SIZE:#x}")
 
-    # Use a more robust approach: find the line and manually parse it
-    lines = content.split('\n')
-    for i, line in enumerate(lines):
-        if 'iram0_0_seg' in line and 'len' in line:
-            # Find the position of "len = " and replace everything after it until the end of the statement
-            match = re.search(r'(iram0_0_seg\s*\([^)]*\)\s*:\s*org\s*=\s*(?:\([^)]+\)|0x[0-9a-fA-F]+)\s*,\s*len\s*=\s*)(.+?)(\s*)$', line)
-            if match:
-                lines[i] = f"{match.group(1)}{TESTING_IRAM_SIZE:#x}{match.group(3)}"
-                break
+    content, patched = patch_segment(content, 'dram0_0_seg', TESTING_DRAM_SIZE)
+    if patched:
+        patches.append(f"DRAM={TESTING_DRAM_SIZE:#x}")
 
-    updated = '\n'.join(lines)
-
-    if updated != content:
+    if patches:
         with open(memory_ld, "w") as f:
-            f.write(updated)
-        print(f"ESPHome: Patched IRAM size to {TESTING_IRAM_SIZE:#x} in {memory_ld} for testing mode")
+            f.write(content)
+        print(f"ESPHome: Patched {', '.join(patches)} in {memory_ld} for testing mode")
     else:
-        print(f"ESPHome: Warning - could not patch iram0_0_seg in {memory_ld}")
+        print(f"ESPHome: Warning - could not patch memory segments in {memory_ld}")
 
 
 # Hook into the build process before linking

From 225330413a137acbff12e81127b983ad05d92e00 Mon Sep 17 00:00:00 2001
From: Keith Burzinski <kbx81x@gmail.com>
Date: Mon, 23 Mar 2026 01:55:14 -0500
Subject: [PATCH 38/60] [uart] Rename `FlushResult` to `UARTFlushResult` with
 `UART_FLUSH_RESULT_` prefix (#15101)

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 esphome/components/api/api_connection.cpp     |  8 ++++----
 esphome/components/ble_nus/ble_nus.cpp        |  6 +++---
 esphome/components/ble_nus/ble_nus.h          |  2 +-
 .../components/serial_proxy/serial_proxy.cpp  |  2 +-
 .../components/serial_proxy/serial_proxy.h    |  2 +-
 esphome/components/uart/uart.h                |  2 +-
 esphome/components/uart/uart_component.h      | 19 +++++++------------
 .../uart/uart_component_esp8266.cpp           |  4 ++--
 .../components/uart/uart_component_esp8266.h  |  2 +-
 .../uart/uart_component_esp_idf.cpp           |  8 ++++----
 .../components/uart/uart_component_esp_idf.h  |  2 +-
 .../components/uart/uart_component_host.cpp   |  6 +++---
 esphome/components/uart/uart_component_host.h |  2 +-
 .../uart/uart_component_libretiny.cpp         |  4 ++--
 .../uart/uart_component_libretiny.h           |  2 +-
 .../components/uart/uart_component_rp2040.cpp |  4 ++--
 .../components/uart/uart_component_rp2040.h   |  2 +-
 esphome/components/usb_cdc_acm/usb_cdc_acm.h  |  2 +-
 .../usb_cdc_acm/usb_cdc_acm_esp32.cpp         | 10 +++++-----
 esphome/components/usb_uart/usb_uart.cpp      |  6 +++---
 esphome/components/usb_uart/usb_uart.h        |  2 +-
 esphome/components/weikai/weikai.cpp          |  6 +++---
 esphome/components/weikai/weikai.h            |  2 +-
 tests/components/ld2450/common.h              |  2 +-
 tests/components/uart/common.h                |  2 +-
 .../uart_mock/uart_mock.cpp                   |  4 ++--
 .../external_components/uart_mock/uart_mock.h |  2 +-
 27 files changed, 55 insertions(+), 60 deletions(-)

diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 40c27b224b..82d7e3f674 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -1519,16 +1519,16 @@ void APIConnection::on_serial_proxy_request(const SerialProxyRequest &msg) {
       resp.instance = msg.instance;
       resp.type = enums::SERIAL_PROXY_REQUEST_TYPE_FLUSH;
       switch (proxies[msg.instance]->flush_port()) {
-        case uart::FlushResult::SUCCESS:
+        case uart::UARTFlushResult::UART_FLUSH_RESULT_SUCCESS:
           resp.status = enums::SERIAL_PROXY_STATUS_OK;
           break;
-        case uart::FlushResult::ASSUMED_SUCCESS:
+        case uart::UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS:
           resp.status = enums::SERIAL_PROXY_STATUS_ASSUMED_SUCCESS;
           break;
-        case uart::FlushResult::TIMEOUT:
+        case uart::UARTFlushResult::UART_FLUSH_RESULT_TIMEOUT:
           resp.status = enums::SERIAL_PROXY_STATUS_TIMEOUT;
           break;
-        case uart::FlushResult::FAILED:
+        case uart::UARTFlushResult::UART_FLUSH_RESULT_FAILED:
           resp.status = enums::SERIAL_PROXY_STATUS_ERROR;
           break;
       }
diff --git a/esphome/components/ble_nus/ble_nus.cpp b/esphome/components/ble_nus/ble_nus.cpp
index 2f60f81471..71d98332e0 100644
--- a/esphome/components/ble_nus/ble_nus.cpp
+++ b/esphome/components/ble_nus/ble_nus.cpp
@@ -103,17 +103,17 @@ size_t BLENUS::available() {
 #endif
 }
 
-uart::FlushResult BLENUS::flush() {
+uart::UARTFlushResult BLENUS::flush() {
   constexpr uint32_t timeout_500ms = 500;
   uint32_t start = millis();
   while (atomic_get(&this->tx_status_) != TX_DISABLED && !ring_buf_is_empty(&global_ble_tx_ring_buf)) {
     if (millis() - start > timeout_500ms) {
       ESP_LOGW(TAG, "Flush timeout");
-      return uart::FlushResult::TIMEOUT;
+      return uart::UARTFlushResult::UART_FLUSH_RESULT_TIMEOUT;
     }
     delay(1);
   }
-  return uart::FlushResult::SUCCESS;
+  return uart::UARTFlushResult::UART_FLUSH_RESULT_SUCCESS;
 }
 
 void BLENUS::connected(bt_conn *conn, uint8_t err) {
diff --git a/esphome/components/ble_nus/ble_nus.h b/esphome/components/ble_nus/ble_nus.h
index b482c240e5..f1afd54af9 100644
--- a/esphome/components/ble_nus/ble_nus.h
+++ b/esphome/components/ble_nus/ble_nus.h
@@ -26,7 +26,7 @@ class BLENUS : public uart::UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
   size_t available() override;
-  uart::FlushResult flush() override;
+  uart::UARTFlushResult flush() override;
   void check_logger_conflict() override {}
   void set_expose_log(bool expose_log) { this->expose_log_ = expose_log; }
 #ifdef USE_LOGGER
diff --git a/esphome/components/serial_proxy/serial_proxy.cpp b/esphome/components/serial_proxy/serial_proxy.cpp
index 00d822b75c..f3c256c62a 100644
--- a/esphome/components/serial_proxy/serial_proxy.cpp
+++ b/esphome/components/serial_proxy/serial_proxy.cpp
@@ -165,7 +165,7 @@ uint32_t SerialProxy::get_modem_pins() const {
          (this->dtr_state_ ? SERIAL_PROXY_LINE_STATE_FLAG_DTR : 0u);
 }
 
-uart::FlushResult SerialProxy::flush_port() {
+uart::UARTFlushResult SerialProxy::flush_port() {
   ESP_LOGV(TAG, "Flushing serial proxy [%u]", this->instance_index_);
   return this->flush();
 }
diff --git a/esphome/components/serial_proxy/serial_proxy.h b/esphome/components/serial_proxy/serial_proxy.h
index 5adfa4fe53..c435787a61 100644
--- a/esphome/components/serial_proxy/serial_proxy.h
+++ b/esphome/components/serial_proxy/serial_proxy.h
@@ -92,7 +92,7 @@ class SerialProxy : public uart::UARTDevice, public Component {
   uint32_t get_modem_pins() const;
 
   /// Flush the serial port (block until all TX data is sent)
-  uart::FlushResult flush_port();
+  uart::UARTFlushResult flush_port();
 
   /// Set the RTS GPIO pin (from YAML configuration)
   void set_rts_pin(GPIOPin *pin) { this->rts_pin_ = pin; }
diff --git a/esphome/components/uart/uart.h b/esphome/components/uart/uart.h
index 2c4fb34c9a..899d349e21 100644
--- a/esphome/components/uart/uart.h
+++ b/esphome/components/uart/uart.h
@@ -45,7 +45,7 @@ class UARTDevice {
 
   size_t available() { return this->parent_->available(); }
 
-  FlushResult flush() { return this->parent_->flush(); }
+  UARTFlushResult flush() { return this->parent_->flush(); }
 
   // Compat APIs
   int read() {
diff --git a/esphome/components/uart/uart_component.h b/esphome/components/uart/uart_component.h
index 00a4c78878..abc77fbae8 100644
--- a/esphome/components/uart/uart_component.h
+++ b/esphome/components/uart/uart_component.h
@@ -30,17 +30,12 @@ enum UARTDirection {
 const LogString *parity_to_str(UARTParityOptions parity);
 
 /// Result of a flush() call.
-// Some vendor SDKs (e.g., Realtek) define SUCCESS as a macro.
-// Save and restore around the enum to avoid collisions with our scoped enum value.
-#pragma push_macro("SUCCESS")
-#undef SUCCESS
-enum class FlushResult {
-  SUCCESS,          ///< Confirmed: all bytes left the TX FIFO.
-  TIMEOUT,          ///< Confirmed: timed out before TX completed.
-  FAILED,           ///< Confirmed: driver or hardware error.
-  ASSUMED_SUCCESS,  ///< Platform cannot report result; success is assumed.
+enum class UARTFlushResult {
+  UART_FLUSH_RESULT_SUCCESS,          ///< Confirmed: all bytes left the TX FIFO.
+  UART_FLUSH_RESULT_TIMEOUT,          ///< Confirmed: timed out before TX completed.
+  UART_FLUSH_RESULT_FAILED,           ///< Confirmed: driver or hardware error.
+  UART_FLUSH_RESULT_ASSUMED_SUCCESS,  ///< Platform cannot report result; success is assumed.
 };
-#pragma pop_macro("SUCCESS")
 
 class UARTComponent {
  public:
@@ -87,8 +82,8 @@ class UARTComponent {
   virtual size_t available() = 0;
 
   // Pure virtual method to block until all bytes have been written to the UART bus.
-  // @return FlushResult indicating whether the flush was confirmed, timed out, failed, or assumed successful.
-  virtual FlushResult flush() = 0;
+  // @return UARTFlushResult indicating whether the flush was confirmed, timed out, failed, or assumed successful.
+  virtual UARTFlushResult flush() = 0;
 
   // Sets the maximum time to wait for TX to drain during flush().
   // Only meaningful on ESP32 (IDF). Other platforms ignore this value.
diff --git a/esphome/components/uart/uart_component_esp8266.cpp b/esphome/components/uart/uart_component_esp8266.cpp
index 91218c4300..0ea7930760 100644
--- a/esphome/components/uart/uart_component_esp8266.cpp
+++ b/esphome/components/uart/uart_component_esp8266.cpp
@@ -213,14 +213,14 @@ size_t ESP8266UartComponent::available() {
     return this->sw_serial_->available();
   }
 }
-FlushResult ESP8266UartComponent::flush() {
+UARTFlushResult ESP8266UartComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
   if (this->hw_serial_ != nullptr) {
     this->hw_serial_->flush();
   } else {
     this->sw_serial_->flush();
   }
-  return FlushResult::ASSUMED_SUCCESS;
+  return UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS;
 }
 void ESP8266SoftwareSerial::setup(InternalGPIOPin *tx_pin, InternalGPIOPin *rx_pin, uint32_t baud_rate,
                                   uint8_t stop_bits, uint32_t data_bits, UARTParityOptions parity,
diff --git a/esphome/components/uart/uart_component_esp8266.h b/esphome/components/uart/uart_component_esp8266.h
index ca90dc5964..7f844d9b65 100644
--- a/esphome/components/uart/uart_component_esp8266.h
+++ b/esphome/components/uart/uart_component_esp8266.h
@@ -58,7 +58,7 @@ class ESP8266UartComponent : public UARTComponent, public Component {
   bool read_array(uint8_t *data, size_t len) override;
 
   size_t available() override;
-  FlushResult flush() override;
+  UARTFlushResult flush() override;
 
   uint32_t get_config();
 
diff --git a/esphome/components/uart/uart_component_esp_idf.cpp b/esphome/components/uart/uart_component_esp_idf.cpp
index 8168e49805..bd2f915d3a 100644
--- a/esphome/components/uart/uart_component_esp_idf.cpp
+++ b/esphome/components/uart/uart_component_esp_idf.cpp
@@ -360,15 +360,15 @@ size_t IDFUARTComponent::available() {
   return available;
 }
 
-FlushResult IDFUARTComponent::flush() {
+UARTFlushResult IDFUARTComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
   TickType_t ticks = this->flush_timeout_ms_ == 0 ? portMAX_DELAY : pdMS_TO_TICKS(this->flush_timeout_ms_);
   esp_err_t err = uart_wait_tx_done(this->uart_num_, ticks);
   if (err == ESP_OK)
-    return FlushResult::SUCCESS;
+    return UARTFlushResult::UART_FLUSH_RESULT_SUCCESS;
   if (err == ESP_ERR_TIMEOUT)
-    return FlushResult::TIMEOUT;
-  return FlushResult::FAILED;
+    return UARTFlushResult::UART_FLUSH_RESULT_TIMEOUT;
+  return UARTFlushResult::UART_FLUSH_RESULT_FAILED;
 }
 
 void IDFUARTComponent::check_logger_conflict() {}
diff --git a/esphome/components/uart/uart_component_esp_idf.h b/esphome/components/uart/uart_component_esp_idf.h
index 9fa2013cfd..ec4f2884b2 100644
--- a/esphome/components/uart/uart_component_esp_idf.h
+++ b/esphome/components/uart/uart_component_esp_idf.h
@@ -31,7 +31,7 @@ class IDFUARTComponent : public UARTComponent, public Component {
   bool read_array(uint8_t *data, size_t len) override;
 
   size_t available() override;
-  FlushResult flush() override;
+  UARTFlushResult flush() override;
 
   void set_flush_timeout(uint32_t flush_timeout_ms) override { this->flush_timeout_ms_ = flush_timeout_ms; }
 
diff --git a/esphome/components/uart/uart_component_host.cpp b/esphome/components/uart/uart_component_host.cpp
index 66026f3ccd..0042ffae23 100644
--- a/esphome/components/uart/uart_component_host.cpp
+++ b/esphome/components/uart/uart_component_host.cpp
@@ -274,13 +274,13 @@ size_t HostUartComponent::available() {
   return result;
 };
 
-FlushResult HostUartComponent::flush() {
+UARTFlushResult HostUartComponent::flush() {
   if (this->file_descriptor_ == -1) {
-    return FlushResult::ASSUMED_SUCCESS;
+    return UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS;
   }
   tcflush(this->file_descriptor_, TCIOFLUSH);
   ESP_LOGV(TAG, "    Flushing");
-  return FlushResult::ASSUMED_SUCCESS;
+  return UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS;
 }
 
 void HostUartComponent::update_error_(const std::string &error) {
diff --git a/esphome/components/uart/uart_component_host.h b/esphome/components/uart/uart_component_host.h
index c22efdcb92..56ff525bc3 100644
--- a/esphome/components/uart/uart_component_host.h
+++ b/esphome/components/uart/uart_component_host.h
@@ -18,7 +18,7 @@ class HostUartComponent : public UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
   size_t available() override;
-  FlushResult flush() override;
+  UARTFlushResult flush() override;
   void set_name(std::string port_name) { port_name_ = port_name; };
 
  protected:
diff --git a/esphome/components/uart/uart_component_libretiny.cpp b/esphome/components/uart/uart_component_libretiny.cpp
index 6a550f296a..4172e7c164 100644
--- a/esphome/components/uart/uart_component_libretiny.cpp
+++ b/esphome/components/uart/uart_component_libretiny.cpp
@@ -170,10 +170,10 @@ bool LibreTinyUARTComponent::read_array(uint8_t *data, size_t len) {
 }
 
 size_t LibreTinyUARTComponent::available() { return this->serial_->available(); }
-FlushResult LibreTinyUARTComponent::flush() {
+UARTFlushResult LibreTinyUARTComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
   this->serial_->flush();
-  return FlushResult::ASSUMED_SUCCESS;
+  return UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS;
 }
 
 void LibreTinyUARTComponent::check_logger_conflict() {
diff --git a/esphome/components/uart/uart_component_libretiny.h b/esphome/components/uart/uart_component_libretiny.h
index 77df808067..872ea86601 100644
--- a/esphome/components/uart/uart_component_libretiny.h
+++ b/esphome/components/uart/uart_component_libretiny.h
@@ -22,7 +22,7 @@ class LibreTinyUARTComponent : public UARTComponent, public Component {
   bool read_array(uint8_t *data, size_t len) override;
 
   size_t available() override;
-  FlushResult flush() override;
+  UARTFlushResult flush() override;
 
   uint16_t get_config();
 
diff --git a/esphome/components/uart/uart_component_rp2040.cpp b/esphome/components/uart/uart_component_rp2040.cpp
index 6f6f1fb96b..1aaf98dc84 100644
--- a/esphome/components/uart/uart_component_rp2040.cpp
+++ b/esphome/components/uart/uart_component_rp2040.cpp
@@ -208,10 +208,10 @@ bool RP2040UartComponent::read_array(uint8_t *data, size_t len) {
   return true;
 }
 size_t RP2040UartComponent::available() { return this->serial_->available(); }
-FlushResult RP2040UartComponent::flush() {
+UARTFlushResult RP2040UartComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
   this->serial_->flush();
-  return FlushResult::ASSUMED_SUCCESS;
+  return UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS;
 }
 
 }  // namespace esphome::uart
diff --git a/esphome/components/uart/uart_component_rp2040.h b/esphome/components/uart/uart_component_rp2040.h
index 891212ca74..198c698af9 100644
--- a/esphome/components/uart/uart_component_rp2040.h
+++ b/esphome/components/uart/uart_component_rp2040.h
@@ -25,7 +25,7 @@ class RP2040UartComponent : public UARTComponent, public Component {
   bool read_array(uint8_t *data, size_t len) override;
 
   size_t available() override;
-  FlushResult flush() override;
+  UARTFlushResult flush() override;
 
   uint16_t get_config();
 
diff --git a/esphome/components/usb_cdc_acm/usb_cdc_acm.h b/esphome/components/usb_cdc_acm/usb_cdc_acm.h
index a56abc9ee8..89405ab893 100644
--- a/esphome/components/usb_cdc_acm/usb_cdc_acm.h
+++ b/esphome/components/usb_cdc_acm/usb_cdc_acm.h
@@ -82,7 +82,7 @@ class USBCDCACMInstance : public uart::UARTComponent, public Parented<USBCDCACMC
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
   size_t available() override;
-  uart::FlushResult flush() override;
+  uart::UARTFlushResult flush() override;
 
  protected:
   void check_logger_conflict() override;
diff --git a/esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp b/esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp
index 583aa77d06..5498c38515 100644
--- a/esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp
+++ b/esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp
@@ -325,10 +325,10 @@ size_t USBCDCACMInstance::available() {
   return waiting + (this->has_peek_ ? 1 : 0);
 }
 
-uart::FlushResult USBCDCACMInstance::flush() {
+uart::UARTFlushResult USBCDCACMInstance::flush() {
   // Wait for TX ring buffer to be empty
   if (this->usb_tx_ringbuf_ == nullptr) {
-    return uart::FlushResult::ASSUMED_SUCCESS;
+    return uart::UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS;
   }
 
   UBaseType_t waiting = 1;
@@ -342,10 +342,10 @@ uart::FlushResult USBCDCACMInstance::flush() {
   // Also wait for USB to finish transmitting
   esp_err_t err = tinyusb_cdcacm_write_flush(static_cast<tinyusb_cdcacm_itf_t>(this->itf_), pdMS_TO_TICKS(100));
   if (err == ESP_OK)
-    return uart::FlushResult::SUCCESS;
+    return uart::UARTFlushResult::UART_FLUSH_RESULT_SUCCESS;
   if (err == ESP_ERR_TIMEOUT)
-    return uart::FlushResult::TIMEOUT;
-  return uart::FlushResult::FAILED;
+    return uart::UARTFlushResult::UART_FLUSH_RESULT_TIMEOUT;
+  return uart::UARTFlushResult::UART_FLUSH_RESULT_FAILED;
 }
 
 void USBCDCACMInstance::check_logger_conflict() {}
diff --git a/esphome/components/usb_uart/usb_uart.cpp b/esphome/components/usb_uart/usb_uart.cpp
index a5d312f191..0b8589f671 100644
--- a/esphome/components/usb_uart/usb_uart.cpp
+++ b/esphome/components/usb_uart/usb_uart.cpp
@@ -169,7 +169,7 @@ void USBUartChannel::write_array(const uint8_t *data, size_t len) {
   this->parent_->start_output(this);
 }
 
-uart::FlushResult USBUartChannel::flush() {
+uart::UARTFlushResult USBUartChannel::flush() {
   // Spin until the output queue is drained and the last USB transfer completes.
   // Safe to call from the main loop only.
   // The flush_timeout_ms_ timeout guards against a device that stops responding mid-flush;
@@ -181,8 +181,8 @@ uart::FlushResult USBUartChannel::flush() {
     yield();
   }
   if (!this->output_queue_.empty() || this->output_started_.load())
-    return uart::FlushResult::TIMEOUT;
-  return uart::FlushResult::SUCCESS;
+    return uart::UARTFlushResult::UART_FLUSH_RESULT_TIMEOUT;
+  return uart::UARTFlushResult::UART_FLUSH_RESULT_SUCCESS;
 }
 
 bool USBUartChannel::peek_byte(uint8_t *data) {
diff --git a/esphome/components/usb_uart/usb_uart.h b/esphome/components/usb_uart/usb_uart.h
index 7a06b04f11..8a47f0cf4b 100644
--- a/esphome/components/usb_uart/usb_uart.h
+++ b/esphome/components/usb_uart/usb_uart.h
@@ -140,7 +140,7 @@ class USBUartChannel : public uart::UARTComponent, public Parented<USBUartCompon
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
   size_t available() override { return this->input_buffer_.get_available(); }
-  uart::FlushResult flush() override;
+  uart::UARTFlushResult flush() override;
   void check_logger_conflict() override {}
   void set_parity(UARTParityOptions parity) { this->parity_ = parity; }
   void set_debug(bool debug) { this->debug_ = debug; }
diff --git a/esphome/components/weikai/weikai.cpp b/esphome/components/weikai/weikai.cpp
index f01d164e9f..2ec5632691 100644
--- a/esphome/components/weikai/weikai.cpp
+++ b/esphome/components/weikai/weikai.cpp
@@ -433,16 +433,16 @@ void WeikaiChannel::write_array(const uint8_t *buffer, size_t length) {
   this->reg(0).write_fifo(const_cast<uint8_t *>(buffer), length);
 }
 
-uart::FlushResult WeikaiChannel::flush() {
+uart::UARTFlushResult WeikaiChannel::flush() {
   uint32_t const start_time = millis();
   while (this->tx_fifo_is_not_empty_()) {  // wait until buffer empty
     if (millis() - start_time > 200) {
       ESP_LOGW(TAG, "WARNING flush timeout - still %d bytes not sent after 200 ms", this->tx_in_fifo_());
-      return uart::FlushResult::TIMEOUT;
+      return uart::UARTFlushResult::UART_FLUSH_RESULT_TIMEOUT;
     }
     yield();  // reschedule our thread to avoid blocking
   }
-  return uart::FlushResult::SUCCESS;
+  return uart::UARTFlushResult::UART_FLUSH_RESULT_SUCCESS;
 }
 
 size_t WeikaiChannel::xfer_fifo_to_buffer_() {
diff --git a/esphome/components/weikai/weikai.h b/esphome/components/weikai/weikai.h
index 715b82bfc7..36d8f66265 100644
--- a/esphome/components/weikai/weikai.h
+++ b/esphome/components/weikai/weikai.h
@@ -380,7 +380,7 @@ class WeikaiChannel : public uart::UARTComponent {
   /// @details If we refer to Serial.flush() in Arduino it says: ** Waits for the transmission of outgoing serial data
   /// to complete. (Prior to Arduino 1.0, this the method was removing any buffered incoming serial data.). ** Therefore
   /// we wait until all bytes are gone with a timeout of 100 ms
-  uart::FlushResult flush() override;
+  uart::UARTFlushResult flush() override;
 
  protected:
   friend class WeikaiComponent;
diff --git a/tests/components/ld2450/common.h b/tests/components/ld2450/common.h
index 9f9e7b3e9f..304634edca 100644
--- a/tests/components/ld2450/common.h
+++ b/tests/components/ld2450/common.h
@@ -16,7 +16,7 @@ class MockUARTComponent : public uart::UARTComponent {
   MOCK_METHOD(bool, read_array, (uint8_t * data, size_t len), (override));
   MOCK_METHOD(bool, peek_byte, (uint8_t * data), (override));
   MOCK_METHOD(size_t, available, (), (override));
-  MOCK_METHOD(uart::FlushResult, flush, (), (override));
+  MOCK_METHOD(uart::UARTFlushResult, flush, (), (override));
   MOCK_METHOD(void, check_logger_conflict, (), (override));
 };
 
diff --git a/tests/components/uart/common.h b/tests/components/uart/common.h
index f7e2d8a3f7..de3ea3029e 100644
--- a/tests/components/uart/common.h
+++ b/tests/components/uart/common.h
@@ -30,7 +30,7 @@ class MockUARTComponent : public UARTComponent {
   MOCK_METHOD(bool, read_array, (uint8_t * data, size_t len), (override));
   MOCK_METHOD(bool, peek_byte, (uint8_t * data), (override));
   MOCK_METHOD(size_t, available, (), (override));
-  MOCK_METHOD(FlushResult, flush, (), (override));
+  MOCK_METHOD(UARTFlushResult, flush, (), (override));
   MOCK_METHOD(void, check_logger_conflict, (), (override));
 };
 
diff --git a/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp b/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp
index 1a15da76d1..d0690e7515 100644
--- a/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp
+++ b/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp
@@ -153,9 +153,9 @@ bool MockUartComponent::read_array(uint8_t *data, size_t len) {
 
 size_t MockUartComponent::available() { return this->rx_buffer_.size(); }
 
-uart::FlushResult MockUartComponent::flush() {
+uart::UARTFlushResult MockUartComponent::flush() {
   // Nothing to flush in mock
-  return uart::FlushResult::ASSUMED_SUCCESS;
+  return uart::UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS;
 }
 
 void MockUartComponent::set_rx_full_threshold(size_t rx_full_threshold) {
diff --git a/tests/integration/fixtures/external_components/uart_mock/uart_mock.h b/tests/integration/fixtures/external_components/uart_mock/uart_mock.h
index 82e3b3d563..0b3b49893d 100644
--- a/tests/integration/fixtures/external_components/uart_mock/uart_mock.h
+++ b/tests/integration/fixtures/external_components/uart_mock/uart_mock.h
@@ -28,7 +28,7 @@ class MockUartComponent : public uart::UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
   size_t available() override;
-  uart::FlushResult flush() override;
+  uart::UARTFlushResult flush() override;
   void set_rx_full_threshold(size_t rx_full_threshold) override;
   void set_rx_timeout(size_t rx_timeout) override;
 

From f4097d5a95a37faa963ec2d8ad1588b70b259e3c Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 20:57:40 -1000
Subject: [PATCH 39/60] [api] Devirtualize API command dispatch (#15044)

---
 esphome/components/api/api_connection.cpp  |   2 +-
 esphome/components/api/api_connection.h    | 156 ++++++++++++---------
 esphome/components/api/api_pb2_service.cpp |   3 +-
 esphome/components/api/api_pb2_service.h   | 134 +++++++++---------
 esphome/components/api/proto.h             |  23 +--
 script/api_protobuf/api_protobuf.py        |  13 +-
 6 files changed, 164 insertions(+), 167 deletions(-)

diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 82d7e3f674..d023cd21a8 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -234,7 +234,7 @@ void APIConnection::loop() {
           this->last_traffic_ = now;
         }
         // read a packet
-        this->read_message(buffer.data_len, buffer.type, buffer.data);
+        this->read_message_(buffer.data_len, buffer.type, buffer.data);
         if (this->flags_.remove)
           return;
       }
diff --git a/esphome/components/api/api_connection.h b/esphome/components/api/api_connection.h
index 85c8e777a9..3d8563b1ae 100644
--- a/esphome/components/api/api_connection.h
+++ b/esphome/components/api/api_connection.h
@@ -49,11 +49,29 @@ class APIConnection final : public APIServerConnectionBase {
   friend class APIServer;
   friend class ListEntitiesIterator;
   APIConnection(std::unique_ptr<socket::Socket> socket, APIServer *parent);
-  virtual ~APIConnection();
+  ~APIConnection();
 
   void start();
   void loop();
 
+ protected:
+  // read_message_ is defined here (instead of in APIServerConnectionBase) so the
+  // compiler can devirtualize and inline on_* handler calls within this final class.
+  void read_message_(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data);
+
+  // Auth helpers defined here (not in ProtoService) so the compiler can
+  // devirtualize is_connection_setup()/on_no_setup_connection() calls
+  // within this final class.
+  inline bool check_connection_setup_() {
+    if (!this->is_connection_setup()) {
+      this->on_no_setup_connection();
+      return false;
+    }
+    return true;
+  }
+  inline bool check_authenticated_() { return this->check_connection_setup_(); }
+
+ public:
   bool send_list_info_done() {
     return this->schedule_message_(nullptr, ListEntitiesDoneResponse::MESSAGE_TYPE,
                                    ListEntitiesDoneResponse::ESTIMATED_SIZE);
@@ -63,72 +81,72 @@ class APIConnection final : public APIServerConnectionBase {
 #endif
 #ifdef USE_COVER
   bool send_cover_state(cover::Cover *cover);
-  void on_cover_command_request(const CoverCommandRequest &msg) override;
+  void on_cover_command_request(const CoverCommandRequest &msg);
 #endif
 #ifdef USE_FAN
   bool send_fan_state(fan::Fan *fan);
-  void on_fan_command_request(const FanCommandRequest &msg) override;
+  void on_fan_command_request(const FanCommandRequest &msg);
 #endif
 #ifdef USE_LIGHT
   bool send_light_state(light::LightState *light);
-  void on_light_command_request(const LightCommandRequest &msg) override;
+  void on_light_command_request(const LightCommandRequest &msg);
 #endif
 #ifdef USE_SENSOR
   bool send_sensor_state(sensor::Sensor *sensor);
 #endif
 #ifdef USE_SWITCH
   bool send_switch_state(switch_::Switch *a_switch);
-  void on_switch_command_request(const SwitchCommandRequest &msg) override;
+  void on_switch_command_request(const SwitchCommandRequest &msg);
 #endif
 #ifdef USE_TEXT_SENSOR
   bool send_text_sensor_state(text_sensor::TextSensor *text_sensor);
 #endif
 #ifdef USE_CAMERA
   void set_camera_state(std::shared_ptr<camera::CameraImage> image);
-  void on_camera_image_request(const CameraImageRequest &msg) override;
+  void on_camera_image_request(const CameraImageRequest &msg);
 #endif
 #ifdef USE_CLIMATE
   bool send_climate_state(climate::Climate *climate);
-  void on_climate_command_request(const ClimateCommandRequest &msg) override;
+  void on_climate_command_request(const ClimateCommandRequest &msg);
 #endif
 #ifdef USE_NUMBER
   bool send_number_state(number::Number *number);
-  void on_number_command_request(const NumberCommandRequest &msg) override;
+  void on_number_command_request(const NumberCommandRequest &msg);
 #endif
 #ifdef USE_DATETIME_DATE
   bool send_date_state(datetime::DateEntity *date);
-  void on_date_command_request(const DateCommandRequest &msg) override;
+  void on_date_command_request(const DateCommandRequest &msg);
 #endif
 #ifdef USE_DATETIME_TIME
   bool send_time_state(datetime::TimeEntity *time);
-  void on_time_command_request(const TimeCommandRequest &msg) override;
+  void on_time_command_request(const TimeCommandRequest &msg);
 #endif
 #ifdef USE_DATETIME_DATETIME
   bool send_datetime_state(datetime::DateTimeEntity *datetime);
-  void on_date_time_command_request(const DateTimeCommandRequest &msg) override;
+  void on_date_time_command_request(const DateTimeCommandRequest &msg);
 #endif
 #ifdef USE_TEXT
   bool send_text_state(text::Text *text);
-  void on_text_command_request(const TextCommandRequest &msg) override;
+  void on_text_command_request(const TextCommandRequest &msg);
 #endif
 #ifdef USE_SELECT
   bool send_select_state(select::Select *select);
-  void on_select_command_request(const SelectCommandRequest &msg) override;
+  void on_select_command_request(const SelectCommandRequest &msg);
 #endif
 #ifdef USE_BUTTON
-  void on_button_command_request(const ButtonCommandRequest &msg) override;
+  void on_button_command_request(const ButtonCommandRequest &msg);
 #endif
 #ifdef USE_LOCK
   bool send_lock_state(lock::Lock *a_lock);
-  void on_lock_command_request(const LockCommandRequest &msg) override;
+  void on_lock_command_request(const LockCommandRequest &msg);
 #endif
 #ifdef USE_VALVE
   bool send_valve_state(valve::Valve *valve);
-  void on_valve_command_request(const ValveCommandRequest &msg) override;
+  void on_valve_command_request(const ValveCommandRequest &msg);
 #endif
 #ifdef USE_MEDIA_PLAYER
   bool send_media_player_state(media_player::MediaPlayer *media_player);
-  void on_media_player_command_request(const MediaPlayerCommandRequest &msg) override;
+  void on_media_player_command_request(const MediaPlayerCommandRequest &msg);
 #endif
   bool try_send_log_message(int level, const char *tag, const char *line, size_t message_len);
 #ifdef USE_API_HOMEASSISTANT_SERVICES
@@ -138,23 +156,23 @@ class APIConnection final : public APIServerConnectionBase {
     this->send_message(call);
   }
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  void on_homeassistant_action_response(const HomeassistantActionResponse &msg) override;
+  void on_homeassistant_action_response(const HomeassistantActionResponse &msg);
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #endif  // USE_API_HOMEASSISTANT_SERVICES
 #ifdef USE_BLUETOOTH_PROXY
-  void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
-  void on_unsubscribe_bluetooth_le_advertisements_request() override;
+  void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg);
+  void on_unsubscribe_bluetooth_le_advertisements_request();
 
-  void on_bluetooth_device_request(const BluetoothDeviceRequest &msg) override;
-  void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &msg) override;
-  void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &msg) override;
-  void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &msg) override;
-  void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &msg) override;
-  void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &msg) override;
-  void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &msg) override;
-  void on_subscribe_bluetooth_connections_free_request() override;
-  void on_bluetooth_scanner_set_mode_request(const BluetoothScannerSetModeRequest &msg) override;
-  void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &msg) override;
+  void on_bluetooth_device_request(const BluetoothDeviceRequest &msg);
+  void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &msg);
+  void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &msg);
+  void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &msg);
+  void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &msg);
+  void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &msg);
+  void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &msg);
+  void on_subscribe_bluetooth_connections_free_request();
+  void on_bluetooth_scanner_set_mode_request(const BluetoothScannerSetModeRequest &msg);
+  void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &msg);
 
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
@@ -165,42 +183,42 @@ class APIConnection final : public APIServerConnectionBase {
 #endif
 
 #ifdef USE_VOICE_ASSISTANT
-  void on_subscribe_voice_assistant_request(const SubscribeVoiceAssistantRequest &msg) override;
-  void on_voice_assistant_response(const VoiceAssistantResponse &msg) override;
-  void on_voice_assistant_event_response(const VoiceAssistantEventResponse &msg) override;
-  void on_voice_assistant_audio(const VoiceAssistantAudio &msg) override;
-  void on_voice_assistant_timer_event_response(const VoiceAssistantTimerEventResponse &msg) override;
-  void on_voice_assistant_announce_request(const VoiceAssistantAnnounceRequest &msg) override;
-  void on_voice_assistant_configuration_request(const VoiceAssistantConfigurationRequest &msg) override;
-  void on_voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &msg) override;
+  void on_subscribe_voice_assistant_request(const SubscribeVoiceAssistantRequest &msg);
+  void on_voice_assistant_response(const VoiceAssistantResponse &msg);
+  void on_voice_assistant_event_response(const VoiceAssistantEventResponse &msg);
+  void on_voice_assistant_audio(const VoiceAssistantAudio &msg);
+  void on_voice_assistant_timer_event_response(const VoiceAssistantTimerEventResponse &msg);
+  void on_voice_assistant_announce_request(const VoiceAssistantAnnounceRequest &msg);
+  void on_voice_assistant_configuration_request(const VoiceAssistantConfigurationRequest &msg);
+  void on_voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &msg);
 #endif
 
 #ifdef USE_ZWAVE_PROXY
-  void on_z_wave_proxy_frame(const ZWaveProxyFrame &msg) override;
-  void on_z_wave_proxy_request(const ZWaveProxyRequest &msg) override;
+  void on_z_wave_proxy_frame(const ZWaveProxyFrame &msg);
+  void on_z_wave_proxy_request(const ZWaveProxyRequest &msg);
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
   bool send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
-  void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &msg) override;
+  void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &msg);
 #endif
 
 #ifdef USE_WATER_HEATER
   bool send_water_heater_state(water_heater::WaterHeater *water_heater);
-  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
+  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg);
 #endif
 
 #ifdef USE_IR_RF
-  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg) override;
+  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg);
   void send_infrared_rf_receive_event(const InfraredRFReceiveEvent &msg);
 #endif
 
 #ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &msg) override;
-  void on_serial_proxy_write_request(const SerialProxyWriteRequest &msg) override;
-  void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &msg) override;
-  void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg) override;
-  void on_serial_proxy_request(const SerialProxyRequest &msg) override;
+  void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &msg);
+  void on_serial_proxy_write_request(const SerialProxyWriteRequest &msg);
+  void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &msg);
+  void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg);
+  void on_serial_proxy_request(const SerialProxyRequest &msg);
   void send_serial_proxy_data(const SerialProxyDataReceived &msg);
 #endif
 
@@ -210,26 +228,26 @@ class APIConnection final : public APIServerConnectionBase {
 
 #ifdef USE_UPDATE
   bool send_update_state(update::UpdateEntity *update);
-  void on_update_command_request(const UpdateCommandRequest &msg) override;
+  void on_update_command_request(const UpdateCommandRequest &msg);
 #endif
 
-  void on_disconnect_response() override;
-  void on_ping_response() override {
+  void on_disconnect_response();
+  void on_ping_response() {
     // we initiated ping
     this->flags_.sent_ping = false;
   }
 #ifdef USE_API_HOMEASSISTANT_STATES
-  void on_home_assistant_state_response(const HomeAssistantStateResponse &msg) override;
+  void on_home_assistant_state_response(const HomeAssistantStateResponse &msg);
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
-  void on_get_time_response(const GetTimeResponse &value) override;
+  void on_get_time_response(const GetTimeResponse &value);
 #endif
-  void on_hello_request(const HelloRequest &msg) override;
-  void on_disconnect_request() override;
-  void on_ping_request() override;
-  void on_device_info_request() override;
-  void on_list_entities_request() override { this->begin_iterator_(ActiveIterator::LIST_ENTITIES); }
-  void on_subscribe_states_request() override {
+  void on_hello_request(const HelloRequest &msg);
+  void on_disconnect_request();
+  void on_ping_request();
+  void on_device_info_request();
+  void on_list_entities_request() { this->begin_iterator_(ActiveIterator::LIST_ENTITIES); }
+  void on_subscribe_states_request() {
     this->flags_.state_subscription = true;
     // Start initial state iterator only if no iterator is active
     // If list_entities is running, we'll start initial_state when it completes
@@ -237,7 +255,7 @@ class APIConnection final : public APIServerConnectionBase {
       this->begin_iterator_(ActiveIterator::INITIAL_STATE);
     }
   }
-  void on_subscribe_logs_request(const SubscribeLogsRequest &msg) override {
+  void on_subscribe_logs_request(const SubscribeLogsRequest &msg) {
     this->flags_.log_subscription = msg.level;
     if (msg.dump_config)
       App.schedule_dump_config();
@@ -249,13 +267,13 @@ class APIConnection final : public APIServerConnectionBase {
 #endif
   }
 #ifdef USE_API_HOMEASSISTANT_SERVICES
-  void on_subscribe_homeassistant_services_request() override { this->flags_.service_call_subscription = true; }
+  void on_subscribe_homeassistant_services_request() { this->flags_.service_call_subscription = true; }
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES
-  void on_subscribe_home_assistant_states_request() override;
+  void on_subscribe_home_assistant_states_request();
 #endif
 #ifdef USE_API_USER_DEFINED_ACTIONS
-  void on_execute_service_request(const ExecuteServiceRequest &msg) override;
+  void on_execute_service_request(const ExecuteServiceRequest &msg);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
   void send_execute_service_response(uint32_t call_id, bool success, StringRef error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
@@ -265,13 +283,13 @@ class APIConnection final : public APIServerConnectionBase {
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES
 #endif
 #ifdef USE_API_NOISE
-  void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &msg) override;
+  void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &msg);
 #endif
 
-  bool is_authenticated() override {
+  bool is_authenticated() {
     return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::AUTHENTICATED;
   }
-  bool is_connection_setup() override {
+  bool is_connection_setup() {
     return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::CONNECTED ||
            this->is_authenticated();
   }
@@ -284,8 +302,8 @@ class APIConnection final : public APIServerConnectionBase {
            (this->client_api_version_major_ == major && this->client_api_version_minor_ >= minor);
   }
 
-  void on_fatal_error() override;
-  void on_no_setup_connection() override;
+  void on_fatal_error();
+  void on_no_setup_connection();
 
   // Function pointer type for type-erased message encoding
   using MessageEncodeFn = void (*)(const void *, ProtoWriteBuffer &);
@@ -324,7 +342,7 @@ class APIConnection final : public APIServerConnectionBase {
       return true;
     return this->try_to_clear_buffer_slow_(log_out_of_space);
   }
-  bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) override;
+  bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type);
 
   const char *get_name() const { return this->helper_->get_client_name(); }
   /// Get peer name (IP address) into caller-provided buffer, returns buf for convenience
diff --git a/esphome/components/api/api_pb2_service.cpp b/esphome/components/api/api_pb2_service.cpp
index f2f7fa5238..d86cf912db 100644
--- a/esphome/components/api/api_pb2_service.cpp
+++ b/esphome/components/api/api_pb2_service.cpp
@@ -1,6 +1,7 @@
 // This file was automatically generated with a tool.
 // See script/api_protobuf/api_protobuf.py
 #include "api_pb2_service.h"
+#include "api_connection.h"
 #include "esphome/core/log.h"
 
 namespace esphome::api {
@@ -20,7 +21,7 @@ void APIServerConnectionBase::log_receive_message_(const LogString *name) {
 }
 #endif
 
-void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {
+void APIConnection::read_message_(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {
   // Check authentication/connection requirements
   switch (msg_type) {
     case HelloRequest::MESSAGE_TYPE:       // No setup required
diff --git a/esphome/components/api/api_pb2_service.h b/esphome/components/api/api_pb2_service.h
index 10fd88d8e1..4925a6497a 100644
--- a/esphome/components/api/api_pb2_service.h
+++ b/esphome/components/api/api_pb2_service.h
@@ -8,7 +8,7 @@
 
 namespace esphome::api {
 
-class APIServerConnectionBase : public ProtoService {
+class APIServerConnectionBase {
  public:
 #ifdef HAS_PROTO_MESSAGE_DUMP
  protected:
@@ -19,227 +19,223 @@ class APIServerConnectionBase : public ProtoService {
  public:
 #endif
 
-  virtual void on_hello_request(const HelloRequest &value){};
+  void on_hello_request(const HelloRequest &value){};
 
-  virtual void on_disconnect_request(){};
-  virtual void on_disconnect_response(){};
-  virtual void on_ping_request(){};
-  virtual void on_ping_response(){};
-  virtual void on_device_info_request(){};
+  void on_disconnect_request(){};
+  void on_disconnect_response(){};
+  void on_ping_request(){};
+  void on_ping_response(){};
+  void on_device_info_request(){};
 
-  virtual void on_list_entities_request(){};
+  void on_list_entities_request(){};
 
-  virtual void on_subscribe_states_request(){};
+  void on_subscribe_states_request(){};
 
 #ifdef USE_COVER
-  virtual void on_cover_command_request(const CoverCommandRequest &value){};
+  void on_cover_command_request(const CoverCommandRequest &value){};
 #endif
 
 #ifdef USE_FAN
-  virtual void on_fan_command_request(const FanCommandRequest &value){};
+  void on_fan_command_request(const FanCommandRequest &value){};
 #endif
 
 #ifdef USE_LIGHT
-  virtual void on_light_command_request(const LightCommandRequest &value){};
+  void on_light_command_request(const LightCommandRequest &value){};
 #endif
 
 #ifdef USE_SWITCH
-  virtual void on_switch_command_request(const SwitchCommandRequest &value){};
+  void on_switch_command_request(const SwitchCommandRequest &value){};
 #endif
 
-  virtual void on_subscribe_logs_request(const SubscribeLogsRequest &value){};
+  void on_subscribe_logs_request(const SubscribeLogsRequest &value){};
 
 #ifdef USE_API_NOISE
-  virtual void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &value){};
+  void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &value){};
 #endif
 
 #ifdef USE_API_HOMEASSISTANT_SERVICES
-  virtual void on_subscribe_homeassistant_services_request(){};
+  void on_subscribe_homeassistant_services_request(){};
 #endif
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  virtual void on_homeassistant_action_response(const HomeassistantActionResponse &value){};
+  void on_homeassistant_action_response(const HomeassistantActionResponse &value){};
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES
-  virtual void on_subscribe_home_assistant_states_request(){};
+  void on_subscribe_home_assistant_states_request(){};
 #endif
 
 #ifdef USE_API_HOMEASSISTANT_STATES
-  virtual void on_home_assistant_state_response(const HomeAssistantStateResponse &value){};
+  void on_home_assistant_state_response(const HomeAssistantStateResponse &value){};
 #endif
 
-  virtual void on_get_time_response(const GetTimeResponse &value){};
+  void on_get_time_response(const GetTimeResponse &value){};
 
 #ifdef USE_API_USER_DEFINED_ACTIONS
-  virtual void on_execute_service_request(const ExecuteServiceRequest &value){};
+  void on_execute_service_request(const ExecuteServiceRequest &value){};
 #endif
 
 #ifdef USE_CAMERA
-  virtual void on_camera_image_request(const CameraImageRequest &value){};
+  void on_camera_image_request(const CameraImageRequest &value){};
 #endif
 
 #ifdef USE_CLIMATE
-  virtual void on_climate_command_request(const ClimateCommandRequest &value){};
+  void on_climate_command_request(const ClimateCommandRequest &value){};
 #endif
 
 #ifdef USE_WATER_HEATER
-  virtual void on_water_heater_command_request(const WaterHeaterCommandRequest &value){};
+  void on_water_heater_command_request(const WaterHeaterCommandRequest &value){};
 #endif
 
 #ifdef USE_NUMBER
-  virtual void on_number_command_request(const NumberCommandRequest &value){};
+  void on_number_command_request(const NumberCommandRequest &value){};
 #endif
 
 #ifdef USE_SELECT
-  virtual void on_select_command_request(const SelectCommandRequest &value){};
+  void on_select_command_request(const SelectCommandRequest &value){};
 #endif
 
 #ifdef USE_SIREN
-  virtual void on_siren_command_request(const SirenCommandRequest &value){};
+  void on_siren_command_request(const SirenCommandRequest &value){};
 #endif
 
 #ifdef USE_LOCK
-  virtual void on_lock_command_request(const LockCommandRequest &value){};
+  void on_lock_command_request(const LockCommandRequest &value){};
 #endif
 
 #ifdef USE_BUTTON
-  virtual void on_button_command_request(const ButtonCommandRequest &value){};
+  void on_button_command_request(const ButtonCommandRequest &value){};
 #endif
 
 #ifdef USE_MEDIA_PLAYER
-  virtual void on_media_player_command_request(const MediaPlayerCommandRequest &value){};
+  void on_media_player_command_request(const MediaPlayerCommandRequest &value){};
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_subscribe_bluetooth_le_advertisements_request(
-      const SubscribeBluetoothLEAdvertisementsRequest &value){};
+  void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_bluetooth_device_request(const BluetoothDeviceRequest &value){};
+  void on_bluetooth_device_request(const BluetoothDeviceRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &value){};
+  void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &value){};
+  void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &value){};
+  void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &value){};
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &value){};
+  void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &value){};
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &value){};
+  void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &value){};
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &value){};
+  void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_subscribe_bluetooth_connections_free_request(){};
+  void on_subscribe_bluetooth_connections_free_request(){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_unsubscribe_bluetooth_le_advertisements_request(){};
+  void on_unsubscribe_bluetooth_le_advertisements_request(){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_bluetooth_scanner_set_mode_request(const BluetoothScannerSetModeRequest &value){};
+  void on_bluetooth_scanner_set_mode_request(const BluetoothScannerSetModeRequest &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  virtual void on_subscribe_voice_assistant_request(const SubscribeVoiceAssistantRequest &value){};
+  void on_subscribe_voice_assistant_request(const SubscribeVoiceAssistantRequest &value){};
 #endif
 
 #ifdef USE_VOICE_ASSISTANT
-  virtual void on_voice_assistant_response(const VoiceAssistantResponse &value){};
+  void on_voice_assistant_response(const VoiceAssistantResponse &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  virtual void on_voice_assistant_event_response(const VoiceAssistantEventResponse &value){};
+  void on_voice_assistant_event_response(const VoiceAssistantEventResponse &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  virtual void on_voice_assistant_audio(const VoiceAssistantAudio &value){};
+  void on_voice_assistant_audio(const VoiceAssistantAudio &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  virtual void on_voice_assistant_timer_event_response(const VoiceAssistantTimerEventResponse &value){};
+  void on_voice_assistant_timer_event_response(const VoiceAssistantTimerEventResponse &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  virtual void on_voice_assistant_announce_request(const VoiceAssistantAnnounceRequest &value){};
+  void on_voice_assistant_announce_request(const VoiceAssistantAnnounceRequest &value){};
 #endif
 
 #ifdef USE_VOICE_ASSISTANT
-  virtual void on_voice_assistant_configuration_request(const VoiceAssistantConfigurationRequest &value){};
+  void on_voice_assistant_configuration_request(const VoiceAssistantConfigurationRequest &value){};
 #endif
 
 #ifdef USE_VOICE_ASSISTANT
-  virtual void on_voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &value){};
+  void on_voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &value){};
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
-  virtual void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &value){};
+  void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &value){};
 #endif
 
 #ifdef USE_TEXT
-  virtual void on_text_command_request(const TextCommandRequest &value){};
+  void on_text_command_request(const TextCommandRequest &value){};
 #endif
 
 #ifdef USE_DATETIME_DATE
-  virtual void on_date_command_request(const DateCommandRequest &value){};
+  void on_date_command_request(const DateCommandRequest &value){};
 #endif
 
 #ifdef USE_DATETIME_TIME
-  virtual void on_time_command_request(const TimeCommandRequest &value){};
+  void on_time_command_request(const TimeCommandRequest &value){};
 #endif
 
 #ifdef USE_VALVE
-  virtual void on_valve_command_request(const ValveCommandRequest &value){};
+  void on_valve_command_request(const ValveCommandRequest &value){};
 #endif
 
 #ifdef USE_DATETIME_DATETIME
-  virtual void on_date_time_command_request(const DateTimeCommandRequest &value){};
+  void on_date_time_command_request(const DateTimeCommandRequest &value){};
 #endif
 
 #ifdef USE_UPDATE
-  virtual void on_update_command_request(const UpdateCommandRequest &value){};
+  void on_update_command_request(const UpdateCommandRequest &value){};
 #endif
 #ifdef USE_ZWAVE_PROXY
-  virtual void on_z_wave_proxy_frame(const ZWaveProxyFrame &value){};
+  void on_z_wave_proxy_frame(const ZWaveProxyFrame &value){};
 #endif
 #ifdef USE_ZWAVE_PROXY
-  virtual void on_z_wave_proxy_request(const ZWaveProxyRequest &value){};
+  void on_z_wave_proxy_request(const ZWaveProxyRequest &value){};
 #endif
 
 #ifdef USE_IR_RF
-  virtual void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &value){};
+  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &value){};
 #endif
 
 #ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &value){};
+  void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &value){};
 #endif
 
 #ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_write_request(const SerialProxyWriteRequest &value){};
+  void on_serial_proxy_write_request(const SerialProxyWriteRequest &value){};
 #endif
 #ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &value){};
+  void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &value){};
 #endif
 #ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &value){};
+  void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &value){};
 #endif
 
 #ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_request(const SerialProxyRequest &value){};
+  void on_serial_proxy_request(const SerialProxyRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &value){};
+  void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &value){};
 #endif
-
- protected:
-  void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
 };
 
 }  // namespace esphome::api
diff --git a/esphome/components/api/proto.h b/esphome/components/api/proto.h
index cd22915703..a1d825ead9 100644
--- a/esphome/components/api/proto.h
+++ b/esphome/components/api/proto.h
@@ -711,26 +711,7 @@ inline void ProtoLengthDelimited::decode_to_message(ProtoDecodableMessage &msg)
 
 template<typename T> const char *proto_enum_to_string(T value);
 
-class ProtoService {
- public:
- protected:
-  virtual bool is_authenticated() = 0;
-  virtual bool is_connection_setup() = 0;
-  virtual void on_fatal_error() = 0;
-  virtual void on_no_setup_connection() = 0;
-  virtual bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) = 0;
-  virtual void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) = 0;
-
-  // Authentication helper methods
-  inline bool check_connection_setup_() {
-    if (!this->is_connection_setup()) {
-      this->on_no_setup_connection();
-      return false;
-    }
-    return true;
-  }
-
-  inline bool check_authenticated_() { return this->check_connection_setup_(); }
-};
+// ProtoService removed — its methods were inlined into APIConnection.
+// APIConnection is the concrete server-side implementation; the extra virtual layer was unnecessary.
 
 }  // namespace esphome::api
diff --git a/script/api_protobuf/api_protobuf.py b/script/api_protobuf/api_protobuf.py
index aca31e49c8..221ccc8d69 100755
--- a/script/api_protobuf/api_protobuf.py
+++ b/script/api_protobuf/api_protobuf.py
@@ -2608,7 +2608,7 @@ def build_service_message_type(
         is_empty = not has_fields
         if is_empty:
             EMPTY_MESSAGES.add(mt.name)
-        hout += f"virtual void {func}({'' if is_empty else f'const {mt.name} &value'}){{}};\n"
+        hout += f"void {func}({'' if is_empty else f'const {mt.name} &value'}){{}};\n"
         case = ""
         if not is_empty:
             case += f"{mt.name} msg;\n"
@@ -2960,6 +2960,7 @@ namespace esphome::api {
     cpp = FILE_HEADER
     cpp += """\
 #include "api_pb2_service.h"
+#include "api_connection.h"
 #include "esphome/core/log.h"
 
 namespace esphome::api {
@@ -2970,7 +2971,7 @@ static const char *const TAG = "api.service";
 
     class_name = "APIServerConnectionBase"
 
-    hpp += f"class {class_name} : public ProtoService {{\n"
+    hpp += f"class {class_name} {{\n"
     hpp += " public:\n"
 
     # Add logging helper method declarations
@@ -3063,11 +3064,11 @@ static const char *const TAG = "api.service";
                 result += "#endif\n"
         return result
 
-    # Generate read_message with auth check before dispatch
-    hpp += " protected:\n"
-    hpp += "  void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;\n"
+    # Generate read_message_ as APIConnection method (not base class) so the compiler
+    # can devirtualize and inline the on_* handler calls within the same class.
+    # APIConnection declares this method in api_connection.h.
 
-    out = f"void {class_name}::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {{\n"
+    out = "void APIConnection::read_message_(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {\n"
 
     # Auth check block before dispatch switch
     out += "  // Check authentication/connection requirements\n"

From 5560c9eef78e2a7be9fc5d728e767c34a23630c1 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 22 Mar 2026 21:10:51 -1000
Subject: [PATCH 40/60] [test] Fix flakey ld2412 integration test race
 condition (#15100)

---
 tests/integration/test_uart_mock_ld2412.py | 33 +++++++++-------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/tests/integration/test_uart_mock_ld2412.py b/tests/integration/test_uart_mock_ld2412.py
index 9b928ef14f..12aa3f8397 100644
--- a/tests/integration/test_uart_mock_ld2412.py
+++ b/tests/integration/test_uart_mock_ld2412.py
@@ -79,9 +79,15 @@ async def test_uart_mock_ld2412(
         ],
     )
 
-    # Signal when we see recovery frame values
+    # Signal when we see all recovery frame values
     recovery_received = collector.add_waiter(
-        lambda: pytest.approx(50.0) in collector.sensor_states["moving_distance"]
+        lambda: (
+            pytest.approx(50.0) in collector.sensor_states["moving_distance"]
+            and pytest.approx(75.0) in collector.sensor_states["still_distance"]
+            and pytest.approx(100.0) in collector.sensor_states["moving_energy"]
+            and pytest.approx(80.0) in collector.sensor_states["still_energy"]
+            and pytest.approx(50.0) in collector.sensor_states["detection_distance"]
+        )
     )
 
     async with (
@@ -150,23 +156,12 @@ async def test_uart_mock_ld2412(
         )
 
         # Recovery frame: moving=50, still=75, energy=100/80, detect=50
-        recovery_idx = next(
-            i
-            for i, v in enumerate(collector.sensor_states["moving_distance"])
-            if v == pytest.approx(50.0)
-        )
-        assert collector.sensor_states["still_distance"][recovery_idx] == pytest.approx(
-            75.0
-        )
-        assert collector.sensor_states["moving_energy"][recovery_idx] == pytest.approx(
-            100.0
-        )
-        assert collector.sensor_states["still_energy"][recovery_idx] == pytest.approx(
-            80.0
-        )
-        assert collector.sensor_states["detection_distance"][
-            recovery_idx
-        ] == pytest.approx(50.0)
+        # Check values exist (waiter already ensured all are present)
+        assert pytest.approx(50.0) in collector.sensor_states["moving_distance"]
+        assert pytest.approx(75.0) in collector.sensor_states["still_distance"]
+        assert pytest.approx(100.0) in collector.sensor_states["moving_energy"]
+        assert pytest.approx(80.0) in collector.sensor_states["still_energy"]
+        assert pytest.approx(50.0) in collector.sensor_states["detection_distance"]
 
         # Verify binary sensors detected targets (from Phase 1 frame)
         assert collector.binary_states["has_target"][0] is True

From 43879964bd3ceff183ff4e113b6b5f4d05b34d77 Mon Sep 17 00:00:00 2001
From: Simone Rossetto <simros85@gmail.com>
Date: Mon, 23 Mar 2026 10:03:19 +0100
Subject: [PATCH 41/60] [wireguard] bump esp_wireguard to 0.4.4 for mbedtls
 4.0+ compatibility (#15104)

Co-authored-by: J. Nick Koston <nick@koston.org>
---
 .clang-tidy.hash                         | 2 +-
 esphome/components/wireguard/__init__.py | 2 +-
 platformio.ini                           | 8 ++++----
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.clang-tidy.hash b/.clang-tidy.hash
index c32978d411..5c7eab517b 100644
--- a/.clang-tidy.hash
+++ b/.clang-tidy.hash
@@ -1 +1 @@
-9f5d763f95ff720024f3fdddba2fad3801e2bfe00b7cc2124e6d68c17d3504c6
+f31f13994768b5b07e29624406c9b053bf4bb26e1623ac2bc1e9d4a9477502d6
diff --git a/esphome/components/wireguard/__init__.py b/esphome/components/wireguard/__init__.py
index e2ea61a542..1b54391376 100644
--- a/esphome/components/wireguard/__init__.py
+++ b/esphome/components/wireguard/__init__.py
@@ -137,7 +137,7 @@ async def to_code(config):
     # the '+1' modifier is relative to the device's own address that will
     # be automatically added to the provided list.
     cg.add_build_flag(f"-DCONFIG_WIREGUARD_MAX_SRC_IPS={len(allowed_ips) + 1}")
-    cg.add_library("droscy/esp_wireguard", "0.4.2")
+    cg.add_library("droscy/esp_wireguard", "0.4.4")
 
     await cg.register_component(var, config)
 
diff --git a/platformio.ini b/platformio.ini
index d3a482b652..e0f7c7d443 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -118,7 +118,7 @@ lib_deps =
     ESP8266HTTPClient                     ; http_request (Arduino built-in)
     ESP8266mDNS                           ; mdns (Arduino built-in)
     DNSServer                             ; captive_portal (Arduino built-in)
-    droscy/esp_wireguard@0.4.2            ; wireguard
+    droscy/esp_wireguard@0.4.4            ; wireguard
     lvgl/lvgl@9.5.0                       ; lvgl
 
 build_flags =
@@ -154,7 +154,7 @@ lib_deps =
     DNSServer                            ; captive_portal (Arduino built-in)
     makuna/NeoPixelBus@2.8.0             ; neopixelbus
     esphome/ESP32-audioI2S@2.3.0         ; i2s_audio
-    droscy/esp_wireguard@0.4.2           ; wireguard
+    droscy/esp_wireguard@0.4.4           ; wireguard
     kahrendt/ESPMicroSpeechFeatures@1.1.0  ; micro_wake_word
 
 build_flags =
@@ -176,7 +176,7 @@ platform_packages =
 framework = espidf
 lib_deps =
     ${common:idf.lib_deps}
-    droscy/esp_wireguard@0.4.2              ; wireguard
+    droscy/esp_wireguard@0.4.4              ; wireguard
     kahrendt/ESPMicroSpeechFeatures@1.1.0   ; micro_wake_word
     tonia/HeatpumpIR@1.0.40                 ; heatpumpir
 build_flags =
@@ -221,7 +221,7 @@ lib_compat_mode = soft
 lib_deps =
     bblanchon/ArduinoJson@7.4.2           ; json
     ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
-    droscy/esp_wireguard@0.4.2            ; wireguard
+    droscy/esp_wireguard@0.4.4            ; wireguard
     lvgl/lvgl@9.5.0                       ; lvgl
 build_flags =
     ${common:arduino.build_flags}

From 5a984b54cfce79fbd6ad93365cf8ccc148942d6f Mon Sep 17 00:00:00 2001
From: Kevin Ahrendt <kevin.ahrendt@openhomefoundation.org>
Date: Mon, 23 Mar 2026 07:31:05 -0500
Subject: [PATCH 42/60] [audio] Bump microOpus to avoid creating an extra
 opus-staged directory (#14974)

---
 esphome/components/audio/__init__.py | 2 +-
 esphome/idf_component.yml            | 2 +-
 script/analyze_component_buses.py    | 1 +
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/esphome/components/audio/__init__.py b/esphome/components/audio/__init__.py
index b28c2ed3d8..9cc80b9b33 100644
--- a/esphome/components/audio/__init__.py
+++ b/esphome/components/audio/__init__.py
@@ -214,4 +214,4 @@ async def to_code(config):
         cg.add_define("USE_AUDIO_MP3_SUPPORT")
     if data.opus_support:
         cg.add_define("USE_AUDIO_OPUS_SUPPORT")
-        add_idf_component(name="esphome/micro-opus", ref="0.3.5")
+        add_idf_component(name="esphome/micro-opus", ref="0.3.6")
diff --git a/esphome/idf_component.yml b/esphome/idf_component.yml
index 5cfa8532ff..4148147a3b 100644
--- a/esphome/idf_component.yml
+++ b/esphome/idf_component.yml
@@ -4,7 +4,7 @@ dependencies:
   esphome/esp-audio-libs:
     version: 2.0.3
   esphome/micro-opus:
-    version: 0.3.5
+    version: 0.3.6
   espressif/esp-dsp:
     version: "1.7.1"
   espressif/esp-tflite-micro:
diff --git a/script/analyze_component_buses.py b/script/analyze_component_buses.py
index 427602dff2..17af7af577 100755
--- a/script/analyze_component_buses.py
+++ b/script/analyze_component_buses.py
@@ -83,6 +83,7 @@ ISOLATED_COMPONENTS = {
     "openthread": "Conflicts with wifi: used by most components",
     "openthread_info": "Conflicts with wifi: used by most components",
     "matrix_keypad": "Needs isolation due to keypad",
+    "microphone": "Defines PDM microphone requiring I2S port 0 - conflicts with micro_wake_word PDM mic when merged",
     "modbus_controller": "Defines multiple modbus buses for testing client/server functionality - conflicts with package modbus bus",
     "neopixelbus": "RMT type conflict with ESP32 Arduino/ESP-IDF headers (enum vs struct rmt_channel_t)",
     "packages": "cannot merge packages",

From e8c5dfca3ecc959f17722bdafb13471ad4e3f1a0 Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Tue, 24 Mar 2026 02:09:30 +1000
Subject: [PATCH 43/60] [lvgl] Various fixes (#15098)

---
 esphome/components/lvgl/__init__.py         | 8 +++++++-
 esphome/components/lvgl/lvgl_esphome.h      | 2 +-
 esphome/components/lvgl/widgets/textarea.py | 4 ++++
 3 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/esphome/components/lvgl/__init__.py b/esphome/components/lvgl/__init__.py
index c37a32ecca..a6afa12afa 100644
--- a/esphome/components/lvgl/__init__.py
+++ b/esphome/components/lvgl/__init__.py
@@ -226,6 +226,9 @@ async def to_code(configs):
     config_0 = configs[0]
     # Global configuration
     if CORE.is_esp32:
+        # Skip compiling lvgl examples
+        add_idf_sdkconfig_option("CONFIG_LV_BUILD_EXAMPLES", False)
+        add_idf_sdkconfig_option("CONFIG_LV_BUILD_DEMOS", False)
         if get_esp32_variant() == VARIANT_ESP32P4:
             add_idf_sdkconfig_option("CONFIG_LV_DRAW_BUF_ALIGN", 64)
             # disable use of PPA for fills until upstream bugs fixed
@@ -406,7 +409,10 @@ async def to_code(configs):
     lv_conf_h_file = CORE.relative_src_path(LV_CONF_FILENAME)
     write_file_if_changed(lv_conf_h_file, generate_lv_conf_h())
     cg.add_build_flag("-DLV_CONF_H=1")
-    cg.add_build_flag(f'-DLV_CONF_PATH=\\"{LV_CONF_FILENAME}\\"')
+    # handle windows paths in a way that doesn't break the generated C++
+    lv_conf_h_path = Path(lv_conf_h_file).as_posix()
+    cg.add_build_flag(f'-DLV_CONF_PATH=\\"{lv_conf_h_path}\\"')
+    cg.add_build_flag("-DLV_KCONFIG_IGNORE")
 
     for prop in df.get_remapped_uses():
         df.LOGGER.warning(
diff --git a/esphome/components/lvgl/lvgl_esphome.h b/esphome/components/lvgl/lvgl_esphome.h
index 8e34f16c98..66f823d549 100644
--- a/esphome/components/lvgl/lvgl_esphome.h
+++ b/esphome/components/lvgl/lvgl_esphome.h
@@ -71,7 +71,7 @@ inline void lv_style_set_text_font(lv_style_t *style, const font::Font *font) {
   lv_style_set_text_font(style, font->get_lv_font());
 }
 #endif
-#ifdef USE_IMAGE
+#if defined(USE_LVGL_IMAGE) && defined(USE_IMAGE)
 // Shortcut / overload, so that the source of an image can easily be updated
 // from within a lambda.
 inline void lv_image_set_src(lv_obj_t *obj, esphome::image::Image *image) {
diff --git a/esphome/components/lvgl/widgets/textarea.py b/esphome/components/lvgl/widgets/textarea.py
index e5ab884685..baa40ee2c6 100644
--- a/esphome/components/lvgl/widgets/textarea.py
+++ b/esphome/components/lvgl/widgets/textarea.py
@@ -16,6 +16,7 @@ from ..lv_validation import lv_bool, lv_int, lv_text
 from ..schemas import TEXT_SCHEMA
 from ..types import LvText
 from . import Widget, WidgetType
+from .label import CONF_LABEL
 
 CONF_TEXTAREA = "textarea"
 
@@ -46,6 +47,9 @@ class TextareaType(WidgetType):
             TEXTAREA_SCHEMA,
         )
 
+    def get_uses(self):
+        return (CONF_LABEL,)
+
     async def to_code(self, w: Widget, config: dict):
         for prop in (CONF_TEXT, CONF_PLACEHOLDER_TEXT, CONF_ACCEPTED_CHARS):
             if (value := config.get(prop)) is not None:

From 3b5b51b4f0f918fef64e4996dcf0a551389afc4d Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 08:22:25 -1000
Subject: [PATCH 44/60] [time] Point to valid IANA timezone list on validation
 failure (#15110)

---
 esphome/components/time/__init__.py | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/esphome/components/time/__init__.py b/esphome/components/time/__init__.py
index 9821046a73..c31ccbc7ea 100644
--- a/esphome/components/time/__init__.py
+++ b/esphome/components/time/__init__.py
@@ -284,13 +284,23 @@ def validate_tz(value: str) -> str:
     tzfile = _load_tzdata(value)
     if tzfile is not None:
         value = _extract_tz_string(tzfile)
+        is_iana = True
+    else:
+        is_iana = False
 
     # Validate that the POSIX TZ string is parseable (skip empty strings)
     if value:
         try:
             parse_posix_tz_python(value)
         except ValueError as e:
-            raise cv.Invalid(f"Invalid POSIX timezone string '{value}': {e}") from e
+            if is_iana:
+                raise cv.Invalid(f"Invalid POSIX timezone string '{value}': {e}") from e
+            raise cv.Invalid(
+                f"Invalid POSIX timezone string '{value}': {e}. "
+                f"If you meant to use an IANA timezone, check the list of valid "
+                f"timezones at "
+                f"https://en.wikipedia.org/wiki/List_of_tz_database_time_zones"
+            ) from e
 
     return value
 

From 03d6b36fe03176ea2bca019f701f8a706dc3f3c0 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 08:22:38 -1000
Subject: [PATCH 45/60] [gpio] Compile out interlock fields when unused
 (#15111)

---
 esphome/components/gpio/switch/__init__.py     | 1 +
 esphome/components/gpio/switch/gpio_switch.cpp | 9 +++++++++
 esphome/components/gpio/switch/gpio_switch.h   | 4 ++++
 esphome/core/defines.h                         | 1 +
 4 files changed, 15 insertions(+)

diff --git a/esphome/components/gpio/switch/__init__.py b/esphome/components/gpio/switch/__init__.py
index 604de6d809..9462cd0161 100644
--- a/esphome/components/gpio/switch/__init__.py
+++ b/esphome/components/gpio/switch/__init__.py
@@ -32,6 +32,7 @@ async def to_code(config):
     cg.add(var.set_pin(pin))
 
     if CONF_INTERLOCK in config:
+        cg.add_define("USE_GPIO_SWITCH_INTERLOCK")
         interlock = []
         for it in config[CONF_INTERLOCK]:
             lock = await cg.get_variable(it)
diff --git a/esphome/components/gpio/switch/gpio_switch.cpp b/esphome/components/gpio/switch/gpio_switch.cpp
index d461fab051..9c6464815a 100644
--- a/esphome/components/gpio/switch/gpio_switch.cpp
+++ b/esphome/components/gpio/switch/gpio_switch.cpp
@@ -5,7 +5,9 @@ namespace esphome {
 namespace gpio {
 
 static const char *const TAG = "switch.gpio";
+#ifdef USE_GPIO_SWITCH_INTERLOCK
 static constexpr uint32_t INTERLOCK_TIMEOUT_ID = 0;
+#endif
 
 float GPIOSwitch::get_setup_priority() const { return setup_priority::HARDWARE; }
 void GPIOSwitch::setup() {
@@ -28,6 +30,7 @@ void GPIOSwitch::setup() {
 void GPIOSwitch::dump_config() {
   LOG_SWITCH("", "GPIO Switch", this);
   LOG_PIN("  Pin: ", this->pin_);
+#ifdef USE_GPIO_SWITCH_INTERLOCK
   if (!this->interlock_.empty()) {
     ESP_LOGCONFIG(TAG, "  Interlocks:");
     for (auto *lock : this->interlock_) {
@@ -36,8 +39,10 @@ void GPIOSwitch::dump_config() {
       ESP_LOGCONFIG(TAG, "    %s", lock->get_name().c_str());
     }
   }
+#endif
 }
 void GPIOSwitch::write_state(bool state) {
+#ifdef USE_GPIO_SWITCH_INTERLOCK
   if (state != this->inverted_) {
     // Turning ON, check interlocking
 
@@ -64,11 +69,15 @@ void GPIOSwitch::write_state(bool state) {
     // re-activations
     this->cancel_timeout(INTERLOCK_TIMEOUT_ID);
   }
+#endif
 
   this->pin_->digital_write(state);
   this->publish_state(state);
 }
+
+#ifdef USE_GPIO_SWITCH_INTERLOCK
 void GPIOSwitch::set_interlock(const std::initializer_list<Switch *> &interlock) { this->interlock_ = interlock; }
+#endif
 
 }  // namespace gpio
 }  // namespace esphome
diff --git a/esphome/components/gpio/switch/gpio_switch.h b/esphome/components/gpio/switch/gpio_switch.h
index a73fb9e18c..f7415d1dba 100644
--- a/esphome/components/gpio/switch/gpio_switch.h
+++ b/esphome/components/gpio/switch/gpio_switch.h
@@ -18,15 +18,19 @@ class GPIOSwitch final : public switch_::Switch, public Component {
 
   void setup() override;
   void dump_config() override;
+#ifdef USE_GPIO_SWITCH_INTERLOCK
   void set_interlock(const std::initializer_list<Switch *> &interlock);
   void set_interlock_wait_time(uint32_t interlock_wait_time) { interlock_wait_time_ = interlock_wait_time; }
+#endif
 
  protected:
   void write_state(bool state) override;
 
   GPIOPin *pin_;
+#ifdef USE_GPIO_SWITCH_INTERLOCK
   FixedVector<Switch *> interlock_;
   uint32_t interlock_wait_time_{0};
+#endif
 };
 
 }  // namespace gpio
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index d94b7e9f5d..f437e30a95 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -53,6 +53,7 @@
 #define USE_ESP32_IMPROV_STATE_CALLBACK
 #define USE_EVENT
 #define USE_FAN
+#define USE_GPIO_SWITCH_INTERLOCK
 #define USE_GRAPH
 #define USE_GRAPHICAL_DISPLAY_MENU
 #define USE_HOMEASSISTANT_TIME

From 36d2e58b11836420fff50447c9c2a9ee70cdf432 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 08:23:08 -1000
Subject: [PATCH 46/60] [api] Make ProtoDecodableMessage::decode() non-virtual
 (#15076)

---
 esphome/components/api/api_pb2.h    |  4 ++--
 esphome/components/api/proto.h      | 22 +++++++---------------
 script/api_protobuf/api_protobuf.py |  2 +-
 3 files changed, 10 insertions(+), 18 deletions(-)

diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index a4ee0adb8b..86289a28d6 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -1253,7 +1253,7 @@ class ExecuteServiceArgument final : public ProtoDecodableMessage {
   FixedVector<int32_t> int_array{};
   FixedVector<float> float_array{};
   FixedVector<std::string> string_array{};
-  void decode(const uint8_t *buffer, size_t length) override;
+  void decode(const uint8_t *buffer, size_t length);
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1278,7 +1278,7 @@ class ExecuteServiceRequest final : public ProtoDecodableMessage {
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
   bool return_response{false};
 #endif
-  void decode(const uint8_t *buffer, size_t length) override;
+  void decode(const uint8_t *buffer, size_t length);
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
diff --git a/esphome/components/api/proto.h b/esphome/components/api/proto.h
index a1d825ead9..d6f9c947d7 100644
--- a/esphome/components/api/proto.h
+++ b/esphome/components/api/proto.h
@@ -152,8 +152,7 @@ class ProtoVarInt {
 #endif
 };
 
-// Forward declarations for decode_to_message and related encoding helpers
-class ProtoDecodableMessage;
+// Forward declarations for encoding helpers
 class ProtoMessage;
 class ProtoSize;
 
@@ -166,16 +165,9 @@ class ProtoLengthDelimited {
   const uint8_t *data() const { return this->value_; }
   size_t size() const { return this->length_; }
 
-  /**
-   * Decode the length-delimited data into an existing ProtoDecodableMessage instance.
-   *
-   * This method allows decoding without templates, enabling use in contexts
-   * where the message type is not known at compile time. The ProtoDecodableMessage's
-   * decode() method will be called with the raw data and length.
-   *
-   * @param msg The ProtoDecodableMessage instance to decode into
-   */
-  void decode_to_message(ProtoDecodableMessage &msg) const;
+  /// Decode the length-delimited data into a message instance.
+  /// Template preserves concrete type so decode() resolves statically.
+  template<typename T> void decode_to_message(T &msg) const;
 
  protected:
   const uint8_t *const value_;
@@ -468,7 +460,7 @@ class ProtoMessage {
 // Base class for messages that support decoding
 class ProtoDecodableMessage : public ProtoMessage {
  public:
-  virtual void decode(const uint8_t *buffer, size_t length);
+  void decode(const uint8_t *buffer, size_t length);
 
   /**
    * Count occurrences of a repeated field in a protobuf buffer.
@@ -704,8 +696,8 @@ template<typename T> inline void ProtoWriteBuffer::encode_optional_sub_message(u
   this->encode_optional_sub_message(field_id, value.calculate_size(), &value, &proto_encode_msg<T>);
 }
 
-// Implementation of decode_to_message - must be after ProtoDecodableMessage is defined
-inline void ProtoLengthDelimited::decode_to_message(ProtoDecodableMessage &msg) const {
+// Template decode_to_message - preserves concrete type so decode() resolves statically
+template<typename T> void ProtoLengthDelimited::decode_to_message(T &msg) const {
   msg.decode(this->value_, this->length_);
 }
 
diff --git a/script/api_protobuf/api_protobuf.py b/script/api_protobuf/api_protobuf.py
index 221ccc8d69..0bb569fdb5 100755
--- a/script/api_protobuf/api_protobuf.py
+++ b/script/api_protobuf/api_protobuf.py
@@ -2275,7 +2275,7 @@ def build_message_type(
         o += "}\n"
         cpp += o
         # Generate the decode() declaration in header (public method)
-        prot = "void decode(const uint8_t *buffer, size_t length) override;"
+        prot = "void decode(const uint8_t *buffer, size_t length);"
         public_content.append(prot)
 
     # Only generate encode method if this message needs encoding and has fields

From 9385f1612820541019f3685810d07f352b9b5ee1 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 08:23:22 -1000
Subject: [PATCH 47/60] [text_sensor] Guard raw_callback_ behind
 USE_TEXT_SENSOR_FILTER, save 4 bytes per instance (#15097)

---
 esphome/components/text_sensor/text_sensor.cpp |  2 ++
 esphome/components/text_sensor/text_sensor.h   | 10 +++++++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/esphome/components/text_sensor/text_sensor.cpp b/esphome/components/text_sensor/text_sensor.cpp
index aa49a85d26..0dc29f9a94 100644
--- a/esphome/components/text_sensor/text_sensor.cpp
+++ b/esphome/components/text_sensor/text_sensor.cpp
@@ -31,7 +31,9 @@ void TextSensor::publish_state(const char *state, size_t len) {
     if (len != this->state.size() || memcmp(state, this->state.data(), len) != 0) {
       this->state.assign(state, len);
     }
+#ifdef USE_TEXT_SENSOR_FILTER
     this->raw_callback_.call(this->state);
+#endif
     ESP_LOGV(TAG, "'%s': Received new state %s", this->name_.c_str(), this->state.c_str());
     this->notify_frontend_();
 #ifdef USE_TEXT_SENSOR_FILTER
diff --git a/esphome/components/text_sensor/text_sensor.h b/esphome/components/text_sensor/text_sensor.h
index 8941790e7c..3f69e91c8d 100644
--- a/esphome/components/text_sensor/text_sensor.h
+++ b/esphome/components/text_sensor/text_sensor.h
@@ -64,8 +64,14 @@ class TextSensor : public EntityBase {
 
   template<typename F> void add_on_state_callback(F &&callback) { this->callback_.add(std::forward<F>(callback)); }
   /// Add a callback that will be called every time the sensor sends a raw value.
+  /// When USE_TEXT_SENSOR_FILTER is not enabled, delegates to the regular callback
+  /// since raw state equals filtered state without filter support compiled in.
   template<typename F> void add_on_raw_state_callback(F &&callback) {
+#ifdef USE_TEXT_SENSOR_FILTER
     this->raw_callback_.add(std::forward<F>(callback));
+#else
+    this->callback_.add(std::forward<F>(callback));
+#endif
   }
 
   // ========== INTERNAL METHODS ==========
@@ -77,8 +83,10 @@ class TextSensor : public EntityBase {
  protected:
   /// Notify frontend that state has changed (assumes this->state is already set)
   void notify_frontend_();
+#ifdef USE_TEXT_SENSOR_FILTER
   LazyCallbackManager<void(const std::string &)> raw_callback_;  ///< Storage for raw state callbacks.
-  LazyCallbackManager<void(const std::string &)> callback_;      ///< Storage for filtered state callbacks.
+#endif
+  LazyCallbackManager<void(const std::string &)> callback_;  ///< Storage for filtered state callbacks.
 
 #ifdef USE_TEXT_SENSOR_FILTER
   Filter *filter_list_{nullptr};  ///< Store all active filters.

From 4b0c711f7743495db05f97168d09bf991f60e204 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 08:23:35 -1000
Subject: [PATCH 48/60] [ci] Ban std::bind in new C++ code (#14969)

---
 script/ci-custom.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/script/ci-custom.py b/script/ci-custom.py
index 06fcdadb8c..1da923b095 100755
--- a/script/ci-custom.py
+++ b/script/ci-custom.py
@@ -890,6 +890,22 @@ def lint_no_powf_in_core(fname, match):
     )
 
 
+@lint_re_check(
+    r"[^\w]std\s*::\s*bind\s*\(" + CPP_RE_EOL,
+    include=cpp_include,
+)
+def lint_no_std_bind(fname, match):
+    return (
+        f"{highlight('std::bind()')} is not allowed in new ESPHome code. "
+        f"Lambdas are clearer, produce smaller binaries, and are more likely to fit within "
+        f"the {highlight('std::function')} small-buffer optimization (avoiding heap allocation).\n"
+        f"Please use a lambda instead.\n"
+        f"  Before: {highlight('std::bind(&Class::method, this, std::placeholders::_1)')}\n"
+        f"  After:  {highlight('[this](auto arg) { this->method(arg); }')}\n"
+        f"(If strictly necessary, add `// NOLINT` to the end of the line)"
+    )
+
+
 LOG_MULTILINE_RE = re.compile(r"ESP_LOG\w+\s*\(.*?;", re.DOTALL)
 LOG_BAD_CONTINUATION_RE = re.compile(r'\\n(?:[^ \\"\r\n\t]|"\s*\n\s*"[^ \\])')
 LOG_PERCENT_S_CONTINUATION_RE = re.compile(r'\\n(?:%s|"\s*\n\s*"%s)')

From 9da0c5bc857b13a1a6387670a19629bcd5ab20fc Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 08:47:15 -1000
Subject: [PATCH 49/60] [wifi] Fix roaming attempt counter reset on disconnect
 during scan (#15099)

---
 esphome/components/wifi/wifi_component.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp
index 0fd1385258..e1d4b07471 100644
--- a/esphome/components/wifi/wifi_component.cpp
+++ b/esphome/components/wifi/wifi_component.cpp
@@ -269,11 +269,11 @@ bool CompactString::operator==(const StringRef &other) const {
 /// │                              │                                       │
 /// │               ┌──────────────┼──────────────┐                        │
 /// │               ↓              ↓              ↓                        │
-/// │         scan error    no better AP    +10 dB better AP               │
+/// │         disconnect    no better AP    +10 dB better AP               │
 /// │               │              │              │                        │
 /// │               ↓              ↓              ↓                        │
 /// │    ┌──────────────────────────────┐  ┌──────────────────────────┐    │
-/// │    │  → IDLE                      │  │        CONNECTING        │    │
+/// │    │  → RECONNECTING              │  │        CONNECTING        │    │
 /// │    │  (counter preserved)         │  │  (process_roaming_scan_) │    │
 /// │    └──────────────────────────────┘  └────────────┬─────────────┘    │
 /// │                                                  │                   │
@@ -296,7 +296,7 @@ bool CompactString::operator==(const StringRef &other) const {
 /// │  Key behaviors:                                                      │
 /// │  - After 3 checks: attempts >= 3, stop checking                      │
 /// │  - Non-roaming disconnect: clear_roaming_state_() resets counter     │
-/// │  - Scan error (SCANNING→IDLE): counter preserved                     │
+/// │  - Disconnect during scan (SCANNING→RECONNECTING): counter preserved  │
 /// │  - Roaming success (CONNECTING→IDLE): counter reset (can roam again) │
 /// │  - Roaming fail (RECONNECTING→IDLE): counter preserved (ping-pong)   │
 /// └──────────────────────────────────────────────────────────────────────┘
@@ -2068,9 +2068,10 @@ void WiFiComponent::retry_connect() {
     ESP_LOGD(TAG, "Roam failed, reconnecting (attempt %u/%u)", this->roaming_attempts_, ROAMING_MAX_ATTEMPTS);
     this->roaming_state_ = RoamingState::RECONNECTING;
   } else if (this->roaming_state_ == RoamingState::SCANNING) {
-    // Roam scan failed (e.g., scan error on ESP8266) - go back to idle, keep counter
-    ESP_LOGD(TAG, "Roam scan failed (attempt %u/%u)", this->roaming_attempts_, ROAMING_MAX_ATTEMPTS);
-    this->roaming_state_ = RoamingState::IDLE;
+    // Disconnected during roam scan - transition to RECONNECTING so the attempts
+    // counter is preserved when reconnection succeeds (IDLE would reset it)
+    ESP_LOGD(TAG, "Disconnected during roam scan (attempt %u/%u)", this->roaming_attempts_, ROAMING_MAX_ATTEMPTS);
+    this->roaming_state_ = RoamingState::RECONNECTING;
   } else if (this->roaming_state_ == RoamingState::IDLE) {
     // Not a roaming-triggered reconnect, reset state
     this->clear_roaming_state_();

From 4c1363b104f198aa837a11bd1ba1ecad28371ec4 Mon Sep 17 00:00:00 2001
From: Daniel Kent <129895318+danielkent-net@users.noreply.github.com>
Date: Mon, 23 Mar 2026 15:07:40 -0400
Subject: [PATCH 50/60] [spi] Add LOG_SPI_DEVICE macro (#15118)

---
 esphome/components/spi/spi.h | 2 ++
 script/ci-custom.py          | 1 +
 2 files changed, 3 insertions(+)

diff --git a/esphome/components/spi/spi.h b/esphome/components/spi/spi.h
index e237cf44f4..84c8bca267 100644
--- a/esphome/components/spi/spi.h
+++ b/esphome/components/spi/spi.h
@@ -34,6 +34,8 @@ using SPIInterface = void *;  // Stub for platforms without SPI (e.g., Zephyr)
  */
 namespace esphome::spi {
 
+#define LOG_SPI_DEVICE(this) ESP_LOGCONFIG(TAG, "  CS Pin: %d", esphome::spi::Utility::get_pin_no(this->cs_));
+
 /// The bit-order for SPI devices. This defines how the data read from and written to the device is interpreted.
 enum SPIBitOrder {
   /// The least significant bit is transmitted/received first.
diff --git a/script/ci-custom.py b/script/ci-custom.py
index 1da923b095..25a0cf2127 100755
--- a/script/ci-custom.py
+++ b/script/ci-custom.py
@@ -963,6 +963,7 @@ def lint_log_multiline_continuation(fname, content):
         "esphome/components/nextion/nextion_base.h",
         "esphome/components/select/select.h",
         "esphome/components/sensor/sensor.h",
+        "esphome/components/spi/spi.h",
         "esphome/components/stepper/stepper.h",
         "esphome/components/switch/switch.h",
         "esphome/components/text/text.h",

From 1e16b30380a4703142318a5a1a93f6ad3626f6f2 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 09:18:58 -1000
Subject: [PATCH 51/60] [ethernet] Add ENC28J60 SPI Ethernet support (#14945)

---
 esphome/components/ethernet/__init__.py       | 44 ++++++++++++++-----
 .../components/ethernet/ethernet_component.h  | 13 ++++++
 .../ethernet/ethernet_component_esp32.cpp     | 41 +++++++++++------
 .../ethernet/ethernet_component_rp2040.cpp    | 27 +++++++++---
 .../ethernet/common-enc28j60-rp2040.yaml      | 18 ++++++++
 .../components/ethernet/common-enc28j60.yaml  | 19 ++++++++
 .../ethernet/test-enc28j60.esp32-idf.yaml     |  1 +
 .../ethernet/test-enc28j60.rp2040-ard.yaml    |  1 +
 8 files changed, 134 insertions(+), 30 deletions(-)
 create mode 100644 tests/components/ethernet/common-enc28j60-rp2040.yaml
 create mode 100644 tests/components/ethernet/common-enc28j60.yaml
 create mode 100644 tests/components/ethernet/test-enc28j60.esp32-idf.yaml
 create mode 100644 tests/components/ethernet/test-enc28j60.rp2040-ard.yaml

diff --git a/esphome/components/ethernet/__init__.py b/esphome/components/ethernet/__init__.py
index f519d79aa1..e17abfcc93 100644
--- a/esphome/components/ethernet/__init__.py
+++ b/esphome/components/ethernet/__init__.py
@@ -119,6 +119,7 @@ ETHERNET_TYPES = {
     "OPENETH": EthernetType.ETHERNET_TYPE_OPENETH,
     "DM9051": EthernetType.ETHERNET_TYPE_DM9051,
     "LAN8670": EthernetType.ETHERNET_TYPE_LAN8670,
+    "ENC28J60": EthernetType.ETHERNET_TYPE_ENC28J60,
 }
 
 # PHY types that need compile-time defines for conditional compilation
@@ -134,6 +135,7 @@ _PHY_TYPE_TO_DEFINE = {
     "W5500": "USE_ETHERNET_W5500",
     "DM9051": "USE_ETHERNET_DM9051",
     "LAN8670": "USE_ETHERNET_LAN8670",
+    "ENC28J60": "USE_ETHERNET_ENC28J60",
 }
 
 
@@ -155,11 +157,16 @@ _IDF6_ETHERNET_COMPONENTS: dict[str, IDFRegistryComponent] = {
     "KSZ8081RNA": IDFRegistryComponent("espressif/ksz80xx", "1.0.0"),
     "W5500": IDFRegistryComponent("espressif/w5500", "1.0.1"),
     "DM9051": IDFRegistryComponent("espressif/dm9051", "1.0.0"),
+    "ENC28J60": IDFRegistryComponent("espressif/enc28j60", "1.0.1"),
+    "LAN8670": IDFRegistryComponent("espressif/lan867x", "2.0.0"),
 }
 
-SPI_ETHERNET_TYPES = ["W5500", "DM9051"]
+# These types are always external IDF components (never built-in to ESP-IDF)
+_ALWAYS_EXTERNAL_IDF_COMPONENTS = {"LAN8670", "ENC28J60"}
+
+SPI_ETHERNET_TYPES = ["W5500", "DM9051", "ENC28J60"]
 # RP2040-supported SPI ethernet types
-RP2040_SPI_ETHERNET_TYPES = ["W5500"]
+RP2040_SPI_ETHERNET_TYPES = ["W5500", "ENC28J60"]
 SPI_ETHERNET_DEFAULT_POLLING_INTERVAL = TimePeriodMilliseconds(milliseconds=10)
 
 emac_rmii_clock_mode_t = cg.global_ns.enum("emac_rmii_clock_mode_t")
@@ -220,7 +227,18 @@ def _validate(config):
 
     if CORE.is_esp32:
         if config[CONF_TYPE] in SPI_ETHERNET_TYPES:
-            if _is_framework_spi_polling_mode_supported():
+            # ENC28J60 driver does not support polling mode - interrupt is required
+            if config[CONF_TYPE] == "ENC28J60":
+                if CONF_POLLING_INTERVAL in config:
+                    raise cv.Invalid(
+                        f"'{CONF_POLLING_INTERVAL}' is not supported for ENC28J60. "
+                        f"'{CONF_INTERRUPT_PIN}' is required."
+                    )
+                if CONF_INTERRUPT_PIN not in config:
+                    raise cv.Invalid(
+                        f"'{CONF_INTERRUPT_PIN}' is a required option for ENC28J60."
+                    )
+            elif _is_framework_spi_polling_mode_supported():
                 if CONF_POLLING_INTERVAL in config and CONF_INTERRUPT_PIN in config:
                     raise cv.Invalid(
                         f"Cannot specify more than one of {CONF_INTERRUPT_PIN}, {CONF_POLLING_INTERVAL}"
@@ -367,6 +385,7 @@ CONFIG_SCHEMA = cv.All(
             "W5500": SPI_SCHEMA,
             "OPENETH": cv.All(BASE_SCHEMA, cv.only_on([Platform.ESP32])),
             "DM9051": SPI_SCHEMA,
+            "ENC28J60": SPI_SCHEMA,
             "LAN8670": RMII_SCHEMA,
         },
         upper=True,
@@ -502,7 +521,8 @@ async def _to_code_esp32(var: cg.Pvariable, config: ConfigType) -> None:
         cg.add_define("USE_ETHERNET_SPI")
         add_idf_sdkconfig_option("CONFIG_ETH_USE_SPI_ETHERNET", True)
         # CONFIG_ETH_SPI_ETHERNET_{TYPE} Kconfig options were removed in IDF 6.0
-        if idf_version() < cv.Version(6, 0, 0):
+        # ENC28J60 was never built-in to IDF, so it has no Kconfig option
+        if idf_version() < cv.Version(6, 0, 0) and config[CONF_TYPE] != "ENC28J60":
             add_idf_sdkconfig_option(
                 f"CONFIG_ETH_SPI_ETHERNET_{config[CONF_TYPE]}", True
             )
@@ -533,12 +553,11 @@ async def _to_code_esp32(var: cg.Pvariable, config: ConfigType) -> None:
     # Re-enable ESP-IDF's Ethernet driver (excluded by default to save compile time)
     include_builtin_idf_component("esp_eth")
 
-    if config[CONF_TYPE] == "LAN8670":
-        # Add LAN867x 10BASE-T1S PHY support component
-        add_idf_component(name="espressif/lan867x", ref="2.0.0")
-
-    # IDF 6.0 moved per-chip PHY/MAC drivers to the Espressif Component Registry
-    if idf_version() >= cv.Version(6, 0, 0) and (
+    if config[CONF_TYPE] in _ALWAYS_EXTERNAL_IDF_COMPONENTS:
+        component = _IDF6_ETHERNET_COMPONENTS[config[CONF_TYPE]]
+        add_idf_component(name=component.name, ref=component.version)
+    elif idf_version() >= cv.Version(6, 0, 0) and (
+        # IDF 6.0 moved per-chip PHY/MAC drivers to the Espressif Component Registry
         component := _IDF6_ETHERNET_COMPONENTS.get(config[CONF_TYPE])
     ):
         add_idf_component(name=component.name, ref=component.version)
@@ -555,7 +574,10 @@ async def _to_code_rp2040(var: cg.Pvariable, config: ConfigType) -> None:
         cg.add(var.set_reset_pin(config[CONF_RESET_PIN]))
 
     cg.add_define("USE_ETHERNET_SPI")
-    cg.add_library("lwIP_w5500", None)
+    if config[CONF_TYPE] == "ENC28J60":
+        cg.add_library("lwIP_enc28j60", None)
+    else:
+        cg.add_library("lwIP_w5500", None)
 
 
 def _final_validate_rmii_pins(config: ConfigType) -> None:
diff --git a/esphome/components/ethernet/ethernet_component.h b/esphome/components/ethernet/ethernet_component.h
index b6699e8020..4c85c39eb8 100644
--- a/esphome/components/ethernet/ethernet_component.h
+++ b/esphome/components/ethernet/ethernet_component.h
@@ -23,7 +23,13 @@ extern "C" eth_esp32_emac_config_t eth_esp32_emac_default_config(void);
 #endif  // USE_ESP32
 
 #ifdef USE_RP2040
+#if defined(USE_ETHERNET_W5500)
 #include <W5500lwIP.h>
+#elif defined(USE_ETHERNET_ENC28J60)
+#include <ENC28J60lwIP.h>
+#else
+#error "Unsupported RP2040 SPI Ethernet type"
+#endif
 #endif
 
 namespace esphome::ethernet {
@@ -57,6 +63,7 @@ enum EthernetType : uint8_t {
   ETHERNET_TYPE_OPENETH,
   ETHERNET_TYPE_DM9051,
   ETHERNET_TYPE_LAN8670,
+  ETHERNET_TYPE_ENC28J60,
 };
 
 struct ManualIP {
@@ -215,7 +222,13 @@ class EthernetComponent final : public Component {
 
 #ifdef USE_RP2040
   static constexpr uint32_t LINK_CHECK_INTERVAL = 500;  // ms between link/IP polls
+#if defined(USE_ETHERNET_W5500)
   Wiznet5500lwIP *eth_{nullptr};
+#elif defined(USE_ETHERNET_ENC28J60)
+  ENC28J60lwIP *eth_{nullptr};
+#else
+#error "Unsupported RP2040 SPI Ethernet type"
+#endif
   uint32_t last_link_check_{0};
   uint8_t clk_pin_;
   uint8_t miso_pin_;
diff --git a/esphome/components/ethernet/ethernet_component_esp32.cpp b/esphome/components/ethernet/ethernet_component_esp32.cpp
index fb69a901aa..a170239e03 100644
--- a/esphome/components/ethernet/ethernet_component_esp32.cpp
+++ b/esphome/components/ethernet/ethernet_component_esp32.cpp
@@ -44,6 +44,11 @@
 #include "esp_eth_phy_lan867x.h"
 #endif
 
+// ENC28J60 header exists on all IDF versions (always an external component)
+#ifdef USE_ETHERNET_ENC28J60
+#include "esp_eth_enc28j60.h"
+#endif
+
 #ifdef USE_ETHERNET_SPI
 #include <driver/gpio.h>
 #include <driver/spi_master.h>
@@ -194,25 +199,27 @@ void EthernetComponent::setup() {
       .post_cb = nullptr,
   };
 
-#ifdef USE_ETHERNET_W5500
+#if defined(USE_ETHERNET_W5500)
   eth_w5500_config_t w5500_config = ETH_W5500_DEFAULT_CONFIG(host, &devcfg);
-#endif
-#ifdef USE_ETHERNET_DM9051
+#elif defined(USE_ETHERNET_DM9051)
   eth_dm9051_config_t dm9051_config = ETH_DM9051_DEFAULT_CONFIG(host, &devcfg);
+#elif defined(USE_ETHERNET_ENC28J60)
+  eth_enc28j60_config_t enc28j60_config = ETH_ENC28J60_DEFAULT_CONFIG(host, &devcfg);
 #endif
 
-#ifdef USE_ETHERNET_W5500
+#if defined(USE_ETHERNET_W5500)
   w5500_config.int_gpio_num = this->interrupt_pin_;
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
   w5500_config.poll_period_ms = this->polling_interval_;
 #endif
-#endif
-
-#ifdef USE_ETHERNET_DM9051
+#elif defined(USE_ETHERNET_DM9051)
   dm9051_config.int_gpio_num = this->interrupt_pin_;
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
   dm9051_config.poll_period_ms = this->polling_interval_;
 #endif
+#elif defined(USE_ETHERNET_ENC28J60)
+  enc28j60_config.int_gpio_num = this->interrupt_pin_;
+  // ENC28J60 does not support poll_period_ms
 #endif
 
   phy_config.phy_addr = this->phy_addr_spi_;
@@ -300,19 +307,24 @@ void EthernetComponent::setup() {
 #endif
 #endif
 #ifdef USE_ETHERNET_SPI
-#ifdef USE_ETHERNET_W5500
+#if defined(USE_ETHERNET_W5500)
     case ETHERNET_TYPE_W5500: {
       mac = esp_eth_mac_new_w5500(&w5500_config, &mac_config);
       this->phy_ = esp_eth_phy_new_w5500(&phy_config);
       break;
     }
-#endif
-#ifdef USE_ETHERNET_DM9051
+#elif defined(USE_ETHERNET_DM9051)
     case ETHERNET_TYPE_DM9051: {
       mac = esp_eth_mac_new_dm9051(&dm9051_config, &mac_config);
       this->phy_ = esp_eth_phy_new_dm9051(&phy_config);
       break;
     }
+#elif defined(USE_ETHERNET_ENC28J60)
+    case ETHERNET_TYPE_ENC28J60: {
+      mac = esp_eth_mac_new_enc28j60(&enc28j60_config, &mac_config);
+      this->phy_ = esp_eth_phy_new_enc28j60(&phy_config);
+      break;
+    }
 #endif
 #endif
     default: {
@@ -405,15 +417,18 @@ void EthernetComponent::dump_config() {
       eth_type = "KSZ8081RNA";
       break;
 #endif
-#ifdef USE_ETHERNET_W5500
+#if defined(USE_ETHERNET_W5500)
     case ETHERNET_TYPE_W5500:
       eth_type = "W5500";
       break;
-#endif
-#ifdef USE_ETHERNET_DM9051
+#elif defined(USE_ETHERNET_DM9051)
     case ETHERNET_TYPE_DM9051:
       eth_type = "DM9051";
       break;
+#elif defined(USE_ETHERNET_ENC28J60)
+    case ETHERNET_TYPE_ENC28J60:
+      eth_type = "ENC28J60";
+      break;
 #endif
 #ifdef USE_ETHERNET_OPENETH
     case ETHERNET_TYPE_OPENETH:
diff --git a/esphome/components/ethernet/ethernet_component_rp2040.cpp b/esphome/components/ethernet/ethernet_component_rp2040.cpp
index 77b1a22d66..bd8c458985 100644
--- a/esphome/components/ethernet/ethernet_component_rp2040.cpp
+++ b/esphome/components/ethernet/ethernet_component_rp2040.cpp
@@ -31,11 +31,15 @@ void EthernetComponent::setup() {
     reset_pin.digital_write(false);
     delay(1);  // NOLINT
     reset_pin.digital_write(true);
-    delay(10);  // NOLINT - wait for W5500 to initialize after reset
+    delay(10);  // NOLINT - wait for chip to initialize after reset
   }
 
-  // Create the W5500 device instance
+  // Create the SPI Ethernet device instance
+#if defined(USE_ETHERNET_W5500)
   this->eth_ = new Wiznet5500lwIP(this->cs_pin_, SPI, this->interrupt_pin_);  // NOLINT
+#elif defined(USE_ETHERNET_ENC28J60)
+  this->eth_ = new ENC28J60lwIP(this->cs_pin_, SPI, this->interrupt_pin_);  // NOLINT
+#endif
 
   // Set hostname before begin() so the LWIP netif gets it
   this->eth_->hostname(App.get_name().c_str());
@@ -61,7 +65,7 @@ void EthernetComponent::setup() {
   }
 
   if (!success) {
-    ESP_LOGE(TAG, "Failed to initialize W5500 Ethernet");
+    ESP_LOGE(TAG, "Failed to initialize Ethernet");
     delete this->eth_;  // NOLINT(cppcoreguidelines-owning-memory)
     this->eth_ = nullptr;
     this->mark_failed();
@@ -164,9 +168,15 @@ void EthernetComponent::loop() {
 }
 
 void EthernetComponent::dump_config() {
+  const char *type_str = "Unknown";
+#if defined(USE_ETHERNET_W5500)
+  type_str = "W5500";
+#elif defined(USE_ETHERNET_ENC28J60)
+  type_str = "ENC28J60";
+#endif
   ESP_LOGCONFIG(TAG,
                 "Ethernet:\n"
-                "  Type: W5500\n"
+                "  Type: %s\n"
                 "  Connected: %s\n"
                 "  CLK Pin: %u\n"
                 "  MISO Pin: %u\n"
@@ -174,7 +184,7 @@ void EthernetComponent::dump_config() {
                 "  CS Pin: %u\n"
                 "  IRQ Pin: %d\n"
                 "  Reset Pin: %d",
-                YESNO(this->is_connected()), this->clk_pin_, this->miso_pin_, this->mosi_pin_, this->cs_pin_,
+                type_str, YESNO(this->is_connected()), this->clk_pin_, this->miso_pin_, this->mosi_pin_, this->cs_pin_,
                 this->interrupt_pin_, this->reset_pin_);
   this->dump_connect_params_();
 }
@@ -216,13 +226,18 @@ const char *EthernetComponent::get_eth_mac_address_pretty_into_buffer(
 }
 
 eth_duplex_t EthernetComponent::get_duplex_mode() {
-  // W5500 is always full duplex
+  // Both W5500 and ENC28J60 are full-duplex on RP2040
   return ETH_DUPLEX_FULL;
 }
 
 eth_speed_t EthernetComponent::get_link_speed() {
+#ifdef USE_ETHERNET_ENC28J60
+  // ENC28J60 is 10Mbps only
+  return ETH_SPEED_10M;
+#else
   // W5500 is always 100Mbps
   return ETH_SPEED_100M;
+#endif
 }
 
 bool EthernetComponent::powerdown() {
diff --git a/tests/components/ethernet/common-enc28j60-rp2040.yaml b/tests/components/ethernet/common-enc28j60-rp2040.yaml
new file mode 100644
index 0000000000..0718723d8a
--- /dev/null
+++ b/tests/components/ethernet/common-enc28j60-rp2040.yaml
@@ -0,0 +1,18 @@
+ethernet:
+  type: ENC28J60
+  clk_pin: 18
+  mosi_pin: 19
+  miso_pin: 16
+  cs_pin: 17
+  interrupt_pin: 21
+  reset_pin: 20
+  manual_ip:
+    static_ip: 192.168.178.56
+    gateway: 192.168.178.1
+    subnet: 255.255.255.0
+  domain: .local
+  mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-enc28j60.yaml b/tests/components/ethernet/common-enc28j60.yaml
new file mode 100644
index 0000000000..6b288bed19
--- /dev/null
+++ b/tests/components/ethernet/common-enc28j60.yaml
@@ -0,0 +1,19 @@
+ethernet:
+  type: ENC28J60
+  clk_pin: 19
+  mosi_pin: 21
+  miso_pin: 23
+  cs_pin: 18
+  interrupt_pin: 36
+  reset_pin: 22
+  clock_speed: 10Mhz
+  manual_ip:
+    static_ip: 192.168.178.56
+    gateway: 192.168.178.1
+    subnet: 255.255.255.0
+  domain: .local
+  mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/test-enc28j60.esp32-idf.yaml b/tests/components/ethernet/test-enc28j60.esp32-idf.yaml
new file mode 100644
index 0000000000..b7c1b7f5aa
--- /dev/null
+++ b/tests/components/ethernet/test-enc28j60.esp32-idf.yaml
@@ -0,0 +1 @@
+<<: !include common-enc28j60.yaml
diff --git a/tests/components/ethernet/test-enc28j60.rp2040-ard.yaml b/tests/components/ethernet/test-enc28j60.rp2040-ard.yaml
new file mode 100644
index 0000000000..61d1cd86f5
--- /dev/null
+++ b/tests/components/ethernet/test-enc28j60.rp2040-ard.yaml
@@ -0,0 +1 @@
+<<: !include common-enc28j60-rp2040.yaml

From 11b829dda17b8cca2174272069caf36d0dca2628 Mon Sep 17 00:00:00 2001
From: Daniel Kent <129895318+danielkent-net@users.noreply.github.com>
Date: Mon, 23 Mar 2026 15:59:17 -0400
Subject: [PATCH 52/60] [spa06_spi] Add SPA06-003 Temperature and Pressure
 Sensor - SPI support (Part 3 of 3) (#14523)

Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
---
 CODEOWNERS                                    |  1 +
 esphome/components/spa06_spi/__init__.py      |  0
 esphome/components/spa06_spi/sensor.py        | 41 +++++++++++
 esphome/components/spa06_spi/spa06_spi.cpp    | 72 +++++++++++++++++++
 esphome/components/spa06_spi/spa06_spi.h      | 22 ++++++
 tests/components/spa06_spi/common.yaml        | 15 ++++
 .../components/spa06_spi/test.esp32-idf.yaml  |  7 ++
 .../spa06_spi/test.esp8266-ard.yaml           |  7 ++
 .../components/spa06_spi/test.rp2040-ard.yaml |  7 ++
 9 files changed, 172 insertions(+)
 create mode 100644 esphome/components/spa06_spi/__init__.py
 create mode 100644 esphome/components/spa06_spi/sensor.py
 create mode 100644 esphome/components/spa06_spi/spa06_spi.cpp
 create mode 100644 esphome/components/spa06_spi/spa06_spi.h
 create mode 100644 tests/components/spa06_spi/common.yaml
 create mode 100644 tests/components/spa06_spi/test.esp32-idf.yaml
 create mode 100644 tests/components/spa06_spi/test.esp8266-ard.yaml
 create mode 100644 tests/components/spa06_spi/test.rp2040-ard.yaml

diff --git a/CODEOWNERS b/CODEOWNERS
index e3e09cbc11..afe4cdb871 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -459,6 +459,7 @@ esphome/components/sonoff_d1/* @anatoly-savchenkov
 esphome/components/sound_level/* @kahrendt
 esphome/components/spa06_base/* @danielkent-net
 esphome/components/spa06_i2c/* @danielkent-net
+esphome/components/spa06_spi/* @danielkent-net
 esphome/components/speaker/* @jesserockz @kahrendt
 esphome/components/speaker/media_player/* @kahrendt @synesthesiam
 esphome/components/speaker_source/* @kahrendt
diff --git a/esphome/components/spa06_spi/__init__.py b/esphome/components/spa06_spi/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/esphome/components/spa06_spi/sensor.py b/esphome/components/spa06_spi/sensor.py
new file mode 100644
index 0000000000..b82186ec21
--- /dev/null
+++ b/esphome/components/spa06_spi/sensor.py
@@ -0,0 +1,41 @@
+import logging
+
+import esphome.codegen as cg
+from esphome.components import spi
+from esphome.components.spi import CONF_SPI_MODE
+import esphome.config_validation as cv
+
+from ..spa06_base import CONFIG_SCHEMA_BASE, to_code_base
+
+AUTO_LOAD = ["spa06_base"]
+CODEOWNERS = ["@danielkent-net"]
+DEPENDENCIES = ["spi"]
+
+spa06_ns = cg.esphome_ns.namespace("spa06_spi")
+SPA06SPIComponent = spa06_ns.class_(
+    "SPA06SPIComponent", cg.PollingComponent, spi.SPIDevice
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+VALID_SPI_MODES = {3: "MODE3", "3": "MODE3", "MODE3": "MODE3"}
+
+
+def check_spi_mode(config):
+    spi_mode = config.get(CONF_SPI_MODE)
+    if spi_mode not in VALID_SPI_MODES:
+        raise cv.Invalid("SPA06 only supports SPI mode 3")
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    CONFIG_SCHEMA_BASE.extend(spi.spi_device_schema(default_mode="mode3")).extend(
+        {cv.GenerateID(): cv.declare_id(SPA06SPIComponent)}
+    ),
+    check_spi_mode,
+)
+
+
+async def to_code(config):
+    var = await to_code_base(config)
+    await spi.register_spi_device(var, config)
diff --git a/esphome/components/spa06_spi/spa06_spi.cpp b/esphome/components/spa06_spi/spa06_spi.cpp
new file mode 100644
index 0000000000..9f3683d219
--- /dev/null
+++ b/esphome/components/spa06_spi/spa06_spi.cpp
@@ -0,0 +1,72 @@
+#include <cstdint>
+#include <cstddef>
+
+#include "spa06_spi.h"
+#include "esphome/components/spa06_base/spa06_base.h"
+#include "esphome/components/spi/spi.h"
+
+// OR (|) register with SPA06_SPI_READ for read.
+inline constexpr uint8_t SPA06_SPI_READ = 0x80;
+
+// AND (&) register with SPA06_SPI_WRITE for write.
+inline constexpr uint8_t SPA06_SPI_WRITE = 0x7F;
+
+namespace esphome::spa06_spi {
+
+static const char *const TAG = "spa06_spi";
+
+void SPA06SPIComponent::dump_config() {
+  SPA06Component::dump_config();
+  LOG_SPI_DEVICE(this)
+}
+
+void SPA06SPIComponent::setup() {
+  this->spi_setup();
+  SPA06Component::setup();
+}
+
+void SPA06SPIComponent::protocol_reset() {
+  // Forces the device into SPI mode using a dummy read
+  uint8_t dummy_read = 0;
+  this->spa_read_byte(spa06_base::SPA06_ID, &dummy_read);
+}
+
+// In SPI mode, only 7 bits of the register addresses are used; the MSB of register address
+// is not used and replaced by a read/write bit (RW = ‘0’ for write and RW = ‘1’ for read).
+// Example: address 0xF7 is accessed by using SPI register address 0x77. For write access,
+// the byte 0x77 is transferred, for read access, the byte 0xF7 is transferred.
+// The expressions SPA06_SPI_READ (| with register) and SPA06_SPI_WRITE (& with register)
+// are defined for readability.
+
+bool SPA06SPIComponent::spa_read_byte(uint8_t a_register, uint8_t *data) {
+  this->enable();
+  this->transfer_byte(a_register | SPA06_SPI_READ);
+  *data = this->transfer_byte(0);
+  this->disable();
+  return true;
+}
+
+bool SPA06SPIComponent::spa_write_byte(uint8_t a_register, uint8_t data) {
+  this->enable();
+  this->transfer_byte(a_register & SPA06_SPI_WRITE);
+  this->transfer_byte(data);
+  this->disable();
+  return true;
+}
+
+bool SPA06SPIComponent::spa_read_bytes(uint8_t a_register, uint8_t *data, size_t len) {
+  this->enable();
+  this->transfer_byte(a_register | SPA06_SPI_READ);
+  this->read_array(data, len);
+  this->disable();
+  return true;
+}
+
+bool SPA06SPIComponent::spa_write_bytes(uint8_t a_register, uint8_t *data, size_t len) {
+  this->enable();
+  this->transfer_byte(a_register & SPA06_SPI_WRITE);
+  this->write_array(data, len);
+  this->disable();
+  return true;
+}
+}  // namespace esphome::spa06_spi
diff --git a/esphome/components/spa06_spi/spa06_spi.h b/esphome/components/spa06_spi/spa06_spi.h
new file mode 100644
index 0000000000..ffbc162d6f
--- /dev/null
+++ b/esphome/components/spa06_spi/spa06_spi.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "esphome/components/spa06_base/spa06_base.h"
+#include "esphome/components/spi/spi.h"
+
+namespace esphome::spa06_spi {
+
+class SPA06SPIComponent : public spa06_base::SPA06Component,
+                          public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH,
+                                                spi::CLOCK_PHASE_TRAILING, spi::DATA_RATE_200KHZ> {
+  void setup() override;
+  bool spa_read_byte(uint8_t a_register, uint8_t *data) override;
+  bool spa_write_byte(uint8_t a_register, uint8_t data) override;
+  bool spa_read_bytes(uint8_t a_register, uint8_t *data, size_t len) override;
+  bool spa_write_bytes(uint8_t a_register, uint8_t *data, size_t len) override;
+  void dump_config() override;
+
+ protected:
+  void protocol_reset() override;
+};
+
+}  // namespace esphome::spa06_spi
diff --git a/tests/components/spa06_spi/common.yaml b/tests/components/spa06_spi/common.yaml
new file mode 100644
index 0000000000..9263202ab4
--- /dev/null
+++ b/tests/components/spa06_spi/common.yaml
@@ -0,0 +1,15 @@
+sensor:
+  - platform: spa06_spi
+    spi_id: spi_bus
+    cs_pin: ${cs_pin}
+    temperature:
+      id: spa06_spi_temperature
+      name: Outside Temperature
+      sample_rate: 1
+      oversampling: NONE
+    pressure:
+      name: Outside Pressure
+      id: spa06_spi_pressure
+      sample_rate: 25p4
+      oversampling: 16X
+    update_interval: 15s
diff --git a/tests/components/spa06_spi/test.esp32-idf.yaml b/tests/components/spa06_spi/test.esp32-idf.yaml
new file mode 100644
index 0000000000..a3352cf880
--- /dev/null
+++ b/tests/components/spa06_spi/test.esp32-idf.yaml
@@ -0,0 +1,7 @@
+substitutions:
+  cs_pin: GPIO5
+
+packages:
+  spi: !include ../../test_build_components/common/spi/esp32-idf.yaml
+
+<<: !include common.yaml
diff --git a/tests/components/spa06_spi/test.esp8266-ard.yaml b/tests/components/spa06_spi/test.esp8266-ard.yaml
new file mode 100644
index 0000000000..595f31046a
--- /dev/null
+++ b/tests/components/spa06_spi/test.esp8266-ard.yaml
@@ -0,0 +1,7 @@
+substitutions:
+  cs_pin: GPIO15
+
+packages:
+  spi: !include ../../test_build_components/common/spi/esp8266-ard.yaml
+
+<<: !include common.yaml
diff --git a/tests/components/spa06_spi/test.rp2040-ard.yaml b/tests/components/spa06_spi/test.rp2040-ard.yaml
new file mode 100644
index 0000000000..93e19cfea4
--- /dev/null
+++ b/tests/components/spa06_spi/test.rp2040-ard.yaml
@@ -0,0 +1,7 @@
+substitutions:
+  cs_pin: GPIO17
+
+packages:
+  spi: !include ../../test_build_components/common/spi/rp2040-ard.yaml
+
+<<: !include common.yaml

From 6956bf7e539589ee06282d8560b97f91989397c3 Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Tue, 24 Mar 2026 07:24:25 +1000
Subject: [PATCH 53/60] [text] Add text_sensor for read-only view of text
 component (#15090)

---
 .../components/text/text_sensor/__init__.py   | 25 +++++++++++++++++++
 .../text/text_sensor/text_text_sensor.cpp     | 16 ++++++++++++
 .../text/text_sensor/text_text_sensor.h       | 19 ++++++++++++++
 tests/components/text/common.yaml             |  5 ++++
 4 files changed, 65 insertions(+)
 create mode 100644 esphome/components/text/text_sensor/__init__.py
 create mode 100644 esphome/components/text/text_sensor/text_text_sensor.cpp
 create mode 100644 esphome/components/text/text_sensor/text_text_sensor.h

diff --git a/esphome/components/text/text_sensor/__init__.py b/esphome/components/text/text_sensor/__init__.py
new file mode 100644
index 0000000000..5e45f10193
--- /dev/null
+++ b/esphome/components/text/text_sensor/__init__.py
@@ -0,0 +1,25 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_SOURCE_ID
+
+from .. import Text, text_ns
+
+TextTextSensor = text_ns.class_("TextTextSensor", text_sensor.TextSensor, cg.Component)
+
+
+CONFIG_SCHEMA = (
+    text_sensor.text_sensor_schema(TextTextSensor)
+    .extend(
+        {
+            cv.Required(CONF_SOURCE_ID): cv.use_id(Text),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    source = await cg.get_variable(config[CONF_SOURCE_ID])
+    var = await text_sensor.new_text_sensor(config, source)
+    await cg.register_component(var, config)
diff --git a/esphome/components/text/text_sensor/text_text_sensor.cpp b/esphome/components/text/text_sensor/text_text_sensor.cpp
new file mode 100644
index 0000000000..50504c605e
--- /dev/null
+++ b/esphome/components/text/text_sensor/text_text_sensor.cpp
@@ -0,0 +1,16 @@
+#include "text_text_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome::text {
+
+static const char *const TAG = "text.text_sensor";
+
+void TextTextSensor::setup() {
+  this->source_->add_on_state_callback([this](const std::string &value) { this->publish_state(value); });
+  if (this->source_->has_state())
+    this->publish_state(this->source_->state);
+}
+
+void TextTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Text Text Sensor", this); }
+
+}  // namespace esphome::text
diff --git a/esphome/components/text/text_sensor/text_text_sensor.h b/esphome/components/text/text_sensor/text_text_sensor.h
new file mode 100644
index 0000000000..fd70ea3451
--- /dev/null
+++ b/esphome/components/text/text_sensor/text_text_sensor.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "../text.h"
+#include "esphome/core/component.h"
+#include "esphome/components/text_sensor/text_sensor.h"
+
+namespace esphome::text {
+
+class TextTextSensor : public text_sensor::TextSensor, public Component {
+ public:
+  explicit TextTextSensor(Text *source) : source_(source) {}
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  Text *source_;
+};
+
+}  // namespace esphome::text
diff --git a/tests/components/text/common.yaml b/tests/components/text/common.yaml
index 26618be03a..561d17143f 100644
--- a/tests/components/text/common.yaml
+++ b/tests/components/text/common.yaml
@@ -23,3 +23,8 @@ text:
     min_length: 8
     max_length: 32
     mode: password
+
+text_sensor:
+  - platform: text
+    name: "Test Text State"
+    source_id: test_text

From 332118db5644b161c09c90f64e07f2289d6f86a9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Mar 2026 11:44:26 -1000
Subject: [PATCH 54/60] Bump pytest-cov from 7.0.0 to 7.1.0 (#15123)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements_test.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements_test.txt b/requirements_test.txt
index 0d3f0671f5..1440b20333 100644
--- a/requirements_test.txt
+++ b/requirements_test.txt
@@ -6,7 +6,7 @@ pre-commit
 
 # Unit tests
 pytest==9.0.2
-pytest-cov==7.0.0
+pytest-cov==7.1.0
 pytest-mock==3.15.1
 pytest-asyncio==1.3.0
 pytest-xdist==3.8.0

From bf6000ef3d38bf663d4fc2d69a220d5a64889e78 Mon Sep 17 00:00:00 2001
From: Javier Peletier <jpeletier@users.noreply.github.com>
Date: Mon, 23 Mar 2026 23:50:28 +0100
Subject: [PATCH 55/60] [substitutions] substitutions pass and !include
 redesign (package refactor part 2b) (#14918)

Co-authored-by: J. Nick Koston <nick@home-assistant.io>
Co-authored-by: J. Nick Koston <nick@koston.org>
---
 esphome/components/packages/__init__.py       |   9 +-
 esphome/components/substitutions/__init__.py  | 444 +++++++++++++-----
 esphome/components/substitutions/jinja.py     |  94 +---
 esphome/config.py                             |  30 +-
 esphome/yaml_util.py                          |  41 +-
 .../component_tests/packages/test_packages.py |   2 +
 .../substitutions/00-simple_var.approved.yaml |  17 +
 .../substitutions/00-simple_var.input.yaml    |  10 +
 .../02-expressions.approved.yaml              |   6 +
 .../substitutions/02-expressions.input.yaml   |   6 +
 .../07-package_merging.approved.yaml          |  46 ++
 .../07-package_merging.input.yaml             |  63 +++
 ...-include_vars_without_substs.approved.yaml |   5 +
 .../09-include_vars_without_substs.input.yaml |   7 +
 tests/unit_tests/test_substitutions.py        | 244 +++++++++-
 tests/unit_tests/test_yaml_util.py            |   2 +-
 16 files changed, 753 insertions(+), 273 deletions(-)
 create mode 100644 tests/unit_tests/fixtures/substitutions/07-package_merging.approved.yaml
 create mode 100644 tests/unit_tests/fixtures/substitutions/07-package_merging.input.yaml
 create mode 100644 tests/unit_tests/fixtures/substitutions/09-include_vars_without_substs.approved.yaml
 create mode 100644 tests/unit_tests/fixtures/substitutions/09-include_vars_without_substs.input.yaml

diff --git a/esphome/components/packages/__init__.py b/esphome/components/packages/__init__.py
index 6d353ccf11..793cb946dd 100644
--- a/esphome/components/packages/__init__.py
+++ b/esphome/components/packages/__init__.py
@@ -226,7 +226,7 @@ def _process_remote_package(config: dict, skip_update: bool = False) -> dict:
                         raise cv.Invalid(
                             f"Current ESPHome Version is too old to use this package: {ESPHOME_VERSION} < {min_version}"
                         )
-                new_yaml = yaml_util.substitute_vars(new_yaml, vars)
+                new_yaml = yaml_util.add_context(new_yaml, vars or None)
                 packages[f"{filename}{idx}"] = new_yaml
             except EsphomeError as e:
                 raise cv.Invalid(
@@ -296,6 +296,13 @@ def do_packages_pass(config: dict, skip_update: bool = False) -> dict:
 
     def process_package_callback(package_config: dict) -> dict:
         """This will be called for each package found in the config."""
+        if isinstance(package_config, yaml_util.ConfigContext):
+            context_vars = package_config.vars
+            if CONF_PACKAGES in package_config or CONF_URL in package_config:
+                # Remote package definition: eagerly resolve before PACKAGE_SCHEMA validation.
+                from esphome.components.substitutions import substitute_context_vars
+
+                substitute_context_vars(package_config, context_vars)
         package_config = PACKAGE_SCHEMA(package_config)
         if isinstance(package_config, str):
             return package_config  # Jinja string, skip processing
diff --git a/esphome/components/substitutions/__init__.py b/esphome/components/substitutions/__init__.py
index 7e15f714f7..ecee816ce9 100644
--- a/esphome/components/substitutions/__init__.py
+++ b/esphome/components/substitutions/__init__.py
@@ -1,31 +1,50 @@
+from collections import ChainMap
 import logging
-from re import Match
 from typing import Any
 
 from esphome import core
 from esphome.config_helpers import Extend, Remove, merge_config, merge_dicts_ordered
 import esphome.config_validation as cv
 from esphome.const import CONF_SUBSTITUTIONS, VALID_SUBSTITUTIONS_CHARACTERS
-from esphome.yaml_util import ESPHomeDataBase, ESPLiteralValue, make_data_base
+from esphome.types import ConfigType
+from esphome.util import OrderedDict
+from esphome.yaml_util import (
+    ConfigContext,
+    ESPHomeDataBase,
+    ESPLiteralValue,
+    make_data_base,
+)
 
-from .jinja import Jinja, JinjaError, JinjaStr, has_jinja
+from .jinja import Jinja, JinjaError, Missing, Resolver, UndefinedError, has_jinja
 
 CODEOWNERS = ["@esphome/core"]
 _LOGGER = logging.getLogger(__name__)
 
+ContextVars = ChainMap[str, Any]
+SubstitutionPath = list[int | str]
+ErrList = list[tuple[UndefinedError, SubstitutionPath, Any]]
+# Module-level instance is safe: context_vars is passed per-call, and context_trace
+# is stack-saved/restored within expand(). Not thread-safe — only use from one thread.
+jinja = Jinja()
 
-def validate_substitution_key(value):
+
+def validate_substitution_key(value: Any) -> str:
+    """Validate and normalize a substitution key, stripping a leading ``$`` if present."""
     value = cv.string(value)
     if not value:
         raise cv.Invalid("Substitution key must not be empty")
     if value[0] == "$":
         value = value[1:]
+    if not value:
+        raise cv.Invalid("Substitution key must not be empty")
     if value[0].isdigit():
         raise cv.Invalid("First character in substitutions cannot be a digit.")
     for char in value:
         if char not in VALID_SUBSTITUTIONS_CHARACTERS:
             raise cv.Invalid(
-                f"Substitution must only consist of upper/lowercase characters, the underscore and numbers. The character '{char}' cannot be used"
+                f"Substitution must only consist of upper/lowercase characters,"
+                f" the underscore and numbers."
+                f" The character '{char}' cannot be used"
             )
     return value
 
@@ -37,8 +56,8 @@ CONFIG_SCHEMA = cv.Schema(
 )
 
 
-async def to_code(config):
-    pass
+async def to_code(config: ConfigType) -> None:
+    """No runtime code generation needed — substitutions are resolved at config time."""
 
 
 def _restore_data_base(value: Any, orig_value: ESPHomeDataBase) -> ESPHomeDataBase:
@@ -62,91 +81,122 @@ def _restore_data_base(value: Any, orig_value: ESPHomeDataBase) -> ESPHomeDataBa
     return value
 
 
-def _expand_jinja(
-    value: str | JinjaStr,
-    orig_value: str | JinjaStr,
-    path,
-    jinja: Jinja,
-    ignore_missing: bool,
-) -> Any:
-    if has_jinja(value):
-        # If the original value passed in to this function is a JinjaStr, it means it contains an unresolved
-        # Jinja expression from a previous pass.
-        if isinstance(orig_value, JinjaStr):
-            # Rebuild the JinjaStr in case it was lost while replacing substitutions.
-            value = JinjaStr(value, orig_value.upvalues)
-        try:
-            # Invoke the jinja engine to evaluate the expression.
-            value, err = jinja.expand(value)
-            if err is not None and not ignore_missing and "password" not in path:
-                _LOGGER.warning(
-                    "Found '%s' (see %s) which looks like an expression,"
-                    " but could not resolve all the variables: %s",
-                    value,
-                    "->".join(str(x) for x in path),
-                    err.message,
-                )
-        except JinjaError as err:
-            raise cv.Invalid(
-                f"{err.error_name()} Error evaluating jinja expression '{value}': {str(err.parent())}."
-                f"\nEvaluation stack: (most recent evaluation last)\n{err.stack_trace_str()}"
-                f"\nRelevant context:\n{err.context_trace_str()}"
-                f"\nSee {'->'.join(str(x) for x in path)}",
-                path,
-            )
-        # If the original, unexpanded string, contained document metadata (ESPHomeDatabase),
-        # assign this same document metadata to the resulting value.
-        if isinstance(orig_value, ESPHomeDataBase):
-            value = _restore_data_base(value, orig_value)
+def _try_substitute(value: Any, context: ContextVars) -> Any:
+    """Substitute variables in value, returning the result or the original if unchanged."""
+    result = _substitute_item(value, [], context, strict_undefined=True)
+    return result if result is not None else value
 
-    return value
+
+def _resolve_var(name: str, context_vars: ContextVars) -> Any:
+    """Look up a substitution variable, falling back to the resolver callback."""
+    sub = context_vars.get(name, Missing)
+    if sub is Missing:
+        resolver = context_vars.get(Resolver)
+        if resolver:
+            sub = resolver(name)
+    return sub
+
+
+def _handle_undefined(
+    err: UndefinedError,
+    path: SubstitutionPath,
+    value: Any,
+    strict_undefined: bool,
+    errors: ErrList | None,
+) -> None:
+    """Handle an undefined variable.
+
+    In strict mode, raises immediately. Otherwise, appends to the errors
+    list for deferred warning at the end of the substitution pass.
+    """
+    if strict_undefined:
+        raise err
+    if errors is not None:
+        errors.append((err, path, value))
 
 
 def _expand_substitutions(
-    substitutions: dict, value: str, path, jinja: Jinja, ignore_missing: bool
+    value: str,
+    path: SubstitutionPath,
+    context_vars: ContextVars,
+    strict_undefined: bool,
+    errors: ErrList | None,
 ) -> Any:
+    """Expand ``$var``, ``${var}``, and Jinja expressions in a string.
+
+    Works in two phases:
+
+    1. **Simple substitution** — scan for ``$name`` / ``${name}`` tokens
+       and replace them with the value from *context_vars*.  If the token
+       spans the entire string, return the raw value (preserving type).
+    2. **Jinja evaluation** — if the result still contains Jinja syntax
+       (e.g. ``${a * b}``), render it through the Jinja engine with the
+       full *context_vars* as template variables.
+
+    Returns the expanded value (may be a non-string type) or the
+    original *value* unchanged if there is nothing to substitute.
+    """
     if "$" not in value:
         return value
 
     orig_value = value
 
-    i = 0
-    while True:
-        m: Match[str] = cv.VARIABLE_PROG.search(value, i)
-        if not m:
-            # No more variable substitutions found. See if the remainder looks like a jinja template
-            value = _expand_jinja(value, orig_value, path, jinja, ignore_missing)
-            break
-
-        i, j = m.span(0)
+    # Phase 1: Replace $var and ${var} references
+    search_pos = 0
+    while (m := cv.VARIABLE_PROG.search(value, search_pos)) is not None:
+        match_start, match_end = m.span(0)
         name: str = m.group(1)
         if name.startswith("{") and name.endswith("}"):
             name = name[1:-1]
-        if name not in substitutions:
-            if not ignore_missing and "password" not in path:
-                _LOGGER.warning(
-                    "Found '%s' (see %s) which looks like a substitution, but '%s' was "
-                    "not declared",
-                    orig_value,
-                    "->".join(str(x) for x in path),
-                    name,
-                )
-            i = j
+        sub = _resolve_var(name, context_vars)
+        if sub is Missing:
+            _handle_undefined(
+                err=UndefinedError(f"'{name}' is undefined"),
+                path=path,
+                value=value,
+                strict_undefined=strict_undefined,
+                errors=errors,
+            )
+            search_pos = match_end
             continue
 
-        sub: Any = substitutions[name]
-
-        if i == 0 and j == len(value):
-            # The variable spans the whole expression, e.g., "${varName}". Return its resolved value directly
-            # to conserve its type.
+        if match_start == 0 and match_end == len(value):
+            # The variable spans the whole expression, e.g., "${varName}".
+            # Return its resolved value directly to conserve its type.
             value = sub
             break
 
-        tail = value[j:]
-        value = value[:i] + str(sub)
-        i = len(value)
+        tail = value[match_end:]
+        value = value[:match_start] + str(sub)
+        search_pos = len(value)
         value += tail
 
+    # Phase 2: Evaluate any remaining jinja expressions (e.g., "${a * b}")
+    if isinstance(value, str) and has_jinja(value):
+        try:
+            value = jinja.expand(value, context_vars)
+        except UndefinedError as err:
+            _handle_undefined(
+                err=err,
+                path=path,
+                value=value,
+                strict_undefined=strict_undefined,
+                errors=errors,
+            )
+        except JinjaError as err:
+            raise cv.Invalid(
+                f"{err.error_name()} Error evaluating jinja expression"
+                f" '{value}': {str(err.parent())}."
+                f"\nEvaluation stack: (most recent evaluation last)"
+                f"\n{err.stack_trace_str()}"
+                f"\nRelevant context:\n{err.context_trace_str()}"
+                f"\nSee {'->'.join(str(x) for x in path)}",
+                path,
+            )
+        else:
+            if isinstance(orig_value, ESPHomeDataBase):
+                value = _restore_data_base(value, orig_value)
+
     # orig_value can also already be a lambda with esp_range info, and only
     # a plain string is sent in orig_value
     if isinstance(orig_value, ESPHomeDataBase):
@@ -157,83 +207,221 @@ def _expand_substitutions(
     return value
 
 
+def _push_context(
+    local_vars: dict[str, Any],
+    parent_context: ContextVars,
+    errors: ErrList | None = None,
+) -> tuple[ContextVars, dict[str, Any]]:
+    """Resolve local_vars and layer them on top of parent_context.
+
+    Returns ``(child_context, resolved_vars)`` where *child_context* is a
+    new :class:`ChainMap` whose front map is *resolved_vars* (an
+    :class:`OrderedDict` of successfully-resolved variables).
+
+    Variables may reference each other (e.g. ``b: ${a + 1}``).
+    Dependencies are resolved recursively via a *resolver* callback
+    that Jinja invokes on cache-miss.  If vars are already in
+    dependency order, the loop iterates exactly once per variable.
+
+    The ChainMap stack used during resolution is::
+
+        resolver_context  →  resolved_vars  →  parent maps …
+              ↑                    ↑
+        holds Resolver       filled as vars
+        callback               are resolved
+    """
+    # Vars still waiting to be resolved — popped one-by-one by resolve().
+    unresolved_vars = local_vars.copy()
+    # Accumulates resolved values in dependency order; becomes the front
+    # map of the returned child context so later lookups find them first.
+    resolved_vars = OrderedDict()
+    # The context callees will search: resolved_vars (initially empty)
+    # shadowing whatever the parent already provides.
+    context_vars = parent_context.new_child(resolved_vars)
+
+    # Vars that failed resolution (missing or circular references).
+    # Maps name → (original_value, cause_error) for deferred warnings.
+    unresolvables: dict[str, tuple[Any, UndefinedError]] = {}
+
+    # One extra child layer so the Resolver callback lives in its own
+    # map and doesn't pollute resolved_vars.
+    resolver_context = context_vars.new_child()
+
+    def resolve(key: str) -> Any:
+        """Resolve a variable, recursively resolving any dependencies it references."""
+        value = unresolved_vars.pop(key, Missing)
+        if value is Missing:
+            return Missing
+        try:
+            value = _try_substitute(value, resolver_context)
+        except UndefinedError as err:
+            unresolvables[key] = (value, err)
+            return Missing
+        resolved_vars[key] = value
+        return value
+
+    # Set up the resolver for use during substitution
+    resolver_context[Resolver] = resolve
+
+    # Resolve all variables, recursively resolving dependencies as needed.
+    # Each call to resolve() resolves that variable and any variables it depends on.
+    while unresolved_vars:
+        resolve(next(iter(unresolved_vars)))
+
+    for name, (value, cause) in unresolvables.items():
+        resolved_vars[name] = value
+        if errors is not None:
+            _handle_undefined(
+                err=UndefinedError(
+                    f"Could not resolve substitution variable '{name}': {cause}"
+                ),
+                path=["substitutions", name],
+                value=value,
+                strict_undefined=False,
+                errors=errors,
+            )
+
+    return context_vars, resolved_vars
+
+
+def push_context(
+    config_node: Any,
+    parent_context: ContextVars,
+    errors: ErrList | None = None,
+) -> ContextVars:
+    """Returns the context vars this config node must be evaluated with."""
+    if isinstance(config_node, ConfigContext):
+        return _push_context(config_node.vars, parent_context, errors)[0]
+
+    # This node does not define any vars itself, so just return parent context
+    return parent_context
+
+
 def _substitute_item(
-    substitutions: dict,
     item: Any,
-    path: list[int | str],
-    jinja: Jinja,
-    ignore_missing: bool,
+    path: SubstitutionPath,
+    parent_context: ContextVars,
+    strict_undefined: bool,
+    errors: ErrList | None = None,
 ) -> Any | None:
-    if isinstance(item, ESPLiteralValue):
-        return None  # do not substitute inside literal blocks
-    if isinstance(item, list):
-        for i, it in enumerate(item):
-            sub = _substitute_item(substitutions, it, path + [i], jinja, ignore_missing)
-            if sub is not None:
-                item[i] = sub
-    elif isinstance(item, dict):
-        replace_keys = []
-        for k, v in item.items():
-            if path or k != CONF_SUBSTITUTIONS:
-                sub = _substitute_item(
-                    substitutions, k, path + [k], jinja, ignore_missing
-                )
+    """Recursively substitute variables in a config item.
+
+    Walks dicts, lists, strings, Lambdas, Extend, and Remove nodes,
+    replacing variable references with values from context_vars.
+    Mutates containers in-place; returns a replacement value for
+    strings/scalars, or None if the item was unchanged.
+    """
+
+    def _walk(item: Any, path: SubstitutionPath, parent_ctx: ContextVars) -> Any | None:
+        if isinstance(item, ESPLiteralValue):
+            return None  # do not substitute inside literal blocks
+
+        ctx = push_context(item, parent_ctx, errors)
+
+        if isinstance(item, list):
+            for idx, it in enumerate(item):
+                sub = _walk(it, path + [idx], ctx)
                 if sub is not None:
-                    replace_keys.append((k, sub))
-            sub = _substitute_item(substitutions, v, path + [k], jinja, ignore_missing)
-            if sub is not None:
-                item[k] = sub
-        for old, new in replace_keys:
-            if str(new) == str(old):
-                item[new] = item[old]
-            else:
-                item[new] = merge_config(item.get(old), item.get(new))
-                del item[old]
-    elif isinstance(item, str):
-        sub = _expand_substitutions(substitutions, item, path, jinja, ignore_missing)
-        if isinstance(sub, JinjaStr) or sub != item:
-            return sub
-    elif isinstance(item, (core.Lambda, Extend, Remove)):
-        sub = _expand_substitutions(
-            substitutions, item.value, path, jinja, ignore_missing
+                    item[idx] = sub
+        elif isinstance(item, dict):
+            replace_keys: list[tuple[str, Any]] = []
+            for k, v in item.items():
+                if path or k != CONF_SUBSTITUTIONS:
+                    sub = _walk(k, path + [k], ctx)
+                    if sub is not None:
+                        replace_keys.append((k, sub))
+                sub = _walk(v, path + [k], ctx)
+                if sub is not None:
+                    item[k] = sub
+            for old, new in replace_keys:
+                if str(new) == str(old):
+                    item[new] = item[old]
+                else:
+                    item[new] = merge_config(item.get(new), item.get(old))
+                    del item[old]
+        elif isinstance(item, str):
+            sub = _expand_substitutions(item, path, ctx, strict_undefined, errors)
+            if not isinstance(sub, str) or sub != item:
+                return sub
+        elif isinstance(item, (core.Lambda, Extend, Remove)) and item.value:
+            sub = _expand_substitutions(item.value, path, ctx, strict_undefined, errors)
+            if sub != item.value:
+                item.value = sub
+        return None
+
+    return _walk(item, path, parent_context)
+
+
+def substitute_context_vars(node: Any, context_vars: dict[str, Any]) -> None:
+    """Eagerly substitute context vars into a config node in-place.
+
+    Undefined variables are silently ignored — this is used before
+    the main substitution pass when not all variables are visible yet.
+    """
+    _substitute_item(node, [], ContextVars(context_vars), strict_undefined=False)
+
+
+def _warn_unresolved_variables(errors: ErrList) -> None:
+    """Log warnings for unresolved substitution variables, skipping password fields."""
+    for err, path, expression in errors:
+        if "password" in path:
+            continue
+        location: str = "->".join(str(x) for x in path)
+        if isinstance(expression, ESPHomeDataBase) and expression.esp_range is not None:
+            location += f" in {str(expression.esp_range.start_mark)}"
+
+        _LOGGER.warning(
+            "The string '%s' looks like an expression,"
+            " but could not resolve all the variables: %s (see %s)",
+            expression,
+            err.message,
+            location,
         )
-        if sub != item:
-            item.value = sub
-    return None
 
 
 def do_substitution_pass(
-    config: dict, command_line_substitutions: dict, ignore_missing: bool = False
-) -> None:
-    if CONF_SUBSTITUTIONS not in config and not command_line_substitutions:
-        return
+    config: OrderedDict, command_line_substitutions: dict[str, Any] | None = None
+) -> OrderedDict:
+    """Run the substitution pass over the entire config.
 
-    # Merge substitutions in config, overriding with substitutions coming from command line:
+    Extracts the ``substitutions:`` block, merges in any command-line
+    overrides, resolves inter-variable dependencies, then walks the
+    config tree replacing all ``$var`` / ``${expr}`` references.
+    Returns the (mutated) config dict with resolved substitutions
+    restored at the front.
+    """
+    # Extract substitutions from config, overriding with substitutions coming from command line:
     # Use merge_dicts_ordered to preserve OrderedDict type for move_to_end()
-    substitutions = merge_dicts_ordered(
-        config.get(CONF_SUBSTITUTIONS, {}), command_line_substitutions or {}
-    )
-    with cv.prepend_path("substitutions"):
+    substitutions = config.pop(CONF_SUBSTITUTIONS, {})
+    with cv.prepend_path(CONF_SUBSTITUTIONS):
         if not isinstance(substitutions, dict):
             raise cv.Invalid(
                 f"Substitutions must be a key to value mapping, got {type(substitutions)}"
             )
+        substitutions = merge_dicts_ordered(
+            substitutions, command_line_substitutions or {}
+        )
 
-        replace_keys = []
-        for key, value in substitutions.items():
+        replace_keys: list[tuple[str, str]] = []
+        for key in substitutions:
             with cv.prepend_path(key):
                 sub = validate_substitution_key(key)
                 if sub != key:
                     replace_keys.append((key, sub))
-                substitutions[key] = value
         for old, new in replace_keys:
             substitutions[new] = substitutions[old]
             del substitutions[old]
 
-    config[CONF_SUBSTITUTIONS] = substitutions
-    # Move substitutions to the first place to replace substitutions in them correctly
-    config.move_to_end(CONF_SUBSTITUTIONS, False)
+    errors: ErrList = []  # Collect undefined errors during substitution
+    parent_context, substitutions = _push_context(substitutions, ContextVars(), errors)
 
-    # Create a Jinja environment that will consider substitutions in scope:
-    jinja = Jinja(substitutions)
-    _substitute_item(substitutions, config, [], jinja, ignore_missing)
+    _substitute_item(config, [], parent_context, False, errors)
+
+    if errors:
+        _warn_unresolved_variables(errors)
+
+    # Restore substitutions to front of dict for readability
+    if substitutions:
+        config[CONF_SUBSTITUTIONS] = substitutions
+        config.move_to_end(CONF_SUBSTITUTIONS, last=False)
+    return config
diff --git a/esphome/components/substitutions/jinja.py b/esphome/components/substitutions/jinja.py
index fb9f843da2..37e9fa4d2d 100644
--- a/esphome/components/substitutions/jinja.py
+++ b/esphome/components/substitutions/jinja.py
@@ -1,7 +1,6 @@
 from ast import literal_eval
-from collections.abc import Iterator
+from collections.abc import Iterator, Mapping
 from itertools import chain, islice
-import logging
 import math
 import re
 from types import GeneratorType
@@ -9,16 +8,17 @@ from typing import Any
 
 import jinja2 as jinja
 from jinja2.nativetypes import NativeCodeGenerator, NativeTemplate
-
-from esphome.yaml_util import ESPLiteralValue
+from jinja2.runtime import missing as Missing
 
 TemplateError = jinja.TemplateError
 TemplateSyntaxError = jinja.TemplateSyntaxError
 TemplateRuntimeError = jinja.TemplateRuntimeError
 UndefinedError = jinja.UndefinedError
 Undefined = jinja.Undefined
+# Sentinel key for resolver callback in ContextVars.
+# Dots are invalid in substitution names so this can never collide with user keys.
+Resolver = ".resolver"
 
-_LOGGER = logging.getLogger(__name__)
 
 DETECT_JINJA = r"(\$\{)"
 detect_jinja_re = re.compile(
@@ -52,33 +52,6 @@ SAFE_GLOBALS = {
 }
 
 
-class JinjaStr(str):
-    """
-    Wraps a string containing an unresolved Jinja expression,
-    storing the variables visible to it when it failed to resolve.
-    For example, an expression inside a package, `${ A * B }` may fail
-    to resolve at package parsing time if `A` is a local package var
-    but `B` is a substitution defined in the root yaml.
-    Therefore, we store the value of `A` as an upvalue bound
-    to the original string so we may be able to resolve `${ A * B }`
-    later in the main substitutions pass.
-    """
-
-    Undefined = object()
-
-    def __new__(cls, value: str, upvalues=None):
-        if isinstance(value, JinjaStr):
-            base = str(value)
-            merged = {**value.upvalues, **(upvalues or {})}
-        else:
-            base = value
-            merged = dict(upvalues or {})
-        obj = super().__new__(cls, base)
-        obj.upvalues = merged
-        obj.result = JinjaStr.Undefined
-        return obj
-
-
 class JinjaError(Exception):
     def __init__(self, context_trace: dict, expr: str):
         self.context_trace = context_trace
@@ -106,9 +79,13 @@ class JinjaError(Exception):
 class TrackerContext(jinja.runtime.Context):
     def resolve_or_missing(self, key):
         val = super().resolve_or_missing(key)
-        if isinstance(val, JinjaStr):
-            self.environment.context_trace[key] = val
-            val, _ = self.environment.expand(val)
+        if val is Missing:
+            # Variable not in the template context — check if a resolver callback
+            # was registered (by _push_context) to lazily resolve dependencies
+            # between substitution variables in the same block.
+            resolver = super().resolve_or_missing(Resolver)
+            if resolver is not Missing:
+                val = resolver(key)
         self.environment.context_trace[key] = val
         return val
 
@@ -160,15 +137,13 @@ def _concat_nodes_override(values: Iterator[Any]) -> Any:
 
 
 class Jinja(jinja.Environment):
-    """
-    Wraps a Jinja environment
-    """
+    """Jinja environment configured for ESPHome substitution expressions."""
 
     # jinja environment customization overrides
     code_generator_class = NativeCodeGenerator
     concat = staticmethod(_concat_nodes_override)
 
-    def __init__(self, context_vars: dict):
+    def __init__(self) -> None:
         super().__init__(
             trim_blocks=True,
             lstrip_blocks=True,
@@ -183,49 +158,25 @@ class Jinja(jinja.Environment):
         self.context_class = TrackerContext
         self.add_extension("jinja2.ext.do")
         self.context_trace = {}
-        self.context_vars = {**context_vars}
-        for k, v in self.context_vars.items():
-            if isinstance(v, ESPLiteralValue):
-                continue
-            if isinstance(v, str) and not isinstance(v, JinjaStr) and has_jinja(v):
-                self.context_vars[k] = JinjaStr(v, self.context_vars)
 
-        self.globals = {
-            **self.globals,
-            **self.context_vars,
-            **SAFE_GLOBALS,
-        }
+        self.globals = {**self.globals, **SAFE_GLOBALS}
 
-    def expand(self, content_str: str | JinjaStr) -> Any:
+    def expand(self, content_str: str, context_vars: Mapping[str, Any]) -> Any:
         """
         Renders a string that may contain Jinja expressions or statements
         Returns the resulting value if all variables and expressions could be resolved.
-        Otherwise, it returns a tagged (JinjaStr) string that captures variables
-        in scope (upvalues), like a closure for later evaluation.
         """
         result = None
-        override_vars = {}
-        if isinstance(content_str, JinjaStr):
-            if content_str.result is not JinjaStr.Undefined:
-                return content_str.result, None
-            # If `value` is already a JinjaStr, it means we are trying to evaluate it again
-            # in a parent pass.
-            # Hopefully, all required variables are visible now.
-            override_vars = content_str.upvalues
 
         old_trace = self.context_trace
         self.context_trace = {}
         try:
             template = self.from_string(content_str)
-            result = template.render(override_vars)
+            result = template.render(context_vars)
             if isinstance(result, Undefined):
-                print("" + result)  # force a UndefinedError exception
-        except (TemplateSyntaxError, UndefinedError) as err:
-            # `content_str` contains a Jinja expression that refers to a variable that is undefined
-            # in this scope. Perhaps it refers to a root substitution that is not visible yet.
-            # Therefore, return `content_str` as a JinjaStr, which contains the variables
-            # that are actually visible to it at this point to postpone evaluation.
-            return JinjaStr(content_str, {**self.context_vars, **override_vars}), err
+                str(result)  # force a UndefinedError exception
+        except UndefinedError as err:
+            raise err
         except JinjaError as err:
             err.context_trace = {**self.context_trace, **err.context_trace}
             err.eval_stack.append(content_str)
@@ -242,10 +193,7 @@ class Jinja(jinja.Environment):
         finally:
             self.context_trace = old_trace
 
-        if isinstance(content_str, JinjaStr):
-            content_str.result = result
-
-        return result, None
+        return result
 
 
 class JinjaTemplate(NativeTemplate):
diff --git a/esphome/config.py b/esphome/config.py
index 6f6ad4886b..b80aaf3700 100644
--- a/esphome/config.py
+++ b/esphome/config.py
@@ -12,7 +12,8 @@ from typing import Any
 import voluptuous as vol
 
 from esphome import core, loader, pins, yaml_util
-from esphome.config_helpers import Extend, Remove, merge_config, merge_dicts_ordered
+from esphome.components.substitutions import do_substitution_pass
+from esphome.config_helpers import Extend, Remove, merge_config
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ESPHOME,
@@ -974,7 +975,7 @@ class PinUseValidationCheck(ConfigValidationStep):
 
 def validate_config(
     config: dict[str, Any],
-    command_line_substitutions: dict[str, Any],
+    command_line_substitutions: dict[str, Any] | None,
     skip_external_update: bool = False,
 ) -> Config:
     result = Config()
@@ -994,21 +995,15 @@ def validate_config(
             result.add_error(err)
             return result
 
-    CORE.raw_config = config
-
     # 1. Load substitutions
     if CONF_SUBSTITUTIONS in config or command_line_substitutions:
-        from esphome.components import substitutions
-
-        result[CONF_SUBSTITUTIONS] = merge_dicts_ordered(
-            config.get(CONF_SUBSTITUTIONS) or {}, command_line_substitutions
-        )
         result.add_output_path([CONF_SUBSTITUTIONS], CONF_SUBSTITUTIONS)
-        try:
-            substitutions.do_substitution_pass(config, command_line_substitutions)
-        except vol.Invalid as err:
-            result.add_error(err)
-            return result
+    try:
+        config = do_substitution_pass(config, command_line_substitutions)
+    except vol.Invalid as err:
+        CORE.raw_config = config
+        result.add_error(err)
+        return result
 
     # 1.1. Merge packages
     if CONF_PACKAGES in config:
@@ -1016,6 +1011,9 @@ def validate_config(
 
         config = merge_packages(config)
 
+    # Remove substitutions from config during validation to prevent
+    # re-substitution. Re-added to result at the end of this function.
+    substitutions = config.pop(CONF_SUBSTITUTIONS, None)
     CORE.raw_config = config
 
     # 1.2. Resolve !extend and !remove and check for REPLACEME
@@ -1089,6 +1087,10 @@ def validate_config(
 
     result.run_validation_steps()
 
+    if substitutions is not None:
+        result[CONF_SUBSTITUTIONS] = substitutions
+        result.move_to_end(CONF_SUBSTITUTIONS, last=False)
+
     return result
 
 
diff --git a/esphome/yaml_util.py b/esphome/yaml_util.py
index d0eab4e44e..e001316a22 100644
--- a/esphome/yaml_util.py
+++ b/esphome/yaml_util.py
@@ -325,9 +325,7 @@ class ESPHomeLoaderMixin:
         return val
 
     @_add_data_ref
-    def construct_include(
-        self, node: yaml.Node
-    ) -> dict[str, Any] | OrderedDict[str, Any]:
+    def construct_include(self, node: yaml.Node) -> Any:
         from esphome.const import CONF_VARS
 
         def extract_file_vars(node):
@@ -344,9 +342,7 @@ class ESPHomeLoaderMixin:
             file, vars = node.value, None
 
         result = self.yaml_loader(self._rel_path(file))
-        if not vars:
-            vars = {}
-        return substitute_vars(result, vars)
+        return add_context(result, vars)
 
     @_add_data_ref
     def construct_include_dir_list(self, node: yaml.Node) -> list[dict[str, Any]]:
@@ -495,39 +491,6 @@ def parse_yaml(
         )
 
 
-def substitute_vars(config, vars):
-    from esphome.components import substitutions
-    from esphome.const import CONF_SUBSTITUTIONS
-
-    org_subs = None
-    result = config
-    if not isinstance(config, dict):
-        # when the included yaml contains a list or a scalar
-        # wrap it into an OrderedDict because do_substitution_pass expects it
-        result = OrderedDict([("yaml", config)])
-    elif CONF_SUBSTITUTIONS in result:
-        org_subs = result.pop(CONF_SUBSTITUTIONS)
-
-    defaults = {}
-    if CONF_DEFAULTS in result:
-        defaults = result.pop(CONF_DEFAULTS)
-
-    result[CONF_SUBSTITUTIONS] = vars
-    for k, v in defaults.items():
-        if k not in result[CONF_SUBSTITUTIONS]:
-            result[CONF_SUBSTITUTIONS][k] = v
-
-    # Ignore missing vars that refer to the top level substitutions
-    substitutions.do_substitution_pass(result, None, ignore_missing=True)
-    result.pop(CONF_SUBSTITUTIONS)
-
-    if not isinstance(config, dict):
-        result = result["yaml"]  # unwrap the result
-    elif org_subs:
-        result[CONF_SUBSTITUTIONS] = org_subs
-    return result
-
-
 def _load_yaml_internal_with_type(
     loader_type: type[ESPHomeLoader] | type[ESPHomePurePythonLoader],
     fname: Path,
diff --git a/tests/component_tests/packages/test_packages.py b/tests/component_tests/packages/test_packages.py
index 22fb2c4e32..60dc0dccda 100644
--- a/tests/component_tests/packages/test_packages.py
+++ b/tests/component_tests/packages/test_packages.py
@@ -6,6 +6,7 @@ from unittest.mock import MagicMock, patch
 import pytest
 
 from esphome.components.packages import CONFIG_SCHEMA, do_packages_pass, merge_packages
+from esphome.components.substitutions import do_substitution_pass
 import esphome.config as config_module
 from esphome.config import resolve_extend_remove
 from esphome.config_helpers import Extend, Remove
@@ -71,6 +72,7 @@ def fixture_basic_esphome():
 def packages_pass(config):
     """Wrapper around packages_pass that also resolves Extend and Remove."""
     config = do_packages_pass(config)
+    config = do_substitution_pass(config)
     config = merge_packages(config)
     resolve_extend_remove(config)
     return config
diff --git a/tests/unit_tests/fixtures/substitutions/00-simple_var.approved.yaml b/tests/unit_tests/fixtures/substitutions/00-simple_var.approved.yaml
index 9ed9b99c49..87f0e3fa21 100644
--- a/tests/unit_tests/fixtures/substitutions/00-simple_var.approved.yaml
+++ b/tests/unit_tests/fixtures/substitutions/00-simple_var.approved.yaml
@@ -38,3 +38,20 @@ test_list:
   - '{ 79, 82 }'
   - a: 15 should be 15, overridden from command line
     b: 20 should stay as 20, not overridden
+  - aa:
+      - 1
+      - 2
+      - 3
+      - 4
+      - 5
+      - 6
+    bb:
+      - 7
+      - 8
+      - 9
+  - aa:
+      x: 1
+      y: 3
+      z: 4
+    bb:
+      w: 5
diff --git a/tests/unit_tests/fixtures/substitutions/00-simple_var.input.yaml b/tests/unit_tests/fixtures/substitutions/00-simple_var.input.yaml
index 64701c03dd..d70372f280 100644
--- a/tests/unit_tests/fixtures/substitutions/00-simple_var.input.yaml
+++ b/tests/unit_tests/fixtures/substitutions/00-simple_var.input.yaml
@@ -44,3 +44,13 @@ test_list:
   - '{ ${position.x}, ${position.y} }'
   - a: ${a} should be 15, overridden from command line
     b: ${b} should stay as 20, not overridden
+
+  # Test merging lists when substituted keys resolve to an existing key
+  - ${ "aa" }: [1, 2, 3]
+    ${ "a" + "a" }: [4, 5, 6]
+    ${ "bb" }: [7, 8, 9]
+
+  # Test merging dicts when substituted keys resolve to an existing key
+  - ${ "aa" }: {"x": 1, "y": 2}
+    ${ "a" + "a" }: {"y": 3, "z": 4}
+    ${ "bb" }: {"w": 5}
diff --git a/tests/unit_tests/fixtures/substitutions/02-expressions.approved.yaml b/tests/unit_tests/fixtures/substitutions/02-expressions.approved.yaml
index 1a51fc44cf..b8c76fbf52 100644
--- a/tests/unit_tests/fixtures/substitutions/02-expressions.approved.yaml
+++ b/tests/unit_tests/fixtures/substitutions/02-expressions.approved.yaml
@@ -9,6 +9,11 @@ substitutions:
   numberOne: 1
   var1: 79
   double_width: 14
+  double_height: 16
+  y: ${x}
+  x: ${y}
+  b: 79
+  c: 80
 test_list:
   - The area is 56
   - 56
@@ -27,3 +32,4 @@ test_list:
   - chr(97) = a
   - len([1,2,3]) = 3
   - width = 7, double_width = 14
+  - a = ${a}
diff --git a/tests/unit_tests/fixtures/substitutions/02-expressions.input.yaml b/tests/unit_tests/fixtures/substitutions/02-expressions.input.yaml
index 4612f581b5..9593867f49 100644
--- a/tests/unit_tests/fixtures/substitutions/02-expressions.input.yaml
+++ b/tests/unit_tests/fixtures/substitutions/02-expressions.input.yaml
@@ -1,4 +1,7 @@
 substitutions:
+  y: ${x}  # Circular reference, expect to pass unresolved.
+  x: ${y}  # Circular reference, expect to pass unresolved.
+  double_height: ${height * 2}
   width: 7
   height: 8
   enabled: true
@@ -9,6 +12,8 @@ substitutions:
   numberOne: 1
   var1: 79
   double_width: ${width * 2}
+  c: ${b+1}
+  b: ${undefined_variable | default(79) }
 
 test_list:
   - "The area is ${width * height}"
@@ -25,3 +30,4 @@ test_list:
   - chr(97) = ${ chr(97) }
   - len([1,2,3]) = ${ len([1,2,3]) }
   - width = ${width}, double_width = ${double_width}
+  - a = ${a}
diff --git a/tests/unit_tests/fixtures/substitutions/07-package_merging.approved.yaml b/tests/unit_tests/fixtures/substitutions/07-package_merging.approved.yaml
new file mode 100644
index 0000000000..867889b7bc
--- /dev/null
+++ b/tests/unit_tests/fixtures/substitutions/07-package_merging.approved.yaml
@@ -0,0 +1,46 @@
+fancy_component: &id001
+  - id: component9
+    value: 9
+some_component:
+  - id: component1
+    value: 1
+  - id: component2
+    value: 2
+  - id: component3
+    value: 3
+  - id: component4
+    value: 4
+  - id: component5
+    value: 79
+    power: 200
+  - id: component6
+    value: 6
+  - id: component7
+    value: 7
+switch: &id002
+  - platform: gpio
+    id: switch1
+    pin: 12
+  - platform: gpio
+    id: switch2
+    pin: 13
+display:
+  - platform: ili9xxx
+    dimensions:
+      width: 100
+      height: 480
+substitutions:
+  extended_component: component5
+  package_options:
+    alternative_package:
+      alternative_component:
+        - id: component8
+          value: 8
+    fancy_package:
+      substitutions:
+        fancy_subst: 42
+      fancy_component: *id001
+  pin: 12
+  some_switches: *id002
+  package_selection: fancy_package
+  fancy_subst: 42
diff --git a/tests/unit_tests/fixtures/substitutions/07-package_merging.input.yaml b/tests/unit_tests/fixtures/substitutions/07-package_merging.input.yaml
new file mode 100644
index 0000000000..cc7b841aba
--- /dev/null
+++ b/tests/unit_tests/fixtures/substitutions/07-package_merging.input.yaml
@@ -0,0 +1,63 @@
+substitutions:
+  package_options:
+    alternative_package:
+      alternative_component:
+        - id: component8
+          value: 8
+    fancy_package:
+      substitutions:
+        fancy_subst: 42
+      fancy_component:
+        - id: component9
+          value: 9
+
+  pin: 12
+  some_switches:
+    - platform: gpio
+      id: switch1
+      pin: ${pin}
+    - platform: gpio
+      id: switch2
+      pin: ${pin+1}
+
+  package_selection: fancy_package
+
+packages:
+  - ${ package_options[package_selection] }
+  - some_component:
+      - id: component1
+        value: 1
+  - some_component:
+      - id: component2
+        value: 2
+  - switch: ${ some_switches }
+  - packages:
+      package_with_defaults: !include
+        file: display.yaml
+        vars:
+          native_width: 100
+          high_dpi: false
+      my_package:
+        packages:
+          - packages:
+              special_package:
+                substitutions:
+                  extended_component: component5
+                some_component:
+                  - id: component3
+                    value: 3
+        some_component:
+          - id: component4
+            value: 4
+          - id: !extend ${ extended_component }
+            power: 200
+            value: 79
+    some_component:
+      - id: component5
+        value: 5
+
+some_component:
+  - id: component6
+    value: 6
+  - id: component7
+    value: 7
diff --git a/tests/unit_tests/fixtures/substitutions/09-include_vars_without_substs.approved.yaml b/tests/unit_tests/fixtures/substitutions/09-include_vars_without_substs.approved.yaml
new file mode 100644
index 0000000000..4abaf4471d
--- /dev/null
+++ b/tests/unit_tests/fixtures/substitutions/09-include_vars_without_substs.approved.yaml
@@ -0,0 +1,5 @@
+values:
+  - var1: $var1
+  - a: 10
+  - b: B-default
+  - c: The value of C is 79
diff --git a/tests/unit_tests/fixtures/substitutions/09-include_vars_without_substs.input.yaml b/tests/unit_tests/fixtures/substitutions/09-include_vars_without_substs.input.yaml
new file mode 100644
index 0000000000..91eb0e9a3f
--- /dev/null
+++ b/tests/unit_tests/fixtures/substitutions/09-include_vars_without_substs.input.yaml
@@ -0,0 +1,7 @@
+# Test that include_vars with vars works even when there are no substitutions key defined.
+packages:
+  - !include
+    file: inc1.yaml
+    vars:
+      a: 10
+      c: 79
diff --git a/tests/unit_tests/test_substitutions.py b/tests/unit_tests/test_substitutions.py
index 1d8cb7631d..db46a27dfb 100644
--- a/tests/unit_tests/test_substitutions.py
+++ b/tests/unit_tests/test_substitutions.py
@@ -10,9 +10,10 @@ from esphome import config as config_module, yaml_util
 from esphome.components import substitutions
 from esphome.components.packages import do_packages_pass, merge_packages
 from esphome.config import resolve_extend_remove
-from esphome.config_helpers import merge_config
+from esphome.config_helpers import Extend, merge_config
+import esphome.config_validation as cv
 from esphome.const import CONF_SUBSTITUTIONS
-from esphome.core import CORE
+from esphome.core import CORE, Lambda
 from esphome.util import OrderedDict
 
 _LOGGER = logging.getLogger(__name__)
@@ -144,7 +145,7 @@ def test_substitutions_fixtures(
 
     config = do_packages_pass(config)
 
-    substitutions.do_substitution_pass(config, command_line_substitutions)
+    config = substitutions.do_substitution_pass(config, command_line_substitutions)
 
     config = merge_packages(config)
 
@@ -206,7 +207,7 @@ def test_substitutions_with_command_line_maintains_ordered_dict() -> None:
     command_line_subs = {"var2": "override", "var3": "new_value"}
 
     # Call do_substitution_pass with command line substitutions
-    substitutions.do_substitution_pass(config, command_line_subs)
+    config = substitutions.do_substitution_pass(config, command_line_subs)
 
     # Verify that config is still an OrderedDict
     assert isinstance(config, OrderedDict), "Config should remain an OrderedDict"
@@ -234,7 +235,7 @@ def test_substitutions_without_command_line_maintains_ordered_dict() -> None:
     config["other_key"] = "other_value"
 
     # Call without command line substitutions
-    substitutions.do_substitution_pass(config, None)
+    config = substitutions.do_substitution_pass(config, None)
 
     # Verify that config is still an OrderedDict
     assert isinstance(config, OrderedDict), "Config should remain an OrderedDict"
@@ -268,7 +269,7 @@ def test_substitutions_after_merge_config_maintains_ordered_dict() -> None:
     )
 
     # Now try to run substitution pass on the merged config
-    substitutions.do_substitution_pass(merged_config, None)
+    merged_config = substitutions.do_substitution_pass(merged_config, None)
 
     # Should not raise AttributeError
     assert isinstance(merged_config, OrderedDict), (
@@ -279,7 +280,7 @@ def test_substitutions_after_merge_config_maintains_ordered_dict() -> None:
 
 
 def test_validate_config_with_command_line_substitutions_maintains_ordered_dict(
-    tmp_path,
+    tmp_path: Path,
 ) -> None:
     """Test that validate_config preserves OrderedDict when merging command-line substitutions.
 
@@ -288,7 +289,7 @@ def test_validate_config_with_command_line_substitutions_maintains_ordered_dict(
     """
     # Create a minimal valid config
     test_config = OrderedDict()
-    test_config["esphome"] = {"name": "test_device", "platform": "ESP32"}
+    test_config["esphome"] = {"name": "test_device"}
     test_config[CONF_SUBSTITUTIONS] = OrderedDict({"var1": "value1", "var2": "value2"})
     test_config["esp32"] = {"board": "esp32dev"}
 
@@ -314,17 +315,11 @@ def test_validate_config_with_command_line_substitutions_maintains_ordered_dict(
     assert result[CONF_SUBSTITUTIONS]["var3"] == "new_value"
 
 
-def test_validate_config_without_command_line_substitutions_maintains_ordered_dict(
-    tmp_path,
-) -> None:
-    """Test that validate_config preserves OrderedDict without command-line substitutions.
-
-    This tests the code path in config.py where result[CONF_SUBSTITUTIONS] is set
-    using merge_dicts_ordered() when command_line_substitutions is None.
-    """
+def _get_test_minimal_valid_config(tmp_path: Path) -> OrderedDict:
+    """Helper to create a minimal valid config for testing."""
     # Create a minimal valid config
     test_config = OrderedDict()
-    test_config["esphome"] = {"name": "test_device", "platform": "ESP32"}
+    test_config["esphome"] = {"name": "test_device"}
     test_config[CONF_SUBSTITUTIONS] = OrderedDict({"var1": "value1", "var2": "value2"})
     test_config["esp32"] = {"board": "esp32dev"}
 
@@ -332,6 +327,19 @@ def test_validate_config_without_command_line_substitutions_maintains_ordered_di
     test_yaml = tmp_path / "test.yaml"
     test_yaml.write_text("# test config")
     CORE.config_path = test_yaml
+    return test_config
+
+
+def test_validate_config_without_command_line_substitutions_maintains_ordered_dict(
+    tmp_path: Path,
+) -> None:
+    """Test that validate_config preserves OrderedDict without command-line substitutions.
+
+    This tests the code path in config.py where result[CONF_SUBSTITUTIONS] is set
+    using merge_dicts_ordered() when command_line_substitutions is None.
+    """
+
+    test_config = _get_test_minimal_valid_config(tmp_path)
 
     # Call validate_config without command line substitutions
     result = config_module.validate_config(test_config, None)
@@ -384,3 +392,205 @@ def test_merge_config_preserves_ordered_dict() -> None:
     assert not isinstance(result, OrderedDict), (
         "dict + dict should not return OrderedDict"
     )
+
+
+def test_substitution_pass_error_gets_captured(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    """vol.Invalid from do_substitution_pass is captured by validate_config."""
+
+    # Patch the target: in config_module.do_substitution_pass (NOT where it's defined)
+    def fake_do_substitution_pass(*args, **kwargs):
+        raise cv.Invalid("Error in do_substitutions_pass!!")
+
+    monkeypatch.setattr(
+        config_module, "do_substitution_pass", fake_do_substitution_pass
+    )
+
+    # Prepare minimal config + no CLI substitutions
+    config = _get_test_minimal_valid_config(tmp_path)
+
+    # Call the function under test
+    result = config_module.validate_config(config, None)
+
+    # Now assert that add_error was called with the vol.Invalid
+
+    assert "Error in do_substitutions_pass!!" in str(result.get_error_for_path([]))
+
+
+@pytest.mark.parametrize(
+    "value", ["", "   ", "1foo", "9VAR", "0abc", "$1foo", "$9VAR", "$0abc"]
+)
+def test_validate_substitution_key_empty_raises(value: str) -> None:
+    """Empty (or all-whitespace) substitution keys are rejected."""
+    with pytest.raises(cv.Invalid):
+        substitutions.validate_substitution_key(value)
+
+
+@pytest.mark.parametrize(
+    "input_value, expected_output",
+    [
+        ("$FOO_bar9", "FOO_bar9"),  # Valid key with leading '$'
+        ("Foo_bar9", "Foo_bar9"),  # Normal valid key
+    ],
+)
+def test_validate_substitution_key_valid(
+    input_value: str, expected_output: str
+) -> None:
+    """Valid substitution keys are accepted with optional leading '$'."""
+    result = substitutions.validate_substitution_key(input_value)
+    assert result == expected_output
+
+
+def test_circular_dependency_warnings(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Circular substitution references produce warnings naming the cause."""
+    config = OrderedDict(
+        {
+            CONF_SUBSTITUTIONS: OrderedDict({"x": "${y}", "y": "${x}"}),
+            "key": "value",
+        }
+    )
+    with caplog.at_level(logging.WARNING):
+        substitutions.do_substitution_pass(config)
+
+    assert "Could not resolve substitution variable 'x'" in caplog.text
+    assert "'y' is undefined" in caplog.text
+    assert "Could not resolve substitution variable 'y'" in caplog.text
+    assert "'x' is undefined" in caplog.text
+    # Verify path includes location
+    assert "substitutions->x" in caplog.text
+    assert "substitutions->y" in caplog.text
+
+
+def test_missing_dependency_warning(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """A substitution referencing an undefined variable warns with the cause."""
+    config = OrderedDict(
+        {
+            CONF_SUBSTITUTIONS: OrderedDict({"a": "${missing}"}),
+            "key": "value",
+        }
+    )
+    with caplog.at_level(logging.WARNING):
+        substitutions.do_substitution_pass(config)
+
+    assert "Could not resolve substitution variable 'a'" in caplog.text
+    assert "'missing' is undefined" in caplog.text
+    assert "substitutions->a" in caplog.text
+
+
+def test_undefined_variable_warning(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """A reference to an undefined variable in config values produces a warning."""
+    config = OrderedDict(
+        {
+            "key": "${undefined_var}",
+        }
+    )
+    with caplog.at_level(logging.WARNING):
+        substitutions.do_substitution_pass(config)
+
+    assert "'undefined_var' is undefined" in caplog.text
+
+
+def test_password_field_warnings_suppressed(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Undefined variables in password fields should not produce warnings."""
+    config = OrderedDict(
+        {
+            "password": "${undefined_var}",
+        }
+    )
+    with caplog.at_level(logging.WARNING):
+        substitutions.do_substitution_pass(config)
+
+    assert caplog.text == ""
+
+
+def test_config_context_unresolvable_warns(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Unresolvable vars in a ConfigContext produce warnings via push_context."""
+    inner = OrderedDict({"key": "${a}"})
+    yaml_util.add_context(inner, {"a": "${undefined}"})
+    config = OrderedDict({"items": [inner]})
+    with caplog.at_level(logging.WARNING):
+        substitutions.do_substitution_pass(config)
+
+    assert "Could not resolve substitution variable 'a'" in caplog.text
+    assert "'undefined' is undefined" in caplog.text
+
+
+def test_non_string_substitution_value_warning(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Undefined vars in non-string contexts (e.g. dict keys) produce warnings."""
+    config = OrderedDict(
+        {
+            "items": {"${undefined_key}": "value"},
+        }
+    )
+    with caplog.at_level(logging.WARNING):
+        substitutions.do_substitution_pass(config)
+
+    assert "'undefined_key' is undefined" in caplog.text
+
+
+def test_lambda_substitution() -> None:
+    """Substitution inside a Lambda value should be expanded."""
+    lam = Lambda("return ${var};")
+    config = OrderedDict(
+        {
+            CONF_SUBSTITUTIONS: OrderedDict({"var": "42"}),
+            "lambda": lam,
+        }
+    )
+    substitutions.do_substitution_pass(config)
+    assert lam.value == "return 42;"
+
+
+def test_lambda_no_substitution_unchanged() -> None:
+    """A Lambda with no variable references should not be mutated."""
+    lam = Lambda("return 1;")
+    original_value = lam.value
+    config = OrderedDict(
+        {
+            CONF_SUBSTITUTIONS: OrderedDict({"var": "42"}),
+            "lambda": lam,
+        }
+    )
+    substitutions.do_substitution_pass(config)
+    assert lam.value is original_value
+
+
+def test_extend_substitution() -> None:
+    """Substitution inside an Extend value should be expanded."""
+    ext = Extend("${component_id}")
+    config = OrderedDict(
+        {
+            CONF_SUBSTITUTIONS: OrderedDict({"component_id": "my_sensor"}),
+            "sensor": ext,
+        }
+    )
+    substitutions.do_substitution_pass(config)
+    assert ext.value == "my_sensor"
+
+
+def test_do_substitution_pass_substitutions_must_be_mapping_from_config() -> None:
+    """Non-mapping substitutions raises cv.Invalid."""
+    config = OrderedDict(
+        {
+            CONF_SUBSTITUTIONS: ["not", "a", "mapping"],
+            "other": "value",
+        }
+    )
+
+    with pytest.raises(
+        cv.Invalid, match="Substitutions must be a key to value mapping"
+    ):
+        substitutions.do_substitution_pass(config)
diff --git a/tests/unit_tests/test_yaml_util.py b/tests/unit_tests/test_yaml_util.py
index adb7658bfd..35a4bc3707 100644
--- a/tests/unit_tests/test_yaml_util.py
+++ b/tests/unit_tests/test_yaml_util.py
@@ -25,7 +25,7 @@ def test_include_with_vars(fixture_path: Path) -> None:
     yaml_file = fixture_path / "yaml_util" / "includetest.yaml"
 
     actual = yaml_util.load_yaml(yaml_file)
-    substitutions.do_substitution_pass(actual, None)
+    actual = substitutions.do_substitution_pass(actual, None)
     assert actual["esphome"]["name"] == "original"
     assert actual["esphome"]["libraries"][0] == "Wire"
     assert actual["esp8266"]["board"] == "nodemcu"

From e6a73cab8f1e090244d63d4d63766a570a45ec62 Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Tue, 24 Mar 2026 09:04:53 +1000
Subject: [PATCH 56/60] [number] Add sensor platform (#15125)

---
 esphome/components/number/sensor/__init__.py  | 25 +++++++++++++++++++
 .../number/sensor/number_sensor.cpp           | 16 ++++++++++++
 .../components/number/sensor/number_sensor.h  | 19 ++++++++++++++
 tests/components/number/common.yaml           | 13 ++++++++++
 tests/components/number/test.esp32-idf.yaml   |  2 ++
 tests/components/number/test.esp8266-ard.yaml |  2 ++
 6 files changed, 77 insertions(+)
 create mode 100644 esphome/components/number/sensor/__init__.py
 create mode 100644 esphome/components/number/sensor/number_sensor.cpp
 create mode 100644 esphome/components/number/sensor/number_sensor.h
 create mode 100644 tests/components/number/common.yaml
 create mode 100644 tests/components/number/test.esp32-idf.yaml
 create mode 100644 tests/components/number/test.esp8266-ard.yaml

diff --git a/esphome/components/number/sensor/__init__.py b/esphome/components/number/sensor/__init__.py
new file mode 100644
index 0000000000..0d4b580d7e
--- /dev/null
+++ b/esphome/components/number/sensor/__init__.py
@@ -0,0 +1,25 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_SOURCE_ID
+
+from .. import Number, number_ns
+
+NumberSensor = number_ns.class_("NumberSensor", sensor.Sensor, cg.Component)
+
+
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(NumberSensor)
+    .extend(
+        {
+            cv.Required(CONF_SOURCE_ID): cv.use_id(Number),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    source = await cg.get_variable(config[CONF_SOURCE_ID])
+    var = await sensor.new_sensor(config, source)
+    await cg.register_component(var, config)
diff --git a/esphome/components/number/sensor/number_sensor.cpp b/esphome/components/number/sensor/number_sensor.cpp
new file mode 100644
index 0000000000..227202622a
--- /dev/null
+++ b/esphome/components/number/sensor/number_sensor.cpp
@@ -0,0 +1,16 @@
+#include "number_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome::number {
+
+static const char *const TAG = "number.sensor";
+
+void NumberSensor::setup() {
+  this->source_->add_on_state_callback([this](float value) { this->publish_state(value); });
+  if (this->source_->has_state())
+    this->publish_state(this->source_->state);
+}
+
+void NumberSensor::dump_config() { LOG_SENSOR("", "Number Sensor", this); }
+
+}  // namespace esphome::number
diff --git a/esphome/components/number/sensor/number_sensor.h b/esphome/components/number/sensor/number_sensor.h
new file mode 100644
index 0000000000..2d6825a298
--- /dev/null
+++ b/esphome/components/number/sensor/number_sensor.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "../number.h"
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+
+namespace esphome::number {
+
+class NumberSensor : public sensor::Sensor, public Component {
+ public:
+  explicit NumberSensor(Number *source) : source_(source) {}
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  Number *source_;
+};
+
+}  // namespace esphome::number
diff --git a/tests/components/number/common.yaml b/tests/components/number/common.yaml
new file mode 100644
index 0000000000..c17c2dd5f8
--- /dev/null
+++ b/tests/components/number/common.yaml
@@ -0,0 +1,13 @@
+number:
+  - platform: template
+    name: "Test Number"
+    id: test_number
+    optimistic: true
+    min_value: 0
+    max_value: 100
+    step: 1
+
+sensor:
+  - platform: number
+    name: "Test Number Value"
+    source_id: test_number
diff --git a/tests/components/number/test.esp32-idf.yaml b/tests/components/number/test.esp32-idf.yaml
new file mode 100644
index 0000000000..25cb37a0b4
--- /dev/null
+++ b/tests/components/number/test.esp32-idf.yaml
@@ -0,0 +1,2 @@
+packages:
+  common: !include common.yaml
diff --git a/tests/components/number/test.esp8266-ard.yaml b/tests/components/number/test.esp8266-ard.yaml
new file mode 100644
index 0000000000..25cb37a0b4
--- /dev/null
+++ b/tests/components/number/test.esp8266-ard.yaml
@@ -0,0 +1,2 @@
+packages:
+  common: !include common.yaml

From 0fb31726f69b304581caec41614a080774feda8a Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 13:39:29 -1000
Subject: [PATCH 57/60] [esp32] Add sram1_as_iram option and bootloader version
 detection (#14874)

---
 esphome/components/esp32/__init__.py       | 19 ++++++++
 esphome/core/application.cpp               | 50 ++++++++++++++++++----
 esphome/core/defines.h                     |  1 +
 tests/components/esp32/test.esp32-idf.yaml |  1 +
 4 files changed, 62 insertions(+), 9 deletions(-)

diff --git a/esphome/components/esp32/__init__.py b/esphome/components/esp32/__init__.py
index f85f13fe73..1ecc270fd1 100644
--- a/esphome/components/esp32/__init__.py
+++ b/esphome/components/esp32/__init__.py
@@ -97,6 +97,7 @@ CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
 CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
 CONF_MINIMUM_CHIP_REVISION = "minimum_chip_revision"
 CONF_RELEASE = "release"
+CONF_SRAM1_AS_IRAM = "sram1_as_iram"
 CONF_SUBTYPE = "subtype"
 
 ARDUINO_FRAMEWORK_NAME = "framework-arduinoespressif32"
@@ -884,6 +885,13 @@ def final_validate(config):
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_MINIMUM_CHIP_REVISION],
             )
         )
+    if config[CONF_VARIANT] != VARIANT_ESP32 and advanced[CONF_SRAM1_AS_IRAM]:
+        errs.append(
+            cv.Invalid(
+                f"'{CONF_SRAM1_AS_IRAM}' is only supported on {VARIANT_ESP32}",
+                path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_SRAM1_AS_IRAM],
+            )
+        )
     if (
         config[CONF_VARIANT] != VARIANT_ESP32P4
         and config.get(CONF_ENGINEERING_SAMPLE) is not None
@@ -1131,6 +1139,7 @@ FRAMEWORK_SCHEMA = cv.Schema(
                 cv.Optional(CONF_MINIMUM_CHIP_REVISION): cv.one_of(
                     *ESP32_CHIP_REVISIONS
                 ),
+                cv.Optional(CONF_SRAM1_AS_IRAM, default=False): cv.boolean,
                 # DHCP server is needed for WiFi AP mode. When WiFi component is used,
                 # it will handle disabling DHCP server when AP is not configured.
                 # Default to false (disabled) when WiFi is not used.
@@ -1655,6 +1664,16 @@ async def to_code(config):
             for rev, flag in ESP32_CHIP_REVISIONS.items():
                 add_idf_sdkconfig_option(flag, rev == min_rev)
             cg.add_define("USE_ESP32_MIN_CHIP_REVISION_SET")
+
+    # Use SRAM1 region as IRAM on ESP32 (original) variant
+    # This provides an additional 40KB of IRAM by using SRAM1 memory that was previously
+    # reserved for bootloader DRAM. Requires a bootloader from ESP-IDF v5.1 or later.
+    # WARNING: If the device has an old bootloader (pre-v5.1), the app will fail to boot.
+    # A USB flash will update the bootloader automatically. OTA updates do not.
+    # See: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/performance/ram-usage.html
+    if variant == VARIANT_ESP32 and conf[CONF_ADVANCED][CONF_SRAM1_AS_IRAM]:
+        add_idf_sdkconfig_option("CONFIG_ESP_SYSTEM_ESP32_SRAM1_REGION_AS_IRAM", True)
+        cg.add_define("USE_ESP32_SRAM1_AS_IRAM")
     add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_SINGLE_APP", False)
     add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM", True)
     add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM_FILENAME", "partitions.csv")
diff --git a/esphome/core/application.cpp b/esphome/core/application.cpp
index c020a8ed58..ce15aed1e2 100644
--- a/esphome/core/application.cpp
+++ b/esphome/core/application.cpp
@@ -9,6 +9,8 @@
 #endif
 #ifdef USE_ESP32
 #include <esp_chip_info.h>
+#include <esp_ota_ops.h>
+#include <esp_bootloader_desc.h>
 #endif
 #ifdef USE_LWIP_FAST_SELECT
 #include "esphome/core/lwip_fast_select.h"
@@ -167,19 +169,49 @@ void Application::process_dump_config_() {
     esp_chip_info(&chip_info);
     ESP_LOGI(TAG, "ESP32 Chip: %s rev%d.%d, %d core(s)", ESPHOME_VARIANT, chip_info.revision / 100,
              chip_info.revision % 100, chip_info.cores);
-#if defined(USE_ESP32_VARIANT_ESP32) && !defined(USE_ESP32_MIN_CHIP_REVISION_SET)
-    // Suggest optimization for chips that don't need the PSRAM cache workaround
-    if (chip_info.revision >= 300) {
-#ifdef USE_PSRAM
-      ESP_LOGW(TAG, "Set minimum_chip_revision: \"%d.%d\" to save ~10KB IRAM", chip_info.revision / 100,
-               chip_info.revision % 100);
-#else
-      ESP_LOGW(TAG, "Set minimum_chip_revision: \"%d.%d\" to reduce binary size", chip_info.revision / 100,
-               chip_info.revision % 100);
+#if defined(USE_ESP32_VARIANT_ESP32) && (!defined(USE_ESP32_MIN_CHIP_REVISION_SET) || !defined(USE_ESP32_SRAM1_AS_IRAM))
+    static const char *const ESP32_ADVANCED_PATH = "under esp32 > framework > advanced";
 #endif
+#if defined(USE_ESP32_VARIANT_ESP32) && !defined(USE_ESP32_MIN_CHIP_REVISION_SET)
+    {
+      // Suggest optimization for chips that don't need the PSRAM cache workaround
+      if (chip_info.revision >= 300) {
+#ifdef USE_PSRAM
+        ESP_LOGW(TAG, "Chip rev >= 3.0 detected. Set minimum_chip_revision: \"%d.%d\" %s to save ~10KB IRAM",
+                 chip_info.revision / 100, chip_info.revision % 100, ESP32_ADVANCED_PATH);
+#else
+        ESP_LOGW(TAG, "Chip rev >= 3.0 detected. Set minimum_chip_revision: \"%d.%d\" %s to reduce binary size",
+                 chip_info.revision / 100, chip_info.revision % 100, ESP32_ADVANCED_PATH);
+#endif
+      }
     }
 #endif
+    {
+      // esp_bootloader_desc_t is available in ESP-IDF >= 5.2; if readable the bootloader is modern.
+      //
+      // Design decision: We intentionally do NOT mention sram1_as_iram when the bootloader is too old.
+      // Enabling sram1_as_iram with an old bootloader causes a hard brick (device fails to boot,
+      // requires USB reflash to recover). Users don't always read warnings carefully, so we only
+      // suggest the option once we've confirmed the bootloader can handle it. In practice this
+      // means a user with an old bootloader may need to flash twice: once via USB to update the
+      // bootloader (they'll see the suggestion on next boot), then OTA with sram1_as_iram: true.
+      // Two flashes is a better outcome than a bricked device.
+      esp_bootloader_desc_t boot_desc;
+      if (esp_ota_get_bootloader_description(nullptr, &boot_desc) != ESP_OK) {
+#ifdef USE_ESP32_VARIANT_ESP32
+        ESP_LOGW(TAG, "Bootloader too old for OTA rollback and SRAM1 as IRAM (+40KB). "
+                      "Flash via USB once to update the bootloader");
+#else
+        ESP_LOGW(TAG, "Bootloader too old for OTA rollback. Flash via USB once to update the bootloader");
 #endif
+      }
+#if defined(USE_ESP32_VARIANT_ESP32) && !defined(USE_ESP32_SRAM1_AS_IRAM)
+      else {
+        ESP_LOGW(TAG, "Bootloader supports SRAM1 as IRAM (+40KB). Set sram1_as_iram: true %s", ESP32_ADVANCED_PATH);
+      }
+#endif
+    }
+#endif  // USE_ESP32
   }
 
   this->components_[this->dump_config_at_]->call_dump_config_();
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index f437e30a95..996818c2e6 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -202,6 +202,7 @@
 #define USE_ESPHOME_TASK_LOG_BUFFER
 #define USE_OTA_ROLLBACK
 #define USE_ESP32_MIN_CHIP_REVISION_SET
+#define USE_ESP32_SRAM1_AS_IRAM
 
 #define USE_BLUETOOTH_PROXY
 #define BLUETOOTH_PROXY_MAX_CONNECTIONS 3
diff --git a/tests/components/esp32/test.esp32-idf.yaml b/tests/components/esp32/test.esp32-idf.yaml
index da85aa3b0f..b999f23e1c 100644
--- a/tests/components/esp32/test.esp32-idf.yaml
+++ b/tests/components/esp32/test.esp32-idf.yaml
@@ -19,6 +19,7 @@ esp32:
       disable_mbedtls_pkcs7: true
       disable_regi2c_in_iram: true
       disable_fatfs: true
+      sram1_as_iram: true
 
 wifi:
   ssid: MySSID

From a0d0516b22e7ea8cd29c718ef510e9d33d3de5a7 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 13:40:41 -1000
Subject: [PATCH 58/60] [benchmark] Add noise handshake benchmark (#15039)

---
 .../components/api/bench_noise_encrypt.cpp    | 129 ++++++++++++++++++
 1 file changed, 129 insertions(+)

diff --git a/tests/benchmarks/components/api/bench_noise_encrypt.cpp b/tests/benchmarks/components/api/bench_noise_encrypt.cpp
index 223e6ada0d..9ef928192c 100644
--- a/tests/benchmarks/components/api/bench_noise_encrypt.cpp
+++ b/tests/benchmarks/components/api/bench_noise_encrypt.cpp
@@ -172,6 +172,135 @@ BENCHMARK(NoiseDecrypt_MediumMessage);
 static void NoiseDecrypt_LargeMessage(benchmark::State &state) { noise_decrypt_bench(state, 1024); }
 BENCHMARK(NoiseDecrypt_LargeMessage);
 
+// --- Full Noise_NNpsk0 handshake benchmark ---
+// Measures the complete handshake between initiator and responder:
+//   - Create handshake states for both sides
+//   - Set PSK and prologue
+//   - Exchange messages (initiator write -> responder read -> responder write -> initiator read)
+//   - Split to get cipher states
+// This is dominated by Curve25519 DH operations (expensive on ESP8266).
+// No inner iterations — each handshake is already expensive enough.
+
+static void NoiseHandshake_Full(benchmark::State &state) {
+  // Matching ESPHome's protocol: Noise_NNpsk0_25519_ChaChaPoly_SHA256
+  NoiseProtocolId nid;
+  memset(&nid, 0, sizeof(nid));
+  nid.pattern_id = NOISE_PATTERN_NN;
+  nid.cipher_id = NOISE_CIPHER_CHACHAPOLY;
+  nid.dh_id = NOISE_DH_CURVE25519;
+  nid.prefix_id = NOISE_PREFIX_STANDARD;
+  nid.hybrid_id = NOISE_DH_NONE;
+  nid.hash_id = NOISE_HASH_SHA256;
+  nid.modifier_ids[0] = NOISE_MODIFIER_PSK0;
+
+  // Dummy PSK (32 bytes) and prologue matching production setup
+  static constexpr uint8_t PSK[32] = {0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB,
+                                      0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB,
+                                      0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB};
+  static constexpr uint8_t PROLOGUE[] = "NoESPHome";
+
+  // Message buffer for handshake exchange (max handshake message ~96 bytes)
+  uint8_t msg_buf[128];
+
+  for (auto _ : state) {
+    NoiseHandshakeState *initiator = nullptr;
+    NoiseHandshakeState *responder = nullptr;
+    NoiseCipherState *init_send = nullptr, *init_recv = nullptr;
+    NoiseCipherState *resp_send = nullptr, *resp_recv = nullptr;
+    int err;
+
+    // Create both handshake states
+    err = noise_handshakestate_new_by_id(&initiator, &nid, NOISE_ROLE_INITIATOR);
+    if (err != NOISE_ERROR_NONE) {
+      state.SkipWithError("Failed to create initiator");
+      return;
+    }
+    err = noise_handshakestate_new_by_id(&responder, &nid, NOISE_ROLE_RESPONDER);
+    if (err != NOISE_ERROR_NONE) {
+      state.SkipWithError("Failed to create responder");
+      noise_handshakestate_free(initiator);
+      return;
+    }
+
+    // Set PSK and prologue on both sides
+    noise_handshakestate_set_pre_shared_key(initiator, PSK, sizeof(PSK));
+    noise_handshakestate_set_pre_shared_key(responder, PSK, sizeof(PSK));
+    noise_handshakestate_set_prologue(initiator, PROLOGUE, sizeof(PROLOGUE) - 1);
+    noise_handshakestate_set_prologue(responder, PROLOGUE, sizeof(PROLOGUE) - 1);
+
+    noise_handshakestate_start(initiator);
+    noise_handshakestate_start(responder);
+
+    // Message 1: Initiator -> Responder
+    NoiseBuffer write_buf, read_buf;
+    noise_buffer_set_output(write_buf, msg_buf, sizeof(msg_buf));
+    err = noise_handshakestate_write_message(initiator, &write_buf, nullptr);
+    if (err != NOISE_ERROR_NONE) {
+      state.SkipWithError("Initiator write_message failed");
+      noise_handshakestate_free(initiator);
+      noise_handshakestate_free(responder);
+      return;
+    }
+
+    noise_buffer_set_input(read_buf, msg_buf, write_buf.size);
+    err = noise_handshakestate_read_message(responder, &read_buf, nullptr);
+    if (err != NOISE_ERROR_NONE) {
+      state.SkipWithError("Responder read_message failed");
+      noise_handshakestate_free(initiator);
+      noise_handshakestate_free(responder);
+      return;
+    }
+
+    // Message 2: Responder -> Initiator
+    noise_buffer_set_output(write_buf, msg_buf, sizeof(msg_buf));
+    err = noise_handshakestate_write_message(responder, &write_buf, nullptr);
+    if (err != NOISE_ERROR_NONE) {
+      state.SkipWithError("Responder write_message failed");
+      noise_handshakestate_free(initiator);
+      noise_handshakestate_free(responder);
+      return;
+    }
+
+    noise_buffer_set_input(read_buf, msg_buf, write_buf.size);
+    err = noise_handshakestate_read_message(initiator, &read_buf, nullptr);
+    if (err != NOISE_ERROR_NONE) {
+      state.SkipWithError("Initiator read_message failed");
+      noise_handshakestate_free(initiator);
+      noise_handshakestate_free(responder);
+      return;
+    }
+
+    // Split to get cipher states
+    err = noise_handshakestate_split(initiator, &init_send, &init_recv);
+    if (err != NOISE_ERROR_NONE) {
+      state.SkipWithError("Initiator split failed");
+      noise_handshakestate_free(initiator);
+      noise_handshakestate_free(responder);
+      return;
+    }
+    err = noise_handshakestate_split(responder, &resp_send, &resp_recv);
+    if (err != NOISE_ERROR_NONE) {
+      state.SkipWithError("Responder split failed");
+      noise_handshakestate_free(initiator);
+      noise_handshakestate_free(responder);
+      noise_cipherstate_free(init_send);
+      noise_cipherstate_free(init_recv);
+      return;
+    }
+
+    benchmark::DoNotOptimize(init_send);
+
+    // Cleanup
+    noise_handshakestate_free(initiator);
+    noise_handshakestate_free(responder);
+    noise_cipherstate_free(init_send);
+    noise_cipherstate_free(init_recv);
+    noise_cipherstate_free(resp_send);
+    noise_cipherstate_free(resp_recv);
+  }
+}
+BENCHMARK(NoiseHandshake_Full);
+
 }  // namespace esphome::api::benchmarks
 
 #endif  // USE_API_NOISE

From 382de7ca906b2b584b1c6188105a50523182f2f1 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 13:40:53 -1000
Subject: [PATCH 59/60] [api] Store dump strings in PROGMEM to save RAM on
 ESP8266 (#14982)

---
 esphome/components/api/api_pb2.h           |  274 +--
 esphome/components/api/api_pb2_dump.cpp    | 2425 ++++++++++----------
 esphome/components/api/api_pb2_service.cpp |    4 +-
 esphome/components/api/api_pb2_service.h   |    2 +-
 esphome/components/api/proto.h             |   20 +-
 script/api_protobuf/api_protobuf.py        |   96 +-
 6 files changed, 1443 insertions(+), 1378 deletions(-)

diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index 86289a28d6..16586e6e9a 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -388,7 +388,7 @@ class HelloRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 1;
   static constexpr uint8_t ESTIMATED_SIZE = 17;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "hello_request"; }
+  const LogString *message_name() const override { return LOG_STR("hello_request"); }
 #endif
   StringRef client_info{};
   uint32_t api_version_major{0};
@@ -406,7 +406,7 @@ class HelloResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 2;
   static constexpr uint8_t ESTIMATED_SIZE = 26;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "hello_response"; }
+  const LogString *message_name() const override { return LOG_STR("hello_response"); }
 #endif
   uint32_t api_version_major{0};
   uint32_t api_version_minor{0};
@@ -425,7 +425,7 @@ class DisconnectRequest final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 5;
   static constexpr uint8_t ESTIMATED_SIZE = 0;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "disconnect_request"; }
+  const LogString *message_name() const override { return LOG_STR("disconnect_request"); }
 #endif
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -438,7 +438,7 @@ class DisconnectResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 6;
   static constexpr uint8_t ESTIMATED_SIZE = 0;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "disconnect_response"; }
+  const LogString *message_name() const override { return LOG_STR("disconnect_response"); }
 #endif
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -451,7 +451,7 @@ class PingRequest final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 7;
   static constexpr uint8_t ESTIMATED_SIZE = 0;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "ping_request"; }
+  const LogString *message_name() const override { return LOG_STR("ping_request"); }
 #endif
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -464,7 +464,7 @@ class PingResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 8;
   static constexpr uint8_t ESTIMATED_SIZE = 0;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "ping_response"; }
+  const LogString *message_name() const override { return LOG_STR("ping_response"); }
 #endif
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -520,7 +520,7 @@ class DeviceInfoResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 10;
   static constexpr uint16_t ESTIMATED_SIZE = 309;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "device_info_response"; }
+  const LogString *message_name() const override { return LOG_STR("device_info_response"); }
 #endif
   StringRef name{};
   StringRef mac_address{};
@@ -587,7 +587,7 @@ class ListEntitiesDoneResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 19;
   static constexpr uint8_t ESTIMATED_SIZE = 0;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_done_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_done_response"); }
 #endif
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -601,7 +601,7 @@ class ListEntitiesBinarySensorResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 12;
   static constexpr uint8_t ESTIMATED_SIZE = 51;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_binary_sensor_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_binary_sensor_response"); }
 #endif
   StringRef device_class{};
   bool is_status_binary_sensor{false};
@@ -618,7 +618,7 @@ class BinarySensorStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 21;
   static constexpr uint8_t ESTIMATED_SIZE = 13;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "binary_sensor_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("binary_sensor_state_response"); }
 #endif
   bool state{false};
   bool missing_state{false};
@@ -637,7 +637,7 @@ class ListEntitiesCoverResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 13;
   static constexpr uint8_t ESTIMATED_SIZE = 57;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_cover_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_cover_response"); }
 #endif
   bool assumed_state{false};
   bool supports_position{false};
@@ -657,7 +657,7 @@ class CoverStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 22;
   static constexpr uint8_t ESTIMATED_SIZE = 21;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "cover_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("cover_state_response"); }
 #endif
   float position{0.0f};
   float tilt{0.0f};
@@ -675,7 +675,7 @@ class CoverCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 30;
   static constexpr uint8_t ESTIMATED_SIZE = 25;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "cover_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("cover_command_request"); }
 #endif
   bool has_position{false};
   float position{0.0f};
@@ -697,7 +697,7 @@ class ListEntitiesFanResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 14;
   static constexpr uint8_t ESTIMATED_SIZE = 68;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_fan_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_fan_response"); }
 #endif
   bool supports_oscillation{false};
   bool supports_speed{false};
@@ -717,7 +717,7 @@ class FanStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 23;
   static constexpr uint8_t ESTIMATED_SIZE = 28;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "fan_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("fan_state_response"); }
 #endif
   bool state{false};
   bool oscillating{false};
@@ -737,7 +737,7 @@ class FanCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 31;
   static constexpr uint8_t ESTIMATED_SIZE = 38;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "fan_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("fan_command_request"); }
 #endif
   bool has_state{false};
   bool state{false};
@@ -765,7 +765,7 @@ class ListEntitiesLightResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 15;
   static constexpr uint8_t ESTIMATED_SIZE = 73;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_light_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_light_response"); }
 #endif
   const light::ColorModeMask *supported_color_modes{};
   float min_mireds{0.0f};
@@ -784,7 +784,7 @@ class LightStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 24;
   static constexpr uint8_t ESTIMATED_SIZE = 67;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "light_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("light_state_response"); }
 #endif
   bool state{false};
   float brightness{0.0f};
@@ -811,7 +811,7 @@ class LightCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 32;
   static constexpr uint8_t ESTIMATED_SIZE = 112;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "light_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("light_command_request"); }
 #endif
   bool has_state{false};
   bool state{false};
@@ -855,7 +855,7 @@ class ListEntitiesSensorResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 16;
   static constexpr uint8_t ESTIMATED_SIZE = 66;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_sensor_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_sensor_response"); }
 #endif
   StringRef unit_of_measurement{};
   int32_t accuracy_decimals{0};
@@ -875,7 +875,7 @@ class SensorStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 25;
   static constexpr uint8_t ESTIMATED_SIZE = 16;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "sensor_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("sensor_state_response"); }
 #endif
   float state{0.0f};
   bool missing_state{false};
@@ -894,7 +894,7 @@ class ListEntitiesSwitchResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 17;
   static constexpr uint8_t ESTIMATED_SIZE = 51;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_switch_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_switch_response"); }
 #endif
   bool assumed_state{false};
   StringRef device_class{};
@@ -911,7 +911,7 @@ class SwitchStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 26;
   static constexpr uint8_t ESTIMATED_SIZE = 11;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "switch_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("switch_state_response"); }
 #endif
   bool state{false};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -927,7 +927,7 @@ class SwitchCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 33;
   static constexpr uint8_t ESTIMATED_SIZE = 11;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "switch_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("switch_command_request"); }
 #endif
   bool state{false};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -945,7 +945,7 @@ class ListEntitiesTextSensorResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 18;
   static constexpr uint8_t ESTIMATED_SIZE = 49;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_text_sensor_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_text_sensor_response"); }
 #endif
   StringRef device_class{};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -961,7 +961,7 @@ class TextSensorStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 27;
   static constexpr uint8_t ESTIMATED_SIZE = 20;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "text_sensor_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("text_sensor_state_response"); }
 #endif
   StringRef state{};
   bool missing_state{false};
@@ -979,7 +979,7 @@ class SubscribeLogsRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 28;
   static constexpr uint8_t ESTIMATED_SIZE = 4;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "subscribe_logs_request"; }
+  const LogString *message_name() const override { return LOG_STR("subscribe_logs_request"); }
 #endif
   enums::LogLevel level{};
   bool dump_config{false};
@@ -995,7 +995,7 @@ class SubscribeLogsResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 29;
   static constexpr uint8_t ESTIMATED_SIZE = 21;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "subscribe_logs_response"; }
+  const LogString *message_name() const override { return LOG_STR("subscribe_logs_response"); }
 #endif
   enums::LogLevel level{};
   const uint8_t *message_ptr_{nullptr};
@@ -1018,7 +1018,7 @@ class NoiseEncryptionSetKeyRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 124;
   static constexpr uint8_t ESTIMATED_SIZE = 19;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "noise_encryption_set_key_request"; }
+  const LogString *message_name() const override { return LOG_STR("noise_encryption_set_key_request"); }
 #endif
   const uint8_t *key{nullptr};
   uint16_t key_len{0};
@@ -1034,7 +1034,7 @@ class NoiseEncryptionSetKeyResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 125;
   static constexpr uint8_t ESTIMATED_SIZE = 2;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "noise_encryption_set_key_response"; }
+  const LogString *message_name() const override { return LOG_STR("noise_encryption_set_key_response"); }
 #endif
   bool success{false};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -1064,7 +1064,7 @@ class HomeassistantActionRequest final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 35;
   static constexpr uint8_t ESTIMATED_SIZE = 128;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "homeassistant_action_request"; }
+  const LogString *message_name() const override { return LOG_STR("homeassistant_action_request"); }
 #endif
   StringRef service{};
   FixedVector<HomeassistantServiceMap> data{};
@@ -1095,7 +1095,7 @@ class HomeassistantActionResponse final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 130;
   static constexpr uint8_t ESTIMATED_SIZE = 34;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "homeassistant_action_response"; }
+  const LogString *message_name() const override { return LOG_STR("homeassistant_action_response"); }
 #endif
   uint32_t call_id{0};
   bool success{false};
@@ -1119,7 +1119,7 @@ class SubscribeHomeAssistantStateResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 39;
   static constexpr uint8_t ESTIMATED_SIZE = 20;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "subscribe_home_assistant_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("subscribe_home_assistant_state_response"); }
 #endif
   StringRef entity_id{};
   StringRef attribute{};
@@ -1137,7 +1137,7 @@ class HomeAssistantStateResponse final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 40;
   static constexpr uint8_t ESTIMATED_SIZE = 27;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "home_assistant_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("home_assistant_state_response"); }
 #endif
   StringRef entity_id{};
   StringRef state{};
@@ -1155,7 +1155,7 @@ class GetTimeRequest final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 36;
   static constexpr uint8_t ESTIMATED_SIZE = 0;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "get_time_request"; }
+  const LogString *message_name() const override { return LOG_STR("get_time_request"); }
 #endif
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1197,7 +1197,7 @@ class GetTimeResponse final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 37;
   static constexpr uint8_t ESTIMATED_SIZE = 31;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "get_time_response"; }
+  const LogString *message_name() const override { return LOG_STR("get_time_response"); }
 #endif
   uint32_t epoch_seconds{0};
   StringRef timezone{};
@@ -1228,7 +1228,7 @@ class ListEntitiesServicesResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 41;
   static constexpr uint8_t ESTIMATED_SIZE = 50;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_services_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_services_response"); }
 #endif
   StringRef name{};
   uint32_t key{0};
@@ -1268,7 +1268,7 @@ class ExecuteServiceRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 42;
   static constexpr uint8_t ESTIMATED_SIZE = 45;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "execute_service_request"; }
+  const LogString *message_name() const override { return LOG_STR("execute_service_request"); }
 #endif
   uint32_t key{0};
   FixedVector<ExecuteServiceArgument> args{};
@@ -1295,7 +1295,7 @@ class ExecuteServiceResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 131;
   static constexpr uint8_t ESTIMATED_SIZE = 34;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "execute_service_response"; }
+  const LogString *message_name() const override { return LOG_STR("execute_service_response"); }
 #endif
   uint32_t call_id{0};
   bool success{false};
@@ -1319,7 +1319,7 @@ class ListEntitiesCameraResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 43;
   static constexpr uint8_t ESTIMATED_SIZE = 40;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_camera_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_camera_response"); }
 #endif
   void encode(ProtoWriteBuffer &buffer) const;
   uint32_t calculate_size() const;
@@ -1334,7 +1334,7 @@ class CameraImageResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 44;
   static constexpr uint8_t ESTIMATED_SIZE = 30;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "camera_image_response"; }
+  const LogString *message_name() const override { return LOG_STR("camera_image_response"); }
 #endif
   const uint8_t *data_ptr_{nullptr};
   size_t data_len_{0};
@@ -1356,7 +1356,7 @@ class CameraImageRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 45;
   static constexpr uint8_t ESTIMATED_SIZE = 4;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "camera_image_request"; }
+  const LogString *message_name() const override { return LOG_STR("camera_image_request"); }
 #endif
   bool single{false};
   bool stream{false};
@@ -1374,7 +1374,7 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 46;
   static constexpr uint8_t ESTIMATED_SIZE = 150;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_climate_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_climate_response"); }
 #endif
   bool supports_current_temperature{false};
   bool supports_two_point_target_temperature{false};
@@ -1407,7 +1407,7 @@ class ClimateStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 47;
   static constexpr uint8_t ESTIMATED_SIZE = 68;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "climate_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("climate_state_response"); }
 #endif
   enums::ClimateMode mode{};
   float current_temperature{0.0f};
@@ -1435,7 +1435,7 @@ class ClimateCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 48;
   static constexpr uint8_t ESTIMATED_SIZE = 84;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "climate_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("climate_command_request"); }
 #endif
   bool has_mode{false};
   enums::ClimateMode mode{};
@@ -1473,7 +1473,7 @@ class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 132;
   static constexpr uint8_t ESTIMATED_SIZE = 63;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_water_heater_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_water_heater_response"); }
 #endif
   float min_temperature{0.0f};
   float max_temperature{0.0f};
@@ -1493,7 +1493,7 @@ class WaterHeaterStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 133;
   static constexpr uint8_t ESTIMATED_SIZE = 35;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "water_heater_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("water_heater_state_response"); }
 #endif
   float current_temperature{0.0f};
   float target_temperature{0.0f};
@@ -1514,7 +1514,7 @@ class WaterHeaterCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 134;
   static constexpr uint8_t ESTIMATED_SIZE = 34;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "water_heater_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("water_heater_command_request"); }
 #endif
   uint32_t has_fields{0};
   enums::WaterHeaterMode mode{};
@@ -1537,7 +1537,7 @@ class ListEntitiesNumberResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 49;
   static constexpr uint8_t ESTIMATED_SIZE = 75;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_number_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_number_response"); }
 #endif
   float min_value{0.0f};
   float max_value{0.0f};
@@ -1558,7 +1558,7 @@ class NumberStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 50;
   static constexpr uint8_t ESTIMATED_SIZE = 16;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "number_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("number_state_response"); }
 #endif
   float state{0.0f};
   bool missing_state{false};
@@ -1575,7 +1575,7 @@ class NumberCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 51;
   static constexpr uint8_t ESTIMATED_SIZE = 14;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "number_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("number_command_request"); }
 #endif
   float state{0.0f};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1593,7 +1593,7 @@ class ListEntitiesSelectResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 52;
   static constexpr uint8_t ESTIMATED_SIZE = 58;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_select_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_select_response"); }
 #endif
   const FixedVector<const char *> *options{};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -1609,7 +1609,7 @@ class SelectStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 53;
   static constexpr uint8_t ESTIMATED_SIZE = 20;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "select_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("select_state_response"); }
 #endif
   StringRef state{};
   bool missing_state{false};
@@ -1626,7 +1626,7 @@ class SelectCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 54;
   static constexpr uint8_t ESTIMATED_SIZE = 18;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "select_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("select_command_request"); }
 #endif
   StringRef state{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1645,7 +1645,7 @@ class ListEntitiesSirenResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 55;
   static constexpr uint8_t ESTIMATED_SIZE = 62;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_siren_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_siren_response"); }
 #endif
   const FixedVector<const char *> *tones{};
   bool supports_duration{false};
@@ -1663,7 +1663,7 @@ class SirenStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 56;
   static constexpr uint8_t ESTIMATED_SIZE = 11;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "siren_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("siren_state_response"); }
 #endif
   bool state{false};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -1679,7 +1679,7 @@ class SirenCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 57;
   static constexpr uint8_t ESTIMATED_SIZE = 37;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "siren_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("siren_command_request"); }
 #endif
   bool has_state{false};
   bool state{false};
@@ -1705,7 +1705,7 @@ class ListEntitiesLockResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 58;
   static constexpr uint8_t ESTIMATED_SIZE = 55;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_lock_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_lock_response"); }
 #endif
   bool assumed_state{false};
   bool supports_open{false};
@@ -1724,7 +1724,7 @@ class LockStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 59;
   static constexpr uint8_t ESTIMATED_SIZE = 11;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "lock_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("lock_state_response"); }
 #endif
   enums::LockState state{};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -1740,7 +1740,7 @@ class LockCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 60;
   static constexpr uint8_t ESTIMATED_SIZE = 22;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "lock_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("lock_command_request"); }
 #endif
   enums::LockCommand command{};
   bool has_code{false};
@@ -1761,7 +1761,7 @@ class ListEntitiesButtonResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 61;
   static constexpr uint8_t ESTIMATED_SIZE = 49;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_button_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_button_response"); }
 #endif
   StringRef device_class{};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -1777,7 +1777,7 @@ class ButtonCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 62;
   static constexpr uint8_t ESTIMATED_SIZE = 9;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "button_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("button_command_request"); }
 #endif
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
@@ -1809,7 +1809,7 @@ class ListEntitiesMediaPlayerResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 63;
   static constexpr uint8_t ESTIMATED_SIZE = 80;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_media_player_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_media_player_response"); }
 #endif
   bool supports_pause{false};
   std::vector<MediaPlayerSupportedFormat> supported_formats{};
@@ -1827,7 +1827,7 @@ class MediaPlayerStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 64;
   static constexpr uint8_t ESTIMATED_SIZE = 18;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "media_player_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("media_player_state_response"); }
 #endif
   enums::MediaPlayerState state{};
   float volume{0.0f};
@@ -1845,7 +1845,7 @@ class MediaPlayerCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 65;
   static constexpr uint8_t ESTIMATED_SIZE = 35;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "media_player_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("media_player_command_request"); }
 #endif
   bool has_command{false};
   enums::MediaPlayerCommand command{};
@@ -1871,7 +1871,7 @@ class SubscribeBluetoothLEAdvertisementsRequest final : public ProtoDecodableMes
   static constexpr uint8_t MESSAGE_TYPE = 66;
   static constexpr uint8_t ESTIMATED_SIZE = 4;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "subscribe_bluetooth_le_advertisements_request"; }
+  const LogString *message_name() const override { return LOG_STR("subscribe_bluetooth_le_advertisements_request"); }
 #endif
   uint32_t flags{0};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1901,7 +1901,7 @@ class BluetoothLERawAdvertisementsResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 93;
   static constexpr uint8_t ESTIMATED_SIZE = 136;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_le_raw_advertisements_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_le_raw_advertisements_response"); }
 #endif
   std::array<BluetoothLERawAdvertisement, BLUETOOTH_PROXY_ADVERTISEMENT_BATCH_SIZE> advertisements{};
   uint16_t advertisements_len{0};
@@ -1918,7 +1918,7 @@ class BluetoothDeviceRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 68;
   static constexpr uint8_t ESTIMATED_SIZE = 12;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_device_request"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_device_request"); }
 #endif
   uint64_t address{0};
   enums::BluetoothDeviceRequestType request_type{};
@@ -1936,7 +1936,7 @@ class BluetoothDeviceConnectionResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 69;
   static constexpr uint8_t ESTIMATED_SIZE = 14;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_device_connection_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_device_connection_response"); }
 #endif
   uint64_t address{0};
   bool connected{false};
@@ -1955,7 +1955,7 @@ class BluetoothGATTGetServicesRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 70;
   static constexpr uint8_t ESTIMATED_SIZE = 4;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_get_services_request"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_get_services_request"); }
 #endif
   uint64_t address{0};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2012,7 +2012,7 @@ class BluetoothGATTGetServicesResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 71;
   static constexpr uint8_t ESTIMATED_SIZE = 38;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_get_services_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_get_services_response"); }
 #endif
   uint64_t address{0};
   std::vector<BluetoothGATTService> services{};
@@ -2029,7 +2029,7 @@ class BluetoothGATTGetServicesDoneResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 72;
   static constexpr uint8_t ESTIMATED_SIZE = 4;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_get_services_done_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_get_services_done_response"); }
 #endif
   uint64_t address{0};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -2045,7 +2045,7 @@ class BluetoothGATTReadRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 73;
   static constexpr uint8_t ESTIMATED_SIZE = 8;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_read_request"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_read_request"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2061,7 +2061,7 @@ class BluetoothGATTReadResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 74;
   static constexpr uint8_t ESTIMATED_SIZE = 27;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_read_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_read_response"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2084,7 +2084,7 @@ class BluetoothGATTWriteRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 75;
   static constexpr uint8_t ESTIMATED_SIZE = 29;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_write_request"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_write_request"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2104,7 +2104,7 @@ class BluetoothGATTReadDescriptorRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 76;
   static constexpr uint8_t ESTIMATED_SIZE = 8;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_read_descriptor_request"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_read_descriptor_request"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2120,7 +2120,7 @@ class BluetoothGATTWriteDescriptorRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 77;
   static constexpr uint8_t ESTIMATED_SIZE = 27;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_write_descriptor_request"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_write_descriptor_request"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2139,7 +2139,7 @@ class BluetoothGATTNotifyRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 78;
   static constexpr uint8_t ESTIMATED_SIZE = 10;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_notify_request"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_notify_request"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2156,7 +2156,7 @@ class BluetoothGATTNotifyDataResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 79;
   static constexpr uint8_t ESTIMATED_SIZE = 27;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_notify_data_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_notify_data_response"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2179,7 +2179,7 @@ class BluetoothConnectionsFreeResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 81;
   static constexpr uint8_t ESTIMATED_SIZE = 20;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_connections_free_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_connections_free_response"); }
 #endif
   uint32_t free{0};
   uint32_t limit{0};
@@ -2197,7 +2197,7 @@ class BluetoothGATTErrorResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 82;
   static constexpr uint8_t ESTIMATED_SIZE = 12;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_error_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_error_response"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2215,7 +2215,7 @@ class BluetoothGATTWriteResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 83;
   static constexpr uint8_t ESTIMATED_SIZE = 8;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_write_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_write_response"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2232,7 +2232,7 @@ class BluetoothGATTNotifyResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 84;
   static constexpr uint8_t ESTIMATED_SIZE = 8;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_gatt_notify_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_notify_response"); }
 #endif
   uint64_t address{0};
   uint32_t handle{0};
@@ -2249,7 +2249,7 @@ class BluetoothDevicePairingResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 85;
   static constexpr uint8_t ESTIMATED_SIZE = 10;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_device_pairing_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_device_pairing_response"); }
 #endif
   uint64_t address{0};
   bool paired{false};
@@ -2267,7 +2267,7 @@ class BluetoothDeviceUnpairingResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 86;
   static constexpr uint8_t ESTIMATED_SIZE = 10;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_device_unpairing_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_device_unpairing_response"); }
 #endif
   uint64_t address{0};
   bool success{false};
@@ -2285,7 +2285,7 @@ class BluetoothDeviceClearCacheResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 88;
   static constexpr uint8_t ESTIMATED_SIZE = 10;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_device_clear_cache_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_device_clear_cache_response"); }
 #endif
   uint64_t address{0};
   bool success{false};
@@ -2303,7 +2303,7 @@ class BluetoothScannerStateResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 126;
   static constexpr uint8_t ESTIMATED_SIZE = 6;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_scanner_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_scanner_state_response"); }
 #endif
   enums::BluetoothScannerState state{};
   enums::BluetoothScannerMode mode{};
@@ -2321,7 +2321,7 @@ class BluetoothScannerSetModeRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 127;
   static constexpr uint8_t ESTIMATED_SIZE = 2;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_scanner_set_mode_request"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_scanner_set_mode_request"); }
 #endif
   enums::BluetoothScannerMode mode{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2338,7 +2338,7 @@ class SubscribeVoiceAssistantRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 89;
   static constexpr uint8_t ESTIMATED_SIZE = 6;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "subscribe_voice_assistant_request"; }
+  const LogString *message_name() const override { return LOG_STR("subscribe_voice_assistant_request"); }
 #endif
   bool subscribe{false};
   uint32_t flags{0};
@@ -2367,7 +2367,7 @@ class VoiceAssistantRequest final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 90;
   static constexpr uint8_t ESTIMATED_SIZE = 41;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_request"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_request"); }
 #endif
   bool start{false};
   StringRef conversation_id{};
@@ -2387,7 +2387,7 @@ class VoiceAssistantResponse final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 91;
   static constexpr uint8_t ESTIMATED_SIZE = 6;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_response"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_response"); }
 #endif
   uint32_t port{0};
   bool error{false};
@@ -2414,7 +2414,7 @@ class VoiceAssistantEventResponse final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 92;
   static constexpr uint8_t ESTIMATED_SIZE = 36;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_event_response"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_event_response"); }
 #endif
   enums::VoiceAssistantEvent event_type{};
   std::vector<VoiceAssistantEventData> data{};
@@ -2431,7 +2431,7 @@ class VoiceAssistantAudio final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 106;
   static constexpr uint8_t ESTIMATED_SIZE = 21;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_audio"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_audio"); }
 #endif
   const uint8_t *data{nullptr};
   uint16_t data_len{0};
@@ -2451,7 +2451,7 @@ class VoiceAssistantTimerEventResponse final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 115;
   static constexpr uint8_t ESTIMATED_SIZE = 30;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_timer_event_response"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_timer_event_response"); }
 #endif
   enums::VoiceAssistantTimerEvent event_type{};
   StringRef timer_id{};
@@ -2472,7 +2472,7 @@ class VoiceAssistantAnnounceRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 119;
   static constexpr uint8_t ESTIMATED_SIZE = 29;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_announce_request"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_announce_request"); }
 #endif
   StringRef media_id{};
   StringRef text{};
@@ -2491,7 +2491,7 @@ class VoiceAssistantAnnounceFinished final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 120;
   static constexpr uint8_t ESTIMATED_SIZE = 2;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_announce_finished"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_announce_finished"); }
 #endif
   bool success{false};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -2537,7 +2537,7 @@ class VoiceAssistantConfigurationRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 121;
   static constexpr uint8_t ESTIMATED_SIZE = 34;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_configuration_request"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_configuration_request"); }
 #endif
   std::vector<VoiceAssistantExternalWakeWord> external_wake_words{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2552,7 +2552,7 @@ class VoiceAssistantConfigurationResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 122;
   static constexpr uint8_t ESTIMATED_SIZE = 56;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_configuration_response"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_configuration_response"); }
 #endif
   std::vector<VoiceAssistantWakeWord> available_wake_words{};
   const std::vector<std::string> *active_wake_words{};
@@ -2570,7 +2570,7 @@ class VoiceAssistantSetConfiguration final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 123;
   static constexpr uint8_t ESTIMATED_SIZE = 18;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "voice_assistant_set_configuration"; }
+  const LogString *message_name() const override { return LOG_STR("voice_assistant_set_configuration"); }
 #endif
   std::vector<std::string> active_wake_words{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2587,7 +2587,7 @@ class ListEntitiesAlarmControlPanelResponse final : public InfoResponseProtoMess
   static constexpr uint8_t MESSAGE_TYPE = 94;
   static constexpr uint8_t ESTIMATED_SIZE = 48;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_alarm_control_panel_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_alarm_control_panel_response"); }
 #endif
   uint32_t supported_features{0};
   bool requires_code{false};
@@ -2605,7 +2605,7 @@ class AlarmControlPanelStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 95;
   static constexpr uint8_t ESTIMATED_SIZE = 11;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "alarm_control_panel_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("alarm_control_panel_state_response"); }
 #endif
   enums::AlarmControlPanelState state{};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -2621,7 +2621,7 @@ class AlarmControlPanelCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 96;
   static constexpr uint8_t ESTIMATED_SIZE = 20;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "alarm_control_panel_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("alarm_control_panel_command_request"); }
 #endif
   enums::AlarmControlPanelStateCommand command{};
   StringRef code{};
@@ -2641,7 +2641,7 @@ class ListEntitiesTextResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 97;
   static constexpr uint8_t ESTIMATED_SIZE = 59;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_text_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_text_response"); }
 #endif
   uint32_t min_length{0};
   uint32_t max_length{0};
@@ -2660,7 +2660,7 @@ class TextStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 98;
   static constexpr uint8_t ESTIMATED_SIZE = 20;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "text_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("text_state_response"); }
 #endif
   StringRef state{};
   bool missing_state{false};
@@ -2677,7 +2677,7 @@ class TextCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 99;
   static constexpr uint8_t ESTIMATED_SIZE = 18;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "text_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("text_command_request"); }
 #endif
   StringRef state{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2696,7 +2696,7 @@ class ListEntitiesDateResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 100;
   static constexpr uint8_t ESTIMATED_SIZE = 40;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_date_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_date_response"); }
 #endif
   void encode(ProtoWriteBuffer &buffer) const;
   uint32_t calculate_size() const;
@@ -2711,7 +2711,7 @@ class DateStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 101;
   static constexpr uint8_t ESTIMATED_SIZE = 23;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "date_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("date_state_response"); }
 #endif
   bool missing_state{false};
   uint32_t year{0};
@@ -2730,7 +2730,7 @@ class DateCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 102;
   static constexpr uint8_t ESTIMATED_SIZE = 21;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "date_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("date_command_request"); }
 #endif
   uint32_t year{0};
   uint32_t month{0};
@@ -2750,7 +2750,7 @@ class ListEntitiesTimeResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 103;
   static constexpr uint8_t ESTIMATED_SIZE = 40;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_time_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_time_response"); }
 #endif
   void encode(ProtoWriteBuffer &buffer) const;
   uint32_t calculate_size() const;
@@ -2765,7 +2765,7 @@ class TimeStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 104;
   static constexpr uint8_t ESTIMATED_SIZE = 23;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "time_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("time_state_response"); }
 #endif
   bool missing_state{false};
   uint32_t hour{0};
@@ -2784,7 +2784,7 @@ class TimeCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 105;
   static constexpr uint8_t ESTIMATED_SIZE = 21;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "time_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("time_command_request"); }
 #endif
   uint32_t hour{0};
   uint32_t minute{0};
@@ -2804,7 +2804,7 @@ class ListEntitiesEventResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 107;
   static constexpr uint8_t ESTIMATED_SIZE = 67;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_event_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_event_response"); }
 #endif
   StringRef device_class{};
   const FixedVector<const char *> *event_types{};
@@ -2821,7 +2821,7 @@ class EventResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 108;
   static constexpr uint8_t ESTIMATED_SIZE = 18;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "event_response"; }
+  const LogString *message_name() const override { return LOG_STR("event_response"); }
 #endif
   StringRef event_type{};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -2839,7 +2839,7 @@ class ListEntitiesValveResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 109;
   static constexpr uint8_t ESTIMATED_SIZE = 55;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_valve_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_valve_response"); }
 #endif
   StringRef device_class{};
   bool assumed_state{false};
@@ -2858,7 +2858,7 @@ class ValveStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 110;
   static constexpr uint8_t ESTIMATED_SIZE = 16;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "valve_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("valve_state_response"); }
 #endif
   float position{0.0f};
   enums::ValveOperation current_operation{};
@@ -2875,7 +2875,7 @@ class ValveCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 111;
   static constexpr uint8_t ESTIMATED_SIZE = 18;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "valve_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("valve_command_request"); }
 #endif
   bool has_position{false};
   float position{0.0f};
@@ -2895,7 +2895,7 @@ class ListEntitiesDateTimeResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 112;
   static constexpr uint8_t ESTIMATED_SIZE = 40;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_date_time_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_date_time_response"); }
 #endif
   void encode(ProtoWriteBuffer &buffer) const;
   uint32_t calculate_size() const;
@@ -2910,7 +2910,7 @@ class DateTimeStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 113;
   static constexpr uint8_t ESTIMATED_SIZE = 16;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "date_time_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("date_time_state_response"); }
 #endif
   bool missing_state{false};
   uint32_t epoch_seconds{0};
@@ -2927,7 +2927,7 @@ class DateTimeCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 114;
   static constexpr uint8_t ESTIMATED_SIZE = 14;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "date_time_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("date_time_command_request"); }
 #endif
   uint32_t epoch_seconds{0};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2945,7 +2945,7 @@ class ListEntitiesUpdateResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 116;
   static constexpr uint8_t ESTIMATED_SIZE = 49;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_update_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_update_response"); }
 #endif
   StringRef device_class{};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -2961,7 +2961,7 @@ class UpdateStateResponse final : public StateResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 117;
   static constexpr uint8_t ESTIMATED_SIZE = 65;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "update_state_response"; }
+  const LogString *message_name() const override { return LOG_STR("update_state_response"); }
 #endif
   bool missing_state{false};
   bool in_progress{false};
@@ -2985,7 +2985,7 @@ class UpdateCommandRequest final : public CommandProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 118;
   static constexpr uint8_t ESTIMATED_SIZE = 11;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "update_command_request"; }
+  const LogString *message_name() const override { return LOG_STR("update_command_request"); }
 #endif
   enums::UpdateCommand command{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -3003,7 +3003,7 @@ class ZWaveProxyFrame final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 128;
   static constexpr uint8_t ESTIMATED_SIZE = 19;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "z_wave_proxy_frame"; }
+  const LogString *message_name() const override { return LOG_STR("z_wave_proxy_frame"); }
 #endif
   const uint8_t *data{nullptr};
   uint16_t data_len{0};
@@ -3021,7 +3021,7 @@ class ZWaveProxyRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 129;
   static constexpr uint8_t ESTIMATED_SIZE = 21;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "z_wave_proxy_request"; }
+  const LogString *message_name() const override { return LOG_STR("z_wave_proxy_request"); }
 #endif
   enums::ZWaveProxyRequestType type{};
   const uint8_t *data{nullptr};
@@ -3043,7 +3043,7 @@ class ListEntitiesInfraredResponse final : public InfoResponseProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 135;
   static constexpr uint8_t ESTIMATED_SIZE = 44;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "list_entities_infrared_response"; }
+  const LogString *message_name() const override { return LOG_STR("list_entities_infrared_response"); }
 #endif
   uint32_t capabilities{0};
   void encode(ProtoWriteBuffer &buffer) const;
@@ -3061,7 +3061,7 @@ class InfraredRFTransmitRawTimingsRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 136;
   static constexpr uint8_t ESTIMATED_SIZE = 220;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "infrared_rf_transmit_raw_timings_request"; }
+  const LogString *message_name() const override { return LOG_STR("infrared_rf_transmit_raw_timings_request"); }
 #endif
 #ifdef USE_DEVICES
   uint32_t device_id{0};
@@ -3086,7 +3086,7 @@ class InfraredRFReceiveEvent final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 137;
   static constexpr uint8_t ESTIMATED_SIZE = 17;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "infrared_rf_receive_event"; }
+  const LogString *message_name() const override { return LOG_STR("infrared_rf_receive_event"); }
 #endif
 #ifdef USE_DEVICES
   uint32_t device_id{0};
@@ -3108,7 +3108,7 @@ class SerialProxyConfigureRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 138;
   static constexpr uint8_t ESTIMATED_SIZE = 20;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_configure_request"; }
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_configure_request"); }
 #endif
   uint32_t instance{0};
   uint32_t baudrate{0};
@@ -3128,7 +3128,7 @@ class SerialProxyDataReceived final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 139;
   static constexpr uint8_t ESTIMATED_SIZE = 23;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_data_received"; }
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_data_received"); }
 #endif
   uint32_t instance{0};
   const uint8_t *data_ptr_{nullptr};
@@ -3150,7 +3150,7 @@ class SerialProxyWriteRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 140;
   static constexpr uint8_t ESTIMATED_SIZE = 23;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_write_request"; }
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_write_request"); }
 #endif
   uint32_t instance{0};
   const uint8_t *data{nullptr};
@@ -3168,7 +3168,7 @@ class SerialProxySetModemPinsRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 141;
   static constexpr uint8_t ESTIMATED_SIZE = 8;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_set_modem_pins_request"; }
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_set_modem_pins_request"); }
 #endif
   uint32_t instance{0};
   uint32_t line_states{0};
@@ -3184,7 +3184,7 @@ class SerialProxyGetModemPinsRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 142;
   static constexpr uint8_t ESTIMATED_SIZE = 4;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_get_modem_pins_request"; }
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_get_modem_pins_request"); }
 #endif
   uint32_t instance{0};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -3199,7 +3199,7 @@ class SerialProxyGetModemPinsResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 143;
   static constexpr uint8_t ESTIMATED_SIZE = 8;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_get_modem_pins_response"; }
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_get_modem_pins_response"); }
 #endif
   uint32_t instance{0};
   uint32_t line_states{0};
@@ -3216,7 +3216,7 @@ class SerialProxyRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 144;
   static constexpr uint8_t ESTIMATED_SIZE = 6;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_request"; }
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_request"); }
 #endif
   uint32_t instance{0};
   enums::SerialProxyRequestType type{};
@@ -3232,7 +3232,7 @@ class SerialProxyRequestResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 147;
   static constexpr uint8_t ESTIMATED_SIZE = 17;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_request_response"; }
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_request_response"); }
 #endif
   uint32_t instance{0};
   enums::SerialProxyRequestType type{};
@@ -3253,7 +3253,7 @@ class BluetoothSetConnectionParamsRequest final : public ProtoDecodableMessage {
   static constexpr uint8_t MESSAGE_TYPE = 145;
   static constexpr uint8_t ESTIMATED_SIZE = 20;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_set_connection_params_request"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_set_connection_params_request"); }
 #endif
   uint64_t address{0};
   uint32_t min_interval{0};
@@ -3272,7 +3272,7 @@ class BluetoothSetConnectionParamsResponse final : public ProtoMessage {
   static constexpr uint8_t MESSAGE_TYPE = 146;
   static constexpr uint8_t ESTIMATED_SIZE = 8;
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "bluetooth_set_connection_params_response"; }
+  const LogString *message_name() const override { return LOG_STR("bluetooth_set_connection_params_response"); }
 #endif
   uint64_t address{0};
   int32_t error{0};
diff --git a/esphome/components/api/api_pb2_dump.cpp b/esphome/components/api/api_pb2_dump.cpp
index 5a53f0281f..a11f3b231e 100644
--- a/esphome/components/api/api_pb2_dump.cpp
+++ b/esphome/components/api/api_pb2_dump.cpp
@@ -2,6 +2,7 @@
 // See script/api_protobuf/api_protobuf.py
 #include "api_pb2.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/progmem.h"
 
 #include <cinttypes>
 
@@ -9,6 +10,21 @@
 
 namespace esphome::api {
 
+#ifdef USE_ESP8266
+// Out-of-line to avoid inlining strlen_P/memcpy_P at every call site
+void DumpBuffer::append_p_esp8266(const char *str) {
+  size_t len = strlen_P(str);
+  size_t space = CAPACITY - 1 - pos_;
+  if (len > space)
+    len = space;
+  if (len > 0) {
+    memcpy_P(buf_ + pos_, str, len);
+    pos_ += len;
+    buf_[pos_] = '\0';
+  }
+}
+#endif
+
 // Helper function to append a quoted string, handling empty StringRef
 static inline void append_quoted_string(DumpBuffer &out, const StringRef &ref) {
   out.append("'");
@@ -19,8 +35,9 @@ static inline void append_quoted_string(DumpBuffer &out, const StringRef &ref) {
 }
 
 // Common helpers for dump_field functions
+// field_name is a PROGMEM pointer (flash on ESP8266, regular pointer on other platforms)
 static inline void append_field_prefix(DumpBuffer &out, const char *field_name, int indent) {
-  out.append(indent, ' ').append(field_name).append(": ");
+  out.append(indent, ' ').append_p(field_name).append(": ");
 }
 
 static inline void append_uint(DumpBuffer &out, uint32_t value) {
@@ -28,10 +45,11 @@ static inline void append_uint(DumpBuffer &out, uint32_t value) {
 }
 
 // RAII helper for message dump formatting
+// message_name is a PROGMEM pointer (flash on ESP8266, regular pointer on other platforms)
 class MessageDumpHelper {
  public:
   MessageDumpHelper(DumpBuffer &out, const char *message_name) : out_(out) {
-    out_.append(message_name);
+    out_.append_p(message_name);
     out_.append(" {\n");
   }
   ~MessageDumpHelper() { out_.append(" }"); }
@@ -41,6 +59,10 @@ class MessageDumpHelper {
 };
 
 // Helper functions to reduce code duplication in dump methods
+// field_name parameters are PROGMEM pointers (flash on ESP8266, regular pointers on other platforms)
+// Not all overloads are used in every build (depends on enabled components)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
 static void dump_field(DumpBuffer &out, const char *field_name, int32_t value, int indent = 2) {
   append_field_prefix(out, field_name, indent);
   out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRId32 "\n", value));
@@ -85,56 +107,59 @@ static void dump_field(DumpBuffer &out, const char *field_name, const char *valu
   out.append("\n");
 }
 
+// proto_enum_to_string returns PROGMEM pointers, so use append_p
 template<typename T> static void dump_field(DumpBuffer &out, const char *field_name, T value, int indent = 2) {
   append_field_prefix(out, field_name, indent);
-  out.append(proto_enum_to_string<T>(value));
+  out.append_p(proto_enum_to_string<T>(value));
   out.append("\n");
 }
 
 // Helper for bytes fields - uses stack buffer to avoid heap allocation
 // Buffer sized for 160 bytes of data (480 chars with separators) to fit typical log buffer
+// field_name is a PROGMEM pointer (flash on ESP8266, regular pointer on other platforms)
 static void dump_bytes_field(DumpBuffer &out, const char *field_name, const uint8_t *data, size_t len, int indent = 2) {
   char hex_buf[format_hex_pretty_size(160)];
   append_field_prefix(out, field_name, indent);
   format_hex_pretty_to(hex_buf, data, len);
   out.append(hex_buf).append("\n");
 }
+#pragma GCC diagnostic pop
 
 template<> const char *proto_enum_to_string<enums::SerialProxyPortType>(enums::SerialProxyPortType value) {
   switch (value) {
     case enums::SERIAL_PROXY_PORT_TYPE_TTL:
-      return "SERIAL_PROXY_PORT_TYPE_TTL";
+      return ESPHOME_PSTR("SERIAL_PROXY_PORT_TYPE_TTL");
     case enums::SERIAL_PROXY_PORT_TYPE_RS232:
-      return "SERIAL_PROXY_PORT_TYPE_RS232";
+      return ESPHOME_PSTR("SERIAL_PROXY_PORT_TYPE_RS232");
     case enums::SERIAL_PROXY_PORT_TYPE_RS485:
-      return "SERIAL_PROXY_PORT_TYPE_RS485";
+      return ESPHOME_PSTR("SERIAL_PROXY_PORT_TYPE_RS485");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::EntityCategory>(enums::EntityCategory value) {
   switch (value) {
     case enums::ENTITY_CATEGORY_NONE:
-      return "ENTITY_CATEGORY_NONE";
+      return ESPHOME_PSTR("ENTITY_CATEGORY_NONE");
     case enums::ENTITY_CATEGORY_CONFIG:
-      return "ENTITY_CATEGORY_CONFIG";
+      return ESPHOME_PSTR("ENTITY_CATEGORY_CONFIG");
     case enums::ENTITY_CATEGORY_DIAGNOSTIC:
-      return "ENTITY_CATEGORY_DIAGNOSTIC";
+      return ESPHOME_PSTR("ENTITY_CATEGORY_DIAGNOSTIC");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #ifdef USE_COVER
 template<> const char *proto_enum_to_string<enums::CoverOperation>(enums::CoverOperation value) {
   switch (value) {
     case enums::COVER_OPERATION_IDLE:
-      return "COVER_OPERATION_IDLE";
+      return ESPHOME_PSTR("COVER_OPERATION_IDLE");
     case enums::COVER_OPERATION_IS_OPENING:
-      return "COVER_OPERATION_IS_OPENING";
+      return ESPHOME_PSTR("COVER_OPERATION_IS_OPENING");
     case enums::COVER_OPERATION_IS_CLOSING:
-      return "COVER_OPERATION_IS_CLOSING";
+      return ESPHOME_PSTR("COVER_OPERATION_IS_CLOSING");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -142,11 +167,11 @@ template<> const char *proto_enum_to_string<enums::CoverOperation>(enums::CoverO
 template<> const char *proto_enum_to_string<enums::FanDirection>(enums::FanDirection value) {
   switch (value) {
     case enums::FAN_DIRECTION_FORWARD:
-      return "FAN_DIRECTION_FORWARD";
+      return ESPHOME_PSTR("FAN_DIRECTION_FORWARD");
     case enums::FAN_DIRECTION_REVERSE:
-      return "FAN_DIRECTION_REVERSE";
+      return ESPHOME_PSTR("FAN_DIRECTION_REVERSE");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -154,29 +179,29 @@ template<> const char *proto_enum_to_string<enums::FanDirection>(enums::FanDirec
 template<> const char *proto_enum_to_string<enums::ColorMode>(enums::ColorMode value) {
   switch (value) {
     case enums::COLOR_MODE_UNKNOWN:
-      return "COLOR_MODE_UNKNOWN";
+      return ESPHOME_PSTR("COLOR_MODE_UNKNOWN");
     case enums::COLOR_MODE_ON_OFF:
-      return "COLOR_MODE_ON_OFF";
+      return ESPHOME_PSTR("COLOR_MODE_ON_OFF");
     case enums::COLOR_MODE_LEGACY_BRIGHTNESS:
-      return "COLOR_MODE_LEGACY_BRIGHTNESS";
+      return ESPHOME_PSTR("COLOR_MODE_LEGACY_BRIGHTNESS");
     case enums::COLOR_MODE_BRIGHTNESS:
-      return "COLOR_MODE_BRIGHTNESS";
+      return ESPHOME_PSTR("COLOR_MODE_BRIGHTNESS");
     case enums::COLOR_MODE_WHITE:
-      return "COLOR_MODE_WHITE";
+      return ESPHOME_PSTR("COLOR_MODE_WHITE");
     case enums::COLOR_MODE_COLOR_TEMPERATURE:
-      return "COLOR_MODE_COLOR_TEMPERATURE";
+      return ESPHOME_PSTR("COLOR_MODE_COLOR_TEMPERATURE");
     case enums::COLOR_MODE_COLD_WARM_WHITE:
-      return "COLOR_MODE_COLD_WARM_WHITE";
+      return ESPHOME_PSTR("COLOR_MODE_COLD_WARM_WHITE");
     case enums::COLOR_MODE_RGB:
-      return "COLOR_MODE_RGB";
+      return ESPHOME_PSTR("COLOR_MODE_RGB");
     case enums::COLOR_MODE_RGB_WHITE:
-      return "COLOR_MODE_RGB_WHITE";
+      return ESPHOME_PSTR("COLOR_MODE_RGB_WHITE");
     case enums::COLOR_MODE_RGB_COLOR_TEMPERATURE:
-      return "COLOR_MODE_RGB_COLOR_TEMPERATURE";
+      return ESPHOME_PSTR("COLOR_MODE_RGB_COLOR_TEMPERATURE");
     case enums::COLOR_MODE_RGB_COLD_WARM_WHITE:
-      return "COLOR_MODE_RGB_COLD_WARM_WHITE";
+      return ESPHOME_PSTR("COLOR_MODE_RGB_COLD_WARM_WHITE");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -184,91 +209,91 @@ template<> const char *proto_enum_to_string<enums::ColorMode>(enums::ColorMode v
 template<> const char *proto_enum_to_string<enums::SensorStateClass>(enums::SensorStateClass value) {
   switch (value) {
     case enums::STATE_CLASS_NONE:
-      return "STATE_CLASS_NONE";
+      return ESPHOME_PSTR("STATE_CLASS_NONE");
     case enums::STATE_CLASS_MEASUREMENT:
-      return "STATE_CLASS_MEASUREMENT";
+      return ESPHOME_PSTR("STATE_CLASS_MEASUREMENT");
     case enums::STATE_CLASS_TOTAL_INCREASING:
-      return "STATE_CLASS_TOTAL_INCREASING";
+      return ESPHOME_PSTR("STATE_CLASS_TOTAL_INCREASING");
     case enums::STATE_CLASS_TOTAL:
-      return "STATE_CLASS_TOTAL";
+      return ESPHOME_PSTR("STATE_CLASS_TOTAL");
     case enums::STATE_CLASS_MEASUREMENT_ANGLE:
-      return "STATE_CLASS_MEASUREMENT_ANGLE";
+      return ESPHOME_PSTR("STATE_CLASS_MEASUREMENT_ANGLE");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
 template<> const char *proto_enum_to_string<enums::LogLevel>(enums::LogLevel value) {
   switch (value) {
     case enums::LOG_LEVEL_NONE:
-      return "LOG_LEVEL_NONE";
+      return ESPHOME_PSTR("LOG_LEVEL_NONE");
     case enums::LOG_LEVEL_ERROR:
-      return "LOG_LEVEL_ERROR";
+      return ESPHOME_PSTR("LOG_LEVEL_ERROR");
     case enums::LOG_LEVEL_WARN:
-      return "LOG_LEVEL_WARN";
+      return ESPHOME_PSTR("LOG_LEVEL_WARN");
     case enums::LOG_LEVEL_INFO:
-      return "LOG_LEVEL_INFO";
+      return ESPHOME_PSTR("LOG_LEVEL_INFO");
     case enums::LOG_LEVEL_CONFIG:
-      return "LOG_LEVEL_CONFIG";
+      return ESPHOME_PSTR("LOG_LEVEL_CONFIG");
     case enums::LOG_LEVEL_DEBUG:
-      return "LOG_LEVEL_DEBUG";
+      return ESPHOME_PSTR("LOG_LEVEL_DEBUG");
     case enums::LOG_LEVEL_VERBOSE:
-      return "LOG_LEVEL_VERBOSE";
+      return ESPHOME_PSTR("LOG_LEVEL_VERBOSE");
     case enums::LOG_LEVEL_VERY_VERBOSE:
-      return "LOG_LEVEL_VERY_VERBOSE";
+      return ESPHOME_PSTR("LOG_LEVEL_VERY_VERBOSE");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::DSTRuleType>(enums::DSTRuleType value) {
   switch (value) {
     case enums::DST_RULE_TYPE_NONE:
-      return "DST_RULE_TYPE_NONE";
+      return ESPHOME_PSTR("DST_RULE_TYPE_NONE");
     case enums::DST_RULE_TYPE_MONTH_WEEK_DAY:
-      return "DST_RULE_TYPE_MONTH_WEEK_DAY";
+      return ESPHOME_PSTR("DST_RULE_TYPE_MONTH_WEEK_DAY");
     case enums::DST_RULE_TYPE_JULIAN_NO_LEAP:
-      return "DST_RULE_TYPE_JULIAN_NO_LEAP";
+      return ESPHOME_PSTR("DST_RULE_TYPE_JULIAN_NO_LEAP");
     case enums::DST_RULE_TYPE_DAY_OF_YEAR:
-      return "DST_RULE_TYPE_DAY_OF_YEAR";
+      return ESPHOME_PSTR("DST_RULE_TYPE_DAY_OF_YEAR");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #ifdef USE_API_USER_DEFINED_ACTIONS
 template<> const char *proto_enum_to_string<enums::ServiceArgType>(enums::ServiceArgType value) {
   switch (value) {
     case enums::SERVICE_ARG_TYPE_BOOL:
-      return "SERVICE_ARG_TYPE_BOOL";
+      return ESPHOME_PSTR("SERVICE_ARG_TYPE_BOOL");
     case enums::SERVICE_ARG_TYPE_INT:
-      return "SERVICE_ARG_TYPE_INT";
+      return ESPHOME_PSTR("SERVICE_ARG_TYPE_INT");
     case enums::SERVICE_ARG_TYPE_FLOAT:
-      return "SERVICE_ARG_TYPE_FLOAT";
+      return ESPHOME_PSTR("SERVICE_ARG_TYPE_FLOAT");
     case enums::SERVICE_ARG_TYPE_STRING:
-      return "SERVICE_ARG_TYPE_STRING";
+      return ESPHOME_PSTR("SERVICE_ARG_TYPE_STRING");
     case enums::SERVICE_ARG_TYPE_BOOL_ARRAY:
-      return "SERVICE_ARG_TYPE_BOOL_ARRAY";
+      return ESPHOME_PSTR("SERVICE_ARG_TYPE_BOOL_ARRAY");
     case enums::SERVICE_ARG_TYPE_INT_ARRAY:
-      return "SERVICE_ARG_TYPE_INT_ARRAY";
+      return ESPHOME_PSTR("SERVICE_ARG_TYPE_INT_ARRAY");
     case enums::SERVICE_ARG_TYPE_FLOAT_ARRAY:
-      return "SERVICE_ARG_TYPE_FLOAT_ARRAY";
+      return ESPHOME_PSTR("SERVICE_ARG_TYPE_FLOAT_ARRAY");
     case enums::SERVICE_ARG_TYPE_STRING_ARRAY:
-      return "SERVICE_ARG_TYPE_STRING_ARRAY";
+      return ESPHOME_PSTR("SERVICE_ARG_TYPE_STRING_ARRAY");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::SupportsResponseType>(enums::SupportsResponseType value) {
   switch (value) {
     case enums::SUPPORTS_RESPONSE_NONE:
-      return "SUPPORTS_RESPONSE_NONE";
+      return ESPHOME_PSTR("SUPPORTS_RESPONSE_NONE");
     case enums::SUPPORTS_RESPONSE_OPTIONAL:
-      return "SUPPORTS_RESPONSE_OPTIONAL";
+      return ESPHOME_PSTR("SUPPORTS_RESPONSE_OPTIONAL");
     case enums::SUPPORTS_RESPONSE_ONLY:
-      return "SUPPORTS_RESPONSE_ONLY";
+      return ESPHOME_PSTR("SUPPORTS_RESPONSE_ONLY");
     case enums::SUPPORTS_RESPONSE_STATUS:
-      return "SUPPORTS_RESPONSE_STATUS";
+      return ESPHOME_PSTR("SUPPORTS_RESPONSE_STATUS");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -276,103 +301,103 @@ template<> const char *proto_enum_to_string<enums::SupportsResponseType>(enums::
 template<> const char *proto_enum_to_string<enums::ClimateMode>(enums::ClimateMode value) {
   switch (value) {
     case enums::CLIMATE_MODE_OFF:
-      return "CLIMATE_MODE_OFF";
+      return ESPHOME_PSTR("CLIMATE_MODE_OFF");
     case enums::CLIMATE_MODE_HEAT_COOL:
-      return "CLIMATE_MODE_HEAT_COOL";
+      return ESPHOME_PSTR("CLIMATE_MODE_HEAT_COOL");
     case enums::CLIMATE_MODE_COOL:
-      return "CLIMATE_MODE_COOL";
+      return ESPHOME_PSTR("CLIMATE_MODE_COOL");
     case enums::CLIMATE_MODE_HEAT:
-      return "CLIMATE_MODE_HEAT";
+      return ESPHOME_PSTR("CLIMATE_MODE_HEAT");
     case enums::CLIMATE_MODE_FAN_ONLY:
-      return "CLIMATE_MODE_FAN_ONLY";
+      return ESPHOME_PSTR("CLIMATE_MODE_FAN_ONLY");
     case enums::CLIMATE_MODE_DRY:
-      return "CLIMATE_MODE_DRY";
+      return ESPHOME_PSTR("CLIMATE_MODE_DRY");
     case enums::CLIMATE_MODE_AUTO:
-      return "CLIMATE_MODE_AUTO";
+      return ESPHOME_PSTR("CLIMATE_MODE_AUTO");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::ClimateFanMode>(enums::ClimateFanMode value) {
   switch (value) {
     case enums::CLIMATE_FAN_ON:
-      return "CLIMATE_FAN_ON";
+      return ESPHOME_PSTR("CLIMATE_FAN_ON");
     case enums::CLIMATE_FAN_OFF:
-      return "CLIMATE_FAN_OFF";
+      return ESPHOME_PSTR("CLIMATE_FAN_OFF");
     case enums::CLIMATE_FAN_AUTO:
-      return "CLIMATE_FAN_AUTO";
+      return ESPHOME_PSTR("CLIMATE_FAN_AUTO");
     case enums::CLIMATE_FAN_LOW:
-      return "CLIMATE_FAN_LOW";
+      return ESPHOME_PSTR("CLIMATE_FAN_LOW");
     case enums::CLIMATE_FAN_MEDIUM:
-      return "CLIMATE_FAN_MEDIUM";
+      return ESPHOME_PSTR("CLIMATE_FAN_MEDIUM");
     case enums::CLIMATE_FAN_HIGH:
-      return "CLIMATE_FAN_HIGH";
+      return ESPHOME_PSTR("CLIMATE_FAN_HIGH");
     case enums::CLIMATE_FAN_MIDDLE:
-      return "CLIMATE_FAN_MIDDLE";
+      return ESPHOME_PSTR("CLIMATE_FAN_MIDDLE");
     case enums::CLIMATE_FAN_FOCUS:
-      return "CLIMATE_FAN_FOCUS";
+      return ESPHOME_PSTR("CLIMATE_FAN_FOCUS");
     case enums::CLIMATE_FAN_DIFFUSE:
-      return "CLIMATE_FAN_DIFFUSE";
+      return ESPHOME_PSTR("CLIMATE_FAN_DIFFUSE");
     case enums::CLIMATE_FAN_QUIET:
-      return "CLIMATE_FAN_QUIET";
+      return ESPHOME_PSTR("CLIMATE_FAN_QUIET");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::ClimateSwingMode>(enums::ClimateSwingMode value) {
   switch (value) {
     case enums::CLIMATE_SWING_OFF:
-      return "CLIMATE_SWING_OFF";
+      return ESPHOME_PSTR("CLIMATE_SWING_OFF");
     case enums::CLIMATE_SWING_BOTH:
-      return "CLIMATE_SWING_BOTH";
+      return ESPHOME_PSTR("CLIMATE_SWING_BOTH");
     case enums::CLIMATE_SWING_VERTICAL:
-      return "CLIMATE_SWING_VERTICAL";
+      return ESPHOME_PSTR("CLIMATE_SWING_VERTICAL");
     case enums::CLIMATE_SWING_HORIZONTAL:
-      return "CLIMATE_SWING_HORIZONTAL";
+      return ESPHOME_PSTR("CLIMATE_SWING_HORIZONTAL");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::ClimateAction>(enums::ClimateAction value) {
   switch (value) {
     case enums::CLIMATE_ACTION_OFF:
-      return "CLIMATE_ACTION_OFF";
+      return ESPHOME_PSTR("CLIMATE_ACTION_OFF");
     case enums::CLIMATE_ACTION_COOLING:
-      return "CLIMATE_ACTION_COOLING";
+      return ESPHOME_PSTR("CLIMATE_ACTION_COOLING");
     case enums::CLIMATE_ACTION_HEATING:
-      return "CLIMATE_ACTION_HEATING";
+      return ESPHOME_PSTR("CLIMATE_ACTION_HEATING");
     case enums::CLIMATE_ACTION_IDLE:
-      return "CLIMATE_ACTION_IDLE";
+      return ESPHOME_PSTR("CLIMATE_ACTION_IDLE");
     case enums::CLIMATE_ACTION_DRYING:
-      return "CLIMATE_ACTION_DRYING";
+      return ESPHOME_PSTR("CLIMATE_ACTION_DRYING");
     case enums::CLIMATE_ACTION_FAN:
-      return "CLIMATE_ACTION_FAN";
+      return ESPHOME_PSTR("CLIMATE_ACTION_FAN");
     case enums::CLIMATE_ACTION_DEFROSTING:
-      return "CLIMATE_ACTION_DEFROSTING";
+      return ESPHOME_PSTR("CLIMATE_ACTION_DEFROSTING");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::ClimatePreset>(enums::ClimatePreset value) {
   switch (value) {
     case enums::CLIMATE_PRESET_NONE:
-      return "CLIMATE_PRESET_NONE";
+      return ESPHOME_PSTR("CLIMATE_PRESET_NONE");
     case enums::CLIMATE_PRESET_HOME:
-      return "CLIMATE_PRESET_HOME";
+      return ESPHOME_PSTR("CLIMATE_PRESET_HOME");
     case enums::CLIMATE_PRESET_AWAY:
-      return "CLIMATE_PRESET_AWAY";
+      return ESPHOME_PSTR("CLIMATE_PRESET_AWAY");
     case enums::CLIMATE_PRESET_BOOST:
-      return "CLIMATE_PRESET_BOOST";
+      return ESPHOME_PSTR("CLIMATE_PRESET_BOOST");
     case enums::CLIMATE_PRESET_COMFORT:
-      return "CLIMATE_PRESET_COMFORT";
+      return ESPHOME_PSTR("CLIMATE_PRESET_COMFORT");
     case enums::CLIMATE_PRESET_ECO:
-      return "CLIMATE_PRESET_ECO";
+      return ESPHOME_PSTR("CLIMATE_PRESET_ECO");
     case enums::CLIMATE_PRESET_SLEEP:
-      return "CLIMATE_PRESET_SLEEP";
+      return ESPHOME_PSTR("CLIMATE_PRESET_SLEEP");
     case enums::CLIMATE_PRESET_ACTIVITY:
-      return "CLIMATE_PRESET_ACTIVITY";
+      return ESPHOME_PSTR("CLIMATE_PRESET_ACTIVITY");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -380,21 +405,21 @@ template<> const char *proto_enum_to_string<enums::ClimatePreset>(enums::Climate
 template<> const char *proto_enum_to_string<enums::WaterHeaterMode>(enums::WaterHeaterMode value) {
   switch (value) {
     case enums::WATER_HEATER_MODE_OFF:
-      return "WATER_HEATER_MODE_OFF";
+      return ESPHOME_PSTR("WATER_HEATER_MODE_OFF");
     case enums::WATER_HEATER_MODE_ECO:
-      return "WATER_HEATER_MODE_ECO";
+      return ESPHOME_PSTR("WATER_HEATER_MODE_ECO");
     case enums::WATER_HEATER_MODE_ELECTRIC:
-      return "WATER_HEATER_MODE_ELECTRIC";
+      return ESPHOME_PSTR("WATER_HEATER_MODE_ELECTRIC");
     case enums::WATER_HEATER_MODE_PERFORMANCE:
-      return "WATER_HEATER_MODE_PERFORMANCE";
+      return ESPHOME_PSTR("WATER_HEATER_MODE_PERFORMANCE");
     case enums::WATER_HEATER_MODE_HIGH_DEMAND:
-      return "WATER_HEATER_MODE_HIGH_DEMAND";
+      return ESPHOME_PSTR("WATER_HEATER_MODE_HIGH_DEMAND");
     case enums::WATER_HEATER_MODE_HEAT_PUMP:
-      return "WATER_HEATER_MODE_HEAT_PUMP";
+      return ESPHOME_PSTR("WATER_HEATER_MODE_HEAT_PUMP");
     case enums::WATER_HEATER_MODE_GAS:
-      return "WATER_HEATER_MODE_GAS";
+      return ESPHOME_PSTR("WATER_HEATER_MODE_GAS");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -402,36 +427,36 @@ template<>
 const char *proto_enum_to_string<enums::WaterHeaterCommandHasField>(enums::WaterHeaterCommandHasField value) {
   switch (value) {
     case enums::WATER_HEATER_COMMAND_HAS_NONE:
-      return "WATER_HEATER_COMMAND_HAS_NONE";
+      return ESPHOME_PSTR("WATER_HEATER_COMMAND_HAS_NONE");
     case enums::WATER_HEATER_COMMAND_HAS_MODE:
-      return "WATER_HEATER_COMMAND_HAS_MODE";
+      return ESPHOME_PSTR("WATER_HEATER_COMMAND_HAS_MODE");
     case enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE:
-      return "WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE";
+      return ESPHOME_PSTR("WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE");
     case enums::WATER_HEATER_COMMAND_HAS_STATE:
-      return "WATER_HEATER_COMMAND_HAS_STATE";
+      return ESPHOME_PSTR("WATER_HEATER_COMMAND_HAS_STATE");
     case enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW:
-      return "WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW";
+      return ESPHOME_PSTR("WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW");
     case enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH:
-      return "WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH";
+      return ESPHOME_PSTR("WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH");
     case enums::WATER_HEATER_COMMAND_HAS_ON_STATE:
-      return "WATER_HEATER_COMMAND_HAS_ON_STATE";
+      return ESPHOME_PSTR("WATER_HEATER_COMMAND_HAS_ON_STATE");
     case enums::WATER_HEATER_COMMAND_HAS_AWAY_STATE:
-      return "WATER_HEATER_COMMAND_HAS_AWAY_STATE";
+      return ESPHOME_PSTR("WATER_HEATER_COMMAND_HAS_AWAY_STATE");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #ifdef USE_NUMBER
 template<> const char *proto_enum_to_string<enums::NumberMode>(enums::NumberMode value) {
   switch (value) {
     case enums::NUMBER_MODE_AUTO:
-      return "NUMBER_MODE_AUTO";
+      return ESPHOME_PSTR("NUMBER_MODE_AUTO");
     case enums::NUMBER_MODE_BOX:
-      return "NUMBER_MODE_BOX";
+      return ESPHOME_PSTR("NUMBER_MODE_BOX");
     case enums::NUMBER_MODE_SLIDER:
-      return "NUMBER_MODE_SLIDER";
+      return ESPHOME_PSTR("NUMBER_MODE_SLIDER");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -439,31 +464,31 @@ template<> const char *proto_enum_to_string<enums::NumberMode>(enums::NumberMode
 template<> const char *proto_enum_to_string<enums::LockState>(enums::LockState value) {
   switch (value) {
     case enums::LOCK_STATE_NONE:
-      return "LOCK_STATE_NONE";
+      return ESPHOME_PSTR("LOCK_STATE_NONE");
     case enums::LOCK_STATE_LOCKED:
-      return "LOCK_STATE_LOCKED";
+      return ESPHOME_PSTR("LOCK_STATE_LOCKED");
     case enums::LOCK_STATE_UNLOCKED:
-      return "LOCK_STATE_UNLOCKED";
+      return ESPHOME_PSTR("LOCK_STATE_UNLOCKED");
     case enums::LOCK_STATE_JAMMED:
-      return "LOCK_STATE_JAMMED";
+      return ESPHOME_PSTR("LOCK_STATE_JAMMED");
     case enums::LOCK_STATE_LOCKING:
-      return "LOCK_STATE_LOCKING";
+      return ESPHOME_PSTR("LOCK_STATE_LOCKING");
     case enums::LOCK_STATE_UNLOCKING:
-      return "LOCK_STATE_UNLOCKING";
+      return ESPHOME_PSTR("LOCK_STATE_UNLOCKING");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::LockCommand>(enums::LockCommand value) {
   switch (value) {
     case enums::LOCK_UNLOCK:
-      return "LOCK_UNLOCK";
+      return ESPHOME_PSTR("LOCK_UNLOCK");
     case enums::LOCK_LOCK:
-      return "LOCK_LOCK";
+      return ESPHOME_PSTR("LOCK_LOCK");
     case enums::LOCK_OPEN:
-      return "LOCK_OPEN";
+      return ESPHOME_PSTR("LOCK_OPEN");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -471,65 +496,65 @@ template<> const char *proto_enum_to_string<enums::LockCommand>(enums::LockComma
 template<> const char *proto_enum_to_string<enums::MediaPlayerState>(enums::MediaPlayerState value) {
   switch (value) {
     case enums::MEDIA_PLAYER_STATE_NONE:
-      return "MEDIA_PLAYER_STATE_NONE";
+      return ESPHOME_PSTR("MEDIA_PLAYER_STATE_NONE");
     case enums::MEDIA_PLAYER_STATE_IDLE:
-      return "MEDIA_PLAYER_STATE_IDLE";
+      return ESPHOME_PSTR("MEDIA_PLAYER_STATE_IDLE");
     case enums::MEDIA_PLAYER_STATE_PLAYING:
-      return "MEDIA_PLAYER_STATE_PLAYING";
+      return ESPHOME_PSTR("MEDIA_PLAYER_STATE_PLAYING");
     case enums::MEDIA_PLAYER_STATE_PAUSED:
-      return "MEDIA_PLAYER_STATE_PAUSED";
+      return ESPHOME_PSTR("MEDIA_PLAYER_STATE_PAUSED");
     case enums::MEDIA_PLAYER_STATE_ANNOUNCING:
-      return "MEDIA_PLAYER_STATE_ANNOUNCING";
+      return ESPHOME_PSTR("MEDIA_PLAYER_STATE_ANNOUNCING");
     case enums::MEDIA_PLAYER_STATE_OFF:
-      return "MEDIA_PLAYER_STATE_OFF";
+      return ESPHOME_PSTR("MEDIA_PLAYER_STATE_OFF");
     case enums::MEDIA_PLAYER_STATE_ON:
-      return "MEDIA_PLAYER_STATE_ON";
+      return ESPHOME_PSTR("MEDIA_PLAYER_STATE_ON");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::MediaPlayerCommand>(enums::MediaPlayerCommand value) {
   switch (value) {
     case enums::MEDIA_PLAYER_COMMAND_PLAY:
-      return "MEDIA_PLAYER_COMMAND_PLAY";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_PLAY");
     case enums::MEDIA_PLAYER_COMMAND_PAUSE:
-      return "MEDIA_PLAYER_COMMAND_PAUSE";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_PAUSE");
     case enums::MEDIA_PLAYER_COMMAND_STOP:
-      return "MEDIA_PLAYER_COMMAND_STOP";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_STOP");
     case enums::MEDIA_PLAYER_COMMAND_MUTE:
-      return "MEDIA_PLAYER_COMMAND_MUTE";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_MUTE");
     case enums::MEDIA_PLAYER_COMMAND_UNMUTE:
-      return "MEDIA_PLAYER_COMMAND_UNMUTE";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_UNMUTE");
     case enums::MEDIA_PLAYER_COMMAND_TOGGLE:
-      return "MEDIA_PLAYER_COMMAND_TOGGLE";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_TOGGLE");
     case enums::MEDIA_PLAYER_COMMAND_VOLUME_UP:
-      return "MEDIA_PLAYER_COMMAND_VOLUME_UP";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_VOLUME_UP");
     case enums::MEDIA_PLAYER_COMMAND_VOLUME_DOWN:
-      return "MEDIA_PLAYER_COMMAND_VOLUME_DOWN";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_VOLUME_DOWN");
     case enums::MEDIA_PLAYER_COMMAND_ENQUEUE:
-      return "MEDIA_PLAYER_COMMAND_ENQUEUE";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_ENQUEUE");
     case enums::MEDIA_PLAYER_COMMAND_REPEAT_ONE:
-      return "MEDIA_PLAYER_COMMAND_REPEAT_ONE";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_REPEAT_ONE");
     case enums::MEDIA_PLAYER_COMMAND_REPEAT_OFF:
-      return "MEDIA_PLAYER_COMMAND_REPEAT_OFF";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_REPEAT_OFF");
     case enums::MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST:
-      return "MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST");
     case enums::MEDIA_PLAYER_COMMAND_TURN_ON:
-      return "MEDIA_PLAYER_COMMAND_TURN_ON";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_TURN_ON");
     case enums::MEDIA_PLAYER_COMMAND_TURN_OFF:
-      return "MEDIA_PLAYER_COMMAND_TURN_OFF";
+      return ESPHOME_PSTR("MEDIA_PLAYER_COMMAND_TURN_OFF");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::MediaPlayerFormatPurpose>(enums::MediaPlayerFormatPurpose value) {
   switch (value) {
     case enums::MEDIA_PLAYER_FORMAT_PURPOSE_DEFAULT:
-      return "MEDIA_PLAYER_FORMAT_PURPOSE_DEFAULT";
+      return ESPHOME_PSTR("MEDIA_PLAYER_FORMAT_PURPOSE_DEFAULT");
     case enums::MEDIA_PLAYER_FORMAT_PURPOSE_ANNOUNCEMENT:
-      return "MEDIA_PLAYER_FORMAT_PURPOSE_ANNOUNCEMENT";
+      return ESPHOME_PSTR("MEDIA_PLAYER_FORMAT_PURPOSE_ANNOUNCEMENT");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -538,49 +563,49 @@ template<>
 const char *proto_enum_to_string<enums::BluetoothDeviceRequestType>(enums::BluetoothDeviceRequestType value) {
   switch (value) {
     case enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT:
-      return "BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT";
+      return ESPHOME_PSTR("BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT");
     case enums::BLUETOOTH_DEVICE_REQUEST_TYPE_DISCONNECT:
-      return "BLUETOOTH_DEVICE_REQUEST_TYPE_DISCONNECT";
+      return ESPHOME_PSTR("BLUETOOTH_DEVICE_REQUEST_TYPE_DISCONNECT");
     case enums::BLUETOOTH_DEVICE_REQUEST_TYPE_PAIR:
-      return "BLUETOOTH_DEVICE_REQUEST_TYPE_PAIR";
+      return ESPHOME_PSTR("BLUETOOTH_DEVICE_REQUEST_TYPE_PAIR");
     case enums::BLUETOOTH_DEVICE_REQUEST_TYPE_UNPAIR:
-      return "BLUETOOTH_DEVICE_REQUEST_TYPE_UNPAIR";
+      return ESPHOME_PSTR("BLUETOOTH_DEVICE_REQUEST_TYPE_UNPAIR");
     case enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITH_CACHE:
-      return "BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITH_CACHE";
+      return ESPHOME_PSTR("BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITH_CACHE");
     case enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITHOUT_CACHE:
-      return "BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITHOUT_CACHE";
+      return ESPHOME_PSTR("BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITHOUT_CACHE");
     case enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CLEAR_CACHE:
-      return "BLUETOOTH_DEVICE_REQUEST_TYPE_CLEAR_CACHE";
+      return ESPHOME_PSTR("BLUETOOTH_DEVICE_REQUEST_TYPE_CLEAR_CACHE");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::BluetoothScannerState>(enums::BluetoothScannerState value) {
   switch (value) {
     case enums::BLUETOOTH_SCANNER_STATE_IDLE:
-      return "BLUETOOTH_SCANNER_STATE_IDLE";
+      return ESPHOME_PSTR("BLUETOOTH_SCANNER_STATE_IDLE");
     case enums::BLUETOOTH_SCANNER_STATE_STARTING:
-      return "BLUETOOTH_SCANNER_STATE_STARTING";
+      return ESPHOME_PSTR("BLUETOOTH_SCANNER_STATE_STARTING");
     case enums::BLUETOOTH_SCANNER_STATE_RUNNING:
-      return "BLUETOOTH_SCANNER_STATE_RUNNING";
+      return ESPHOME_PSTR("BLUETOOTH_SCANNER_STATE_RUNNING");
     case enums::BLUETOOTH_SCANNER_STATE_FAILED:
-      return "BLUETOOTH_SCANNER_STATE_FAILED";
+      return ESPHOME_PSTR("BLUETOOTH_SCANNER_STATE_FAILED");
     case enums::BLUETOOTH_SCANNER_STATE_STOPPING:
-      return "BLUETOOTH_SCANNER_STATE_STOPPING";
+      return ESPHOME_PSTR("BLUETOOTH_SCANNER_STATE_STOPPING");
     case enums::BLUETOOTH_SCANNER_STATE_STOPPED:
-      return "BLUETOOTH_SCANNER_STATE_STOPPED";
+      return ESPHOME_PSTR("BLUETOOTH_SCANNER_STATE_STOPPED");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::BluetoothScannerMode>(enums::BluetoothScannerMode value) {
   switch (value) {
     case enums::BLUETOOTH_SCANNER_MODE_PASSIVE:
-      return "BLUETOOTH_SCANNER_MODE_PASSIVE";
+      return ESPHOME_PSTR("BLUETOOTH_SCANNER_MODE_PASSIVE");
     case enums::BLUETOOTH_SCANNER_MODE_ACTIVE:
-      return "BLUETOOTH_SCANNER_MODE_ACTIVE";
+      return ESPHOME_PSTR("BLUETOOTH_SCANNER_MODE_ACTIVE");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -588,76 +613,76 @@ template<>
 const char *proto_enum_to_string<enums::VoiceAssistantSubscribeFlag>(enums::VoiceAssistantSubscribeFlag value) {
   switch (value) {
     case enums::VOICE_ASSISTANT_SUBSCRIBE_NONE:
-      return "VOICE_ASSISTANT_SUBSCRIBE_NONE";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_SUBSCRIBE_NONE");
     case enums::VOICE_ASSISTANT_SUBSCRIBE_API_AUDIO:
-      return "VOICE_ASSISTANT_SUBSCRIBE_API_AUDIO";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_SUBSCRIBE_API_AUDIO");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::VoiceAssistantRequestFlag>(enums::VoiceAssistantRequestFlag value) {
   switch (value) {
     case enums::VOICE_ASSISTANT_REQUEST_NONE:
-      return "VOICE_ASSISTANT_REQUEST_NONE";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_REQUEST_NONE");
     case enums::VOICE_ASSISTANT_REQUEST_USE_VAD:
-      return "VOICE_ASSISTANT_REQUEST_USE_VAD";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_REQUEST_USE_VAD");
     case enums::VOICE_ASSISTANT_REQUEST_USE_WAKE_WORD:
-      return "VOICE_ASSISTANT_REQUEST_USE_WAKE_WORD";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_REQUEST_USE_WAKE_WORD");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #ifdef USE_VOICE_ASSISTANT
 template<> const char *proto_enum_to_string<enums::VoiceAssistantEvent>(enums::VoiceAssistantEvent value) {
   switch (value) {
     case enums::VOICE_ASSISTANT_ERROR:
-      return "VOICE_ASSISTANT_ERROR";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_ERROR");
     case enums::VOICE_ASSISTANT_RUN_START:
-      return "VOICE_ASSISTANT_RUN_START";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_RUN_START");
     case enums::VOICE_ASSISTANT_RUN_END:
-      return "VOICE_ASSISTANT_RUN_END";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_RUN_END");
     case enums::VOICE_ASSISTANT_STT_START:
-      return "VOICE_ASSISTANT_STT_START";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_STT_START");
     case enums::VOICE_ASSISTANT_STT_END:
-      return "VOICE_ASSISTANT_STT_END";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_STT_END");
     case enums::VOICE_ASSISTANT_INTENT_START:
-      return "VOICE_ASSISTANT_INTENT_START";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_INTENT_START");
     case enums::VOICE_ASSISTANT_INTENT_END:
-      return "VOICE_ASSISTANT_INTENT_END";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_INTENT_END");
     case enums::VOICE_ASSISTANT_TTS_START:
-      return "VOICE_ASSISTANT_TTS_START";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_TTS_START");
     case enums::VOICE_ASSISTANT_TTS_END:
-      return "VOICE_ASSISTANT_TTS_END";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_TTS_END");
     case enums::VOICE_ASSISTANT_WAKE_WORD_START:
-      return "VOICE_ASSISTANT_WAKE_WORD_START";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_WAKE_WORD_START");
     case enums::VOICE_ASSISTANT_WAKE_WORD_END:
-      return "VOICE_ASSISTANT_WAKE_WORD_END";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_WAKE_WORD_END");
     case enums::VOICE_ASSISTANT_STT_VAD_START:
-      return "VOICE_ASSISTANT_STT_VAD_START";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_STT_VAD_START");
     case enums::VOICE_ASSISTANT_STT_VAD_END:
-      return "VOICE_ASSISTANT_STT_VAD_END";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_STT_VAD_END");
     case enums::VOICE_ASSISTANT_TTS_STREAM_START:
-      return "VOICE_ASSISTANT_TTS_STREAM_START";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_TTS_STREAM_START");
     case enums::VOICE_ASSISTANT_TTS_STREAM_END:
-      return "VOICE_ASSISTANT_TTS_STREAM_END";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_TTS_STREAM_END");
     case enums::VOICE_ASSISTANT_INTENT_PROGRESS:
-      return "VOICE_ASSISTANT_INTENT_PROGRESS";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_INTENT_PROGRESS");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::VoiceAssistantTimerEvent>(enums::VoiceAssistantTimerEvent value) {
   switch (value) {
     case enums::VOICE_ASSISTANT_TIMER_STARTED:
-      return "VOICE_ASSISTANT_TIMER_STARTED";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_TIMER_STARTED");
     case enums::VOICE_ASSISTANT_TIMER_UPDATED:
-      return "VOICE_ASSISTANT_TIMER_UPDATED";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_TIMER_UPDATED");
     case enums::VOICE_ASSISTANT_TIMER_CANCELLED:
-      return "VOICE_ASSISTANT_TIMER_CANCELLED";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_TIMER_CANCELLED");
     case enums::VOICE_ASSISTANT_TIMER_FINISHED:
-      return "VOICE_ASSISTANT_TIMER_FINISHED";
+      return ESPHOME_PSTR("VOICE_ASSISTANT_TIMER_FINISHED");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -665,48 +690,48 @@ template<> const char *proto_enum_to_string<enums::VoiceAssistantTimerEvent>(enu
 template<> const char *proto_enum_to_string<enums::AlarmControlPanelState>(enums::AlarmControlPanelState value) {
   switch (value) {
     case enums::ALARM_STATE_DISARMED:
-      return "ALARM_STATE_DISARMED";
+      return ESPHOME_PSTR("ALARM_STATE_DISARMED");
     case enums::ALARM_STATE_ARMED_HOME:
-      return "ALARM_STATE_ARMED_HOME";
+      return ESPHOME_PSTR("ALARM_STATE_ARMED_HOME");
     case enums::ALARM_STATE_ARMED_AWAY:
-      return "ALARM_STATE_ARMED_AWAY";
+      return ESPHOME_PSTR("ALARM_STATE_ARMED_AWAY");
     case enums::ALARM_STATE_ARMED_NIGHT:
-      return "ALARM_STATE_ARMED_NIGHT";
+      return ESPHOME_PSTR("ALARM_STATE_ARMED_NIGHT");
     case enums::ALARM_STATE_ARMED_VACATION:
-      return "ALARM_STATE_ARMED_VACATION";
+      return ESPHOME_PSTR("ALARM_STATE_ARMED_VACATION");
     case enums::ALARM_STATE_ARMED_CUSTOM_BYPASS:
-      return "ALARM_STATE_ARMED_CUSTOM_BYPASS";
+      return ESPHOME_PSTR("ALARM_STATE_ARMED_CUSTOM_BYPASS");
     case enums::ALARM_STATE_PENDING:
-      return "ALARM_STATE_PENDING";
+      return ESPHOME_PSTR("ALARM_STATE_PENDING");
     case enums::ALARM_STATE_ARMING:
-      return "ALARM_STATE_ARMING";
+      return ESPHOME_PSTR("ALARM_STATE_ARMING");
     case enums::ALARM_STATE_DISARMING:
-      return "ALARM_STATE_DISARMING";
+      return ESPHOME_PSTR("ALARM_STATE_DISARMING");
     case enums::ALARM_STATE_TRIGGERED:
-      return "ALARM_STATE_TRIGGERED";
+      return ESPHOME_PSTR("ALARM_STATE_TRIGGERED");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<>
 const char *proto_enum_to_string<enums::AlarmControlPanelStateCommand>(enums::AlarmControlPanelStateCommand value) {
   switch (value) {
     case enums::ALARM_CONTROL_PANEL_DISARM:
-      return "ALARM_CONTROL_PANEL_DISARM";
+      return ESPHOME_PSTR("ALARM_CONTROL_PANEL_DISARM");
     case enums::ALARM_CONTROL_PANEL_ARM_AWAY:
-      return "ALARM_CONTROL_PANEL_ARM_AWAY";
+      return ESPHOME_PSTR("ALARM_CONTROL_PANEL_ARM_AWAY");
     case enums::ALARM_CONTROL_PANEL_ARM_HOME:
-      return "ALARM_CONTROL_PANEL_ARM_HOME";
+      return ESPHOME_PSTR("ALARM_CONTROL_PANEL_ARM_HOME");
     case enums::ALARM_CONTROL_PANEL_ARM_NIGHT:
-      return "ALARM_CONTROL_PANEL_ARM_NIGHT";
+      return ESPHOME_PSTR("ALARM_CONTROL_PANEL_ARM_NIGHT");
     case enums::ALARM_CONTROL_PANEL_ARM_VACATION:
-      return "ALARM_CONTROL_PANEL_ARM_VACATION";
+      return ESPHOME_PSTR("ALARM_CONTROL_PANEL_ARM_VACATION");
     case enums::ALARM_CONTROL_PANEL_ARM_CUSTOM_BYPASS:
-      return "ALARM_CONTROL_PANEL_ARM_CUSTOM_BYPASS";
+      return ESPHOME_PSTR("ALARM_CONTROL_PANEL_ARM_CUSTOM_BYPASS");
     case enums::ALARM_CONTROL_PANEL_TRIGGER:
-      return "ALARM_CONTROL_PANEL_TRIGGER";
+      return ESPHOME_PSTR("ALARM_CONTROL_PANEL_TRIGGER");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -714,11 +739,11 @@ const char *proto_enum_to_string<enums::AlarmControlPanelStateCommand>(enums::Al
 template<> const char *proto_enum_to_string<enums::TextMode>(enums::TextMode value) {
   switch (value) {
     case enums::TEXT_MODE_TEXT:
-      return "TEXT_MODE_TEXT";
+      return ESPHOME_PSTR("TEXT_MODE_TEXT");
     case enums::TEXT_MODE_PASSWORD:
-      return "TEXT_MODE_PASSWORD";
+      return ESPHOME_PSTR("TEXT_MODE_PASSWORD");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -726,13 +751,13 @@ template<> const char *proto_enum_to_string<enums::TextMode>(enums::TextMode val
 template<> const char *proto_enum_to_string<enums::ValveOperation>(enums::ValveOperation value) {
   switch (value) {
     case enums::VALVE_OPERATION_IDLE:
-      return "VALVE_OPERATION_IDLE";
+      return ESPHOME_PSTR("VALVE_OPERATION_IDLE");
     case enums::VALVE_OPERATION_IS_OPENING:
-      return "VALVE_OPERATION_IS_OPENING";
+      return ESPHOME_PSTR("VALVE_OPERATION_IS_OPENING");
     case enums::VALVE_OPERATION_IS_CLOSING:
-      return "VALVE_OPERATION_IS_CLOSING";
+      return ESPHOME_PSTR("VALVE_OPERATION_IS_CLOSING");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -740,13 +765,13 @@ template<> const char *proto_enum_to_string<enums::ValveOperation>(enums::ValveO
 template<> const char *proto_enum_to_string<enums::UpdateCommand>(enums::UpdateCommand value) {
   switch (value) {
     case enums::UPDATE_COMMAND_NONE:
-      return "UPDATE_COMMAND_NONE";
+      return ESPHOME_PSTR("UPDATE_COMMAND_NONE");
     case enums::UPDATE_COMMAND_UPDATE:
-      return "UPDATE_COMMAND_UPDATE";
+      return ESPHOME_PSTR("UPDATE_COMMAND_UPDATE");
     case enums::UPDATE_COMMAND_CHECK:
-      return "UPDATE_COMMAND_CHECK";
+      return ESPHOME_PSTR("UPDATE_COMMAND_CHECK");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -754,13 +779,13 @@ template<> const char *proto_enum_to_string<enums::UpdateCommand>(enums::UpdateC
 template<> const char *proto_enum_to_string<enums::ZWaveProxyRequestType>(enums::ZWaveProxyRequestType value) {
   switch (value) {
     case enums::ZWAVE_PROXY_REQUEST_TYPE_SUBSCRIBE:
-      return "ZWAVE_PROXY_REQUEST_TYPE_SUBSCRIBE";
+      return ESPHOME_PSTR("ZWAVE_PROXY_REQUEST_TYPE_SUBSCRIBE");
     case enums::ZWAVE_PROXY_REQUEST_TYPE_UNSUBSCRIBE:
-      return "ZWAVE_PROXY_REQUEST_TYPE_UNSUBSCRIBE";
+      return ESPHOME_PSTR("ZWAVE_PROXY_REQUEST_TYPE_UNSUBSCRIBE");
     case enums::ZWAVE_PROXY_REQUEST_TYPE_HOME_ID_CHANGE:
-      return "ZWAVE_PROXY_REQUEST_TYPE_HOME_ID_CHANGE";
+      return ESPHOME_PSTR("ZWAVE_PROXY_REQUEST_TYPE_HOME_ID_CHANGE");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
@@ -768,165 +793,165 @@ template<> const char *proto_enum_to_string<enums::ZWaveProxyRequestType>(enums:
 template<> const char *proto_enum_to_string<enums::SerialProxyParity>(enums::SerialProxyParity value) {
   switch (value) {
     case enums::SERIAL_PROXY_PARITY_NONE:
-      return "SERIAL_PROXY_PARITY_NONE";
+      return ESPHOME_PSTR("SERIAL_PROXY_PARITY_NONE");
     case enums::SERIAL_PROXY_PARITY_EVEN:
-      return "SERIAL_PROXY_PARITY_EVEN";
+      return ESPHOME_PSTR("SERIAL_PROXY_PARITY_EVEN");
     case enums::SERIAL_PROXY_PARITY_ODD:
-      return "SERIAL_PROXY_PARITY_ODD";
+      return ESPHOME_PSTR("SERIAL_PROXY_PARITY_ODD");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::SerialProxyRequestType>(enums::SerialProxyRequestType value) {
   switch (value) {
     case enums::SERIAL_PROXY_REQUEST_TYPE_SUBSCRIBE:
-      return "SERIAL_PROXY_REQUEST_TYPE_SUBSCRIBE";
+      return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_SUBSCRIBE");
     case enums::SERIAL_PROXY_REQUEST_TYPE_UNSUBSCRIBE:
-      return "SERIAL_PROXY_REQUEST_TYPE_UNSUBSCRIBE";
+      return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_UNSUBSCRIBE");
     case enums::SERIAL_PROXY_REQUEST_TYPE_FLUSH:
-      return "SERIAL_PROXY_REQUEST_TYPE_FLUSH";
+      return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_FLUSH");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 template<> const char *proto_enum_to_string<enums::SerialProxyStatus>(enums::SerialProxyStatus value) {
   switch (value) {
     case enums::SERIAL_PROXY_STATUS_OK:
-      return "SERIAL_PROXY_STATUS_OK";
+      return ESPHOME_PSTR("SERIAL_PROXY_STATUS_OK");
     case enums::SERIAL_PROXY_STATUS_ASSUMED_SUCCESS:
-      return "SERIAL_PROXY_STATUS_ASSUMED_SUCCESS";
+      return ESPHOME_PSTR("SERIAL_PROXY_STATUS_ASSUMED_SUCCESS");
     case enums::SERIAL_PROXY_STATUS_ERROR:
-      return "SERIAL_PROXY_STATUS_ERROR";
+      return ESPHOME_PSTR("SERIAL_PROXY_STATUS_ERROR");
     case enums::SERIAL_PROXY_STATUS_TIMEOUT:
-      return "SERIAL_PROXY_STATUS_TIMEOUT";
+      return ESPHOME_PSTR("SERIAL_PROXY_STATUS_TIMEOUT");
     case enums::SERIAL_PROXY_STATUS_NOT_SUPPORTED:
-      return "SERIAL_PROXY_STATUS_NOT_SUPPORTED";
+      return ESPHOME_PSTR("SERIAL_PROXY_STATUS_NOT_SUPPORTED");
     default:
-      return "UNKNOWN";
+      return ESPHOME_PSTR("UNKNOWN");
   }
 }
 #endif
 
 const char *HelloRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "HelloRequest");
-  dump_field(out, "client_info", this->client_info);
-  dump_field(out, "api_version_major", this->api_version_major);
-  dump_field(out, "api_version_minor", this->api_version_minor);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("HelloRequest"));
+  dump_field(out, ESPHOME_PSTR("client_info"), this->client_info);
+  dump_field(out, ESPHOME_PSTR("api_version_major"), this->api_version_major);
+  dump_field(out, ESPHOME_PSTR("api_version_minor"), this->api_version_minor);
   return out.c_str();
 }
 const char *HelloResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "HelloResponse");
-  dump_field(out, "api_version_major", this->api_version_major);
-  dump_field(out, "api_version_minor", this->api_version_minor);
-  dump_field(out, "server_info", this->server_info);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("HelloResponse"));
+  dump_field(out, ESPHOME_PSTR("api_version_major"), this->api_version_major);
+  dump_field(out, ESPHOME_PSTR("api_version_minor"), this->api_version_minor);
+  dump_field(out, ESPHOME_PSTR("server_info"), this->server_info);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
   return out.c_str();
 }
 const char *DisconnectRequest::dump_to(DumpBuffer &out) const {
-  out.append("DisconnectRequest {}");
+  out.append_p(ESPHOME_PSTR("DisconnectRequest {}"));
   return out.c_str();
 }
 const char *DisconnectResponse::dump_to(DumpBuffer &out) const {
-  out.append("DisconnectResponse {}");
+  out.append_p(ESPHOME_PSTR("DisconnectResponse {}"));
   return out.c_str();
 }
 const char *PingRequest::dump_to(DumpBuffer &out) const {
-  out.append("PingRequest {}");
+  out.append_p(ESPHOME_PSTR("PingRequest {}"));
   return out.c_str();
 }
 const char *PingResponse::dump_to(DumpBuffer &out) const {
-  out.append("PingResponse {}");
+  out.append_p(ESPHOME_PSTR("PingResponse {}"));
   return out.c_str();
 }
 #ifdef USE_AREAS
 const char *AreaInfo::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "AreaInfo");
-  dump_field(out, "area_id", this->area_id);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("AreaInfo"));
+  dump_field(out, ESPHOME_PSTR("area_id"), this->area_id);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
   return out.c_str();
 }
 #endif
 #ifdef USE_DEVICES
 const char *DeviceInfo::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "DeviceInfo");
-  dump_field(out, "device_id", this->device_id);
-  dump_field(out, "name", this->name);
-  dump_field(out, "area_id", this->area_id);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("DeviceInfo"));
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("area_id"), this->area_id);
   return out.c_str();
 }
 #endif
 #ifdef USE_SERIAL_PROXY
 const char *SerialProxyInfo::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyInfo");
-  dump_field(out, "name", this->name);
-  dump_field(out, "port_type", static_cast<enums::SerialProxyPortType>(this->port_type));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyInfo"));
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("port_type"), static_cast<enums::SerialProxyPortType>(this->port_type));
   return out.c_str();
 }
 #endif
 const char *DeviceInfoResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "DeviceInfoResponse");
-  dump_field(out, "name", this->name);
-  dump_field(out, "mac_address", this->mac_address);
-  dump_field(out, "esphome_version", this->esphome_version);
-  dump_field(out, "compilation_time", this->compilation_time);
-  dump_field(out, "model", this->model);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("DeviceInfoResponse"));
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("mac_address"), this->mac_address);
+  dump_field(out, ESPHOME_PSTR("esphome_version"), this->esphome_version);
+  dump_field(out, ESPHOME_PSTR("compilation_time"), this->compilation_time);
+  dump_field(out, ESPHOME_PSTR("model"), this->model);
 #ifdef USE_DEEP_SLEEP
-  dump_field(out, "has_deep_sleep", this->has_deep_sleep);
+  dump_field(out, ESPHOME_PSTR("has_deep_sleep"), this->has_deep_sleep);
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  dump_field(out, "project_name", this->project_name);
+  dump_field(out, ESPHOME_PSTR("project_name"), this->project_name);
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  dump_field(out, "project_version", this->project_version);
+  dump_field(out, ESPHOME_PSTR("project_version"), this->project_version);
 #endif
 #ifdef USE_WEBSERVER
-  dump_field(out, "webserver_port", this->webserver_port);
+  dump_field(out, ESPHOME_PSTR("webserver_port"), this->webserver_port);
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  dump_field(out, "bluetooth_proxy_feature_flags", this->bluetooth_proxy_feature_flags);
+  dump_field(out, ESPHOME_PSTR("bluetooth_proxy_feature_flags"), this->bluetooth_proxy_feature_flags);
 #endif
-  dump_field(out, "manufacturer", this->manufacturer);
-  dump_field(out, "friendly_name", this->friendly_name);
+  dump_field(out, ESPHOME_PSTR("manufacturer"), this->manufacturer);
+  dump_field(out, ESPHOME_PSTR("friendly_name"), this->friendly_name);
 #ifdef USE_VOICE_ASSISTANT
-  dump_field(out, "voice_assistant_feature_flags", this->voice_assistant_feature_flags);
+  dump_field(out, ESPHOME_PSTR("voice_assistant_feature_flags"), this->voice_assistant_feature_flags);
 #endif
 #ifdef USE_AREAS
-  dump_field(out, "suggested_area", this->suggested_area);
+  dump_field(out, ESPHOME_PSTR("suggested_area"), this->suggested_area);
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  dump_field(out, "bluetooth_mac_address", this->bluetooth_mac_address);
+  dump_field(out, ESPHOME_PSTR("bluetooth_mac_address"), this->bluetooth_mac_address);
 #endif
 #ifdef USE_API_NOISE
-  dump_field(out, "api_encryption_supported", this->api_encryption_supported);
+  dump_field(out, ESPHOME_PSTR("api_encryption_supported"), this->api_encryption_supported);
 #endif
 #ifdef USE_DEVICES
   for (const auto &it : this->devices) {
-    out.append("  devices: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("devices")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
 #endif
 #ifdef USE_AREAS
   for (const auto &it : this->areas) {
-    out.append("  areas: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("areas")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
 #endif
 #ifdef USE_AREAS
-  out.append("  area: ");
+  out.append(2, ' ').append_p(ESPHOME_PSTR("area")).append(": ");
   this->area.dump_to(out);
   out.append("\n");
 #endif
 #ifdef USE_ZWAVE_PROXY
-  dump_field(out, "zwave_proxy_feature_flags", this->zwave_proxy_feature_flags);
+  dump_field(out, ESPHOME_PSTR("zwave_proxy_feature_flags"), this->zwave_proxy_feature_flags);
 #endif
 #ifdef USE_ZWAVE_PROXY
-  dump_field(out, "zwave_home_id", this->zwave_home_id);
+  dump_field(out, ESPHOME_PSTR("zwave_home_id"), this->zwave_home_id);
 #endif
 #ifdef USE_SERIAL_PROXY
   for (const auto &it : this->serial_proxies) {
-    out.append("  serial_proxies: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("serial_proxies")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
@@ -934,1720 +959,1720 @@ const char *DeviceInfoResponse::dump_to(DumpBuffer &out) const {
   return out.c_str();
 }
 const char *ListEntitiesDoneResponse::dump_to(DumpBuffer &out) const {
-  out.append("ListEntitiesDoneResponse {}");
+  out.append_p(ESPHOME_PSTR("ListEntitiesDoneResponse {}"));
   return out.c_str();
 }
 #ifdef USE_BINARY_SENSOR
 const char *ListEntitiesBinarySensorResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesBinarySensorResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
-  dump_field(out, "device_class", this->device_class);
-  dump_field(out, "is_status_binary_sensor", this->is_status_binary_sensor);
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesBinarySensorResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("is_status_binary_sensor"), this->is_status_binary_sensor);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *BinarySensorStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BinarySensorStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
-  dump_field(out, "missing_state", this->missing_state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BinarySensorStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_COVER
 const char *ListEntitiesCoverResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesCoverResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
-  dump_field(out, "assumed_state", this->assumed_state);
-  dump_field(out, "supports_position", this->supports_position);
-  dump_field(out, "supports_tilt", this->supports_tilt);
-  dump_field(out, "device_class", this->device_class);
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesCoverResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("assumed_state"), this->assumed_state);
+  dump_field(out, ESPHOME_PSTR("supports_position"), this->supports_position);
+  dump_field(out, ESPHOME_PSTR("supports_tilt"), this->supports_tilt);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "supports_stop", this->supports_stop);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("supports_stop"), this->supports_stop);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *CoverStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "CoverStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "position", this->position);
-  dump_field(out, "tilt", this->tilt);
-  dump_field(out, "current_operation", static_cast<enums::CoverOperation>(this->current_operation));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("CoverStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("position"), this->position);
+  dump_field(out, ESPHOME_PSTR("tilt"), this->tilt);
+  dump_field(out, ESPHOME_PSTR("current_operation"), static_cast<enums::CoverOperation>(this->current_operation));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *CoverCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "CoverCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "has_position", this->has_position);
-  dump_field(out, "position", this->position);
-  dump_field(out, "has_tilt", this->has_tilt);
-  dump_field(out, "tilt", this->tilt);
-  dump_field(out, "stop", this->stop);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("CoverCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("has_position"), this->has_position);
+  dump_field(out, ESPHOME_PSTR("position"), this->position);
+  dump_field(out, ESPHOME_PSTR("has_tilt"), this->has_tilt);
+  dump_field(out, ESPHOME_PSTR("tilt"), this->tilt);
+  dump_field(out, ESPHOME_PSTR("stop"), this->stop);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_FAN
 const char *ListEntitiesFanResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesFanResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
-  dump_field(out, "supports_oscillation", this->supports_oscillation);
-  dump_field(out, "supports_speed", this->supports_speed);
-  dump_field(out, "supports_direction", this->supports_direction);
-  dump_field(out, "supported_speed_count", this->supported_speed_count);
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesFanResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("supports_oscillation"), this->supports_oscillation);
+  dump_field(out, ESPHOME_PSTR("supports_speed"), this->supports_speed);
+  dump_field(out, ESPHOME_PSTR("supports_direction"), this->supports_direction);
+  dump_field(out, ESPHOME_PSTR("supported_speed_count"), this->supported_speed_count);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
   for (const auto &it : *this->supported_preset_modes) {
-    dump_field(out, "supported_preset_modes", it, 4);
+    dump_field(out, ESPHOME_PSTR("supported_preset_modes"), it, 4);
   }
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *FanStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "FanStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
-  dump_field(out, "oscillating", this->oscillating);
-  dump_field(out, "direction", static_cast<enums::FanDirection>(this->direction));
-  dump_field(out, "speed_level", this->speed_level);
-  dump_field(out, "preset_mode", this->preset_mode);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("FanStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("oscillating"), this->oscillating);
+  dump_field(out, ESPHOME_PSTR("direction"), static_cast<enums::FanDirection>(this->direction));
+  dump_field(out, ESPHOME_PSTR("speed_level"), this->speed_level);
+  dump_field(out, ESPHOME_PSTR("preset_mode"), this->preset_mode);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *FanCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "FanCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "has_state", this->has_state);
-  dump_field(out, "state", this->state);
-  dump_field(out, "has_oscillating", this->has_oscillating);
-  dump_field(out, "oscillating", this->oscillating);
-  dump_field(out, "has_direction", this->has_direction);
-  dump_field(out, "direction", static_cast<enums::FanDirection>(this->direction));
-  dump_field(out, "has_speed_level", this->has_speed_level);
-  dump_field(out, "speed_level", this->speed_level);
-  dump_field(out, "has_preset_mode", this->has_preset_mode);
-  dump_field(out, "preset_mode", this->preset_mode);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("FanCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("has_state"), this->has_state);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("has_oscillating"), this->has_oscillating);
+  dump_field(out, ESPHOME_PSTR("oscillating"), this->oscillating);
+  dump_field(out, ESPHOME_PSTR("has_direction"), this->has_direction);
+  dump_field(out, ESPHOME_PSTR("direction"), static_cast<enums::FanDirection>(this->direction));
+  dump_field(out, ESPHOME_PSTR("has_speed_level"), this->has_speed_level);
+  dump_field(out, ESPHOME_PSTR("speed_level"), this->speed_level);
+  dump_field(out, ESPHOME_PSTR("has_preset_mode"), this->has_preset_mode);
+  dump_field(out, ESPHOME_PSTR("preset_mode"), this->preset_mode);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_LIGHT
 const char *ListEntitiesLightResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesLightResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesLightResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
   for (const auto &it : *this->supported_color_modes) {
-    dump_field(out, "supported_color_modes", static_cast<enums::ColorMode>(it), 4);
+    dump_field(out, ESPHOME_PSTR("supported_color_modes"), static_cast<enums::ColorMode>(it), 4);
   }
-  dump_field(out, "min_mireds", this->min_mireds);
-  dump_field(out, "max_mireds", this->max_mireds);
+  dump_field(out, ESPHOME_PSTR("min_mireds"), this->min_mireds);
+  dump_field(out, ESPHOME_PSTR("max_mireds"), this->max_mireds);
   for (const auto &it : *this->effects) {
-    dump_field(out, "effects", it, 4);
+    dump_field(out, ESPHOME_PSTR("effects"), it, 4);
   }
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *LightStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "LightStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
-  dump_field(out, "brightness", this->brightness);
-  dump_field(out, "color_mode", static_cast<enums::ColorMode>(this->color_mode));
-  dump_field(out, "color_brightness", this->color_brightness);
-  dump_field(out, "red", this->red);
-  dump_field(out, "green", this->green);
-  dump_field(out, "blue", this->blue);
-  dump_field(out, "white", this->white);
-  dump_field(out, "color_temperature", this->color_temperature);
-  dump_field(out, "cold_white", this->cold_white);
-  dump_field(out, "warm_white", this->warm_white);
-  dump_field(out, "effect", this->effect);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("LightStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("brightness"), this->brightness);
+  dump_field(out, ESPHOME_PSTR("color_mode"), static_cast<enums::ColorMode>(this->color_mode));
+  dump_field(out, ESPHOME_PSTR("color_brightness"), this->color_brightness);
+  dump_field(out, ESPHOME_PSTR("red"), this->red);
+  dump_field(out, ESPHOME_PSTR("green"), this->green);
+  dump_field(out, ESPHOME_PSTR("blue"), this->blue);
+  dump_field(out, ESPHOME_PSTR("white"), this->white);
+  dump_field(out, ESPHOME_PSTR("color_temperature"), this->color_temperature);
+  dump_field(out, ESPHOME_PSTR("cold_white"), this->cold_white);
+  dump_field(out, ESPHOME_PSTR("warm_white"), this->warm_white);
+  dump_field(out, ESPHOME_PSTR("effect"), this->effect);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *LightCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "LightCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "has_state", this->has_state);
-  dump_field(out, "state", this->state);
-  dump_field(out, "has_brightness", this->has_brightness);
-  dump_field(out, "brightness", this->brightness);
-  dump_field(out, "has_color_mode", this->has_color_mode);
-  dump_field(out, "color_mode", static_cast<enums::ColorMode>(this->color_mode));
-  dump_field(out, "has_color_brightness", this->has_color_brightness);
-  dump_field(out, "color_brightness", this->color_brightness);
-  dump_field(out, "has_rgb", this->has_rgb);
-  dump_field(out, "red", this->red);
-  dump_field(out, "green", this->green);
-  dump_field(out, "blue", this->blue);
-  dump_field(out, "has_white", this->has_white);
-  dump_field(out, "white", this->white);
-  dump_field(out, "has_color_temperature", this->has_color_temperature);
-  dump_field(out, "color_temperature", this->color_temperature);
-  dump_field(out, "has_cold_white", this->has_cold_white);
-  dump_field(out, "cold_white", this->cold_white);
-  dump_field(out, "has_warm_white", this->has_warm_white);
-  dump_field(out, "warm_white", this->warm_white);
-  dump_field(out, "has_transition_length", this->has_transition_length);
-  dump_field(out, "transition_length", this->transition_length);
-  dump_field(out, "has_flash_length", this->has_flash_length);
-  dump_field(out, "flash_length", this->flash_length);
-  dump_field(out, "has_effect", this->has_effect);
-  dump_field(out, "effect", this->effect);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("LightCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("has_state"), this->has_state);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("has_brightness"), this->has_brightness);
+  dump_field(out, ESPHOME_PSTR("brightness"), this->brightness);
+  dump_field(out, ESPHOME_PSTR("has_color_mode"), this->has_color_mode);
+  dump_field(out, ESPHOME_PSTR("color_mode"), static_cast<enums::ColorMode>(this->color_mode));
+  dump_field(out, ESPHOME_PSTR("has_color_brightness"), this->has_color_brightness);
+  dump_field(out, ESPHOME_PSTR("color_brightness"), this->color_brightness);
+  dump_field(out, ESPHOME_PSTR("has_rgb"), this->has_rgb);
+  dump_field(out, ESPHOME_PSTR("red"), this->red);
+  dump_field(out, ESPHOME_PSTR("green"), this->green);
+  dump_field(out, ESPHOME_PSTR("blue"), this->blue);
+  dump_field(out, ESPHOME_PSTR("has_white"), this->has_white);
+  dump_field(out, ESPHOME_PSTR("white"), this->white);
+  dump_field(out, ESPHOME_PSTR("has_color_temperature"), this->has_color_temperature);
+  dump_field(out, ESPHOME_PSTR("color_temperature"), this->color_temperature);
+  dump_field(out, ESPHOME_PSTR("has_cold_white"), this->has_cold_white);
+  dump_field(out, ESPHOME_PSTR("cold_white"), this->cold_white);
+  dump_field(out, ESPHOME_PSTR("has_warm_white"), this->has_warm_white);
+  dump_field(out, ESPHOME_PSTR("warm_white"), this->warm_white);
+  dump_field(out, ESPHOME_PSTR("has_transition_length"), this->has_transition_length);
+  dump_field(out, ESPHOME_PSTR("transition_length"), this->transition_length);
+  dump_field(out, ESPHOME_PSTR("has_flash_length"), this->has_flash_length);
+  dump_field(out, ESPHOME_PSTR("flash_length"), this->flash_length);
+  dump_field(out, ESPHOME_PSTR("has_effect"), this->has_effect);
+  dump_field(out, ESPHOME_PSTR("effect"), this->effect);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_SENSOR
 const char *ListEntitiesSensorResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesSensorResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesSensorResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "unit_of_measurement", this->unit_of_measurement);
-  dump_field(out, "accuracy_decimals", this->accuracy_decimals);
-  dump_field(out, "force_update", this->force_update);
-  dump_field(out, "device_class", this->device_class);
-  dump_field(out, "state_class", static_cast<enums::SensorStateClass>(this->state_class));
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("unit_of_measurement"), this->unit_of_measurement);
+  dump_field(out, ESPHOME_PSTR("accuracy_decimals"), this->accuracy_decimals);
+  dump_field(out, ESPHOME_PSTR("force_update"), this->force_update);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("state_class"), static_cast<enums::SensorStateClass>(this->state_class));
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *SensorStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SensorStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
-  dump_field(out, "missing_state", this->missing_state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SensorStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_SWITCH
 const char *ListEntitiesSwitchResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesSwitchResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesSwitchResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "assumed_state", this->assumed_state);
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "device_class", this->device_class);
+  dump_field(out, ESPHOME_PSTR("assumed_state"), this->assumed_state);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *SwitchStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SwitchStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SwitchStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *SwitchCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SwitchCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SwitchCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_TEXT_SENSOR
 const char *ListEntitiesTextSensorResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesTextSensorResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesTextSensorResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "device_class", this->device_class);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *TextSensorStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "TextSensorStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
-  dump_field(out, "missing_state", this->missing_state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("TextSensorStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 const char *SubscribeLogsRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SubscribeLogsRequest");
-  dump_field(out, "level", static_cast<enums::LogLevel>(this->level));
-  dump_field(out, "dump_config", this->dump_config);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SubscribeLogsRequest"));
+  dump_field(out, ESPHOME_PSTR("level"), static_cast<enums::LogLevel>(this->level));
+  dump_field(out, ESPHOME_PSTR("dump_config"), this->dump_config);
   return out.c_str();
 }
 const char *SubscribeLogsResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SubscribeLogsResponse");
-  dump_field(out, "level", static_cast<enums::LogLevel>(this->level));
-  dump_bytes_field(out, "message", this->message_ptr_, this->message_len_);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SubscribeLogsResponse"));
+  dump_field(out, ESPHOME_PSTR("level"), static_cast<enums::LogLevel>(this->level));
+  dump_bytes_field(out, ESPHOME_PSTR("message"), this->message_ptr_, this->message_len_);
   return out.c_str();
 }
 #ifdef USE_API_NOISE
 const char *NoiseEncryptionSetKeyRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "NoiseEncryptionSetKeyRequest");
-  dump_bytes_field(out, "key", this->key, this->key_len);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("NoiseEncryptionSetKeyRequest"));
+  dump_bytes_field(out, ESPHOME_PSTR("key"), this->key, this->key_len);
   return out.c_str();
 }
 const char *NoiseEncryptionSetKeyResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "NoiseEncryptionSetKeyResponse");
-  dump_field(out, "success", this->success);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("NoiseEncryptionSetKeyResponse"));
+  dump_field(out, ESPHOME_PSTR("success"), this->success);
   return out.c_str();
 }
 #endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
 const char *HomeassistantServiceMap::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "HomeassistantServiceMap");
-  dump_field(out, "key", this->key);
-  dump_field(out, "value", this->value);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("HomeassistantServiceMap"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("value"), this->value);
   return out.c_str();
 }
 const char *HomeassistantActionRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "HomeassistantActionRequest");
-  dump_field(out, "service", this->service);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("HomeassistantActionRequest"));
+  dump_field(out, ESPHOME_PSTR("service"), this->service);
   for (const auto &it : this->data) {
-    out.append("  data: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("data")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
   for (const auto &it : this->data_template) {
-    out.append("  data_template: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("data_template")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
   for (const auto &it : this->variables) {
-    out.append("  variables: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("variables")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
-  dump_field(out, "is_event", this->is_event);
+  dump_field(out, ESPHOME_PSTR("is_event"), this->is_event);
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  dump_field(out, "call_id", this->call_id);
+  dump_field(out, ESPHOME_PSTR("call_id"), this->call_id);
 #endif
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  dump_field(out, "wants_response", this->wants_response);
+  dump_field(out, ESPHOME_PSTR("wants_response"), this->wants_response);
 #endif
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  dump_field(out, "response_template", this->response_template);
+  dump_field(out, ESPHOME_PSTR("response_template"), this->response_template);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
 const char *HomeassistantActionResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "HomeassistantActionResponse");
-  dump_field(out, "call_id", this->call_id);
-  dump_field(out, "success", this->success);
-  dump_field(out, "error_message", this->error_message);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("HomeassistantActionResponse"));
+  dump_field(out, ESPHOME_PSTR("call_id"), this->call_id);
+  dump_field(out, ESPHOME_PSTR("success"), this->success);
+  dump_field(out, ESPHOME_PSTR("error_message"), this->error_message);
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  dump_bytes_field(out, "response_data", this->response_data, this->response_data_len);
+  dump_bytes_field(out, ESPHOME_PSTR("response_data"), this->response_data, this->response_data_len);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES
 const char *SubscribeHomeAssistantStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SubscribeHomeAssistantStateResponse");
-  dump_field(out, "entity_id", this->entity_id);
-  dump_field(out, "attribute", this->attribute);
-  dump_field(out, "once", this->once);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SubscribeHomeAssistantStateResponse"));
+  dump_field(out, ESPHOME_PSTR("entity_id"), this->entity_id);
+  dump_field(out, ESPHOME_PSTR("attribute"), this->attribute);
+  dump_field(out, ESPHOME_PSTR("once"), this->once);
   return out.c_str();
 }
 const char *HomeAssistantStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "HomeAssistantStateResponse");
-  dump_field(out, "entity_id", this->entity_id);
-  dump_field(out, "state", this->state);
-  dump_field(out, "attribute", this->attribute);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("HomeAssistantStateResponse"));
+  dump_field(out, ESPHOME_PSTR("entity_id"), this->entity_id);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("attribute"), this->attribute);
   return out.c_str();
 }
 #endif
 const char *GetTimeRequest::dump_to(DumpBuffer &out) const {
-  out.append("GetTimeRequest {}");
+  out.append_p(ESPHOME_PSTR("GetTimeRequest {}"));
   return out.c_str();
 }
 const char *DSTRule::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "DSTRule");
-  dump_field(out, "time_seconds", this->time_seconds);
-  dump_field(out, "day", this->day);
-  dump_field(out, "type", static_cast<enums::DSTRuleType>(this->type));
-  dump_field(out, "month", this->month);
-  dump_field(out, "week", this->week);
-  dump_field(out, "day_of_week", this->day_of_week);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("DSTRule"));
+  dump_field(out, ESPHOME_PSTR("time_seconds"), this->time_seconds);
+  dump_field(out, ESPHOME_PSTR("day"), this->day);
+  dump_field(out, ESPHOME_PSTR("type"), static_cast<enums::DSTRuleType>(this->type));
+  dump_field(out, ESPHOME_PSTR("month"), this->month);
+  dump_field(out, ESPHOME_PSTR("week"), this->week);
+  dump_field(out, ESPHOME_PSTR("day_of_week"), this->day_of_week);
   return out.c_str();
 }
 const char *ParsedTimezone::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ParsedTimezone");
-  dump_field(out, "std_offset_seconds", this->std_offset_seconds);
-  dump_field(out, "dst_offset_seconds", this->dst_offset_seconds);
-  out.append("  dst_start: ");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ParsedTimezone"));
+  dump_field(out, ESPHOME_PSTR("std_offset_seconds"), this->std_offset_seconds);
+  dump_field(out, ESPHOME_PSTR("dst_offset_seconds"), this->dst_offset_seconds);
+  out.append(2, ' ').append_p(ESPHOME_PSTR("dst_start")).append(": ");
   this->dst_start.dump_to(out);
   out.append("\n");
-  out.append("  dst_end: ");
+  out.append(2, ' ').append_p(ESPHOME_PSTR("dst_end")).append(": ");
   this->dst_end.dump_to(out);
   out.append("\n");
   return out.c_str();
 }
 const char *GetTimeResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "GetTimeResponse");
-  dump_field(out, "epoch_seconds", this->epoch_seconds);
-  dump_field(out, "timezone", this->timezone);
-  out.append("  parsed_timezone: ");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("GetTimeResponse"));
+  dump_field(out, ESPHOME_PSTR("epoch_seconds"), this->epoch_seconds);
+  dump_field(out, ESPHOME_PSTR("timezone"), this->timezone);
+  out.append(2, ' ').append_p(ESPHOME_PSTR("parsed_timezone")).append(": ");
   this->parsed_timezone.dump_to(out);
   out.append("\n");
   return out.c_str();
 }
 #ifdef USE_API_USER_DEFINED_ACTIONS
 const char *ListEntitiesServicesArgument::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesServicesArgument");
-  dump_field(out, "name", this->name);
-  dump_field(out, "type", static_cast<enums::ServiceArgType>(this->type));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesServicesArgument"));
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("type"), static_cast<enums::ServiceArgType>(this->type));
   return out.c_str();
 }
 const char *ListEntitiesServicesResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesServicesResponse");
-  dump_field(out, "name", this->name);
-  dump_field(out, "key", this->key);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesServicesResponse"));
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
   for (const auto &it : this->args) {
-    out.append("  args: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("args")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
-  dump_field(out, "supports_response", static_cast<enums::SupportsResponseType>(this->supports_response));
+  dump_field(out, ESPHOME_PSTR("supports_response"), static_cast<enums::SupportsResponseType>(this->supports_response));
   return out.c_str();
 }
 const char *ExecuteServiceArgument::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ExecuteServiceArgument");
-  dump_field(out, "bool_", this->bool_);
-  dump_field(out, "legacy_int", this->legacy_int);
-  dump_field(out, "float_", this->float_);
-  dump_field(out, "string_", this->string_);
-  dump_field(out, "int_", this->int_);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ExecuteServiceArgument"));
+  dump_field(out, ESPHOME_PSTR("bool_"), this->bool_);
+  dump_field(out, ESPHOME_PSTR("legacy_int"), this->legacy_int);
+  dump_field(out, ESPHOME_PSTR("float_"), this->float_);
+  dump_field(out, ESPHOME_PSTR("string_"), this->string_);
+  dump_field(out, ESPHOME_PSTR("int_"), this->int_);
   for (const auto it : this->bool_array) {
-    dump_field(out, "bool_array", static_cast<bool>(it), 4);
+    dump_field(out, ESPHOME_PSTR("bool_array"), static_cast<bool>(it), 4);
   }
   for (const auto &it : this->int_array) {
-    dump_field(out, "int_array", it, 4);
+    dump_field(out, ESPHOME_PSTR("int_array"), it, 4);
   }
   for (const auto &it : this->float_array) {
-    dump_field(out, "float_array", it, 4);
+    dump_field(out, ESPHOME_PSTR("float_array"), it, 4);
   }
   for (const auto &it : this->string_array) {
-    dump_field(out, "string_array", it, 4);
+    dump_field(out, ESPHOME_PSTR("string_array"), it, 4);
   }
   return out.c_str();
 }
 const char *ExecuteServiceRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ExecuteServiceRequest");
-  dump_field(out, "key", this->key);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ExecuteServiceRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
   for (const auto &it : this->args) {
-    out.append("  args: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("args")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-  dump_field(out, "call_id", this->call_id);
+  dump_field(out, ESPHOME_PSTR("call_id"), this->call_id);
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-  dump_field(out, "return_response", this->return_response);
+  dump_field(out, ESPHOME_PSTR("return_response"), this->return_response);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
 const char *ExecuteServiceResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ExecuteServiceResponse");
-  dump_field(out, "call_id", this->call_id);
-  dump_field(out, "success", this->success);
-  dump_field(out, "error_message", this->error_message);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ExecuteServiceResponse"));
+  dump_field(out, ESPHOME_PSTR("call_id"), this->call_id);
+  dump_field(out, ESPHOME_PSTR("success"), this->success);
+  dump_field(out, ESPHOME_PSTR("error_message"), this->error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  dump_bytes_field(out, "response_data", this->response_data, this->response_data_len);
+  dump_bytes_field(out, ESPHOME_PSTR("response_data"), this->response_data, this->response_data_len);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_CAMERA
 const char *ListEntitiesCameraResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesCameraResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesCameraResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *CameraImageResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "CameraImageResponse");
-  dump_field(out, "key", this->key);
-  dump_bytes_field(out, "data", this->data_ptr_, this->data_len_);
-  dump_field(out, "done", this->done);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("CameraImageResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data_ptr_, this->data_len_);
+  dump_field(out, ESPHOME_PSTR("done"), this->done);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *CameraImageRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "CameraImageRequest");
-  dump_field(out, "single", this->single);
-  dump_field(out, "stream", this->stream);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("CameraImageRequest"));
+  dump_field(out, ESPHOME_PSTR("single"), this->single);
+  dump_field(out, ESPHOME_PSTR("stream"), this->stream);
   return out.c_str();
 }
 #endif
 #ifdef USE_CLIMATE
 const char *ListEntitiesClimateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesClimateResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
-  dump_field(out, "supports_current_temperature", this->supports_current_temperature);
-  dump_field(out, "supports_two_point_target_temperature", this->supports_two_point_target_temperature);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesClimateResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("supports_current_temperature"), this->supports_current_temperature);
+  dump_field(out, ESPHOME_PSTR("supports_two_point_target_temperature"), this->supports_two_point_target_temperature);
   for (const auto &it : *this->supported_modes) {
-    dump_field(out, "supported_modes", static_cast<enums::ClimateMode>(it), 4);
+    dump_field(out, ESPHOME_PSTR("supported_modes"), static_cast<enums::ClimateMode>(it), 4);
   }
-  dump_field(out, "visual_min_temperature", this->visual_min_temperature);
-  dump_field(out, "visual_max_temperature", this->visual_max_temperature);
-  dump_field(out, "visual_target_temperature_step", this->visual_target_temperature_step);
-  dump_field(out, "supports_action", this->supports_action);
+  dump_field(out, ESPHOME_PSTR("visual_min_temperature"), this->visual_min_temperature);
+  dump_field(out, ESPHOME_PSTR("visual_max_temperature"), this->visual_max_temperature);
+  dump_field(out, ESPHOME_PSTR("visual_target_temperature_step"), this->visual_target_temperature_step);
+  dump_field(out, ESPHOME_PSTR("supports_action"), this->supports_action);
   for (const auto &it : *this->supported_fan_modes) {
-    dump_field(out, "supported_fan_modes", static_cast<enums::ClimateFanMode>(it), 4);
+    dump_field(out, ESPHOME_PSTR("supported_fan_modes"), static_cast<enums::ClimateFanMode>(it), 4);
   }
   for (const auto &it : *this->supported_swing_modes) {
-    dump_field(out, "supported_swing_modes", static_cast<enums::ClimateSwingMode>(it), 4);
+    dump_field(out, ESPHOME_PSTR("supported_swing_modes"), static_cast<enums::ClimateSwingMode>(it), 4);
   }
   for (const auto &it : *this->supported_custom_fan_modes) {
-    dump_field(out, "supported_custom_fan_modes", it, 4);
+    dump_field(out, ESPHOME_PSTR("supported_custom_fan_modes"), it, 4);
   }
   for (const auto &it : *this->supported_presets) {
-    dump_field(out, "supported_presets", static_cast<enums::ClimatePreset>(it), 4);
+    dump_field(out, ESPHOME_PSTR("supported_presets"), static_cast<enums::ClimatePreset>(it), 4);
   }
   for (const auto &it : *this->supported_custom_presets) {
-    dump_field(out, "supported_custom_presets", it, 4);
+    dump_field(out, ESPHOME_PSTR("supported_custom_presets"), it, 4);
   }
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "visual_current_temperature_step", this->visual_current_temperature_step);
-  dump_field(out, "supports_current_humidity", this->supports_current_humidity);
-  dump_field(out, "supports_target_humidity", this->supports_target_humidity);
-  dump_field(out, "visual_min_humidity", this->visual_min_humidity);
-  dump_field(out, "visual_max_humidity", this->visual_max_humidity);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("visual_current_temperature_step"), this->visual_current_temperature_step);
+  dump_field(out, ESPHOME_PSTR("supports_current_humidity"), this->supports_current_humidity);
+  dump_field(out, ESPHOME_PSTR("supports_target_humidity"), this->supports_target_humidity);
+  dump_field(out, ESPHOME_PSTR("visual_min_humidity"), this->visual_min_humidity);
+  dump_field(out, ESPHOME_PSTR("visual_max_humidity"), this->visual_max_humidity);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, "feature_flags", this->feature_flags);
+  dump_field(out, ESPHOME_PSTR("feature_flags"), this->feature_flags);
   return out.c_str();
 }
 const char *ClimateStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ClimateStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "mode", static_cast<enums::ClimateMode>(this->mode));
-  dump_field(out, "current_temperature", this->current_temperature);
-  dump_field(out, "target_temperature", this->target_temperature);
-  dump_field(out, "target_temperature_low", this->target_temperature_low);
-  dump_field(out, "target_temperature_high", this->target_temperature_high);
-  dump_field(out, "action", static_cast<enums::ClimateAction>(this->action));
-  dump_field(out, "fan_mode", static_cast<enums::ClimateFanMode>(this->fan_mode));
-  dump_field(out, "swing_mode", static_cast<enums::ClimateSwingMode>(this->swing_mode));
-  dump_field(out, "custom_fan_mode", this->custom_fan_mode);
-  dump_field(out, "preset", static_cast<enums::ClimatePreset>(this->preset));
-  dump_field(out, "custom_preset", this->custom_preset);
-  dump_field(out, "current_humidity", this->current_humidity);
-  dump_field(out, "target_humidity", this->target_humidity);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ClimateStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::ClimateMode>(this->mode));
+  dump_field(out, ESPHOME_PSTR("current_temperature"), this->current_temperature);
+  dump_field(out, ESPHOME_PSTR("target_temperature"), this->target_temperature);
+  dump_field(out, ESPHOME_PSTR("target_temperature_low"), this->target_temperature_low);
+  dump_field(out, ESPHOME_PSTR("target_temperature_high"), this->target_temperature_high);
+  dump_field(out, ESPHOME_PSTR("action"), static_cast<enums::ClimateAction>(this->action));
+  dump_field(out, ESPHOME_PSTR("fan_mode"), static_cast<enums::ClimateFanMode>(this->fan_mode));
+  dump_field(out, ESPHOME_PSTR("swing_mode"), static_cast<enums::ClimateSwingMode>(this->swing_mode));
+  dump_field(out, ESPHOME_PSTR("custom_fan_mode"), this->custom_fan_mode);
+  dump_field(out, ESPHOME_PSTR("preset"), static_cast<enums::ClimatePreset>(this->preset));
+  dump_field(out, ESPHOME_PSTR("custom_preset"), this->custom_preset);
+  dump_field(out, ESPHOME_PSTR("current_humidity"), this->current_humidity);
+  dump_field(out, ESPHOME_PSTR("target_humidity"), this->target_humidity);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *ClimateCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ClimateCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "has_mode", this->has_mode);
-  dump_field(out, "mode", static_cast<enums::ClimateMode>(this->mode));
-  dump_field(out, "has_target_temperature", this->has_target_temperature);
-  dump_field(out, "target_temperature", this->target_temperature);
-  dump_field(out, "has_target_temperature_low", this->has_target_temperature_low);
-  dump_field(out, "target_temperature_low", this->target_temperature_low);
-  dump_field(out, "has_target_temperature_high", this->has_target_temperature_high);
-  dump_field(out, "target_temperature_high", this->target_temperature_high);
-  dump_field(out, "has_fan_mode", this->has_fan_mode);
-  dump_field(out, "fan_mode", static_cast<enums::ClimateFanMode>(this->fan_mode));
-  dump_field(out, "has_swing_mode", this->has_swing_mode);
-  dump_field(out, "swing_mode", static_cast<enums::ClimateSwingMode>(this->swing_mode));
-  dump_field(out, "has_custom_fan_mode", this->has_custom_fan_mode);
-  dump_field(out, "custom_fan_mode", this->custom_fan_mode);
-  dump_field(out, "has_preset", this->has_preset);
-  dump_field(out, "preset", static_cast<enums::ClimatePreset>(this->preset));
-  dump_field(out, "has_custom_preset", this->has_custom_preset);
-  dump_field(out, "custom_preset", this->custom_preset);
-  dump_field(out, "has_target_humidity", this->has_target_humidity);
-  dump_field(out, "target_humidity", this->target_humidity);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ClimateCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("has_mode"), this->has_mode);
+  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::ClimateMode>(this->mode));
+  dump_field(out, ESPHOME_PSTR("has_target_temperature"), this->has_target_temperature);
+  dump_field(out, ESPHOME_PSTR("target_temperature"), this->target_temperature);
+  dump_field(out, ESPHOME_PSTR("has_target_temperature_low"), this->has_target_temperature_low);
+  dump_field(out, ESPHOME_PSTR("target_temperature_low"), this->target_temperature_low);
+  dump_field(out, ESPHOME_PSTR("has_target_temperature_high"), this->has_target_temperature_high);
+  dump_field(out, ESPHOME_PSTR("target_temperature_high"), this->target_temperature_high);
+  dump_field(out, ESPHOME_PSTR("has_fan_mode"), this->has_fan_mode);
+  dump_field(out, ESPHOME_PSTR("fan_mode"), static_cast<enums::ClimateFanMode>(this->fan_mode));
+  dump_field(out, ESPHOME_PSTR("has_swing_mode"), this->has_swing_mode);
+  dump_field(out, ESPHOME_PSTR("swing_mode"), static_cast<enums::ClimateSwingMode>(this->swing_mode));
+  dump_field(out, ESPHOME_PSTR("has_custom_fan_mode"), this->has_custom_fan_mode);
+  dump_field(out, ESPHOME_PSTR("custom_fan_mode"), this->custom_fan_mode);
+  dump_field(out, ESPHOME_PSTR("has_preset"), this->has_preset);
+  dump_field(out, ESPHOME_PSTR("preset"), static_cast<enums::ClimatePreset>(this->preset));
+  dump_field(out, ESPHOME_PSTR("has_custom_preset"), this->has_custom_preset);
+  dump_field(out, ESPHOME_PSTR("custom_preset"), this->custom_preset);
+  dump_field(out, ESPHOME_PSTR("has_target_humidity"), this->has_target_humidity);
+  dump_field(out, ESPHOME_PSTR("target_humidity"), this->target_humidity);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_WATER_HEATER
 const char *ListEntitiesWaterHeaterResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesWaterHeaterResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesWaterHeaterResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, "min_temperature", this->min_temperature);
-  dump_field(out, "max_temperature", this->max_temperature);
-  dump_field(out, "target_temperature_step", this->target_temperature_step);
+  dump_field(out, ESPHOME_PSTR("min_temperature"), this->min_temperature);
+  dump_field(out, ESPHOME_PSTR("max_temperature"), this->max_temperature);
+  dump_field(out, ESPHOME_PSTR("target_temperature_step"), this->target_temperature_step);
   for (const auto &it : *this->supported_modes) {
-    dump_field(out, "supported_modes", static_cast<enums::WaterHeaterMode>(it), 4);
+    dump_field(out, ESPHOME_PSTR("supported_modes"), static_cast<enums::WaterHeaterMode>(it), 4);
   }
-  dump_field(out, "supported_features", this->supported_features);
+  dump_field(out, ESPHOME_PSTR("supported_features"), this->supported_features);
   return out.c_str();
 }
 const char *WaterHeaterStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "WaterHeaterStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "current_temperature", this->current_temperature);
-  dump_field(out, "target_temperature", this->target_temperature);
-  dump_field(out, "mode", static_cast<enums::WaterHeaterMode>(this->mode));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("WaterHeaterStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("current_temperature"), this->current_temperature);
+  dump_field(out, ESPHOME_PSTR("target_temperature"), this->target_temperature);
+  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::WaterHeaterMode>(this->mode));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, "state", this->state);
-  dump_field(out, "target_temperature_low", this->target_temperature_low);
-  dump_field(out, "target_temperature_high", this->target_temperature_high);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("target_temperature_low"), this->target_temperature_low);
+  dump_field(out, ESPHOME_PSTR("target_temperature_high"), this->target_temperature_high);
   return out.c_str();
 }
 const char *WaterHeaterCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "WaterHeaterCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "has_fields", this->has_fields);
-  dump_field(out, "mode", static_cast<enums::WaterHeaterMode>(this->mode));
-  dump_field(out, "target_temperature", this->target_temperature);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("WaterHeaterCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("has_fields"), this->has_fields);
+  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::WaterHeaterMode>(this->mode));
+  dump_field(out, ESPHOME_PSTR("target_temperature"), this->target_temperature);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, "state", this->state);
-  dump_field(out, "target_temperature_low", this->target_temperature_low);
-  dump_field(out, "target_temperature_high", this->target_temperature_high);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("target_temperature_low"), this->target_temperature_low);
+  dump_field(out, ESPHOME_PSTR("target_temperature_high"), this->target_temperature_high);
   return out.c_str();
 }
 #endif
 #ifdef USE_NUMBER
 const char *ListEntitiesNumberResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesNumberResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesNumberResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "min_value", this->min_value);
-  dump_field(out, "max_value", this->max_value);
-  dump_field(out, "step", this->step);
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "unit_of_measurement", this->unit_of_measurement);
-  dump_field(out, "mode", static_cast<enums::NumberMode>(this->mode));
-  dump_field(out, "device_class", this->device_class);
+  dump_field(out, ESPHOME_PSTR("min_value"), this->min_value);
+  dump_field(out, ESPHOME_PSTR("max_value"), this->max_value);
+  dump_field(out, ESPHOME_PSTR("step"), this->step);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("unit_of_measurement"), this->unit_of_measurement);
+  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::NumberMode>(this->mode));
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *NumberStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "NumberStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
-  dump_field(out, "missing_state", this->missing_state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("NumberStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *NumberCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "NumberCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("NumberCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_SELECT
 const char *ListEntitiesSelectResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesSelectResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesSelectResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   for (const auto &it : *this->options) {
-    dump_field(out, "options", it, 4);
+    dump_field(out, ESPHOME_PSTR("options"), it, 4);
   }
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *SelectStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SelectStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
-  dump_field(out, "missing_state", this->missing_state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SelectStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *SelectCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SelectCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SelectCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_SIREN
 const char *ListEntitiesSirenResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesSirenResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesSirenResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   for (const auto &it : *this->tones) {
-    dump_field(out, "tones", it, 4);
+    dump_field(out, ESPHOME_PSTR("tones"), it, 4);
   }
-  dump_field(out, "supports_duration", this->supports_duration);
-  dump_field(out, "supports_volume", this->supports_volume);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("supports_duration"), this->supports_duration);
+  dump_field(out, ESPHOME_PSTR("supports_volume"), this->supports_volume);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *SirenStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SirenStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SirenStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *SirenCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SirenCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "has_state", this->has_state);
-  dump_field(out, "state", this->state);
-  dump_field(out, "has_tone", this->has_tone);
-  dump_field(out, "tone", this->tone);
-  dump_field(out, "has_duration", this->has_duration);
-  dump_field(out, "duration", this->duration);
-  dump_field(out, "has_volume", this->has_volume);
-  dump_field(out, "volume", this->volume);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SirenCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("has_state"), this->has_state);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("has_tone"), this->has_tone);
+  dump_field(out, ESPHOME_PSTR("tone"), this->tone);
+  dump_field(out, ESPHOME_PSTR("has_duration"), this->has_duration);
+  dump_field(out, ESPHOME_PSTR("duration"), this->duration);
+  dump_field(out, ESPHOME_PSTR("has_volume"), this->has_volume);
+  dump_field(out, ESPHOME_PSTR("volume"), this->volume);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_LOCK
 const char *ListEntitiesLockResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesLockResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesLockResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "assumed_state", this->assumed_state);
-  dump_field(out, "supports_open", this->supports_open);
-  dump_field(out, "requires_code", this->requires_code);
-  dump_field(out, "code_format", this->code_format);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("assumed_state"), this->assumed_state);
+  dump_field(out, ESPHOME_PSTR("supports_open"), this->supports_open);
+  dump_field(out, ESPHOME_PSTR("requires_code"), this->requires_code);
+  dump_field(out, ESPHOME_PSTR("code_format"), this->code_format);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *LockStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "LockStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", static_cast<enums::LockState>(this->state));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("LockStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), static_cast<enums::LockState>(this->state));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *LockCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "LockCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "command", static_cast<enums::LockCommand>(this->command));
-  dump_field(out, "has_code", this->has_code);
-  dump_field(out, "code", this->code);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("LockCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("command"), static_cast<enums::LockCommand>(this->command));
+  dump_field(out, ESPHOME_PSTR("has_code"), this->has_code);
+  dump_field(out, ESPHOME_PSTR("code"), this->code);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_BUTTON
 const char *ListEntitiesButtonResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesButtonResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesButtonResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "device_class", this->device_class);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *ButtonCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ButtonCommandRequest");
-  dump_field(out, "key", this->key);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ButtonCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_MEDIA_PLAYER
 const char *MediaPlayerSupportedFormat::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "MediaPlayerSupportedFormat");
-  dump_field(out, "format", this->format);
-  dump_field(out, "sample_rate", this->sample_rate);
-  dump_field(out, "num_channels", this->num_channels);
-  dump_field(out, "purpose", static_cast<enums::MediaPlayerFormatPurpose>(this->purpose));
-  dump_field(out, "sample_bytes", this->sample_bytes);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("MediaPlayerSupportedFormat"));
+  dump_field(out, ESPHOME_PSTR("format"), this->format);
+  dump_field(out, ESPHOME_PSTR("sample_rate"), this->sample_rate);
+  dump_field(out, ESPHOME_PSTR("num_channels"), this->num_channels);
+  dump_field(out, ESPHOME_PSTR("purpose"), static_cast<enums::MediaPlayerFormatPurpose>(this->purpose));
+  dump_field(out, ESPHOME_PSTR("sample_bytes"), this->sample_bytes);
   return out.c_str();
 }
 const char *ListEntitiesMediaPlayerResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesMediaPlayerResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesMediaPlayerResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "supports_pause", this->supports_pause);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("supports_pause"), this->supports_pause);
   for (const auto &it : this->supported_formats) {
-    out.append("  supported_formats: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("supported_formats")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, "feature_flags", this->feature_flags);
+  dump_field(out, ESPHOME_PSTR("feature_flags"), this->feature_flags);
   return out.c_str();
 }
 const char *MediaPlayerStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "MediaPlayerStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", static_cast<enums::MediaPlayerState>(this->state));
-  dump_field(out, "volume", this->volume);
-  dump_field(out, "muted", this->muted);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("MediaPlayerStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), static_cast<enums::MediaPlayerState>(this->state));
+  dump_field(out, ESPHOME_PSTR("volume"), this->volume);
+  dump_field(out, ESPHOME_PSTR("muted"), this->muted);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *MediaPlayerCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "MediaPlayerCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "has_command", this->has_command);
-  dump_field(out, "command", static_cast<enums::MediaPlayerCommand>(this->command));
-  dump_field(out, "has_volume", this->has_volume);
-  dump_field(out, "volume", this->volume);
-  dump_field(out, "has_media_url", this->has_media_url);
-  dump_field(out, "media_url", this->media_url);
-  dump_field(out, "has_announcement", this->has_announcement);
-  dump_field(out, "announcement", this->announcement);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("MediaPlayerCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("has_command"), this->has_command);
+  dump_field(out, ESPHOME_PSTR("command"), static_cast<enums::MediaPlayerCommand>(this->command));
+  dump_field(out, ESPHOME_PSTR("has_volume"), this->has_volume);
+  dump_field(out, ESPHOME_PSTR("volume"), this->volume);
+  dump_field(out, ESPHOME_PSTR("has_media_url"), this->has_media_url);
+  dump_field(out, ESPHOME_PSTR("media_url"), this->media_url);
+  dump_field(out, ESPHOME_PSTR("has_announcement"), this->has_announcement);
+  dump_field(out, ESPHOME_PSTR("announcement"), this->announcement);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_BLUETOOTH_PROXY
 const char *SubscribeBluetoothLEAdvertisementsRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SubscribeBluetoothLEAdvertisementsRequest");
-  dump_field(out, "flags", this->flags);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SubscribeBluetoothLEAdvertisementsRequest"));
+  dump_field(out, ESPHOME_PSTR("flags"), this->flags);
   return out.c_str();
 }
 const char *BluetoothLERawAdvertisement::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothLERawAdvertisement");
-  dump_field(out, "address", this->address);
-  dump_field(out, "rssi", this->rssi);
-  dump_field(out, "address_type", this->address_type);
-  dump_bytes_field(out, "data", this->data, this->data_len);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothLERawAdvertisement"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("rssi"), this->rssi);
+  dump_field(out, ESPHOME_PSTR("address_type"), this->address_type);
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
   return out.c_str();
 }
 const char *BluetoothLERawAdvertisementsResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothLERawAdvertisementsResponse");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothLERawAdvertisementsResponse"));
   for (uint16_t i = 0; i < this->advertisements_len; i++) {
-    out.append("  advertisements: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("advertisements")).append(": ");
     this->advertisements[i].dump_to(out);
     out.append("\n");
   }
   return out.c_str();
 }
 const char *BluetoothDeviceRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothDeviceRequest");
-  dump_field(out, "address", this->address);
-  dump_field(out, "request_type", static_cast<enums::BluetoothDeviceRequestType>(this->request_type));
-  dump_field(out, "has_address_type", this->has_address_type);
-  dump_field(out, "address_type", this->address_type);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothDeviceRequest"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("request_type"), static_cast<enums::BluetoothDeviceRequestType>(this->request_type));
+  dump_field(out, ESPHOME_PSTR("has_address_type"), this->has_address_type);
+  dump_field(out, ESPHOME_PSTR("address_type"), this->address_type);
   return out.c_str();
 }
 const char *BluetoothDeviceConnectionResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothDeviceConnectionResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "connected", this->connected);
-  dump_field(out, "mtu", this->mtu);
-  dump_field(out, "error", this->error);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothDeviceConnectionResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("connected"), this->connected);
+  dump_field(out, ESPHOME_PSTR("mtu"), this->mtu);
+  dump_field(out, ESPHOME_PSTR("error"), this->error);
   return out.c_str();
 }
 const char *BluetoothGATTGetServicesRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTGetServicesRequest");
-  dump_field(out, "address", this->address);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTGetServicesRequest"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
   return out.c_str();
 }
 const char *BluetoothGATTDescriptor::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTDescriptor");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTDescriptor"));
   for (const auto &it : this->uuid) {
-    dump_field(out, "uuid", it, 4);
+    dump_field(out, ESPHOME_PSTR("uuid"), it, 4);
   }
-  dump_field(out, "handle", this->handle);
-  dump_field(out, "short_uuid", this->short_uuid);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
+  dump_field(out, ESPHOME_PSTR("short_uuid"), this->short_uuid);
   return out.c_str();
 }
 const char *BluetoothGATTCharacteristic::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTCharacteristic");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTCharacteristic"));
   for (const auto &it : this->uuid) {
-    dump_field(out, "uuid", it, 4);
+    dump_field(out, ESPHOME_PSTR("uuid"), it, 4);
   }
-  dump_field(out, "handle", this->handle);
-  dump_field(out, "properties", this->properties);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
+  dump_field(out, ESPHOME_PSTR("properties"), this->properties);
   for (const auto &it : this->descriptors) {
-    out.append("  descriptors: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("descriptors")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
-  dump_field(out, "short_uuid", this->short_uuid);
+  dump_field(out, ESPHOME_PSTR("short_uuid"), this->short_uuid);
   return out.c_str();
 }
 const char *BluetoothGATTService::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTService");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTService"));
   for (const auto &it : this->uuid) {
-    dump_field(out, "uuid", it, 4);
+    dump_field(out, ESPHOME_PSTR("uuid"), it, 4);
   }
-  dump_field(out, "handle", this->handle);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
   for (const auto &it : this->characteristics) {
-    out.append("  characteristics: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("characteristics")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
-  dump_field(out, "short_uuid", this->short_uuid);
+  dump_field(out, ESPHOME_PSTR("short_uuid"), this->short_uuid);
   return out.c_str();
 }
 const char *BluetoothGATTGetServicesResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTGetServicesResponse");
-  dump_field(out, "address", this->address);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTGetServicesResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
   for (const auto &it : this->services) {
-    out.append("  services: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("services")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
   return out.c_str();
 }
 const char *BluetoothGATTGetServicesDoneResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTGetServicesDoneResponse");
-  dump_field(out, "address", this->address);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTGetServicesDoneResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
   return out.c_str();
 }
 const char *BluetoothGATTReadRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTReadRequest");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTReadRequest"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
   return out.c_str();
 }
 const char *BluetoothGATTReadResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTReadResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
-  dump_bytes_field(out, "data", this->data_ptr_, this->data_len_);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTReadResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data_ptr_, this->data_len_);
   return out.c_str();
 }
 const char *BluetoothGATTWriteRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTWriteRequest");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
-  dump_field(out, "response", this->response);
-  dump_bytes_field(out, "data", this->data, this->data_len);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTWriteRequest"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
+  dump_field(out, ESPHOME_PSTR("response"), this->response);
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
   return out.c_str();
 }
 const char *BluetoothGATTReadDescriptorRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTReadDescriptorRequest");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTReadDescriptorRequest"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
   return out.c_str();
 }
 const char *BluetoothGATTWriteDescriptorRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTWriteDescriptorRequest");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
-  dump_bytes_field(out, "data", this->data, this->data_len);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTWriteDescriptorRequest"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
   return out.c_str();
 }
 const char *BluetoothGATTNotifyRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTNotifyRequest");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
-  dump_field(out, "enable", this->enable);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTNotifyRequest"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
+  dump_field(out, ESPHOME_PSTR("enable"), this->enable);
   return out.c_str();
 }
 const char *BluetoothGATTNotifyDataResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTNotifyDataResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
-  dump_bytes_field(out, "data", this->data_ptr_, this->data_len_);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTNotifyDataResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data_ptr_, this->data_len_);
   return out.c_str();
 }
 const char *BluetoothConnectionsFreeResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothConnectionsFreeResponse");
-  dump_field(out, "free", this->free);
-  dump_field(out, "limit", this->limit);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothConnectionsFreeResponse"));
+  dump_field(out, ESPHOME_PSTR("free"), this->free);
+  dump_field(out, ESPHOME_PSTR("limit"), this->limit);
   for (const auto &it : this->allocated) {
-    dump_field(out, "allocated", it, 4);
+    dump_field(out, ESPHOME_PSTR("allocated"), it, 4);
   }
   return out.c_str();
 }
 const char *BluetoothGATTErrorResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTErrorResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
-  dump_field(out, "error", this->error);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTErrorResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
+  dump_field(out, ESPHOME_PSTR("error"), this->error);
   return out.c_str();
 }
 const char *BluetoothGATTWriteResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTWriteResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTWriteResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
   return out.c_str();
 }
 const char *BluetoothGATTNotifyResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothGATTNotifyResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "handle", this->handle);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothGATTNotifyResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("handle"), this->handle);
   return out.c_str();
 }
 const char *BluetoothDevicePairingResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothDevicePairingResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "paired", this->paired);
-  dump_field(out, "error", this->error);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothDevicePairingResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("paired"), this->paired);
+  dump_field(out, ESPHOME_PSTR("error"), this->error);
   return out.c_str();
 }
 const char *BluetoothDeviceUnpairingResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothDeviceUnpairingResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "success", this->success);
-  dump_field(out, "error", this->error);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothDeviceUnpairingResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("success"), this->success);
+  dump_field(out, ESPHOME_PSTR("error"), this->error);
   return out.c_str();
 }
 const char *BluetoothDeviceClearCacheResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothDeviceClearCacheResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "success", this->success);
-  dump_field(out, "error", this->error);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothDeviceClearCacheResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("success"), this->success);
+  dump_field(out, ESPHOME_PSTR("error"), this->error);
   return out.c_str();
 }
 const char *BluetoothScannerStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothScannerStateResponse");
-  dump_field(out, "state", static_cast<enums::BluetoothScannerState>(this->state));
-  dump_field(out, "mode", static_cast<enums::BluetoothScannerMode>(this->mode));
-  dump_field(out, "configured_mode", static_cast<enums::BluetoothScannerMode>(this->configured_mode));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothScannerStateResponse"));
+  dump_field(out, ESPHOME_PSTR("state"), static_cast<enums::BluetoothScannerState>(this->state));
+  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::BluetoothScannerMode>(this->mode));
+  dump_field(out, ESPHOME_PSTR("configured_mode"), static_cast<enums::BluetoothScannerMode>(this->configured_mode));
   return out.c_str();
 }
 const char *BluetoothScannerSetModeRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothScannerSetModeRequest");
-  dump_field(out, "mode", static_cast<enums::BluetoothScannerMode>(this->mode));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothScannerSetModeRequest"));
+  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::BluetoothScannerMode>(this->mode));
   return out.c_str();
 }
 #endif
 #ifdef USE_VOICE_ASSISTANT
 const char *SubscribeVoiceAssistantRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SubscribeVoiceAssistantRequest");
-  dump_field(out, "subscribe", this->subscribe);
-  dump_field(out, "flags", this->flags);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SubscribeVoiceAssistantRequest"));
+  dump_field(out, ESPHOME_PSTR("subscribe"), this->subscribe);
+  dump_field(out, ESPHOME_PSTR("flags"), this->flags);
   return out.c_str();
 }
 const char *VoiceAssistantAudioSettings::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantAudioSettings");
-  dump_field(out, "noise_suppression_level", this->noise_suppression_level);
-  dump_field(out, "auto_gain", this->auto_gain);
-  dump_field(out, "volume_multiplier", this->volume_multiplier);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantAudioSettings"));
+  dump_field(out, ESPHOME_PSTR("noise_suppression_level"), this->noise_suppression_level);
+  dump_field(out, ESPHOME_PSTR("auto_gain"), this->auto_gain);
+  dump_field(out, ESPHOME_PSTR("volume_multiplier"), this->volume_multiplier);
   return out.c_str();
 }
 const char *VoiceAssistantRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantRequest");
-  dump_field(out, "start", this->start);
-  dump_field(out, "conversation_id", this->conversation_id);
-  dump_field(out, "flags", this->flags);
-  out.append("  audio_settings: ");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantRequest"));
+  dump_field(out, ESPHOME_PSTR("start"), this->start);
+  dump_field(out, ESPHOME_PSTR("conversation_id"), this->conversation_id);
+  dump_field(out, ESPHOME_PSTR("flags"), this->flags);
+  out.append(2, ' ').append_p(ESPHOME_PSTR("audio_settings")).append(": ");
   this->audio_settings.dump_to(out);
   out.append("\n");
-  dump_field(out, "wake_word_phrase", this->wake_word_phrase);
+  dump_field(out, ESPHOME_PSTR("wake_word_phrase"), this->wake_word_phrase);
   return out.c_str();
 }
 const char *VoiceAssistantResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantResponse");
-  dump_field(out, "port", this->port);
-  dump_field(out, "error", this->error);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantResponse"));
+  dump_field(out, ESPHOME_PSTR("port"), this->port);
+  dump_field(out, ESPHOME_PSTR("error"), this->error);
   return out.c_str();
 }
 const char *VoiceAssistantEventData::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantEventData");
-  dump_field(out, "name", this->name);
-  dump_field(out, "value", this->value);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantEventData"));
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("value"), this->value);
   return out.c_str();
 }
 const char *VoiceAssistantEventResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantEventResponse");
-  dump_field(out, "event_type", static_cast<enums::VoiceAssistantEvent>(this->event_type));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantEventResponse"));
+  dump_field(out, ESPHOME_PSTR("event_type"), static_cast<enums::VoiceAssistantEvent>(this->event_type));
   for (const auto &it : this->data) {
-    out.append("  data: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("data")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
   return out.c_str();
 }
 const char *VoiceAssistantAudio::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantAudio");
-  dump_bytes_field(out, "data", this->data, this->data_len);
-  dump_field(out, "end", this->end);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantAudio"));
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
+  dump_field(out, ESPHOME_PSTR("end"), this->end);
   return out.c_str();
 }
 const char *VoiceAssistantTimerEventResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantTimerEventResponse");
-  dump_field(out, "event_type", static_cast<enums::VoiceAssistantTimerEvent>(this->event_type));
-  dump_field(out, "timer_id", this->timer_id);
-  dump_field(out, "name", this->name);
-  dump_field(out, "total_seconds", this->total_seconds);
-  dump_field(out, "seconds_left", this->seconds_left);
-  dump_field(out, "is_active", this->is_active);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantTimerEventResponse"));
+  dump_field(out, ESPHOME_PSTR("event_type"), static_cast<enums::VoiceAssistantTimerEvent>(this->event_type));
+  dump_field(out, ESPHOME_PSTR("timer_id"), this->timer_id);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("total_seconds"), this->total_seconds);
+  dump_field(out, ESPHOME_PSTR("seconds_left"), this->seconds_left);
+  dump_field(out, ESPHOME_PSTR("is_active"), this->is_active);
   return out.c_str();
 }
 const char *VoiceAssistantAnnounceRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantAnnounceRequest");
-  dump_field(out, "media_id", this->media_id);
-  dump_field(out, "text", this->text);
-  dump_field(out, "preannounce_media_id", this->preannounce_media_id);
-  dump_field(out, "start_conversation", this->start_conversation);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantAnnounceRequest"));
+  dump_field(out, ESPHOME_PSTR("media_id"), this->media_id);
+  dump_field(out, ESPHOME_PSTR("text"), this->text);
+  dump_field(out, ESPHOME_PSTR("preannounce_media_id"), this->preannounce_media_id);
+  dump_field(out, ESPHOME_PSTR("start_conversation"), this->start_conversation);
   return out.c_str();
 }
 const char *VoiceAssistantAnnounceFinished::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantAnnounceFinished");
-  dump_field(out, "success", this->success);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantAnnounceFinished"));
+  dump_field(out, ESPHOME_PSTR("success"), this->success);
   return out.c_str();
 }
 const char *VoiceAssistantWakeWord::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantWakeWord");
-  dump_field(out, "id", this->id);
-  dump_field(out, "wake_word", this->wake_word);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantWakeWord"));
+  dump_field(out, ESPHOME_PSTR("id"), this->id);
+  dump_field(out, ESPHOME_PSTR("wake_word"), this->wake_word);
   for (const auto &it : this->trained_languages) {
-    dump_field(out, "trained_languages", it, 4);
+    dump_field(out, ESPHOME_PSTR("trained_languages"), it, 4);
   }
   return out.c_str();
 }
 const char *VoiceAssistantExternalWakeWord::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantExternalWakeWord");
-  dump_field(out, "id", this->id);
-  dump_field(out, "wake_word", this->wake_word);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantExternalWakeWord"));
+  dump_field(out, ESPHOME_PSTR("id"), this->id);
+  dump_field(out, ESPHOME_PSTR("wake_word"), this->wake_word);
   for (const auto &it : this->trained_languages) {
-    dump_field(out, "trained_languages", it, 4);
+    dump_field(out, ESPHOME_PSTR("trained_languages"), it, 4);
   }
-  dump_field(out, "model_type", this->model_type);
-  dump_field(out, "model_size", this->model_size);
-  dump_field(out, "model_hash", this->model_hash);
-  dump_field(out, "url", this->url);
+  dump_field(out, ESPHOME_PSTR("model_type"), this->model_type);
+  dump_field(out, ESPHOME_PSTR("model_size"), this->model_size);
+  dump_field(out, ESPHOME_PSTR("model_hash"), this->model_hash);
+  dump_field(out, ESPHOME_PSTR("url"), this->url);
   return out.c_str();
 }
 const char *VoiceAssistantConfigurationRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantConfigurationRequest");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantConfigurationRequest"));
   for (const auto &it : this->external_wake_words) {
-    out.append("  external_wake_words: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("external_wake_words")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
   return out.c_str();
 }
 const char *VoiceAssistantConfigurationResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantConfigurationResponse");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantConfigurationResponse"));
   for (const auto &it : this->available_wake_words) {
-    out.append("  available_wake_words: ");
+    out.append(4, ' ').append_p(ESPHOME_PSTR("available_wake_words")).append(": ");
     it.dump_to(out);
     out.append("\n");
   }
   for (const auto &it : *this->active_wake_words) {
-    dump_field(out, "active_wake_words", it, 4);
+    dump_field(out, ESPHOME_PSTR("active_wake_words"), it, 4);
   }
-  dump_field(out, "max_active_wake_words", this->max_active_wake_words);
+  dump_field(out, ESPHOME_PSTR("max_active_wake_words"), this->max_active_wake_words);
   return out.c_str();
 }
 const char *VoiceAssistantSetConfiguration::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "VoiceAssistantSetConfiguration");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("VoiceAssistantSetConfiguration"));
   for (const auto &it : this->active_wake_words) {
-    dump_field(out, "active_wake_words", it, 4);
+    dump_field(out, ESPHOME_PSTR("active_wake_words"), it, 4);
   }
   return out.c_str();
 }
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
 const char *ListEntitiesAlarmControlPanelResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesAlarmControlPanelResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesAlarmControlPanelResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "supported_features", this->supported_features);
-  dump_field(out, "requires_code", this->requires_code);
-  dump_field(out, "requires_code_to_arm", this->requires_code_to_arm);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("supported_features"), this->supported_features);
+  dump_field(out, ESPHOME_PSTR("requires_code"), this->requires_code);
+  dump_field(out, ESPHOME_PSTR("requires_code_to_arm"), this->requires_code_to_arm);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *AlarmControlPanelStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "AlarmControlPanelStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", static_cast<enums::AlarmControlPanelState>(this->state));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("AlarmControlPanelStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), static_cast<enums::AlarmControlPanelState>(this->state));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *AlarmControlPanelCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "AlarmControlPanelCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "command", static_cast<enums::AlarmControlPanelStateCommand>(this->command));
-  dump_field(out, "code", this->code);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("AlarmControlPanelCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("command"), static_cast<enums::AlarmControlPanelStateCommand>(this->command));
+  dump_field(out, ESPHOME_PSTR("code"), this->code);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_TEXT
 const char *ListEntitiesTextResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesTextResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesTextResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "min_length", this->min_length);
-  dump_field(out, "max_length", this->max_length);
-  dump_field(out, "pattern", this->pattern);
-  dump_field(out, "mode", static_cast<enums::TextMode>(this->mode));
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("min_length"), this->min_length);
+  dump_field(out, ESPHOME_PSTR("max_length"), this->max_length);
+  dump_field(out, ESPHOME_PSTR("pattern"), this->pattern);
+  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::TextMode>(this->mode));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *TextStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "TextStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
-  dump_field(out, "missing_state", this->missing_state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("TextStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *TextCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "TextCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("TextCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("state"), this->state);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_DATETIME_DATE
 const char *ListEntitiesDateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesDateResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesDateResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *DateStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "DateStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "missing_state", this->missing_state);
-  dump_field(out, "year", this->year);
-  dump_field(out, "month", this->month);
-  dump_field(out, "day", this->day);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("DateStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
+  dump_field(out, ESPHOME_PSTR("year"), this->year);
+  dump_field(out, ESPHOME_PSTR("month"), this->month);
+  dump_field(out, ESPHOME_PSTR("day"), this->day);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *DateCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "DateCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "year", this->year);
-  dump_field(out, "month", this->month);
-  dump_field(out, "day", this->day);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("DateCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("year"), this->year);
+  dump_field(out, ESPHOME_PSTR("month"), this->month);
+  dump_field(out, ESPHOME_PSTR("day"), this->day);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_DATETIME_TIME
 const char *ListEntitiesTimeResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesTimeResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesTimeResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *TimeStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "TimeStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "missing_state", this->missing_state);
-  dump_field(out, "hour", this->hour);
-  dump_field(out, "minute", this->minute);
-  dump_field(out, "second", this->second);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("TimeStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
+  dump_field(out, ESPHOME_PSTR("hour"), this->hour);
+  dump_field(out, ESPHOME_PSTR("minute"), this->minute);
+  dump_field(out, ESPHOME_PSTR("second"), this->second);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *TimeCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "TimeCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "hour", this->hour);
-  dump_field(out, "minute", this->minute);
-  dump_field(out, "second", this->second);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("TimeCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("hour"), this->hour);
+  dump_field(out, ESPHOME_PSTR("minute"), this->minute);
+  dump_field(out, ESPHOME_PSTR("second"), this->second);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_EVENT
 const char *ListEntitiesEventResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesEventResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesEventResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "device_class", this->device_class);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
   for (const auto &it : *this->event_types) {
-    dump_field(out, "event_types", it, 4);
+    dump_field(out, ESPHOME_PSTR("event_types"), it, 4);
   }
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *EventResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "EventResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "event_type", this->event_type);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("EventResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("event_type"), this->event_type);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_VALVE
 const char *ListEntitiesValveResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesValveResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesValveResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "device_class", this->device_class);
-  dump_field(out, "assumed_state", this->assumed_state);
-  dump_field(out, "supports_position", this->supports_position);
-  dump_field(out, "supports_stop", this->supports_stop);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("assumed_state"), this->assumed_state);
+  dump_field(out, ESPHOME_PSTR("supports_position"), this->supports_position);
+  dump_field(out, ESPHOME_PSTR("supports_stop"), this->supports_stop);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *ValveStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ValveStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "position", this->position);
-  dump_field(out, "current_operation", static_cast<enums::ValveOperation>(this->current_operation));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ValveStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("position"), this->position);
+  dump_field(out, ESPHOME_PSTR("current_operation"), static_cast<enums::ValveOperation>(this->current_operation));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *ValveCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ValveCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "has_position", this->has_position);
-  dump_field(out, "position", this->position);
-  dump_field(out, "stop", this->stop);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ValveCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("has_position"), this->has_position);
+  dump_field(out, ESPHOME_PSTR("position"), this->position);
+  dump_field(out, ESPHOME_PSTR("stop"), this->stop);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_DATETIME_DATETIME
 const char *ListEntitiesDateTimeResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesDateTimeResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesDateTimeResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *DateTimeStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "DateTimeStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "missing_state", this->missing_state);
-  dump_field(out, "epoch_seconds", this->epoch_seconds);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("DateTimeStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
+  dump_field(out, ESPHOME_PSTR("epoch_seconds"), this->epoch_seconds);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *DateTimeCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "DateTimeCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "epoch_seconds", this->epoch_seconds);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("DateTimeCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("epoch_seconds"), this->epoch_seconds);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_UPDATE
 const char *ListEntitiesUpdateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesUpdateResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesUpdateResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  dump_field(out, "device_class", this->device_class);
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *UpdateStateResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "UpdateStateResponse");
-  dump_field(out, "key", this->key);
-  dump_field(out, "missing_state", this->missing_state);
-  dump_field(out, "in_progress", this->in_progress);
-  dump_field(out, "has_progress", this->has_progress);
-  dump_field(out, "progress", this->progress);
-  dump_field(out, "current_version", this->current_version);
-  dump_field(out, "latest_version", this->latest_version);
-  dump_field(out, "title", this->title);
-  dump_field(out, "release_summary", this->release_summary);
-  dump_field(out, "release_url", this->release_url);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("UpdateStateResponse"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
+  dump_field(out, ESPHOME_PSTR("in_progress"), this->in_progress);
+  dump_field(out, ESPHOME_PSTR("has_progress"), this->has_progress);
+  dump_field(out, ESPHOME_PSTR("progress"), this->progress);
+  dump_field(out, ESPHOME_PSTR("current_version"), this->current_version);
+  dump_field(out, ESPHOME_PSTR("latest_version"), this->latest_version);
+  dump_field(out, ESPHOME_PSTR("title"), this->title);
+  dump_field(out, ESPHOME_PSTR("release_summary"), this->release_summary);
+  dump_field(out, ESPHOME_PSTR("release_url"), this->release_url);
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 const char *UpdateCommandRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "UpdateCommandRequest");
-  dump_field(out, "key", this->key);
-  dump_field(out, "command", static_cast<enums::UpdateCommand>(this->command));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("UpdateCommandRequest"));
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("command"), static_cast<enums::UpdateCommand>(this->command));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
   return out.c_str();
 }
 #endif
 #ifdef USE_ZWAVE_PROXY
 const char *ZWaveProxyFrame::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ZWaveProxyFrame");
-  dump_bytes_field(out, "data", this->data, this->data_len);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ZWaveProxyFrame"));
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
   return out.c_str();
 }
 const char *ZWaveProxyRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ZWaveProxyRequest");
-  dump_field(out, "type", static_cast<enums::ZWaveProxyRequestType>(this->type));
-  dump_bytes_field(out, "data", this->data, this->data_len);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ZWaveProxyRequest"));
+  dump_field(out, ESPHOME_PSTR("type"), static_cast<enums::ZWaveProxyRequestType>(this->type));
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
   return out.c_str();
 }
 #endif
 #ifdef USE_INFRARED
 const char *ListEntitiesInfraredResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "ListEntitiesInfraredResponse");
-  dump_field(out, "object_id", this->object_id);
-  dump_field(out, "key", this->key);
-  dump_field(out, "name", this->name);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesInfraredResponse"));
+  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_field(out, "icon", this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
-  dump_field(out, "disabled_by_default", this->disabled_by_default);
-  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
+  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, "capabilities", this->capabilities);
+  dump_field(out, ESPHOME_PSTR("capabilities"), this->capabilities);
   return out.c_str();
 }
 #endif
 #ifdef USE_IR_RF
 const char *InfraredRFTransmitRawTimingsRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "InfraredRFTransmitRawTimingsRequest");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("InfraredRFTransmitRawTimingsRequest"));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, "key", this->key);
-  dump_field(out, "carrier_frequency", this->carrier_frequency);
-  dump_field(out, "repeat_count", this->repeat_count);
-  out.append("  timings: ");
-  out.append("packed buffer [");
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("carrier_frequency"), this->carrier_frequency);
+  dump_field(out, ESPHOME_PSTR("repeat_count"), this->repeat_count);
+  out.append(2, ' ').append_p(ESPHOME_PSTR("timings")).append(": ");
+  out.append_p(ESPHOME_PSTR("packed buffer ["));
   append_uint(out, this->timings_count_);
-  out.append(" values, ");
+  out.append_p(ESPHOME_PSTR(" values, "));
   append_uint(out, this->timings_length_);
-  out.append(" bytes]\n");
+  out.append_p(ESPHOME_PSTR(" bytes]\n"));
   return out.c_str();
 }
 const char *InfraredRFReceiveEvent::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "InfraredRFReceiveEvent");
+  MessageDumpHelper helper(out, ESPHOME_PSTR("InfraredRFReceiveEvent"));
 #ifdef USE_DEVICES
-  dump_field(out, "device_id", this->device_id);
+  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, "key", this->key);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
   for (const auto &it : *this->timings) {
-    dump_field(out, "timings", it, 4);
+    dump_field(out, ESPHOME_PSTR("timings"), it, 4);
   }
   return out.c_str();
 }
 #endif
 #ifdef USE_SERIAL_PROXY
 const char *SerialProxyConfigureRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyConfigureRequest");
-  dump_field(out, "instance", this->instance);
-  dump_field(out, "baudrate", this->baudrate);
-  dump_field(out, "flow_control", this->flow_control);
-  dump_field(out, "parity", static_cast<enums::SerialProxyParity>(this->parity));
-  dump_field(out, "stop_bits", this->stop_bits);
-  dump_field(out, "data_size", this->data_size);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyConfigureRequest"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  dump_field(out, ESPHOME_PSTR("baudrate"), this->baudrate);
+  dump_field(out, ESPHOME_PSTR("flow_control"), this->flow_control);
+  dump_field(out, ESPHOME_PSTR("parity"), static_cast<enums::SerialProxyParity>(this->parity));
+  dump_field(out, ESPHOME_PSTR("stop_bits"), this->stop_bits);
+  dump_field(out, ESPHOME_PSTR("data_size"), this->data_size);
   return out.c_str();
 }
 const char *SerialProxyDataReceived::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyDataReceived");
-  dump_field(out, "instance", this->instance);
-  dump_bytes_field(out, "data", this->data_ptr_, this->data_len_);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyDataReceived"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data_ptr_, this->data_len_);
   return out.c_str();
 }
 const char *SerialProxyWriteRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyWriteRequest");
-  dump_field(out, "instance", this->instance);
-  dump_bytes_field(out, "data", this->data, this->data_len);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyWriteRequest"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
   return out.c_str();
 }
 const char *SerialProxySetModemPinsRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxySetModemPinsRequest");
-  dump_field(out, "instance", this->instance);
-  dump_field(out, "line_states", this->line_states);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxySetModemPinsRequest"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  dump_field(out, ESPHOME_PSTR("line_states"), this->line_states);
   return out.c_str();
 }
 const char *SerialProxyGetModemPinsRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyGetModemPinsRequest");
-  dump_field(out, "instance", this->instance);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyGetModemPinsRequest"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
   return out.c_str();
 }
 const char *SerialProxyGetModemPinsResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyGetModemPinsResponse");
-  dump_field(out, "instance", this->instance);
-  dump_field(out, "line_states", this->line_states);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyGetModemPinsResponse"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  dump_field(out, ESPHOME_PSTR("line_states"), this->line_states);
   return out.c_str();
 }
 const char *SerialProxyRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyRequest");
-  dump_field(out, "instance", this->instance);
-  dump_field(out, "type", static_cast<enums::SerialProxyRequestType>(this->type));
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyRequest"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  dump_field(out, ESPHOME_PSTR("type"), static_cast<enums::SerialProxyRequestType>(this->type));
   return out.c_str();
 }
 const char *SerialProxyRequestResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyRequestResponse");
-  dump_field(out, "instance", this->instance);
-  dump_field(out, "type", static_cast<enums::SerialProxyRequestType>(this->type));
-  dump_field(out, "status", static_cast<enums::SerialProxyStatus>(this->status));
-  dump_field(out, "error_message", this->error_message);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyRequestResponse"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  dump_field(out, ESPHOME_PSTR("type"), static_cast<enums::SerialProxyRequestType>(this->type));
+  dump_field(out, ESPHOME_PSTR("status"), static_cast<enums::SerialProxyStatus>(this->status));
+  dump_field(out, ESPHOME_PSTR("error_message"), this->error_message);
   return out.c_str();
 }
 #endif
 #ifdef USE_BLUETOOTH_PROXY
 const char *BluetoothSetConnectionParamsRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothSetConnectionParamsRequest");
-  dump_field(out, "address", this->address);
-  dump_field(out, "min_interval", this->min_interval);
-  dump_field(out, "max_interval", this->max_interval);
-  dump_field(out, "latency", this->latency);
-  dump_field(out, "timeout", this->timeout);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothSetConnectionParamsRequest"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("min_interval"), this->min_interval);
+  dump_field(out, ESPHOME_PSTR("max_interval"), this->max_interval);
+  dump_field(out, ESPHOME_PSTR("latency"), this->latency);
+  dump_field(out, ESPHOME_PSTR("timeout"), this->timeout);
   return out.c_str();
 }
 const char *BluetoothSetConnectionParamsResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "BluetoothSetConnectionParamsResponse");
-  dump_field(out, "address", this->address);
-  dump_field(out, "error", this->error);
+  MessageDumpHelper helper(out, ESPHOME_PSTR("BluetoothSetConnectionParamsResponse"));
+  dump_field(out, ESPHOME_PSTR("address"), this->address);
+  dump_field(out, ESPHOME_PSTR("error"), this->error);
   return out.c_str();
 }
 #endif
diff --git a/esphome/components/api/api_pb2_service.cpp b/esphome/components/api/api_pb2_service.cpp
index d86cf912db..b41233eddd 100644
--- a/esphome/components/api/api_pb2_service.cpp
+++ b/esphome/components/api/api_pb2_service.cpp
@@ -9,8 +9,8 @@ namespace esphome::api {
 static const char *const TAG = "api.service";
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
-void APIServerConnectionBase::log_send_message_(const char *name, const char *dump) {
-  ESP_LOGVV(TAG, "send_message %s: %s", name, dump);
+void APIServerConnectionBase::log_send_message_(const LogString *name, const char *dump) {
+  ESP_LOGVV(TAG, "send_message %s: %s", LOG_STR_ARG(name), dump);
 }
 void APIServerConnectionBase::log_receive_message_(const LogString *name, const ProtoMessage &msg) {
   DumpBuffer dump_buf;
diff --git a/esphome/components/api/api_pb2_service.h b/esphome/components/api/api_pb2_service.h
index 4925a6497a..6ff988902f 100644
--- a/esphome/components/api/api_pb2_service.h
+++ b/esphome/components/api/api_pb2_service.h
@@ -12,7 +12,7 @@ class APIServerConnectionBase {
  public:
 #ifdef HAS_PROTO_MESSAGE_DUMP
  protected:
-  void log_send_message_(const char *name, const char *dump);
+  void log_send_message_(const LogString *name, const char *dump);
   void log_receive_message_(const LogString *name, const ProtoMessage &msg);
   void log_receive_message_(const LogString *name);
 
diff --git a/esphome/components/api/proto.h b/esphome/components/api/proto.h
index d6f9c947d7..95a79105a3 100644
--- a/esphome/components/api/proto.h
+++ b/esphome/components/api/proto.h
@@ -5,6 +5,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include "esphome/core/string_ref.h"
 
 #include <cassert>
@@ -400,6 +401,23 @@ class DumpBuffer {
     return *this;
   }
 
+  /// Append a PROGMEM string (flash-safe on ESP8266, regular append on other platforms)
+  DumpBuffer &append_p(const char *str) {
+    if (str) {
+#ifdef USE_ESP8266
+      append_p_esp8266(str);
+#else
+      append_impl_(str, strlen(str));
+#endif
+    }
+    return *this;
+  }
+
+#ifdef USE_ESP8266
+  /// Out-of-line ESP8266 PROGMEM append to avoid inlining strlen_P/memcpy_P at every call site
+  void append_p_esp8266(const char *str);
+#endif
+
   const char *c_str() const { return buf_; }
   size_t size() const { return pos_; }
 
@@ -445,7 +463,7 @@ class ProtoMessage {
   uint32_t calculate_size() const { return 0; }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   virtual const char *dump_to(DumpBuffer &out) const = 0;
-  virtual const char *message_name() const { return "unknown"; }
+  virtual const LogString *message_name() const { return LOG_STR("unknown"); }
 #endif
 
 #ifndef USE_HOST
diff --git a/script/api_protobuf/api_protobuf.py b/script/api_protobuf/api_protobuf.py
index 0bb569fdb5..81ea93caf4 100755
--- a/script/api_protobuf/api_protobuf.py
+++ b/script/api_protobuf/api_protobuf.py
@@ -248,7 +248,7 @@ class TypeInfo(ABC):
     @property
     def dump_content(self) -> str:
         # Default implementation - subclasses can override if they need special handling
-        return f'dump_field(out, "{self.name}", {self.dump_field_value(f"this->{self.field_name}")});'
+        return f'dump_field(out, ESPHOME_PSTR("{self.name}"), {self.dump_field_value(f"this->{self.field_name}")});'
 
     @abstractmethod
     def dump(self, name: str) -> str:
@@ -665,14 +665,14 @@ class StringType(TypeInfo):
     def dump_content(self) -> str:
         # For SOURCE_CLIENT only, use std::string
         if not self._needs_encode:
-            return f'dump_field(out, "{self.name}", this->{self.field_name});'
+            return f'dump_field(out, ESPHOME_PSTR("{self.name}"), this->{self.field_name});'
 
         # For SOURCE_SERVER, use StringRef with _ref_ suffix
         if not self._needs_decode:
-            return f'dump_field(out, "{self.name}", this->{self.field_name}_ref_);'
+            return f'dump_field(out, ESPHOME_PSTR("{self.name}"), this->{self.field_name}_ref_);'
 
         # For SOURCE_BOTH, we need custom logic
-        o = f'out.append("  {self.name}: ");\n'
+        o = f'out.append(2, \' \').append_p(ESPHOME_PSTR("{self.name}")).append(": ");\n'
         o += self.dump(f"this->{self.field_name}") + "\n"
         o += 'out.append("\\n");'
         return o
@@ -745,7 +745,7 @@ class MessageType(TypeInfo):
 
     @property
     def dump_content(self) -> str:
-        o = f'out.append("  {self.name}: ");\n'
+        o = f'out.append(2, \' \').append_p(ESPHOME_PSTR("{self.name}")).append(": ");\n'
         o += f"this->{self.field_name}.dump_to(out);\n"
         o += 'out.append("\\n");'
         return o
@@ -831,7 +831,7 @@ class BytesType(TypeInfo):
         # For SOURCE_CLIENT only, always use std::string
         if not self._needs_encode:
             return (
-                f'dump_bytes_field(out, "{self.name}", '
+                f'dump_bytes_field(out, ESPHOME_PSTR("{self.name}"), '
                 f"reinterpret_cast<const uint8_t*>(this->{self.field_name}.data()), "
                 f"this->{self.field_name}.size());"
             )
@@ -839,17 +839,17 @@ class BytesType(TypeInfo):
         # For SOURCE_SERVER, always use pointer/length
         if not self._needs_decode:
             return (
-                f'dump_bytes_field(out, "{self.name}", '
+                f'dump_bytes_field(out, ESPHOME_PSTR("{self.name}"), '
                 f"this->{self.field_name}_ptr_, this->{self.field_name}_len_);"
             )
 
         # For SOURCE_BOTH, check if pointer is set (sending) or use string (received)
         return (
             f"if (this->{self.field_name}_ptr_ != nullptr) {{\n"
-            f'  dump_bytes_field(out, "{self.name}", '
+            f'  dump_bytes_field(out, ESPHOME_PSTR("{self.name}"), '
             f"this->{self.field_name}_ptr_, this->{self.field_name}_len_);\n"
             f"}} else {{\n"
-            f'  dump_bytes_field(out, "{self.name}", '
+            f'  dump_bytes_field(out, ESPHOME_PSTR("{self.name}"), '
             f"reinterpret_cast<const uint8_t*>(this->{self.field_name}.data()), "
             f"this->{self.field_name}.size());\n"
             f"}}"
@@ -928,7 +928,7 @@ class PointerToBytesBufferType(PointerToBufferTypeBase):
     @property
     def dump_content(self) -> str:
         return (
-            f'dump_bytes_field(out, "{self.name}", '
+            f'dump_bytes_field(out, ESPHOME_PSTR("{self.name}"), '
             f"this->{self.field_name}, this->{self.field_name}_len);"
         )
 
@@ -976,7 +976,7 @@ class PointerToStringBufferType(PointerToBufferTypeBase):
 
     @property
     def dump_content(self) -> str:
-        return f'dump_field(out, "{self.name}", this->{self.field_name});'
+        return f'dump_field(out, ESPHOME_PSTR("{self.name}"), this->{self.field_name});'
 
     def get_size_calculation(self, name: str, force: bool = False) -> str:
         return f"size += ProtoSize::calc_length({self.calculate_field_id_size()}, this->{self.field_name}.size());"
@@ -1036,12 +1036,12 @@ class PackedBufferTypeInfo(TypeInfo):
     def dump_content(self) -> str:
         """Dump shows buffer info but not decoded values."""
         return (
-            f'out.append("  {self.name}: ");\n'
-            + 'out.append("packed buffer [");\n'
+            f'out.append(2, \' \').append_p(ESPHOME_PSTR("{self.name}")).append(": ");\n'
+            + 'out.append_p(ESPHOME_PSTR("packed buffer ["));\n'
             + f"append_uint(out, this->{self.field_name}_count_);\n"
-            + 'out.append(" values, ");\n'
+            + 'out.append_p(ESPHOME_PSTR(" values, "));\n'
             + f"append_uint(out, this->{self.field_name}_length_);\n"
-            + 'out.append(" bytes]\\n");'
+            + 'out.append_p(ESPHOME_PSTR(" bytes]\\n"));'
         )
 
     def dump(self, name: str) -> str:
@@ -1134,7 +1134,7 @@ class FixedArrayBytesType(TypeInfo):
     @property
     def dump_content(self) -> str:
         return (
-            f'dump_bytes_field(out, "{self.name}", '
+            f'dump_bytes_field(out, ESPHOME_PSTR("{self.name}"), '
             f"this->{self.field_name}, this->{self.field_name}_len);"
         )
 
@@ -1204,7 +1204,7 @@ class EnumType(TypeInfo):
         return f"buffer.{self.encode_func}({self.number}, static_cast<uint32_t>(this->{self.field_name}));"
 
     def dump(self, name: str) -> str:
-        return f"out.append(proto_enum_to_string<{self.cpp_type}>({name}));"
+        return f"out.append_p(proto_enum_to_string<{self.cpp_type}>({name}));"
 
     def dump_field_value(self, value: str) -> str:
         # Enums need explicit cast for the template
@@ -1326,15 +1326,15 @@ def _generate_array_dump_content(
     # Check if underlying type can use dump_field
     if is_const_char_ptr:
         # Special case for const char* - use it directly
-        o += f'  dump_field(out, "{name}", it, 4);\n'
+        o += f'  dump_field(out, ESPHOME_PSTR("{name}"), it, 4);\n'
     elif ti.can_use_dump_field():
         # For types that have dump_field overloads, use them with extra indent
         # std::vector<bool> iterators return proxy objects, need explicit cast
         value_expr = "static_cast<bool>(it)" if is_bool else ti.dump_field_value("it")
-        o += f'  dump_field(out, "{name}", {value_expr}, 4);\n'
+        o += f'  dump_field(out, ESPHOME_PSTR("{name}"), {value_expr}, 4);\n'
     else:
         # For complex types (messages, bytes), use the old pattern
-        o += f'  out.append("  {name}: ");\n'
+        o += f'  out.append(4, \' \').append_p(ESPHOME_PSTR("{name}")).append(": ");\n'
         o += indent(ti.dump("it")) + "\n"
         o += '  out.append("\\n");\n'
     o += "}"
@@ -1543,9 +1543,9 @@ class FixedArrayWithLengthRepeatedType(FixedArrayRepeatedType):
         o = f"for (uint16_t i = 0; i < this->{self.field_name}_len; i++) {{\n"
         # Check if underlying type can use dump_field
         if self._ti.can_use_dump_field():
-            o += f'  dump_field(out, "{self.name}", {self._ti.dump_field_value(f"this->{self.field_name}[i]")}, 4);\n'
+            o += f'  dump_field(out, ESPHOME_PSTR("{self.name}"), {self._ti.dump_field_value(f"this->{self.field_name}[i]")}, 4);\n'
         else:
-            o += f'  out.append("  {self.name}: ");\n'
+            o += f'  out.append(4, \' \').append_p(ESPHOME_PSTR("{self.name}")).append(": ");\n'
             o += indent(self._ti.dump(f"this->{self.field_name}[i]")) + "\n"
             o += '  out.append("\\n");\n'
         o += "}"
@@ -2023,9 +2023,9 @@ def build_enum_type(desc, enum_ifdef_map) -> tuple[str, str, str]:
     dump_cpp += "  switch (value) {\n"
     for v in desc.value:
         dump_cpp += f"    case enums::{v.name}:\n"
-        dump_cpp += f'      return "{v.name}";\n'
+        dump_cpp += f'      return ESPHOME_PSTR("{v.name}");\n'
     dump_cpp += "    default:\n"
-    dump_cpp += '      return "UNKNOWN";\n'
+    dump_cpp += '      return ESPHOME_PSTR("UNKNOWN");\n'
     dump_cpp += "  }\n"
     dump_cpp += "}\n"
 
@@ -2107,7 +2107,7 @@ def build_message_type(
         public_content.append("#ifdef HAS_PROTO_MESSAGE_DUMP")
         snake_name = camel_to_snake(desc.name)
         public_content.append(
-            f'const char *message_name() const override {{ return "{snake_name}"; }}'
+            f'const LogString *message_name() const override {{ return LOG_STR("{snake_name}"); }}'
         )
         public_content.append("#endif")
 
@@ -2315,12 +2315,12 @@ def build_message_type(
     if dump:
         # Always use MessageDumpHelper for consistent output formatting
         dump_impl += "\n"
-        dump_impl += f'  MessageDumpHelper helper(out, "{desc.name}");\n'
+        dump_impl += f'  MessageDumpHelper helper(out, ESPHOME_PSTR("{desc.name}"));\n'
         dump_impl += indent("\n".join(dump)) + "\n"
         dump_impl += "  return out.c_str();\n"
     else:
         dump_impl += "\n"
-        dump_impl += f'  out.append("{desc.name} {{}}");\n'
+        dump_impl += f'  out.append_p(ESPHOME_PSTR("{desc.name} {{}}"));\n'
         dump_impl += "  return out.c_str();\n"
     dump_impl += "}\n"
 
@@ -2707,6 +2707,7 @@ namespace esphome::api {
     dump_cpp += """\
 #include "api_pb2.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/progmem.h"
 
 #include <cinttypes>
 
@@ -2714,6 +2715,21 @@ namespace esphome::api {
 
 namespace esphome::api {
 
+#ifdef USE_ESP8266
+// Out-of-line to avoid inlining strlen_P/memcpy_P at every call site
+void DumpBuffer::append_p_esp8266(const char *str) {
+  size_t len = strlen_P(str);
+  size_t space = CAPACITY - 1 - pos_;
+  if (len > space)
+    len = space;
+  if (len > 0) {
+    memcpy_P(buf_ + pos_, str, len);
+    pos_ += len;
+    buf_[pos_] = '\\0';
+  }
+}
+#endif
+
 // Helper function to append a quoted string, handling empty StringRef
 static inline void append_quoted_string(DumpBuffer &out, const StringRef &ref) {
   out.append("'");
@@ -2724,8 +2740,9 @@ static inline void append_quoted_string(DumpBuffer &out, const StringRef &ref) {
 }
 
 // Common helpers for dump_field functions
+// field_name is a PROGMEM pointer (flash on ESP8266, regular pointer on other platforms)
 static inline void append_field_prefix(DumpBuffer &out, const char *field_name, int indent) {
-  out.append(indent, ' ').append(field_name).append(": ");
+  out.append(indent, ' ').append_p(field_name).append(": ");
 }
 
 static inline void append_uint(DumpBuffer &out, uint32_t value) {
@@ -2733,10 +2750,11 @@ static inline void append_uint(DumpBuffer &out, uint32_t value) {
 }
 
 // RAII helper for message dump formatting
+// message_name is a PROGMEM pointer (flash on ESP8266, regular pointer on other platforms)
 class MessageDumpHelper {
  public:
   MessageDumpHelper(DumpBuffer &out, const char *message_name) : out_(out) {
-    out_.append(message_name);
+    out_.append_p(message_name);
     out_.append(" {\\n");
   }
   ~MessageDumpHelper() { out_.append(" }"); }
@@ -2746,6 +2764,10 @@ class MessageDumpHelper {
 };
 
 // Helper functions to reduce code duplication in dump methods
+// field_name parameters are PROGMEM pointers (flash on ESP8266, regular pointers on other platforms)
+// Not all overloads are used in every build (depends on enabled components)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
 static void dump_field(DumpBuffer &out, const char *field_name, int32_t value, int indent = 2) {
   append_field_prefix(out, field_name, indent);
   out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRId32 "\\n", value));
@@ -2790,21 +2812,23 @@ static void dump_field(DumpBuffer &out, const char *field_name, const char *valu
   out.append("\\n");
 }
 
-template<typename T>
-static void dump_field(DumpBuffer &out, const char *field_name, T value, int indent = 2) {
+// proto_enum_to_string returns PROGMEM pointers, so use append_p
+template<typename T> static void dump_field(DumpBuffer &out, const char *field_name, T value, int indent = 2) {
   append_field_prefix(out, field_name, indent);
-  out.append(proto_enum_to_string<T>(value));
+  out.append_p(proto_enum_to_string<T>(value));
   out.append("\\n");
 }
 
 // Helper for bytes fields - uses stack buffer to avoid heap allocation
 // Buffer sized for 160 bytes of data (480 chars with separators) to fit typical log buffer
+// field_name is a PROGMEM pointer (flash on ESP8266, regular pointer on other platforms)
 static void dump_bytes_field(DumpBuffer &out, const char *field_name, const uint8_t *data, size_t len, int indent = 2) {
   char hex_buf[format_hex_pretty_size(160)];
   append_field_prefix(out, field_name, indent);
   format_hex_pretty_to(hex_buf, data, len);
   out.append(hex_buf).append("\\n");
 }
+#pragma GCC diagnostic pop
 
 """
 
@@ -2977,7 +3001,7 @@ static const char *const TAG = "api.service";
     # Add logging helper method declarations
     hpp += "#ifdef HAS_PROTO_MESSAGE_DUMP\n"
     hpp += " protected:\n"
-    hpp += "  void log_send_message_(const char *name, const char *dump);\n"
+    hpp += "  void log_send_message_(const LogString *name, const char *dump);\n"
     hpp += (
         "  void log_receive_message_(const LogString *name, const ProtoMessage &msg);\n"
     )
@@ -2990,10 +3014,8 @@ static const char *const TAG = "api.service";
 
     # Add logging helper method implementations to cpp
     cpp += "#ifdef HAS_PROTO_MESSAGE_DUMP\n"
-    cpp += (
-        f"void {class_name}::log_send_message_(const char *name, const char *dump) {{\n"
-    )
-    cpp += '  ESP_LOGVV(TAG, "send_message %s: %s", name, dump);\n'
+    cpp += f"void {class_name}::log_send_message_(const LogString *name, const char *dump) {{\n"
+    cpp += '  ESP_LOGVV(TAG, "send_message %s: %s", LOG_STR_ARG(name), dump);\n'
     cpp += "}\n"
     cpp += f"void {class_name}::log_receive_message_(const LogString *name, const ProtoMessage &msg) {{\n"
     cpp += "  DumpBuffer dump_buf;\n"

From 13d3968d9b9220fd777b953aac8efbbba1819013 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 23 Mar 2026 13:41:09 -1000
Subject: [PATCH 60/60] [api] Avoid heap allocation in PSK update timeout
 lambda (#14921)

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 esphome/components/api/api_server.cpp | 28 ++++++++++++++++++---------
 esphome/components/api/api_server.h   |  4 +++-
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/esphome/components/api/api_server.cpp b/esphome/components/api/api_server.cpp
index 17d69405ad..1151bc5983 100644
--- a/esphome/components/api/api_server.cpp
+++ b/esphome/components/api/api_server.cpp
@@ -46,10 +46,8 @@ void APIServer::setup() {
 
 #ifndef USE_API_NOISE_PSK_FROM_YAML
   // Only load saved PSK if not set from YAML
-  SavedNoisePsk noise_pref_saved{};
-  if (this->noise_pref_.load(&noise_pref_saved)) {
+  if (this->load_and_apply_noise_psk_()) {
     ESP_LOGD(TAG, "Loaded saved Noise PSK");
-    this->set_noise_psk(noise_pref_saved.psk);
   }
 #endif
 #endif
@@ -514,7 +512,7 @@ void APIServer::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeo
 
 #ifdef USE_API_NOISE
 bool APIServer::update_noise_psk_(const SavedNoisePsk &new_psk, const LogString *save_log_msg,
-                                  const LogString *fail_log_msg, const psk_t &active_psk, bool make_active) {
+                                  const LogString *fail_log_msg, bool make_active) {
   if (!this->noise_pref_.save(&new_psk)) {
     ESP_LOGW(TAG, "%s", LOG_STR_ARG(fail_log_msg));
     return false;
@@ -526,9 +524,14 @@ bool APIServer::update_noise_psk_(const SavedNoisePsk &new_psk, const LogString
   }
   ESP_LOGD(TAG, "%s", LOG_STR_ARG(save_log_msg));
   if (make_active) {
-    this->set_timeout(100, [this, active_psk]() {
+    this->set_timeout(100, [this]() {
+      // Re-read the PSK from preferences rather than capturing the 32-byte array
+      // in the lambda (which would exceed std::function SBO and heap-allocate).
+      if (!this->load_and_apply_noise_psk_()) {
+        ESP_LOGW(TAG, "Failed to load saved PSK for activation");
+        return;
+      }
       ESP_LOGW(TAG, "Disconnecting all clients to reset PSK");
-      this->set_noise_psk(active_psk);
       for (auto &c : this->clients_) {
         DisconnectRequest req;
         c->send_message(req);
@@ -538,6 +541,14 @@ bool APIServer::update_noise_psk_(const SavedNoisePsk &new_psk, const LogString
   return true;
 }
 
+bool APIServer::load_and_apply_noise_psk_() {
+  SavedNoisePsk saved{};
+  if (!this->noise_pref_.load(&saved))
+    return false;
+  this->set_noise_psk(saved.psk);
+  return true;
+}
+
 bool APIServer::save_noise_psk(psk_t psk, bool make_active) {
 #ifdef USE_API_NOISE_PSK_FROM_YAML
   // When PSK is set from YAML, this function should never be called
@@ -552,7 +563,7 @@ bool APIServer::save_noise_psk(psk_t psk, bool make_active) {
   }
 
   SavedNoisePsk new_saved_psk{psk};
-  return this->update_noise_psk_(new_saved_psk, LOG_STR("Noise PSK saved"), LOG_STR("Failed to save Noise PSK"), psk,
+  return this->update_noise_psk_(new_saved_psk, LOG_STR("Noise PSK saved"), LOG_STR("Failed to save Noise PSK"),
                                  make_active);
 #endif
 }
@@ -564,8 +575,7 @@ bool APIServer::clear_noise_psk(bool make_active) {
   return false;
 #else
   SavedNoisePsk empty_psk{};
-  psk_t empty{};
-  return this->update_noise_psk_(empty_psk, LOG_STR("Noise PSK cleared"), LOG_STR("Failed to clear Noise PSK"), empty,
+  return this->update_noise_psk_(empty_psk, LOG_STR("Noise PSK cleared"), LOG_STR("Failed to clear Noise PSK"),
                                  make_active);
 #endif
 }
diff --git a/esphome/components/api/api_server.h b/esphome/components/api/api_server.h
index ccba6deb00..65076879a2 100644
--- a/esphome/components/api/api_server.h
+++ b/esphome/components/api/api_server.h
@@ -239,7 +239,9 @@ class APIServer final : public Component,
 
 #ifdef USE_API_NOISE
   bool update_noise_psk_(const SavedNoisePsk &new_psk, const LogString *save_log_msg, const LogString *fail_log_msg,
-                         const psk_t &active_psk, bool make_active);
+                         bool make_active);
+  // Load saved PSK from preferences and apply it. Returns true on success.
+  bool load_and_apply_noise_psk_();
 #endif  // USE_API_NOISE
 #ifdef USE_API_HOMEASSISTANT_STATES
   // Helper methods to reduce code duplication