Merge pull request #12149 from esphome/bump-2025.11.2

2025.11.2

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2025.11.0
+PROJECT_NUMBER         = 2025.11.2
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/__main__.py

@@ -1319,7 +1319,7 @@ def parse_args(argv):
         "clean-all", help="Clean all build and platform files."
     )
     parser_clean_all.add_argument(
-        "configuration", help="Your YAML configuration directory.", nargs="*"
+        "configuration", help="Your YAML file or configuration directory.", nargs="*"
     )
 
     parser_dashboard = subparsers.add_parser(

esphome/components/cst816/touchscreen/cst816_touchscreen.cpp

@@ -19,8 +19,9 @@ void CST816Touchscreen::continue_setup_() {
       case CST816T_CHIP_ID:
         break;
       default:
+        ESP_LOGE(TAG, "Unknown chip ID: 0x%02X", this->chip_id_);
+        this->status_set_error("Unknown chip ID");
         this->mark_failed();
-        this->status_set_error(str_sprintf("Unknown chip ID 0x%02X", this->chip_id_).c_str());
         return;
     }
     this->write_byte(REG_IRQ_CTL, IRQ_EN_MOTION);

esphome/components/esp32/__init__.py

@@ -854,6 +854,10 @@ def _configure_lwip_max_sockets(conf: dict) -> None:
 async def to_code(config):
     cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_platformio_option("board_upload.flash_size", config[CONF_FLASH_SIZE])
+    cg.add_platformio_option(
+        "board_upload.maximum_size",
+        int(config[CONF_FLASH_SIZE].removesuffix("MB")) * 1024 * 1024,
+    )
     cg.set_cpp_standard("gnu++20")
     cg.add_build_flag("-DUSE_ESP32")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
@@ -883,6 +887,12 @@ async def to_code(config):
         CORE.relative_internal_path(".espressif")
     )
 
+    add_extra_script(
+        "pre",
+        "pre_build.py",
+        Path(__file__).parent / "pre_build.py.script",
+    )
+
     add_extra_script(
         "post",
         "post_build.py",

esphome/components/esp32/pre_build.py.script

@@ -0,0 +1,9 @@
+Import("env")  # noqa: F821
+
+# Remove custom_sdkconfig from the board config as it causes
+# pioarduino to enable some strange hybrid build mode that breaks IDF
+board = env.BoardConfig()
+if "espidf.custom_sdkconfig" in board:
+    del board._manifest["espidf"]["custom_sdkconfig"]
+    if not board._manifest["espidf"]:
+        del board._manifest["espidf"]

esphome/components/esp32_hosted/update/esp32_hosted_update.cpp

@@ -22,6 +22,11 @@ constexpr size_t CHUNK_SIZE = 1500;
 void Esp32HostedUpdate::setup() {
   this->update_info_.title = "ESP32 Hosted Coprocessor";
 
+  // if wifi is not present, connect to the coprocessor
+#ifndef USE_WIFI
+  esp_hosted_connect_to_slave();  // NOLINT
+#endif
+
   // get coprocessor version
   esp_hosted_coprocessor_fwver_t ver_info;
   if (esp_hosted_get_coprocessor_fwversion(&ver_info) == ESP_OK) {

esphome/components/esp_ldo/esp_ldo.cpp

@@ -14,8 +14,8 @@ void EspLdo::setup() {
   config.flags.adjustable = this->adjustable_;
   auto err = esp_ldo_acquire_channel(&config, &this->handle_);
   if (err != ESP_OK) {
-    auto msg = str_sprintf("Failed to acquire LDO channel %d with voltage %fV", this->channel_, this->voltage_);
-    this->mark_failed(msg.c_str());
+    ESP_LOGE(TAG, "Failed to acquire LDO channel %d with voltage %fV", this->channel_, this->voltage_);
+    this->mark_failed("Failed to acquire LDO channel");
   } else {
     ESP_LOGD(TAG, "Acquired LDO channel %d with voltage %fV", this->channel_, this->voltage_);
   }

esphome/components/graph/graph.cpp

@@ -337,7 +337,7 @@ void Graph::draw_legend(display::Display *buff, uint16_t x_offset, uint16_t y_of
     return;
 
   /// Plot border
-  if (this->border_) {
+  if (legend_->border_) {
     int w = legend_->width_;
     int h = legend_->height_;
     buff->horizontal_line(x_offset, y_offset, w, color);

esphome/components/http_request/update/http_request_update.cpp

@@ -49,18 +49,18 @@ void HttpRequestUpdate::update_task(void *params) {
   auto container = this_update->request_parent_->get(this_update->source_url_);
 
   if (container == nullptr || container->status_code != HTTP_STATUS_OK) {
-    std::string msg = str_sprintf("Failed to fetch manifest from %s", this_update->source_url_.c_str());
+    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this_update->source_url_.c_str());
     // Defer to main loop to avoid race condition on component_state_ read-modify-write
-    this_update->defer([this_update, msg]() { this_update->status_set_error(msg.c_str()); });
+    this_update->defer([this_update]() { this_update->status_set_error("Failed to fetch manifest"); });
     UPDATE_RETURN;
   }
 
   RAMAllocator<uint8_t> allocator;
   uint8_t *data = allocator.allocate(container->content_length);
   if (data == nullptr) {
-    std::string msg = str_sprintf("Failed to allocate %zu bytes for manifest", container->content_length);
+    ESP_LOGE(TAG, "Failed to allocate %zu bytes for manifest", container->content_length);
     // Defer to main loop to avoid race condition on component_state_ read-modify-write
-    this_update->defer([this_update, msg]() { this_update->status_set_error(msg.c_str()); });
+    this_update->defer([this_update]() { this_update->status_set_error("Failed to allocate memory for manifest"); });
     container->end();
     UPDATE_RETURN;
   }
@@ -121,9 +121,9 @@ void HttpRequestUpdate::update_task(void *params) {
   }
 
   if (!valid) {
-    std::string msg = str_sprintf("Failed to parse JSON from %s", this_update->source_url_.c_str());
+    ESP_LOGE(TAG, "Failed to parse JSON from %s", this_update->source_url_.c_str());
     // Defer to main loop to avoid race condition on component_state_ read-modify-write
-    this_update->defer([this_update, msg]() { this_update->status_set_error(msg.c_str()); });
+    this_update->defer([this_update]() { this_update->status_set_error("Failed to parse manifest JSON"); });
     UPDATE_RETURN;
   }
 

esphome/components/jsn_sr04t/jsn_sr04t.cpp

@@ -10,7 +10,7 @@ namespace jsn_sr04t {
 static const char *const TAG = "jsn_sr04t.sensor";
 
 void Jsnsr04tComponent::update() {
-  this->write_byte(0x55);
+  this->write_byte((this->model_ == AJ_SR04M) ? 0x01 : 0x55);
   ESP_LOGV(TAG, "Request read out from sensor");
 }
 
@@ -31,19 +31,10 @@ void Jsnsr04tComponent::loop() {
 }
 
 void Jsnsr04tComponent::check_buffer_() {
-  uint8_t checksum = 0;
-  switch (this->model_) {
-    case JSN_SR04T:
-      checksum = this->buffer_[0] + this->buffer_[1] + this->buffer_[2];
-      break;
-    case AJ_SR04M:
-      checksum = this->buffer_[1] + this->buffer_[2];
-      break;
-  }
-
+  uint8_t checksum = this->buffer_[0] + this->buffer_[1] + this->buffer_[2];
   if (this->buffer_[3] == checksum) {
     uint16_t distance = encode_uint16(this->buffer_[1], this->buffer_[2]);
-    if (distance > 250) {
+    if (distance > ((this->model_ == AJ_SR04M) ? 200 : 250)) {
       float meters = distance / 1000.0f;
       ESP_LOGV(TAG, "Distance from sensor: %umm, %.3fm", distance, meters);
       this->publish_state(meters);

esphome/components/ltr501/ltr501.cpp

@@ -174,7 +174,7 @@ void LTRAlsPs501Component::loop() {
       break;
 
     case State::WAITING_FOR_DATA:
-      if (this->is_als_data_ready_(this->als_readings_) == DataAvail::DATA_OK) {
+      if (this->is_als_data_ready_(this->als_readings_) == LtrDataAvail::LTR_DATA_OK) {
         tries = 0;
         ESP_LOGV(TAG, "Reading sensor data assuming gain = %.0fx, time = %d ms",
                  get_gain_coeff(this->als_readings_.gain), get_itime_ms(this->als_readings_.integration_time));
@@ -379,18 +379,18 @@ void LTRAlsPs501Component::configure_integration_time_(IntegrationTime501 time)
   }
 }
 
-DataAvail LTRAlsPs501Component::is_als_data_ready_(AlsReadings &data) {
+LtrDataAvail LTRAlsPs501Component::is_als_data_ready_(AlsReadings &data) {
   AlsPsStatusRegister als_status{0};
   als_status.raw = this->reg((uint8_t) CommandRegisters::ALS_PS_STATUS).get();
   if (!als_status.als_new_data)
-    return DataAvail::NO_DATA;
+    return LtrDataAvail::LTR_NO_DATA;
   ESP_LOGV(TAG, "Data ready, reported gain is %.0fx", get_gain_coeff(als_status.gain));
   if (data.gain != als_status.gain) {
     ESP_LOGW(TAG, "Actual gain differs from requested (%.0f)", get_gain_coeff(data.gain));
-    return DataAvail::BAD_DATA;
+    return LtrDataAvail::LTR_BAD_DATA;
   }
   data.gain = als_status.gain;
-  return DataAvail::DATA_OK;
+  return LtrDataAvail::LTR_DATA_OK;
 }
 
 void LTRAlsPs501Component::read_sensor_data_(AlsReadings &data) {

esphome/components/ltr501/ltr501.h

@@ -11,7 +11,7 @@
 namespace esphome {
 namespace ltr501 {
 
-enum DataAvail : uint8_t { NO_DATA, BAD_DATA, DATA_OK };
+enum LtrDataAvail : uint8_t { LTR_NO_DATA, LTR_BAD_DATA, LTR_DATA_OK };
 
 enum LtrType : uint8_t {
   LTR_TYPE_UNKNOWN = 0,
@@ -106,7 +106,7 @@ class LTRAlsPs501Component : public PollingComponent, public i2c::I2CDevice {
   void configure_als_();
   void configure_integration_time_(IntegrationTime501 time);
   void configure_gain_(AlsGain501 gain);
-  DataAvail is_als_data_ready_(AlsReadings &data);
+  LtrDataAvail is_als_data_ready_(AlsReadings &data);
   void read_sensor_data_(AlsReadings &data);
   bool are_adjustments_required_(AlsReadings &data);
   void apply_lux_calculation_(AlsReadings &data);

esphome/components/ltr_als_ps/ltr_als_ps.cpp

@@ -165,7 +165,7 @@ void LTRAlsPsComponent::loop() {
       break;
 
     case State::WAITING_FOR_DATA:
-      if (this->is_als_data_ready_(this->als_readings_) == DataAvail::DATA_OK) {
+      if (this->is_als_data_ready_(this->als_readings_) == LtrDataAvail::LTR_DATA_OK) {
         tries = 0;
         ESP_LOGV(TAG, "Reading sensor data having gain = %.0fx, time = %d ms", get_gain_coeff(this->als_readings_.gain),
                  get_itime_ms(this->als_readings_.integration_time));
@@ -376,23 +376,23 @@ void LTRAlsPsComponent::configure_integration_time_(IntegrationTime time) {
   }
 }
 
-DataAvail LTRAlsPsComponent::is_als_data_ready_(AlsReadings &data) {
+LtrDataAvail LTRAlsPsComponent::is_als_data_ready_(AlsReadings &data) {
   AlsPsStatusRegister als_status{0};
 
   als_status.raw = this->reg((uint8_t) CommandRegisters::ALS_PS_STATUS).get();
   if (!als_status.als_new_data)
-    return DataAvail::NO_DATA;
+    return LtrDataAvail::LTR_NO_DATA;
 
   if (als_status.data_invalid) {
     ESP_LOGW(TAG, "Data available but not valid");
-    return DataAvail::BAD_DATA;
+    return LtrDataAvail::LTR_BAD_DATA;
   }
   ESP_LOGV(TAG, "Data ready, reported gain is %.0f", get_gain_coeff(als_status.gain));
   if (data.gain != als_status.gain) {
     ESP_LOGW(TAG, "Actual gain differs from requested (%.0f)", get_gain_coeff(data.gain));
-    return DataAvail::BAD_DATA;
+    return LtrDataAvail::LTR_BAD_DATA;
   }
-  return DataAvail::DATA_OK;
+  return LtrDataAvail::LTR_DATA_OK;
 }
 
 void LTRAlsPsComponent::read_sensor_data_(AlsReadings &data) {

esphome/components/ltr_als_ps/ltr_als_ps.h

@@ -11,7 +11,7 @@
 namespace esphome {
 namespace ltr_als_ps {
 
-enum DataAvail : uint8_t { NO_DATA, BAD_DATA, DATA_OK };
+enum LtrDataAvail : uint8_t { LTR_NO_DATA, LTR_BAD_DATA, LTR_DATA_OK };
 
 enum LtrType : uint8_t {
   LTR_TYPE_UNKNOWN = 0,
@@ -106,7 +106,7 @@ class LTRAlsPsComponent : public PollingComponent, public i2c::I2CDevice {
   void configure_als_();
   void configure_integration_time_(IntegrationTime time);
   void configure_gain_(AlsGain gain);
-  DataAvail is_als_data_ready_(AlsReadings &data);
+  LtrDataAvail is_als_data_ready_(AlsReadings &data);
   void read_sensor_data_(AlsReadings &data);
   bool are_adjustments_required_(AlsReadings &data);
   void apply_lux_calculation_(AlsReadings &data);

esphome/components/lvgl/layout.py

@@ -36,6 +36,8 @@ from .defines import (
 )
 from .lv_validation import padding, size
 
+CONF_MULTIPLE_WIDGETS_PER_CELL = "multiple_widgets_per_cell"
+
 cell_alignments = LV_CELL_ALIGNMENTS.one_of
 grid_alignments = LV_GRID_ALIGNMENTS.one_of
 flex_alignments = LV_FLEX_ALIGNMENTS.one_of
@@ -220,6 +222,7 @@ class GridLayout(Layout):
                 cv.Optional(CONF_GRID_ROW_ALIGN): grid_alignments,
                 cv.Optional(CONF_PAD_ROW): padding,
                 cv.Optional(CONF_PAD_COLUMN): padding,
+                cv.Optional(CONF_MULTIPLE_WIDGETS_PER_CELL, default=False): cv.boolean,
             },
             {
                 cv.Optional(CONF_GRID_CELL_ROW_POS): cv.positive_int,
@@ -263,6 +266,7 @@ class GridLayout(Layout):
         # should be guaranteed to be a dict at this point
         assert isinstance(layout, dict)
         assert layout.get(CONF_TYPE).lower() == TYPE_GRID
+        allow_multiple = layout.get(CONF_MULTIPLE_WIDGETS_PER_CELL, False)
         rows = len(layout[CONF_GRID_ROWS])
         columns = len(layout[CONF_GRID_COLUMNS])
         used_cells = [[None] * columns for _ in range(rows)]
@@ -299,7 +303,10 @@ class GridLayout(Layout):
                             f"exceeds grid size {rows}x{columns}",
                             [CONF_WIDGETS, index],
                         )
-                    if used_cells[row + i][column + j] is not None:
+                    if (
+                        not allow_multiple
+                        and used_cells[row + i][column + j] is not None
+                    ):
                         raise cv.Invalid(
                             f"Cell span {row + i}/{column + j} already occupied by widget at index {used_cells[row + i][column + j]}",
                             [CONF_WIDGETS, index],

esphome/components/lvgl/schemas.py

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

esphome/components/mipi_dsi/mipi_dsi.cpp

@@ -11,6 +11,12 @@ static bool notify_refresh_ready(esp_lcd_panel_handle_t panel, esp_lcd_dpi_panel
   xSemaphoreGiveFromISR(sem, &need_yield);
   return (need_yield == pdTRUE);
 }
+
+void MIPI_DSI::smark_failed(const char *message, esp_err_t err) {
+  ESP_LOGE(TAG, "%s: %s", message, esp_err_to_name(err));
+  this->mark_failed(message);
+}
+
 void MIPI_DSI::setup() {
   ESP_LOGCONFIG(TAG, "Running Setup");
 

esphome/components/mipi_dsi/mipi_dsi.h

@@ -62,10 +62,7 @@ class MIPI_DSI : public display::Display {
   void set_lanes(uint8_t lanes) { this->lanes_ = lanes; }
   void set_madctl(uint8_t madctl) { this->madctl_ = madctl; }
 
-  void smark_failed(const char *message, esp_err_t err) {
-    auto str = str_sprintf("Setup failed: %s: %s", message, esp_err_to_name(err));
-    this->mark_failed(str.c_str());
-  }
+  void smark_failed(const char *message, esp_err_t err);
 
   void update() override;
 

esphome/components/mipi_rgb/mipi_rgb.cpp

@@ -164,8 +164,8 @@ void MipiRgb::common_setup_() {
   if (err == ESP_OK)
     err = esp_lcd_panel_init(this->handle_);
   if (err != ESP_OK) {
-    auto msg = str_sprintf("lcd setup failed: %s", esp_err_to_name(err));
-    this->mark_failed(msg.c_str());
+    ESP_LOGE(TAG, "lcd setup failed: %s", esp_err_to_name(err));
+    this->mark_failed("lcd setup failed");
   }
   ESP_LOGCONFIG(TAG, "MipiRgb setup complete");
 }

esphome/components/network/ip_address.h

@@ -81,7 +81,12 @@ struct IPAddress {
     ip_addr_.type = IPADDR_TYPE_V6;
   }
 #endif /* LWIP_IPV6 */
-  IPAddress(esp_ip4_addr_t *other_ip) { memcpy((void *) &ip_addr_, (void *) other_ip, sizeof(esp_ip4_addr_t)); }
+  IPAddress(esp_ip4_addr_t *other_ip) {
+    memcpy((void *) &ip_addr_, (void *) other_ip, sizeof(esp_ip4_addr_t));
+#if LWIP_IPV6
+    ip_addr_.type = IPADDR_TYPE_V4;
+#endif
+  }
   IPAddress(esp_ip_addr_t *other_ip) {
 #if LWIP_IPV6
     memcpy((void *) &ip_addr_, (void *) other_ip, sizeof(ip_addr_));

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -174,6 +174,9 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   // Check if baud rate is supported
   this->original_baud_rate_ = this->parent_->get_baud_rate();
+  if (baud_rate <= 0) {
+    baud_rate = this->original_baud_rate_;
+  }
   ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
 
   // Define the configuration for the HTTP client

esphome/components/nextion/nextion_upload_idf.cpp

@@ -177,6 +177,9 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   // Check if baud rate is supported
   this->original_baud_rate_ = this->parent_->get_baud_rate();
+  if (baud_rate <= 0) {
+    baud_rate = this->original_baud_rate_;
+  }
   ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
 
   // Define the configuration for the HTTP client

esphome/components/online_image/png_image.cpp

@@ -2,6 +2,7 @@
 #ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
 
 #include "esphome/components/display/display_buffer.h"
+#include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
@@ -38,6 +39,14 @@ static void draw_callback(pngle_t *pngle, uint32_t x, uint32_t y, uint32_t w, ui
   PngDecoder *decoder = (PngDecoder *) pngle_get_user_data(pngle);
   Color color(rgba[0], rgba[1], rgba[2], rgba[3]);
   decoder->draw(x, y, w, h, color);
+
+  // Feed watchdog periodically to avoid triggering during long decode operations.
+  // Feed every 1024 pixels to balance efficiency and responsiveness.
+  uint32_t pixels = w * h;
+  decoder->increment_pixels_decoded(pixels);
+  if ((decoder->get_pixels_decoded() % 1024) < pixels) {
+    App.feed_wdt();
+  }
 }
 
 PngDecoder::PngDecoder(OnlineImage *image) : ImageDecoder(image) {

esphome/components/online_image/png_image.h

@@ -25,9 +25,13 @@ class PngDecoder : public ImageDecoder {
   int prepare(size_t download_size) override;
   int HOT decode(uint8_t *buffer, size_t size) override;
 
+  void increment_pixels_decoded(uint32_t count) { this->pixels_decoded_ += count; }
+  uint32_t get_pixels_decoded() const { return this->pixels_decoded_; }
+
  protected:
   RAMAllocator<pngle_t> allocator_;
   pngle_t *pngle_;
+  uint32_t pixels_decoded_{0};
 };
 
 }  // namespace online_image

esphome/components/packet_transport/packet_transport.cpp

@@ -195,8 +195,8 @@ static void add(std::vector<uint8_t> &vec, const char *str) {
 void PacketTransport::setup() {
   this->name_ = App.get_name().c_str();
   if (strlen(this->name_) > 255) {
-    this->mark_failed();
     this->status_set_error("Device name exceeds 255 chars");
+    this->mark_failed();
     return;
   }
   this->resend_ping_key_ = this->ping_pong_enable_;

esphome/components/script/script.h

@@ -1,8 +1,8 @@
 #pragma once
 
+#include <list>
 #include <memory>
 #include <tuple>
-#include <forward_list>
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
@@ -278,7 +278,12 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
 
   void setup() override {
     // Start with loop disabled - only enable when there's work to do
-    this->disable_loop();
+    // IMPORTANT: Only disable if num_running_ is 0, otherwise play_complex() was already
+    // called before our setup() (e.g., from on_boot trigger at same priority level)
+    // and we must not undo its enable_loop() call
+    if (this->num_running_ == 0) {
+      this->disable_loop();
+    }
   }
 
   void play_complex(const Ts &...x) override {
@@ -290,10 +295,10 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
     }
 
     // Store parameters for later execution
-    this->param_queue_.emplace_front(x...);
-    // Enable loop now that we have work to do
+    this->param_queue_.emplace_back(x...);
+    // Enable loop now that we have work to do - don't call loop() synchronously!
+    // Let the event loop call it to avoid reentrancy issues
     this->enable_loop();
-    this->loop();
   }
 
   void loop() override {
@@ -303,13 +308,17 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
     if (this->script_->is_running())
       return;
 
-    while (!this->param_queue_.empty()) {
+    // Only process ONE queued item per loop iteration
+    // Processing all items in a while loop causes infinite loops because
+    // play_next_() can trigger more items to be queued
+    if (!this->param_queue_.empty()) {
       auto &params = this->param_queue_.front();
       this->play_next_tuple_(params, typename gens<sizeof...(Ts)>::type());
       this->param_queue_.pop_front();
+    } else {
+      // Queue is now empty - disable loop until next play_complex
+      this->disable_loop();
     }
-    // Queue is now empty - disable loop until next play_complex
-    this->disable_loop();
   }
 
   void play(const Ts &...x) override { /* ignore - see play_complex */
@@ -326,7 +335,7 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
   }
 
   C *script_;
-  std::forward_list<std::tuple<Ts...>> param_queue_;
+  std::list<std::tuple<Ts...>> param_queue_;
 };
 
 }  // namespace script

esphome/components/udp/udp_component.cpp

@@ -21,8 +21,8 @@ void UDPComponent::setup() {
   if (this->should_broadcast_) {
     this->broadcast_socket_ = socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
     if (this->broadcast_socket_ == nullptr) {
-      this->mark_failed();
       this->status_set_error("Could not create socket");
+      this->mark_failed();
       return;
     }
     int enable = 1;
@@ -41,15 +41,15 @@ void UDPComponent::setup() {
   if (this->should_listen_) {
     this->listen_socket_ = socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
     if (this->listen_socket_ == nullptr) {
-      this->mark_failed();
       this->status_set_error("Could not create socket");
+      this->mark_failed();
       return;
     }
     auto err = this->listen_socket_->setblocking(false);
     if (err < 0) {
       ESP_LOGE(TAG, "Unable to set nonblocking: errno %d", errno);
-      this->mark_failed();
       this->status_set_error("Unable to set nonblocking");
+      this->mark_failed();
       return;
     }
     int enable = 1;
@@ -73,8 +73,8 @@ void UDPComponent::setup() {
       err = this->listen_socket_->setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP, &imreq, sizeof(imreq));
       if (err < 0) {
         ESP_LOGE(TAG, "Failed to set IP_ADD_MEMBERSHIP. Error %d", errno);
-        this->mark_failed();
         this->status_set_error("Failed to set IP_ADD_MEMBERSHIP");
+        this->mark_failed();
         return;
       }
     }
@@ -82,8 +82,8 @@ void UDPComponent::setup() {
     err = this->listen_socket_->bind((struct sockaddr *) &server, sizeof(server));
     if (err != 0) {
       ESP_LOGE(TAG, "Socket unable to bind: errno %d", errno);
-      this->mark_failed();
       this->status_set_error("Unable to bind socket");
+      this->mark_failed();
       return;
     }
   }

esphome/components/wake_on_lan/wake_on_lan.cpp

@@ -67,8 +67,8 @@ void WakeOnLanButton::setup() {
 #if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
   this->broadcast_socket_ = socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
   if (this->broadcast_socket_ == nullptr) {
-    this->mark_failed();
     this->status_set_error("Could not create socket");
+    this->mark_failed();
     return;
   }
   int enable = 1;

esphome/components/wifi/wifi_component.cpp

@@ -1555,6 +1555,20 @@ void WiFiComponent::retry_connect() {
   }
 }
 
+#ifdef USE_RP2040
+// RP2040's mDNS library (LEAmDNS) relies on LwipIntf::stateUpCB() to restart
+// mDNS when the network interface reconnects. However, this callback is disabled
+// in the arduino-pico framework. As a workaround, we block component setup until
+// WiFi is connected, ensuring mDNS.begin() is called with an active connection.
+
+bool WiFiComponent::can_proceed() {
+  if (!this->has_sta() || this->state_ == WIFI_COMPONENT_STATE_DISABLED || this->ap_setup_) {
+    return true;
+  }
+  return this->is_connected();
+}
+#endif
+
 void WiFiComponent::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
 bool WiFiComponent::is_connected() {
   return this->state_ == WIFI_COMPONENT_STATE_STA_CONNECTED &&

esphome/components/wifi/wifi_component.h

@@ -280,6 +280,10 @@ class WiFiComponent : public Component {
 
   void retry_connect();
 
+#ifdef USE_RP2040
+  bool can_proceed() override;
+#endif
+
   void set_reboot_timeout(uint32_t reboot_timeout);
 
   bool is_connected();

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2025.11.0"
+__version__ = "2025.11.2"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

esphome/core/base_automation.h

@@ -9,8 +9,8 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 
+#include <list>
 #include <vector>
-#include <forward_list>
 
 namespace esphome {
 
@@ -433,9 +433,10 @@ template<typename... Ts> class WaitUntilAction : public Action<Ts...>, public Co
     // Store for later processing
     auto now = millis();
     auto timeout = this->timeout_value_.optional_value(x...);
-    this->var_queue_.emplace_front(now, timeout, std::make_tuple(x...));
+    this->var_queue_.emplace_back(now, timeout, std::make_tuple(x...));
 
-    // Do immediate check with fresh timestamp
+    // Do immediate check with fresh timestamp - don't call loop() synchronously!
+    // Let the event loop call it to avoid reentrancy issues
     if (this->process_queue_(now)) {
       // Only enable loop if we still have pending items
       this->enable_loop();
@@ -487,7 +488,7 @@ template<typename... Ts> class WaitUntilAction : public Action<Ts...>, public Co
   }
 
   Condition<Ts...> *condition_;
-  std::forward_list<std::tuple<uint32_t, optional<uint32_t>, std::tuple<Ts...>>> var_queue_{};
+  std::list<std::tuple<uint32_t, optional<uint32_t>, std::tuple<Ts...>>> var_queue_{};
 };
 
 template<typename... Ts> class UpdateComponentAction : public Action<Ts...> {

esphome/core/scheduler.cpp

@@ -359,8 +359,7 @@ void HOT Scheduler::call(uint32_t now) {
       std::unique_ptr<SchedulerItem> item;
       {
         LockGuard guard{this->lock_};
-        item = std::move(this->items_[0]);
-        this->pop_raw_();
+        item = this->pop_raw_locked_();
       }
 
       const char *name = item->get_name();
@@ -401,7 +400,7 @@ void HOT Scheduler::call(uint32_t now) {
     // Don't run on failed components
     if (item->component != nullptr && item->component->is_failed()) {
       LockGuard guard{this->lock_};
-      this->pop_raw_();
+      this->recycle_item_(this->pop_raw_locked_());
       continue;
     }
 
@@ -414,7 +413,7 @@ void HOT Scheduler::call(uint32_t now) {
     {
       LockGuard guard{this->lock_};
       if (is_item_removed_(item.get())) {
-        this->pop_raw_();
+        this->recycle_item_(this->pop_raw_locked_());
         this->to_remove_--;
         continue;
       }
@@ -423,7 +422,7 @@ void HOT Scheduler::call(uint32_t now) {
     // Single-threaded or multi-threaded with atomics: can check without lock
     if (is_item_removed_(item.get())) {
       LockGuard guard{this->lock_};
-      this->pop_raw_();
+      this->recycle_item_(this->pop_raw_locked_());
       this->to_remove_--;
       continue;
     }
@@ -443,14 +442,14 @@ void HOT Scheduler::call(uint32_t now) {
 
     LockGuard guard{this->lock_};
 
-    auto executed_item = std::move(this->items_[0]);
     // Only pop after function call, this ensures we were reachable
     // during the function call and know if we were cancelled.
-    this->pop_raw_();
+    auto executed_item = this->pop_raw_locked_();
 
     if (executed_item->remove) {
-      // We were removed/cancelled in the function call, stop
+      // We were removed/cancelled in the function call, recycle and continue
       this->to_remove_--;
+      this->recycle_item_(std::move(executed_item));
       continue;
     }
 
@@ -497,7 +496,7 @@ size_t HOT Scheduler::cleanup_() {
     return this->items_.size();
 
   // We must hold the lock for the entire cleanup operation because:
-  // 1. We're modifying items_ (via pop_raw_) which requires exclusive access
+  // 1. We're modifying items_ (via pop_raw_locked_) which requires exclusive access
   // 2. We're decrementing to_remove_ which is also modified by other threads
   //    (though all modifications are already under lock)
   // 3. Other threads read items_ when searching for items to cancel in cancel_item_locked_()
@@ -510,17 +509,18 @@ size_t HOT Scheduler::cleanup_() {
     if (!item->remove)
       break;
     this->to_remove_--;
-    this->pop_raw_();
+    this->recycle_item_(this->pop_raw_locked_());
   }
   return this->items_.size();
 }
-void HOT Scheduler::pop_raw_() {
+std::unique_ptr<Scheduler::SchedulerItem> HOT Scheduler::pop_raw_locked_() {
   std::pop_heap(this->items_.begin(), this->items_.end(), SchedulerItem::cmp);
 
-  // Instead of destroying, recycle the item
-  this->recycle_item_(std::move(this->items_.back()));
+  // Move the item out before popping - this is the item that was at the front of the heap
+  auto item = std::move(this->items_.back());
 
   this->items_.pop_back();
+  return item;
 }
 
 // Helper to execute a scheduler item

esphome/core/scheduler.h

@@ -219,7 +219,9 @@ class Scheduler {
   // Returns the number of items remaining after cleanup
   // IMPORTANT: This method should only be called from the main thread (loop task).
   size_t cleanup_();
-  void pop_raw_();
+  // Remove and return the front item from the heap
+  // IMPORTANT: Caller must hold the scheduler lock before calling this function.
+  std::unique_ptr<SchedulerItem> pop_raw_locked_();
 
  private:
   // Helper to cancel items by name - must be called with lock held

esphome/writer.py

@@ -340,7 +340,13 @@ def clean_build():
 def clean_all(configuration: list[str]):
     import shutil
 
-    data_dirs = [Path(dir) / ".esphome" for dir in configuration]
+    data_dirs = []
+    for config in configuration:
+        item = Path(config)
+        if item.is_file() and item.suffix in (".yaml", ".yml"):
+            data_dirs.append(item.parent / ".esphome")
+        else:
+            data_dirs.append(item / ".esphome")
     if is_ha_addon():
         data_dirs.append(Path("/data"))
     if "ESPHOME_DATA_DIR" in os.environ:

tests/components/lvgl/lvgl-package.yaml

@@ -881,6 +881,7 @@ lvgl:
                   grid_columns: [40, fr(1), fr(1)]
                   pad_row: 6px
                   pad_column: 0
+                  multiple_widgets_per_cell: true
                 widgets:
                   - image:
                       grid_cell_row_pos: 0
@@ -905,6 +906,10 @@ lvgl:
                       grid_cell_row_pos: 1
                       grid_cell_column_pos: 0
                       text: "Grid cell 1/0"
+                  - label:
+                      grid_cell_row_pos: 1
+                      grid_cell_column_pos: 0
+                      text: "Duplicate for 1/0"
                   - label:
                       styles: bdr_style
                       grid_cell_row_pos: 1

tests/integration/fixtures/script_delay_with_params.yaml

@@ -0,0 +1,131 @@
+esphome:
+  name: test-script-delay-params
+
+host:
+
+api:
+  actions:
+    # Test case from issue #12044: parent script with repeat calling child with delay
+    - action: test_repeat_with_delay
+      then:
+        - logger.log: "=== TEST: Repeat loop calling script with delay and parameters ==="
+        - script.execute: father_script
+
+    # Test case from issue #12043: script.wait with delayed child script
+    - action: test_script_wait
+      then:
+        - logger.log: "=== TEST: script.wait with delayed child script ==="
+        - script.execute: show_start_page
+        - script.wait: show_start_page
+        - logger.log: "After wait: script completed successfully"
+
+    # Test: Delay with different parameter types
+    - action: test_delay_param_types
+      then:
+        - logger.log: "=== TEST: Delay with various parameter types ==="
+        - script.execute:
+            id: delay_with_int
+            val: 42
+        - delay: 50ms
+        - script.execute:
+            id: delay_with_string
+            msg: "test message"
+        - delay: 50ms
+        - script.execute:
+            id: delay_with_float
+            num: 3.14
+
+logger:
+  level: DEBUG
+
+script:
+  # Reproduces issue #12044: child script with conditional delay
+  - id: son_script
+    mode: single
+    parameters:
+      iteration: int
+    then:
+      - logger.log:
+          format: "Son script started with iteration %d"
+          args: ['iteration']
+      - if:
+          condition:
+            lambda: 'return iteration >= 5;'
+          then:
+            - logger.log:
+                format: "Son script delaying for iteration %d"
+                args: ['iteration']
+            - delay: 100ms
+      - logger.log:
+          format: "Son script finished with iteration %d"
+          args: ['iteration']
+
+  # Reproduces issue #12044: parent script with repeat loop
+  - id: father_script
+    mode: single
+    then:
+      - repeat:
+          count: 10
+          then:
+            - logger.log:
+                format: "Father iteration %d: calling son"
+                args: ['iteration']
+            - script.execute:
+                id: son_script
+                iteration: !lambda 'return iteration;'
+            - script.wait: son_script
+            - logger.log:
+                format: "Father iteration %d: son finished, wait returned"
+                args: ['iteration']
+
+  # Reproduces issue #12043: script.wait hangs
+  - id: show_start_page
+    mode: single
+    then:
+      - logger.log: "Start page: beginning"
+      - delay: 100ms
+      - logger.log: "Start page: after delay"
+      - delay: 100ms
+      - logger.log: "Start page: completed"
+
+  # Test delay with int parameter
+  - id: delay_with_int
+    mode: single
+    parameters:
+      val: int
+    then:
+      - logger.log:
+          format: "Int test: before delay, val=%d"
+          args: ['val']
+      - delay: 50ms
+      - logger.log:
+          format: "Int test: after delay, val=%d"
+          args: ['val']
+
+  # Test delay with string parameter
+  - id: delay_with_string
+    mode: single
+    parameters:
+      msg: string
+    then:
+      - logger.log:
+          format: "String test: before delay, msg=%s"
+          args: ['msg.c_str()']
+      - delay: 50ms
+      - logger.log:
+          format: "String test: after delay, msg=%s"
+          args: ['msg.c_str()']
+
+  # Test delay with float parameter
+  - id: delay_with_float
+    mode: single
+    parameters:
+      num: float
+    then:
+      - logger.log:
+          format: "Float test: before delay, num=%.2f"
+          args: ['num']
+      - delay: 50ms
+      - logger.log:
+          format: "Float test: after delay, num=%.2f"
+          args: ['num']

tests/integration/fixtures/script_wait_on_boot.yaml

@@ -0,0 +1,54 @@
+esphome:
+  name: test-script-wait-on-boot
+  on_boot:
+    # Use default priority (600.0) which is same as ScriptWaitAction's setup priority
+    # This tests the race condition where on_boot runs before ScriptWaitAction::setup()
+    then:
+      - logger.log: "=== on_boot: Starting boot sequence ==="
+      - script.execute: show_start_page
+      - script.wait: show_start_page
+      - logger.log: "=== on_boot: First script completed, starting second ==="
+      - script.execute: flip_thru_pages
+      - script.wait: flip_thru_pages
+      - logger.log: "=== on_boot: All boot scripts completed successfully ==="
+
+host:
+
+api:
+  actions:
+    # Manual trigger for additional testing
+    - action: test_script_wait
+      then:
+        - logger.log: "=== Manual test: Starting ==="
+        - script.execute: show_start_page
+        - script.wait: show_start_page
+        - logger.log: "=== Manual test: First script completed ==="
+        - script.execute: flip_thru_pages
+        - script.wait: flip_thru_pages
+        - logger.log: "=== Manual test: All completed ==="
+
+logger:
+  level: DEBUG
+
+script:
+  # First script - simulates display initialization
+  - id: show_start_page
+    mode: single
+    then:
+      - logger.log: "show_start_page: Starting"
+      - delay: 100ms
+      - logger.log: "show_start_page: After delay 1"
+      - delay: 100ms
+      - logger.log: "show_start_page: Completed"
+
+  # Second script - simulates page flip sequence
+  - id: flip_thru_pages
+    mode: single
+    then:
+      - logger.log: "flip_thru_pages: Starting"
+      - delay: 50ms
+      - logger.log: "flip_thru_pages: Page 1"
+      - delay: 50ms
+      - logger.log: "flip_thru_pages: Page 2"
+      - delay: 50ms
+      - logger.log: "flip_thru_pages: Completed"

tests/integration/fixtures/wait_until_fifo_ordering.yaml

@@ -0,0 +1,82 @@
+esphome:
+  name: test-wait-until-ordering
+
+host:
+
+api:
+  actions:
+    - action: test_wait_until_fifo
+      then:
+        - logger.log: "=== TEST: wait_until should execute in FIFO order ==="
+        - globals.set:
+            id: gate_open
+            value: 'false'
+        - delay: 100ms
+        # Start multiple parallel executions of coordinator script
+        # Each will call the shared waiter script, queueing in same wait_until
+        - script.execute: coordinator_0
+        - script.execute: coordinator_1
+        - script.execute: coordinator_2
+        - script.execute: coordinator_3
+        - script.execute: coordinator_4
+        # Give scripts time to reach wait_until and queue
+        - delay: 200ms
+        - logger.log: "Opening gate - all wait_until should complete now"
+        - globals.set:
+            id: gate_open
+            value: 'true'
+        - delay: 500ms
+        - logger.log: "Test complete"
+
+globals:
+  - id: gate_open
+    type: bool
+    initial_value: 'false'
+
+script:
+  # Shared waiter with single wait_until action (all coordinators call this)
+  - id: waiter
+    mode: parallel
+    parameters:
+      iter: int
+    then:
+      - lambda: 'ESP_LOGD("main", "Queueing iteration %d", iter);'
+      - wait_until:
+          condition:
+            lambda: 'return id(gate_open);'
+          timeout: 5s
+      - lambda: 'ESP_LOGD("main", "Completed iteration %d", iter);'
+
+  # Coordinator scripts - each calls shared waiter with different iteration number
+  - id: coordinator_0
+    then:
+      - script.execute:
+          id: waiter
+          iter: 0
+
+  - id: coordinator_1
+    then:
+      - script.execute:
+          id: waiter
+          iter: 1
+
+  - id: coordinator_2
+    then:
+      - script.execute:
+          id: waiter
+          iter: 2
+
+  - id: coordinator_3
+    then:
+      - script.execute:
+          id: waiter
+          iter: 3
+
+  - id: coordinator_4
+    then:
+      - script.execute:
+          id: waiter
+          iter: 4
+
+logger:
+  level: DEBUG

tests/integration/test_script_delay_params.py

@@ -0,0 +1,121 @@
+"""Integration test for script.wait FIFO ordering (issues #12043, #12044).
+
+This test verifies that ScriptWaitAction processes queued items in FIFO order.
+
+PR #7972 introduced bugs in ScriptWaitAction:
+- Used emplace_front() causing LIFO ordering instead of FIFO
+- Called loop() synchronously causing reentrancy issues
+- Used while loop processing entire queue causing infinite loops
+
+These bugs manifested as:
+- Scripts becoming "zombies" (stuck in running state)
+- script.wait hanging forever
+- Incorrect execution order
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_script_delay_with_params(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test that script.wait processes queued items in FIFO order.
+
+    This reproduces issues #12043 and #12044 where scripts would hang or become
+    zombies due to LIFO ordering bugs in ScriptWaitAction from PR #7972.
+    """
+    test_complete = asyncio.Event()
+
+    # Patterns to match in logs
+    father_calling_pattern = re.compile(r"Father iteration (\d+): calling son")
+    son_started_pattern = re.compile(r"Son script started with iteration (\d+)")
+    son_delaying_pattern = re.compile(r"Son script delaying for iteration (\d+)")
+    son_finished_pattern = re.compile(r"Son script finished with iteration (\d+)")
+    father_wait_returned_pattern = re.compile(
+        r"Father iteration (\d+): son finished, wait returned"
+    )
+
+    # Track which iterations completed
+    father_calling = set()
+    son_started = set()
+    son_delaying = set()
+    son_finished = set()
+    wait_returned = set()
+
+    def check_output(line: str) -> None:
+        """Check log output for expected messages."""
+        if test_complete.is_set():
+            return
+
+        if mo := father_calling_pattern.search(line):
+            father_calling.add(int(mo.group(1)))
+        elif mo := son_started_pattern.search(line):
+            son_started.add(int(mo.group(1)))
+        elif mo := son_delaying_pattern.search(line):
+            son_delaying.add(int(mo.group(1)))
+        elif mo := son_finished_pattern.search(line):
+            son_finished.add(int(mo.group(1)))
+        elif mo := father_wait_returned_pattern.search(line):
+            iteration = int(mo.group(1))
+            wait_returned.add(iteration)
+            # Test completes when iteration 9 finishes
+            if iteration == 9:
+                test_complete.set()
+
+    # Run with log monitoring
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        # Verify device info
+        device_info = await client.device_info()
+        assert device_info is not None
+        assert device_info.name == "test-script-delay-params"
+
+        # Get services
+        _, services = await client.list_entities_services()
+        test_service = next(
+            (s for s in services if s.name == "test_repeat_with_delay"), None
+        )
+        assert test_service is not None, "test_repeat_with_delay service not found"
+
+        # Execute the test
+        client.execute_service(test_service, {})
+
+        # Wait for test to complete (10 iterations * ~100ms each + margin)
+        try:
+            await asyncio.wait_for(test_complete.wait(), timeout=5.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Test timed out. Completed iterations: {sorted(wait_returned)}. "
+                f"This likely indicates the script became a zombie (issue #12044)."
+            )
+
+        # Verify all 10 iterations completed successfully
+        expected_iterations = set(range(10))
+        assert father_calling == expected_iterations, "Not all iterations started"
+        assert son_started == expected_iterations, (
+            "Son script not started for all iterations"
+        )
+        assert son_finished == expected_iterations, (
+            "Son script not finished for all iterations"
+        )
+        assert wait_returned == expected_iterations, (
+            "script.wait did not return for all iterations"
+        )
+
+        # Verify delays were triggered for iterations >= 5
+        expected_delays = set(range(5, 10))
+        assert son_delaying == expected_delays, (
+            "Delays not triggered for iterations >= 5"
+        )

tests/integration/test_script_wait_on_boot.py

@@ -0,0 +1,130 @@
+"""Integration test for script.wait during on_boot (issue #12043).
+
+This test verifies that script.wait works correctly when triggered from on_boot.
+The issue was that ScriptWaitAction::setup() unconditionally disabled the loop,
+even if play_complex() had already been called (from an on_boot trigger at the
+same priority level) and enabled it.
+
+The race condition occurs because:
+1. on_boot's default priority is 600.0 (setup_priority::DATA)
+2. ScriptWaitAction's default setup priority is also DATA (600.0)
+3. When they have the same priority, if on_boot runs first and triggers a script,
+   ScriptWaitAction::play_complex() enables the loop
+4. Then ScriptWaitAction::setup() runs and unconditionally disables the loop
+5. The wait never completes because the loop is disabled
+
+The fix adds a conditional check (like WaitUntilAction has) to only disable the
+loop in setup() if num_running_ is 0.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_script_wait_on_boot(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test that script.wait works correctly when triggered from on_boot.
+
+    This reproduces issue #12043 where script.wait would hang forever when
+    triggered from on_boot due to a race condition in ScriptWaitAction::setup().
+    """
+    test_complete = asyncio.Event()
+
+    # Track progress through the boot sequence
+    boot_started = False
+    first_script_started = False
+    first_script_completed = False
+    first_wait_returned = False
+    second_script_started = False
+    second_script_completed = False
+    all_completed = False
+
+    # Patterns for boot sequence logs
+    boot_start_pattern = re.compile(r"on_boot: Starting boot sequence")
+    show_start_pattern = re.compile(r"show_start_page: Starting")
+    show_complete_pattern = re.compile(r"show_start_page: Completed")
+    first_wait_pattern = re.compile(r"on_boot: First script completed")
+    flip_start_pattern = re.compile(r"flip_thru_pages: Starting")
+    flip_complete_pattern = re.compile(r"flip_thru_pages: Completed")
+    all_complete_pattern = re.compile(r"on_boot: All boot scripts completed")
+
+    def check_output(line: str) -> None:
+        """Check log output for boot sequence progress."""
+        nonlocal boot_started, first_script_started, first_script_completed
+        nonlocal first_wait_returned, second_script_started, second_script_completed
+        nonlocal all_completed
+
+        if boot_start_pattern.search(line):
+            boot_started = True
+        elif show_start_pattern.search(line):
+            first_script_started = True
+        elif show_complete_pattern.search(line):
+            first_script_completed = True
+        elif first_wait_pattern.search(line):
+            first_wait_returned = True
+        elif flip_start_pattern.search(line):
+            second_script_started = True
+        elif flip_complete_pattern.search(line):
+            second_script_completed = True
+        elif all_complete_pattern.search(line):
+            all_completed = True
+            test_complete.set()
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        # Verify device info
+        device_info = await client.device_info()
+        assert device_info is not None
+        assert device_info.name == "test-script-wait-on-boot"
+
+        # Wait for on_boot sequence to complete
+        # The boot sequence should complete automatically
+        # Timeout is generous to allow for delays in the scripts
+        try:
+            await asyncio.wait_for(test_complete.wait(), timeout=5.0)
+        except TimeoutError:
+            # Build a detailed error message showing where the boot sequence got stuck
+            progress = []
+            if boot_started:
+                progress.append("boot started")
+            if first_script_started:
+                progress.append("show_start_page started")
+            if first_script_completed:
+                progress.append("show_start_page completed")
+            if first_wait_returned:
+                progress.append("first script.wait returned")
+            if second_script_started:
+                progress.append("flip_thru_pages started")
+            if second_script_completed:
+                progress.append("flip_thru_pages completed")
+
+            if not first_wait_returned and first_script_completed:
+                pytest.fail(
+                    f"Test timed out - script.wait hung after show_start_page completed! "
+                    f"This is the issue #12043 bug. Progress: {', '.join(progress)}"
+                )
+            else:
+                pytest.fail(
+                    f"Test timed out. Progress: {', '.join(progress) if progress else 'none'}"
+                )
+
+        # Verify the complete boot sequence executed in order
+        assert boot_started, "on_boot did not start"
+        assert first_script_started, "show_start_page did not start"
+        assert first_script_completed, "show_start_page did not complete"
+        assert first_wait_returned, "First script.wait did not return"
+        assert second_script_started, "flip_thru_pages did not start"
+        assert second_script_completed, "flip_thru_pages did not complete"
+        assert all_completed, "Boot sequence did not complete"

tests/integration/test_wait_until_ordering.py

@@ -0,0 +1,90 @@
+"""Integration test for wait_until FIFO ordering.
+
+This test verifies that when multiple wait_until actions are queued,
+they execute in FIFO (First In First Out) order, not LIFO.
+
+PR #7972 introduced a bug where emplace_front() was used, causing
+LIFO ordering which is incorrect.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_wait_until_fifo_ordering(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test that wait_until executes queued items in FIFO order.
+
+    With the bug (using emplace_front), the order would be 4,3,2,1,0 (LIFO).
+    With the fix (using emplace_back), the order should be 0,1,2,3,4 (FIFO).
+    """
+    test_complete = asyncio.Event()
+
+    # Track completion order
+    completed_order = []
+
+    # Patterns to match
+    queuing_pattern = re.compile(r"Queueing iteration (\d+)")
+    completed_pattern = re.compile(r"Completed iteration (\d+)")
+
+    def check_output(line: str) -> None:
+        """Check log output for completion order."""
+        if test_complete.is_set():
+            return
+
+        if mo := queuing_pattern.search(line):
+            iteration = int(mo.group(1))
+
+        elif mo := completed_pattern.search(line):
+            iteration = int(mo.group(1))
+            completed_order.append(iteration)
+
+            # Test completes when all 5 have completed
+            if len(completed_order) == 5:
+                test_complete.set()
+
+    # Run with log monitoring
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        # Verify device info
+        device_info = await client.device_info()
+        assert device_info is not None
+        assert device_info.name == "test-wait-until-ordering"
+
+        # Get services
+        _, services = await client.list_entities_services()
+        test_service = next(
+            (s for s in services if s.name == "test_wait_until_fifo"), None
+        )
+        assert test_service is not None, "test_wait_until_fifo service not found"
+
+        # Execute the test
+        client.execute_service(test_service, {})
+
+        # Wait for test to complete
+        try:
+            await asyncio.wait_for(test_complete.wait(), timeout=5.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Test timed out. Completed order: {completed_order}. "
+                f"Expected 5 completions but got {len(completed_order)}."
+            )
+
+        # Verify FIFO order
+        expected_order = [0, 1, 2, 3, 4]
+        assert completed_order == expected_order, (
+            f"Unexpected order: {completed_order}. "
+            f"Expected FIFO order: {expected_order}"
+        )

tests/unit_tests/test_writer.py

@@ -737,6 +737,37 @@ def test_write_cpp_with_duplicate_markers(
         write_cpp("// New code")
 
 
+@patch("esphome.writer.CORE")
+def test_clean_all_with_yaml_file(
+    mock_core: MagicMock,
+    tmp_path: Path,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test clean_all with a .yaml file uses parent directory."""
+    # Create config directory with yaml file
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+    yaml_file = config_dir / "test.yaml"
+    yaml_file.write_text("esphome:\n  name: test\n")
+
+    build_dir = config_dir / ".esphome"
+    build_dir.mkdir()
+    (build_dir / "dummy.txt").write_text("x")
+
+    from esphome.writer import clean_all
+
+    with caplog.at_level("INFO"):
+        clean_all([str(yaml_file)])
+
+    # Verify .esphome directory still exists but contents cleaned
+    assert build_dir.exists()
+    assert not (build_dir / "dummy.txt").exists()
+
+    # Verify logging mentions the build dir
+    assert "Cleaning" in caplog.text
+    assert str(build_dir) in caplog.text
+
+
 @patch("esphome.writer.CORE")
 def test_clean_all(
     mock_core: MagicMock,