From 7f1a9a611f7cb8d5d8d17b7b096eeb5595cc8957 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 25 Nov 2025 02:09:02 +0000
Subject: [PATCH 01/26] Bump aioesphomeapi from 42.7.0 to 42.8.0 (#12092)

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 df036eeccc..a5c919e95f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -12,7 +12,7 @@ platformio==6.1.18  # When updating platformio, also update /docker/Dockerfile
 esptool==5.1.0
 click==8.1.7
 esphome-dashboard==20251013.0
-aioesphomeapi==42.7.0
+aioesphomeapi==42.8.0
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.18.16 # dashboard_import

From 2bc8a4a77980493101aa66f089d9f213d8f5213b Mon Sep 17 00:00:00 2001
From: Keith Burzinski <kbx81x@gmail.com>
Date: Mon, 24 Nov 2025 20:23:10 -0600
Subject: [PATCH 02/26] [wifi_info] Use callbacks instead of polling (#10748)

Co-authored-by: J. Nick Koston <nick+github@koston.org>
---
 esphome/components/wifi/__init__.py           |  14 ++
 esphome/components/wifi/automation.h          | 116 +++++++++++++++
 esphome/components/wifi/wifi_component.cpp    |   6 +-
 esphome/components/wifi/wifi_component.h      | 138 ++++--------------
 .../wifi/wifi_component_esp8266.cpp           |  22 ++-
 .../wifi/wifi_component_esp_idf.cpp           |  22 ++-
 .../wifi/wifi_component_libretiny.cpp         |  23 ++-
 .../components/wifi/wifi_component_pico_w.cpp |  61 +++++++-
 esphome/components/wifi_info/text_sensor.py   |  37 +++--
 .../wifi_info/wifi_info_text_sensor.cpp       | 119 ++++++++++++++-
 .../wifi_info/wifi_info_text_sensor.h         | 102 +++----------
 esphome/core/defines.h                        |   1 +
 12 files changed, 417 insertions(+), 244 deletions(-)
 create mode 100644 esphome/components/wifi/automation.h

diff --git a/esphome/components/wifi/__init__.py b/esphome/components/wifi/__init__.py
index 8a5e5329f1..31d9ca0f70 100644
--- a/esphome/components/wifi/__init__.py
+++ b/esphome/components/wifi/__init__.py
@@ -608,6 +608,7 @@ async def wifi_disable_to_code(config, action_id, template_arg, args):
 
 KEEP_SCAN_RESULTS_KEY = "wifi_keep_scan_results"
 RUNTIME_POWER_SAVE_KEY = "wifi_runtime_power_save"
+WIFI_CALLBACKS_KEY = "wifi_callbacks"
 
 
 def request_wifi_scan_results():
@@ -633,6 +634,17 @@ def enable_runtime_power_save_control():
     CORE.data[RUNTIME_POWER_SAVE_KEY] = True
 
 
+def request_wifi_callbacks() -> None:
+    """Request that WiFi callbacks be compiled in.
+
+    Components that need to be notified about WiFi state changes (IP address changes,
+    scan results, connection state) should call this function during their code generation.
+    This enables the add_on_ip_state_callback(), add_on_wifi_scan_state_callback(),
+    and add_on_wifi_connect_state_callback() APIs.
+    """
+    CORE.data[WIFI_CALLBACKS_KEY] = True
+
+
 @coroutine_with_priority(CoroPriority.FINAL)
 async def final_step():
     """Final code generation step to configure optional WiFi features."""
@@ -642,6 +654,8 @@ async def final_step():
         )
     if CORE.data.get(RUNTIME_POWER_SAVE_KEY, False):
         cg.add_define("USE_WIFI_RUNTIME_POWER_SAVE")
+    if CORE.data.get(WIFI_CALLBACKS_KEY, False):
+        cg.add_define("USE_WIFI_CALLBACKS")
 
 
 @automation.register_action(
diff --git a/esphome/components/wifi/automation.h b/esphome/components/wifi/automation.h
new file mode 100644
index 0000000000..7997baff65
--- /dev/null
+++ b/esphome/components/wifi/automation.h
@@ -0,0 +1,116 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_WIFI
+#include "wifi_component.h"
+
+namespace esphome::wifi {
+
+template<typename... Ts> class WiFiConnectedCondition : public Condition<Ts...> {
+ public:
+  bool check(const Ts &...x) override { return global_wifi_component->is_connected(); }
+};
+
+template<typename... Ts> class WiFiEnabledCondition : public Condition<Ts...> {
+ public:
+  bool check(const Ts &...x) override { return !global_wifi_component->is_disabled(); }
+};
+
+template<typename... Ts> class WiFiAPActiveCondition : public Condition<Ts...> {
+ public:
+  bool check(const Ts &...x) override { return global_wifi_component->is_ap_active(); }
+};
+
+template<typename... Ts> class WiFiEnableAction : public Action<Ts...> {
+ public:
+  void play(const Ts &...x) override { global_wifi_component->enable(); }
+};
+
+template<typename... Ts> class WiFiDisableAction : public Action<Ts...> {
+ public:
+  void play(const Ts &...x) override { global_wifi_component->disable(); }
+};
+
+template<typename... Ts> class WiFiConfigureAction : public Action<Ts...>, public Component {
+ public:
+  TEMPLATABLE_VALUE(std::string, ssid)
+  TEMPLATABLE_VALUE(std::string, password)
+  TEMPLATABLE_VALUE(bool, save)
+  TEMPLATABLE_VALUE(uint32_t, connection_timeout)
+
+  void play(const Ts &...x) override {
+    auto ssid = this->ssid_.value(x...);
+    auto password = this->password_.value(x...);
+    // Avoid multiple calls
+    if (this->connecting_)
+      return;
+    // If already connected to the same AP, do nothing
+    if (global_wifi_component->wifi_ssid() == ssid) {
+      // Callback to notify the user that the connection was successful
+      this->connect_trigger_->trigger();
+      return;
+    }
+    // Create a new WiFiAP object with the new SSID and password
+    this->new_sta_.set_ssid(ssid);
+    this->new_sta_.set_password(password);
+    // Save the current STA
+    this->old_sta_ = global_wifi_component->get_sta();
+    // Disable WiFi
+    global_wifi_component->disable();
+    // Set the state to connecting
+    this->connecting_ = true;
+    // Store the new STA so once the WiFi is enabled, it will connect to it
+    // This is necessary because the WiFiComponent will raise an error and fallback to the saved STA
+    // if trying to connect to a new STA while already connected to another one
+    if (this->save_.value(x...)) {
+      global_wifi_component->save_wifi_sta(new_sta_.get_ssid(), new_sta_.get_password());
+    } else {
+      global_wifi_component->set_sta(new_sta_);
+    }
+    // Enable WiFi
+    global_wifi_component->enable();
+    // Set timeout for the connection
+    this->set_timeout("wifi-connect-timeout", this->connection_timeout_.value(x...), [this, x...]() {
+      // If the timeout is reached, stop connecting and revert to the old AP
+      global_wifi_component->disable();
+      global_wifi_component->save_wifi_sta(old_sta_.get_ssid(), old_sta_.get_password());
+      global_wifi_component->enable();
+      // Start a timeout for the fallback if the connection to the old AP fails
+      this->set_timeout("wifi-fallback-timeout", this->connection_timeout_.value(x...), [this]() {
+        this->connecting_ = false;
+        this->error_trigger_->trigger();
+      });
+    });
+  }
+
+  Trigger<> *get_connect_trigger() const { return this->connect_trigger_; }
+  Trigger<> *get_error_trigger() const { return this->error_trigger_; }
+
+  void loop() override {
+    if (!this->connecting_)
+      return;
+    if (global_wifi_component->is_connected()) {
+      // The WiFi is connected, stop the timeout and reset the connecting flag
+      this->cancel_timeout("wifi-connect-timeout");
+      this->cancel_timeout("wifi-fallback-timeout");
+      this->connecting_ = false;
+      if (global_wifi_component->wifi_ssid() == this->new_sta_.get_ssid()) {
+        // Callback to notify the user that the connection was successful
+        this->connect_trigger_->trigger();
+      } else {
+        // Callback to notify the user that the connection failed
+        this->error_trigger_->trigger();
+      }
+    }
+  }
+
+ protected:
+  bool connecting_{false};
+  WiFiAP new_sta_;
+  WiFiAP old_sta_;
+  Trigger<> *connect_trigger_{new Trigger<>()};
+  Trigger<> *error_trigger_{new Trigger<>()};
+};
+
+}  // namespace esphome::wifi
+#endif
diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp
index 41931a7785..d53de83bd3 100644
--- a/esphome/components/wifi/wifi_component.cpp
+++ b/esphome/components/wifi/wifi_component.cpp
@@ -37,8 +37,7 @@
 #include "esphome/components/esp32_improv/esp32_improv_component.h"
 #endif
 
-namespace esphome {
-namespace wifi {
+namespace esphome::wifi {
 
 static const char *const TAG = "wifi";
 
@@ -1813,6 +1812,5 @@ bool WiFiScanResult::operator==(const WiFiScanResult &rhs) const { return this->
 
 WiFiComponent *global_wifi_component;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-}  // namespace wifi
-}  // namespace esphome
+}  // namespace esphome::wifi
 #endif
diff --git a/esphome/components/wifi/wifi_component.h b/esphome/components/wifi/wifi_component.h
index 0dac80ad21..b6b956a12d 100644
--- a/esphome/components/wifi/wifi_component.h
+++ b/esphome/components/wifi/wifi_component.h
@@ -54,8 +54,7 @@ extern "C" {
 #include <freertos/semphr.h>
 #endif
 
-namespace esphome {
-namespace wifi {
+namespace esphome::wifi {
 
 /// Sentinel value for RSSI when WiFi is not connected
 static constexpr int8_t WIFI_RSSI_DISCONNECTED = -127;
@@ -370,6 +369,27 @@ class WiFiComponent : public Component {
 
   int32_t get_wifi_channel();
 
+#ifdef USE_WIFI_CALLBACKS
+  /// Add a callback that will be called on configuration changes (IP change, SSID change, etc.)
+  /// @param callback The callback to be called; template arguments are:
+  /// - IP addresses
+  /// - DNS address 1
+  /// - DNS address 2
+  void add_on_ip_state_callback(
+      std::function<void(network::IPAddresses, network::IPAddress, network::IPAddress)> &&callback) {
+    this->ip_state_callback_.add(std::move(callback));
+  }
+  /// - Wi-Fi scan results
+  void add_on_wifi_scan_state_callback(std::function<void(wifi_scan_vector_t<WiFiScanResult> &)> &&callback) {
+    this->wifi_scan_state_callback_.add(std::move(callback));
+  }
+  /// - Wi-Fi SSID
+  /// - Wi-Fi BSSID
+  void add_on_wifi_connect_state_callback(std::function<void(std::string, wifi::bssid_t)> &&callback) {
+    this->wifi_connect_state_callback_.add(std::move(callback));
+  }
+#endif  // USE_WIFI_CALLBACKS
+
 #ifdef USE_WIFI_RUNTIME_POWER_SAVE
   /** Request high-performance mode (no power saving) for improved WiFi latency.
    *
@@ -526,6 +546,11 @@ class WiFiComponent : public Component {
   WiFiAP ap_;
 #endif
   optional<float> output_power_;
+#ifdef USE_WIFI_CALLBACKS
+  CallbackManager<void(network::IPAddresses, network::IPAddress, network::IPAddress)> ip_state_callback_;
+  CallbackManager<void(wifi_scan_vector_t<WiFiScanResult> &)> wifi_scan_state_callback_;
+  CallbackManager<void(std::string, wifi::bssid_t)> wifi_connect_state_callback_;
+#endif  // USE_WIFI_CALLBACKS
   ESPPreferenceObject pref_;
 #ifdef USE_WIFI_FAST_CONNECT
   ESPPreferenceObject fast_connect_pref_;
@@ -590,112 +615,5 @@ class WiFiComponent : public Component {
 
 extern WiFiComponent *global_wifi_component;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-template<typename... Ts> class WiFiConnectedCondition : public Condition<Ts...> {
- public:
-  bool check(const Ts &...x) override { return global_wifi_component->is_connected(); }
-};
-
-template<typename... Ts> class WiFiEnabledCondition : public Condition<Ts...> {
- public:
-  bool check(const Ts &...x) override { return !global_wifi_component->is_disabled(); }
-};
-
-template<typename... Ts> class WiFiAPActiveCondition : public Condition<Ts...> {
- public:
-  bool check(const Ts &...x) override { return global_wifi_component->is_ap_active(); }
-};
-
-template<typename... Ts> class WiFiEnableAction : public Action<Ts...> {
- public:
-  void play(const Ts &...x) override { global_wifi_component->enable(); }
-};
-
-template<typename... Ts> class WiFiDisableAction : public Action<Ts...> {
- public:
-  void play(const Ts &...x) override { global_wifi_component->disable(); }
-};
-
-template<typename... Ts> class WiFiConfigureAction : public Action<Ts...>, public Component {
- public:
-  TEMPLATABLE_VALUE(std::string, ssid)
-  TEMPLATABLE_VALUE(std::string, password)
-  TEMPLATABLE_VALUE(bool, save)
-  TEMPLATABLE_VALUE(uint32_t, connection_timeout)
-
-  void play(const Ts &...x) override {
-    auto ssid = this->ssid_.value(x...);
-    auto password = this->password_.value(x...);
-    // Avoid multiple calls
-    if (this->connecting_)
-      return;
-    // If already connected to the same AP, do nothing
-    if (global_wifi_component->wifi_ssid() == ssid) {
-      // Callback to notify the user that the connection was successful
-      this->connect_trigger_->trigger();
-      return;
-    }
-    // Create a new WiFiAP object with the new SSID and password
-    this->new_sta_.set_ssid(ssid);
-    this->new_sta_.set_password(password);
-    // Save the current STA
-    this->old_sta_ = global_wifi_component->get_sta();
-    // Disable WiFi
-    global_wifi_component->disable();
-    // Set the state to connecting
-    this->connecting_ = true;
-    // Store the new STA so once the WiFi is enabled, it will connect to it
-    // This is necessary because the WiFiComponent will raise an error and fallback to the saved STA
-    // if trying to connect to a new STA while already connected to another one
-    if (this->save_.value(x...)) {
-      global_wifi_component->save_wifi_sta(new_sta_.get_ssid(), new_sta_.get_password());
-    } else {
-      global_wifi_component->set_sta(new_sta_);
-    }
-    // Enable WiFi
-    global_wifi_component->enable();
-    // Set timeout for the connection
-    this->set_timeout("wifi-connect-timeout", this->connection_timeout_.value(x...), [this, x...]() {
-      // If the timeout is reached, stop connecting and revert to the old AP
-      global_wifi_component->disable();
-      global_wifi_component->save_wifi_sta(old_sta_.get_ssid(), old_sta_.get_password());
-      global_wifi_component->enable();
-      // Start a timeout for the fallback if the connection to the old AP fails
-      this->set_timeout("wifi-fallback-timeout", this->connection_timeout_.value(x...), [this]() {
-        this->connecting_ = false;
-        this->error_trigger_->trigger();
-      });
-    });
-  }
-
-  Trigger<> *get_connect_trigger() const { return this->connect_trigger_; }
-  Trigger<> *get_error_trigger() const { return this->error_trigger_; }
-
-  void loop() override {
-    if (!this->connecting_)
-      return;
-    if (global_wifi_component->is_connected()) {
-      // The WiFi is connected, stop the timeout and reset the connecting flag
-      this->cancel_timeout("wifi-connect-timeout");
-      this->cancel_timeout("wifi-fallback-timeout");
-      this->connecting_ = false;
-      if (global_wifi_component->wifi_ssid() == this->new_sta_.get_ssid()) {
-        // Callback to notify the user that the connection was successful
-        this->connect_trigger_->trigger();
-      } else {
-        // Callback to notify the user that the connection failed
-        this->error_trigger_->trigger();
-      }
-    }
-  }
-
- protected:
-  bool connecting_{false};
-  WiFiAP new_sta_;
-  WiFiAP old_sta_;
-  Trigger<> *connect_trigger_{new Trigger<>()};
-  Trigger<> *error_trigger_{new Trigger<>()};
-};
-
-}  // namespace wifi
-}  // namespace esphome
+}  // namespace esphome::wifi
 #endif
diff --git a/esphome/components/wifi/wifi_component_esp8266.cpp b/esphome/components/wifi/wifi_component_esp8266.cpp
index 274a505db2..540ad3a585 100644
--- a/esphome/components/wifi/wifi_component_esp8266.cpp
+++ b/esphome/components/wifi/wifi_component_esp8266.cpp
@@ -38,8 +38,7 @@ extern "C" {
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
-namespace esphome {
-namespace wifi {
+namespace esphome::wifi {
 
 static const char *const TAG = "wifi_esp8266";
 
@@ -514,6 +513,10 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       ESP_LOGV(TAG, "Connected ssid='%s' bssid=%s channel=%u", buf, format_mac_address_pretty(it.bssid).c_str(),
                it.channel);
       s_sta_connected = true;
+#ifdef USE_WIFI_CALLBACKS
+      global_wifi_component->wifi_connect_state_callback_.call(global_wifi_component->wifi_ssid(),
+                                                               global_wifi_component->wifi_bssid());
+#endif
       break;
     }
     case EVENT_STAMODE_DISCONNECTED: {
@@ -533,6 +536,9 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       }
       s_sta_connected = false;
       s_sta_connecting = false;
+#ifdef USE_WIFI_CALLBACKS
+      global_wifi_component->wifi_connect_state_callback_.call("", bssid_t({0, 0, 0, 0, 0, 0}));
+#endif
       break;
     }
     case EVENT_STAMODE_AUTHMODE_CHANGE: {
@@ -555,6 +561,11 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       ESP_LOGV(TAG, "static_ip=%s gateway=%s netmask=%s", format_ip_addr(it.ip).c_str(), format_ip_addr(it.gw).c_str(),
                format_ip_addr(it.mask).c_str());
       s_sta_got_ip = true;
+#ifdef USE_WIFI_CALLBACKS
+      global_wifi_component->ip_state_callback_.call(global_wifi_component->wifi_sta_ip_addresses(),
+                                                     global_wifi_component->get_dns_address(0),
+                                                     global_wifi_component->get_dns_address(1));
+#endif
       break;
     }
     case EVENT_STAMODE_DHCP_TIMEOUT: {
@@ -729,6 +740,9 @@ void WiFiComponent::wifi_scan_done_callback_(void *arg, STATUS status) {
         it->is_hidden != 0);
   }
   this->scan_done_ = true;
+#ifdef USE_WIFI_CALLBACKS
+  global_wifi_component->wifi_scan_state_callback_.call(global_wifi_component->scan_result_);
+#endif
 }
 
 #ifdef USE_WIFI_AP
@@ -885,8 +899,6 @@ network::IPAddress WiFiComponent::wifi_gateway_ip_() { return {(const ip_addr_t
 network::IPAddress WiFiComponent::wifi_dns_ip_(int num) { return {(const ip_addr_t *) WiFi.dnsIP(num)}; }
 void WiFiComponent::wifi_loop_() {}
 
-}  // namespace wifi
-}  // namespace esphome
-
+}  // namespace esphome::wifi
 #endif
 #endif
diff --git a/esphome/components/wifi/wifi_component_esp_idf.cpp b/esphome/components/wifi/wifi_component_esp_idf.cpp
index e6e914c0b4..c20c96ced0 100644
--- a/esphome/components/wifi/wifi_component_esp_idf.cpp
+++ b/esphome/components/wifi/wifi_component_esp_idf.cpp
@@ -41,8 +41,7 @@
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
-namespace esphome {
-namespace wifi {
+namespace esphome::wifi {
 
 static const char *const TAG = "wifi_esp32";
 
@@ -728,6 +727,9 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     ESP_LOGV(TAG, "Connected ssid='%s' bssid=" LOG_SECRET("%s") " channel=%u, authmode=%s", buf,
              format_mac_address_pretty(it.bssid).c_str(), it.channel, get_auth_mode_str(it.authmode));
     s_sta_connected = true;
+#ifdef USE_WIFI_CALLBACKS
+    this->wifi_connect_state_callback_.call(this->wifi_ssid(), this->wifi_bssid());
+#endif
 
   } else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_DISCONNECTED) {
     const auto &it = data->data.sta_disconnected;
@@ -751,6 +753,9 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     s_sta_connected = false;
     s_sta_connecting = false;
     error_from_callback_ = true;
+#ifdef USE_WIFI_CALLBACKS
+    this->wifi_connect_state_callback_.call("", bssid_t({0, 0, 0, 0, 0, 0}));
+#endif
 
   } else if (data->event_base == IP_EVENT && data->event_id == IP_EVENT_STA_GOT_IP) {
     const auto &it = data->data.ip_got_ip;
@@ -759,12 +764,18 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
 #endif /* USE_NETWORK_IPV6 */
     ESP_LOGV(TAG, "static_ip=" IPSTR " gateway=" IPSTR, IP2STR(&it.ip_info.ip), IP2STR(&it.ip_info.gw));
     this->got_ipv4_address_ = true;
+#ifdef USE_WIFI_CALLBACKS
+    this->ip_state_callback_.call(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
+#endif
 
 #if USE_NETWORK_IPV6
   } else if (data->event_base == IP_EVENT && data->event_id == IP_EVENT_GOT_IP6) {
     const auto &it = data->data.ip_got_ip6;
     ESP_LOGV(TAG, "IPv6 address=" IPV6STR, IPV62STR(it.ip6_info.ip));
     this->num_ipv6_addresses_++;
+#ifdef USE_WIFI_CALLBACKS
+    this->ip_state_callback_.call(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
+#endif
 #endif /* USE_NETWORK_IPV6 */
 
   } else if (data->event_base == IP_EVENT && data->event_id == IP_EVENT_STA_LOST_IP) {
@@ -804,6 +815,9 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
       scan_result_.emplace_back(bssid, ssid, record.primary, record.rssi, record.authmode != WIFI_AUTH_OPEN,
                                 ssid.empty());
     }
+#ifdef USE_WIFI_CALLBACKS
+    this->wifi_scan_state_callback_.call(this->scan_result_);
+#endif
 
   } else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_AP_START) {
     ESP_LOGV(TAG, "AP start");
@@ -1088,8 +1102,6 @@ network::IPAddress WiFiComponent::wifi_dns_ip_(int num) {
   return network::IPAddress(dns_ip);
 }
 
-}  // namespace wifi
-}  // namespace esphome
-
+}  // namespace esphome::wifi
 #endif  // USE_ESP32
 #endif
diff --git a/esphome/components/wifi/wifi_component_libretiny.cpp b/esphome/components/wifi/wifi_component_libretiny.cpp
index 98cbfddb1d..04d0d4fa85 100644
--- a/esphome/components/wifi/wifi_component_libretiny.cpp
+++ b/esphome/components/wifi/wifi_component_libretiny.cpp
@@ -15,8 +15,7 @@
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
-namespace esphome {
-namespace wifi {
+namespace esphome::wifi {
 
 static const char *const TAG = "wifi_lt";
 
@@ -288,7 +287,9 @@ void WiFiComponent::wifi_event_callback_(esphome_wifi_event_id_t event, esphome_
       buf[it.ssid_len] = '\0';
       ESP_LOGV(TAG, "Connected ssid='%s' bssid=" LOG_SECRET("%s") " channel=%u, authmode=%s", buf,
                format_mac_address_pretty(it.bssid).c_str(), it.channel, get_auth_mode_str(it.authmode));
-
+#ifdef USE_WIFI_CALLBACKS
+      this->wifi_connect_state_callback_.call(this->wifi_ssid(), this->wifi_bssid());
+#endif
       break;
     }
     case ESPHOME_EVENT_ID_WIFI_STA_DISCONNECTED: {
@@ -314,6 +315,9 @@ void WiFiComponent::wifi_event_callback_(esphome_wifi_event_id_t event, esphome_
       }
 
       s_sta_connecting = false;
+#ifdef USE_WIFI_CALLBACKS
+      this->wifi_connect_state_callback_.call("", bssid_t({0, 0, 0, 0, 0, 0}));
+#endif
       break;
     }
     case ESPHOME_EVENT_ID_WIFI_STA_AUTHMODE_CHANGE: {
@@ -335,11 +339,17 @@ void WiFiComponent::wifi_event_callback_(esphome_wifi_event_id_t event, esphome_
       ESP_LOGV(TAG, "static_ip=%s gateway=%s", format_ip4_addr(WiFi.localIP()).c_str(),
                format_ip4_addr(WiFi.gatewayIP()).c_str());
       s_sta_connecting = false;
+#ifdef USE_WIFI_CALLBACKS
+      this->ip_state_callback_.call(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
+#endif
       break;
     }
     case ESPHOME_EVENT_ID_WIFI_STA_GOT_IP6: {
       // auto it = info.got_ip.ip_info;
       ESP_LOGV(TAG, "Got IPv6");
+#ifdef USE_WIFI_CALLBACKS
+      this->ip_state_callback_.call(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
+#endif
       break;
     }
     case ESPHOME_EVENT_ID_WIFI_STA_LOST_IP: {
@@ -433,6 +443,9 @@ void WiFiComponent::wifi_scan_done_callback_() {
   }
   WiFi.scanDelete();
   this->scan_done_ = true;
+#ifdef USE_WIFI_CALLBACKS
+  this->wifi_scan_state_callback_.call(this->scan_result_);
+#endif
 }
 
 #ifdef USE_WIFI_AP
@@ -493,8 +506,6 @@ network::IPAddress WiFiComponent::wifi_gateway_ip_() { return {WiFi.gatewayIP()}
 network::IPAddress WiFiComponent::wifi_dns_ip_(int num) { return {WiFi.dnsIP(num)}; }
 void WiFiComponent::wifi_loop_() {}
 
-}  // namespace wifi
-}  // namespace esphome
-
+}  // namespace esphome::wifi
 #endif  // USE_LIBRETINY
 #endif
diff --git a/esphome/components/wifi/wifi_component_pico_w.cpp b/esphome/components/wifi/wifi_component_pico_w.cpp
index 91766e8ab5..326883c0c4 100644
--- a/esphome/components/wifi/wifi_component_pico_w.cpp
+++ b/esphome/components/wifi/wifi_component_pico_w.cpp
@@ -1,4 +1,3 @@
-
 #include "wifi_component.h"
 
 #ifdef USE_WIFI
@@ -15,11 +14,14 @@
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
-namespace esphome {
-namespace wifi {
+namespace esphome::wifi {
 
 static const char *const TAG = "wifi_pico_w";
 
+// Track previous state for detecting changes
+static bool s_sta_was_connected = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static bool s_sta_had_ip = false;         // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 bool WiFiComponent::wifi_mode_(optional<bool> sta, optional<bool> ap) {
   if (sta.has_value()) {
     if (sta.value()) {
@@ -51,7 +53,7 @@ bool WiFiComponent::wifi_apply_power_save_() {
   return ret == 0;
 }
 
-// TODO: The driver doesnt seem to have an API for this
+// TODO: The driver doesn't seem to have an API for this
 bool WiFiComponent::wifi_apply_output_power_(float output_power) { return true; }
 
 bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
@@ -219,16 +221,61 @@ network::IPAddress WiFiComponent::wifi_dns_ip_(int num) {
 }
 
 void WiFiComponent::wifi_loop_() {
+  // Handle scan completion
   if (this->state_ == WIFI_COMPONENT_STATE_STA_SCANNING && !cyw43_wifi_scan_active(&cyw43_state)) {
     this->scan_done_ = true;
     ESP_LOGV(TAG, "Scan done");
+#ifdef USE_WIFI_CALLBACKS
+    this->wifi_scan_state_callback_.call(this->scan_result_);
+#endif
+  }
+
+  // Poll for connection state changes
+  // The arduino-pico WiFi library doesn't have event callbacks like ESP8266/ESP32,
+  // so we need to poll the link status to detect state changes
+  auto status = cyw43_tcpip_link_status(&cyw43_state, CYW43_ITF_STA);
+  bool is_connected = (status == CYW43_LINK_UP);
+
+  // Detect connection state change
+  if (is_connected && !s_sta_was_connected) {
+    // Just connected
+    s_sta_was_connected = true;
+    ESP_LOGV(TAG, "Connected");
+#ifdef USE_WIFI_CALLBACKS
+    this->wifi_connect_state_callback_.call(this->wifi_ssid(), this->wifi_bssid());
+#endif
+  } else if (!is_connected && s_sta_was_connected) {
+    // Just disconnected
+    s_sta_was_connected = false;
+    s_sta_had_ip = false;
+    ESP_LOGV(TAG, "Disconnected");
+#ifdef USE_WIFI_CALLBACKS
+    this->wifi_connect_state_callback_.call("", bssid_t({0, 0, 0, 0, 0, 0}));
+#endif
+  }
+
+  // Detect IP address changes (only when connected)
+  if (is_connected) {
+    bool has_ip = false;
+    // Check for any IP address (IPv4 or IPv6)
+    for (auto addr : addrList) {
+      has_ip = true;
+      break;
+    }
+
+    if (has_ip && !s_sta_had_ip) {
+      // Just got IP address
+      s_sta_had_ip = true;
+      ESP_LOGV(TAG, "Got IP address");
+#ifdef USE_WIFI_CALLBACKS
+      this->ip_state_callback_.call(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
+#endif
+    }
   }
 }
 
 void WiFiComponent::wifi_pre_setup_() {}
 
-}  // namespace wifi
-}  // namespace esphome
-
+}  // namespace esphome::wifi
 #endif
 #endif
diff --git a/esphome/components/wifi_info/text_sensor.py b/esphome/components/wifi_info/text_sensor.py
index a4da582c55..0feee3d4a9 100644
--- a/esphome/components/wifi_info/text_sensor.py
+++ b/esphome/components/wifi_info/text_sensor.py
@@ -15,31 +15,27 @@ DEPENDENCIES = ["wifi"]
 
 wifi_info_ns = cg.esphome_ns.namespace("wifi_info")
 IPAddressWiFiInfo = wifi_info_ns.class_(
-    "IPAddressWiFiInfo", text_sensor.TextSensor, cg.PollingComponent
+    "IPAddressWiFiInfo", text_sensor.TextSensor, cg.Component
 )
 ScanResultsWiFiInfo = wifi_info_ns.class_(
-    "ScanResultsWiFiInfo", text_sensor.TextSensor, cg.PollingComponent
-)
-SSIDWiFiInfo = wifi_info_ns.class_(
-    "SSIDWiFiInfo", text_sensor.TextSensor, cg.PollingComponent
+    "ScanResultsWiFiInfo", text_sensor.TextSensor, cg.Component
 )
+SSIDWiFiInfo = wifi_info_ns.class_("SSIDWiFiInfo", text_sensor.TextSensor, cg.Component)
 BSSIDWiFiInfo = wifi_info_ns.class_(
-    "BSSIDWiFiInfo", text_sensor.TextSensor, cg.PollingComponent
+    "BSSIDWiFiInfo", text_sensor.TextSensor, cg.Component
 )
 MacAddressWifiInfo = wifi_info_ns.class_(
     "MacAddressWifiInfo", text_sensor.TextSensor, cg.Component
 )
 DNSAddressWifiInfo = wifi_info_ns.class_(
-    "DNSAddressWifiInfo", text_sensor.TextSensor, cg.PollingComponent
+    "DNSAddressWifiInfo", text_sensor.TextSensor, cg.Component
 )
 
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.Optional(CONF_IP_ADDRESS): text_sensor.text_sensor_schema(
             IPAddressWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
-        )
-        .extend(cv.polling_component_schema("1s"))
-        .extend(
+        ).extend(
             {
                 cv.Optional(f"address_{x}"): text_sensor.text_sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
@@ -49,22 +45,31 @@ CONFIG_SCHEMA = cv.Schema(
         ),
         cv.Optional(CONF_SCAN_RESULTS): text_sensor.text_sensor_schema(
             ScanResultsWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
-        ).extend(cv.polling_component_schema("60s")),
+        ),
         cv.Optional(CONF_SSID): text_sensor.text_sensor_schema(
             SSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
-        ).extend(cv.polling_component_schema("1s")),
+        ),
         cv.Optional(CONF_BSSID): text_sensor.text_sensor_schema(
             BSSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
-        ).extend(cv.polling_component_schema("1s")),
+        ),
         cv.Optional(CONF_MAC_ADDRESS): text_sensor.text_sensor_schema(
             MacAddressWifiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
         ),
         cv.Optional(CONF_DNS_ADDRESS): text_sensor.text_sensor_schema(
             DNSAddressWifiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
-        ).extend(cv.polling_component_schema("1s")),
+        ),
     }
 )
 
+# Keys that require WiFi callbacks
+_NETWORK_INFO_KEYS = {
+    CONF_SSID,
+    CONF_BSSID,
+    CONF_IP_ADDRESS,
+    CONF_DNS_ADDRESS,
+    CONF_SCAN_RESULTS,
+}
+
 
 async def setup_conf(config, key):
     if key in config:
@@ -74,6 +79,10 @@ async def setup_conf(config, key):
 
 
 async def to_code(config):
+    # Request WiFi callbacks for any sensor that needs them
+    if _NETWORK_INFO_KEYS.intersection(config):
+        wifi.request_wifi_callbacks()
+
     await setup_conf(config, CONF_SSID)
     await setup_conf(config, CONF_BSSID)
     await setup_conf(config, CONF_MAC_ADDRESS)
diff --git a/esphome/components/wifi_info/wifi_info_text_sensor.cpp b/esphome/components/wifi_info/wifi_info_text_sensor.cpp
index 2612e4af8d..abd590b168 100644
--- a/esphome/components/wifi_info/wifi_info_text_sensor.cpp
+++ b/esphome/components/wifi_info/wifi_info_text_sensor.cpp
@@ -2,18 +2,121 @@
 #ifdef USE_WIFI
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace wifi_info {
+namespace esphome::wifi_info {
 
 static const char *const TAG = "wifi_info";
 
+static constexpr size_t MAX_STATE_LENGTH = 255;
+
+/********************
+ * IPAddressWiFiInfo
+ *******************/
+
+void IPAddressWiFiInfo::setup() {
+  wifi::global_wifi_component->add_on_ip_state_callback(
+      [this](const network::IPAddresses &ips, const network::IPAddress &dns1_ip, const network::IPAddress &dns2_ip) {
+        this->state_callback_(ips);
+      });
+}
+
 void IPAddressWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "IP Address", this); }
-void ScanResultsWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "Scan Results", this); }
-void SSIDWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "SSID", this); }
-void BSSIDWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "BSSID", this); }
-void MacAddressWifiInfo::dump_config() { LOG_TEXT_SENSOR("", "MAC Address", this); }
+
+void IPAddressWiFiInfo::state_callback_(const network::IPAddresses &ips) {
+  this->publish_state(ips[0].str());
+  uint8_t sensor = 0;
+  for (const auto &ip : ips) {
+    if (ip.is_set()) {
+      if (this->ip_sensors_[sensor] != nullptr) {
+        this->ip_sensors_[sensor]->publish_state(ip.str());
+      }
+      sensor++;
+    }
+  }
+}
+
+/*********************
+ * DNSAddressWifiInfo
+ ********************/
+
+void DNSAddressWifiInfo::setup() {
+  wifi::global_wifi_component->add_on_ip_state_callback(
+      [this](const network::IPAddresses &ips, const network::IPAddress &dns1_ip, const network::IPAddress &dns2_ip) {
+        this->state_callback_(dns1_ip, dns2_ip);
+      });
+}
+
 void DNSAddressWifiInfo::dump_config() { LOG_TEXT_SENSOR("", "DNS Address", this); }
 
-}  // namespace wifi_info
-}  // namespace esphome
+void DNSAddressWifiInfo::state_callback_(const network::IPAddress &dns1_ip, const network::IPAddress &dns2_ip) {
+  std::string dns_results = dns1_ip.str() + " " + dns2_ip.str();
+  this->publish_state(dns_results);
+}
+
+/**********************
+ * ScanResultsWiFiInfo
+ *********************/
+
+void ScanResultsWiFiInfo::setup() {
+  wifi::global_wifi_component->add_on_wifi_scan_state_callback(
+      [this](const wifi::wifi_scan_vector_t<wifi::WiFiScanResult> &results) { this->state_callback_(results); });
+}
+
+void ScanResultsWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "Scan Results", this); }
+
+void ScanResultsWiFiInfo::state_callback_(const wifi::wifi_scan_vector_t<wifi::WiFiScanResult> &results) {
+  std::string scan_results;
+  for (const auto &scan : results) {
+    if (scan.get_is_hidden())
+      continue;
+
+    scan_results += scan.get_ssid();
+    scan_results += ": ";
+    scan_results += esphome::to_string(scan.get_rssi());
+    scan_results += "dB\n";
+  }
+  // There's a limit of 255 characters per state; longer states just don't get sent so we truncate it
+  if (scan_results.length() > MAX_STATE_LENGTH) {
+    scan_results.resize(MAX_STATE_LENGTH);
+  }
+  this->publish_state(scan_results);
+}
+
+/***************
+ * SSIDWiFiInfo
+ **************/
+
+void SSIDWiFiInfo::setup() {
+  wifi::global_wifi_component->add_on_wifi_connect_state_callback(
+      [this](const std::string &ssid, const wifi::bssid_t &bssid) { this->state_callback_(ssid); });
+}
+
+void SSIDWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "SSID", this); }
+
+void SSIDWiFiInfo::state_callback_(const std::string &ssid) { this->publish_state(ssid); }
+
+/****************
+ * BSSIDWiFiInfo
+ ***************/
+
+void BSSIDWiFiInfo::setup() {
+  wifi::global_wifi_component->add_on_wifi_connect_state_callback(
+      [this](const std::string &ssid, const wifi::bssid_t &bssid) { this->state_callback_(bssid); });
+}
+
+void BSSIDWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "BSSID", this); }
+
+void BSSIDWiFiInfo::state_callback_(const wifi::bssid_t &bssid) {
+  char buf[18] = "unknown";
+  if (mac_address_is_valid(bssid.data())) {
+    format_mac_addr_upper(bssid.data(), buf);
+  }
+  this->publish_state(buf);
+}
+/*********************
+ * MacAddressWifiInfo
+ ********************/
+
+void MacAddressWifiInfo::dump_config() { LOG_TEXT_SENSOR("", "MAC Address", this); }
+
+}  // namespace esphome::wifi_info
 #endif
diff --git a/esphome/components/wifi_info/wifi_info_text_sensor.h b/esphome/components/wifi_info/wifi_info_text_sensor.h
index 0814336c43..12666b4059 100644
--- a/esphome/components/wifi_info/wifi_info_text_sensor.h
+++ b/esphome/components/wifi_info/wifi_info_text_sensor.h
@@ -7,121 +7,54 @@
 #ifdef USE_WIFI
 #include <array>
 
-namespace esphome {
-namespace wifi_info {
+namespace esphome::wifi_info {
 
-static constexpr size_t MAX_STATE_LENGTH = 255;
-
-class IPAddressWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
+class IPAddressWiFiInfo : public Component, public text_sensor::TextSensor {
  public:
-  void update() override {
-    auto ips = wifi::global_wifi_component->wifi_sta_ip_addresses();
-    if (ips != this->last_ips_) {
-      this->last_ips_ = ips;
-      this->publish_state(ips[0].str());
-      uint8_t sensor = 0;
-      for (auto &ip : ips) {
-        if (ip.is_set()) {
-          if (this->ip_sensors_[sensor] != nullptr) {
-            this->ip_sensors_[sensor]->publish_state(ip.str());
-          }
-          sensor++;
-        }
-      }
-    }
-  }
-  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void setup() override;
   void dump_config() override;
   void add_ip_sensors(uint8_t index, text_sensor::TextSensor *s) { this->ip_sensors_[index] = s; }
 
  protected:
-  network::IPAddresses last_ips_;
+  void state_callback_(const network::IPAddresses &ips);
   std::array<text_sensor::TextSensor *, 5> ip_sensors_;
 };
 
-class DNSAddressWifiInfo : public PollingComponent, public text_sensor::TextSensor {
+class DNSAddressWifiInfo : public Component, public text_sensor::TextSensor {
  public:
-  void update() override {
-    auto dns_one = wifi::global_wifi_component->get_dns_address(0);
-    auto dns_two = wifi::global_wifi_component->get_dns_address(1);
-
-    std::string dns_results = dns_one.str() + " " + dns_two.str();
-
-    if (dns_results != this->last_results_) {
-      this->last_results_ = dns_results;
-      this->publish_state(dns_results);
-    }
-  }
-  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void setup() override;
   void dump_config() override;
 
  protected:
-  std::string last_results_;
+  void state_callback_(const network::IPAddress &dns1_ip, const network::IPAddress &dns2_ip);
 };
 
-class ScanResultsWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
+class ScanResultsWiFiInfo : public Component, public text_sensor::TextSensor {
  public:
-  void update() override {
-    std::string scan_results;
-    for (auto &scan : wifi::global_wifi_component->get_scan_result()) {
-      if (scan.get_is_hidden())
-        continue;
-
-      scan_results += scan.get_ssid();
-      scan_results += ": ";
-      scan_results += esphome::to_string(scan.get_rssi());
-      scan_results += "dB\n";
-    }
-
-    // There's a limit of 255 characters per state.
-    // Longer states just don't get sent so we truncate it.
-    if (scan_results.length() > MAX_STATE_LENGTH) {
-      scan_results.resize(MAX_STATE_LENGTH);
-    }
-    if (this->last_scan_results_ != scan_results) {
-      this->last_scan_results_ = scan_results;
-      this->publish_state(scan_results);
-    }
-  }
+  void setup() override;
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
   void dump_config() override;
 
  protected:
-  std::string last_scan_results_;
+  void state_callback_(const wifi::wifi_scan_vector_t<wifi::WiFiScanResult> &results);
 };
 
-class SSIDWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
+class SSIDWiFiInfo : public Component, public text_sensor::TextSensor {
  public:
-  void update() override {
-    std::string ssid = wifi::global_wifi_component->wifi_ssid();
-    if (this->last_ssid_ != ssid) {
-      this->last_ssid_ = ssid;
-      this->publish_state(this->last_ssid_);
-    }
-  }
-  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void setup() override;
   void dump_config() override;
 
  protected:
-  std::string last_ssid_;
+  void state_callback_(const std::string &ssid);
 };
 
-class BSSIDWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
+class BSSIDWiFiInfo : public Component, public text_sensor::TextSensor {
  public:
-  void update() override {
-    wifi::bssid_t bssid = wifi::global_wifi_component->wifi_bssid();
-    if (memcmp(bssid.data(), last_bssid_.data(), 6) != 0) {
-      std::copy(bssid.begin(), bssid.end(), last_bssid_.begin());
-      char buf[18];
-      format_mac_addr_upper(bssid.data(), buf);
-      this->publish_state(buf);
-    }
-  }
-  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+  void setup() override;
   void dump_config() override;
 
  protected:
-  wifi::bssid_t last_bssid_;
+  void state_callback_(const wifi::bssid_t &bssid);
 };
 
 class MacAddressWifiInfo : public Component, public text_sensor::TextSensor {
@@ -133,6 +66,5 @@ class MacAddressWifiInfo : public Component, public text_sensor::TextSensor {
   void dump_config() override;
 };
 
-}  // namespace wifi_info
-}  // namespace esphome
+}  // namespace esphome::wifi_info
 #endif
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index 4b24c395b9..1373ea6366 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -210,6 +210,7 @@
 #define USE_WEBSERVER_SORTING
 #define USE_WIFI_11KV_SUPPORT
 #define USE_WIFI_FAST_CONNECT
+#define USE_WIFI_CALLBACKS
 #define USE_WIFI_RUNTIME_POWER_SAVE
 #define USB_HOST_MAX_REQUESTS 16
 

From 1c808a3375a824f37cfdb6bfb067f96975be733b Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 24 Nov 2025 21:19:18 -0600
Subject: [PATCH 03/26] [ble_client] Write static BLE data directly from flash
 without allocation (#11826)

---
 esphome/components/ble_client/automation.h | 27 +++++++++++++---------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/esphome/components/ble_client/automation.h b/esphome/components/ble_client/automation.h
index 9c5646b3d1..bbc2dd05e0 100644
--- a/esphome/components/ble_client/automation.h
+++ b/esphome/components/ble_client/automation.h
@@ -122,16 +122,19 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   void play_complex(const Ts &...x) override {
     this->num_running_++;
     this->var_ = std::make_tuple(x...);
-    std::vector<uint8_t> value;
+
+    bool result;
     if (this->len_ >= 0) {
-      // Static mode: copy from flash to vector
-      value.assign(this->value_.data, this->value_.data + this->len_);
+      // Static mode: write directly from flash pointer
+      result = this->write(this->value_.data, this->len_);
     } else {
-      // Template mode: call function
-      value = this->value_.func(x...);
+      // Template mode: call function and write the vector
+      std::vector<uint8_t> value = this->value_.func(x...);
+      result = this->write(value);
     }
+
     // on write failure, continue the automation chain rather than stopping so that e.g. disconnect can work.
-    if (!write(value))
+    if (!result)
       this->play_next_(x...);
   }
 
@@ -144,15 +147,15 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
    * errors.
    */
   // initiate the write. Return true if all went well, will be followed by a WRITE_CHAR event.
-  bool write(const std::vector<uint8_t> &value) {
+  bool write(const uint8_t *data, size_t len) {
     if (this->node_state != espbt::ClientState::ESTABLISHED) {
       esph_log_w(Automation::TAG, "Cannot write to BLE characteristic - not connected");
       return false;
     }
-    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", value.size(), format_hex_pretty(value).c_str());
-    esp_err_t err = esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(),
-                                             this->char_handle_, value.size(), const_cast<uint8_t *>(value.data()),
-                                             this->write_type_, ESP_GATT_AUTH_REQ_NONE);
+    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", len, format_hex_pretty(data, len).c_str());
+    esp_err_t err =
+        esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_, len,
+                                 const_cast<uint8_t *>(data), this->write_type_, ESP_GATT_AUTH_REQ_NONE);
     if (err != ESP_OK) {
       esph_log_e(Automation::TAG, "Error writing to characteristic: %s!", esp_err_to_name(err));
       return false;
@@ -160,6 +163,8 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
     return true;
   }
 
+  bool write(const std::vector<uint8_t> &value) { return this->write(value.data(), value.size()); }
+
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                            esp_ble_gattc_cb_param_t *param) override {
     switch (event) {

From 46a26560fd32eceedc547b154018ddad4deefd8a Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 24 Nov 2025 21:21:56 -0600
Subject: [PATCH 04/26] [template.alarm_control_panel] Replace std::map with
 FixedVector for heap and flash savings (#11893)

---
 .../template/alarm_control_panel/__init__.py  |   6 +-
 .../template_alarm_control_panel.cpp          |  35 +++--
 .../template_alarm_control_panel.h            |  20 ++-
 ...late_alarm_control_panel_many_sensors.yaml | 136 ++++++++++++++++++
 ...mplate_alarm_control_panel_many_sensors.py | 118 +++++++++++++++
 5 files changed, 296 insertions(+), 19 deletions(-)
 create mode 100644 tests/integration/fixtures/template_alarm_control_panel_many_sensors.yaml
 create mode 100644 tests/integration/test_template_alarm_control_panel_many_sensors.py

diff --git a/esphome/components/template/alarm_control_panel/__init__.py b/esphome/components/template/alarm_control_panel/__init__.py
index 5d2421fcbc..256c7f276a 100644
--- a/esphome/components/template/alarm_control_panel/__init__.py
+++ b/esphome/components/template/alarm_control_panel/__init__.py
@@ -137,7 +137,11 @@ async def to_code(config):
         cg.add(var.set_arming_night_time(config[CONF_ARMING_NIGHT_TIME]))
         supports_arm_night = True
 
-    for sensor in config.get(CONF_BINARY_SENSORS, []):
+    if sensors := config.get(CONF_BINARY_SENSORS, []):
+        # Initialize FixedVector with the exact number of sensors
+        cg.add(var.init_sensors(len(sensors)))
+
+    for sensor in sensors:
         bs = await cg.get_variable(sensor[CONF_INPUT])
 
         flags = BinarySensorFlags[FLAG_NORMAL]
diff --git a/esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp b/esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp
index af662a05a0..f025435261 100644
--- a/esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp
+++ b/esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp
@@ -20,10 +20,13 @@ void TemplateAlarmControlPanel::add_sensor(binary_sensor::BinarySensor *sensor,
   // Save the flags and type. Assign a store index for the per sensor data type.
   SensorDataStore sd;
   sd.last_chime_state = false;
-  this->sensor_map_[sensor].flags = flags;
-  this->sensor_map_[sensor].type = type;
+  AlarmSensor alarm_sensor;
+  alarm_sensor.sensor = sensor;
+  alarm_sensor.info.flags = flags;
+  alarm_sensor.info.type = type;
+  alarm_sensor.info.store_index = this->next_store_index_++;
+  this->sensors_.push_back(alarm_sensor);
   this->sensor_data_.push_back(sd);
-  this->sensor_map_[sensor].store_index = this->next_store_index_++;
 };
 
 static const LogString *sensor_type_to_string(AlarmSensorType type) {
@@ -45,7 +48,7 @@ void TemplateAlarmControlPanel::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "TemplateAlarmControlPanel:\n"
                 "  Current State: %s\n"
-                "  Number of Codes: %u\n"
+                "  Number of Codes: %zu\n"
                 "  Requires Code To Arm: %s\n"
                 "  Arming Away Time: %" PRIu32 "s\n"
                 "  Arming Home Time: %" PRIu32 "s\n"
@@ -58,7 +61,8 @@ void TemplateAlarmControlPanel::dump_config() {
                 (this->arming_home_time_ / 1000), (this->arming_night_time_ / 1000), (this->pending_time_ / 1000),
                 (this->trigger_time_ / 1000), this->get_supported_features());
 #ifdef USE_BINARY_SENSOR
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  for (const auto &alarm_sensor : this->sensors_) {
+    const uint16_t flags = alarm_sensor.info.flags;
     ESP_LOGCONFIG(TAG,
                   "  Binary Sensor:\n"
                   "    Name: %s\n"
@@ -67,11 +71,10 @@ void TemplateAlarmControlPanel::dump_config() {
                   "    Armed night bypass: %s\n"
                   "    Auto bypass: %s\n"
                   "    Chime mode: %s",
-                  sensor->get_name().c_str(), LOG_STR_ARG(sensor_type_to_string(info.type)),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO),
-                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_CHIME));
+                  alarm_sensor.sensor->get_name().c_str(), LOG_STR_ARG(sensor_type_to_string(alarm_sensor.info.type)),
+                  TRUEFALSE(flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
+                  TRUEFALSE(flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
+                  TRUEFALSE(flags & BINARY_SENSOR_MODE_BYPASS_AUTO), TRUEFALSE(flags & BINARY_SENSOR_MODE_CHIME));
   }
 #endif
 }
@@ -121,7 +124,9 @@ void TemplateAlarmControlPanel::loop() {
 
 #ifdef USE_BINARY_SENSOR
   // Test all of the sensors regardless of the alarm panel state
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  for (const auto &alarm_sensor : this->sensors_) {
+    const auto &info = alarm_sensor.info;
+    auto *sensor = alarm_sensor.sensor;
     // Check for chime zones
     if (info.flags & BINARY_SENSOR_MODE_CHIME) {
       // Look for the transition from closed to open
@@ -242,11 +247,11 @@ void TemplateAlarmControlPanel::arm_(optional<std::string> code, alarm_control_p
 
 void TemplateAlarmControlPanel::bypass_before_arming() {
 #ifdef USE_BINARY_SENSOR
-  for (auto const &[sensor, info] : this->sensor_map_) {
+  for (const auto &alarm_sensor : this->sensors_) {
     // Check for faulted bypass_auto sensors and remove them from monitoring
-    if ((info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (sensor->state)) {
-      ESP_LOGW(TAG, "'%s' is faulted and will be automatically bypassed", sensor->get_name().c_str());
-      this->bypassed_sensor_indicies_.push_back(info.store_index);
+    if ((alarm_sensor.info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (alarm_sensor.sensor->state)) {
+      ESP_LOGW(TAG, "'%s' is faulted and will be automatically bypassed", alarm_sensor.sensor->get_name().c_str());
+      this->bypassed_sensor_indicies_.push_back(alarm_sensor.info.store_index);
     }
   }
 #endif
diff --git a/esphome/components/template/alarm_control_panel/template_alarm_control_panel.h b/esphome/components/template/alarm_control_panel/template_alarm_control_panel.h
index 202dc7c13f..80ce34b8ae 100644
--- a/esphome/components/template/alarm_control_panel/template_alarm_control_panel.h
+++ b/esphome/components/template/alarm_control_panel/template_alarm_control_panel.h
@@ -1,11 +1,12 @@
 #pragma once
 
 #include <cinttypes>
-#include <map>
+#include <vector>
 
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
+#include "esphome/core/helpers.h"
 
 #include "esphome/components/alarm_control_panel/alarm_control_panel.h"
 
@@ -49,6 +50,13 @@ struct SensorInfo {
   uint8_t store_index;
 };
 
+#ifdef USE_BINARY_SENSOR
+struct AlarmSensor {
+  binary_sensor::BinarySensor *sensor;
+  SensorInfo info;
+};
+#endif
+
 class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControlPanel, public Component {
  public:
   TemplateAlarmControlPanel();
@@ -63,6 +71,12 @@ class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControl
   void bypass_before_arming();
 
 #ifdef USE_BINARY_SENSOR
+  /** Initialize the sensors vector with the specified capacity.
+   *
+   * @param capacity The number of sensors to allocate space for.
+   */
+  void init_sensors(size_t capacity) { this->sensors_.init(capacity); }
+
   /** Add a binary_sensor to the alarm_panel.
    *
    * @param sensor The BinarySensor instance.
@@ -122,8 +136,8 @@ class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControl
  protected:
   void control(const alarm_control_panel::AlarmControlPanelCall &call) override;
 #ifdef USE_BINARY_SENSOR
-  // This maps a binary sensor to its alarm specific info
-  std::map<binary_sensor::BinarySensor *, SensorInfo> sensor_map_;
+  // List of binary sensors with their alarm-specific info
+  FixedVector<AlarmSensor> sensors_;
   // a list of automatically bypassed sensors
   std::vector<uint8_t> bypassed_sensor_indicies_;
 #endif
diff --git a/tests/integration/fixtures/template_alarm_control_panel_many_sensors.yaml b/tests/integration/fixtures/template_alarm_control_panel_many_sensors.yaml
new file mode 100644
index 0000000000..836d3f11d5
--- /dev/null
+++ b/tests/integration/fixtures/template_alarm_control_panel_many_sensors.yaml
@@ -0,0 +1,136 @@
+esphome:
+  name: template-alarm-many-sensors
+  friendly_name: "Template Alarm Control Panel with Many Sensors"
+
+logger:
+
+host:
+
+api:
+
+binary_sensor:
+  - platform: template
+    id: sensor1
+    name: "Door 1"
+  - platform: template
+    id: sensor2
+    name: "Door 2"
+  - platform: template
+    id: sensor3
+    name: "Window 1"
+  - platform: template
+    id: sensor4
+    name: "Window 2"
+  - platform: template
+    id: sensor5
+    name: "Motion 1"
+  - platform: template
+    id: sensor6
+    name: "Motion 2"
+  - platform: template
+    id: sensor7
+    name: "Glass Break 1"
+  - platform: template
+    id: sensor8
+    name: "Glass Break 2"
+  - platform: template
+    id: sensor9
+    name: "Smoke Detector"
+  - platform: template
+    id: sensor10
+    name: "CO Detector"
+
+alarm_control_panel:
+  - platform: template
+    id: test_alarm
+    name: "Test Alarm"
+    codes:
+      - "1234"
+    requires_code_to_arm: true
+    arming_away_time: 5s
+    arming_home_time: 3s
+    arming_night_time: 3s
+    pending_time: 10s
+    trigger_time: 300s
+    restore_mode: ALWAYS_DISARMED
+    binary_sensors:
+      - input: sensor1
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: true
+        chime: true
+        trigger_mode: DELAYED
+      - input: sensor2
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: true
+        chime: true
+        trigger_mode: DELAYED
+      - input: sensor3
+        bypass_armed_home: true
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: DELAYED
+      - input: sensor4
+        bypass_armed_home: true
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: DELAYED
+      - input: sensor5
+        bypass_armed_home: false
+        bypass_armed_night: true
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT
+      - input: sensor6
+        bypass_armed_home: false
+        bypass_armed_night: true
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT
+      - input: sensor7
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT
+      - input: sensor8
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT
+      - input: sensor9
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT_ALWAYS
+      - input: sensor10
+        bypass_armed_home: false
+        bypass_armed_night: false
+        bypass_auto: false
+        chime: false
+        trigger_mode: INSTANT_ALWAYS
+    on_disarmed:
+      - logger.log: "Alarm disarmed"
+    on_arming:
+      - logger.log: "Alarm arming"
+    on_armed_away:
+      - logger.log: "Alarm armed away"
+    on_armed_home:
+      - logger.log: "Alarm armed home"
+    on_armed_night:
+      - logger.log: "Alarm armed night"
+    on_pending:
+      - logger.log: "Alarm pending"
+    on_triggered:
+      - logger.log: "Alarm triggered"
+    on_cleared:
+      - logger.log: "Alarm cleared"
+    on_chime:
+      - logger.log: "Chime activated"
+    on_ready:
+      - logger.log: "Sensors ready state changed"
diff --git a/tests/integration/test_template_alarm_control_panel_many_sensors.py b/tests/integration/test_template_alarm_control_panel_many_sensors.py
new file mode 100644
index 0000000000..856815c731
--- /dev/null
+++ b/tests/integration/test_template_alarm_control_panel_many_sensors.py
@@ -0,0 +1,118 @@
+"""Integration test for template alarm control panel with many sensors."""
+
+from __future__ import annotations
+
+import aioesphomeapi
+from aioesphomeapi.model import APIIntEnum
+import pytest
+
+from .state_utils import InitialStateHelper
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+class EspHomeACPFeatures(APIIntEnum):
+    """ESPHome AlarmControlPanel feature numbers."""
+
+    ARM_HOME = 1
+    ARM_AWAY = 2
+    ARM_NIGHT = 4
+    TRIGGER = 8
+    ARM_CUSTOM_BYPASS = 16
+    ARM_VACATION = 32
+
+
+@pytest.mark.asyncio
+async def test_template_alarm_control_panel_many_sensors(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test template alarm control panel with 10 binary sensors using FixedVector."""
+    async with run_compiled(yaml_config), api_client_connected() as client:
+        # Get entity info first
+        entities, _ = await client.list_entities_services()
+
+        # Find the alarm control panel and binary sensors
+        alarm_info: aioesphomeapi.AlarmControlPanelInfo | None = None
+        binary_sensors: list[aioesphomeapi.BinarySensorInfo] = []
+
+        for entity in entities:
+            if isinstance(entity, aioesphomeapi.AlarmControlPanelInfo):
+                alarm_info = entity
+            elif isinstance(entity, aioesphomeapi.BinarySensorInfo):
+                binary_sensors.append(entity)
+
+        assert alarm_info is not None, "Alarm control panel entity info not found"
+        assert alarm_info.name == "Test Alarm"
+        assert alarm_info.requires_code is True
+        assert alarm_info.requires_code_to_arm is True
+
+        # Verify we have 10 binary sensors
+        assert len(binary_sensors) == 10, (
+            f"Expected 10 binary sensors, got {len(binary_sensors)}"
+        )
+
+        # Verify sensor names
+        expected_sensor_names = {
+            "Door 1",
+            "Door 2",
+            "Window 1",
+            "Window 2",
+            "Motion 1",
+            "Motion 2",
+            "Glass Break 1",
+            "Glass Break 2",
+            "Smoke Detector",
+            "CO Detector",
+        }
+        actual_sensor_names = {sensor.name for sensor in binary_sensors}
+        assert actual_sensor_names == expected_sensor_names, (
+            f"Sensor names mismatch. Expected: {expected_sensor_names}, "
+            f"Got: {actual_sensor_names}"
+        )
+
+        # Use InitialStateHelper to wait for all initial states
+        state_helper = InitialStateHelper(entities)
+
+        def on_state(state: aioesphomeapi.EntityState) -> None:
+            # We'll receive subsequent states here after initial states
+            pass
+
+        client.subscribe_states(state_helper.on_state_wrapper(on_state))
+
+        # Wait for all initial states
+        await state_helper.wait_for_initial_states(timeout=5.0)
+
+        # Verify the alarm state is disarmed initially
+        alarm_state = state_helper.initial_states.get(alarm_info.key)
+        assert alarm_state is not None, "Alarm control panel initial state not received"
+        assert isinstance(alarm_state, aioesphomeapi.AlarmControlPanelEntityState)
+        assert alarm_state.state == aioesphomeapi.AlarmControlPanelState.DISARMED, (
+            f"Expected initial state DISARMED, got {alarm_state.state}"
+        )
+
+        # Verify all 10 binary sensors have initial states
+        binary_sensor_states = [
+            state_helper.initial_states.get(sensor.key) for sensor in binary_sensors
+        ]
+        assert all(state is not None for state in binary_sensor_states), (
+            "Not all binary sensors have initial states"
+        )
+
+        # Verify all binary sensor states are BinarySensorState type
+        for i, state in enumerate(binary_sensor_states):
+            assert isinstance(state, aioesphomeapi.BinarySensorState), (
+                f"Binary sensor {i} state is not BinarySensorState: {type(state)}"
+            )
+
+        # Verify supported features
+        expected_features = (
+            EspHomeACPFeatures.ARM_HOME
+            | EspHomeACPFeatures.ARM_AWAY
+            | EspHomeACPFeatures.ARM_NIGHT
+            | EspHomeACPFeatures.TRIGGER
+        )
+        assert alarm_info.supported_features == expected_features, (
+            f"Expected supported_features={expected_features} (ARM_HOME|ARM_AWAY|ARM_NIGHT|TRIGGER), "
+            f"got {alarm_info.supported_features}"
+        )

From 66a871840e1f0b6ba37b03f833b49e6bb73afaaf Mon Sep 17 00:00:00 2001
From: bdm310 <bdm310@users.noreply.github.com>
Date: Mon, 24 Nov 2025 22:14:23 -0800
Subject: [PATCH 05/26] Add more lvgl arc update parameters (#12066)

---
 esphome/components/lvgl/widgets/arc.py  | 54 +++++++++++++++++++------
 tests/components/lvgl/lvgl-package.yaml | 12 ++++++
 2 files changed, 53 insertions(+), 13 deletions(-)

diff --git a/esphome/components/lvgl/widgets/arc.py b/esphome/components/lvgl/widgets/arc.py
index ef4da0d815..21530441f8 100644
--- a/esphome/components/lvgl/widgets/arc.py
+++ b/esphome/components/lvgl/widgets/arc.py
@@ -20,7 +20,13 @@ from ..defines import (
     CONF_START_ANGLE,
     literal,
 )
-from ..lv_validation import get_start_value, lv_angle_degrees, lv_float, lv_int
+from ..lv_validation import (
+    get_start_value,
+    lv_angle_degrees,
+    lv_float,
+    lv_int,
+    lv_positive_int,
+)
 from ..lvcode import lv, lv_expr, lv_obj
 from ..types import LvNumber, NumberType
 from . import Widget
@@ -36,13 +42,20 @@ ARC_SCHEMA = cv.Schema(
         cv.Optional(CONF_ROTATION, default=0.0): lv_angle_degrees,
         cv.Optional(CONF_ADJUSTABLE, default=False): bool,
         cv.Optional(CONF_MODE, default="NORMAL"): ARC_MODES.one_of,
-        cv.Optional(CONF_CHANGE_RATE, default=720): cv.uint16_t,
+        cv.Optional(CONF_CHANGE_RATE, default=720): lv_positive_int,
     }
 )
 
 ARC_MODIFY_SCHEMA = cv.Schema(
     {
         cv.Optional(CONF_VALUE): lv_float,
+        cv.Optional(CONF_MIN_VALUE): lv_int,
+        cv.Optional(CONF_MAX_VALUE): lv_int,
+        cv.Optional(CONF_START_ANGLE): lv_angle_degrees,
+        cv.Optional(CONF_END_ANGLE): lv_angle_degrees,
+        cv.Optional(CONF_ROTATION): lv_angle_degrees,
+        cv.Optional(CONF_MODE): ARC_MODES.one_of,
+        cv.Optional(CONF_CHANGE_RATE): lv_positive_int,
     }
 )
 
@@ -58,17 +71,34 @@ class ArcType(NumberType):
         )
 
     async def to_code(self, w: Widget, config):
-        if CONF_MIN_VALUE in config:
+        if CONF_MIN_VALUE in config and CONF_MAX_VALUE in config:
             max_value = await lv_int.process(config[CONF_MAX_VALUE])
             min_value = await lv_int.process(config[CONF_MIN_VALUE])
             lv.arc_set_range(w.obj, min_value, max_value)
-            start = await lv_angle_degrees.process(config[CONF_START_ANGLE])
-            end = await lv_angle_degrees.process(config[CONF_END_ANGLE])
-            rotation = await lv_angle_degrees.process(config[CONF_ROTATION])
-            lv.arc_set_bg_angles(w.obj, start, end)
-            lv.arc_set_rotation(w.obj, rotation)
-            lv.arc_set_mode(w.obj, literal(config[CONF_MODE]))
-            lv.arc_set_change_rate(w.obj, config[CONF_CHANGE_RATE])
+        elif CONF_MIN_VALUE in config:
+            max_value = w.get_property(CONF_MAX_VALUE)
+            min_value = await lv_int.process(config[CONF_MIN_VALUE])
+            lv.arc_set_range(w.obj, min_value, max_value)
+        elif CONF_MAX_VALUE in config:
+            max_value = await lv_int.process(config[CONF_MAX_VALUE])
+            min_value = w.get_property(CONF_MIN_VALUE)
+            lv.arc_set_range(w.obj, min_value, max_value)
+
+        await w.set_property(
+            CONF_START_ANGLE,
+            await lv_angle_degrees.process(config.get(CONF_START_ANGLE)),
+        )
+        await w.set_property(
+            CONF_END_ANGLE, await lv_angle_degrees.process(config.get(CONF_END_ANGLE))
+        )
+        await w.set_property(
+            CONF_ROTATION, await lv_angle_degrees.process(config.get(CONF_ROTATION))
+        )
+        await w.set_property(CONF_MODE, config)
+        await w.set_property(
+            CONF_CHANGE_RATE,
+            await lv_positive_int.process(config.get(CONF_CHANGE_RATE)),
+        )
 
         if CONF_ADJUSTABLE in config:
             if not config[CONF_ADJUSTABLE]:
@@ -78,9 +108,7 @@ class ArcType(NumberType):
                 # For some reason arc does not get automatically added to the default group
                 lv.group_add_obj(lv_expr.group_get_default(), w.obj)
 
-        value = await get_start_value(config)
-        if value is not None:
-            lv.arc_set_value(w.obj, value)
+        await w.set_property(CONF_VALUE, await get_start_value(config))
 
 
 arc_spec = ArcType()
diff --git a/tests/components/lvgl/lvgl-package.yaml b/tests/components/lvgl/lvgl-package.yaml
index 5839643638..d54aef8b4a 100644
--- a/tests/components/lvgl/lvgl-package.yaml
+++ b/tests/components/lvgl/lvgl-package.yaml
@@ -781,6 +781,18 @@ lvgl:
                 arc_color: 0xFFFF00
               focused:
                 arc_color: 0x808080
+            on_click:
+              then:
+                - lvgl.arc.update:
+                    id: lv_arc_1
+                    value: !lambda return (int)((float)rand() / RAND_MAX * 100);
+                    min_value: !lambda return (int)((float)rand() / RAND_MAX * 100);
+                    max_value: !lambda return (int)((float)rand() / RAND_MAX * 100);
+                    start_angle: !lambda return (int)((float)rand() / RAND_MAX * 100);
+                    end_angle: !lambda return (int)((float)rand() / RAND_MAX * 100);
+                    rotation: !lambda return (int)((float)rand() / RAND_MAX * 100);
+                    change_rate: !lambda return (uint)((float)rand() / RAND_MAX * 100);
+                    mode: NORMAL
         - bar:
             id: bar_id
             align: top_mid

From 18c97a08c38193e4a2807c254a4ff52f265f2f28 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 01:47:06 -0600
Subject: [PATCH 06/26] [esp8266] Use C++17 nested namespaces and constexpr
 (#12096)

---
 esphome/components/esp8266/core.h          |  4 +---
 esphome/components/esp8266/gpio.cpp        |  9 +++++----
 esphome/components/esp8266/gpio.h          |  6 ++----
 esphome/components/esp8266/preferences.cpp | 20 ++++++++++----------
 esphome/components/esp8266/preferences.h   |  6 ++----
 5 files changed, 20 insertions(+), 25 deletions(-)

diff --git a/esphome/components/esp8266/core.h b/esphome/components/esp8266/core.h
index ac33305669..1abe67be86 100644
--- a/esphome/components/esp8266/core.h
+++ b/esphome/components/esp8266/core.h
@@ -7,8 +7,6 @@
 extern const uint8_t ESPHOME_ESP8266_GPIO_INITIAL_MODE[16];
 extern const uint8_t ESPHOME_ESP8266_GPIO_INITIAL_LEVEL[16];
 
-namespace esphome {
-namespace esp8266 {}  // namespace esp8266
-}  // namespace esphome
+namespace esphome::esp8266 {}  // namespace esphome::esp8266
 
 #endif  // USE_ESP8266
diff --git a/esphome/components/esp8266/gpio.cpp b/esphome/components/esp8266/gpio.cpp
index ee3683c67d..17a495bc1d 100644
--- a/esphome/components/esp8266/gpio.cpp
+++ b/esphome/components/esp8266/gpio.cpp
@@ -3,8 +3,7 @@
 #include "gpio.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace esp8266 {
+namespace esphome::esp8266 {
 
 static const char *const TAG = "esp8266";
 
@@ -110,9 +109,11 @@ void ESP8266GPIOPin::digital_write(bool value) {
 }
 void ESP8266GPIOPin::detach_interrupt() const { detachInterrupt(pin_); }
 
-}  // namespace esp8266
+}  // namespace esphome::esp8266
 
-using namespace esp8266;
+namespace esphome {
+
+using esp8266::ISRPinArg;
 
 bool IRAM_ATTR ISRInternalGPIOPin::digital_read() {
   auto *arg = reinterpret_cast<ISRPinArg *>(this->arg_);
diff --git a/esphome/components/esp8266/gpio.h b/esphome/components/esp8266/gpio.h
index a1b6d79b3b..213a5c54be 100644
--- a/esphome/components/esp8266/gpio.h
+++ b/esphome/components/esp8266/gpio.h
@@ -5,8 +5,7 @@
 #include "esphome/core/hal.h"
 #include <Arduino.h>
 
-namespace esphome {
-namespace esp8266 {
+namespace esphome::esp8266 {
 
 class ESP8266GPIOPin : public InternalGPIOPin {
  public:
@@ -33,7 +32,6 @@ class ESP8266GPIOPin : public InternalGPIOPin {
   gpio::Flags flags_{};
 };
 
-}  // namespace esp8266
-}  // namespace esphome
+}  // namespace esphome::esp8266
 
 #endif  // USE_ESP8266
diff --git a/esphome/components/esp8266/preferences.cpp b/esphome/components/esp8266/preferences.cpp
index a26e9cc498..197d244dc4 100644
--- a/esphome/components/esp8266/preferences.cpp
+++ b/esphome/components/esp8266/preferences.cpp
@@ -15,24 +15,24 @@ extern "C" {
 #include <cstring>
 #include <memory>
 
-namespace esphome {
-namespace esp8266 {
+namespace esphome::esp8266 {
 
 static const char *const TAG = "esp8266.preferences";
 
-static bool s_prevent_write = false;         // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 static uint32_t *s_flash_storage = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static bool s_prevent_write = false;         // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 static bool s_flash_dirty = false;           // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-static const uint32_t ESP_RTC_USER_MEM_START = 0x60001200;
+static constexpr uint32_t ESP_RTC_USER_MEM_START = 0x60001200;
+static constexpr uint32_t ESP_RTC_USER_MEM_SIZE_WORDS = 128;
+static constexpr uint32_t ESP_RTC_USER_MEM_SIZE_BYTES = ESP_RTC_USER_MEM_SIZE_WORDS * 4;
+
 #define ESP_RTC_USER_MEM ((uint32_t *) ESP_RTC_USER_MEM_START)
-static const uint32_t ESP_RTC_USER_MEM_SIZE_WORDS = 128;
-static const uint32_t ESP_RTC_USER_MEM_SIZE_BYTES = ESP_RTC_USER_MEM_SIZE_WORDS * 4;
 
 #ifdef USE_ESP8266_PREFERENCES_FLASH
-static const uint32_t ESP8266_FLASH_STORAGE_SIZE = 128;
+static constexpr uint32_t ESP8266_FLASH_STORAGE_SIZE = 128;
 #else
-static const uint32_t ESP8266_FLASH_STORAGE_SIZE = 64;
+static constexpr uint32_t ESP8266_FLASH_STORAGE_SIZE = 64;
 #endif
 
 static inline bool esp_rtc_user_mem_read(uint32_t index, uint32_t *dest) {
@@ -284,10 +284,10 @@ void setup_preferences() {
 }
 void preferences_prevent_write(bool prevent) { s_prevent_write = prevent; }
 
-}  // namespace esp8266
+}  // namespace esphome::esp8266
 
+namespace esphome {
 ESPPreferences *global_preferences;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
 }  // namespace esphome
 
 #endif  // USE_ESP8266
diff --git a/esphome/components/esp8266/preferences.h b/esphome/components/esp8266/preferences.h
index edec915794..16cf80a129 100644
--- a/esphome/components/esp8266/preferences.h
+++ b/esphome/components/esp8266/preferences.h
@@ -2,13 +2,11 @@
 
 #ifdef USE_ESP8266
 
-namespace esphome {
-namespace esp8266 {
+namespace esphome::esp8266 {
 
 void setup_preferences();
 void preferences_prevent_write(bool prevent);
 
-}  // namespace esp8266
-}  // namespace esphome
+}  // namespace esphome::esp8266
 
 #endif  // USE_ESP8266

From 697c5f424ebf0aa9c07693cce2c1c79675b164f4 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 02:17:53 -0600
Subject: [PATCH 07/26] [api] Use const char* pointers for light effects to
 eliminate heap allocations (#12090)

---
 esphome/components/api/api.proto          |  2 +-
 esphome/components/api/api_connection.cpp | 10 +++++++---
 esphome/components/api/api_pb2.cpp        | 10 +++++-----
 esphome/components/api/api_pb2.h          |  2 +-
 esphome/components/api/api_pb2_dump.cpp   |  2 +-
 5 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto
index 26d1fa6876..74a8e8ff7f 100644
--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@@ -518,7 +518,7 @@ message ListEntitiesLightResponse {
   bool legacy_supports_color_temperature = 8 [deprecated=true];
   float min_mireds = 9;
   float max_mireds = 10;
-  repeated string effects = 11;
+  repeated string effects = 11 [(container_pointer_no_template) = "FixedVector<const char *>"];
   bool disabled_by_default = 13;
   string icon = 14 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 15;
diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index ebfc641537..12cbbb991d 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -484,12 +484,16 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
     msg.min_mireds = traits.get_min_mireds();
     msg.max_mireds = traits.get_max_mireds();
   }
+  FixedVector<const char *> effects_list;
   if (light->supports_effects()) {
-    msg.effects.emplace_back("None");
-    for (auto *effect : light->get_effects()) {
-      msg.effects.emplace_back(effect->get_name());
+    auto &light_effects = light->get_effects();
+    effects_list.init(light_effects.size() + 1);
+    effects_list.push_back("None");
+    for (auto *effect : light_effects) {
+      effects_list.push_back(effect->get_name());
     }
   }
+  msg.effects = &effects_list;
   return fill_and_encode_entity_info(light, msg, ListEntitiesLightResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index d52135a566..c131815456 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -476,8 +476,8 @@ void ListEntitiesLightResponse::encode(ProtoWriteBuffer buffer) const {
   }
   buffer.encode_float(9, this->min_mireds);
   buffer.encode_float(10, this->max_mireds);
-  for (auto &it : this->effects) {
-    buffer.encode_string(11, it, true);
+  for (const char *it : *this->effects) {
+    buffer.encode_string(11, it, strlen(it), true);
   }
   buffer.encode_bool(13, this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
@@ -499,9 +499,9 @@ void ListEntitiesLightResponse::calculate_size(ProtoSize &size) const {
   }
   size.add_float(1, this->min_mireds);
   size.add_float(1, this->max_mireds);
-  if (!this->effects.empty()) {
-    for (const auto &it : this->effects) {
-      size.add_length_force(1, it.size());
+  if (!this->effects->empty()) {
+    for (const char *it : *this->effects) {
+      size.add_length_force(1, strlen(it));
     }
   }
   size.add_bool(1, this->disabled_by_default);
diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index b19e92d4ff..93ece74d85 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -793,7 +793,7 @@ class ListEntitiesLightResponse final : public InfoResponseProtoMessage {
   const light::ColorModeMask *supported_color_modes{};
   float min_mireds{0.0f};
   float max_mireds{0.0f};
-  std::vector<std::string> effects{};
+  const FixedVector<const char *> *effects{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
diff --git a/esphome/components/api/api_pb2_dump.cpp b/esphome/components/api/api_pb2_dump.cpp
index ea752ba3ba..a985e052ac 100644
--- a/esphome/components/api/api_pb2_dump.cpp
+++ b/esphome/components/api/api_pb2_dump.cpp
@@ -924,7 +924,7 @@ void ListEntitiesLightResponse::dump_to(std::string &out) const {
   }
   dump_field(out, "min_mireds", this->min_mireds);
   dump_field(out, "max_mireds", this->max_mireds);
-  for (const auto &it : this->effects) {
+  for (const auto &it : *this->effects) {
     dump_field(out, "effects", it, 4);
   }
   dump_field(out, "disabled_by_default", this->disabled_by_default);

From c30b92019347b681698551857e06eddac406a1d7 Mon Sep 17 00:00:00 2001
From: Edward Firmo <94725493+edwardtfn@users.noreply.github.com>
Date: Tue, 25 Nov 2025 13:48:32 +0100
Subject: [PATCH 08/26] [nextion] Do not set alternative baud rate when not
 specified or `<= 0` (#12097)

---
 esphome/components/nextion/nextion_upload_arduino.cpp | 3 +++
 esphome/components/nextion/nextion_upload_idf.cpp     | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/esphome/components/nextion/nextion_upload_arduino.cpp b/esphome/components/nextion/nextion_upload_arduino.cpp
index b4d217d7aa..baea938729 100644
--- a/esphome/components/nextion/nextion_upload_arduino.cpp
+++ b/esphome/components/nextion/nextion_upload_arduino.cpp
@@ -174,6 +174,9 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   // Check if baud rate is supported
   this->original_baud_rate_ = this->parent_->get_baud_rate();
+  if (baud_rate <= 0) {
+    baud_rate = this->original_baud_rate_;
+  }
   ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
 
   // Define the configuration for the HTTP client
diff --git a/esphome/components/nextion/nextion_upload_idf.cpp b/esphome/components/nextion/nextion_upload_idf.cpp
index 3b0d65643d..942e3dd6c3 100644
--- a/esphome/components/nextion/nextion_upload_idf.cpp
+++ b/esphome/components/nextion/nextion_upload_idf.cpp
@@ -177,6 +177,9 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   // Check if baud rate is supported
   this->original_baud_rate_ = this->parent_->get_baud_rate();
+  if (baud_rate <= 0) {
+    baud_rate = this->original_baud_rate_;
+  }
   ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
 
   // Define the configuration for the HTTP client

From cdf27f144766759efc1bb809a5f7631cc8a7cf85 Mon Sep 17 00:00:00 2001
From: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Date: Tue, 25 Nov 2025 11:14:53 -0500
Subject: [PATCH 09/26] [esp32] Fix platformio flash size print (#12099)

Co-authored-by: J. Nick Koston <nick+github@koston.org>
---
 esphome/components/esp32/__init__.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/esphome/components/esp32/__init__.py b/esphome/components/esp32/__init__.py
index 59c6029334..d372af3e6a 100644
--- a/esphome/components/esp32/__init__.py
+++ b/esphome/components/esp32/__init__.py
@@ -854,6 +854,10 @@ def _configure_lwip_max_sockets(conf: dict) -> None:
 async def to_code(config):
     cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_platformio_option("board_upload.flash_size", config[CONF_FLASH_SIZE])
+    cg.add_platformio_option(
+        "board_upload.maximum_size",
+        int(config[CONF_FLASH_SIZE].removesuffix("MB")) * 1024 * 1024,
+    )
     cg.set_cpp_standard("gnu++20")
     cg.add_build_flag("-DUSE_ESP32")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])

From a571033b43f3418c54f42ef078b357b90b6f8bed Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 10:30:01 -0600
Subject: [PATCH 10/26] [script] Fix script.wait hanging when triggered from
 on_boot (#12102)

---
 esphome/components/script/script.h            |   7 +-
 .../fixtures/script_wait_on_boot.yaml         |  54 ++++++++
 tests/integration/test_script_wait_on_boot.py | 130 ++++++++++++++++++
 3 files changed, 190 insertions(+), 1 deletion(-)
 create mode 100644 tests/integration/fixtures/script_wait_on_boot.yaml
 create mode 100644 tests/integration/test_script_wait_on_boot.py

diff --git a/esphome/components/script/script.h b/esphome/components/script/script.h
index d60ed657f7..3a0823f3cc 100644
--- a/esphome/components/script/script.h
+++ b/esphome/components/script/script.h
@@ -278,7 +278,12 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
 
   void setup() override {
     // Start with loop disabled - only enable when there's work to do
-    this->disable_loop();
+    // IMPORTANT: Only disable if num_running_ is 0, otherwise play_complex() was already
+    // called before our setup() (e.g., from on_boot trigger at same priority level)
+    // and we must not undo its enable_loop() call
+    if (this->num_running_ == 0) {
+      this->disable_loop();
+    }
   }
 
   void play_complex(const Ts &...x) override {
diff --git a/tests/integration/fixtures/script_wait_on_boot.yaml b/tests/integration/fixtures/script_wait_on_boot.yaml
new file mode 100644
index 0000000000..8736b02294
--- /dev/null
+++ b/tests/integration/fixtures/script_wait_on_boot.yaml
@@ -0,0 +1,54 @@
+esphome:
+  name: test-script-wait-on-boot
+  on_boot:
+    # Use default priority (600.0) which is same as ScriptWaitAction's setup priority
+    # This tests the race condition where on_boot runs before ScriptWaitAction::setup()
+    then:
+      - logger.log: "=== on_boot: Starting boot sequence ==="
+      - script.execute: show_start_page
+      - script.wait: show_start_page
+      - logger.log: "=== on_boot: First script completed, starting second ==="
+      - script.execute: flip_thru_pages
+      - script.wait: flip_thru_pages
+      - logger.log: "=== on_boot: All boot scripts completed successfully ==="
+
+host:
+
+api:
+  actions:
+    # Manual trigger for additional testing
+    - action: test_script_wait
+      then:
+        - logger.log: "=== Manual test: Starting ==="
+        - script.execute: show_start_page
+        - script.wait: show_start_page
+        - logger.log: "=== Manual test: First script completed ==="
+        - script.execute: flip_thru_pages
+        - script.wait: flip_thru_pages
+        - logger.log: "=== Manual test: All completed ==="
+
+logger:
+  level: DEBUG
+
+script:
+  # First script - simulates display initialization
+  - id: show_start_page
+    mode: single
+    then:
+      - logger.log: "show_start_page: Starting"
+      - delay: 100ms
+      - logger.log: "show_start_page: After delay 1"
+      - delay: 100ms
+      - logger.log: "show_start_page: Completed"
+
+  # Second script - simulates page flip sequence
+  - id: flip_thru_pages
+    mode: single
+    then:
+      - logger.log: "flip_thru_pages: Starting"
+      - delay: 50ms
+      - logger.log: "flip_thru_pages: Page 1"
+      - delay: 50ms
+      - logger.log: "flip_thru_pages: Page 2"
+      - delay: 50ms
+      - logger.log: "flip_thru_pages: Completed"
diff --git a/tests/integration/test_script_wait_on_boot.py b/tests/integration/test_script_wait_on_boot.py
new file mode 100644
index 0000000000..478090f782
--- /dev/null
+++ b/tests/integration/test_script_wait_on_boot.py
@@ -0,0 +1,130 @@
+"""Integration test for script.wait during on_boot (issue #12043).
+
+This test verifies that script.wait works correctly when triggered from on_boot.
+The issue was that ScriptWaitAction::setup() unconditionally disabled the loop,
+even if play_complex() had already been called (from an on_boot trigger at the
+same priority level) and enabled it.
+
+The race condition occurs because:
+1. on_boot's default priority is 600.0 (setup_priority::DATA)
+2. ScriptWaitAction's default setup priority is also DATA (600.0)
+3. When they have the same priority, if on_boot runs first and triggers a script,
+   ScriptWaitAction::play_complex() enables the loop
+4. Then ScriptWaitAction::setup() runs and unconditionally disables the loop
+5. The wait never completes because the loop is disabled
+
+The fix adds a conditional check (like WaitUntilAction has) to only disable the
+loop in setup() if num_running_ is 0.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_script_wait_on_boot(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test that script.wait works correctly when triggered from on_boot.
+
+    This reproduces issue #12043 where script.wait would hang forever when
+    triggered from on_boot due to a race condition in ScriptWaitAction::setup().
+    """
+    test_complete = asyncio.Event()
+
+    # Track progress through the boot sequence
+    boot_started = False
+    first_script_started = False
+    first_script_completed = False
+    first_wait_returned = False
+    second_script_started = False
+    second_script_completed = False
+    all_completed = False
+
+    # Patterns for boot sequence logs
+    boot_start_pattern = re.compile(r"on_boot: Starting boot sequence")
+    show_start_pattern = re.compile(r"show_start_page: Starting")
+    show_complete_pattern = re.compile(r"show_start_page: Completed")
+    first_wait_pattern = re.compile(r"on_boot: First script completed")
+    flip_start_pattern = re.compile(r"flip_thru_pages: Starting")
+    flip_complete_pattern = re.compile(r"flip_thru_pages: Completed")
+    all_complete_pattern = re.compile(r"on_boot: All boot scripts completed")
+
+    def check_output(line: str) -> None:
+        """Check log output for boot sequence progress."""
+        nonlocal boot_started, first_script_started, first_script_completed
+        nonlocal first_wait_returned, second_script_started, second_script_completed
+        nonlocal all_completed
+
+        if boot_start_pattern.search(line):
+            boot_started = True
+        elif show_start_pattern.search(line):
+            first_script_started = True
+        elif show_complete_pattern.search(line):
+            first_script_completed = True
+        elif first_wait_pattern.search(line):
+            first_wait_returned = True
+        elif flip_start_pattern.search(line):
+            second_script_started = True
+        elif flip_complete_pattern.search(line):
+            second_script_completed = True
+        elif all_complete_pattern.search(line):
+            all_completed = True
+            test_complete.set()
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        # Verify device info
+        device_info = await client.device_info()
+        assert device_info is not None
+        assert device_info.name == "test-script-wait-on-boot"
+
+        # Wait for on_boot sequence to complete
+        # The boot sequence should complete automatically
+        # Timeout is generous to allow for delays in the scripts
+        try:
+            await asyncio.wait_for(test_complete.wait(), timeout=5.0)
+        except TimeoutError:
+            # Build a detailed error message showing where the boot sequence got stuck
+            progress = []
+            if boot_started:
+                progress.append("boot started")
+            if first_script_started:
+                progress.append("show_start_page started")
+            if first_script_completed:
+                progress.append("show_start_page completed")
+            if first_wait_returned:
+                progress.append("first script.wait returned")
+            if second_script_started:
+                progress.append("flip_thru_pages started")
+            if second_script_completed:
+                progress.append("flip_thru_pages completed")
+
+            if not first_wait_returned and first_script_completed:
+                pytest.fail(
+                    f"Test timed out - script.wait hung after show_start_page completed! "
+                    f"This is the issue #12043 bug. Progress: {', '.join(progress)}"
+                )
+            else:
+                pytest.fail(
+                    f"Test timed out. Progress: {', '.join(progress) if progress else 'none'}"
+                )
+
+        # Verify the complete boot sequence executed in order
+        assert boot_started, "on_boot did not start"
+        assert first_script_started, "show_start_page did not start"
+        assert first_script_completed, "show_start_page did not complete"
+        assert first_wait_returned, "First script.wait did not return"
+        assert second_script_started, "flip_thru_pages did not start"
+        assert second_script_completed, "flip_thru_pages did not complete"
+        assert all_completed, "Boot sequence did not complete"

From cf8c2056444bf5b6f02accf6a8480b913d0f1c67 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 12:15:45 -0600
Subject: [PATCH 11/26] [core] Reduce flash size by combining set_name() and
 set_object_id() calls (#11941)

---
 esphome/core/entity_base.cpp                      |  6 ++++++
 esphome/core/entity_base.h                        |  3 +++
 esphome/core/entity_helpers.py                    |  6 ++----
 .../binary_sensor/test_binary_sensor.py           |  2 +-
 tests/component_tests/button/test_button.py       |  2 +-
 tests/component_tests/text/test_text.py           |  2 +-
 .../text_sensor/test_text_sensor.py               | 15 ++++++++++++---
 tests/unit_tests/core/test_entity_helpers.py      | 13 ++++++++++---
 8 files changed, 36 insertions(+), 13 deletions(-)

diff --git a/esphome/core/entity_base.cpp b/esphome/core/entity_base.cpp
index 4883c72cf1..046f99d8cc 100644
--- a/esphome/core/entity_base.cpp
+++ b/esphome/core/entity_base.cpp
@@ -74,6 +74,12 @@ void EntityBase::set_object_id(const char *object_id) {
   this->calc_object_id_();
 }
 
+void EntityBase::set_name_and_object_id(const char *name, const char *object_id) {
+  this->set_name(name);
+  this->object_id_c_str_ = object_id;
+  this->calc_object_id_();
+}
+
 // Calculate Object ID Hash from Entity Name
 void EntityBase::calc_object_id_() {
   this->object_id_hash_ =
diff --git a/esphome/core/entity_base.h b/esphome/core/entity_base.h
index 2b52d66f76..aa9b92877a 100644
--- a/esphome/core/entity_base.h
+++ b/esphome/core/entity_base.h
@@ -41,6 +41,9 @@ class EntityBase {
   std::string get_object_id() const;
   void set_object_id(const char *object_id);
 
+  // Set both name and object_id in one call (reduces generated code size)
+  void set_name_and_object_id(const char *name, const char *object_id);
+
   // Get the unique Object ID of this Entity
   uint32_t get_object_id_hash();
 
diff --git a/esphome/core/entity_helpers.py b/esphome/core/entity_helpers.py
index 9b4786f835..f360b4d809 100644
--- a/esphome/core/entity_helpers.py
+++ b/esphome/core/entity_helpers.py
@@ -84,8 +84,6 @@ async def setup_entity(var: MockObj, config: ConfigType, platform: str) -> None:
         # Get device name for object ID calculation
         device_name = device_id_obj.id
 
-    add(var.set_name(config[CONF_NAME]))
-
     # Calculate base object_id using the same logic as C++
     # This must match the C++ behavior in esphome/core/entity_base.cpp
     base_object_id = get_base_entity_object_id(
@@ -97,8 +95,8 @@ async def setup_entity(var: MockObj, config: ConfigType, platform: str) -> None:
             "Entity has empty name, using '%s' as object_id base", base_object_id
         )
 
-    # Set the object ID
-    add(var.set_object_id(base_object_id))
+    # Set both name and object_id in one call to reduce generated code size
+    add(var.set_name_and_object_id(config[CONF_NAME], base_object_id))
     _LOGGER.debug(
         "Setting object_id '%s' for entity '%s' on platform '%s'",
         base_object_id,
diff --git a/tests/component_tests/binary_sensor/test_binary_sensor.py b/tests/component_tests/binary_sensor/test_binary_sensor.py
index 32d74027ba..86e0705023 100644
--- a/tests/component_tests/binary_sensor/test_binary_sensor.py
+++ b/tests/component_tests/binary_sensor/test_binary_sensor.py
@@ -29,7 +29,7 @@ def test_binary_sensor_sets_mandatory_fields(generate_main):
     )
 
     # Then
-    assert 'bs_1->set_name("test bs1");' in main_cpp
+    assert 'bs_1->set_name_and_object_id("test bs1", "test_bs1");' in main_cpp
     assert "bs_1->set_pin(" in main_cpp
 
 
diff --git a/tests/component_tests/button/test_button.py b/tests/component_tests/button/test_button.py
index 512ef42b44..b21665288c 100644
--- a/tests/component_tests/button/test_button.py
+++ b/tests/component_tests/button/test_button.py
@@ -26,7 +26,7 @@ def test_button_sets_mandatory_fields(generate_main):
     main_cpp = generate_main("tests/component_tests/button/test_button.yaml")
 
     # Then
-    assert 'wol_1->set_name("wol_test_1");' in main_cpp
+    assert 'wol_1->set_name_and_object_id("wol_test_1", "wol_test_1");' in main_cpp
     assert "wol_2->set_macaddr(18, 52, 86, 120, 144, 171);" in main_cpp
 
 
diff --git a/tests/component_tests/text/test_text.py b/tests/component_tests/text/test_text.py
index 99ddd78ee7..bfc3131f6d 100644
--- a/tests/component_tests/text/test_text.py
+++ b/tests/component_tests/text/test_text.py
@@ -25,7 +25,7 @@ def test_text_sets_mandatory_fields(generate_main):
     main_cpp = generate_main("tests/component_tests/text/test_text.yaml")
 
     # Then
-    assert 'it_1->set_name("test 1 text");' in main_cpp
+    assert 'it_1->set_name_and_object_id("test 1 text", "test_1_text");' in main_cpp
 
 
 def test_text_config_value_internal_set(generate_main):
diff --git a/tests/component_tests/text_sensor/test_text_sensor.py b/tests/component_tests/text_sensor/test_text_sensor.py
index 1c4ef6633d..934ee67cef 100644
--- a/tests/component_tests/text_sensor/test_text_sensor.py
+++ b/tests/component_tests/text_sensor/test_text_sensor.py
@@ -25,9 +25,18 @@ def test_text_sensor_sets_mandatory_fields(generate_main):
     main_cpp = generate_main("tests/component_tests/text_sensor/test_text_sensor.yaml")
 
     # Then
-    assert 'ts_1->set_name("Template Text Sensor 1");' in main_cpp
-    assert 'ts_2->set_name("Template Text Sensor 2");' in main_cpp
-    assert 'ts_3->set_name("Template Text Sensor 3");' in main_cpp
+    assert (
+        'ts_1->set_name_and_object_id("Template Text Sensor 1", "template_text_sensor_1");'
+        in main_cpp
+    )
+    assert (
+        'ts_2->set_name_and_object_id("Template Text Sensor 2", "template_text_sensor_2");'
+        in main_cpp
+    )
+    assert (
+        'ts_3->set_name_and_object_id("Template Text Sensor 3", "template_text_sensor_3");'
+        in main_cpp
+    )
 
 
 def test_text_sensor_config_value_internal_set(generate_main):
diff --git a/tests/unit_tests/core/test_entity_helpers.py b/tests/unit_tests/core/test_entity_helpers.py
index 9ba5367413..01de0f27f9 100644
--- a/tests/unit_tests/core/test_entity_helpers.py
+++ b/tests/unit_tests/core/test_entity_helpers.py
@@ -27,8 +27,13 @@ from esphome.helpers import sanitize, snake_case
 
 from .common import load_config_from_fixture
 
-# Pre-compiled regex pattern for extracting object IDs from expressions
+# Pre-compiled regex patterns for extracting object IDs from expressions
+# Matches both old format: .set_object_id("obj_id")
+# and new format: .set_name_and_object_id("name", "obj_id")
 OBJECT_ID_PATTERN = re.compile(r'\.set_object_id\(["\'](.*?)["\']\)')
+COMBINED_PATTERN = re.compile(
+    r'\.set_name_and_object_id\(["\'].*?["\']\s*,\s*["\'](.*?)["\']\)'
+)
 
 FIXTURES_DIR = Path(__file__).parent.parent / "fixtures" / "core" / "entity_helpers"
 
@@ -273,8 +278,10 @@ def setup_test_environment() -> Generator[list[str], None, None]:
 def extract_object_id_from_expressions(expressions: list[str]) -> str | None:
     """Extract the object ID that was set from the generated expressions."""
     for expr in expressions:
-        # Look for set_object_id calls with regex to handle various formats
-        # Matches: var.set_object_id("temperature_2") or var.set_object_id('temperature_2')
+        # First try new combined format: .set_name_and_object_id("name", "obj_id")
+        if match := COMBINED_PATTERN.search(expr):
+            return match.group(1)
+        # Fall back to old format: .set_object_id("obj_id")
         if match := OBJECT_ID_PATTERN.search(expr):
             return match.group(1)
     return None

From 8c5985f68a4cc8e14e84b90577e98255ac1a51e1 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 12:16:02 -0600
Subject: [PATCH 12/26] [web_server] Consolidate turn_on/turn_off handlers to
 eliminate duplicate lambdas (#12094)

---
 esphome/components/web_server/web_server.cpp | 65 +++++++++++---------
 1 file changed, 36 insertions(+), 29 deletions(-)

diff --git a/esphome/components/web_server/web_server.cpp b/esphome/components/web_server/web_server.cpp
index cc51463fe7..6bf6524fbc 100644
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -690,8 +690,14 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
     } else if (match.method_equals("toggle")) {
       this->defer([obj]() { obj->toggle().perform(); });
       request->send(200);
-    } else if (match.method_equals("turn_on") || match.method_equals("turn_off")) {
-      auto call = match.method_equals("turn_on") ? obj->turn_on() : obj->turn_off();
+    } else {
+      bool is_on = match.method_equals("turn_on");
+      bool is_off = match.method_equals("turn_off");
+      if (!is_on && !is_off) {
+        request->send(404);
+        return;
+      }
+      auto call = is_on ? obj->turn_on() : obj->turn_off();
 
       parse_int_param_(request, "speed_level", call, &decltype(call)::set_speed);
 
@@ -715,8 +721,6 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
       }
       this->defer([call]() mutable { call.perform(); });
       request->send(200);
-    } else {
-      request->send(404);
     }
     return;
   }
@@ -766,32 +770,35 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
     } else if (match.method_equals("toggle")) {
       this->defer([obj]() { obj->toggle().perform(); });
       request->send(200);
-    } else if (match.method_equals("turn_on")) {
-      auto call = obj->turn_on();
-
-      // Parse color parameters
-      parse_light_param_(request, "brightness", call, &decltype(call)::set_brightness, 255.0f);
-      parse_light_param_(request, "r", call, &decltype(call)::set_red, 255.0f);
-      parse_light_param_(request, "g", call, &decltype(call)::set_green, 255.0f);
-      parse_light_param_(request, "b", call, &decltype(call)::set_blue, 255.0f);
-      parse_light_param_(request, "white_value", call, &decltype(call)::set_white, 255.0f);
-      parse_light_param_(request, "color_temp", call, &decltype(call)::set_color_temperature);
-
-      // Parse timing parameters
-      parse_light_param_uint_(request, "flash", call, &decltype(call)::set_flash_length, 1000);
-      parse_light_param_uint_(request, "transition", call, &decltype(call)::set_transition_length, 1000);
-
-      parse_string_param_(request, "effect", call, &decltype(call)::set_effect);
-
-      this->defer([call]() mutable { call.perform(); });
-      request->send(200);
-    } else if (match.method_equals("turn_off")) {
-      auto call = obj->turn_off();
-      parse_light_param_uint_(request, "transition", call, &decltype(call)::set_transition_length, 1000);
-      this->defer([call]() mutable { call.perform(); });
-      request->send(200);
     } else {
-      request->send(404);
+      bool is_on = match.method_equals("turn_on");
+      bool is_off = match.method_equals("turn_off");
+      if (!is_on && !is_off) {
+        request->send(404);
+        return;
+      }
+      auto call = is_on ? obj->turn_on() : obj->turn_off();
+
+      if (is_on) {
+        // Parse color parameters
+        parse_light_param_(request, "brightness", call, &decltype(call)::set_brightness, 255.0f);
+        parse_light_param_(request, "r", call, &decltype(call)::set_red, 255.0f);
+        parse_light_param_(request, "g", call, &decltype(call)::set_green, 255.0f);
+        parse_light_param_(request, "b", call, &decltype(call)::set_blue, 255.0f);
+        parse_light_param_(request, "white_value", call, &decltype(call)::set_white, 255.0f);
+        parse_light_param_(request, "color_temp", call, &decltype(call)::set_color_temperature);
+
+        // Parse timing parameters
+        parse_light_param_uint_(request, "flash", call, &decltype(call)::set_flash_length, 1000);
+      }
+      parse_light_param_uint_(request, "transition", call, &decltype(call)::set_transition_length, 1000);
+
+      if (is_on) {
+        parse_string_param_(request, "effect", call, &decltype(call)::set_effect);
+      }
+
+      this->defer([call]() mutable { call.perform(); });
+      request->send(200);
     }
     return;
   }

From 310693467819523eea3a53b2a1681db50aec3e36 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 12:16:27 -0600
Subject: [PATCH 13/26] [esp32_ble] Optimize name storage to reduce RAM and
 eliminate heap allocations (#12071)

---
 esphome/components/esp32_ble/ble.cpp | 31 ++++++++++++++++++----------
 esphome/components/esp32_ble/ble.h   |  6 ++----
 esphome/core/application.h           |  8 ++++---
 esphome/core/helpers.cpp             | 10 ++++++---
 esphome/core/helpers.h               | 11 ++++++++++
 5 files changed, 45 insertions(+), 21 deletions(-)

diff --git a/esphome/components/esp32_ble/ble.cpp b/esphome/components/esp32_ble/ble.cpp
index d0bfb6f843..a0ed9ee90c 100644
--- a/esphome/components/esp32_ble/ble.cpp
+++ b/esphome/components/esp32_ble/ble.cpp
@@ -256,29 +256,38 @@ bool ESP32BLE::ble_setup_() {
   }
 #endif
 
-  std::string name;
-  if (this->name_.has_value()) {
-    name = this->name_.value();
+  const char *device_name;
+  std::string name_with_suffix;
+
+  if (this->name_ != nullptr) {
     if (App.is_name_add_mac_suffix_enabled()) {
+      // MAC address length: 12 hex chars + null terminator
+      constexpr size_t mac_address_len = 13;
       // MAC address suffix length (last 6 characters of 12-char MAC address string)
       constexpr size_t mac_address_suffix_len = 6;
-      const std::string mac_addr = get_mac_address();
-      const char *mac_suffix_ptr = mac_addr.c_str() + mac_address_suffix_len;
-      name = make_name_with_suffix(name, '-', mac_suffix_ptr, mac_address_suffix_len);
+      char mac_addr[mac_address_len];
+      get_mac_address_into_buffer(mac_addr);
+      const char *mac_suffix_ptr = mac_addr + mac_address_suffix_len;
+      name_with_suffix =
+          make_name_with_suffix(this->name_, strlen(this->name_), '-', mac_suffix_ptr, mac_address_suffix_len);
+      device_name = name_with_suffix.c_str();
+    } else {
+      device_name = this->name_;
     }
   } else {
-    name = App.get_name();
-    if (name.length() > 20) {
+    name_with_suffix = App.get_name();
+    if (name_with_suffix.length() > 20) {
       if (App.is_name_add_mac_suffix_enabled()) {
         // Keep first 13 chars and last 7 chars (MAC suffix), remove middle
-        name.erase(13, name.length() - 20);
+        name_with_suffix.erase(13, name_with_suffix.length() - 20);
       } else {
-        name.resize(20);
+        name_with_suffix.resize(20);
       }
     }
+    device_name = name_with_suffix.c_str();
   }
 
-  err = esp_ble_gap_set_device_name(name.c_str());
+  err = esp_ble_gap_set_device_name(device_name);
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "esp_ble_gap_set_device_name failed: %d", err);
     return false;
diff --git a/esphome/components/esp32_ble/ble.h b/esphome/components/esp32_ble/ble.h
index 2fb60bb822..393ec2e911 100644
--- a/esphome/components/esp32_ble/ble.h
+++ b/esphome/components/esp32_ble/ble.h
@@ -112,7 +112,7 @@ class ESP32BLE : public Component {
   void loop() override;
   void dump_config() override;
   float get_setup_priority() const override;
-  void set_name(const std::string &name) { this->name_ = name; }
+  void set_name(const char *name) { this->name_ = name; }
 
 #ifdef USE_ESP32_BLE_ADVERTISING
   void advertising_start();
@@ -191,13 +191,11 @@ class ESP32BLE : public Component {
   esphome::LockFreeQueue<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_events_;
   esphome::EventPool<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_event_pool_;
 
-  // optional<string> (typically 16+ bytes on 32-bit, aligned to 4 bytes)
-  optional<std::string> name_;
-
   // 4-byte aligned members
 #ifdef USE_ESP32_BLE_ADVERTISING
   BLEAdvertising *advertising_{};  // 4 bytes (pointer)
 #endif
+  const char *name_{nullptr};                 // 4 bytes (pointer to string literal in flash)
   esp_ble_io_cap_t io_cap_{ESP_IO_CAP_NONE};  // 4 bytes (enum)
   uint32_t advertising_cycle_time_{};         // 4 bytes
 
diff --git a/esphome/core/application.h b/esphome/core/application.h
index dae44d8902..14e800342e 100644
--- a/esphome/core/application.h
+++ b/esphome/core/application.h
@@ -105,11 +105,13 @@ class Application {
     arch_init();
     this->name_add_mac_suffix_ = name_add_mac_suffix;
     if (name_add_mac_suffix) {
+      // MAC address length: 12 hex chars + null terminator
+      constexpr size_t mac_address_len = 13;
       // MAC address suffix length (last 6 characters of 12-char MAC address string)
       constexpr size_t mac_address_suffix_len = 6;
-      const std::string mac_addr = get_mac_address();
-      // Use pointer + offset to avoid substr() allocation
-      const char *mac_suffix_ptr = mac_addr.c_str() + mac_address_suffix_len;
+      char mac_addr[mac_address_len];
+      get_mac_address_into_buffer(mac_addr);
+      const char *mac_suffix_ptr = mac_addr + mac_address_suffix_len;
       this->name_ = make_name_with_suffix(name, '-', mac_suffix_ptr, mac_address_suffix_len);
       if (!friendly_name.empty()) {
         this->friendly_name_ = make_name_with_suffix(friendly_name, ' ', mac_suffix_ptr, mac_address_suffix_len);
diff --git a/esphome/core/helpers.cpp b/esphome/core/helpers.cpp
index 50af71649c..1f675563c7 100644
--- a/esphome/core/helpers.cpp
+++ b/esphome/core/helpers.cpp
@@ -238,9 +238,9 @@ std::string str_sprintf(const char *fmt, ...) {
 // Maximum size for name with suffix: 120 (max friendly name) + 1 (separator) + 6 (MAC suffix) + 1 (null term)
 static constexpr size_t MAX_NAME_WITH_SUFFIX_SIZE = 128;
 
-std::string make_name_with_suffix(const std::string &name, char sep, const char *suffix_ptr, size_t suffix_len) {
+std::string make_name_with_suffix(const char *name, size_t name_len, char sep, const char *suffix_ptr,
+                                  size_t suffix_len) {
   char buffer[MAX_NAME_WITH_SUFFIX_SIZE];
-  size_t name_len = name.size();
   size_t total_len = name_len + 1 + suffix_len;
 
   // Silently truncate if needed: prioritize keeping the full suffix
@@ -252,13 +252,17 @@ std::string make_name_with_suffix(const std::string &name, char sep, const char
     total_len = name_len + 1 + suffix_len;
   }
 
-  memcpy(buffer, name.c_str(), name_len);
+  memcpy(buffer, name, name_len);
   buffer[name_len] = sep;
   memcpy(buffer + name_len + 1, suffix_ptr, suffix_len);
   buffer[total_len] = '\0';
   return std::string(buffer, total_len);
 }
 
+std::string make_name_with_suffix(const std::string &name, char sep, const char *suffix_ptr, size_t suffix_len) {
+  return make_name_with_suffix(name.c_str(), name.size(), sep, suffix_ptr, suffix_len);
+}
+
 // Parsing & formatting
 
 size_t parse_hex(const char *str, size_t length, uint8_t *data, size_t count) {
diff --git a/esphome/core/helpers.h b/esphome/core/helpers.h
index d8c1f4647e..a43c55e06b 100644
--- a/esphome/core/helpers.h
+++ b/esphome/core/helpers.h
@@ -512,6 +512,17 @@ std::string __attribute__((format(printf, 1, 2))) str_sprintf(const char *fmt, .
 /// @return The concatenated string: name + sep + suffix
 std::string make_name_with_suffix(const std::string &name, char sep, const char *suffix_ptr, size_t suffix_len);
 
+/// Optimized string concatenation: name + separator + suffix (const char* overload)
+/// Uses a fixed stack buffer to avoid heap allocations.
+/// @param name The base name string
+/// @param name_len Length of the name
+/// @param sep Single character separator
+/// @param suffix_ptr Pointer to the suffix characters
+/// @param suffix_len Length of the suffix
+/// @return The concatenated string: name + sep + suffix
+std::string make_name_with_suffix(const char *name, size_t name_len, char sep, const char *suffix_ptr,
+                                  size_t suffix_len);
+
 ///@}
 
 /// @name Parsing & formatting

From 6ca0cd1e8b3f6b1622acfdcd0b8ed6a4c84d1a0b Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 12:16:48 -0600
Subject: [PATCH 14/26] [ltr390] Simplify mode tracking with bitmask instead of
 vector/function (#12093)

---
 esphome/components/ltr390/ltr390.cpp | 55 ++++++++++++++--------------
 esphome/components/ltr390/ltr390.h   | 14 +++----
 2 files changed, 35 insertions(+), 34 deletions(-)

diff --git a/esphome/components/ltr390/ltr390.cpp b/esphome/components/ltr390/ltr390.cpp
index c1885dcb6f..ba4a7ea5cb 100644
--- a/esphome/components/ltr390/ltr390.cpp
+++ b/esphome/components/ltr390/ltr390.cpp
@@ -104,12 +104,17 @@ void LTR390Component::read_uvs_() {
   }
 }
 
-void LTR390Component::read_mode_(int mode_index) {
-  // Set mode
-  LTR390MODE mode = std::get<0>(this->mode_funcs_[mode_index]);
-
+void LTR390Component::standby_() {
   std::bitset<8> ctrl = this->reg(LTR390_MAIN_CTRL).get();
-  ctrl[LTR390_CTRL_MODE] = mode;
+  ctrl[LTR390_CTRL_EN] = false;
+  this->reg(LTR390_MAIN_CTRL) = ctrl.to_ulong();
+  this->reading_ = false;
+}
+
+void LTR390Component::read_mode_(LTR390MODE mode) {
+  // Set mode
+  std::bitset<8> ctrl = this->reg(LTR390_MAIN_CTRL).get();
+  ctrl[LTR390_CTRL_MODE] = (mode == LTR390_MODE_UVS);
   ctrl[LTR390_CTRL_EN] = true;
   this->reg(LTR390_MAIN_CTRL) = ctrl.to_ulong();
 
@@ -129,21 +134,18 @@ void LTR390Component::read_mode_(int mode_index) {
   }
 
   // After the sensor integration time do the following
-  this->set_timeout(int_time + LTR390_WAKEUP_TIME + LTR390_SETTLE_TIME, [this, mode_index]() {
-    // Read from the sensor
-    std::get<1>(this->mode_funcs_[mode_index])();
-
-    // If there are more modes to read then begin the next
-    // otherwise stop
-    if (mode_index + 1 < (int) this->mode_funcs_.size()) {
-      this->read_mode_(mode_index + 1);
+  this->set_timeout(int_time + LTR390_WAKEUP_TIME + LTR390_SETTLE_TIME, [this, mode]() {
+    // Read from the sensor and continue to next mode or standby
+    if (mode == LTR390_MODE_ALS) {
+      this->read_als_();
+      if (this->enabled_modes_ & ENABLED_MODE_UVS) {
+        this->read_mode_(LTR390_MODE_UVS);
+        return;
+      }
     } else {
-      // put sensor in standby
-      std::bitset<8> ctrl = this->reg(LTR390_MAIN_CTRL).get();
-      ctrl[LTR390_CTRL_EN] = false;
-      this->reg(LTR390_MAIN_CTRL) = ctrl.to_ulong();
-      this->reading_ = false;
+      this->read_uvs_();
     }
+    this->standby_();
   });
 }
 
@@ -172,14 +174,12 @@ void LTR390Component::setup() {
   // Set sensor read state
   this->reading_ = false;
 
-  // If we need the light sensor then add to the list
+  // Determine which modes are enabled based on configured sensors
   if (this->light_sensor_ != nullptr || this->als_sensor_ != nullptr) {
-    this->mode_funcs_.emplace_back(LTR390_MODE_ALS, std::bind(&LTR390Component::read_als_, this));
+    this->enabled_modes_ |= ENABLED_MODE_ALS;
   }
-
-  // If we need the UV sensor then add to the list
   if (this->uvi_sensor_ != nullptr || this->uv_sensor_ != nullptr) {
-    this->mode_funcs_.emplace_back(LTR390_MODE_UVS, std::bind(&LTR390Component::read_uvs_, this));
+    this->enabled_modes_ |= ENABLED_MODE_UVS;
   }
 }
 
@@ -195,10 +195,11 @@ void LTR390Component::dump_config() {
 }
 
 void LTR390Component::update() {
-  if (!this->reading_ && !mode_funcs_.empty()) {
-    this->reading_ = true;
-    this->read_mode_(0);
-  }
+  if (this->reading_ || this->enabled_modes_ == 0)
+    return;
+
+  this->reading_ = true;
+  this->read_mode_((this->enabled_modes_ & ENABLED_MODE_ALS) ? LTR390_MODE_ALS : LTR390_MODE_UVS);
 }
 
 }  // namespace ltr390
diff --git a/esphome/components/ltr390/ltr390.h b/esphome/components/ltr390/ltr390.h
index 7db73d68ff..47884b9166 100644
--- a/esphome/components/ltr390/ltr390.h
+++ b/esphome/components/ltr390/ltr390.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <tuple>
-#include <vector>
 #include "esphome/components/i2c/i2c.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/core/component.h"
@@ -60,17 +58,19 @@ class LTR390Component : public PollingComponent, public i2c::I2CDevice {
   void set_uv_sensor(sensor::Sensor *uv_sensor) { this->uv_sensor_ = uv_sensor; }
 
  protected:
+  static constexpr uint8_t ENABLED_MODE_ALS = 1 << 0;
+  static constexpr uint8_t ENABLED_MODE_UVS = 1 << 1;
+
   optional<uint32_t> read_sensor_data_(LTR390MODE mode);
 
   void read_als_();
   void read_uvs_();
 
-  void read_mode_(int mode_index);
+  void read_mode_(LTR390MODE mode);
+  void standby_();
 
-  bool reading_;
-
-  // a list of modes and corresponding read functions
-  std::vector<std::tuple<LTR390MODE, std::function<void()>>> mode_funcs_;
+  bool reading_{false};
+  uint8_t enabled_modes_{0};
 
   LTR390GAIN gain_als_;
   LTR390GAIN gain_uv_;

From dec323e786314b9fc1d3cdddd8c8153ab237e490 Mon Sep 17 00:00:00 2001
From: Nikolai Ryzhkov <me@namezys.com>
Date: Tue, 25 Nov 2025 19:27:35 +0100
Subject: [PATCH 15/26] [sht4x] Read and store a serial number of SHT4x sensors
 (#12089)

Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Co-authored-by: J. Nick Koston <nick+github@koston.org>
---
 esphome/components/sht4x/sht4x.cpp | 23 ++++++++++++++++++++++-
 esphome/components/sht4x/sht4x.h   |  2 ++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/esphome/components/sht4x/sht4x.cpp b/esphome/components/sht4x/sht4x.cpp
index 617b19ef3e..9d29746f0b 100644
--- a/esphome/components/sht4x/sht4x.cpp
+++ b/esphome/components/sht4x/sht4x.cpp
@@ -7,6 +7,7 @@ namespace sht4x {
 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[] = {MEASURECOMMANDS[this->heater_command_]};
@@ -17,6 +18,17 @@ void SHT4XComponent::start_heater_() {
   }
 }
 
+void SHT4XComponent::read_serial_number_() {
+  uint16_t buffer[2];
+  if (!this->get_8bit_register(SERIAL_NUMBER_COMMAND, buffer, 2, 1)) {
+    ESP_LOGE(TAG, "Get serial number failed");
+    this->serial_number_ = 0;
+    return;
+  }
+  this->serial_number_ = (uint32_t(buffer[0]) << 16) | (uint32_t(buffer[1]));
+  ESP_LOGD(TAG, "Serial number: %08" PRIx32, this->serial_number_);
+}
+
 void SHT4XComponent::setup() {
   auto err = this->write(nullptr, 0);
   if (err != i2c::ERROR_OK) {
@@ -24,6 +36,8 @@ void SHT4XComponent::setup() {
     return;
   }
 
+  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);
@@ -54,11 +68,18 @@ void SHT4XComponent::setup() {
 }
 
 void SHT4XComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "SHT4x:");
+  ESP_LOGCONFIG(TAG,
+                "SHT4x:\n"
+                "  Serial number: %08" PRIx32,
+                this->serial_number_);
+
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
+  if (this->serial_number_ == 0) {
+    ESP_LOGW(TAG, "Get serial number failed");
+  }
 }
 
 void SHT4XComponent::update() {
diff --git a/esphome/components/sht4x/sht4x.h b/esphome/components/sht4x/sht4x.h
index accc7323be..aec0f3d7f8 100644
--- a/esphome/components/sht4x/sht4x.h
+++ b/esphome/components/sht4x/sht4x.h
@@ -36,7 +36,9 @@ class SHT4XComponent : public PollingComponent, public sensirion_common::Sensiri
   float duty_cycle_;
 
   void start_heater_();
+  void read_serial_number_();
   uint8_t heater_command_;
+  uint32_t serial_number_;
 
   sensor::Sensor *temp_sensor_{nullptr};
   sensor::Sensor *humidity_sensor_{nullptr};

From b6be5e3eda156568c114089b22a9ba1e989a6f12 Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Wed, 26 Nov 2025 05:06:42 +1000
Subject: [PATCH 16/26] [lvgl] Allow multiple widgets per grid cell (#12091)

---
 esphome/components/lvgl/layout.py       | 9 ++++++++-
 tests/components/lvgl/lvgl-package.yaml | 5 +++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/esphome/components/lvgl/layout.py b/esphome/components/lvgl/layout.py
index a6aa816fda..caa503ef0d 100644
--- a/esphome/components/lvgl/layout.py
+++ b/esphome/components/lvgl/layout.py
@@ -36,6 +36,8 @@ from .defines import (
 )
 from .lv_validation import padding, size
 
+CONF_MULTIPLE_WIDGETS_PER_CELL = "multiple_widgets_per_cell"
+
 cell_alignments = LV_CELL_ALIGNMENTS.one_of
 grid_alignments = LV_GRID_ALIGNMENTS.one_of
 flex_alignments = LV_FLEX_ALIGNMENTS.one_of
@@ -220,6 +222,7 @@ class GridLayout(Layout):
                 cv.Optional(CONF_GRID_ROW_ALIGN): grid_alignments,
                 cv.Optional(CONF_PAD_ROW): padding,
                 cv.Optional(CONF_PAD_COLUMN): padding,
+                cv.Optional(CONF_MULTIPLE_WIDGETS_PER_CELL, default=False): cv.boolean,
             },
             {
                 cv.Optional(CONF_GRID_CELL_ROW_POS): cv.positive_int,
@@ -263,6 +266,7 @@ class GridLayout(Layout):
         # should be guaranteed to be a dict at this point
         assert isinstance(layout, dict)
         assert layout.get(CONF_TYPE).lower() == TYPE_GRID
+        allow_multiple = layout.get(CONF_MULTIPLE_WIDGETS_PER_CELL, False)
         rows = len(layout[CONF_GRID_ROWS])
         columns = len(layout[CONF_GRID_COLUMNS])
         used_cells = [[None] * columns for _ in range(rows)]
@@ -299,7 +303,10 @@ class GridLayout(Layout):
                             f"exceeds grid size {rows}x{columns}",
                             [CONF_WIDGETS, index],
                         )
-                    if used_cells[row + i][column + j] is not None:
+                    if (
+                        not allow_multiple
+                        and used_cells[row + i][column + j] is not None
+                    ):
                         raise cv.Invalid(
                             f"Cell span {row + i}/{column + j} already occupied by widget at index {used_cells[row + i][column + j]}",
                             [CONF_WIDGETS, index],
diff --git a/tests/components/lvgl/lvgl-package.yaml b/tests/components/lvgl/lvgl-package.yaml
index d54aef8b4a..708dfa2cb1 100644
--- a/tests/components/lvgl/lvgl-package.yaml
+++ b/tests/components/lvgl/lvgl-package.yaml
@@ -893,6 +893,7 @@ lvgl:
                   grid_columns: [40, fr(1), fr(1)]
                   pad_row: 6px
                   pad_column: 0
+                  multiple_widgets_per_cell: true
                 widgets:
                   - image:
                       grid_cell_row_pos: 0
@@ -917,6 +918,10 @@ lvgl:
                       grid_cell_row_pos: 1
                       grid_cell_column_pos: 0
                       text: "Grid cell 1/0"
+                  - label:
+                      grid_cell_row_pos: 1
+                      grid_cell_column_pos: 0
+                      text: "Duplicate for 1/0"
                   - label:
                       styles: bdr_style
                       grid_cell_row_pos: 1

From 70df4ecaa93d7c6bacfada4980df9034dfecc06d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 25 Nov 2025 13:35:40 -0600
Subject: [PATCH 17/26] Bump actions/setup-python from 6.0.0 to 6.1.0 (#12106)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci-api-proto.yml        | 2 +-
 .github/workflows/ci-clang-tidy-hash.yml  | 2 +-
 .github/workflows/ci-docker.yml           | 2 +-
 .github/workflows/ci.yml                  | 4 ++--
 .github/workflows/release.yml             | 4 ++--
 .github/workflows/sync-device-classes.yml | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/ci-api-proto.yml b/.github/workflows/ci-api-proto.yml
index b377ca76d8..2bee5ed211 100644
--- a/.github/workflows/ci-api-proto.yml
+++ b/.github/workflows/ci-api-proto.yml
@@ -23,7 +23,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       - name: Set up Python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: "3.11"
 
diff --git a/.github/workflows/ci-clang-tidy-hash.yml b/.github/workflows/ci-clang-tidy-hash.yml
index 9556b99015..1826ed27cf 100644
--- a/.github/workflows/ci-clang-tidy-hash.yml
+++ b/.github/workflows/ci-clang-tidy-hash.yml
@@ -24,7 +24,7 @@ jobs:
         uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Set up Python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: "3.11"
 
diff --git a/.github/workflows/ci-docker.yml b/.github/workflows/ci-docker.yml
index 5287d92b10..c76d9cf2a5 100644
--- a/.github/workflows/ci-docker.yml
+++ b/.github/workflows/ci-docker.yml
@@ -45,7 +45,7 @@ jobs:
     steps:
       - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       - name: Set up Python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: "3.11"
       - name: Set up Docker Buildx
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9c2fab0912..9cfc02d5cf 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -42,7 +42,7 @@ jobs:
         run: echo key="${{ hashFiles('requirements.txt', 'requirements_test.txt', '.pre-commit-config.yaml') }}" >> $GITHUB_OUTPUT
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
       - name: Restore Python virtual environment
@@ -240,7 +240,7 @@ jobs:
         uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       - name: Set up Python 3.13
         id: python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: "3.13"
       - name: Restore Python virtual environment
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 497ecd29e7..1ff810d869 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -62,7 +62,7 @@ jobs:
     steps:
       - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       - name: Set up Python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: "3.x"
       - name: Build
@@ -94,7 +94,7 @@ jobs:
     steps:
       - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       - name: Set up Python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: "3.11"
 
diff --git a/.github/workflows/sync-device-classes.yml b/.github/workflows/sync-device-classes.yml
index 8f95fa68ee..baaa29df2c 100644
--- a/.github/workflows/sync-device-classes.yml
+++ b/.github/workflows/sync-device-classes.yml
@@ -22,7 +22,7 @@ jobs:
           path: lib/home-assistant
 
       - name: Setup Python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: 3.13
 

From ae60b5e6a133b4df3266831078fc1df3976fa314 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 25 Nov 2025 14:27:49 -0600
Subject: [PATCH 18/26] Bump actions/setup-python from 6.0.0 to 6.1.0 in
 /.github/actions/restore-python (#12108)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/actions/restore-python/action.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/actions/restore-python/action.yml b/.github/actions/restore-python/action.yml
index f314e79ad9..c4ac3d1a9e 100644
--- a/.github/actions/restore-python/action.yml
+++ b/.github/actions/restore-python/action.yml
@@ -17,7 +17,7 @@ runs:
   steps:
     - name: Set up Python ${{ inputs.python-version }}
       id: python
-      uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
       with:
         python-version: ${{ inputs.python-version }}
     - name: Restore Python virtual environment

From 50bdcdee0c851810940652913d12dfaa38330e6e Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Wed, 26 Nov 2025 12:39:41 +1300
Subject: [PATCH 19/26] Add developer-breaking-change labelling (#12095)

---
 .github/PULL_REQUEST_TEMPLATE.md    | 1 +
 .github/workflows/auto-label-pr.yml | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 28437e6302..41dd02458e 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -7,6 +7,7 @@
 - [ ] Bugfix (non-breaking change which fixes an issue)
 - [ ] New feature (non-breaking change which adds functionality)
 - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Developer breaking change (an API change that could break external components)
 - [ ] Code quality improvements to existing code or addition of tests
 - [ ] Other
 
diff --git a/.github/workflows/auto-label-pr.yml b/.github/workflows/auto-label-pr.yml
index 998f3315c6..d09072d814 100644
--- a/.github/workflows/auto-label-pr.yml
+++ b/.github/workflows/auto-label-pr.yml
@@ -68,6 +68,7 @@ jobs:
               'bugfix',
               'new-feature',
               'breaking-change',
+              'developer-breaking-change',
               'code-quality'
             ];
 
@@ -367,6 +368,7 @@ jobs:
                 { pattern: /- \[x\] Bugfix \(non-breaking change which fixes an issue\)/i, label: 'bugfix' },
                 { pattern: /- \[x\] New feature \(non-breaking change which adds functionality\)/i, label: 'new-feature' },
                 { pattern: /- \[x\] Breaking change \(fix or feature that would cause existing functionality to not work as expected\)/i, label: 'breaking-change' },
+                { pattern: /- \[x\] Developer breaking change \(an API change that could break external components\)/i, label: 'developer-breaking-change' },
                 { pattern: /- \[x\] Code quality improvements to existing code or addition of tests/i, label: 'code-quality' }
               ];
 

From ffae3501ab00c1fc06dd7d395dee64b95154fe0c Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 17:44:50 -0600
Subject: [PATCH 20/26] [core] Replace seq<>/gens<> with std::index_sequence
 for code clarity (#11921)

---
 esphome/components/api/user_services.h | 10 ++++---
 esphome/components/script/script.h     | 12 ++++-----
 esphome/core/automation.h              | 36 +++++++++++++++++++-------
 3 files changed, 39 insertions(+), 19 deletions(-)

diff --git a/esphome/components/api/user_services.h b/esphome/components/api/user_services.h
index 501b702e6b..d9c13c520b 100644
--- a/esphome/components/api/user_services.h
+++ b/esphome/components/api/user_services.h
@@ -51,13 +51,14 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
       return false;
     if (req.args.size() != sizeof...(Ts))
       return false;
-    this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
+    this->execute_(req.args, std::make_index_sequence<sizeof...(Ts)>{});
     return true;
   }
 
  protected:
   virtual void execute(Ts... x) = 0;
-  template<typename ArgsContainer, int... S> void execute_(const ArgsContainer &args, seq<S...> type) {
+  template<typename ArgsContainer, size_t... S>
+  void execute_(const ArgsContainer &args, std::index_sequence<S...> type) {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 
@@ -95,13 +96,14 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
       return false;
     if (req.args.size() != sizeof...(Ts))
       return false;
-    this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
+    this->execute_(req.args, std::make_index_sequence<sizeof...(Ts)>{});
     return true;
   }
 
  protected:
   virtual void execute(Ts... x) = 0;
-  template<typename ArgsContainer, int... S> void execute_(const ArgsContainer &args, seq<S...> type) {
+  template<typename ArgsContainer, size_t... S>
+  void execute_(const ArgsContainer &args, std::index_sequence<S...> type) {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 
diff --git a/esphome/components/script/script.h b/esphome/components/script/script.h
index 3a0823f3cc..cd1a084f16 100644
--- a/esphome/components/script/script.h
+++ b/esphome/components/script/script.h
@@ -46,14 +46,14 @@ template<typename... Ts> class Script : public ScriptLogger, public Trigger<Ts..
 
   // execute this script using a tuple that contains the arguments
   void execute_tuple(const std::tuple<Ts...> &tuple) {
-    this->execute_tuple_(tuple, typename gens<sizeof...(Ts)>::type());
+    this->execute_tuple_(tuple, std::make_index_sequence<sizeof...(Ts)>{});
   }
 
   // Internal function to give scripts readable names.
   void set_name(const LogString *name) { name_ = name; }
 
  protected:
-  template<int... S> void execute_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
+  template<size_t... S> void execute_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
     this->execute(std::get<S>(tuple)...);
   }
 
@@ -157,7 +157,7 @@ template<typename... Ts> class QueueingScript : public Script<Ts...>, public Com
       const size_t queue_capacity = static_cast<size_t>(this->max_runs_ - 1);
       auto tuple_ptr = std::move(this->var_queue_[this->queue_front_]);
       this->queue_front_ = (this->queue_front_ + 1) % queue_capacity;
-      this->trigger_tuple_(*tuple_ptr, typename gens<sizeof...(Ts)>::type());
+      this->trigger_tuple_(*tuple_ptr, std::make_index_sequence<sizeof...(Ts)>{});
     }
   }
 
@@ -174,7 +174,7 @@ template<typename... Ts> class QueueingScript : public Script<Ts...>, public Com
     }
   }
 
-  template<int... S> void trigger_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
+  template<size_t... S> void trigger_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
     this->trigger(std::get<S>(tuple)...);
   }
 
@@ -313,7 +313,7 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
     // play_next_() can trigger more items to be queued
     if (!this->param_queue_.empty()) {
       auto &params = this->param_queue_.front();
-      this->play_next_tuple_(params, typename gens<sizeof...(Ts)>::type());
+      this->play_next_tuple_(params, std::make_index_sequence<sizeof...(Ts)>{});
       this->param_queue_.pop_front();
     } else {
       // Queue is now empty - disable loop until next play_complex
@@ -330,7 +330,7 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
   }
 
  protected:
-  template<int... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
+  template<size_t... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
     this->play_next_(std::get<S>(tuple)...);
   }
 
diff --git a/esphome/core/automation.h b/esphome/core/automation.h
index 33e08c9c1c..dacadd35e8 100644
--- a/esphome/core/automation.h
+++ b/esphome/core/automation.h
@@ -11,10 +11,26 @@
 
 namespace esphome {
 
+// C++20 std::index_sequence is now used for tuple unpacking
+// Legacy seq<>/gens<> pattern deprecated but kept for backwards compatibility
 // https://stackoverflow.com/questions/7858817/unpacking-a-tuple-to-call-a-matching-function-pointer/7858971#7858971
-template<int...> struct seq {};                                       // NOLINT
-template<int N, int... S> struct gens : gens<N - 1, N - 1, S...> {};  // NOLINT
-template<int... S> struct gens<0, S...> { using type = seq<S...>; };  // NOLINT
+// Remove before 2026.6.0
+// NOLINTBEGIN(readability-identifier-naming)
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+template<int...> struct ESPDEPRECATED("Use std::index_sequence instead. Removed in 2026.6.0", "2025.12.0") seq {};
+template<int N, int... S>
+struct ESPDEPRECATED("Use std::make_index_sequence instead. Removed in 2026.6.0", "2025.12.0") gens
+    : gens<N - 1, N - 1, S...> {};
+template<int... S> struct gens<0, S...> { using type = seq<S...>; };
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+// NOLINTEND(readability-identifier-naming)
 
 #define TEMPLATABLE_VALUE_(type, name) \
  protected: \
@@ -152,11 +168,11 @@ template<typename... Ts> class Condition {
 
   /// Call check with a tuple of values as parameter.
   bool check_tuple(const std::tuple<Ts...> &tuple) {
-    return this->check_tuple_(tuple, typename gens<sizeof...(Ts)>::type());
+    return this->check_tuple_(tuple, std::make_index_sequence<sizeof...(Ts)>{});
   }
 
  protected:
-  template<int... S> bool check_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
+  template<size_t... S> bool check_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
     return this->check(std::get<S>(tuple)...);
   }
 };
@@ -231,11 +247,11 @@ template<typename... Ts> class Action {
       }
     }
   }
-  template<int... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
+  template<size_t... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
     this->play_next_(std::get<S>(tuple)...);
   }
   void play_next_tuple_(const std::tuple<Ts...> &tuple) {
-    this->play_next_tuple_(tuple, typename gens<sizeof...(Ts)>::type());
+    this->play_next_tuple_(tuple, std::make_index_sequence<sizeof...(Ts)>{});
   }
 
   virtual void stop() {}
@@ -277,7 +293,9 @@ template<typename... Ts> class ActionList {
     if (this->actions_begin_ != nullptr)
       this->actions_begin_->play_complex(x...);
   }
-  void play_tuple(const std::tuple<Ts...> &tuple) { this->play_tuple_(tuple, typename gens<sizeof...(Ts)>::type()); }
+  void play_tuple(const std::tuple<Ts...> &tuple) {
+    this->play_tuple_(tuple, std::make_index_sequence<sizeof...(Ts)>{});
+  }
   void stop() {
     if (this->actions_begin_ != nullptr)
       this->actions_begin_->stop_complex();
@@ -298,7 +316,7 @@ template<typename... Ts> class ActionList {
   }
 
  protected:
-  template<int... S> void play_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
+  template<size_t... S> void play_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
     this->play(std::get<S>(tuple)...);
   }
 

From bda17180df0c9ca735d25dc52def20b83b2465f6 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 17:48:08 -0600
Subject: [PATCH 21/26] [core] Deduplicate identical stateless lambdas to
 reduce flash usage (#11918)

---
 esphome/cpp_generator.py                | 177 ++++++++++++++-
 tests/component_tests/text/test_text.py |  19 +-
 tests/unit_tests/test_lambda_dedup.py   | 286 ++++++++++++++++++++++++
 3 files changed, 471 insertions(+), 11 deletions(-)
 create mode 100644 tests/unit_tests/test_lambda_dedup.py

diff --git a/esphome/cpp_generator.py b/esphome/cpp_generator.py
index 6f1af01a5b..4f91696ca1 100644
--- a/esphome/cpp_generator.py
+++ b/esphome/cpp_generator.py
@@ -19,11 +19,21 @@ from esphome.core import (
     TimePeriodNanoseconds,
     TimePeriodSeconds,
 )
+from esphome.coroutine import CoroPriority, coroutine_with_priority
 from esphome.helpers import cpp_string_escape, indent_all_but_first_and_last
 from esphome.types import Expression, SafeExpType, TemplateArgsType
 from esphome.util import OrderedDict
 from esphome.yaml_util import ESPHomeDataBase
 
+# Keys for lambda deduplication storage in CORE.data
+_KEY_LAMBDA_DEDUP = "lambda_dedup"
+_KEY_LAMBDA_DEDUP_DECLARATIONS = "lambda_dedup_declarations"
+
+# Regex patterns for static variable detection (compiled once)
+_RE_CPP_SINGLE_LINE_COMMENT = re.compile(r"//.*?$", re.MULTILINE)
+_RE_CPP_MULTI_LINE_COMMENT = re.compile(r"/\*.*?\*/", re.DOTALL)
+_RE_STATIC_VARIABLE = re.compile(r"\bstatic\s+(?!cast|assert|pointer_cast)\w+\s+\w+")
+
 
 class RawExpression(Expression):
     __slots__ = ("text",)
@@ -188,7 +198,7 @@ class LambdaExpression(Expression):
 
     def __init__(
         self, parts, parameters, capture: str = "=", return_type=None, source=None
-    ):
+    ) -> None:
         self.parts = parts
         if not isinstance(parameters, ParameterListExpression):
             parameters = ParameterListExpression(*parameters)
@@ -197,16 +207,21 @@ class LambdaExpression(Expression):
         self.capture = capture
         self.return_type = safe_exp(return_type) if return_type is not None else None
 
-    def __str__(self):
+    def format_body(self) -> str:
+        """Format the lambda body with source directive and content."""
+        body = ""
+        if self.source is not None:
+            body += f"{self.source.as_line_directive}\n"
+        body += self.content
+        return body
+
+    def __str__(self) -> str:
         # Stateless lambdas (empty capture) implicitly convert to function pointers
         # when assigned to function pointer types - no unary + needed
         cpp = f"[{self.capture}]({self.parameters})"
         if self.return_type is not None:
             cpp += f" -> {self.return_type}"
-        cpp += " {\n"
-        if self.source is not None:
-            cpp += f"{self.source.as_line_directive}\n"
-        cpp += f"{self.content}\n}}"
+        cpp += f" {{\n{self.format_body()}\n}}"
         return indent_all_but_first_and_last(cpp)
 
     @property
@@ -214,6 +229,37 @@ class LambdaExpression(Expression):
         return "".join(str(part) for part in self.parts)
 
 
+class SharedFunctionLambdaExpression(LambdaExpression):
+    """A lambda expression that references a shared deduplicated function.
+
+    This class wraps a function pointer but maintains the LambdaExpression
+    interface so calling code works unchanged.
+    """
+
+    __slots__ = ("_func_name",)
+
+    def __init__(
+        self,
+        func_name: str,
+        parameters: TemplateArgsType,
+        return_type: SafeExpType | None = None,
+    ) -> None:
+        # Initialize parent with empty parts since we're just a function reference
+        super().__init__(
+            [], parameters, capture="", return_type=return_type, source=None
+        )
+        self._func_name = func_name
+
+    def __str__(self) -> str:
+        # Just return the function name - it's already a function pointer
+        return self._func_name
+
+    @property
+    def content(self) -> str:
+        # No content, just a function reference
+        return ""
+
+
 # pylint: disable=abstract-method
 class Literal(Expression, metaclass=abc.ABCMeta):
     __slots__ = ()
@@ -583,6 +629,25 @@ def add_global(expression: SafeExpType | Statement, prepend: bool = False):
     CORE.add_global(expression, prepend)
 
 
+@coroutine_with_priority(CoroPriority.FINAL)
+async def flush_lambda_dedup_declarations() -> None:
+    """Flush all deferred lambda deduplication declarations to global scope.
+
+    This is a coroutine that runs with FINAL priority (after all components)
+    to ensure all referenced variables are declared before the shared
+    lambda functions that use them.
+    """
+    if _KEY_LAMBDA_DEDUP_DECLARATIONS not in CORE.data:
+        return
+
+    declarations = CORE.data[_KEY_LAMBDA_DEDUP_DECLARATIONS]
+    for func_declaration in declarations:
+        add_global(RawStatement(func_declaration))
+
+    # Clear the list so we don't add them again
+    CORE.data[_KEY_LAMBDA_DEDUP_DECLARATIONS] = []
+
+
 def add_library(name: str, version: str | None, repository: str | None = None):
     """Add a library to the codegen library storage.
 
@@ -656,6 +721,93 @@ async def get_variable_with_full_id(id_: ID) -> tuple[ID, "MockObj"]:
     return await CORE.get_variable_with_full_id(id_)
 
 
+def _has_static_variables(code: str) -> bool:
+    """Check if code contains static variable definitions.
+
+    Static variables in lambdas should not be deduplicated because each lambda
+    instance should have its own static variable state.
+
+    Args:
+        code: The lambda body code to check
+
+    Returns:
+        True if code contains static variable definitions
+    """
+    # Remove C++ comments to avoid false positives
+    # Remove single-line comments (// ...)
+    code_no_comments = _RE_CPP_SINGLE_LINE_COMMENT.sub("", code)
+    # Remove multi-line comments (/* ... */)
+    code_no_comments = _RE_CPP_MULTI_LINE_COMMENT.sub("", code_no_comments)
+
+    # Match: static <type> <identifier>
+    # But not: static_cast, static_assert, static_pointer_cast
+    return bool(_RE_STATIC_VARIABLE.search(code_no_comments))
+
+
+def _get_shared_lambda_name(lambda_expr: LambdaExpression) -> str | None:
+    """Get the shared function name for a lambda expression.
+
+    If an identical lambda was already generated, returns the existing shared
+    function name. Otherwise, creates a new shared function and returns its name.
+
+    Lambdas with static variables are not deduplicated to preserve their
+    independent state.
+
+    Args:
+        lambda_expr: The lambda expression to deduplicate
+
+    Returns:
+        The name of the shared function for this lambda (either existing or newly created),
+        or None if the lambda should not be deduplicated (e.g., contains static variables)
+    """
+    # Create a unique key from the lambda content, parameters, and return type
+    content = lambda_expr.content
+
+    # Don't deduplicate lambdas with static variables - each instance needs its own state
+    if _has_static_variables(content):
+        return None
+    param_str = str(lambda_expr.parameters)
+    return_str = (
+        str(lambda_expr.return_type) if lambda_expr.return_type is not None else "void"
+    )
+
+    # Use tuple of (content, params, return_type) as key
+    lambda_key = (content, param_str, return_str)
+
+    # Initialize deduplication storage in CORE.data if not exists
+    if _KEY_LAMBDA_DEDUP not in CORE.data:
+        CORE.data[_KEY_LAMBDA_DEDUP] = {}
+        # Register the flush job to run after all components (FINAL priority)
+        # This ensures all variables are declared before shared lambda functions
+        CORE.add_job(flush_lambda_dedup_declarations)
+
+    lambda_cache = CORE.data[_KEY_LAMBDA_DEDUP]
+
+    # Check if we've seen this lambda before
+    if lambda_key in lambda_cache:
+        # Return name of existing shared function
+        return lambda_cache[lambda_key]
+
+    # First occurrence - create a shared function
+    # Use the cache size as the function number
+    func_name = f"shared_lambda_{len(lambda_cache)}"
+
+    # Build the function declaration using lambda's body formatting
+    func_declaration = (
+        f"{return_str} {func_name}({param_str}) {{\n{lambda_expr.format_body()}\n}}"
+    )
+
+    # Store the declaration to be added later (after all variable declarations)
+    # We can't add it immediately because it might reference variables not yet declared
+    CORE.data.setdefault(_KEY_LAMBDA_DEDUP_DECLARATIONS, []).append(func_declaration)
+
+    # Store in cache
+    lambda_cache[lambda_key] = func_name
+
+    # Return the function name (this is the first occurrence, but we still generate shared function)
+    return func_name
+
+
 async def process_lambda(
     value: Lambda,
     parameters: TemplateArgsType,
@@ -713,6 +865,19 @@ async def process_lambda(
         location.line += value.content_offset
     else:
         location = None
+
+    # Lambda deduplication: Only deduplicate stateless lambdas (empty capture).
+    # Stateful lambdas cannot be shared as they capture different contexts.
+    # Lambdas with static variables are also not deduplicated to preserve independent state.
+    if capture == "":
+        lambda_expr = LambdaExpression(
+            parts, parameters, capture, return_type, location
+        )
+        func_name = _get_shared_lambda_name(lambda_expr)
+        if func_name is not None:
+            # Return a shared function reference instead of inline lambda
+            return SharedFunctionLambdaExpression(func_name, parameters, return_type)
+
     return LambdaExpression(parts, parameters, capture, return_type, location)
 
 
diff --git a/tests/component_tests/text/test_text.py b/tests/component_tests/text/test_text.py
index bfc3131f6d..56dee205b4 100644
--- a/tests/component_tests/text/test_text.py
+++ b/tests/component_tests/text/test_text.py
@@ -1,4 +1,6 @@
-"""Tests for the binary sensor component."""
+"""Tests for the text component."""
+
+from esphome.core import CORE
 
 
 def test_text_is_setup(generate_main):
@@ -56,15 +58,22 @@ def test_text_config_value_mode_set(generate_main):
     assert "it_3->traits.set_mode(text::TEXT_MODE_PASSWORD);" in main_cpp
 
 
-def test_text_config_lamda_is_set(generate_main):
+def test_text_config_lambda_is_set(generate_main) -> None:
     """
-    Test if lambda is set for lambda mode (optimized with stateless lambda)
+    Test if lambda is set for lambda mode (optimized with stateless lambda and deduplication)
     """
     # Given
 
     # When
     main_cpp = generate_main("tests/component_tests/text/test_text.yaml")
 
+    # Get both global and main sections to find the shared lambda definition
+    full_cpp = CORE.cpp_global_section + main_cpp
+
     # Then
-    assert "it_4->set_template([]() -> esphome::optional<std::string> {" in main_cpp
-    assert 'return std::string{"Hello"};' in main_cpp
+    # Lambda is deduplicated into a shared function (reference in main section)
+    assert "it_4->set_template(shared_lambda_" in main_cpp
+    # Lambda body should be in the code somewhere
+    assert 'return std::string{"Hello"};' in full_cpp
+    # Verify the shared lambda function is defined (in global section)
+    assert "esphome::optional<std::string> shared_lambda_" in full_cpp
diff --git a/tests/unit_tests/test_lambda_dedup.py b/tests/unit_tests/test_lambda_dedup.py
new file mode 100644
index 0000000000..bbf5f02e6d
--- /dev/null
+++ b/tests/unit_tests/test_lambda_dedup.py
@@ -0,0 +1,286 @@
+"""Tests for lambda deduplication in cpp_generator."""
+
+from esphome import cpp_generator as cg
+from esphome.core import CORE
+
+
+def test_deduplicate_identical_lambdas() -> None:
+    """Test that identical stateless lambdas are deduplicated."""
+    # Create two identical lambda expressions
+    lambda1 = cg.LambdaExpression(
+        parts=["return 42;"],
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    lambda2 = cg.LambdaExpression(
+        parts=["return 42;"],
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    # Try to deduplicate them
+    func_name1 = cg._get_shared_lambda_name(lambda1)
+    func_name2 = cg._get_shared_lambda_name(lambda2)
+
+    # Both should get the same function name (deduplication happened)
+    assert func_name1 == func_name2
+    assert func_name1 == "shared_lambda_0"
+
+
+def test_different_lambdas_not_deduplicated() -> None:
+    """Test that different lambdas get different function names."""
+    lambda1 = cg.LambdaExpression(
+        parts=["return 42;"],
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    lambda2 = cg.LambdaExpression(
+        parts=["return 24;"],  # Different content
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    func_name1 = cg._get_shared_lambda_name(lambda1)
+    func_name2 = cg._get_shared_lambda_name(lambda2)
+
+    # Different lambdas should get different function names
+    assert func_name1 != func_name2
+    assert func_name1 == "shared_lambda_0"
+    assert func_name2 == "shared_lambda_1"
+
+
+def test_different_return_types_not_deduplicated() -> None:
+    """Test that lambdas with different return types are not deduplicated."""
+    lambda1 = cg.LambdaExpression(
+        parts=["return 42;"],
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    lambda2 = cg.LambdaExpression(
+        parts=["return 42;"],  # Same content
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("float"),  # Different return type
+    )
+
+    func_name1 = cg._get_shared_lambda_name(lambda1)
+    func_name2 = cg._get_shared_lambda_name(lambda2)
+
+    # Different return types = different functions
+    assert func_name1 != func_name2
+
+
+def test_different_parameters_not_deduplicated() -> None:
+    """Test that lambdas with different parameters are not deduplicated."""
+    lambda1 = cg.LambdaExpression(
+        parts=["return x;"],
+        parameters=[("int", "x")],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    lambda2 = cg.LambdaExpression(
+        parts=["return x;"],  # Same content
+        parameters=[("float", "x")],  # Different parameter type
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    func_name1 = cg._get_shared_lambda_name(lambda1)
+    func_name2 = cg._get_shared_lambda_name(lambda2)
+
+    # Different parameters = different functions
+    assert func_name1 != func_name2
+
+
+def test_flush_lambda_dedup_declarations() -> None:
+    """Test that deferred declarations are properly stored for later flushing."""
+    # Create a lambda which will create a deferred declaration
+    lambda1 = cg.LambdaExpression(
+        parts=["return 42;"],
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    cg._get_shared_lambda_name(lambda1)
+
+    # Check that declaration was stored
+    assert cg._KEY_LAMBDA_DEDUP_DECLARATIONS in CORE.data
+    assert len(CORE.data[cg._KEY_LAMBDA_DEDUP_DECLARATIONS]) == 1
+
+    # Verify the declaration content is correct
+    declaration = CORE.data[cg._KEY_LAMBDA_DEDUP_DECLARATIONS][0]
+    assert "shared_lambda_0" in declaration
+    assert "return 42;" in declaration
+
+    # Note: The actual flushing happens via CORE.add_job with FINAL priority
+    # during real code generation, so we don't test that here
+
+
+def test_shared_function_lambda_expression() -> None:
+    """Test SharedFunctionLambdaExpression behaves correctly."""
+    shared_lambda = cg.SharedFunctionLambdaExpression(
+        func_name="shared_lambda_0",
+        parameters=[],
+        return_type=cg.RawExpression("int"),
+    )
+
+    # Should output just the function name
+    assert str(shared_lambda) == "shared_lambda_0"
+
+    # Should have empty capture (stateless)
+    assert shared_lambda.capture == ""
+
+    # Should have empty content (just a reference)
+    assert shared_lambda.content == ""
+
+
+def test_lambda_deduplication_counter() -> None:
+    """Test that lambda counter increments correctly."""
+    # Create 3 different lambdas
+    for i in range(3):
+        lambda_expr = cg.LambdaExpression(
+            parts=[f"return {i};"],
+            parameters=[],
+            capture="",
+            return_type=cg.RawExpression("int"),
+        )
+        func_name = cg._get_shared_lambda_name(lambda_expr)
+        assert func_name == f"shared_lambda_{i}"
+
+
+def test_lambda_format_body() -> None:
+    """Test that format_body correctly formats lambda body with source."""
+    # Without source
+    lambda1 = cg.LambdaExpression(
+        parts=["return 42;"],
+        parameters=[],
+        capture="",
+        return_type=None,
+        source=None,
+    )
+    assert lambda1.format_body() == "return 42;"
+
+    # With source would need a proper source object, skip for now
+
+
+def test_stateful_lambdas_not_deduplicated() -> None:
+    """Test that stateful lambdas (non-empty capture) are not deduplicated."""
+    # _get_shared_lambda_name is only called for stateless lambdas (capture == "")
+    # Stateful lambdas bypass deduplication entirely in process_lambda
+
+    # Verify that a stateful lambda would NOT get deduplicated
+    # by checking it's not in the stateless dedup cache
+    stateful_lambda = cg.LambdaExpression(
+        parts=["return x + y;"],
+        parameters=[],
+        capture="=",  # Non-empty capture means stateful
+        return_type=cg.RawExpression("int"),
+    )
+
+    # Stateful lambdas should NOT be passed to _get_shared_lambda_name
+    # This is enforced by the `if capture == ""` check in process_lambda
+    # We verify the lambda has a non-empty capture
+    assert stateful_lambda.capture != ""
+    assert stateful_lambda.capture == "="
+
+
+def test_static_variable_detection() -> None:
+    """Test detection of static variables in lambda code."""
+    # Should detect static variables
+    assert cg._has_static_variables("static int counter = 0;")
+    assert cg._has_static_variables("static bool flag = false; return flag;")
+    assert cg._has_static_variables("  static  float  value  =  1.0;  ")
+
+    # Should NOT detect static_cast, static_assert, etc. (with underscores)
+    assert not cg._has_static_variables("return static_cast<int>(value);")
+    assert not cg._has_static_variables("static_assert(sizeof(int) == 4);")
+    assert not cg._has_static_variables("auto ptr = static_pointer_cast<Foo>(bar);")
+
+    # Edge case: 'cast', 'assert', 'pointer_cast' are NOT C++ keywords
+    # Someone could use them as type names, but we should NOT flag them
+    # because they're not actually static variables with state
+    # NOTE: These are valid C++ but extremely unlikely in ESPHome lambdas
+    assert not cg._has_static_variables("static cast obj;")  # 'cast' as type name
+    assert not cg._has_static_variables("static assert value;")  # 'assert' as type name
+    assert not cg._has_static_variables(
+        "static pointer_cast ptr;"
+    )  # 'pointer_cast' as type
+
+    # Should NOT detect in comments
+    assert not cg._has_static_variables("// static int x = 0;\nreturn 42;")
+    assert not cg._has_static_variables("/* static int y = 0; */ return 42;")
+
+    # Should detect even with comments elsewhere
+    assert cg._has_static_variables("// comment\nstatic int x = 0;\nreturn x;")
+
+    # Should NOT detect non-static code
+    assert not cg._has_static_variables("int counter = 0; return counter++;")
+    assert not cg._has_static_variables("return 42;")
+
+    # Should handle newlines between static and type/variable
+    assert cg._has_static_variables("static int\nfoo = 0;")
+    assert cg._has_static_variables("static\nint\nbar = 0;")
+    assert cg._has_static_variables(
+        "static  int  \n  foo  =  0;"
+    )  # Mixed spaces/newlines
+
+
+def test_lambdas_with_static_not_deduplicated() -> None:
+    """Test that lambdas with static variables are not deduplicated."""
+    # Two identical lambdas with static variables
+    lambda1 = cg.LambdaExpression(
+        parts=["static int counter = 0; return counter++;"],
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    lambda2 = cg.LambdaExpression(
+        parts=["static int counter = 0; return counter++;"],
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    # Should return None (not deduplicated)
+    func_name1 = cg._get_shared_lambda_name(lambda1)
+    func_name2 = cg._get_shared_lambda_name(lambda2)
+
+    assert func_name1 is None
+    assert func_name2 is None
+
+
+def test_lambdas_without_static_still_deduplicated() -> None:
+    """Test that lambdas without static variables are still deduplicated."""
+    # Two identical lambdas WITHOUT static variables
+    lambda1 = cg.LambdaExpression(
+        parts=["int counter = 0; return counter++;"],  # No static
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    lambda2 = cg.LambdaExpression(
+        parts=["int counter = 0; return counter++;"],  # No static
+        parameters=[],
+        capture="",
+        return_type=cg.RawExpression("int"),
+    )
+
+    # Should be deduplicated (same function name)
+    func_name1 = cg._get_shared_lambda_name(lambda1)
+    func_name2 = cg._get_shared_lambda_name(lambda2)
+
+    assert func_name1 is not None
+    assert func_name2 is not None
+    assert func_name1 == func_name2

From 03a8ef71ff4224ad57315402bfedc897906d6038 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 18:37:49 -0600
Subject: [PATCH 22/26] [esp32_ble_client] Replace std::string with char[18]
 for BLE address storage (#12070)

---
 esphome/components/alpha3/alpha3.cpp          | 18 ++---
 .../components/am43/sensor/am43_sensor.cpp    | 13 ++--
 esphome/components/anova/anova.cpp            |  9 +--
 esphome/components/ble_client/automation.h    |  2 +-
 esphome/components/ble_client/ble_client.cpp  |  2 +-
 .../ble_client/output/ble_binary_output.cpp   |  4 +-
 .../ble_client/sensor/ble_rssi_sensor.cpp     |  6 +-
 .../ble_client/sensor/ble_sensor.cpp          |  2 +-
 .../text_sensor/ble_text_sensor.cpp           |  2 +-
 .../bluetooth_proxy/bluetooth_connection.cpp  | 41 +++++-----
 .../bluetooth_proxy/bluetooth_proxy.cpp       | 11 ++-
 .../esp32_ble_client/ble_characteristic.cpp   |  6 +-
 .../esp32_ble_client/ble_client_base.cpp      | 75 +++++++++----------
 .../esp32_ble_client/ble_client_base.h        | 16 ++--
 .../esp32_ble_client/ble_service.cpp          |  4 +-
 .../display/pvvx_display.cpp                  | 36 +++++----
 16 files changed, 115 insertions(+), 132 deletions(-)

diff --git a/esphome/components/alpha3/alpha3.cpp b/esphome/components/alpha3/alpha3.cpp
index 344f2d5a03..f22a8e2444 100644
--- a/esphome/components/alpha3/alpha3.cpp
+++ b/esphome/components/alpha3/alpha3.cpp
@@ -56,13 +56,13 @@ bool Alpha3::is_current_response_type_(const uint8_t *response_type) {
 
 void Alpha3::handle_geni_response_(const uint8_t *response, uint16_t length) {
   if (this->response_offset_ >= this->response_length_) {
-    ESP_LOGD(TAG, "[%s] GENI response begin", this->parent_->address_str().c_str());
+    ESP_LOGD(TAG, "[%s] GENI response begin", this->parent_->address_str());
     if (length < GENI_RESPONSE_HEADER_LENGTH) {
-      ESP_LOGW(TAG, "[%s] response to short", this->parent_->address_str().c_str());
+      ESP_LOGW(TAG, "[%s] response too short", this->parent_->address_str());
       return;
     }
     if (response[0] != 36 || response[2] != 248 || response[3] != 231 || response[4] != 10) {
-      ESP_LOGW(TAG, "[%s] response bytes %d %d %d %d %d don't match GENI HEADER", this->parent_->address_str().c_str(),
+      ESP_LOGW(TAG, "[%s] response bytes %d %d %d %d %d don't match GENI HEADER", this->parent_->address_str(),
                response[0], response[1], response[2], response[3], response[4]);
       return;
     }
@@ -77,11 +77,11 @@ void Alpha3::handle_geni_response_(const uint8_t *response, uint16_t length) {
   };
 
   if (this->is_current_response_type_(GENI_RESPONSE_TYPE_FLOW_HEAD)) {
-    ESP_LOGD(TAG, "[%s] FLOW HEAD Response", this->parent_->address_str().c_str());
+    ESP_LOGD(TAG, "[%s] FLOW HEAD Response", this->parent_->address_str());
     extract_publish_sensor_value(GENI_RESPONSE_FLOW_OFFSET, this->flow_sensor_, 3600.0F);
     extract_publish_sensor_value(GENI_RESPONSE_HEAD_OFFSET, this->head_sensor_, .0001F);
   } else if (this->is_current_response_type_(GENI_RESPONSE_TYPE_POWER)) {
-    ESP_LOGD(TAG, "[%s] POWER Response", this->parent_->address_str().c_str());
+    ESP_LOGD(TAG, "[%s] POWER Response", this->parent_->address_str());
     extract_publish_sensor_value(GENI_RESPONSE_POWER_OFFSET, this->power_sensor_, 1.0F);
     extract_publish_sensor_value(GENI_RESPONSE_CURRENT_OFFSET, this->current_sensor_, 1.0F);
     extract_publish_sensor_value(GENI_RESPONSE_MOTOR_SPEED_OFFSET, this->speed_sensor_, 1.0F);
@@ -100,7 +100,7 @@ void Alpha3::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc
       if (param->open.status == ESP_GATT_OK) {
         this->response_offset_ = 0;
         this->response_length_ = 0;
-        ESP_LOGI(TAG, "[%s] connection open", this->parent_->address_str().c_str());
+        ESP_LOGI(TAG, "[%s] connection open", this->parent_->address_str());
       }
       break;
     }
@@ -132,7 +132,7 @@ void Alpha3::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc
     case ESP_GATTC_SEARCH_CMPL_EVT: {
       auto *chr = this->parent_->get_characteristic(ALPHA3_GENI_SERVICE_UUID, ALPHA3_GENI_CHARACTERISTIC_UUID);
       if (chr == nullptr) {
-        ESP_LOGE(TAG, "[%s] No GENI service found at device, not an Alpha3..?", this->parent_->address_str().c_str());
+        ESP_LOGE(TAG, "[%s] No GENI service found at device, not an Alpha3..?", this->parent_->address_str());
         break;
       }
       auto status = esp_ble_gattc_register_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
@@ -164,12 +164,12 @@ void Alpha3::send_request_(uint8_t *request, size_t len) {
       esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->geni_handle_, len,
                                request, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
   if (status)
-    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
 }
 
 void Alpha3::update() {
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
-    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str());
     return;
   }
 
diff --git a/esphome/components/am43/sensor/am43_sensor.cpp b/esphome/components/am43/sensor/am43_sensor.cpp
index 4cc99001ae..b2bc3254e2 100644
--- a/esphome/components/am43/sensor/am43_sensor.cpp
+++ b/esphome/components/am43/sensor/am43_sensor.cpp
@@ -44,11 +44,9 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
       auto *chr = this->parent_->get_characteristic(AM43_SERVICE_UUID, AM43_CHARACTERISTIC_UUID);
       if (chr == nullptr) {
         if (this->parent_->get_characteristic(AM43_TUYA_SERVICE_UUID, AM43_TUYA_CHARACTERISTIC_UUID) != nullptr) {
-          ESP_LOGE(TAG, "[%s] Detected a Tuya AM43 which is not supported, sorry.",
-                   this->parent_->address_str().c_str());
+          ESP_LOGE(TAG, "[%s] Detected a Tuya AM43 which is not supported, sorry.", this->parent_->address_str());
         } else {
-          ESP_LOGE(TAG, "[%s] No control service found at device, not an AM43..?",
-                   this->parent_->address_str().c_str());
+          ESP_LOGE(TAG, "[%s] No control service found at device, not an AM43..?", this->parent_->address_str());
         }
         break;
       }
@@ -82,8 +80,7 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
                                                  this->char_handle_, packet->length, packet->data,
                                                  ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
           if (status) {
-            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(),
-                     status);
+            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
           }
         }
         this->current_sensor_ = 0;
@@ -97,7 +94,7 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
 
 void Am43::update() {
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
-    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str());
     return;
   }
   if (this->current_sensor_ == 0) {
@@ -107,7 +104,7 @@ void Am43::update() {
           esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                    packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
       if (status) {
-        ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+        ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
       }
     }
     this->current_sensor_++;
diff --git a/esphome/components/anova/anova.cpp b/esphome/components/anova/anova.cpp
index d0e8f6827f..2693224a97 100644
--- a/esphome/components/anova/anova.cpp
+++ b/esphome/components/anova/anova.cpp
@@ -42,7 +42,7 @@ void Anova::control(const ClimateCall &call) {
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
     if (status) {
-      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
     }
   }
   if (call.get_target_temperature().has_value()) {
@@ -51,7 +51,7 @@ void Anova::control(const ClimateCall &call) {
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
     if (status) {
-      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
     }
   }
 }
@@ -124,8 +124,7 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
               esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                        pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
           if (status) {
-            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(),
-                     status);
+            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
           }
         }
       }
@@ -150,7 +149,7 @@ void Anova::update() {
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
     if (status) {
-      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
     }
     this->current_request_++;
   }
diff --git a/esphome/components/ble_client/automation.h b/esphome/components/ble_client/automation.h
index bbc2dd05e0..788eac4a57 100644
--- a/esphome/components/ble_client/automation.h
+++ b/esphome/components/ble_client/automation.h
@@ -198,7 +198,7 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
         }
         this->node_state = espbt::ClientState::ESTABLISHED;
         esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_string().c_str(),
-                   ble_client_->address_str().c_str());
+                   ble_client_->address_str());
         break;
       }
       default:
diff --git a/esphome/components/ble_client/ble_client.cpp b/esphome/components/ble_client/ble_client.cpp
index 5cf096c9d4..b8968fe4ba 100644
--- a/esphome/components/ble_client/ble_client.cpp
+++ b/esphome/components/ble_client/ble_client.cpp
@@ -39,7 +39,7 @@ void BLEClient::set_enabled(bool enabled) {
     return;
   this->enabled = enabled;
   if (!enabled) {
-    ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str().c_str());
+    ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str());
     this->disconnect();
   }
 }
diff --git a/esphome/components/ble_client/output/ble_binary_output.cpp b/esphome/components/ble_client/output/ble_binary_output.cpp
index ce67193be7..84558717f8 100644
--- a/esphome/components/ble_client/output/ble_binary_output.cpp
+++ b/esphome/components/ble_client/output/ble_binary_output.cpp
@@ -14,7 +14,7 @@ void BLEBinaryOutput::dump_config() {
                 "  MAC address        : %s\n"
                 "  Service UUID       : %s\n"
                 "  Characteristic UUID: %s",
-                this->parent_->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->parent_->address_str(), this->service_uuid_.to_string().c_str(),
                 this->char_uuid_.to_string().c_str());
   LOG_BINARY_OUTPUT(this);
 }
@@ -44,7 +44,7 @@ void BLEBinaryOutput::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
       }
       this->node_state = espbt::ClientState::ESTABLISHED;
       ESP_LOGD(TAG, "Found characteristic %s on device %s", this->char_uuid_.to_string().c_str(),
-               this->parent()->address_str().c_str());
+               this->parent()->address_str());
       this->node_state = espbt::ClientState::ESTABLISHED;
       break;
     }
diff --git a/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp b/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp
index 663c52ac10..4edcbd3877 100644
--- a/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp
+++ b/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp
@@ -19,7 +19,7 @@ void BLEClientRSSISensor::loop() {
 
 void BLEClientRSSISensor::dump_config() {
   LOG_SENSOR("", "BLE Client RSSI Sensor", this);
-  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str().c_str());
+  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str());
   LOG_UPDATE_INTERVAL(this);
 }
 
@@ -69,10 +69,10 @@ void BLEClientRSSISensor::update() {
   this->get_rssi_();
 }
 void BLEClientRSSISensor::get_rssi_() {
-  ESP_LOGV(TAG, "requesting rssi from %s", this->parent()->address_str().c_str());
+  ESP_LOGV(TAG, "requesting rssi from %s", this->parent()->address_str());
   auto status = esp_ble_gap_read_rssi(this->parent()->get_remote_bda());
   if (status != ESP_OK) {
-    ESP_LOGW(TAG, "esp_ble_gap_read_rssi error, address=%s, status=%d", this->parent()->address_str().c_str(), status);
+    ESP_LOGW(TAG, "esp_ble_gap_read_rssi error, address=%s, status=%d", this->parent()->address_str(), status);
     this->status_set_warning();
     this->publish_state(NAN);
   }
diff --git a/esphome/components/ble_client/sensor/ble_sensor.cpp b/esphome/components/ble_client/sensor/ble_sensor.cpp
index 61685c0566..8e3e483003 100644
--- a/esphome/components/ble_client/sensor/ble_sensor.cpp
+++ b/esphome/components/ble_client/sensor/ble_sensor.cpp
@@ -25,7 +25,7 @@ void BLESensor::dump_config() {
                 "  Characteristic UUID: %s\n"
                 "  Descriptor UUID    : %s\n"
                 "  Notifications      : %s",
-                this->parent()->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->parent()->address_str(), this->service_uuid_.to_string().c_str(),
                 this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
diff --git a/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp b/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
index b7a6d154db..bb771aed99 100644
--- a/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
+++ b/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
@@ -28,7 +28,7 @@ void BLETextSensor::dump_config() {
                 "  Characteristic UUID: %s\n"
                 "  Descriptor UUID    : %s\n"
                 "  Notifications      : %s",
-                this->parent()->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->parent()->address_str(), this->service_uuid_.to_string().c_str(),
                 this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
diff --git a/esphome/components/bluetooth_proxy/bluetooth_connection.cpp b/esphome/components/bluetooth_proxy/bluetooth_connection.cpp
index fcc344dda9..1d6f7e23b3 100644
--- a/esphome/components/bluetooth_proxy/bluetooth_connection.cpp
+++ b/esphome/components/bluetooth_proxy/bluetooth_connection.cpp
@@ -196,8 +196,8 @@ void BluetoothConnection::send_service_for_discovery_() {
 
     if (service_status != ESP_GATT_OK || service_count == 0) {
       ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_service %s, status=%d, service_count=%d, offset=%d",
-               this->connection_index_, this->address_str().c_str(),
-               service_status != ESP_GATT_OK ? "error" : "missing", service_status, service_count, this->send_service_);
+               this->connection_index_, this->address_str(), service_status != ESP_GATT_OK ? "error" : "missing",
+               service_status, service_count, this->send_service_);
       this->send_service_ = DONE_SENDING_SERVICES;
       return;
     }
@@ -312,13 +312,13 @@ void BluetoothConnection::send_service_for_discovery_() {
       if (resp.services.size() > 1) {
         resp.services.pop_back();
         ESP_LOGD(TAG, "[%d] [%s] Service %d would exceed limit (current: %d + service: %d > %d), sending current batch",
-                 this->connection_index_, this->address_str().c_str(), this->send_service_, current_size, service_size,
+                 this->connection_index_, this->address_str(), this->send_service_, current_size, service_size,
                  MAX_PACKET_SIZE);
         // Don't increment send_service_ - we'll retry this service in next batch
       } else {
         // This single service is too large, but we have to send it anyway
         ESP_LOGV(TAG, "[%d] [%s] Service %d is too large (%d bytes) but sending anyway", this->connection_index_,
-                 this->address_str().c_str(), this->send_service_, service_size);
+                 this->address_str(), this->send_service_, service_size);
         // Increment so we don't get stuck
         this->send_service_++;
       }
@@ -337,21 +337,20 @@ void BluetoothConnection::send_service_for_discovery_() {
 }
 
 void BluetoothConnection::log_connection_error_(const char *operation, esp_gatt_status_t status) {
-  ESP_LOGE(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str().c_str(), operation,
-           status);
+  ESP_LOGE(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str(), operation, status);
 }
 
 void BluetoothConnection::log_connection_warning_(const char *operation, esp_err_t err) {
-  ESP_LOGW(TAG, "[%d] [%s] %s failed, err=%d", this->connection_index_, this->address_str().c_str(), operation, err);
+  ESP_LOGW(TAG, "[%d] [%s] %s failed, err=%d", this->connection_index_, this->address_str(), operation, err);
 }
 
 void BluetoothConnection::log_gatt_not_connected_(const char *action, const char *type) {
-  ESP_LOGW(TAG, "[%d] [%s] Cannot %s GATT %s, not connected.", this->connection_index_, this->address_str().c_str(),
-           action, type);
+  ESP_LOGW(TAG, "[%d] [%s] Cannot %s GATT %s, not connected.", this->connection_index_, this->address_str(), action,
+           type);
 }
 
 void BluetoothConnection::log_gatt_operation_error_(const char *operation, uint16_t handle, esp_gatt_status_t status) {
-  ESP_LOGW(TAG, "[%d] [%s] Error %s for handle 0x%2X, status=%d", this->connection_index_, this->address_str().c_str(),
+  ESP_LOGW(TAG, "[%d] [%s] Error %s for handle 0x%2X, status=%d", this->connection_index_, this->address_str(),
            operation, handle, status);
 }
 
@@ -372,14 +371,14 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
     case ESP_GATTC_DISCONNECT_EVT: {
       // Don't reset connection yet - wait for CLOSE_EVT to ensure controller has freed resources
       // This prevents race condition where we mark slot as free before controller cleanup is complete
-      ESP_LOGD(TAG, "[%d] [%s] Disconnect, reason=0x%02x", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGD(TAG, "[%d] [%s] Disconnect, reason=0x%02x", this->connection_index_, this->address_str_,
                param->disconnect.reason);
       // Send disconnection notification but don't free the slot yet
       this->proxy_->send_device_connection(this->address_, false, 0, param->disconnect.reason);
       break;
     }
     case ESP_GATTC_CLOSE_EVT: {
-      ESP_LOGD(TAG, "[%d] [%s] Close, reason=0x%02x, freeing slot", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGD(TAG, "[%d] [%s] Close, reason=0x%02x, freeing slot", this->connection_index_, this->address_str_,
                param->close.reason);
       // Now the GATT connection is fully closed and controller resources are freed
       // Safe to mark the connection slot as available
@@ -463,7 +462,7 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
       break;
     }
     case ESP_GATTC_NOTIFY_EVT: {
-      ESP_LOGV(TAG, "[%d] [%s] ESP_GATTC_NOTIFY_EVT: handle=0x%2X", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGV(TAG, "[%d] [%s] ESP_GATTC_NOTIFY_EVT: handle=0x%2X", this->connection_index_, this->address_str_,
                param->notify.handle);
       api::BluetoothGATTNotifyDataResponse resp;
       resp.address = this->address_;
@@ -502,8 +501,7 @@ esp_err_t BluetoothConnection::read_characteristic(uint16_t handle) {
     return ESP_GATT_NOT_CONNECTED;
   }
 
-  ESP_LOGV(TAG, "[%d] [%s] Reading GATT characteristic handle %d", this->connection_index_, this->address_str_.c_str(),
-           handle);
+  ESP_LOGV(TAG, "[%d] [%s] Reading GATT characteristic handle %d", this->connection_index_, this->address_str_, handle);
 
   esp_err_t err = esp_ble_gattc_read_char(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE);
   return this->check_and_log_error_("esp_ble_gattc_read_char", err);
@@ -515,8 +513,7 @@ esp_err_t BluetoothConnection::write_characteristic(uint16_t handle, const uint8
     this->log_gatt_not_connected_("write", "characteristic");
     return ESP_GATT_NOT_CONNECTED;
   }
-  ESP_LOGV(TAG, "[%d] [%s] Writing GATT characteristic handle %d", this->connection_index_, this->address_str_.c_str(),
-           handle);
+  ESP_LOGV(TAG, "[%d] [%s] Writing GATT characteristic handle %d", this->connection_index_, this->address_str_, handle);
 
   // ESP-IDF's API requires a non-const uint8_t* but it doesn't modify the data
   // The BTC layer immediately copies the data to its own buffer (see btc_gattc.c)
@@ -532,8 +529,7 @@ esp_err_t BluetoothConnection::read_descriptor(uint16_t handle) {
     this->log_gatt_not_connected_("read", "descriptor");
     return ESP_GATT_NOT_CONNECTED;
   }
-  ESP_LOGV(TAG, "[%d] [%s] Reading GATT descriptor handle %d", this->connection_index_, this->address_str_.c_str(),
-           handle);
+  ESP_LOGV(TAG, "[%d] [%s] Reading GATT descriptor handle %d", this->connection_index_, this->address_str_, handle);
 
   esp_err_t err = esp_ble_gattc_read_char_descr(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE);
   return this->check_and_log_error_("esp_ble_gattc_read_char_descr", err);
@@ -544,8 +540,7 @@ esp_err_t BluetoothConnection::write_descriptor(uint16_t handle, const uint8_t *
     this->log_gatt_not_connected_("write", "descriptor");
     return ESP_GATT_NOT_CONNECTED;
   }
-  ESP_LOGV(TAG, "[%d] [%s] Writing GATT descriptor handle %d", this->connection_index_, this->address_str_.c_str(),
-           handle);
+  ESP_LOGV(TAG, "[%d] [%s] Writing GATT descriptor handle %d", this->connection_index_, this->address_str_, handle);
 
   // ESP-IDF's API requires a non-const uint8_t* but it doesn't modify the data
   // The BTC layer immediately copies the data to its own buffer (see btc_gattc.c)
@@ -564,13 +559,13 @@ esp_err_t BluetoothConnection::notify_characteristic(uint16_t handle, bool enabl
 
   if (enable) {
     ESP_LOGV(TAG, "[%d] [%s] Registering for GATT characteristic notifications handle %d", this->connection_index_,
-             this->address_str_.c_str(), handle);
+             this->address_str_, handle);
     esp_err_t err = esp_ble_gattc_register_for_notify(this->gattc_if_, this->remote_bda_, handle);
     return this->check_and_log_error_("esp_ble_gattc_register_for_notify", err);
   }
 
   ESP_LOGV(TAG, "[%d] [%s] Unregistering for GATT characteristic notifications handle %d", this->connection_index_,
-           this->address_str_.c_str(), handle);
+           this->address_str_, handle);
   esp_err_t err = esp_ble_gattc_unregister_for_notify(this->gattc_if_, this->remote_bda_, handle);
   return this->check_and_log_error_("esp_ble_gattc_unregister_for_notify", err);
 }
diff --git a/esphome/components/bluetooth_proxy/bluetooth_proxy.cpp b/esphome/components/bluetooth_proxy/bluetooth_proxy.cpp
index 34e0aa93a3..71f8da75a7 100644
--- a/esphome/components/bluetooth_proxy/bluetooth_proxy.cpp
+++ b/esphome/components/bluetooth_proxy/bluetooth_proxy.cpp
@@ -47,12 +47,11 @@ void BluetoothProxy::send_bluetooth_scanner_state_(esp32_ble_tracker::ScannerSta
 
 void BluetoothProxy::log_connection_request_ignored_(BluetoothConnection *connection, espbt::ClientState state) {
   ESP_LOGW(TAG, "[%d] [%s] Connection request ignored, state: %s", connection->get_connection_index(),
-           connection->address_str().c_str(), espbt::client_state_to_string(state));
+           connection->address_str(), espbt::client_state_to_string(state));
 }
 
 void BluetoothProxy::log_connection_info_(BluetoothConnection *connection, const char *message) {
-  ESP_LOGI(TAG, "[%d] [%s] Connecting %s", connection->get_connection_index(), connection->address_str().c_str(),
-           message);
+  ESP_LOGI(TAG, "[%d] [%s] Connecting %s", connection->get_connection_index(), connection->address_str(), message);
 }
 
 void BluetoothProxy::log_not_connected_gatt_(const char *action, const char *type) {
@@ -186,7 +185,7 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
       }
       if (!msg.has_address_type) {
         ESP_LOGE(TAG, "[%d] [%s] Missing address type in connect request", connection->get_connection_index(),
-                 connection->address_str().c_str());
+                 connection->address_str());
         this->send_device_connection(msg.address, false);
         return;
       }
@@ -199,7 +198,7 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
       } else if (connection->state() == espbt::ClientState::CONNECTING) {
         if (connection->disconnect_pending()) {
           ESP_LOGW(TAG, "[%d] [%s] Connection request while pending disconnect, cancelling pending disconnect",
-                   connection->get_connection_index(), connection->address_str().c_str());
+                   connection->get_connection_index(), connection->address_str());
           connection->cancel_pending_disconnect();
           return;
         }
@@ -339,7 +338,7 @@ void BluetoothProxy::bluetooth_gatt_send_services(const api::BluetoothGATTGetSer
     return;
   }
   if (!connection->service_count_) {
-    ESP_LOGW(TAG, "[%d] [%s] No GATT services found", connection->connection_index_, connection->address_str().c_str());
+    ESP_LOGW(TAG, "[%d] [%s] No GATT services found", connection->connection_index_, connection->address_str());
     this->send_gatt_services_done(msg.address);
     return;
   }
diff --git a/esphome/components/esp32_ble_client/ble_characteristic.cpp b/esphome/components/esp32_ble_client/ble_characteristic.cpp
index 36229c23c3..e0d0174c57 100644
--- a/esphome/components/esp32_ble_client/ble_characteristic.cpp
+++ b/esphome/components/esp32_ble_client/ble_characteristic.cpp
@@ -38,7 +38,7 @@ void BLECharacteristic::parse_descriptors() {
     }
     if (status != ESP_GATT_OK) {
       ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_get_all_descr error, status=%d",
-               this->service->client->get_connection_index(), this->service->client->address_str().c_str(), status);
+               this->service->client->get_connection_index(), this->service->client->address_str(), status);
       break;
     }
     if (count == 0) {
@@ -51,7 +51,7 @@ void BLECharacteristic::parse_descriptors() {
     desc->characteristic = this;
     this->descriptors.push_back(desc);
     ESP_LOGV(TAG, "[%d] [%s]    descriptor %s, handle 0x%x", this->service->client->get_connection_index(),
-             this->service->client->address_str().c_str(), desc->uuid.to_string().c_str(), desc->handle);
+             this->service->client->address_str(), desc->uuid.to_string().c_str(), desc->handle);
     offset++;
   }
 }
@@ -84,7 +84,7 @@ esp_err_t BLECharacteristic::write_value(uint8_t *new_val, int16_t new_val_size,
                                          new_val, write_type, ESP_GATT_AUTH_REQ_NONE);
   if (status) {
     ESP_LOGW(TAG, "[%d] [%s] Error sending write value to BLE gattc server, status=%d",
-             this->service->client->get_connection_index(), this->service->client->address_str().c_str(), status);
+             this->service->client->get_connection_index(), this->service->client->address_str(), status);
   }
   return status;
 }
diff --git a/esphome/components/esp32_ble_client/ble_client_base.cpp b/esphome/components/esp32_ble_client/ble_client_base.cpp
index 18321ef91c..07e88c7528 100644
--- a/esphome/components/esp32_ble_client/ble_client_base.cpp
+++ b/esphome/components/esp32_ble_client/ble_client_base.cpp
@@ -41,7 +41,7 @@ void BLEClientBase::setup() {
 }
 
 void BLEClientBase::set_state(espbt::ClientState st) {
-  ESP_LOGV(TAG, "[%d] [%s] Set state %d", this->connection_index_, this->address_str_.c_str(), (int) st);
+  ESP_LOGV(TAG, "[%d] [%s] Set state %d", this->connection_index_, this->address_str_, (int) st);
   ESPBTClient::set_state(st);
 }
 
@@ -71,7 +71,7 @@ void BLEClientBase::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "  Address: %s\n"
                 "  Auto-Connect: %s",
-                this->address_str().c_str(), TRUEFALSE(this->auto_connect_));
+                this->address_str(), TRUEFALSE(this->auto_connect_));
   ESP_LOGCONFIG(TAG, "  State: %s", espbt::client_state_to_string(this->state()));
   if (this->status_ == ESP_GATT_NO_RESOURCES) {
     ESP_LOGE(TAG, "  Failed due to no resources. Try to reduce number of BLE clients in config.");
@@ -104,12 +104,11 @@ void BLEClientBase::connect() {
   // Prevent duplicate connection attempts
   if (this->state_ == espbt::ClientState::CONNECTING || this->state_ == espbt::ClientState::CONNECTED ||
       this->state_ == espbt::ClientState::ESTABLISHED) {
-    ESP_LOGW(TAG, "[%d] [%s] Connection already in progress, state=%s", this->connection_index_,
-             this->address_str_.c_str(), espbt::client_state_to_string(this->state_));
+    ESP_LOGW(TAG, "[%d] [%s] Connection already in progress, state=%s", this->connection_index_, this->address_str_,
+             espbt::client_state_to_string(this->state_));
     return;
   }
-  ESP_LOGI(TAG, "[%d] [%s] 0x%02x Connecting", this->connection_index_, this->address_str_.c_str(),
-           this->remote_addr_type_);
+  ESP_LOGI(TAG, "[%d] [%s] 0x%02x Connecting", this->connection_index_, this->address_str_, this->remote_addr_type_);
   this->paired_ = false;
   // Enable loop for state processing
   this->enable_loop();
@@ -135,13 +134,13 @@ esp_err_t BLEClientBase::pair() { return esp_ble_set_encryption(this->remote_bda
 
 void BLEClientBase::disconnect() {
   if (this->state_ == espbt::ClientState::IDLE || this->state_ == espbt::ClientState::DISCONNECTING) {
-    ESP_LOGI(TAG, "[%d] [%s] Disconnect requested, but already %s", this->connection_index_, this->address_str_.c_str(),
+    ESP_LOGI(TAG, "[%d] [%s] Disconnect requested, but already %s", this->connection_index_, this->address_str_,
              espbt::client_state_to_string(this->state_));
     return;
   }
   if (this->state_ == espbt::ClientState::CONNECTING || this->conn_id_ == UNSET_CONN_ID) {
     ESP_LOGD(TAG, "[%d] [%s] Disconnect before connected, disconnect scheduled", this->connection_index_,
-             this->address_str_.c_str());
+             this->address_str_);
     this->want_disconnect_ = true;
     return;
   }
@@ -150,8 +149,7 @@ void BLEClientBase::disconnect() {
 
 void BLEClientBase::unconditional_disconnect() {
   // Disconnect without checking the state.
-  ESP_LOGI(TAG, "[%d] [%s] Disconnecting (conn_id: %d).", this->connection_index_, this->address_str_.c_str(),
-           this->conn_id_);
+  ESP_LOGI(TAG, "[%d] [%s] Disconnecting (conn_id: %d).", this->connection_index_, this->address_str_, this->conn_id_);
   if (this->state_ == espbt::ClientState::DISCONNECTING) {
     this->log_error_("Already disconnecting");
     return;
@@ -192,24 +190,23 @@ void BLEClientBase::release_services() {
 }
 
 void BLEClientBase::log_event_(const char *name) {
-  ESP_LOGD(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_.c_str(), name);
+  ESP_LOGD(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_, name);
 }
 
 void BLEClientBase::log_gattc_event_(const char *name) {
-  ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_%s_EVT", this->connection_index_, this->address_str_.c_str(), name);
+  ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_%s_EVT", this->connection_index_, this->address_str_, name);
 }
 
 void BLEClientBase::log_gattc_warning_(const char *operation, esp_gatt_status_t status) {
-  ESP_LOGW(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str_.c_str(), operation,
-           status);
+  ESP_LOGW(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str_, operation, status);
 }
 
 void BLEClientBase::log_gattc_warning_(const char *operation, esp_err_t err) {
-  ESP_LOGW(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str_.c_str(), operation, err);
+  ESP_LOGW(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str_, operation, err);
 }
 
 void BLEClientBase::log_connection_params_(const char *param_type) {
-  ESP_LOGD(TAG, "[%d] [%s] %s conn params", this->connection_index_, this->address_str_.c_str(), param_type);
+  ESP_LOGD(TAG, "[%d] [%s] %s conn params", this->connection_index_, this->address_str_, param_type);
 }
 
 void BLEClientBase::handle_connection_result_(esp_err_t ret) {
@@ -220,15 +217,15 @@ void BLEClientBase::handle_connection_result_(esp_err_t ret) {
 }
 
 void BLEClientBase::log_error_(const char *message) {
-  ESP_LOGE(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_.c_str(), message);
+  ESP_LOGE(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_, message);
 }
 
 void BLEClientBase::log_error_(const char *message, int code) {
-  ESP_LOGE(TAG, "[%d] [%s] %s=%d", this->connection_index_, this->address_str_.c_str(), message, code);
+  ESP_LOGE(TAG, "[%d] [%s] %s=%d", this->connection_index_, this->address_str_, message, code);
 }
 
 void BLEClientBase::log_warning_(const char *message) {
-  ESP_LOGW(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_.c_str(), message);
+  ESP_LOGW(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_, message);
 }
 
 void BLEClientBase::update_conn_params_(uint16_t min_interval, uint16_t max_interval, uint16_t latency,
@@ -264,13 +261,13 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
   if (event != ESP_GATTC_REG_EVT && esp_gattc_if != ESP_GATT_IF_NONE && esp_gattc_if != this->gattc_if_)
     return false;
 
-  ESP_LOGV(TAG, "[%d] [%s] gattc_event_handler: event=%d gattc_if=%d", this->connection_index_,
-           this->address_str_.c_str(), event, esp_gattc_if);
+  ESP_LOGV(TAG, "[%d] [%s] gattc_event_handler: event=%d gattc_if=%d", this->connection_index_, this->address_str_,
+           event, esp_gattc_if);
 
   switch (event) {
     case ESP_GATTC_REG_EVT: {
       if (param->reg.status == ESP_GATT_OK) {
-        ESP_LOGV(TAG, "[%d] [%s] gattc registered app id %d", this->connection_index_, this->address_str_.c_str(),
+        ESP_LOGV(TAG, "[%d] [%s] gattc registered app id %d", this->connection_index_, this->address_str_,
                  this->app_id);
         this->gattc_if_ = esp_gattc_if;
       } else {
@@ -292,7 +289,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       // arriving after we've already transitioned to IDLE state.
       if (this->state_ == espbt::ClientState::IDLE) {
         ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in IDLE state (status=%d), ignoring", this->connection_index_,
-                 this->address_str_.c_str(), param->open.status);
+                 this->address_str_, param->open.status);
         break;
       }
 
@@ -301,7 +298,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         // because it means we have a bad assumption about how the
         // ESP BT stack works.
         ESP_LOGE(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in %s state (status=%d)", this->connection_index_,
-                 this->address_str_.c_str(), espbt::client_state_to_string(this->state_), param->open.status);
+                 this->address_str_, espbt::client_state_to_string(this->state_), param->open.status);
       }
       if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
         this->log_gattc_warning_("Connection open", param->open.status);
@@ -318,7 +315,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       }
       // MTU negotiation already started in ESP_GATTC_CONNECT_EVT
       this->set_state(espbt::ClientState::CONNECTED);
-      ESP_LOGI(TAG, "[%d] [%s] Connection open", this->connection_index_, this->address_str_.c_str());
+      ESP_LOGI(TAG, "[%d] [%s] Connection open", this->connection_index_, this->address_str_);
       if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
         // Cached connections already connected with medium parameters, no update needed
         // only set our state, subclients might have more stuff to do yet.
@@ -354,8 +351,8 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
           this->state_ == espbt::ClientState::CONNECTED) {
         this->log_warning_("Remote closed during discovery");
       } else {
-        ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_DISCONNECT_EVT, reason 0x%02x", this->connection_index_,
-                 this->address_str_.c_str(), param->disconnect.reason);
+        ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_DISCONNECT_EVT, reason 0x%02x", this->connection_index_, this->address_str_,
+                 param->disconnect.reason);
       }
       this->release_services();
       this->set_state(espbt::ClientState::IDLE);
@@ -366,12 +363,12 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       if (this->conn_id_ != param->cfg_mtu.conn_id)
         return false;
       if (param->cfg_mtu.status != ESP_GATT_OK) {
-        ESP_LOGW(TAG, "[%d] [%s] cfg_mtu failed, mtu %d, status %d", this->connection_index_,
-                 this->address_str_.c_str(), param->cfg_mtu.mtu, param->cfg_mtu.status);
+        ESP_LOGW(TAG, "[%d] [%s] cfg_mtu failed, mtu %d, status %d", this->connection_index_, this->address_str_,
+                 param->cfg_mtu.mtu, param->cfg_mtu.status);
         // No state change required here - disconnect event will follow if needed.
         break;
       }
-      ESP_LOGD(TAG, "[%d] [%s] cfg_mtu status %d, mtu %d", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGD(TAG, "[%d] [%s] cfg_mtu status %d, mtu %d", this->connection_index_, this->address_str_,
                param->cfg_mtu.status, param->cfg_mtu.mtu);
       this->mtu_ = param->cfg_mtu.mtu;
       break;
@@ -415,14 +412,14 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       } else if (this->connection_type_ != espbt::ConnectionType::V3_WITH_CACHE) {
 #ifdef USE_ESP32_BLE_DEVICE
         for (auto &svc : this->services_) {
-          ESP_LOGV(TAG, "[%d] [%s] Service UUID: %s", this->connection_index_, this->address_str_.c_str(),
+          ESP_LOGV(TAG, "[%d] [%s] Service UUID: %s", this->connection_index_, this->address_str_,
                    svc->uuid.to_string().c_str());
-          ESP_LOGV(TAG, "[%d] [%s]  start_handle: 0x%x  end_handle: 0x%x", this->connection_index_,
-                   this->address_str_.c_str(), svc->start_handle, svc->end_handle);
+          ESP_LOGV(TAG, "[%d] [%s]  start_handle: 0x%x  end_handle: 0x%x", this->connection_index_, this->address_str_,
+                   svc->start_handle, svc->end_handle);
         }
 #endif
       }
-      ESP_LOGI(TAG, "[%d] [%s] Service discovery complete", this->connection_index_, this->address_str_.c_str());
+      ESP_LOGI(TAG, "[%d] [%s] Service discovery complete", this->connection_index_, this->address_str_);
       this->state_ = espbt::ClientState::ESTABLISHED;
       break;
     }
@@ -503,7 +500,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
 
     default:
       // ideally would check all other events for matching conn_id
-      ESP_LOGD(TAG, "[%d] [%s] Event %d", this->connection_index_, this->address_str_.c_str(), event);
+      ESP_LOGD(TAG, "[%d] [%s] Event %d", this->connection_index_, this->address_str_, event);
       break;
   }
   return true;
@@ -520,7 +517,7 @@ void BLEClientBase::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_
     case ESP_GAP_BLE_SEC_REQ_EVT:
       if (!this->check_addr(param->ble_security.auth_cmpl.bd_addr))
         return;
-      ESP_LOGV(TAG, "[%d] [%s] ESP_GAP_BLE_SEC_REQ_EVT %x", this->connection_index_, this->address_str_.c_str(), event);
+      ESP_LOGV(TAG, "[%d] [%s] ESP_GAP_BLE_SEC_REQ_EVT %x", this->connection_index_, this->address_str_, event);
       esp_ble_gap_security_rsp(param->ble_security.ble_req.bd_addr, true);
       break;
     // This event is sent once authentication has completed
@@ -529,13 +526,13 @@ void BLEClientBase::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_
         return;
       esp_bd_addr_t bd_addr;
       memcpy(bd_addr, param->ble_security.auth_cmpl.bd_addr, sizeof(esp_bd_addr_t));
-      ESP_LOGI(TAG, "[%d] [%s] auth complete addr: %s", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGI(TAG, "[%d] [%s] auth complete addr: %s", this->connection_index_, this->address_str_,
                format_hex(bd_addr, 6).c_str());
       if (!param->ble_security.auth_cmpl.success) {
         this->log_error_("auth fail reason", param->ble_security.auth_cmpl.fail_reason);
       } else {
         this->paired_ = true;
-        ESP_LOGD(TAG, "[%d] [%s] auth success type = %d mode = %d", this->connection_index_, this->address_str_.c_str(),
+        ESP_LOGD(TAG, "[%d] [%s] auth success type = %d mode = %d", this->connection_index_, this->address_str_,
                  param->ble_security.auth_cmpl.addr_type, param->ble_security.auth_cmpl.auth_mode);
       }
       break;
@@ -598,7 +595,7 @@ float BLEClientBase::parse_char_value(uint8_t *value, uint16_t length) {
       }
   }
   ESP_LOGW(TAG, "[%d] [%s] Cannot parse characteristic value of type 0x%x length %d", this->connection_index_,
-           this->address_str_.c_str(), value[0], length);
+           this->address_str_, value[0], length);
   return NAN;
 }
 
diff --git a/esphome/components/esp32_ble_client/ble_client_base.h b/esphome/components/esp32_ble_client/ble_client_base.h
index 7f0ae3b83e..7786495915 100644
--- a/esphome/components/esp32_ble_client/ble_client_base.h
+++ b/esphome/components/esp32_ble_client/ble_client_base.h
@@ -10,7 +10,6 @@
 #endif
 
 #include <array>
-#include <string>
 #include <vector>
 
 #include <esp_bt_defs.h>
@@ -23,6 +22,7 @@ namespace esphome::esp32_ble_client {
 namespace espbt = esphome::esp32_ble_tracker;
 
 static const int UNSET_CONN_ID = 0xFFFF;
+static constexpr size_t MAC_ADDR_STR_LEN = 18;  // "AA:BB:CC:DD:EE:FF\0"
 
 class BLEClientBase : public espbt::ESPBTClient, public Component {
  public:
@@ -58,14 +58,12 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
     this->remote_bda_[4] = (address >> 8) & 0xFF;
     this->remote_bda_[5] = (address >> 0) & 0xFF;
     if (address == 0) {
-      this->address_str_ = "";
+      this->address_str_[0] = '\0';
     } else {
-      char buf[18];
-      format_mac_addr_upper(this->remote_bda_, buf);
-      this->address_str_ = buf;
+      format_mac_addr_upper(this->remote_bda_, this->address_str_);
     }
   }
-  const std::string &address_str() const { return this->address_str_; }
+  const char *address_str() const { return this->address_str_; }
 
 #ifdef USE_ESP32_BLE_DEVICE
   BLEService *get_service(espbt::ESPBTUUID uuid);
@@ -104,7 +102,6 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   uint64_t address_{0};
 
   // Group 2: Container types (grouped for memory optimization)
-  std::string address_str_{};
 #ifdef USE_ESP32_BLE_DEVICE
   std::vector<BLEService *> services_;
 #endif
@@ -113,8 +110,9 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   int gattc_if_;
   esp_gatt_status_t status_{ESP_GATT_OK};
 
-  // Group 4: Arrays (6 bytes)
-  esp_bd_addr_t remote_bda_;
+  // Group 4: Arrays
+  char address_str_[MAC_ADDR_STR_LEN]{};  // 18 bytes: "AA:BB:CC:DD:EE:FF\0"
+  esp_bd_addr_t remote_bda_;              // 6 bytes
 
   // Group 5: 2-byte types
   uint16_t conn_id_{UNSET_CONN_ID};
diff --git a/esphome/components/esp32_ble_client/ble_service.cpp b/esphome/components/esp32_ble_client/ble_service.cpp
index accaad15e1..deaaa3de02 100644
--- a/esphome/components/esp32_ble_client/ble_service.cpp
+++ b/esphome/components/esp32_ble_client/ble_service.cpp
@@ -51,7 +51,7 @@ void BLEService::parse_characteristics() {
     }
     if (status != ESP_GATT_OK) {
       ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_get_all_char error, status=%d", this->client->get_connection_index(),
-               this->client->address_str().c_str(), status);
+               this->client->address_str(), status);
       break;
     }
     if (count == 0) {
@@ -65,7 +65,7 @@ void BLEService::parse_characteristics() {
     characteristic->service = this;
     this->characteristics.push_back(characteristic);
     ESP_LOGV(TAG, "[%d] [%s]  characteristic %s, handle 0x%x, properties 0x%x", this->client->get_connection_index(),
-             this->client->address_str().c_str(), characteristic->uuid.to_string().c_str(), characteristic->handle,
+             this->client->address_str(), characteristic->uuid.to_string().c_str(), characteristic->handle,
              characteristic->properties);
     offset++;
   }
diff --git a/esphome/components/pvvx_mithermometer/display/pvvx_display.cpp b/esphome/components/pvvx_mithermometer/display/pvvx_display.cpp
index b6916ad68f..8436633619 100644
--- a/esphome/components/pvvx_mithermometer/display/pvvx_display.cpp
+++ b/esphome/components/pvvx_mithermometer/display/pvvx_display.cpp
@@ -14,7 +14,7 @@ void PVVXDisplay::dump_config() {
                 "  Service UUID          : %s\n"
                 "  Characteristic UUID   : %s\n"
                 "  Auto clear            : %s",
-                this->parent_->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->parent_->address_str(), this->service_uuid_.to_string().c_str(),
                 this->char_uuid_.to_string().c_str(), YESNO(this->auto_clear_enabled_));
 #ifdef USE_TIME
   ESP_LOGCONFIG(TAG, "  Set time on connection: %s", YESNO(this->time_ != nullptr));
@@ -28,12 +28,12 @@ void PVVXDisplay::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t
   switch (event) {
     case ESP_GATTC_OPEN_EVT:
       if (param->open.status == ESP_GATT_OK) {
-        ESP_LOGV(TAG, "[%s] Connected successfully!", this->parent_->address_str().c_str());
+        ESP_LOGV(TAG, "[%s] Connected successfully!", this->parent_->address_str());
         this->delayed_disconnect_();
       }
       break;
     case ESP_GATTC_DISCONNECT_EVT:
-      ESP_LOGV(TAG, "[%s] Disconnected", this->parent_->address_str().c_str());
+      ESP_LOGV(TAG, "[%s] Disconnected", this->parent_->address_str());
       this->connection_established_ = false;
       this->cancel_timeout("disconnect");
       this->char_handle_ = 0;
@@ -41,7 +41,7 @@ void PVVXDisplay::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t
     case ESP_GATTC_SEARCH_CMPL_EVT: {
       auto *chr = this->parent_->get_characteristic(this->service_uuid_, this->char_uuid_);
       if (chr == nullptr) {
-        ESP_LOGW(TAG, "[%s] Characteristic not found.", this->parent_->address_str().c_str());
+        ESP_LOGW(TAG, "[%s] Characteristic not found.", this->parent_->address_str());
         break;
       }
       this->connection_established_ = true;
@@ -66,11 +66,11 @@ void PVVXDisplay::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb
         return;
 
       if (param->ble_security.auth_cmpl.success) {
-        ESP_LOGD(TAG, "[%s] Authentication successful, performing writes.", this->parent_->address_str().c_str());
+        ESP_LOGD(TAG, "[%s] Authentication successful, performing writes.", this->parent_->address_str());
         // Now that pairing is complete, perform the pending writes
         this->sync_time_and_display_();
       } else {
-        ESP_LOGW(TAG, "[%s] Authentication failed.", this->parent_->address_str().c_str());
+        ESP_LOGW(TAG, "[%s] Authentication failed.", this->parent_->address_str());
       }
       break;
     }
@@ -89,22 +89,20 @@ void PVVXDisplay::update() {
 
 void PVVXDisplay::display() {
   if (!this->parent_->enabled) {
-    ESP_LOGD(TAG, "[%s] BLE client not enabled.  Init connection.", this->parent_->address_str().c_str());
+    ESP_LOGD(TAG, "[%s] BLE client not enabled.  Init connection.", this->parent_->address_str());
     this->parent_->set_enabled(true);
     return;
   }
   if (!this->connection_established_) {
-    ESP_LOGW(TAG, "[%s] Not connected to BLE client.  State update can not be written.",
-             this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Not connected to BLE client.  State update can not be written.", this->parent_->address_str());
     return;
   }
   if (!this->char_handle_) {
-    ESP_LOGW(TAG, "[%s] No ble handle to BLE client.  State update can not be written.",
-             this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] No ble handle to BLE client.  State update can not be written.", this->parent_->address_str());
     return;
   }
   ESP_LOGD(TAG, "[%s] Send to display: bignum %d, smallnum: %d, cfg: 0x%02x, validity period: %u.",
-           this->parent_->address_str().c_str(), this->bignum_, this->smallnum_, this->cfg_, this->validity_period_);
+           this->parent_->address_str(), this->bignum_, this->smallnum_, this->cfg_, this->validity_period_);
   uint8_t blk[8] = {};
   blk[0] = 0x22;
   blk[1] = this->bignum_ & 0xff;
@@ -128,16 +126,16 @@ void PVVXDisplay::setcfgbit_(uint8_t bit, bool value) {
 
 void PVVXDisplay::send_to_setup_char_(uint8_t *blk, size_t size) {
   if (!this->connection_established_) {
-    ESP_LOGW(TAG, "[%s] Not connected to BLE client.", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Not connected to BLE client.", this->parent_->address_str());
     return;
   }
   auto status =
       esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_, size,
                                blk, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
   if (status) {
-    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
   } else {
-    ESP_LOGV(TAG, "[%s] send %u bytes", this->parent_->address_str().c_str(), size);
+    ESP_LOGV(TAG, "[%s] send %u bytes", this->parent_->address_str(), size);
     this->delayed_disconnect_();
   }
 }
@@ -161,21 +159,21 @@ void PVVXDisplay::sync_time_() {
   if (this->time_ == nullptr)
     return;
   if (!this->connection_established_) {
-    ESP_LOGW(TAG, "[%s] Not connected to BLE client.  Time can not be synced.", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Not connected to BLE client.  Time can not be synced.", this->parent_->address_str());
     return;
   }
   if (!this->char_handle_) {
-    ESP_LOGW(TAG, "[%s] No ble handle to BLE client.  Time can not be synced.", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] No ble handle to BLE client.  Time can not be synced.", this->parent_->address_str());
     return;
   }
   auto time = this->time_->now();
   if (!time.is_valid()) {
-    ESP_LOGW(TAG, "[%s] Time is not yet valid.  Time can not be synced.", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Time is not yet valid.  Time can not be synced.", this->parent_->address_str());
     return;
   }
   time.recalc_timestamp_utc(true);  // calculate timestamp of local time
   uint8_t blk[5] = {};
-  ESP_LOGD(TAG, "[%s] Sync time with timestamp %" PRIu64 ".", this->parent_->address_str().c_str(), time.timestamp);
+  ESP_LOGD(TAG, "[%s] Sync time with timestamp %" PRIu64 ".", this->parent_->address_str(), time.timestamp);
   blk[0] = 0x23;
   blk[1] = time.timestamp & 0xff;
   blk[2] = (time.timestamp >> 8) & 0xff;

From d443dbbf344626357cb2321c84cf189f0fc75bef Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 25 Nov 2025 19:42:09 -0600
Subject: [PATCH 23/26] [lvgl] Fix lambda return types for coord and font
 validators (#12113)

---
 esphome/components/lvgl/lv_validation.py | 6 ++++--
 esphome/components/lvgl/widgets/line.py  | 6 ++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/esphome/components/lvgl/lv_validation.py b/esphome/components/lvgl/lv_validation.py
index 23c322c31f..9c1dd22085 100644
--- a/esphome/components/lvgl/lv_validation.py
+++ b/esphome/components/lvgl/lv_validation.py
@@ -40,7 +40,7 @@ from .helpers import (
     lv_fonts_used,
     requires_component,
 )
-from .types import lv_font_t, lv_gradient_t
+from .types import lv_gradient_t
 
 opacity_consts = LvConstant("LV_OPA_", "TRANSP", "COVER")
 
@@ -498,7 +498,9 @@ class LvFont(LValidator):
             esphome_fonts_used.add(fontval)
             return requires_component("font")(fontval)
 
-        super().__init__(validator, lv_font_t)
+        # Use font::Font* as return type for lambdas returning ESPHome fonts
+        # The inline overloads in lvgl_esphome.h handle conversion to lv_font_t*
+        super().__init__(validator, Font.operator("ptr"))
 
     async def process(self, value, args=()):
         if is_lv_font(value):
diff --git a/esphome/components/lvgl/widgets/line.py b/esphome/components/lvgl/widgets/line.py
index bd90edbefc..57cb965737 100644
--- a/esphome/components/lvgl/widgets/line.py
+++ b/esphome/components/lvgl/widgets/line.py
@@ -6,7 +6,7 @@ from esphome.core import Lambda
 from ..defines import CONF_MAIN, call_lambda
 from ..lvcode import lv_add
 from ..schemas import point_schema
-from ..types import LvCompound, LvType
+from ..types import LvCompound, LvType, lv_coord_t
 from . import Widget, WidgetType
 
 CONF_LINE = "line"
@@ -23,9 +23,7 @@ LINE_SCHEMA = {
 
 async def process_coord(coord):
     if isinstance(coord, Lambda):
-        coord = call_lambda(
-            await cg.process_lambda(coord, [], return_type="lv_coord_t")
-        )
+        coord = call_lambda(await cg.process_lambda(coord, [], return_type=lv_coord_t))
         if not coord.endswith("()"):
             coord = f"static_cast<lv_coord_t>({coord})"
         return cg.RawExpression(coord)

From f071b6232a2f9cd043b4870384a9070019221b2d Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Wed, 26 Nov 2025 11:47:27 +1000
Subject: [PATCH 24/26] [lvgl] Fix position of errors in widget config (#12111)

Co-authored-by: J. Nick Koston <nick@koston.org>
---
 esphome/components/lvgl/schemas.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/esphome/components/lvgl/schemas.py b/esphome/components/lvgl/schemas.py
index 6b77f66abb..b2d463c5fd 100644
--- a/esphome/components/lvgl/schemas.py
+++ b/esphome/components/lvgl/schemas.py
@@ -1,6 +1,7 @@
 from esphome import config_validation as cv
 from esphome.automation import Trigger, validate_automation
 from esphome.components.time import RealTimeClock
+from esphome.config_validation import prepend_path
 from esphome.const import (
     CONF_ARGS,
     CONF_FORMAT,
@@ -422,7 +423,10 @@ def any_widget_schema(extras=None):
     def validator(value):
         if isinstance(value, dict):
             # Convert to list
+            is_dict = True
             value = [{k: v} for k, v in value.items()]
+        else:
+            is_dict = False
         if not isinstance(value, list):
             raise cv.Invalid("Expected a list of widgets")
         result = []
@@ -443,7 +447,9 @@ def any_widget_schema(extras=None):
                 )
             # Apply custom validation
             value = widget_type.validate(value or {})
-            result.append({key: container_validator(value)})
+            path = [key] if is_dict else [index, key]
+            with prepend_path(path):
+                result.append({key: container_validator(value)})
         return result
 
     return validator

From e071380532a3082ac3ba7de0c52aae5250720226 Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Wed, 26 Nov 2025 11:49:47 +1000
Subject: [PATCH 25/26] [lvgl] Add missing obj scroll properties (#11901)

Co-authored-by: J. Nick Koston <nick@koston.org>
---
 esphome/components/lvgl/defines.py          |  5 +++++
 esphome/components/lvgl/schemas.py          | 19 ++++++++++++++++++-
 esphome/components/lvgl/widgets/__init__.py |  6 +++---
 tests/components/lvgl/lvgl-package.yaml     |  5 +++++
 4 files changed, 31 insertions(+), 4 deletions(-)

diff --git a/esphome/components/lvgl/defines.py b/esphome/components/lvgl/defines.py
index f2bcb6cc06..6b3b9c97ef 100644
--- a/esphome/components/lvgl/defines.py
+++ b/esphome/components/lvgl/defines.py
@@ -279,6 +279,8 @@ KEYBOARD_MODES = LvConstant(
 )
 ROLLER_MODES = LvConstant("LV_ROLLER_MODE_", "NORMAL", "INFINITE")
 TILE_DIRECTIONS = DIRECTIONS.extend("HOR", "VER", "ALL")
+SCROLL_DIRECTIONS = TILE_DIRECTIONS.extend("NONE")
+SNAP_DIRECTIONS = LvConstant("LV_SCROLL_SNAP_", "NONE", "START", "END", "CENTER")
 CHILD_ALIGNMENTS = LvConstant(
     "LV_ALIGN_",
     "TOP_LEFT",
@@ -511,6 +513,9 @@ CONF_ROLLOVER = "rollover"
 CONF_ROOT_BACK_BTN = "root_back_btn"
 CONF_SCALE_LINES = "scale_lines"
 CONF_SCROLLBAR_MODE = "scrollbar_mode"
+CONF_SCROLL_DIR = "scroll_dir"
+CONF_SCROLL_SNAP_X = "scroll_snap_x"
+CONF_SCROLL_SNAP_Y = "scroll_snap_y"
 CONF_SELECTED_INDEX = "selected_index"
 CONF_SELECTED_TEXT = "selected_text"
 CONF_SHOW_SNOW = "show_snow"
diff --git a/esphome/components/lvgl/schemas.py b/esphome/components/lvgl/schemas.py
index b2d463c5fd..f2704f99de 100644
--- a/esphome/components/lvgl/schemas.py
+++ b/esphome/components/lvgl/schemas.py
@@ -20,7 +20,14 @@ from esphome.core import TimePeriod
 from esphome.core.config import StartupTrigger
 
 from . import defines as df, lv_validation as lvalid
-from .defines import CONF_TIME_FORMAT, LV_GRAD_DIR
+from .defines import (
+    CONF_SCROLL_DIR,
+    CONF_SCROLL_SNAP_X,
+    CONF_SCROLL_SNAP_Y,
+    CONF_SCROLLBAR_MODE,
+    CONF_TIME_FORMAT,
+    LV_GRAD_DIR,
+)
 from .helpers import CONF_IF_NAN, requires_component, validate_printf
 from .layout import (
     FLEX_OBJ_SCHEMA,
@@ -234,9 +241,19 @@ STYLE_SCHEMA = cv.Schema({cv.Optional(k): v for k, v in STYLE_PROPS.items()}).ex
         cv.Optional(df.CONF_SCROLLBAR_MODE): df.LvConstant(
             "LV_SCROLLBAR_MODE_", "OFF", "ON", "ACTIVE", "AUTO"
         ).one_of,
+        cv.Optional(CONF_SCROLL_DIR): df.SCROLL_DIRECTIONS.one_of,
+        cv.Optional(CONF_SCROLL_SNAP_X): df.SNAP_DIRECTIONS.one_of,
+        cv.Optional(CONF_SCROLL_SNAP_Y): df.SNAP_DIRECTIONS.one_of,
     }
 )
 
+OBJ_PROPERTIES = {
+    CONF_SCROLL_SNAP_X,
+    CONF_SCROLL_SNAP_Y,
+    CONF_SCROLL_DIR,
+    CONF_SCROLLBAR_MODE,
+}
+
 # Also allow widget specific properties for use in style definitions
 FULL_STYLE_SCHEMA = STYLE_SCHEMA.extend(
     {
diff --git a/esphome/components/lvgl/widgets/__init__.py b/esphome/components/lvgl/widgets/__init__.py
index 187b5828c2..2e7948522e 100644
--- a/esphome/components/lvgl/widgets/__init__.py
+++ b/esphome/components/lvgl/widgets/__init__.py
@@ -21,7 +21,6 @@ from ..defines import (
     CONF_MAIN,
     CONF_PAD_COLUMN,
     CONF_PAD_ROW,
-    CONF_SCROLLBAR_MODE,
     CONF_STYLES,
     CONF_WIDGETS,
     OBJ_FLAGS,
@@ -45,7 +44,7 @@ from ..lvcode import (
     lv_obj,
     lv_Pvariable,
 )
-from ..schemas import ALL_STYLES, STYLE_REMAP, WIDGET_TYPES
+from ..schemas import ALL_STYLES, OBJ_PROPERTIES, STYLE_REMAP, WIDGET_TYPES
 from ..types import LV_STATE, LvType, WidgetType, lv_coord_t, lv_obj_t, lv_obj_t_ptr
 
 EVENT_LAMB = "event_lamb__"
@@ -414,7 +413,8 @@ async def set_obj_properties(w: Widget, config):
                 w.add_state(state)
                 cond.else_()
                 w.clear_state(state)
-    await w.set_property(CONF_SCROLLBAR_MODE, config, lv_name="obj")
+    for property in OBJ_PROPERTIES:
+        await w.set_property(property, config, lv_name="obj")
 
 
 async def add_widgets(parent: Widget, config: dict):
diff --git a/tests/components/lvgl/lvgl-package.yaml b/tests/components/lvgl/lvgl-package.yaml
index 708dfa2cb1..eddcbe9fd5 100644
--- a/tests/components/lvgl/lvgl-package.yaml
+++ b/tests/components/lvgl/lvgl-package.yaml
@@ -537,6 +537,9 @@ lvgl:
         - tileview:
             id: tileview_id
             scrollbar_mode: active
+            scroll_dir: all
+            scroll_elastic: true
+            scroll_momentum: true
             on_value:
               then:
                 - if:
@@ -546,6 +549,8 @@ lvgl:
                       - logger.log: "tile 1 is now showing"
             tiles:
               - id: tile_1
+                scroll_snap_y: center
+                scroll_snap_x: start
                 layout: vertical
                 row: 0
                 column: 0

From 1207b9e99532733cb77597384c47876c3358a1f4 Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Wed, 26 Nov 2025 11:53:51 +1000
Subject: [PATCH 26/26] [lvgl] Automatically pad rows and columns (#11879)

Co-authored-by: J. Nick Koston <nick@koston.org>
---
 esphome/components/lvgl/layout.py       | 6 +++++-
 tests/components/lvgl/lvgl-package.yaml | 2 ++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/esphome/components/lvgl/layout.py b/esphome/components/lvgl/layout.py
index caa503ef0d..b27a0b54a2 100644
--- a/esphome/components/lvgl/layout.py
+++ b/esphome/components/lvgl/layout.py
@@ -172,10 +172,14 @@ class DirectionalLayout(FlexLayout):
 
     def validate(self, config):
         assert config[CONF_LAYOUT].lower() == self.direction
-        config[CONF_LAYOUT] = {
+        layout = {
             **FLEX_HV_STYLE,
             CONF_FLEX_FLOW: "LV_FLEX_FLOW_" + self.flow.upper(),
         }
+        if pad_all := config.get("pad_all"):
+            layout[CONF_PAD_ROW] = pad_all
+            layout[CONF_PAD_COLUMN] = pad_all
+        config[CONF_LAYOUT] = layout
         return config
 
 
diff --git a/tests/components/lvgl/lvgl-package.yaml b/tests/components/lvgl/lvgl-package.yaml
index eddcbe9fd5..30866a603c 100644
--- a/tests/components/lvgl/lvgl-package.yaml
+++ b/tests/components/lvgl/lvgl-package.yaml
@@ -552,6 +552,7 @@ lvgl:
                 scroll_snap_y: center
                 scroll_snap_x: start
                 layout: vertical
+                pad_all: 6px
                 row: 0
                 column: 0
                 dir: ALL
@@ -1049,6 +1050,7 @@ lvgl:
                                 opa: 0%
     - id: page3
       layout: Horizontal
+      pad_all: 6px
       widgets:
         - keyboard:
             id: lv_keyboard