From 3e17767f6a310d10e33e74849e61786bfabeab78 Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Mon, 3 Nov 2025 10:50:15 +1000
Subject: [PATCH 01/13] [font][image] Use ESPHome urls for remote images
 (#11675)

---
 tests/components/font/common.yaml    | 4 ++--
 tests/components/font/test.host.yaml | 4 ++--
 tests/components/image/common.yaml   | 6 +++---
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/components/font/common.yaml b/tests/components/font/common.yaml
index 6ba52e3d97..c156b4aea1 100644
--- a/tests/components/font/common.yaml
+++ b/tests/components/font/common.yaml
@@ -21,12 +21,12 @@ font:
     id: roboto_greek
     size: 20
     glyphs: ["\u0300", "\u00C5", "\U000000C7"]
-  - file: "https://github.com/IdreesInc/Monocraft/releases/download/v3.0/Monocraft.ttf"
+  - file: "https://media.esphome.io/tests/fonts/Monocraft.ttf"
     id: monocraft
     size: 20
   - file:
       type: web
-      url: "https://github.com/IdreesInc/Monocraft/releases/download/v3.0/Monocraft.ttf"
+      url: "https://media.esphome.io/tests/fonts/Monocraft.ttf"
     id: monocraft2
     size: 24
   - file: $component_dir/Monocraft.ttf
diff --git a/tests/components/font/test.host.yaml b/tests/components/font/test.host.yaml
index c5399f2826..387ea47335 100644
--- a/tests/components/font/test.host.yaml
+++ b/tests/components/font/test.host.yaml
@@ -21,12 +21,12 @@ font:
     id: roboto_greek
     size: 20
     glyphs: ["\u0300", "\u00C5", "\U000000C7"]
-  - file: "https://github.com/IdreesInc/Monocraft/releases/download/v3.0/Monocraft.ttf"
+  - file: "https://media.esphome.io/tests/fonts/Monocraft.ttf"
     id: monocraft
     size: 20
   - file:
       type: web
-      url: "https://github.com/IdreesInc/Monocraft/releases/download/v3.0/Monocraft.ttf"
+      url: "https://media.esphome.io/tests/fonts/Monocraft.ttf"
     id: monocraft2
     size: 24
   - file: $component_dir/Monocraft.ttf
diff --git a/tests/components/image/common.yaml b/tests/components/image/common.yaml
index 864ca41c44..9819068970 100644
--- a/tests/components/image/common.yaml
+++ b/tests/components/image/common.yaml
@@ -50,16 +50,16 @@ image:
     transparency: opaque
 
   - id: web_svg_image
-    file: https://raw.githubusercontent.com/esphome/esphome-docs/a62d7ab193c1a464ed791670170c7d518189109b/images/logo.svg
+    file: https://media.esphome.io/logo/logo.svg
     resize: 256x48
     type: BINARY
     transparency: chroma_key
   - id: web_tiff_image
-    file: https://upload.wikimedia.org/wikipedia/commons/b/b6/SIPI_Jelly_Beans_4.1.07.tiff
+    file: https://media.esphome.io/tests/images/SIPI_Jelly_Beans_4.1.07.tiff
     type: RGB
     resize: 48x48
   - id: web_redirect_image
-    file: https://avatars.githubusercontent.com/u/3060199?s=48&v=4
+    file: https://media.esphome.io/logo/logo.png
     type: RGB
     resize: 48x48
   - id: mdi_alert

From 1509ed8d2391f0cdd16e65b703e2979006515200 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:04:06 -0600
Subject: [PATCH 02/13] [esphome][ota] Add write_byte_() helper to reduce code
 duplication (#11511)

---
 .../components/esphome/ota/ota_esphome.cpp    | 28 ++++++-------------
 esphome/components/esphome/ota/ota_esphome.h  |  1 +
 2 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/esphome/components/esphome/ota/ota_esphome.cpp b/esphome/components/esphome/ota/ota_esphome.cpp
index 569268ea15..b85d660272 100644
--- a/esphome/components/esphome/ota/ota_esphome.cpp
+++ b/esphome/components/esphome/ota/ota_esphome.cpp
@@ -281,19 +281,15 @@ void ESPHomeOTAComponent::handle_data_() {
 #endif
 
   // Acknowledge auth OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_AUTH_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_AUTH_OK);
 
   // Read size, 4 bytes MSB first
   if (!this->readall_(buf, 4)) {
     this->log_read_error_(LOG_STR("size"));
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
-  ota_size = 0;
-  for (uint8_t i = 0; i < 4; i++) {
-    ota_size <<= 8;
-    ota_size |= buf[i];
-  }
+  ota_size = (static_cast<size_t>(buf[0]) << 24) | (static_cast<size_t>(buf[1]) << 16) |
+             (static_cast<size_t>(buf[2]) << 8) | buf[3];
   ESP_LOGV(TAG, "Size is %u bytes", ota_size);
 
   // Now that we've passed authentication and are actually
@@ -313,8 +309,7 @@ void ESPHomeOTAComponent::handle_data_() {
   update_started = true;
 
   // Acknowledge prepare OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_UPDATE_PREPARE_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_UPDATE_PREPARE_OK);
 
   // Read binary MD5, 32 bytes
   if (!this->readall_(buf, 32)) {
@@ -326,8 +321,7 @@ void ESPHomeOTAComponent::handle_data_() {
   this->backend_->set_update_md5(sbuf);
 
   // Acknowledge MD5 OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_BIN_MD5_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_BIN_MD5_OK);
 
   while (total < ota_size) {
     // TODO: timeout check
@@ -354,8 +348,7 @@ void ESPHomeOTAComponent::handle_data_() {
     total += read;
 #if USE_OTA_VERSION == 2
     while (size_acknowledged + OTA_BLOCK_SIZE <= total || (total == ota_size && size_acknowledged < ota_size)) {
-      buf[0] = ota::OTA_RESPONSE_CHUNK_OK;
-      this->writeall_(buf, 1);
+      this->write_byte_(ota::OTA_RESPONSE_CHUNK_OK);
       size_acknowledged += OTA_BLOCK_SIZE;
     }
 #endif
@@ -374,8 +367,7 @@ void ESPHomeOTAComponent::handle_data_() {
   }
 
   // Acknowledge receive OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_RECEIVE_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_RECEIVE_OK);
 
   error_code = this->backend_->end();
   if (error_code != ota::OTA_RESPONSE_OK) {
@@ -384,8 +376,7 @@ void ESPHomeOTAComponent::handle_data_() {
   }
 
   // Acknowledge Update end OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_UPDATE_END_OK;
-  this->writeall_(buf, 1);
+  this->write_byte_(ota::OTA_RESPONSE_UPDATE_END_OK);
 
   // Read ACK
   if (!this->readall_(buf, 1) || buf[0] != ota::OTA_RESPONSE_OK) {
@@ -404,8 +395,7 @@ void ESPHomeOTAComponent::handle_data_() {
   App.safe_reboot();
 
 error:
-  buf[0] = static_cast<uint8_t>(error_code);
-  this->writeall_(buf, 1);
+  this->write_byte_(static_cast<uint8_t>(error_code));
   this->cleanup_connection_();
 
   if (this->backend_ != nullptr && update_started) {
diff --git a/esphome/components/esphome/ota/ota_esphome.h b/esphome/components/esphome/ota/ota_esphome.h
index d4a8410d35..057461e6a4 100644
--- a/esphome/components/esphome/ota/ota_esphome.h
+++ b/esphome/components/esphome/ota/ota_esphome.h
@@ -53,6 +53,7 @@ class ESPHomeOTAComponent : public ota::OTAComponent {
 #endif  // USE_OTA_PASSWORD
   bool readall_(uint8_t *buf, size_t len);
   bool writeall_(const uint8_t *buf, size_t len);
+  inline bool write_byte_(uint8_t byte) { return this->writeall_(&byte, 1); }
 
   bool try_read_(size_t to_read, const LogString *desc);
   bool try_write_(size_t to_write, const LogString *desc);

From 17ab20ef6108bcf4c3c2f67d2f022cbe71d9c00d Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:05:36 -0600
Subject: [PATCH 03/13] [esp32_ble] Optimize loop() to reduce flash usage by
 ~104 bytes (#11627)

---
 esphome/components/esp32_ble/ble.cpp | 120 +++++++++++++--------------
 1 file changed, 59 insertions(+), 61 deletions(-)

diff --git a/esphome/components/esp32_ble/ble.cpp b/esphome/components/esp32_ble/ble.cpp
index 5bbd5fe9ed..69e317ff6d 100644
--- a/esphome/components/esp32_ble/ble.cpp
+++ b/esphome/components/esp32_ble/ble.cpp
@@ -31,6 +31,26 @@ namespace esphome::esp32_ble {
 
 static const char *const TAG = "esp32_ble";
 
+// GAP event groups for deduplication across gap_event_handler and dispatch_gap_event_
+#define GAP_SCAN_COMPLETE_EVENTS \
+  case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT: \
+  case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT: \
+  case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT
+
+#define GAP_ADV_COMPLETE_EVENTS \
+  case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT: \
+  case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT: \
+  case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT: \
+  case ESP_GAP_BLE_ADV_START_COMPLETE_EVT: \
+  case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT
+
+#define GAP_SECURITY_EVENTS \
+  case ESP_GAP_BLE_AUTH_CMPL_EVT: \
+  case ESP_GAP_BLE_SEC_REQ_EVT: \
+  case ESP_GAP_BLE_PASSKEY_NOTIF_EVT: \
+  case ESP_GAP_BLE_PASSKEY_REQ_EVT: \
+  case ESP_GAP_BLE_NC_REQ_EVT
+
 void ESP32BLE::setup() {
   global_ble = this;
   if (!ble_pre_setup_()) {
@@ -414,60 +434,48 @@ void ESP32BLE::loop() {
             break;
 
           // Scan complete events
-          case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
-          case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
-          case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
-            // All three scan complete events have the same structure with just status
-            // The scan_complete struct matches ESP-IDF's layout exactly, so this reinterpret_cast is safe
-            // This is verified at compile-time by static_assert checks in ble_event.h
-            // The struct already contains our copy of the status (copied in BLEEvent constructor)
-            ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
-#ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
-            for (auto *gap_handler : this->gap_event_handlers_) {
-              gap_handler->gap_event_handler(
-                  gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.scan_complete));
-            }
-#endif
-            break;
-
+          GAP_SCAN_COMPLETE_EVENTS:
           // Advertising complete events
-          case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
-          case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT:
-          case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
-          case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
-          case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
-            // All advertising complete events have the same structure with just status
-            ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
-#ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
-            for (auto *gap_handler : this->gap_event_handlers_) {
-              gap_handler->gap_event_handler(
-                  gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.adv_complete));
-            }
-#endif
-            break;
-
+          GAP_ADV_COMPLETE_EVENTS:
           // RSSI complete event
           case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT:
-            ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
-#ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
-            for (auto *gap_handler : this->gap_event_handlers_) {
-              gap_handler->gap_event_handler(
-                  gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.read_rssi_complete));
-            }
-#endif
-            break;
-
           // Security events
-          case ESP_GAP_BLE_AUTH_CMPL_EVT:
-          case ESP_GAP_BLE_SEC_REQ_EVT:
-          case ESP_GAP_BLE_PASSKEY_NOTIF_EVT:
-          case ESP_GAP_BLE_PASSKEY_REQ_EVT:
-          case ESP_GAP_BLE_NC_REQ_EVT:
+          GAP_SECURITY_EVENTS:
             ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
 #ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
-            for (auto *gap_handler : this->gap_event_handlers_) {
-              gap_handler->gap_event_handler(
-                  gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.security));
+            {
+              esp_ble_gap_cb_param_t *param;
+              // clang-format off
+              switch (gap_event) {
+                // All three scan complete events have the same structure with just status
+                // The scan_complete struct matches ESP-IDF's layout exactly, so this reinterpret_cast is safe
+                // This is verified at compile-time by static_assert checks in ble_event.h
+                // The struct already contains our copy of the status (copied in BLEEvent constructor)
+                GAP_SCAN_COMPLETE_EVENTS:
+                  param = reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.scan_complete);
+                  break;
+
+                // All advertising complete events have the same structure with just status
+                GAP_ADV_COMPLETE_EVENTS:
+                  param = reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.adv_complete);
+                  break;
+
+                case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT:
+                  param = reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.read_rssi_complete);
+                  break;
+
+                GAP_SECURITY_EVENTS:
+                  param = reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.security);
+                  break;
+
+                default:
+                  break;
+              }
+              // clang-format on
+              // Dispatch to all registered handlers
+              for (auto *gap_handler : this->gap_event_handlers_) {
+                gap_handler->gap_event_handler(gap_event, param);
+              }
             }
 #endif
             break;
@@ -547,23 +555,13 @@ void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_pa
     // Queue GAP events that components need to handle
     // Scanning events - used by esp32_ble_tracker
     case ESP_GAP_BLE_SCAN_RESULT_EVT:
-    case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
-    case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
-    case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
+    GAP_SCAN_COMPLETE_EVENTS:
     // Advertising events - used by esp32_ble_beacon and esp32_ble server
-    case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
-    case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT:
-    case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
-    case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
-    case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
+    GAP_ADV_COMPLETE_EVENTS:
     // Connection events - used by ble_client
     case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT:
     // Security events - used by ble_client and bluetooth_proxy
-    case ESP_GAP_BLE_AUTH_CMPL_EVT:
-    case ESP_GAP_BLE_SEC_REQ_EVT:
-    case ESP_GAP_BLE_PASSKEY_NOTIF_EVT:
-    case ESP_GAP_BLE_PASSKEY_REQ_EVT:
-    case ESP_GAP_BLE_NC_REQ_EVT:
+    GAP_SECURITY_EVENTS:
       enqueue_ble_event(event, param);
       return;
 

From 01ae86145a7e15f8c537798a6f6f3050596bcf99 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:06:40 -0600
Subject: [PATCH 04/13] [ble_client] Fix premature disconnections by reading
 characteristics immediately after service discovery (#11410)

---
 esphome/components/ble_client/sensor/ble_sensor.cpp           | 3 +++
 esphome/components/ble_client/text_sensor/ble_text_sensor.cpp | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/esphome/components/ble_client/sensor/ble_sensor.cpp b/esphome/components/ble_client/sensor/ble_sensor.cpp
index 6d293528c6..61685c0566 100644
--- a/esphome/components/ble_client/sensor/ble_sensor.cpp
+++ b/esphome/components/ble_client/sensor/ble_sensor.cpp
@@ -77,6 +77,9 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
         }
       } else {
         this->node_state = espbt::ClientState::ESTABLISHED;
+        // For non-notify characteristics, trigger an immediate read after service discovery
+        // to avoid peripherals disconnecting due to inactivity
+        this->update();
       }
       break;
     }
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 e7da297fa0..b7a6d154db 100644
--- a/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
+++ b/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
@@ -79,6 +79,9 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         }
       } else {
         this->node_state = espbt::ClientState::ESTABLISHED;
+        // For non-notify characteristics, trigger an immediate read after service discovery
+        // to avoid peripherals disconnecting due to inactivity
+        this->update();
       }
       break;
     }

From 40f919eaa6f3fb60d461f745220d414e66ca80bf Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:07:03 -0600
Subject: [PATCH 05/13] Add action continuation tests (#11674)

---
 tests/components/api/common-base.yaml         |  96 +++++++
 .../fixtures/continuation_actions.yaml        | 174 +++++++++++++
 .../integration/test_continuation_actions.py  | 235 ++++++++++++++++++
 3 files changed, 505 insertions(+)
 create mode 100644 tests/integration/fixtures/continuation_actions.yaml
 create mode 100644 tests/integration/test_continuation_actions.py

diff --git a/tests/components/api/common-base.yaml b/tests/components/api/common-base.yaml
index 6483d5a997..c90fa4dfef 100644
--- a/tests/components/api/common-base.yaml
+++ b/tests/components/api/common-base.yaml
@@ -87,3 +87,99 @@ api:
               - float_arr.size()
               - string_arr[0].c_str()
               - string_arr.size()
+    # Test ContinuationAction (IfAction with then/else branches)
+    - action: test_if_action
+      variables:
+        condition: bool
+        value: int
+      then:
+        - if:
+            condition:
+              lambda: 'return condition;'
+            then:
+              - logger.log:
+                  format: "Condition true, value: %d"
+                  args: ['value']
+            else:
+              - logger.log:
+                  format: "Condition false, value: %d"
+                  args: ['value']
+        - logger.log: "After if/else"
+    # Test nested IfAction (multiple ContinuationAction instances)
+    - action: test_nested_if
+      variables:
+        outer: bool
+        inner: bool
+      then:
+        - if:
+            condition:
+              lambda: 'return outer;'
+            then:
+              - if:
+                  condition:
+                    lambda: 'return inner;'
+                  then:
+                    - logger.log: "Both true"
+                  else:
+                    - logger.log: "Outer true, inner false"
+            else:
+              - logger.log: "Outer false"
+        - logger.log: "After nested if"
+    # Test WhileLoopContinuation (WhileAction)
+    - action: test_while_action
+      variables:
+        max_count: int
+      then:
+        - lambda: 'id(api_continuation_test_counter) = 0;'
+        - while:
+            condition:
+              lambda: 'return id(api_continuation_test_counter) < max_count;'
+            then:
+              - logger.log:
+                  format: "While loop iteration: %d"
+                  args: ['id(api_continuation_test_counter)']
+              - lambda: 'id(api_continuation_test_counter)++;'
+        - logger.log: "After while loop"
+    # Test RepeatLoopContinuation (RepeatAction)
+    - action: test_repeat_action
+      variables:
+        count: int
+      then:
+        - repeat:
+            count: !lambda 'return count;'
+            then:
+              - logger.log:
+                  format: "Repeat iteration: %d"
+                  args: ['iteration']
+        - logger.log: "After repeat"
+    # Test combined continuations (if + while + repeat)
+    - action: test_combined_continuations
+      variables:
+        do_loop: bool
+        loop_count: int
+      then:
+        - if:
+            condition:
+              lambda: 'return do_loop;'
+            then:
+              - repeat:
+                  count: !lambda 'return loop_count;'
+                  then:
+                    - lambda: 'id(api_continuation_test_counter) = iteration;'
+                    - while:
+                        condition:
+                          lambda: 'return id(api_continuation_test_counter) > 0;'
+                        then:
+                          - logger.log:
+                              format: "Combined: repeat=%d, while=%d"
+                              args: ['iteration', 'id(api_continuation_test_counter)']
+                          - lambda: 'id(api_continuation_test_counter)--;'
+            else:
+              - logger.log: "Skipped loops"
+        - logger.log: "After combined test"
+
+globals:
+  - id: api_continuation_test_counter
+    type: int
+    restore_value: false
+    initial_value: '0'
diff --git a/tests/integration/fixtures/continuation_actions.yaml b/tests/integration/fixtures/continuation_actions.yaml
new file mode 100644
index 0000000000..bdfe149cb7
--- /dev/null
+++ b/tests/integration/fixtures/continuation_actions.yaml
@@ -0,0 +1,174 @@
+esphome:
+  name: test-continuation-actions
+
+host:
+
+api:
+  actions:
+    # Test 1: IfAction with ContinuationAction (then/else branches)
+    - action: test_if_action
+      variables:
+        condition: bool
+        value: int
+      then:
+        - logger.log:
+            format: "Test if: condition=%s, value=%d"
+            args: ['YESNO(condition)', 'value']
+        - if:
+            condition:
+              lambda: 'return condition;'
+            then:
+              - logger.log:
+                  format: "if-then executed: value=%d"
+                  args: ['value']
+            else:
+              - logger.log:
+                  format: "if-else executed: value=%d"
+                  args: ['value']
+        - logger.log: "if completed"
+
+    # Test 2: Nested IfAction (multiple ContinuationAction instances)
+    - action: test_nested_if
+      variables:
+        outer: bool
+        inner: bool
+      then:
+        - logger.log:
+            format: "Test nested if: outer=%s, inner=%s"
+            args: ['YESNO(outer)', 'YESNO(inner)']
+        - if:
+            condition:
+              lambda: 'return outer;'
+            then:
+              - if:
+                  condition:
+                    lambda: 'return inner;'
+                  then:
+                    - logger.log: "nested-both-true"
+                  else:
+                    - logger.log: "nested-outer-true-inner-false"
+            else:
+              - logger.log: "nested-outer-false"
+        - logger.log: "nested if completed"
+
+    # Test 3: WhileAction with WhileLoopContinuation
+    - action: test_while_action
+      variables:
+        max_count: int
+      then:
+        - logger.log:
+            format: "Test while: max_count=%d"
+            args: ['max_count']
+        - globals.set:
+            id: continuation_test_counter
+            value: !lambda 'return 0;'
+        - while:
+            condition:
+              lambda: 'return id(continuation_test_counter) < max_count;'
+            then:
+              - logger.log:
+                  format: "while-iteration-%d"
+                  args: ['id(continuation_test_counter)']
+              - globals.set:
+                  id: continuation_test_counter
+                  value: !lambda 'return id(continuation_test_counter) + 1;'
+        - logger.log: "while completed"
+
+    # Test 4: RepeatAction with RepeatLoopContinuation
+    - action: test_repeat_action
+      variables:
+        count: int
+      then:
+        - logger.log:
+            format: "Test repeat: count=%d"
+            args: ['count']
+        - repeat:
+            count: !lambda 'return count;'
+            then:
+              - logger.log:
+                  format: "repeat-iteration-%d"
+                  args: ['iteration']
+        - logger.log: "repeat completed"
+
+    # Test 5: Combined continuations (if + while + repeat)
+    - action: test_combined
+      variables:
+        do_loop: bool
+        loop_count: int
+      then:
+        - logger.log:
+            format: "Test combined: do_loop=%s, loop_count=%d"
+            args: ['YESNO(do_loop)', 'loop_count']
+        - if:
+            condition:
+              lambda: 'return do_loop;'
+            then:
+              - repeat:
+                  count: !lambda 'return loop_count;'
+                  then:
+                    - globals.set:
+                        id: continuation_test_counter
+                        value: !lambda 'return iteration;'
+                    - while:
+                        condition:
+                          lambda: 'return id(continuation_test_counter) > 0;'
+                        then:
+                          - logger.log:
+                              format: "combined-repeat%d-while%d"
+                              args: ['iteration', 'id(continuation_test_counter)']
+                          - globals.set:
+                              id: continuation_test_counter
+                              value: !lambda 'return id(continuation_test_counter) - 1;'
+            else:
+              - logger.log: "combined-skipped"
+        - logger.log: "combined completed"
+
+    # Test 6: Rapid triggers to verify memory efficiency
+    - action: test_rapid_if
+      then:
+        - logger.log: "=== Rapid if test start ==="
+        - sensor.template.publish:
+            id: rapid_sensor
+            state: 1
+        - sensor.template.publish:
+            id: rapid_sensor
+            state: 2
+        - sensor.template.publish:
+            id: rapid_sensor
+            state: 3
+        - sensor.template.publish:
+            id: rapid_sensor
+            state: 4
+        - sensor.template.publish:
+            id: rapid_sensor
+            state: 5
+        - logger.log: "=== Rapid if test published 5 values ==="
+
+logger:
+  level: DEBUG
+
+globals:
+  - id: continuation_test_counter
+    type: int
+    restore_value: false
+    initial_value: '0'
+
+# Sensor to test rapid automation triggers with if/else (ContinuationAction)
+sensor:
+  - platform: template
+    id: rapid_sensor
+    on_value:
+      - if:
+          condition:
+            lambda: 'return x > 2;'
+          then:
+            - logger.log:
+                format: "rapid-if-then: value=%d"
+                args: ['(int)x']
+          else:
+            - logger.log:
+                format: "rapid-if-else: value=%d"
+                args: ['(int)x']
+      - logger.log:
+          format: "rapid-if-completed: value=%d"
+          args: ['(int)x']
diff --git a/tests/integration/test_continuation_actions.py b/tests/integration/test_continuation_actions.py
new file mode 100644
index 0000000000..1069ee7581
--- /dev/null
+++ b/tests/integration/test_continuation_actions.py
@@ -0,0 +1,235 @@
+"""Test continuation actions (ContinuationAction, WhileLoopContinuation, RepeatLoopContinuation)."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_continuation_actions(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """
+    Test that continuation actions work correctly for if/while/repeat.
+
+    These continuation classes replace LambdaAction with simple parent pointers,
+    saving 32-36 bytes per instance and eliminating std::function overhead.
+    """
+    loop = asyncio.get_running_loop()
+
+    # Track test completions
+    test_results = {
+        "if_then": False,
+        "if_else": False,
+        "if_complete": False,
+        "nested_both_true": False,
+        "nested_outer_true_inner_false": False,
+        "nested_outer_false": False,
+        "nested_complete": False,
+        "while_iterations": 0,
+        "while_complete": False,
+        "repeat_iterations": 0,
+        "repeat_complete": False,
+        "combined_iterations": 0,
+        "combined_complete": False,
+        "rapid_then": 0,
+        "rapid_else": 0,
+        "rapid_complete": 0,
+    }
+
+    # Patterns for log messages
+    if_then_pattern = re.compile(r"if-then executed: value=(\d+)")
+    if_else_pattern = re.compile(r"if-else executed: value=(\d+)")
+    if_complete_pattern = re.compile(r"if completed")
+    nested_both_true_pattern = re.compile(r"nested-both-true")
+    nested_outer_true_inner_false_pattern = re.compile(r"nested-outer-true-inner-false")
+    nested_outer_false_pattern = re.compile(r"nested-outer-false")
+    nested_complete_pattern = re.compile(r"nested if completed")
+    while_iteration_pattern = re.compile(r"while-iteration-(\d+)")
+    while_complete_pattern = re.compile(r"while completed")
+    repeat_iteration_pattern = re.compile(r"repeat-iteration-(\d+)")
+    repeat_complete_pattern = re.compile(r"repeat completed")
+    combined_pattern = re.compile(r"combined-repeat(\d+)-while(\d+)")
+    combined_complete_pattern = re.compile(r"combined completed")
+    rapid_then_pattern = re.compile(r"rapid-if-then: value=(\d+)")
+    rapid_else_pattern = re.compile(r"rapid-if-else: value=(\d+)")
+    rapid_complete_pattern = re.compile(r"rapid-if-completed: value=(\d+)")
+
+    # Test completion futures
+    test1_complete = loop.create_future()  # if action
+    test2_complete = loop.create_future()  # nested if
+    test3_complete = loop.create_future()  # while
+    test4_complete = loop.create_future()  # repeat
+    test5_complete = loop.create_future()  # combined
+    test6_complete = loop.create_future()  # rapid
+
+    def check_output(line: str) -> None:
+        """Check log output for test messages."""
+        # Test 1: IfAction
+        if if_then_pattern.search(line):
+            test_results["if_then"] = True
+        if if_else_pattern.search(line):
+            test_results["if_else"] = True
+        if if_complete_pattern.search(line):
+            test_results["if_complete"] = True
+            if not test1_complete.done():
+                test1_complete.set_result(True)
+
+        # Test 2: Nested IfAction
+        if nested_both_true_pattern.search(line):
+            test_results["nested_both_true"] = True
+        if nested_outer_true_inner_false_pattern.search(line):
+            test_results["nested_outer_true_inner_false"] = True
+        if nested_outer_false_pattern.search(line):
+            test_results["nested_outer_false"] = True
+        if nested_complete_pattern.search(line):
+            test_results["nested_complete"] = True
+            if not test2_complete.done():
+                test2_complete.set_result(True)
+
+        # Test 3: WhileAction
+        if match := while_iteration_pattern.search(line):
+            test_results["while_iterations"] = max(
+                test_results["while_iterations"], int(match.group(1)) + 1
+            )
+        if while_complete_pattern.search(line):
+            test_results["while_complete"] = True
+            if not test3_complete.done():
+                test3_complete.set_result(True)
+
+        # Test 4: RepeatAction
+        if match := repeat_iteration_pattern.search(line):
+            test_results["repeat_iterations"] = max(
+                test_results["repeat_iterations"], int(match.group(1)) + 1
+            )
+        if repeat_complete_pattern.search(line):
+            test_results["repeat_complete"] = True
+            if not test4_complete.done():
+                test4_complete.set_result(True)
+
+        # Test 5: Combined
+        if combined_pattern.search(line):
+            test_results["combined_iterations"] += 1
+        if combined_complete_pattern.search(line):
+            test_results["combined_complete"] = True
+            if not test5_complete.done():
+                test5_complete.set_result(True)
+
+        # Test 6: Rapid triggers
+        if rapid_then_pattern.search(line):
+            test_results["rapid_then"] += 1
+        if rapid_else_pattern.search(line):
+            test_results["rapid_else"] += 1
+        if rapid_complete_pattern.search(line):
+            test_results["rapid_complete"] += 1
+            if test_results["rapid_complete"] == 5 and not test6_complete.done():
+                test6_complete.set_result(True)
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        # Get services
+        _, services = await client.list_entities_services()
+
+        # Test 1: IfAction with then branch
+        test_service = next((s for s in services if s.name == "test_if_action"), None)
+        assert test_service is not None, "test_if_action service not found"
+        client.execute_service(test_service, {"condition": True, "value": 42})
+        await asyncio.wait_for(test1_complete, timeout=2.0)
+        assert test_results["if_then"], "IfAction then branch not executed"
+        assert test_results["if_complete"], "IfAction did not complete"
+
+        # Test 1b: IfAction with else branch
+        test1_complete = loop.create_future()
+        test_results["if_complete"] = False
+        client.execute_service(test_service, {"condition": False, "value": 99})
+        await asyncio.wait_for(test1_complete, timeout=2.0)
+        assert test_results["if_else"], "IfAction else branch not executed"
+        assert test_results["if_complete"], "IfAction did not complete"
+
+        # Test 2: Nested IfAction - test all branches
+        test_service = next((s for s in services if s.name == "test_nested_if"), None)
+        assert test_service is not None, "test_nested_if service not found"
+
+        # Both true
+        client.execute_service(test_service, {"outer": True, "inner": True})
+        await asyncio.wait_for(test2_complete, timeout=2.0)
+        assert test_results["nested_both_true"], "Nested both true not executed"
+
+        # Outer true, inner false
+        test2_complete = loop.create_future()
+        test_results["nested_complete"] = False
+        client.execute_service(test_service, {"outer": True, "inner": False})
+        await asyncio.wait_for(test2_complete, timeout=2.0)
+        assert test_results["nested_outer_true_inner_false"], (
+            "Nested outer true inner false not executed"
+        )
+
+        # Outer false
+        test2_complete = loop.create_future()
+        test_results["nested_complete"] = False
+        client.execute_service(test_service, {"outer": False, "inner": True})
+        await asyncio.wait_for(test2_complete, timeout=2.0)
+        assert test_results["nested_outer_false"], "Nested outer false not executed"
+
+        # Test 3: WhileAction
+        test_service = next(
+            (s for s in services if s.name == "test_while_action"), None
+        )
+        assert test_service is not None, "test_while_action service not found"
+        client.execute_service(test_service, {"max_count": 3})
+        await asyncio.wait_for(test3_complete, timeout=2.0)
+        assert test_results["while_iterations"] == 3, (
+            f"WhileAction expected 3 iterations, got {test_results['while_iterations']}"
+        )
+        assert test_results["while_complete"], "WhileAction did not complete"
+
+        # Test 4: RepeatAction
+        test_service = next(
+            (s for s in services if s.name == "test_repeat_action"), None
+        )
+        assert test_service is not None, "test_repeat_action service not found"
+        client.execute_service(test_service, {"count": 5})
+        await asyncio.wait_for(test4_complete, timeout=2.0)
+        assert test_results["repeat_iterations"] == 5, (
+            f"RepeatAction expected 5 iterations, got {test_results['repeat_iterations']}"
+        )
+        assert test_results["repeat_complete"], "RepeatAction did not complete"
+
+        # Test 5: Combined (if + repeat + while)
+        test_service = next((s for s in services if s.name == "test_combined"), None)
+        assert test_service is not None, "test_combined service not found"
+        client.execute_service(test_service, {"do_loop": True, "loop_count": 2})
+        await asyncio.wait_for(test5_complete, timeout=2.0)
+        # Should execute: repeat 2 times, each iteration does while from iteration down to 0
+        # iteration 0: while 0 times = 0
+        # iteration 1: while 1 time = 1
+        # Total: 1 combined log
+        assert test_results["combined_iterations"] >= 1, (
+            f"Combined expected >=1 iterations, got {test_results['combined_iterations']}"
+        )
+        assert test_results["combined_complete"], "Combined did not complete"
+
+        # Test 6: Rapid triggers (tests memory efficiency of ContinuationAction)
+        test_service = next((s for s in services if s.name == "test_rapid_if"), None)
+        assert test_service is not None, "test_rapid_if service not found"
+        client.execute_service(test_service, {})
+        await asyncio.wait_for(test6_complete, timeout=2.0)
+        # Values 1, 2 should hit else (<=2), values 3, 4, 5 should hit then (>2)
+        assert test_results["rapid_else"] == 2, (
+            f"Rapid test expected 2 else, got {test_results['rapid_else']}"
+        )
+        assert test_results["rapid_then"] == 3, (
+            f"Rapid test expected 3 then, got {test_results['rapid_then']}"
+        )
+        assert test_results["rapid_complete"] == 5, (
+            f"Rapid test expected 5 completions, got {test_results['rapid_complete']}"
+        )

From 7a1297ec8428025075b48d52f3d32c1ccd8de8e3 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:08:12 -0600
Subject: [PATCH 06/13] [web_server] Remove redundant assignment in
 deq_push_back_with_dedup_ (#11642)

---
 esphome/components/web_server/web_server.cpp         | 3 +--
 esphome/components/web_server_idf/web_server_idf.cpp | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/esphome/components/web_server/web_server.cpp b/esphome/components/web_server/web_server.cpp
index 1d08ef5a35..61951e2600 100644
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -111,8 +111,7 @@ void DeferredUpdateEventSource::deq_push_back_with_dedup_(void *source, message_
   // Use range-based for loop instead of std::find_if to reduce template instantiation overhead and binary size
   for (auto &event : this->deferred_queue_) {
     if (event == item) {
-      event = item;
-      return;
+      return;  // Already in queue, no need to update since items are equal
     }
   }
   this->deferred_queue_.push_back(item);
diff --git a/esphome/components/web_server_idf/web_server_idf.cpp b/esphome/components/web_server_idf/web_server_idf.cpp
index c3ba7ddc2b..ac0b5bad83 100644
--- a/esphome/components/web_server_idf/web_server_idf.cpp
+++ b/esphome/components/web_server_idf/web_server_idf.cpp
@@ -494,8 +494,7 @@ void AsyncEventSourceResponse::deq_push_back_with_dedup_(void *source, message_g
   // Use range-based for loop instead of std::find_if to reduce template instantiation overhead and binary size
   for (auto &event : this->deferred_queue_) {
     if (event == item) {
-      event = item;
-      return;
+      return;  // Already in queue, no need to update since items are equal
     }
   }
   this->deferred_queue_.push_back(item);

From 712421b82b6dc241329f25993d5500656e500f1b Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:10:18 -0600
Subject: [PATCH 07/13] [web_server] Eliminate nested lambdas in
 DeferredUpdateEventSourceList (#11641)

---
 esphome/components/web_server/web_server.cpp | 61 ++++++++++----------
 esphome/components/web_server/web_server.h   |  2 +-
 2 files changed, 32 insertions(+), 31 deletions(-)

diff --git a/esphome/components/web_server/web_server.cpp b/esphome/components/web_server/web_server.cpp
index 61951e2600..cc62b019c3 100644
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -219,50 +219,51 @@ void DeferredUpdateEventSourceList::add_new_client(WebServer *ws, AsyncWebServer
   DeferredUpdateEventSource *es = new DeferredUpdateEventSource(ws, "/events");
   this->push_back(es);
 
-  es->onConnect([this, ws, es](AsyncEventSourceClient *client) {
-    ws->defer([this, ws, es]() { this->on_client_connect_(ws, es); });
-  });
+  es->onConnect([this, es](AsyncEventSourceClient *client) { this->on_client_connect_(es); });
 
-  es->onDisconnect([this, ws, es](AsyncEventSourceClient *client) {
-    ws->defer([this, es]() { this->on_client_disconnect_((DeferredUpdateEventSource *) es); });
-  });
+  es->onDisconnect([this, es](AsyncEventSourceClient *client) { this->on_client_disconnect_(es); });
 
   es->handleRequest(request);
 }
 
-void DeferredUpdateEventSourceList::on_client_connect_(WebServer *ws, DeferredUpdateEventSource *source) {
-  // Configure reconnect timeout and send config
-  // this should always go through since the AsyncEventSourceClient event queue is empty on connect
-  std::string message = ws->get_config_json();
-  source->try_send_nodefer(message.c_str(), "ping", millis(), 30000);
+void DeferredUpdateEventSourceList::on_client_connect_(DeferredUpdateEventSource *source) {
+  WebServer *ws = source->web_server_;
+  ws->defer([ws, source]() {
+    // Configure reconnect timeout and send config
+    // this should always go through since the AsyncEventSourceClient event queue is empty on connect
+    std::string message = ws->get_config_json();
+    source->try_send_nodefer(message.c_str(), "ping", millis(), 30000);
 
 #ifdef USE_WEBSERVER_SORTING
-  for (auto &group : ws->sorting_groups_) {
-    json::JsonBuilder builder;
-    JsonObject root = builder.root();
-    root["name"] = group.second.name;
-    root["sorting_weight"] = group.second.weight;
-    message = builder.serialize();
+    for (auto &group : ws->sorting_groups_) {
+      json::JsonBuilder builder;
+      JsonObject root = builder.root();
+      root["name"] = group.second.name;
+      root["sorting_weight"] = group.second.weight;
+      message = builder.serialize();
 
-    // up to 31 groups should be able to be queued initially without defer
-    source->try_send_nodefer(message.c_str(), "sorting_group");
-  }
+      // up to 31 groups should be able to be queued initially without defer
+      source->try_send_nodefer(message.c_str(), "sorting_group");
+    }
 #endif
 
-  source->entities_iterator_.begin(ws->include_internal_);
+    source->entities_iterator_.begin(ws->include_internal_);
 
-  // just dump them all up-front and take advantage of the deferred queue
-  //     on second thought that takes too long, but leaving the commented code here for debug purposes
-  // while(!source->entities_iterator_.completed()) {
-  //  source->entities_iterator_.advance();
-  //}
+    // just dump them all up-front and take advantage of the deferred queue
+    //     on second thought that takes too long, but leaving the commented code here for debug purposes
+    // while(!source->entities_iterator_.completed()) {
+    //  source->entities_iterator_.advance();
+    //}
+  });
 }
 
 void DeferredUpdateEventSourceList::on_client_disconnect_(DeferredUpdateEventSource *source) {
-  // This method was called via WebServer->defer() and is no longer executing in the
-  // context of the network callback. The object is now dead and can be safely deleted.
-  this->remove(source);
-  delete source;  // NOLINT
+  source->web_server_->defer([this, source]() {
+    // This method was called via WebServer->defer() and is no longer executing in the
+    // context of the network callback. The object is now dead and can be safely deleted.
+    this->remove(source);
+    delete source;  // NOLINT
+  });
 }
 #endif
 
diff --git a/esphome/components/web_server/web_server.h b/esphome/components/web_server/web_server.h
index 2e5d58d375..c54f5558a9 100644
--- a/esphome/components/web_server/web_server.h
+++ b/esphome/components/web_server/web_server.h
@@ -141,7 +141,7 @@ class DeferredUpdateEventSource : public AsyncEventSource {
 
 class DeferredUpdateEventSourceList : public std::list<DeferredUpdateEventSource *> {
  protected:
-  void on_client_connect_(WebServer *ws, DeferredUpdateEventSource *source);
+  void on_client_connect_(DeferredUpdateEventSource *source);
   void on_client_disconnect_(DeferredUpdateEventSource *source);
 
  public:

From 4838eff3829831d2a6b1390de1c848e52be62fca Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:12:56 -0600
Subject: [PATCH 08/13] [web_server] Use zero-copy entity ID comparison in
 request handlers (#11644)

---
 esphome/components/web_server/web_server.cpp | 52 +++++++++++---------
 esphome/components/web_server/web_server.h   | 11 ++++-
 esphome/core/entity_base.h                   |  5 ++
 3 files changed, 42 insertions(+), 26 deletions(-)

diff --git a/esphome/components/web_server/web_server.cpp b/esphome/components/web_server/web_server.cpp
index cc62b019c3..fe0da14435 100644
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -435,9 +435,10 @@ void WebServer::on_sensor_update(sensor::Sensor *obj, float state) {
 }
 void WebServer::handle_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (sensor::Sensor *obj : App.get_sensors()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
-    if (request->method() == HTTP_GET && match.method_empty()) {
+    // Note: request->method() is always HTTP_GET here (canHandle ensures this)
+    if (match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->sensor_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -477,9 +478,10 @@ void WebServer::on_text_sensor_update(text_sensor::TextSensor *obj, const std::s
 }
 void WebServer::handle_text_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (text_sensor::TextSensor *obj : App.get_text_sensors()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
-    if (request->method() == HTTP_GET && match.method_empty()) {
+    // Note: request->method() is always HTTP_GET here (canHandle ensures this)
+    if (match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->text_sensor_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -516,7 +518,7 @@ void WebServer::on_switch_update(switch_::Switch *obj, bool state) {
 }
 void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (switch_::Switch *obj : App.get_switches()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -585,7 +587,7 @@ std::string WebServer::switch_json(switch_::Switch *obj, bool value, JsonDetail
 #ifdef USE_BUTTON
 void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (button::Button *obj : App.get_buttons()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
     if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
@@ -627,9 +629,10 @@ void WebServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj) {
 }
 void WebServer::handle_binary_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (binary_sensor::BinarySensor *obj : App.get_binary_sensors()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
-    if (request->method() == HTTP_GET && match.method_empty()) {
+    // Note: request->method() is always HTTP_GET here (canHandle ensures this)
+    if (match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->binary_sensor_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -665,7 +668,7 @@ void WebServer::on_fan_update(fan::Fan *obj) {
 }
 void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (fan::Fan *obj : App.get_fans()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -739,7 +742,7 @@ void WebServer::on_light_update(light::LightState *obj) {
 }
 void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (light::LightState *obj : App.get_lights()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -812,7 +815,7 @@ void WebServer::on_cover_update(cover::Cover *obj) {
 }
 void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (cover::Cover *obj : App.get_covers()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -897,7 +900,7 @@ void WebServer::on_number_update(number::Number *obj, float state) {
 }
 void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_numbers()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -962,7 +965,7 @@ void WebServer::on_date_update(datetime::DateEntity *obj) {
 }
 void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_dates()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
     if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
@@ -1017,7 +1020,7 @@ void WebServer::on_time_update(datetime::TimeEntity *obj) {
 }
 void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_times()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
     if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
@@ -1071,7 +1074,7 @@ void WebServer::on_datetime_update(datetime::DateTimeEntity *obj) {
 }
 void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_datetimes()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
     if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
@@ -1126,7 +1129,7 @@ void WebServer::on_text_update(text::Text *obj, const std::string &state) {
 }
 void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_texts()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -1180,7 +1183,7 @@ void WebServer::on_select_update(select::Select *obj, const std::string &state,
 }
 void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_selects()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -1236,7 +1239,7 @@ void WebServer::on_climate_update(climate::Climate *obj) {
 }
 void WebServer::handle_climate_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_climates()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -1377,7 +1380,7 @@ void WebServer::on_lock_update(lock::Lock *obj) {
 }
 void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (lock::Lock *obj : App.get_locks()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -1448,7 +1451,7 @@ void WebServer::on_valve_update(valve::Valve *obj) {
 }
 void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (valve::Valve *obj : App.get_valves()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -1529,7 +1532,7 @@ void WebServer::on_alarm_control_panel_update(alarm_control_panel::AlarmControlP
 }
 void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (alarm_control_panel::AlarmControlPanel *obj : App.get_alarm_control_panels()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
@@ -1608,10 +1611,11 @@ void WebServer::on_event(event::Event *obj, const std::string &event_type) {
 
 void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (event::Event *obj : App.get_events()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && match.method_empty()) {
+    // Note: request->method() is always HTTP_GET here (canHandle ensures this)
+    if (match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->event_json(obj, "", detail);
       request->send(200, "application/json", data.c_str());
@@ -1673,7 +1677,7 @@ void WebServer::on_update(update::UpdateEntity *obj) {
 }
 void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (update::UpdateEntity *obj : App.get_updates()) {
-    if (!match.id_equals(obj->get_object_id()))
+    if (!match.id_equals_entity(obj))
       continue;
 
     if (request->method() == HTTP_GET && match.method_empty()) {
diff --git a/esphome/components/web_server/web_server.h b/esphome/components/web_server/web_server.h
index c54f5558a9..fb790483dc 100644
--- a/esphome/components/web_server/web_server.h
+++ b/esphome/components/web_server/web_server.h
@@ -48,8 +48,15 @@ struct UrlMatch {
     return domain && domain_len == strlen(str) && memcmp(domain, str, domain_len) == 0;
   }
 
-  bool id_equals(const std::string &str) const {
-    return id && id_len == str.length() && memcmp(id, str.c_str(), id_len) == 0;
+  bool id_equals_entity(EntityBase *entity) const {
+    // Zero-copy comparison using StringRef
+    StringRef static_ref = entity->get_object_id_ref_for_api_();
+    if (!static_ref.empty()) {
+      return id && id_len == static_ref.size() && memcmp(id, static_ref.c_str(), id_len) == 0;
+    }
+    // Fallback to allocation (rare)
+    const auto &obj_id = entity->get_object_id();
+    return id && id_len == obj_id.length() && memcmp(id, obj_id.c_str(), id_len) == 0;
   }
 
   bool method_equals(const char *str) const {
diff --git a/esphome/core/entity_base.h b/esphome/core/entity_base.h
index 4a6460e708..80cd6b8e77 100644
--- a/esphome/core/entity_base.h
+++ b/esphome/core/entity_base.h
@@ -17,6 +17,10 @@ namespace api {
 class APIConnection;
 }  // namespace api
 
+namespace web_server {
+struct UrlMatch;
+}  // namespace web_server
+
 enum EntityCategory : uint8_t {
   ENTITY_CATEGORY_NONE = 0,
   ENTITY_CATEGORY_CONFIG = 1,
@@ -116,6 +120,7 @@ class EntityBase {
 
  protected:
   friend class api::APIConnection;
+  friend struct web_server::UrlMatch;
 
   // Get object_id as StringRef when it's static (for API usage)
   // Returns empty StringRef if object_id is dynamic (needs allocation)

From 34244afea1117c6042e786f5f99a1f026aa0c39c Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:16:26 -0600
Subject: [PATCH 09/13] =?UTF-8?q?[esp32=5Fble]=20Reduce=20GATT=20event=20l?=
 =?UTF-8?q?atency=20from=208ms=20to=2012=CE=BCs=20with=20notification=20so?=
 =?UTF-8?q?cket=20(#11663)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 esphome/components/esp32_ble/__init__.py |   9 ++
 esphome/components/esp32_ble/ble.cpp     | 112 +++++++++++++++++++++++
 esphome/components/esp32_ble/ble.h       |  41 +++++++++
 3 files changed, 162 insertions(+)

diff --git a/esphome/components/esp32_ble/__init__.py b/esphome/components/esp32_ble/__init__.py
index 411c2add71..1ae8df6f5e 100644
--- a/esphome/components/esp32_ble/__init__.py
+++ b/esphome/components/esp32_ble/__init__.py
@@ -7,6 +7,7 @@ from typing import Any
 
 from esphome import automation
 import esphome.codegen as cg
+from esphome.components import socket
 from esphome.components.esp32 import add_idf_sdkconfig_option, const, get_esp32_variant
 import esphome.config_validation as cv
 from esphome.const import (
@@ -481,6 +482,14 @@ async def to_code(config):
         cg.add(var.set_name(name))
     await cg.register_component(var, config)
 
+    # BLE uses 1 UDP socket for event notification to wake up main loop from select()
+    # This enables low-latency (~12μs) BLE event processing instead of waiting for
+    # select() timeout (0-16ms). The socket is created in ble_setup_() and used to
+    # wake lwip_select() when BLE events arrive from the BLE thread.
+    # Note: Called during config generation, socket is created at runtime. In practice,
+    # always used since esp32_ble only runs on ESP32 which always has USE_SOCKET_SELECT_SUPPORT.
+    socket.consume_sockets(1, "esp32_ble")(config)
+
     # Define max connections for use in C++ code (e.g., ble_server.h)
     max_connections = config.get(CONF_MAX_CONNECTIONS, DEFAULT_MAX_CONNECTIONS)
     cg.add_define("USE_ESP32_BLE_MAX_CONNECTIONS", max_connections)
diff --git a/esphome/components/esp32_ble/ble.cpp b/esphome/components/esp32_ble/ble.cpp
index 69e317ff6d..eef0db5347 100644
--- a/esphome/components/esp32_ble/ble.cpp
+++ b/esphome/components/esp32_ble/ble.cpp
@@ -27,6 +27,10 @@ extern "C" {
 #include <esp32-hal-bt.h>
 #endif
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+#include <lwip/sockets.h>
+#endif
+
 namespace esphome::esp32_ble {
 
 static const char *const TAG = "esp32_ble";
@@ -293,10 +297,21 @@ bool ESP32BLE::ble_setup_() {
   // BLE takes some time to be fully set up, 200ms should be more than enough
   delay(200);  // NOLINT
 
+  // Set up notification socket to wake main loop for BLE events
+  // This enables low-latency (~12μs) event processing instead of waiting for select() timeout
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  this->setup_event_notification_();
+#endif
+
   return true;
 }
 
 bool ESP32BLE::ble_dismantle_() {
+  // Clean up notification socket first before dismantling BLE stack
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  this->cleanup_event_notification_();
+#endif
+
   esp_err_t err = esp_bluedroid_disable();
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "esp_bluedroid_disable failed: %d", err);
@@ -394,6 +409,12 @@ void ESP32BLE::loop() {
       break;
   }
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  // Drain any notification socket events first
+  // This clears the socket so it doesn't stay "ready" in subsequent select() calls
+  this->drain_event_notifications_();
+#endif
+
   BLEEvent *ble_event = this->ble_events_.pop();
   while (ble_event != nullptr) {
     switch (ble_event->type_) {
@@ -582,6 +603,10 @@ void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_pa
 void ESP32BLE::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
                                    esp_ble_gatts_cb_param_t *param) {
   enqueue_ble_event(event, gatts_if, param);
+  // Wake up main loop to process GATT event immediately
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  global_ble->notify_main_loop_();
+#endif
 }
 #endif
 
@@ -589,6 +614,10 @@ void ESP32BLE::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gat
 void ESP32BLE::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                    esp_ble_gattc_cb_param_t *param) {
   enqueue_ble_event(event, gattc_if, param);
+  // Wake up main loop to process GATT event immediately
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  global_ble->notify_main_loop_();
+#endif
 }
 #endif
 
@@ -628,6 +657,89 @@ void ESP32BLE::dump_config() {
   }
 }
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+void ESP32BLE::setup_event_notification_() {
+  // Create UDP socket for event notifications
+  this->notify_fd_ = lwip_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+  if (this->notify_fd_ < 0) {
+    ESP_LOGW(TAG, "Event socket create failed: %d", errno);
+    return;
+  }
+
+  // Bind to loopback with auto-assigned port
+  struct sockaddr_in addr = {};
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = lwip_htonl(INADDR_LOOPBACK);
+  addr.sin_port = 0;  // Auto-assign port
+
+  if (lwip_bind(this->notify_fd_, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+    ESP_LOGW(TAG, "Event socket bind failed: %d", errno);
+    lwip_close(this->notify_fd_);
+    this->notify_fd_ = -1;
+    return;
+  }
+
+  // Get the assigned address and connect to it
+  // Connecting a UDP socket allows using send() instead of sendto() for better performance
+  struct sockaddr_in notify_addr;
+  socklen_t len = sizeof(notify_addr);
+  if (lwip_getsockname(this->notify_fd_, (struct sockaddr *) &notify_addr, &len) < 0) {
+    ESP_LOGW(TAG, "Event socket address failed: %d", errno);
+    lwip_close(this->notify_fd_);
+    this->notify_fd_ = -1;
+    return;
+  }
+
+  // Connect to self (loopback) - allows using send() instead of sendto()
+  // After connect(), no need to store notify_addr - the socket remembers it
+  if (lwip_connect(this->notify_fd_, (struct sockaddr *) &notify_addr, sizeof(notify_addr)) < 0) {
+    ESP_LOGW(TAG, "Event socket connect failed: %d", errno);
+    lwip_close(this->notify_fd_);
+    this->notify_fd_ = -1;
+    return;
+  }
+
+  // Set non-blocking mode
+  int flags = lwip_fcntl(this->notify_fd_, F_GETFL, 0);
+  lwip_fcntl(this->notify_fd_, F_SETFL, flags | O_NONBLOCK);
+
+  // Register with application's select() loop
+  if (!App.register_socket_fd(this->notify_fd_)) {
+    ESP_LOGW(TAG, "Event socket register failed");
+    lwip_close(this->notify_fd_);
+    this->notify_fd_ = -1;
+    return;
+  }
+
+  ESP_LOGD(TAG, "Event socket ready");
+}
+
+void ESP32BLE::cleanup_event_notification_() {
+  if (this->notify_fd_ >= 0) {
+    App.unregister_socket_fd(this->notify_fd_);
+    lwip_close(this->notify_fd_);
+    this->notify_fd_ = -1;
+    ESP_LOGD(TAG, "Event socket closed");
+  }
+}
+
+void ESP32BLE::drain_event_notifications_() {
+  // Called from main loop to drain any pending notifications
+  // Must check is_socket_ready() to avoid blocking on empty socket
+  if (this->notify_fd_ >= 0 && App.is_socket_ready(this->notify_fd_)) {
+    char buffer[BLE_EVENT_NOTIFY_DRAIN_BUFFER_SIZE];
+    // Drain all pending notifications with non-blocking reads
+    // Multiple BLE events may have triggered multiple writes, so drain until EWOULDBLOCK
+    // We control both ends of this loopback socket (always write 1 byte per event),
+    // so no error checking needed - any errors indicate catastrophic system failure
+    while (lwip_recvfrom(this->notify_fd_, buffer, sizeof(buffer), 0, nullptr, nullptr) > 0) {
+      // Just draining, no action needed - actual BLE events are already queued
+    }
+  }
+}
+
+#endif  // USE_SOCKET_SELECT_SUPPORT
+
 uint64_t ble_addr_to_uint64(const esp_bd_addr_t address) {
   uint64_t u = 0;
   u |= uint64_t(address[0] & 0xFF) << 40;
diff --git a/esphome/components/esp32_ble/ble.h b/esphome/components/esp32_ble/ble.h
index dc973f0e82..7c3195db6d 100644
--- a/esphome/components/esp32_ble/ble.h
+++ b/esphome/components/esp32_ble/ble.h
@@ -25,6 +25,10 @@
 #include <esp_gattc_api.h>
 #include <esp_gatts_api.h>
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+#include <lwip/sockets.h>
+#endif
+
 namespace esphome::esp32_ble {
 
 // Maximum size of the BLE event queue
@@ -162,6 +166,13 @@ class ESP32BLE : public Component {
   void advertising_init_();
 #endif
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  void setup_event_notification_();    // Create notification socket
+  void cleanup_event_notification_();  // Close and unregister socket
+  inline void notify_main_loop_();     // Wake up select() from BLE thread (hot path - inlined)
+  void drain_event_notifications_();   // Read pending notifications in main loop
+#endif
+
  private:
   template<typename... Args> friend void enqueue_ble_event(Args... args);
 
@@ -196,6 +207,13 @@ class ESP32BLE : public Component {
   esp_ble_io_cap_t io_cap_{ESP_IO_CAP_NONE};  // 4 bytes (enum)
   uint32_t advertising_cycle_time_{};         // 4 bytes
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  // Event notification socket for waking up main loop from BLE thread
+  // Uses connected UDP loopback socket to wake lwip_select() with ~12μs latency vs 0-16ms timeout
+  // Socket is connected during setup, allowing use of send() instead of sendto() for efficiency
+  int notify_fd_{-1};  // 4 bytes (file descriptor)
+#endif
+
   // 2-byte aligned members
   uint16_t appearance_{0};  // 2 bytes
 
@@ -207,6 +225,29 @@ class ESP32BLE : public Component {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 extern ESP32BLE *global_ble;
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+// Inline implementations for hot-path functions
+// These are called from BLE thread (notify) and main loop (drain) on every event
+
+// Small buffer for draining notification bytes (1 byte sent per BLE event)
+// Size allows draining multiple notifications per recvfrom() without wasting stack
+static constexpr size_t BLE_EVENT_NOTIFY_DRAIN_BUFFER_SIZE = 16;
+
+inline void ESP32BLE::notify_main_loop_() {
+  // Called from BLE thread context when events are queued
+  // Wakes up lwip_select() in main loop by writing to connected loopback socket
+  if (this->notify_fd_ >= 0) {
+    const char dummy = 1;
+    // Non-blocking send - if it fails (unlikely), select() will wake on timeout anyway
+    // No error checking needed: we control both ends of this loopback socket, and the
+    // BLE event is already queued. Notification is best-effort to reduce latency.
+    // This is safe to call from BLE thread - send() is thread-safe in lwip
+    // Socket is already connected to loopback address, so send() is faster than sendto()
+    lwip_send(this->notify_fd_, &dummy, 1, 0);
+  }
+}
+#endif  // USE_SOCKET_SELECT_SUPPORT
+
 template<typename... Ts> class BLEEnabledCondition : public Condition<Ts...> {
  public:
   bool check(Ts... x) override { return global_ble->is_active(); }

From 3f05fd82e50d43ec878939049a7ef10119571ad2 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:18:59 -0600
Subject: [PATCH 10/13] [fan] Use std::vector for preset modes, preserve config
 order (#11483)

---
 esphome/components/api/api.proto              |  2 +-
 esphome/components/api/api_connection.cpp     |  2 +-
 esphome/components/api/api_pb2.cpp            |  8 ++--
 esphome/components/api/api_pb2.h              |  2 +-
 esphome/components/fan/fan.cpp                | 44 +++++++++++++------
 esphome/components/fan/fan_traits.h           | 38 +++++++---------
 esphome/components/hbridge/fan/hbridge_fan.h  |  6 +--
 esphome/components/speed/fan/speed_fan.h      |  6 +--
 .../components/template/fan/template_fan.h    |  6 +--
 9 files changed, 59 insertions(+), 55 deletions(-)

diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto
index f50944ffa4..20645fc47b 100644
--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@@ -425,7 +425,7 @@ message ListEntitiesFanResponse {
   bool disabled_by_default = 9;
   string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 11;
-  repeated string supported_preset_modes = 12 [(container_pointer) = "std::set"];
+  repeated string supported_preset_modes = 12 [(container_pointer_no_template) = "std::vector<const char *>"];
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
 }
 // Deprecated in API version 1.6 - only used in deprecated fields
diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 382c4acc16..33d5072d9c 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -423,7 +423,7 @@ uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *con
   msg.supports_speed = traits.supports_speed();
   msg.supports_direction = traits.supports_direction();
   msg.supported_speed_count = traits.supported_speed_count();
-  msg.supported_preset_modes = &traits.supported_preset_modes_for_api_();
+  msg.supported_preset_modes = &traits.supported_preset_modes();
   return fill_and_encode_entity_info(fan, msg, ListEntitiesFanResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::fan_command(const FanCommandRequest &msg) {
diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index 3472707d3c..0673d35518 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -355,8 +355,8 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(10, this->icon_ref_);
 #endif
   buffer.encode_uint32(11, static_cast<uint32_t>(this->entity_category));
-  for (const auto &it : *this->supported_preset_modes) {
-    buffer.encode_string(12, it, true);
+  for (const char *it : *this->supported_preset_modes) {
+    buffer.encode_string(12, it, strlen(it), true);
   }
 #ifdef USE_DEVICES
   buffer.encode_uint32(13, this->device_id);
@@ -376,8 +376,8 @@ void ListEntitiesFanResponse::calculate_size(ProtoSize &size) const {
 #endif
   size.add_uint32(1, static_cast<uint32_t>(this->entity_category));
   if (!this->supported_preset_modes->empty()) {
-    for (const auto &it : *this->supported_preset_modes) {
-      size.add_length_force(1, it.size());
+    for (const char *it : *this->supported_preset_modes) {
+      size.add_length_force(1, strlen(it));
     }
   }
 #ifdef USE_DEVICES
diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index aa5c031ac7..89f16044d7 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -725,7 +725,7 @@ class ListEntitiesFanResponse final : public InfoResponseProtoMessage {
   bool supports_speed{false};
   bool supports_direction{false};
   int32_t supported_speed_count{0};
-  const std::set<std::string> *supported_preset_modes{};
+  const std::vector<const char *> *supported_preset_modes{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
diff --git a/esphome/components/fan/fan.cpp b/esphome/components/fan/fan.cpp
index 26065ed644..5b4f437f99 100644
--- a/esphome/components/fan/fan.cpp
+++ b/esphome/components/fan/fan.cpp
@@ -51,7 +51,14 @@ void FanCall::validate_() {
 
   if (!this->preset_mode_.empty()) {
     const auto &preset_modes = traits.supported_preset_modes();
-    if (preset_modes.find(this->preset_mode_) == preset_modes.end()) {
+    bool found = false;
+    for (const auto &mode : preset_modes) {
+      if (strcmp(mode, this->preset_mode_.c_str()) == 0) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
       ESP_LOGW(TAG, "%s: Preset mode '%s' not supported", this->parent_.get_name().c_str(), this->preset_mode_.c_str());
       this->preset_mode_.clear();
     }
@@ -92,11 +99,12 @@ FanCall FanRestoreState::to_call(Fan &fan) {
   call.set_speed(this->speed);
   call.set_direction(this->direction);
 
-  if (fan.get_traits().supports_preset_modes()) {
+  auto traits = fan.get_traits();
+  if (traits.supports_preset_modes()) {
     // Use stored preset index to get preset name
-    const auto &preset_modes = fan.get_traits().supported_preset_modes();
+    const auto &preset_modes = traits.supported_preset_modes();
     if (this->preset_mode < preset_modes.size()) {
-      call.set_preset_mode(*std::next(preset_modes.begin(), this->preset_mode));
+      call.set_preset_mode(preset_modes[this->preset_mode]);
     }
   }
   return call;
@@ -107,11 +115,12 @@ void FanRestoreState::apply(Fan &fan) {
   fan.speed = this->speed;
   fan.direction = this->direction;
 
-  if (fan.get_traits().supports_preset_modes()) {
+  auto traits = fan.get_traits();
+  if (traits.supports_preset_modes()) {
     // Use stored preset index to get preset name
-    const auto &preset_modes = fan.get_traits().supported_preset_modes();
+    const auto &preset_modes = traits.supported_preset_modes();
     if (this->preset_mode < preset_modes.size()) {
-      fan.preset_mode = *std::next(preset_modes.begin(), this->preset_mode);
+      fan.preset_mode = preset_modes[this->preset_mode];
     }
   }
   fan.publish_state();
@@ -182,18 +191,25 @@ void Fan::save_state_() {
     return;
   }
 
+  auto traits = this->get_traits();
+
   FanRestoreState state{};
   state.state = this->state;
   state.oscillating = this->oscillating;
   state.speed = this->speed;
   state.direction = this->direction;
 
-  if (this->get_traits().supports_preset_modes() && !this->preset_mode.empty()) {
-    const auto &preset_modes = this->get_traits().supported_preset_modes();
+  if (traits.supports_preset_modes() && !this->preset_mode.empty()) {
+    const auto &preset_modes = traits.supported_preset_modes();
     // Store index of current preset mode
-    auto preset_iterator = preset_modes.find(this->preset_mode);
-    if (preset_iterator != preset_modes.end())
-      state.preset_mode = std::distance(preset_modes.begin(), preset_iterator);
+    size_t i = 0;
+    for (const auto &mode : preset_modes) {
+      if (strcmp(mode, this->preset_mode.c_str()) == 0) {
+        state.preset_mode = i;
+        break;
+      }
+      i++;
+    }
   }
 
   this->rtc_.save(&state);
@@ -216,8 +232,8 @@ void Fan::dump_traits_(const char *tag, const char *prefix) {
   }
   if (traits.supports_preset_modes()) {
     ESP_LOGCONFIG(tag, "%s  Supported presets:", prefix);
-    for (const std::string &s : traits.supported_preset_modes())
-      ESP_LOGCONFIG(tag, "%s    - %s", prefix, s.c_str());
+    for (const char *s : traits.supported_preset_modes())
+      ESP_LOGCONFIG(tag, "%s    - %s", prefix, s);
   }
 }
 
diff --git a/esphome/components/fan/fan_traits.h b/esphome/components/fan/fan_traits.h
index 48509e5705..df345f9b04 100644
--- a/esphome/components/fan/fan_traits.h
+++ b/esphome/components/fan/fan_traits.h
@@ -1,15 +1,9 @@
-#include <set>
-#include <utility>
-
 #pragma once
 
-namespace esphome {
+#include <vector>
+#include <initializer_list>
 
-#ifdef USE_API
-namespace api {
-class APIConnection;
-}  // namespace api
-#endif
+namespace esphome {
 
 namespace fan {
 
@@ -36,27 +30,27 @@ class FanTraits {
   /// Set whether this fan supports changing direction
   void set_direction(bool direction) { this->direction_ = direction; }
   /// Return the preset modes supported by the fan.
-  std::set<std::string> supported_preset_modes() const { return this->preset_modes_; }
-  /// Set the preset modes supported by the fan.
-  void set_supported_preset_modes(const std::set<std::string> &preset_modes) { this->preset_modes_ = preset_modes; }
+  const std::vector<const char *> &supported_preset_modes() const { return this->preset_modes_; }
+  /// Set the preset modes supported by the fan (from initializer list).
+  void set_supported_preset_modes(std::initializer_list<const char *> preset_modes) {
+    this->preset_modes_ = preset_modes;
+  }
+  /// Set the preset modes supported by the fan (from vector).
+  void set_supported_preset_modes(const std::vector<const char *> &preset_modes) { this->preset_modes_ = preset_modes; }
+
+  // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
+  void set_supported_preset_modes(const std::vector<std::string> &preset_modes) = delete;
+  void set_supported_preset_modes(std::initializer_list<std::string> preset_modes) = delete;
+
   /// Return if preset modes are supported
   bool supports_preset_modes() const { return !this->preset_modes_.empty(); }
 
  protected:
-#ifdef USE_API
-  // The API connection is a friend class to access internal methods
-  friend class api::APIConnection;
-  // This method returns a reference to the internal preset modes set.
-  // It is used by the API to avoid copying data when encoding messages.
-  // Warning: Do not use this method outside of the API connection code.
-  // It returns a reference to internal data that can be invalidated.
-  const std::set<std::string> &supported_preset_modes_for_api_() const { return this->preset_modes_; }
-#endif
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
   int speed_count_{};
-  std::set<std::string> preset_modes_{};
+  std::vector<const char *> preset_modes_{};
 };
 
 }  // namespace fan
diff --git a/esphome/components/hbridge/fan/hbridge_fan.h b/esphome/components/hbridge/fan/hbridge_fan.h
index 4234fccae3..143c7c1853 100644
--- a/esphome/components/hbridge/fan/hbridge_fan.h
+++ b/esphome/components/hbridge/fan/hbridge_fan.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <set>
-
 #include "esphome/core/automation.h"
 #include "esphome/components/output/binary_output.h"
 #include "esphome/components/output/float_output.h"
@@ -22,7 +20,7 @@ class HBridgeFan : public Component, public fan::Fan {
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
   void set_enable_pin(output::FloatOutput *enable) { enable_ = enable; }
-  void set_preset_modes(const std::set<std::string> &presets) { preset_modes_ = presets; }
+  void set_preset_modes(std::initializer_list<const char *> presets) { preset_modes_ = presets; }
 
   void setup() override;
   void dump_config() override;
@@ -38,7 +36,7 @@ class HBridgeFan : public Component, public fan::Fan {
   int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
-  std::set<std::string> preset_modes_{};
+  std::vector<const char *> preset_modes_{};
 
   void control(const fan::FanCall &call) override;
   void write_state_();
diff --git a/esphome/components/speed/fan/speed_fan.h b/esphome/components/speed/fan/speed_fan.h
index 6537bce3f6..e9a389e0f3 100644
--- a/esphome/components/speed/fan/speed_fan.h
+++ b/esphome/components/speed/fan/speed_fan.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <set>
-
 #include "esphome/core/component.h"
 #include "esphome/components/output/binary_output.h"
 #include "esphome/components/output/float_output.h"
@@ -18,7 +16,7 @@ class SpeedFan : public Component, public fan::Fan {
   void set_output(output::FloatOutput *output) { this->output_ = output; }
   void set_oscillating(output::BinaryOutput *oscillating) { this->oscillating_ = oscillating; }
   void set_direction(output::BinaryOutput *direction) { this->direction_ = direction; }
-  void set_preset_modes(const std::set<std::string> &presets) { this->preset_modes_ = presets; }
+  void set_preset_modes(std::initializer_list<const char *> presets) { this->preset_modes_ = presets; }
   fan::FanTraits get_traits() override { return this->traits_; }
 
  protected:
@@ -30,7 +28,7 @@ class SpeedFan : public Component, public fan::Fan {
   output::BinaryOutput *direction_{nullptr};
   int speed_count_{};
   fan::FanTraits traits_;
-  std::set<std::string> preset_modes_{};
+  std::vector<const char *> preset_modes_{};
 };
 
 }  // namespace speed
diff --git a/esphome/components/template/fan/template_fan.h b/esphome/components/template/fan/template_fan.h
index 7f5305ca48..b09352f4d4 100644
--- a/esphome/components/template/fan/template_fan.h
+++ b/esphome/components/template/fan/template_fan.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <set>
-
 #include "esphome/core/component.h"
 #include "esphome/components/fan/fan.h"
 
@@ -16,7 +14,7 @@ class TemplateFan : public Component, public fan::Fan {
   void set_has_direction(bool has_direction) { this->has_direction_ = has_direction; }
   void set_has_oscillating(bool has_oscillating) { this->has_oscillating_ = has_oscillating; }
   void set_speed_count(int count) { this->speed_count_ = count; }
-  void set_preset_modes(const std::set<std::string> &presets) { this->preset_modes_ = presets; }
+  void set_preset_modes(std::initializer_list<const char *> presets) { this->preset_modes_ = presets; }
   fan::FanTraits get_traits() override { return this->traits_; }
 
  protected:
@@ -26,7 +24,7 @@ class TemplateFan : public Component, public fan::Fan {
   bool has_direction_{false};
   int speed_count_{0};
   fan::FanTraits traits_;
-  std::set<std::string> preset_modes_{};
+  std::vector<const char *> preset_modes_{};
 };
 
 }  // namespace template_

From cf76c3a74769f18254e24c9e6173974581966802 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:23:03 -0600
Subject: [PATCH 11/13] [web_server_idf] Reduce flash by eliminating temporary
 string allocations in event formatting (#11658)

Co-authored-by: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
---
 .../web_server_idf/web_server_idf.cpp         | 31 +++++++++++++------
 1 file changed, 21 insertions(+), 10 deletions(-)

diff --git a/esphome/components/web_server_idf/web_server_idf.cpp b/esphome/components/web_server_idf/web_server_idf.cpp
index ac0b5bad83..0dab5e7e8c 100644
--- a/esphome/components/web_server_idf/web_server_idf.cpp
+++ b/esphome/components/web_server_idf/web_server_idf.cpp
@@ -4,6 +4,7 @@
 #include <memory>
 #include <cstring>
 #include <cctype>
+#include <cinttypes>
 
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -245,8 +246,8 @@ void AsyncWebServerRequest::redirect(const std::string &url) {
 }
 
 void AsyncWebServerRequest::init_response_(AsyncWebServerResponse *rsp, int code, const char *content_type) {
-  // Set status code - use constants for common codes to avoid string allocation
-  const char *status = nullptr;
+  // Set status code - use constants for common codes, default to 500 for unknown codes
+  const char *status;
   switch (code) {
     case 200:
       status = HTTPD_200;
@@ -258,9 +259,10 @@ void AsyncWebServerRequest::init_response_(AsyncWebServerResponse *rsp, int code
       status = HTTPD_409;
       break;
     default:
+      status = HTTPD_500;
       break;
   }
-  httpd_resp_set_status(*this, status == nullptr ? to_string(code).c_str() : status);
+  httpd_resp_set_status(*this, status);
 
   if (content_type && *content_type) {
     httpd_resp_set_type(*this, content_type);
@@ -348,7 +350,13 @@ void AsyncWebServerResponse::addHeader(const char *name, const char *value) {
   httpd_resp_set_hdr(*this->req_, name, value);
 }
 
-void AsyncResponseStream::print(float value) { this->print(to_string(value)); }
+void AsyncResponseStream::print(float value) {
+  // Use stack buffer to avoid temporary string allocation
+  // Size: sign (1) + digits (10) + decimal (1) + precision (6) + exponent (5) + null (1) = 24, use 32 for safety
+  char buf[32];
+  int len = snprintf(buf, sizeof(buf), "%f", value);
+  this->content_.append(buf, len);
+}
 
 void AsyncResponseStream::printf(const char *fmt, ...) {
   va_list args;
@@ -593,16 +601,19 @@ bool AsyncEventSourceResponse::try_send_nodefer(const char *message, const char
 
   event_buffer_.append(chunk_len_header);
 
+  // Use stack buffer for formatting numeric fields to avoid temporary string allocations
+  // Size: "retry: " (7) + max uint32 (10 digits) + CRLF (2) + null (1) = 20 bytes, use 32 for safety
+  constexpr size_t num_buf_size = 32;
+  char num_buf[num_buf_size];
+
   if (reconnect) {
-    event_buffer_.append("retry: ", sizeof("retry: ") - 1);
-    event_buffer_.append(to_string(reconnect));
-    event_buffer_.append(CRLF_STR, CRLF_LEN);
+    int len = snprintf(num_buf, num_buf_size, "retry: %" PRIu32 CRLF_STR, reconnect);
+    event_buffer_.append(num_buf, len);
   }
 
   if (id) {
-    event_buffer_.append("id: ", sizeof("id: ") - 1);
-    event_buffer_.append(to_string(id));
-    event_buffer_.append(CRLF_STR, CRLF_LEN);
+    int len = snprintf(num_buf, num_buf_size, "id: %" PRIu32 CRLF_STR, id);
+    event_buffer_.append(num_buf, len);
   }
 
   if (event && *event) {

From 4a5e6576c8eac98dc9120e250325af2394e8ea8b Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:29:29 -0600
Subject: [PATCH 12/13] [scheduler] Refactor call() for improved code
 organization (#11643)

---
 esphome/core/scheduler.cpp | 105 +++++++++++--------------------------
 esphome/core/scheduler.h   |  58 ++++++++++++++++++++
 2 files changed, 88 insertions(+), 75 deletions(-)

diff --git a/esphome/core/scheduler.cpp b/esphome/core/scheduler.cpp
index 0d4715f621..11d59c2499 100644
--- a/esphome/core/scheduler.cpp
+++ b/esphome/core/scheduler.cpp
@@ -316,59 +316,37 @@ optional<uint32_t> HOT Scheduler::next_schedule_in(uint32_t now) {
     return 0;
   return next_exec - now_64;
 }
+
+void Scheduler::full_cleanup_removed_items_() {
+  // We hold the lock for the entire cleanup operation because:
+  // 1. We're rebuilding the entire items_ list, so we need exclusive access throughout
+  // 2. Other threads must see either the old state or the new state, not intermediate states
+  // 3. The operation is already expensive (O(n)), so lock overhead is negligible
+  // 4. No operations inside can block or take other locks, so no deadlock risk
+  LockGuard guard{this->lock_};
+
+  std::vector<std::unique_ptr<SchedulerItem>> valid_items;
+
+  // Move all non-removed items to valid_items, recycle removed ones
+  for (auto &item : this->items_) {
+    if (!is_item_removed_(item.get())) {
+      valid_items.push_back(std::move(item));
+    } else {
+      // Recycle removed items
+      this->recycle_item_(std::move(item));
+    }
+  }
+
+  // Replace items_ with the filtered list
+  this->items_ = std::move(valid_items);
+  // Rebuild the heap structure since items are no longer in heap order
+  std::make_heap(this->items_.begin(), this->items_.end(), SchedulerItem::cmp);
+  this->to_remove_ = 0;
+}
+
 void HOT Scheduler::call(uint32_t now) {
 #ifndef ESPHOME_THREAD_SINGLE
-  // Process defer queue first to guarantee FIFO execution order for deferred items.
-  // Previously, defer() used the heap which gave undefined order for equal timestamps,
-  // causing race conditions on multi-core systems (ESP32, BK7200).
-  // With the defer queue:
-  // - Deferred items (delay=0) go directly to defer_queue_ in set_timer_common_
-  // - Items execute in exact order they were deferred (FIFO guarantee)
-  // - No deferred items exist in to_add_, so processing order doesn't affect correctness
-  // Single-core platforms don't use this queue and fall back to the heap-based approach.
-  //
-  // Note: Items cancelled via cancel_item_locked_() are marked with remove=true but still
-  // processed here. They are skipped during execution by should_skip_item_().
-  // This is intentional - no memory leak occurs.
-  //
-  // We use an index (defer_queue_front_) to track the read position instead of calling
-  // erase() on every pop, which would be O(n). The queue is processed once per loop -
-  // any items added during processing are left for the next loop iteration.
-
-  // Snapshot the queue end point - only process items that existed at loop start
-  // Items added during processing (by callbacks or other threads) run next loop
-  // No lock needed: single consumer (main loop), stale read just means we process less this iteration
-  size_t defer_queue_end = this->defer_queue_.size();
-
-  while (this->defer_queue_front_ < defer_queue_end) {
-    std::unique_ptr<SchedulerItem> item;
-    {
-      LockGuard lock(this->lock_);
-      // SAFETY: Moving out the unique_ptr leaves a nullptr in the vector at defer_queue_front_.
-      // This is intentional and safe because:
-      // 1. The vector is only cleaned up by cleanup_defer_queue_locked_() at the end of this function
-      // 2. Any code iterating defer_queue_ MUST check for nullptr items (see mark_matching_items_removed_
-      //    and has_cancelled_timeout_in_container_ in scheduler.h)
-      // 3. The lock protects concurrent access, but the nullptr remains until cleanup
-      item = std::move(this->defer_queue_[this->defer_queue_front_]);
-      this->defer_queue_front_++;
-    }
-
-    // Execute callback without holding lock to prevent deadlocks
-    // if the callback tries to call defer() again
-    if (!this->should_skip_item_(item.get())) {
-      now = this->execute_item_(item.get(), now);
-    }
-    // Recycle the defer item after execution
-    this->recycle_item_(std::move(item));
-  }
-
-  // If we've consumed all items up to the snapshot point, clean up the dead space
-  // Single consumer (main loop), so no lock needed for this check
-  if (this->defer_queue_front_ >= defer_queue_end) {
-    LockGuard lock(this->lock_);
-    this->cleanup_defer_queue_locked_();
-  }
+  this->process_defer_queue_(now);
 #endif /* not ESPHOME_THREAD_SINGLE */
 
   // Convert the fresh timestamp from main loop to 64-bit for scheduler operations
@@ -429,30 +407,7 @@ void HOT Scheduler::call(uint32_t now) {
   // If we still have too many cancelled items, do a full cleanup
   // This only happens if cancelled items are stuck in the middle/bottom of the heap
   if (this->to_remove_ >= MAX_LOGICALLY_DELETED_ITEMS) {
-    // We hold the lock for the entire cleanup operation because:
-    // 1. We're rebuilding the entire items_ list, so we need exclusive access throughout
-    // 2. Other threads must see either the old state or the new state, not intermediate states
-    // 3. The operation is already expensive (O(n)), so lock overhead is negligible
-    // 4. No operations inside can block or take other locks, so no deadlock risk
-    LockGuard guard{this->lock_};
-
-    std::vector<std::unique_ptr<SchedulerItem>> valid_items;
-
-    // Move all non-removed items to valid_items, recycle removed ones
-    for (auto &item : this->items_) {
-      if (!is_item_removed_(item.get())) {
-        valid_items.push_back(std::move(item));
-      } else {
-        // Recycle removed items
-        this->recycle_item_(std::move(item));
-      }
-    }
-
-    // Replace items_ with the filtered list
-    this->items_ = std::move(valid_items);
-    // Rebuild the heap structure since items are no longer in heap order
-    std::make_heap(this->items_.begin(), this->items_.end(), SchedulerItem::cmp);
-    this->to_remove_ = 0;
+    this->full_cleanup_removed_items_();
   }
   while (!this->items_.empty()) {
     // Don't copy-by value yet
diff --git a/esphome/core/scheduler.h b/esphome/core/scheduler.h
index df0be0e4ce..f6ec07294d 100644
--- a/esphome/core/scheduler.h
+++ b/esphome/core/scheduler.h
@@ -263,7 +263,65 @@ class Scheduler {
   // Helper to recycle a SchedulerItem
   void recycle_item_(std::unique_ptr<SchedulerItem> item);
 
+  // Helper to perform full cleanup when too many items are cancelled
+  void full_cleanup_removed_items_();
+
 #ifndef ESPHOME_THREAD_SINGLE
+  // Helper to process defer queue - inline for performance in hot path
+  inline void process_defer_queue_(uint32_t &now) {
+    // Process defer queue first to guarantee FIFO execution order for deferred items.
+    // Previously, defer() used the heap which gave undefined order for equal timestamps,
+    // causing race conditions on multi-core systems (ESP32, BK7200).
+    // With the defer queue:
+    // - Deferred items (delay=0) go directly to defer_queue_ in set_timer_common_
+    // - Items execute in exact order they were deferred (FIFO guarantee)
+    // - No deferred items exist in to_add_, so processing order doesn't affect correctness
+    // Single-core platforms don't use this queue and fall back to the heap-based approach.
+    //
+    // Note: Items cancelled via cancel_item_locked_() are marked with remove=true but still
+    // processed here. They are skipped during execution by should_skip_item_().
+    // This is intentional - no memory leak occurs.
+    //
+    // We use an index (defer_queue_front_) to track the read position instead of calling
+    // erase() on every pop, which would be O(n). The queue is processed once per loop -
+    // any items added during processing are left for the next loop iteration.
+
+    // Snapshot the queue end point - only process items that existed at loop start
+    // Items added during processing (by callbacks or other threads) run next loop
+    // No lock needed: single consumer (main loop), stale read just means we process less this iteration
+    size_t defer_queue_end = this->defer_queue_.size();
+
+    while (this->defer_queue_front_ < defer_queue_end) {
+      std::unique_ptr<SchedulerItem> item;
+      {
+        LockGuard lock(this->lock_);
+        // SAFETY: Moving out the unique_ptr leaves a nullptr in the vector at defer_queue_front_.
+        // This is intentional and safe because:
+        // 1. The vector is only cleaned up by cleanup_defer_queue_locked_() at the end of this function
+        // 2. Any code iterating defer_queue_ MUST check for nullptr items (see mark_matching_items_removed_
+        //    and has_cancelled_timeout_in_container_ in scheduler.h)
+        // 3. The lock protects concurrent access, but the nullptr remains until cleanup
+        item = std::move(this->defer_queue_[this->defer_queue_front_]);
+        this->defer_queue_front_++;
+      }
+
+      // Execute callback without holding lock to prevent deadlocks
+      // if the callback tries to call defer() again
+      if (!this->should_skip_item_(item.get())) {
+        now = this->execute_item_(item.get(), now);
+      }
+      // Recycle the defer item after execution
+      this->recycle_item_(std::move(item));
+    }
+
+    // If we've consumed all items up to the snapshot point, clean up the dead space
+    // Single consumer (main loop), so no lock needed for this check
+    if (this->defer_queue_front_ >= defer_queue_end) {
+      LockGuard lock(this->lock_);
+      this->cleanup_defer_queue_locked_();
+    }
+  }
+
   // Helper to cleanup defer_queue_ after processing
   // IMPORTANT: Caller must hold the scheduler lock before calling this function.
   inline void cleanup_defer_queue_locked_() {

From 0f0cd1f706e31c35961578647f4d63c8e04dc768 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 2 Nov 2025 19:40:13 -0600
Subject: [PATCH 13/13] [core] Avoid redundant millis() calls in
 base_automation loop methods (#11676)

---
 esphome/core/base_automation.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/esphome/core/base_automation.h b/esphome/core/base_automation.h
index e668a1782a..28af02a846 100644
--- a/esphome/core/base_automation.h
+++ b/esphome/core/base_automation.h
@@ -103,7 +103,7 @@ template<typename... Ts> class ForCondition : public Condition<Ts...>, public Co
   bool check_internal() {
     bool cond = this->condition_->check();
     if (!cond)
-      this->last_inactive_ = millis();
+      this->last_inactive_ = App.get_loop_component_start_time();
     return cond;
   }
 
@@ -380,7 +380,7 @@ template<typename... Ts> class WaitUntilAction : public Action<Ts...>, public Co
     if (this->num_running_ == 0)
       return;
 
-    auto now = millis();
+    auto now = App.get_loop_component_start_time();
 
     this->var_queue_.remove_if([&](auto &queued) {
       auto start = std::get<uint32_t>(queued);