Merge pull request #12086 from esphome/bump-2025.11.1

2025.11.1

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.0b2
+PROJECT_NUMBER         = 2025.11.1
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

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/analyze_memory/cli.py

@@ -15,6 +15,11 @@ from . import (
 class MemoryAnalyzerCLI(MemoryAnalyzer):
     """Memory analyzer with CLI-specific report generation."""
 
+    # Symbol size threshold for detailed analysis
+    SYMBOL_SIZE_THRESHOLD: int = (
+        100  # Show symbols larger than this in detailed analysis
+    )
+
     # Column width constants
     COL_COMPONENT: int = 29
     COL_FLASH_TEXT: int = 14
@@ -191,14 +196,21 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                     f"{len(symbols):>{self.COL_CORE_COUNT}} | {percentage:>{self.COL_CORE_PERCENT - 1}.1f}%"
                 )
 
-            # Top 15 largest core symbols
+            # All core symbols above threshold
             lines.append("")
-            lines.append(f"Top 15 Largest {_COMPONENT_CORE} Symbols:")
             sorted_core_symbols = sorted(
                 self._esphome_core_symbols, key=lambda x: x[2], reverse=True
             )
+            large_core_symbols = [
+                (symbol, demangled, size)
+                for symbol, demangled, size in sorted_core_symbols
+                if size > self.SYMBOL_SIZE_THRESHOLD
+            ]
 
-            for i, (symbol, demangled, size) in enumerate(sorted_core_symbols[:15]):
+            lines.append(
+                f"{_COMPONENT_CORE} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_core_symbols)} symbols):"
+            )
+            for i, (symbol, demangled, size) in enumerate(large_core_symbols):
                 lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
             lines.append("=" * self.TABLE_WIDTH)
@@ -268,13 +280,15 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 lines.append(f"Total size: {comp_mem.flash_total:,} B")
                 lines.append("")
 
-                # Show all symbols > 100 bytes for better visibility
+                # Show all symbols above threshold for better visibility
                 large_symbols = [
-                    (sym, dem, size) for sym, dem, size in sorted_symbols if size > 100
+                    (sym, dem, size)
+                    for sym, dem, size in sorted_symbols
+                    if size > self.SYMBOL_SIZE_THRESHOLD
                 ]
 
                 lines.append(
-                    f"{comp_name} Symbols > 100 B ({len(large_symbols)} symbols):"
+                    f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_symbols)} symbols):"
                 )
                 for i, (symbol, demangled, size) in enumerate(large_symbols):
                     lines.append(f"{i + 1}. {demangled} ({size:,} B)")

esphome/components/captive_portal/__init__.py

@@ -1,9 +1,12 @@
+import logging
+
 import esphome.codegen as cg
 from esphome.components import web_server_base
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_AP,
     CONF_ID,
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
@@ -14,6 +17,10 @@ from esphome.const import (
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+_LOGGER = logging.getLogger(__name__)
 
 
 def AUTO_LOAD() -> list[str]:
@@ -50,6 +57,37 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
+def _final_validate(config: ConfigType) -> ConfigType:
+    full_config = fv.full_config.get()
+    wifi_conf = full_config.get("wifi")
+
+    if wifi_conf is None:
+        # This shouldn't happen due to DEPENDENCIES = ["wifi"], but check anyway
+        raise cv.Invalid("Captive portal requires the wifi component to be configured")
+
+    if CONF_AP not in wifi_conf:
+        _LOGGER.warning(
+            "Captive portal is enabled but no WiFi AP is configured. "
+            "The captive portal will not be accessible. "
+            "Add 'ap:' to your WiFi configuration to enable the captive portal."
+        )
+
+    # Register socket needs for DNS server and additional HTTP connections
+    # - 1 UDP socket for DNS server
+    # - 3 additional TCP sockets for captive portal detection probes + configuration requests
+    #   OS captive portal detection makes multiple probe requests that stay in TIME_WAIT.
+    #   Need headroom for actual user configuration requests.
+    #   LRU purging will reclaim idle sockets to prevent exhaustion from repeated attempts.
+    from esphome.components import socket
+
+    socket.consume_sockets(4, "captive_portal")(config)
+
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 @coroutine_with_priority(CoroPriority.CAPTIVE_PORTAL)
 async def to_code(config):
     paren = await cg.get_variable(config[CONF_WEB_SERVER_BASE_ID])

esphome/components/captive_portal/captive_portal.cpp

@@ -50,8 +50,8 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
   ESP_LOGI(TAG, "Requested WiFi Settings Change:");
   ESP_LOGI(TAG, "  SSID='%s'", ssid.c_str());
   ESP_LOGI(TAG, "  Password=" LOG_SECRET("'%s'"), psk.c_str());
-  wifi::global_wifi_component->save_wifi_sta(ssid, psk);
-  wifi::global_wifi_component->start_scanning();
+  // Defer save to main loop thread to avoid NVS operations from HTTP thread
+  this->defer([ssid, psk]() { wifi::global_wifi_component->save_wifi_sta(ssid, psk); });
   request->redirect(ESPHOME_F("/?save"));
 }
 
@@ -63,6 +63,12 @@ void CaptivePortal::start() {
   this->base_->init();
   if (!this->initialized_) {
     this->base_->add_handler(this);
+#ifdef USE_ESP32
+    // Enable LRU socket purging to handle captive portal detection probe bursts
+    // OS captive portal detection makes many simultaneous HTTP requests which can
+    // exhaust sockets. LRU purging automatically closes oldest idle connections.
+    this->base_->get_server()->set_lru_purge_enable(true);
+#endif
   }
 
   network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();

esphome/components/captive_portal/captive_portal.h

@@ -40,6 +40,10 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   void end() {
     this->active_ = false;
     this->disable_loop();  // Stop processing DNS requests
+#ifdef USE_ESP32
+    // Disable LRU socket purging now that captive portal is done
+    this->base_->get_server()->set_lru_purge_enable(false);
+#endif
     this->base_->deinit();
     if (this->dns_server_ != nullptr) {
       this->dns_server_->stop();

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/epaper_spi/display.py

@@ -102,7 +102,7 @@ def customise_schema(config):
     """
     config = cv.Schema(
         {
-            cv.Required(CONF_MODEL): cv.one_of(*MODELS, upper=True),
+            cv.Required(CONF_MODEL): cv.one_of(*MODELS, upper=True, space="-"),
         },
         extra=cv.ALLOW_EXTRA,
     )(config)

esphome/components/epaper_spi/models/spectra_e6.py

@@ -32,11 +32,15 @@ class SpectraE6(EpaperModel):
 
 spectra_e6 = SpectraE6("spectra-e6")
 
-spectra_e6.extend(
-    "Seeed-reTerminal-E1002",
+spectra_e6_7p3 = spectra_e6.extend(
+    "7.3in-Spectra-E6",
     width=800,
     height=480,
     data_rate="20MHz",
+)
+
+spectra_e6_7p3.extend(
+    "Seeed-reTerminal-E1002",
     cs_pin=10,
     dc_pin=11,
     reset_pin=12,

esphome/components/esp32/__init__.py

@@ -381,8 +381,9 @@ PLATFORM_VERSION_LOOKUP = {
 }
 
 
-def _check_versions(value):
-    value = value.copy()
+def _check_versions(config):
+    config = config.copy()
+    value = config[CONF_FRAMEWORK]
 
     if value[CONF_VERSION] in PLATFORM_VERSION_LOOKUP:
         if CONF_SOURCE in value or CONF_PLATFORM_VERSION in value:
@@ -447,7 +448,7 @@ def _check_versions(value):
             "If there are connectivity or build issues please remove the manual version."
         )
 
-    return value
+    return config
 
 
 def _parse_platform_version(value):
@@ -497,6 +498,8 @@ def final_validate(config):
     from esphome.components.psram import DOMAIN as PSRAM_DOMAIN
 
     errs = []
+    conf_fw = config[CONF_FRAMEWORK]
+    advanced = conf_fw[CONF_ADVANCED]
     full_config = fv.full_config.get()
     if pio_options := full_config[CONF_ESPHOME].get(CONF_PLATFORMIO_OPTIONS):
         pio_flash_size_key = "board_upload.flash_size"
@@ -513,22 +516,14 @@ def final_validate(config):
                     f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
                 )
             )
-    if (
-        config[CONF_VARIANT] != VARIANT_ESP32
-        and CONF_ADVANCED in (conf_fw := config[CONF_FRAMEWORK])
-        and CONF_IGNORE_EFUSE_MAC_CRC in conf_fw[CONF_ADVANCED]
-    ):
+    if config[CONF_VARIANT] != VARIANT_ESP32 and advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
         errs.append(
             cv.Invalid(
                 f"'{CONF_IGNORE_EFUSE_MAC_CRC}' is not supported on {config[CONF_VARIANT]}",
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_IGNORE_EFUSE_MAC_CRC],
             )
         )
-    if (
-        config.get(CONF_FRAMEWORK, {})
-        .get(CONF_ADVANCED, {})
-        .get(CONF_EXECUTE_FROM_PSRAM)
-    ):
+    if advanced[CONF_EXECUTE_FROM_PSRAM]:
         if config[CONF_VARIANT] != VARIANT_ESP32S3:
             errs.append(
                 cv.Invalid(
@@ -544,6 +539,17 @@ def final_validate(config):
                 )
             )
 
+    if (
+        config[CONF_FLASH_SIZE] == "32MB"
+        and "ota" in full_config
+        and not advanced[CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES]
+    ):
+        errs.append(
+            cv.Invalid(
+                f"OTA with 32MB flash requires '{CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES}' to be set in the '{CONF_ADVANCED}' section of the esp32 configuration",
+                path=[CONF_FLASH_SIZE],
+            )
+        )
     if errs:
         raise cv.MultipleInvalid(errs)
 
@@ -598,89 +604,74 @@ def _validate_idf_component(config: ConfigType) -> ConfigType:
 
 FRAMEWORK_ESP_IDF = "esp-idf"
 FRAMEWORK_ARDUINO = "arduino"
-FRAMEWORK_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.Optional(CONF_TYPE, default=FRAMEWORK_ARDUINO): cv.one_of(
-                FRAMEWORK_ESP_IDF, FRAMEWORK_ARDUINO
-            ),
-            cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
-            cv.Optional(CONF_RELEASE): cv.string_strict,
-            cv.Optional(CONF_SOURCE): cv.string_strict,
-            cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
-            cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
-                cv.string_strict: cv.string_strict
-            },
-            cv.Optional(CONF_LOG_LEVEL, default="ERROR"): cv.one_of(
-                *LOG_LEVELS_IDF, upper=True
-            ),
-            cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
-                {
-                    cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
-                        *ASSERTION_LEVELS, upper=True
-                    ),
-                    cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
-                        *COMPILER_OPTIMIZATIONS, upper=True
-                    ),
-                    cv.Optional(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES): cv.boolean,
-                    cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
-                    cv.Optional(
-                        CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False
-                    ): cv.boolean,
-                    cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC): cv.boolean,
-                    # DHCP server is needed for WiFi AP mode. When WiFi component is used,
-                    # it will handle disabling DHCP server when AP is not configured.
-                    # Default to false (disabled) when WiFi is not used.
-                    cv.OnlyWithout(
-                        CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_MDNS_QUERIES, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_DISABLE_LIBC_LOCKS_IN_IRAM, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_DISABLE_VFS_SUPPORT_TERMIOS, default=True
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_DISABLE_VFS_SUPPORT_SELECT, default=True
-                    ): cv.boolean,
-                    cv.Optional(CONF_DISABLE_VFS_SUPPORT_DIR, default=True): cv.boolean,
-                    cv.Optional(CONF_EXECUTE_FROM_PSRAM): cv.boolean,
-                    cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
-                        min=8192, max=32768
-                    ),
-                }
-            ),
-            cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
-                cv.All(
-                    cv.Schema(
-                        {
-                            cv.Required(CONF_NAME): cv.string_strict,
-                            cv.Optional(CONF_SOURCE): cv.git_ref,
-                            cv.Optional(CONF_REF): cv.string,
-                            cv.Optional(CONF_PATH): cv.string,
-                            cv.Optional(CONF_REFRESH): cv.All(
-                                cv.string, cv.source_refresh
-                            ),
-                        }
-                    ),
-                    _validate_idf_component,
-                )
-            ),
-        }
-    ),
-    _check_versions,
+FRAMEWORK_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_TYPE): cv.one_of(FRAMEWORK_ESP_IDF, FRAMEWORK_ARDUINO),
+        cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
+        cv.Optional(CONF_RELEASE): cv.string_strict,
+        cv.Optional(CONF_SOURCE): cv.string_strict,
+        cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
+        cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
+            cv.string_strict: cv.string_strict
+        },
+        cv.Optional(CONF_LOG_LEVEL, default="ERROR"): cv.one_of(
+            *LOG_LEVELS_IDF, upper=True
+        ),
+        cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
+            {
+                cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
+                    *ASSERTION_LEVELS, upper=True
+                ),
+                cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
+                    *COMPILER_OPTIMIZATIONS, upper=True
+                ),
+                cv.Optional(
+                    CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES, default=False
+                ): cv.boolean,
+                cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
+                cv.Optional(CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False): cv.boolean,
+                cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False): cv.boolean,
+                # DHCP server is needed for WiFi AP mode. When WiFi component is used,
+                # it will handle disabling DHCP server when AP is not configured.
+                # Default to false (disabled) when WiFi is not used.
+                cv.OnlyWithout(
+                    CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
+                ): cv.boolean,
+                cv.Optional(CONF_ENABLE_LWIP_MDNS_QUERIES, default=True): cv.boolean,
+                cv.Optional(
+                    CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
+                ): cv.boolean,
+                cv.Optional(
+                    CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, default=True
+                ): cv.boolean,
+                cv.Optional(
+                    CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
+                ): cv.boolean,
+                cv.Optional(CONF_DISABLE_LIBC_LOCKS_IN_IRAM, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_VFS_SUPPORT_TERMIOS, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_VFS_SUPPORT_SELECT, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_VFS_SUPPORT_DIR, default=True): cv.boolean,
+                cv.Optional(CONF_EXECUTE_FROM_PSRAM, default=False): cv.boolean,
+                cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
+                    min=8192, max=32768
+                ),
+            }
+        ),
+        cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
+            cv.All(
+                cv.Schema(
+                    {
+                        cv.Required(CONF_NAME): cv.string_strict,
+                        cv.Optional(CONF_SOURCE): cv.git_ref,
+                        cv.Optional(CONF_REF): cv.string,
+                        cv.Optional(CONF_PATH): cv.string,
+                        cv.Optional(CONF_REFRESH): cv.All(cv.string, cv.source_refresh),
+                    }
+                ),
+                _validate_idf_component,
+            )
+        ),
+    }
 )
 
 
@@ -743,11 +734,11 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
 
 
 def _set_default_framework(config):
+    config = config.copy()
     if CONF_FRAMEWORK not in config:
-        config = config.copy()
-
-        variant = config[CONF_VARIANT]
         config[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
+    if CONF_TYPE not in config[CONF_FRAMEWORK]:
+        variant = config[CONF_VARIANT]
         if variant in ARDUINO_ALLOWED_VARIANTS:
             config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ARDUINO
             _show_framework_migration_message(
@@ -787,6 +778,7 @@ CONFIG_SCHEMA = cv.All(
     ),
     _detect_variant,
     _set_default_framework,
+    _check_versions,
     set_core_data,
     cv.has_at_least_one_key(CONF_BOARD, CONF_VARIANT),
 )
@@ -805,9 +797,7 @@ def _configure_lwip_max_sockets(conf: dict) -> None:
     from esphome.components.socket import KEY_SOCKET_CONSUMERS
 
     # Check if user manually specified CONFIG_LWIP_MAX_SOCKETS
-    user_max_sockets = conf.get(CONF_SDKCONFIG_OPTIONS, {}).get(
-        "CONFIG_LWIP_MAX_SOCKETS"
-    )
+    user_max_sockets = conf[CONF_SDKCONFIG_OPTIONS].get("CONFIG_LWIP_MAX_SOCKETS")
 
     socket_consumers: dict[str, int] = CORE.data.get(KEY_SOCKET_CONSUMERS, {})
     total_sockets = sum(socket_consumers.values())
@@ -893,6 +883,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",
@@ -941,6 +937,12 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)
         add_idf_sdkconfig_option("CONFIG_ESP_PHY_REDUCE_TX_POWER", True)
 
+        # ESP32-S2 Arduino: Disable USB Serial on boot to avoid TinyUSB dependency
+        if get_esp32_variant() == VARIANT_ESP32S2:
+            cg.add_build_unflag("-DARDUINO_USB_CDC_ON_BOOT=1")
+            cg.add_build_unflag("-DARDUINO_USB_CDC_ON_BOOT=0")
+            cg.add_build_flag("-DARDUINO_USB_CDC_ON_BOOT=0")
+
     cg.add_build_flag("-Wno-nonnull-compare")
 
     add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
@@ -977,23 +979,18 @@ async def to_code(config):
     # WiFi component handles its own optimization when AP mode is not used
     # When using Arduino with Ethernet, DHCP server functions must be available
     # for the Network library to compile, even if not actively used
-    if (
-        CONF_ENABLE_LWIP_DHCP_SERVER in advanced
-        and not advanced[CONF_ENABLE_LWIP_DHCP_SERVER]
-        and not (
-            conf[CONF_TYPE] == FRAMEWORK_ARDUINO
-            and "ethernet" in CORE.loaded_integrations
-        )
+    if advanced.get(CONF_ENABLE_LWIP_DHCP_SERVER) is False and not (
+        conf[CONF_TYPE] == FRAMEWORK_ARDUINO and "ethernet" in CORE.loaded_integrations
     ):
         add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
-    if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, True):
+    if not advanced[CONF_ENABLE_LWIP_MDNS_QUERIES]:
         add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
-    if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
+    if not advanced[CONF_ENABLE_LWIP_BRIDGE_INTERFACE]:
         add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
 
     _configure_lwip_max_sockets(conf)
 
-    if advanced.get(CONF_EXECUTE_FROM_PSRAM, False):
+    if advanced[CONF_EXECUTE_FROM_PSRAM]:
         add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True)
         add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True)
 
@@ -1004,23 +1001,22 @@ async def to_code(config):
     # - select() on 4 sockets: ~190μs (Arduino/core locking) vs ~235μs (ESP-IDF default)
     # - Up to 200% slower under load when all operations queue through tcpip_thread
     # Enabling this makes ESP-IDF socket performance match Arduino framework.
-    if advanced.get(CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, True):
+    if advanced[CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING]:
         add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_CORE_LOCKING", True)
-    if advanced.get(CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, True):
+    if advanced[CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY]:
         add_idf_sdkconfig_option("CONFIG_LWIP_CHECK_THREAD_SAFETY", True)
 
     # Disable placing libc locks in IRAM to save RAM
     # This is safe for ESPHome since no IRAM ISRs (interrupts that run while cache is disabled)
     # use libc lock APIs. Saves approximately 1.3KB (1,356 bytes) of IRAM.
-    if advanced.get(CONF_DISABLE_LIBC_LOCKS_IN_IRAM, True):
+    if advanced[CONF_DISABLE_LIBC_LOCKS_IN_IRAM]:
         add_idf_sdkconfig_option("CONFIG_LIBC_LOCKS_PLACE_IN_IRAM", False)
 
     # Disable VFS support for termios (terminal I/O functions)
     # ESPHome doesn't use termios functions on ESP32 (only used in host UART driver).
     # Saves approximately 1.8KB of flash when disabled (default).
     add_idf_sdkconfig_option(
-        "CONFIG_VFS_SUPPORT_TERMIOS",
-        not advanced.get(CONF_DISABLE_VFS_SUPPORT_TERMIOS, True),
+        "CONFIG_VFS_SUPPORT_TERMIOS", not advanced[CONF_DISABLE_VFS_SUPPORT_TERMIOS]
     )
 
     # Disable VFS support for select() with file descriptors
@@ -1034,8 +1030,7 @@ async def to_code(config):
     else:
         # No component needs it - allow user to control (default: disabled)
         add_idf_sdkconfig_option(
-            "CONFIG_VFS_SUPPORT_SELECT",
-            not advanced.get(CONF_DISABLE_VFS_SUPPORT_SELECT, True),
+            "CONFIG_VFS_SUPPORT_SELECT", not advanced[CONF_DISABLE_VFS_SUPPORT_SELECT]
         )
 
     # Disable VFS support for directory functions (opendir, readdir, mkdir, etc.)
@@ -1048,8 +1043,7 @@ async def to_code(config):
     else:
         # No component needs it - allow user to control (default: disabled)
         add_idf_sdkconfig_option(
-            "CONFIG_VFS_SUPPORT_DIR",
-            not advanced.get(CONF_DISABLE_VFS_SUPPORT_DIR, True),
+            "CONFIG_VFS_SUPPORT_DIR", not advanced[CONF_DISABLE_VFS_SUPPORT_DIR]
         )
 
     cg.add_platformio_option("board_build.partitions", "partitions.csv")
@@ -1063,7 +1057,7 @@ async def to_code(config):
             add_idf_sdkconfig_option(flag, assertion_level == key)
 
     add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
-    compiler_optimization = advanced.get(CONF_COMPILER_OPTIMIZATION)
+    compiler_optimization = advanced[CONF_COMPILER_OPTIMIZATION]
     for key, flag in COMPILER_OPTIMIZATIONS.items():
         add_idf_sdkconfig_option(flag, compiler_optimization == key)
 
@@ -1072,18 +1066,20 @@ async def to_code(config):
         conf[CONF_ADVANCED][CONF_ENABLE_LWIP_ASSERT],
     )
 
-    if advanced.get(CONF_IGNORE_EFUSE_MAC_CRC):
+    if advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
         add_idf_sdkconfig_option("CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR", True)
         add_idf_sdkconfig_option("CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE", False)
-    if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
+    if advanced[CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES]:
         _LOGGER.warning(
             "Using experimental features in ESP-IDF may result in unexpected failures."
         )
         add_idf_sdkconfig_option("CONFIG_IDF_EXPERIMENTAL_FEATURES", True)
+        if config[CONF_FLASH_SIZE] == "32MB":
+            add_idf_sdkconfig_option(
+                "CONFIG_BOOTLOADER_CACHE_32BIT_ADDR_QUAD_FLASH", True
+            )
 
-    cg.add_define(
-        "ESPHOME_LOOP_TASK_STACK_SIZE", advanced.get(CONF_LOOP_TASK_STACK_SIZE)
-    )
+    cg.add_define("ESPHOME_LOOP_TASK_STACK_SIZE", advanced[CONF_LOOP_TASK_STACK_SIZE])
 
     cg.add_define(
         "USE_ESP_IDF_VERSION_CODE",

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

@@ -20,6 +20,10 @@ CONF_ON_STOP = "on_stop"
 CONF_STATUS_INDICATOR = "status_indicator"
 CONF_WIFI_TIMEOUT = "wifi_timeout"
 
+# Default WiFi timeout - aligned with WiFi component ap_timeout
+# Allows sufficient time to try all BSSIDs before starting provisioning mode
+DEFAULT_WIFI_TIMEOUT = "90s"
+
 
 improv_ns = cg.esphome_ns.namespace("improv")
 Error = improv_ns.enum("Error")
@@ -59,7 +63,7 @@ CONFIG_SCHEMA = (
                 CONF_AUTHORIZED_DURATION, default="1min"
             ): cv.positive_time_period_milliseconds,
             cv.Optional(
-                CONF_WIFI_TIMEOUT, default="1min"
+                CONF_WIFI_TIMEOUT, default=DEFAULT_WIFI_TIMEOUT
             ): cv.positive_time_period_milliseconds,
             cv.Optional(CONF_ON_PROVISIONED): automation.validate_automation(
                 {

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -127,6 +127,7 @@ void ESP32ImprovComponent::loop() {
           // Set initial state based on whether we have an authorizer
           this->set_state_(this->get_initial_state_(), false);
           this->set_error_(improv::ERROR_NONE);
+          this->should_start_ = false;  // Clear flag after starting
           ESP_LOGD(TAG, "Service started!");
         }
       }

esphome/components/esp32_improv/esp32_improv_component.h

@@ -45,6 +45,7 @@ class ESP32ImprovComponent : public Component, public improv_base::ImprovBase {
   void start();
   void stop();
   bool is_active() const { return this->state_ != improv::STATE_STOPPED; }
+  bool should_start() const { return this->should_start_; }
 
 #ifdef USE_ESP32_IMPROV_STATE_CALLBACK
   void add_on_state_callback(std::function<void(improv::State, improv::Error)> &&callback) {

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/ld2410/sensor.py

@@ -31,35 +31,83 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_LIGHTBULB,
         ),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
@@ -73,7 +121,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -81,7 +135,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/ld2412/sensor.py

@@ -31,36 +31,84 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_LIGHTBULB,
             unit_of_measurement=UNIT_EMPTY,  # No standard unit for this light sensor
         ),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
@@ -74,7 +122,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -82,7 +136,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/light/light_call.cpp

@@ -52,8 +52,10 @@ static void log_invalid_parameter(const char *name, const LogString *message) {
   }
 
 static const LogString *color_mode_to_human(ColorMode color_mode) {
-  if (color_mode == ColorMode::UNKNOWN)
-    return LOG_STR("Unknown");
+  if (color_mode == ColorMode::ON_OFF)
+    return LOG_STR("On/Off");
+  if (color_mode == ColorMode::BRIGHTNESS)
+    return LOG_STR("Brightness");
   if (color_mode == ColorMode::WHITE)
     return LOG_STR("White");
   if (color_mode == ColorMode::COLOR_TEMPERATURE)
@@ -68,7 +70,7 @@ static const LogString *color_mode_to_human(ColorMode color_mode) {
     return LOG_STR("RGB + cold/warm white");
   if (color_mode == ColorMode::RGB_COLOR_TEMPERATURE)
     return LOG_STR("RGB + color temperature");
-  return LOG_STR("");
+  return LOG_STR("Unknown");
 }
 
 // Helper to log percentage values

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/widgets/spinbox.py

@@ -1,6 +1,7 @@
 from esphome import automation
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_RANGE_FROM, CONF_RANGE_TO, CONF_STEP, CONF_VALUE
+from esphome.cpp_generator import MockObj
 
 from ..automation import action_to_code
 from ..defines import (
@@ -114,7 +115,9 @@ class SpinboxType(WidgetType):
                 w.obj, digits, digits - config[CONF_DECIMAL_PLACES]
             )
         if (value := config.get(CONF_VALUE)) is not None:
-            lv.spinbox_set_value(w.obj, await lv_float.process(value))
+            lv.spinbox_set_value(
+                w.obj, MockObj(await lv_float.process(value)) * w.get_scale()
+            )
 
     def get_scale(self, config):
         return 10 ** config[CONF_DECIMAL_PLACES]

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");
 }
@@ -350,6 +350,7 @@ void MipiRgb::dump_config() {
                 "\n  Width: %u"
                 "\n  Height: %u"
                 "\n  Rotation: %d degrees"
+                "\n  PCLK Inverted: %s"
                 "\n  HSync Pulse Width: %u"
                 "\n  HSync Back Porch: %u"
                 "\n  HSync Front Porch: %u"
@@ -357,18 +358,18 @@ void MipiRgb::dump_config() {
                 "\n  VSync Back Porch: %u"
                 "\n  VSync Front Porch: %u"
                 "\n  Invert Colors: %s"
-                "\n  Pixel Clock: %dMHz"
+                "\n  Pixel Clock: %uMHz"
                 "\n  Reset Pin: %s"
                 "\n  DE Pin: %s"
                 "\n  PCLK Pin: %s"
                 "\n  HSYNC Pin: %s"
                 "\n  VSYNC Pin: %s",
-                this->model_, this->width_, this->height_, this->rotation_, this->hsync_pulse_width_,
-                this->hsync_back_porch_, this->hsync_front_porch_, this->vsync_pulse_width_, this->vsync_back_porch_,
-                this->vsync_front_porch_, YESNO(this->invert_colors_), this->pclk_frequency_ / 1000000,
-                get_pin_name(this->reset_pin_).c_str(), get_pin_name(this->de_pin_).c_str(),
-                get_pin_name(this->pclk_pin_).c_str(), get_pin_name(this->hsync_pin_).c_str(),
-                get_pin_name(this->vsync_pin_).c_str());
+                this->model_, this->width_, this->height_, this->rotation_, YESNO(this->pclk_inverted_),
+                this->hsync_pulse_width_, this->hsync_back_porch_, this->hsync_front_porch_, this->vsync_pulse_width_,
+                this->vsync_back_porch_, this->vsync_front_porch_, YESNO(this->invert_colors_),
+                (unsigned) (this->pclk_frequency_ / 1000000), get_pin_name(this->reset_pin_).c_str(),
+                get_pin_name(this->de_pin_).c_str(), get_pin_name(this->pclk_pin_).c_str(),
+                get_pin_name(this->hsync_pin_).c_str(), get_pin_name(this->vsync_pin_).c_str());
 
   if (this->madctl_ & MADCTL_BGR) {
     this->dump_pins_(8, 13, "Blue", 0);

esphome/components/mipi_rgb/models/guition.py

@@ -11,6 +11,7 @@ st7701s.extend(
     vsync_pin=17,
     pclk_pin=21,
     pclk_frequency="12MHz",
+    pclk_inverted=False,
     pixel_mode="18bit",
     mirror_x=True,
     mirror_y=True,

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/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"
@@ -290,10 +290,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 +303,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 +330,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/sfa30/sfa30.cpp

@@ -73,17 +73,17 @@ void SFA30Component::update() {
     }
 
     if (this->formaldehyde_sensor_ != nullptr) {
-      const float formaldehyde = raw_data[0] / 5.0f;
+      const float formaldehyde = static_cast<int16_t>(raw_data[0]) / 5.0f;
       this->formaldehyde_sensor_->publish_state(formaldehyde);
     }
 
     if (this->humidity_sensor_ != nullptr) {
-      const float humidity = raw_data[1] / 100.0f;
+      const float humidity = static_cast<int16_t>(raw_data[1]) / 100.0f;
       this->humidity_sensor_->publish_state(humidity);
     }
 
     if (this->temperature_sensor_ != nullptr) {
-      const float temperature = raw_data[2] / 200.0f;
+      const float temperature = static_cast<int16_t>(raw_data[2]) / 200.0f;
       this->temperature_sensor_->publish_state(temperature);
     }
 

esphome/components/sntp/time.py

@@ -1,9 +1,14 @@
+import logging
+
 import esphome.codegen as cg
 from esphome.components import time as time_
+from esphome.config_helpers import merge_config
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
+    CONF_PLATFORM,
     CONF_SERVERS,
+    CONF_TIME,
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
@@ -12,13 +17,74 @@ from esphome.const import (
     PLATFORM_RTL87XX,
 )
 from esphome.core import CORE
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+_LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ["network"]
+
+CONF_SNTP = "sntp"
+
 sntp_ns = cg.esphome_ns.namespace("sntp")
 SNTPComponent = sntp_ns.class_("SNTPComponent", time_.RealTimeClock)
 
 DEFAULT_SERVERS = ["0.pool.ntp.org", "1.pool.ntp.org", "2.pool.ntp.org"]
 
+
+def _sntp_final_validate(config: ConfigType) -> None:
+    """Merge multiple SNTP instances into one, similar to OTA merging behavior."""
+    full_conf = fv.full_config.get()
+    time_confs = full_conf.get(CONF_TIME, [])
+
+    sntp_configs: list[ConfigType] = []
+    other_time_configs: list[ConfigType] = []
+
+    for time_conf in time_confs:
+        if time_conf.get(CONF_PLATFORM) == CONF_SNTP:
+            sntp_configs.append(time_conf)
+        else:
+            other_time_configs.append(time_conf)
+
+    if len(sntp_configs) <= 1:
+        return
+
+    # Merge all SNTP configs into the first one
+    merged = sntp_configs[0]
+    for sntp_conf in sntp_configs[1:]:
+        # Validate that IDs are consistent if manually specified
+        if merged[CONF_ID].is_manual and sntp_conf[CONF_ID].is_manual:
+            raise cv.Invalid(
+                f"Found multiple SNTP configurations but {CONF_ID} is inconsistent"
+            )
+        merged = merge_config(merged, sntp_conf)
+
+    # Deduplicate servers while preserving order
+    servers = merged[CONF_SERVERS]
+    unique_servers = list(dict.fromkeys(servers))
+
+    # Warn if we're dropping servers due to 3-server limit
+    if len(unique_servers) > 3:
+        dropped = unique_servers[3:]
+        unique_servers = unique_servers[:3]
+        _LOGGER.warning(
+            "SNTP supports maximum 3 servers. Dropped excess server(s): %s",
+            dropped,
+        )
+
+    merged[CONF_SERVERS] = unique_servers
+
+    _LOGGER.warning(
+        "Found and merged %d SNTP time configurations into one instance",
+        len(sntp_configs),
+    )
+
+    # Replace time configs with merged SNTP + other time platforms
+    other_time_configs.append(merged)
+    full_conf[CONF_TIME] = other_time_configs
+    fv.full_config.set(full_conf)
+
+
 CONFIG_SCHEMA = cv.All(
     time_.TIME_SCHEMA.extend(
         {
@@ -40,6 +106,8 @@ CONFIG_SCHEMA = cv.All(
     ),
 )
 
+FINAL_VALIDATE_SCHEMA = _sntp_final_validate
+
 
 async def to_code(config):
     servers = config[CONF_SERVERS]

esphome/components/text_sensor/filter.cpp

@@ -66,10 +66,14 @@ SubstituteFilter::SubstituteFilter(const std::initializer_list<Substitution> &su
     : substitutions_(substitutions) {}
 
 optional<std::string> SubstituteFilter::new_value(std::string value) {
-  std::size_t pos;
   for (const auto &sub : this->substitutions_) {
-    while ((pos = value.find(sub.from)) != std::string::npos)
+    std::size_t pos = 0;
+    while ((pos = value.find(sub.from, pos)) != std::string::npos) {
       value.replace(pos, sub.from.size(), sub.to);
+      // Advance past the replacement to avoid infinite loop when
+      // the replacement contains the search pattern (e.g., f -> foo)
+      pos += sub.to.size();
+    }
   }
   return value;
 }

esphome/components/uart/__init__.py

@@ -1,3 +1,4 @@
+from logging import getLogger
 import math
 import re
 
@@ -35,6 +36,8 @@ from esphome.core import CORE, ID
 import esphome.final_validate as fv
 from esphome.yaml_util import make_data_base
 
+_LOGGER = getLogger(__name__)
+
 CODEOWNERS = ["@esphome/core"]
 uart_ns = cg.esphome_ns.namespace("uart")
 UARTComponent = uart_ns.class_("UARTComponent")
@@ -130,6 +133,21 @@ def validate_host_config(config):
     return config
 
 
+def validate_rx_buffer_size(config):
+    if CORE.is_esp32:
+        # ESP32 UART hardware FIFO is 128 bytes (LP UART is 16 bytes, but we use 128 as safe minimum)
+        # rx_buffer_size must be greater than the hardware FIFO length
+        min_buffer_size = 128
+        if config[CONF_RX_BUFFER_SIZE] <= min_buffer_size:
+            _LOGGER.warning(
+                "UART rx_buffer_size (%d bytes) is too small and must be greater than the hardware "
+                "FIFO size (%d bytes). The buffer size will be automatically adjusted at runtime.",
+                config[CONF_RX_BUFFER_SIZE],
+                min_buffer_size,
+            )
+    return config
+
+
 def _uart_declare_type(value):
     if CORE.is_esp8266:
         return cv.declare_id(ESP8266UartComponent)(value)
@@ -247,6 +265,7 @@ CONFIG_SCHEMA = cv.All(
     ).extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN, CONF_PORT),
     validate_host_config,
+    validate_rx_buffer_size,
 )
 
 

esphome/components/uart/uart_component_esp8266.cpp

@@ -56,11 +56,19 @@ uint32_t ESP8266UartComponent::get_config() {
 }
 
 void ESP8266UartComponent::setup() {
-  if (this->rx_pin_) {
-    this->rx_pin_->setup();
-  }
-  if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
-    this->tx_pin_->setup();
+  auto setup_pin_if_needed = [](InternalGPIOPin *pin) {
+    if (!pin) {
+      return;
+    }
+    const auto mask = gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN;
+    if ((pin->get_flags() & mask) != gpio::Flags::FLAG_NONE) {
+      pin->setup();
+    }
+  };
+
+  setup_pin_if_needed(this->rx_pin_);
+  if (this->rx_pin_ != this->tx_pin_) {
+    setup_pin_if_needed(this->tx_pin_);
   }
 
   // Use Arduino HardwareSerial UARTs if all used pins match the ones

esphome/components/uart/uart_component_esp_idf.cpp

@@ -91,6 +91,16 @@ void IDFUARTComponent::setup() {
   this->uart_num_ = static_cast<uart_port_t>(next_uart_num++);
   this->lock_ = xSemaphoreCreateMutex();
 
+#if (SOC_UART_LP_NUM >= 1)
+  size_t fifo_len = ((this->uart_num_ < SOC_UART_HP_NUM) ? SOC_UART_FIFO_LEN : SOC_LP_UART_FIFO_LEN);
+#else
+  size_t fifo_len = SOC_UART_FIFO_LEN;
+#endif
+  if (this->rx_buffer_size_ <= fifo_len) {
+    ESP_LOGW(TAG, "rx_buffer_size is too small, must be greater than %zu", fifo_len);
+    this->rx_buffer_size_ = fifo_len * 2;
+  }
+
   xSemaphoreTake(this->lock_, portMAX_DELAY);
 
   this->load_settings(false);
@@ -123,11 +133,19 @@ void IDFUARTComponent::load_settings(bool dump_config) {
     return;
   }
 
-  if (this->rx_pin_) {
-    this->rx_pin_->setup();
-  }
-  if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
-    this->tx_pin_->setup();
+  auto setup_pin_if_needed = [](InternalGPIOPin *pin) {
+    if (!pin) {
+      return;
+    }
+    const auto mask = gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN;
+    if ((pin->get_flags() & mask) != gpio::Flags::FLAG_NONE) {
+      pin->setup();
+    }
+  };
+
+  setup_pin_if_needed(this->rx_pin_);
+  if (this->rx_pin_ != this->tx_pin_) {
+    setup_pin_if_needed(this->tx_pin_);
   }
 
   int8_t tx = this->tx_pin_ != nullptr ? this->tx_pin_->get_pin() : -1;
@@ -237,8 +255,12 @@ void IDFUARTComponent::set_rx_timeout(size_t rx_timeout) {
 
 void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  uart_write_bytes(this->uart_num_, data, len);
+  int32_t write_len = uart_write_bytes(this->uart_num_, data, len);
   xSemaphoreGive(this->lock_);
+  if (write_len != (int32_t) len) {
+    ESP_LOGW(TAG, "uart_write_bytes failed: %d != %zu", write_len, len);
+    this->mark_failed();
+  }
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_TX, data[i]);
@@ -267,6 +289,7 @@ bool IDFUARTComponent::peek_byte(uint8_t *data) {
 
 bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   size_t length_to_read = len;
+  int32_t read_len = 0;
   if (!this->check_read_timeout_(len))
     return false;
   xSemaphoreTake(this->lock_, portMAX_DELAY);
@@ -277,25 +300,31 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
     this->has_peek_ = false;
   }
   if (length_to_read > 0)
-    uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
+    read_len = uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
   xSemaphoreGive(this->lock_);
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_RX, data[i]);
   }
 #endif
-  return true;
+  return read_len == (int32_t) length_to_read;
 }
 
 int IDFUARTComponent::available() {
-  size_t available;
+  size_t available = 0;
+  esp_err_t err;
 
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  uart_get_buffered_data_len(this->uart_num_, &available);
-  if (this->has_peek_)
-    available++;
+  err = uart_get_buffered_data_len(this->uart_num_, &available);
   xSemaphoreGive(this->lock_);
 
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "uart_get_buffered_data_len failed: %s", esp_err_to_name(err));
+    this->mark_failed();
+  }
+  if (this->has_peek_) {
+    available++;
+  }
   return available;
 }
 

esphome/components/uart/uart_component_libretiny.cpp

@@ -53,7 +53,7 @@ void LibreTinyUARTComponent::setup() {
 
   auto shouldFallbackToSoftwareSerial = [&]() -> bool {
     auto hasFlags = [](InternalGPIOPin *pin, const gpio::Flags mask) -> bool {
-      return pin && pin->get_flags() & mask != gpio::Flags::FLAG_NONE;
+      return pin && (pin->get_flags() & mask) != gpio::Flags::FLAG_NONE;
     };
     if (hasFlags(this->tx_pin_, gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN) ||
         hasFlags(this->rx_pin_, gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN)) {

esphome/components/uart/uart_component_rp2040.cpp

@@ -52,11 +52,19 @@ uint16_t RP2040UartComponent::get_config() {
 }
 
 void RP2040UartComponent::setup() {
-  if (this->rx_pin_) {
-    this->rx_pin_->setup();
-  }
-  if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
-    this->tx_pin_->setup();
+  auto setup_pin_if_needed = [](InternalGPIOPin *pin) {
+    if (!pin) {
+      return;
+    }
+    const auto mask = gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN;
+    if ((pin->get_flags() & mask) != gpio::Flags::FLAG_NONE) {
+      pin->setup();
+    }
+  };
+
+  setup_pin_if_needed(this->rx_pin_);
+  if (this->rx_pin_ != this->tx_pin_) {
+    setup_pin_if_needed(this->tx_pin_);
   }
 
   uint16_t config = get_config();

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

@@ -1,10 +1,17 @@
+import logging
+
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_component
 from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code
+from esphome.config_helpers import merge_config
 import esphome.config_validation as cv
-from esphome.const import CONF_ID
+from esphome.const import CONF_ID, CONF_OTA, CONF_PLATFORM, CONF_WEB_SERVER
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+_LOGGER = logging.getLogger(__name__)
 
 CODEOWNERS = ["@esphome/core"]
 DEPENDENCIES = ["network", "web_server_base"]
@@ -12,6 +19,53 @@ DEPENDENCIES = ["network", "web_server_base"]
 web_server_ns = cg.esphome_ns.namespace("web_server")
 WebServerOTAComponent = web_server_ns.class_("WebServerOTAComponent", OTAComponent)
 
+
+def _web_server_ota_final_validate(config: ConfigType) -> None:
+    """Merge multiple web_server OTA instances into one.
+
+    Multiple web_server OTA instances register duplicate HTTP handlers for /update,
+    causing undefined behavior. Merge them into a single instance.
+    """
+    full_conf = fv.full_config.get()
+    ota_confs = full_conf.get(CONF_OTA, [])
+
+    web_server_ota_configs: list[ConfigType] = []
+    other_ota_configs: list[ConfigType] = []
+
+    for ota_conf in ota_confs:
+        if ota_conf.get(CONF_PLATFORM) == CONF_WEB_SERVER:
+            web_server_ota_configs.append(ota_conf)
+        else:
+            other_ota_configs.append(ota_conf)
+
+    if len(web_server_ota_configs) <= 1:
+        return
+
+    # Merge all web_server OTA configs into the first one
+    merged = web_server_ota_configs[0]
+    for ota_conf in web_server_ota_configs[1:]:
+        # Validate that IDs are consistent if manually specified
+        if (
+            merged[CONF_ID].is_manual
+            and ota_conf[CONF_ID].is_manual
+            and merged[CONF_ID] != ota_conf[CONF_ID]
+        ):
+            raise cv.Invalid(
+                f"Found multiple web_server OTA configurations but {CONF_ID} is inconsistent"
+            )
+        merged = merge_config(merged, ota_conf)
+
+    _LOGGER.warning(
+        "Found and merged %d web_server OTA configurations into one instance",
+        len(web_server_ota_configs),
+    )
+
+    # Replace OTA configs with merged web_server + other OTA platforms
+    other_ota_configs.append(merged)
+    full_conf[CONF_OTA] = other_ota_configs
+    fv.full_config.set(full_conf)
+
+
 CONFIG_SCHEMA = (
     cv.Schema(
         {
@@ -22,6 +76,8 @@ CONFIG_SCHEMA = (
     .extend(cv.COMPONENT_SCHEMA)
 )
 
+FINAL_VALIDATE_SCHEMA = _web_server_ota_final_validate
+
 
 @coroutine_with_priority(CoroPriority.WEB_SERVER_OTA)
 async def to_code(config):

esphome/components/web_server_idf/web_server_idf.cpp

@@ -87,6 +87,29 @@ int nonblocking_send(httpd_handle_t hd, int sockfd, const char *buf, size_t buf_
 }
 }  // namespace
 
+void AsyncWebServer::safe_close_with_shutdown(httpd_handle_t hd, int sockfd) {
+  // CRITICAL: Shut down receive BEFORE closing to prevent lwIP race conditions
+  //
+  // The race condition occurs because close() initiates lwIP teardown while
+  // the TCP/IP thread can still receive packets, causing assertions when
+  // recv_tcp() sees partially-torn-down state.
+  //
+  // By shutting down receive first, we tell lwIP to stop accepting new data BEFORE
+  // the teardown begins, eliminating the race window. We only shutdown RD (not RDWR)
+  // to allow the FIN packet to be sent cleanly during close().
+  //
+  // Note: This function may be called with an already-closed socket if the network
+  // stack closed it. In that case, shutdown() will fail but close() is safe to call.
+  //
+  // See: https://github.com/esphome/esphome-webserver/issues/163
+
+  // Attempt shutdown - ignore errors as socket may already be closed
+  shutdown(sockfd, SHUT_RD);
+
+  // Always close - safe even if socket is already closed by network stack
+  close(sockfd);
+}
+
 void AsyncWebServer::end() {
   if (this->server_) {
     httpd_stop(this->server_);
@@ -94,6 +117,18 @@ void AsyncWebServer::end() {
   }
 }
 
+void AsyncWebServer::set_lru_purge_enable(bool enable) {
+  if (this->lru_purge_enable_ == enable) {
+    return;  // No change needed
+  }
+  this->lru_purge_enable_ = enable;
+  // If server is already running, restart it with new config
+  if (this->server_) {
+    this->end();
+    this->begin();
+  }
+}
+
 void AsyncWebServer::begin() {
   if (this->server_) {
     this->end();
@@ -101,6 +136,10 @@ void AsyncWebServer::begin() {
   httpd_config_t config = HTTPD_DEFAULT_CONFIG();
   config.server_port = this->port_;
   config.uri_match_fn = [](const char * /*unused*/, const char * /*unused*/, size_t /*unused*/) { return true; };
+  // Enable LRU purging if requested (e.g., by captive portal to handle probe bursts)
+  config.lru_purge_enable = this->lru_purge_enable_;
+  // Use custom close function that shuts down before closing to prevent lwIP race conditions
+  config.close_fn = AsyncWebServer::safe_close_with_shutdown;
   if (httpd_start(&this->server_, &config) == ESP_OK) {
     const httpd_uri_t handler_get = {
         .uri = "",
@@ -242,6 +281,7 @@ void AsyncWebServerRequest::send(int code, const char *content_type, const char
 void AsyncWebServerRequest::redirect(const std::string &url) {
   httpd_resp_set_status(*this, "302 Found");
   httpd_resp_set_hdr(*this, "Location", url.c_str());
+  httpd_resp_set_hdr(*this, "Connection", "close");
   httpd_resp_send(*this, nullptr, 0);
 }
 
@@ -489,10 +529,12 @@ AsyncEventSourceResponse::AsyncEventSourceResponse(const AsyncWebServerRequest *
 
 void AsyncEventSourceResponse::destroy(void *ptr) {
   auto *rsp = static_cast<AsyncEventSourceResponse *>(ptr);
-  ESP_LOGD(TAG, "Event source connection closed (fd: %d)", rsp->fd_.load());
-  // Mark as dead by setting fd to 0 - will be cleaned up in the main loop
-  rsp->fd_.store(0);
+  int fd = rsp->fd_.exchange(0);  // Atomically get and clear fd
+  ESP_LOGD(TAG, "Event source connection closed (fd: %d)", fd);
+  // Mark as dead - will be cleaned up in the main loop
   // Note: We don't delete or remove from set here to avoid race conditions
+  // httpd will call our custom close_fn (safe_close_with_shutdown) which handles
+  // shutdown() before close() to prevent lwIP race conditions
 }
 
 // helper for allowing only unique entries in the queue

esphome/components/web_server_idf/web_server_idf.h

@@ -199,12 +199,17 @@ class AsyncWebServer {
     return *handler;
   }
 
+  void set_lru_purge_enable(bool enable);
+  httpd_handle_t get_server() { return this->server_; }
+
  protected:
   uint16_t port_{};
   httpd_handle_t server_{};
+  bool lru_purge_enable_{false};
   static esp_err_t request_handler(httpd_req_t *r);
   static esp_err_t request_post_handler(httpd_req_t *r);
   esp_err_t request_handler_(AsyncWebServerRequest *request) const;
+  static void safe_close_with_shutdown(httpd_handle_t hd, int sockfd);
 #ifdef USE_WEBSERVER_OTA
   esp_err_t handle_multipart_upload_(httpd_req_t *r, const char *content_type);
 #endif

esphome/components/wifi/__init__.py

@@ -12,7 +12,6 @@ from esphome.components.network import (
 from esphome.components.psram import is_guaranteed as psram_is_guaranteed
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
-from esphome.config_validation import only_with_esp_idf
 from esphome.const import (
     CONF_AP,
     CONF_BSSID,
@@ -70,6 +69,12 @@ CONF_MIN_AUTH_MODE = "min_auth_mode"
 # Limited to 127 because selected_sta_index_ is int8_t in C++
 MAX_WIFI_NETWORKS = 127
 
+# Default AP timeout - allows sufficient time to try all BSSIDs during initial connection
+# After AP starts, WiFi scanning is skipped to avoid disrupting the AP, so we only
+# get best-effort connection attempts. Longer timeout ensures we exhaust all options
+# before falling back to AP mode. Aligned with improv wifi_timeout default.
+DEFAULT_AP_TIMEOUT = "90s"
+
 wifi_ns = cg.esphome_ns.namespace("wifi")
 EAPAuth = wifi_ns.struct("EAPAuth")
 ManualIP = wifi_ns.struct("ManualIP")
@@ -178,7 +183,7 @@ CONF_AP_TIMEOUT = "ap_timeout"
 WIFI_NETWORK_AP = WIFI_NETWORK_BASE.extend(
     {
         cv.Optional(
-            CONF_AP_TIMEOUT, default="1min"
+            CONF_AP_TIMEOUT, default=DEFAULT_AP_TIMEOUT
         ): cv.positive_time_period_milliseconds,
     }
 )
@@ -352,7 +357,7 @@ CONFIG_SCHEMA = cv.All(
                 single=True
             ),
             cv.Optional(CONF_USE_PSRAM): cv.All(
-                only_with_esp_idf, cv.requires_component("psram"), cv.boolean
+                cv.only_on_esp32, cv.requires_component("psram"), cv.boolean
             ),
         }
     ),

esphome/components/wifi/wifi_component.cpp

@@ -199,7 +199,12 @@ static constexpr uint8_t WIFI_RETRY_COUNT_PER_AP = 1;
 
 /// Cooldown duration in milliseconds after adapter restart or repeated failures
 /// Allows WiFi hardware to stabilize before next connection attempt
-static constexpr uint32_t WIFI_COOLDOWN_DURATION_MS = 1000;
+static constexpr uint32_t WIFI_COOLDOWN_DURATION_MS = 500;
+
+/// Cooldown duration when fallback AP is active and captive portal may be running
+/// Longer interval gives users time to configure WiFi without constant connection attempts
+/// While connecting, WiFi can't beacon the AP properly, so needs longer cooldown
+static constexpr uint32_t WIFI_COOLDOWN_WITH_AP_ACTIVE_MS = 30000;
 
 static constexpr uint8_t get_max_retries_for_phase(WiFiRetryPhase phase) {
   switch (phase) {
@@ -275,7 +280,9 @@ int8_t WiFiComponent::find_next_hidden_sta_(int8_t start_index) {
       }
     }
 
-    if (!this->ssid_was_seen_in_scan_(sta.get_ssid())) {
+    // If we didn't scan this cycle, treat all networks as potentially hidden
+    // Otherwise, only retry networks that weren't seen in the scan
+    if (!this->did_scan_this_cycle_ || !this->ssid_was_seen_in_scan_(sta.get_ssid())) {
       ESP_LOGD(TAG, "Hidden candidate " LOG_SECRET("'%s'") " at index %d", sta.get_ssid().c_str(), static_cast<int>(i));
       return static_cast<int8_t>(i);
     }
@@ -417,10 +424,6 @@ void WiFiComponent::start() {
 void WiFiComponent::restart_adapter() {
   ESP_LOGW(TAG, "Restarting adapter");
   this->wifi_mode_(false, {});
-  // Enter cooldown state to allow WiFi hardware to stabilize after restart
-  // Don't set retry_phase_ or num_retried_ here - state machine handles transitions
-  this->state_ = WIFI_COMPONENT_STATE_COOLDOWN;
-  this->action_started_ = millis();
   this->error_from_callback_ = false;
 }
 
@@ -441,7 +444,16 @@ void WiFiComponent::loop() {
     switch (this->state_) {
       case WIFI_COMPONENT_STATE_COOLDOWN: {
         this->status_set_warning(LOG_STR("waiting to reconnect"));
-        if (now - this->action_started_ > WIFI_COOLDOWN_DURATION_MS) {
+        // Skip cooldown if new credentials were provided while connecting
+        if (this->skip_cooldown_next_cycle_) {
+          this->skip_cooldown_next_cycle_ = false;
+          this->check_connecting_finished();
+          break;
+        }
+        // Use longer cooldown when captive portal/improv is active to avoid disrupting user config
+        bool portal_active = this->is_captive_portal_active_() || this->is_esp32_improv_active_();
+        uint32_t cooldown_duration = portal_active ? WIFI_COOLDOWN_WITH_AP_ACTIVE_MS : WIFI_COOLDOWN_DURATION_MS;
+        if (now - this->action_started_ > cooldown_duration) {
           // After cooldown we either restarted the adapter because of
           // a failure, or something tried to connect over and over
           // so we entered cooldown. In both cases we call
@@ -495,7 +507,8 @@ void WiFiComponent::loop() {
 #endif  // USE_WIFI_AP
 
 #ifdef USE_IMPROV
-    if (esp32_improv::global_improv_component != nullptr && !esp32_improv::global_improv_component->is_active()) {
+    if (esp32_improv::global_improv_component != nullptr && !esp32_improv::global_improv_component->is_active() &&
+        !esp32_improv::global_improv_component->should_start()) {
       if (now - this->last_connected_ > esp32_improv::global_improv_component->get_wifi_timeout()) {
         if (this->wifi_mode_(true, {}))
           esp32_improv::global_improv_component->start();
@@ -605,6 +618,8 @@ void WiFiComponent::set_sta(const WiFiAP &ap) {
   this->init_sta(1);
   this->add_sta(ap);
   this->selected_sta_index_ = 0;
+  // When new credentials are set (e.g., from improv), skip cooldown to retry immediately
+  this->skip_cooldown_next_cycle_ = true;
 }
 
 WiFiAP WiFiComponent::build_params_for_current_phase_() {
@@ -666,6 +681,17 @@ void WiFiComponent::save_wifi_sta(const std::string &ssid, const std::string &pa
   sta.set_ssid(ssid);
   sta.set_password(password);
   this->set_sta(sta);
+
+  // Trigger connection attempt (exits cooldown if needed, no-op if already connecting/connected)
+  this->connect_soon_();
+}
+
+void WiFiComponent::connect_soon_() {
+  // Only trigger retry if we're in cooldown - if already connecting/connected, do nothing
+  if (this->state_ == WIFI_COMPONENT_STATE_COOLDOWN) {
+    ESP_LOGD(TAG, "Exiting cooldown early due to new WiFi credentials");
+    this->retry_connect();
+  }
 }
 
 void WiFiComponent::start_connecting(const WiFiAP &ap) {
@@ -961,6 +987,7 @@ void WiFiComponent::check_scanning_finished() {
     return;
   }
   this->scan_done_ = false;
+  this->did_scan_this_cycle_ = true;
 
   if (this->scan_result_.empty()) {
     ESP_LOGW(TAG, "No networks found");
@@ -1227,9 +1254,16 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
       return WiFiRetryPhase::RESTARTING_ADAPTER;
 
     case WiFiRetryPhase::RESTARTING_ADAPTER:
-      // After restart, go back to explicit hidden if we went through it initially, otherwise scan
-      return this->went_through_explicit_hidden_phase_() ? WiFiRetryPhase::EXPLICIT_HIDDEN
-                                                         : WiFiRetryPhase::SCAN_CONNECTING;
+      // After restart, go back to explicit hidden if we went through it initially
+      if (this->went_through_explicit_hidden_phase_()) {
+        return WiFiRetryPhase::EXPLICIT_HIDDEN;
+      }
+      // Skip scanning when captive portal/improv is active to avoid disrupting AP
+      // Even passive scans can cause brief AP disconnections on ESP32
+      if (this->is_captive_portal_active_() || this->is_esp32_improv_active_()) {
+        return WiFiRetryPhase::RETRY_HIDDEN;
+      }
+      return WiFiRetryPhase::SCAN_CONNECTING;
   }
 
   // Should never reach here
@@ -1317,6 +1351,12 @@ bool WiFiComponent::transition_to_phase_(WiFiRetryPhase new_phase) {
       if (!this->is_captive_portal_active_() && !this->is_esp32_improv_active_()) {
         this->restart_adapter();
       }
+      // Clear scan flag - we're starting a new retry cycle
+      this->did_scan_this_cycle_ = false;
+      // Always enter cooldown after restart (or skip-restart) to allow stabilization
+      // Use extended cooldown when AP is active to avoid constant scanning that blocks DNS
+      this->state_ = WIFI_COMPONENT_STATE_COOLDOWN;
+      this->action_started_ = millis();
       // Return true to indicate we should wait (go to COOLDOWN) instead of immediately connecting
       return true;
 

esphome/components/wifi/wifi_component.h

@@ -291,6 +291,7 @@ class WiFiComponent : public Component {
   void set_passive_scan(bool passive);
 
   void save_wifi_sta(const std::string &ssid, const std::string &password);
+
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
   /// Setup WiFi interface.
@@ -424,6 +425,8 @@ class WiFiComponent : public Component {
     return true;
   }
 
+  void connect_soon_();
+
   void wifi_loop_();
   bool wifi_mode_(optional<bool> sta, optional<bool> ap);
   bool wifi_sta_pre_setup_();
@@ -529,6 +532,8 @@ class WiFiComponent : public Component {
   bool enable_on_boot_;
   bool got_ipv4_address_{false};
   bool keep_scan_results_{false};
+  bool did_scan_this_cycle_{false};
+  bool skip_cooldown_next_cycle_{false};
 
   // Pointers at the end (naturally aligned)
   Trigger<> *connect_trigger_{new Trigger<>()};

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -870,7 +870,13 @@ bssid_t WiFiComponent::wifi_bssid() {
   return bssid;
 }
 std::string WiFiComponent::wifi_ssid() { return WiFi.SSID().c_str(); }
-int8_t WiFiComponent::wifi_rssi() { return WiFi.status() == WL_CONNECTED ? WiFi.RSSI() : WIFI_RSSI_DISCONNECTED; }
+int8_t WiFiComponent::wifi_rssi() {
+  if (WiFi.status() != WL_CONNECTED)
+    return WIFI_RSSI_DISCONNECTED;
+  int8_t rssi = WiFi.RSSI();
+  // Values >= 31 are error codes per NONOS SDK API, not valid RSSI readings
+  return rssi >= 31 ? WIFI_RSSI_DISCONNECTED : rssi;
+}
 int32_t WiFiComponent::get_wifi_channel() { return WiFi.channel(); }
 network::IPAddress WiFiComponent::wifi_subnet_mask_() { return {(const ip_addr_t *) WiFi.subnetMask()}; }
 network::IPAddress WiFiComponent::wifi_gateway_ip_() { return {(const ip_addr_t *) WiFi.gatewayIP()}; }

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2025.11.0b2"
+__version__ = "2025.11.1"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
@@ -336,6 +336,7 @@ CONF_ENERGY = "energy"
 CONF_ENTITY_CATEGORY = "entity_category"
 CONF_ENTITY_ID = "entity_id"
 CONF_ENUM_DATAPOINT = "enum_datapoint"
+CONF_ENVIRONMENT_VARIABLES = "environment_variables"
 CONF_EQUATION = "equation"
 CONF_ESP8266_DISABLE_SSL_SUPPORT = "esp8266_disable_ssl_support"
 CONF_ESPHOME = "esphome"

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

@@ -17,6 +17,7 @@ from esphome.const import (
     CONF_COMPILE_PROCESS_LIMIT,
     CONF_DEBUG_SCHEDULER,
     CONF_DEVICES,
+    CONF_ENVIRONMENT_VARIABLES,
     CONF_ESPHOME,
     CONF_FRIENDLY_NAME,
     CONF_ID,
@@ -215,6 +216,11 @@ CONFIG_SCHEMA = cv.All(
                     cv.string_strict: cv.Any([cv.string], cv.string),
                 }
             ),
+            cv.Optional(CONF_ENVIRONMENT_VARIABLES, default={}): cv.Schema(
+                {
+                    cv.string_strict: cv.string,
+                }
+            ),
             cv.Optional(CONF_ON_BOOT): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StartupTrigger),
@@ -426,6 +432,12 @@ async def _add_platformio_options(pio_options):
         cg.add_platformio_option(key, val)
 
 
+@coroutine_with_priority(CoroPriority.FINAL)
+async def _add_environment_variables(env_vars: dict[str, str]) -> None:
+    # Set environment variables for the build process
+    os.environ.update(env_vars)
+
+
 @coroutine_with_priority(CoroPriority.AUTOMATION)
 async def _add_automations(config):
     for conf in config.get(CONF_ON_BOOT, []):
@@ -563,6 +575,9 @@ async def to_code(config: ConfigType) -> None:
     if config[CONF_PLATFORMIO_OPTIONS]:
         CORE.add_job(_add_platformio_options, config[CONF_PLATFORMIO_OPTIONS])
 
+    if config[CONF_ENVIRONMENT_VARIABLES]:
+        CORE.add_job(_add_environment_variables, config[CONF_ENVIRONMENT_VARIABLES])
+
     # Process areas
     all_areas: list[dict[str, str | core.ID]] = []
     if CONF_AREA in config:

esphome/core/scheduler.cpp

@@ -154,8 +154,8 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
 
   // For retries, check if there's a cancelled timeout first
   if (is_retry && name_cstr != nullptr && type == SchedulerItem::TIMEOUT &&
-      (has_cancelled_timeout_in_container_(this->items_, component, name_cstr, /* match_retry= */ true) ||
-       has_cancelled_timeout_in_container_(this->to_add_, component, name_cstr, /* match_retry= */ true))) {
+      (has_cancelled_timeout_in_container_locked_(this->items_, component, name_cstr, /* match_retry= */ true) ||
+       has_cancelled_timeout_in_container_locked_(this->to_add_, component, name_cstr, /* match_retry= */ true))) {
     // Skip scheduling - the retry was cancelled
 #ifdef ESPHOME_DEBUG_SCHEDULER
     ESP_LOGD(TAG, "Skipping retry '%s' - found cancelled item", name_cstr);
@@ -556,7 +556,8 @@ bool HOT Scheduler::cancel_item_locked_(Component *component, const char *name_c
 #ifndef ESPHOME_THREAD_SINGLE
   // Mark items in defer queue as cancelled (they'll be skipped when processed)
   if (type == SchedulerItem::TIMEOUT) {
-    total_cancelled += this->mark_matching_items_removed_(this->defer_queue_, component, name_cstr, type, match_retry);
+    total_cancelled +=
+        this->mark_matching_items_removed_locked_(this->defer_queue_, component, name_cstr, type, match_retry);
   }
 #endif /* not ESPHOME_THREAD_SINGLE */
 
@@ -565,19 +566,20 @@ bool HOT Scheduler::cancel_item_locked_(Component *component, const char *name_c
   // (removing the last element doesn't break heap structure)
   if (!this->items_.empty()) {
     auto &last_item = this->items_.back();
-    if (this->matches_item_(last_item, component, name_cstr, type, match_retry)) {
+    if (this->matches_item_locked_(last_item, component, name_cstr, type, match_retry)) {
       this->recycle_item_(std::move(this->items_.back()));
       this->items_.pop_back();
       total_cancelled++;
     }
     // For other items in heap, we can only mark for removal (can't remove from middle of heap)
-    size_t heap_cancelled = this->mark_matching_items_removed_(this->items_, component, name_cstr, type, match_retry);
+    size_t heap_cancelled =
+        this->mark_matching_items_removed_locked_(this->items_, component, name_cstr, type, match_retry);
     total_cancelled += heap_cancelled;
     this->to_remove_ += heap_cancelled;  // Track removals for heap items
   }
 
   // Cancel items in to_add_
-  total_cancelled += this->mark_matching_items_removed_(this->to_add_, component, name_cstr, type, match_retry);
+  total_cancelled += this->mark_matching_items_removed_locked_(this->to_add_, component, name_cstr, type, match_retry);
 
   return total_cancelled > 0;
 }
@@ -609,13 +611,12 @@ uint64_t Scheduler::millis_64_(uint32_t now) {
   if (now < last && (last - now) > HALF_MAX_UINT32) {
     this->millis_major_++;
     major++;
+    this->last_millis_ = now;
 #ifdef ESPHOME_DEBUG_SCHEDULER
     ESP_LOGD(TAG, "Detected true 32-bit rollover at %" PRIu32 "ms (was %" PRIu32 ")", now, last);
 #endif /* ESPHOME_DEBUG_SCHEDULER */
-  }
-
-  // Only update if time moved forward
-  if (now > last) {
+  } else if (now > last) {
+    // Only update if time moved forward
     this->last_millis_ = now;
   }
 

esphome/core/scheduler.h

@@ -243,8 +243,18 @@ class Scheduler {
   }
 
   // Helper function to check if item matches criteria for cancellation
-  inline bool HOT matches_item_(const std::unique_ptr<SchedulerItem> &item, Component *component, const char *name_cstr,
-                                SchedulerItem::Type type, bool match_retry, bool skip_removed = true) const {
+  // IMPORTANT: Must be called with scheduler lock held
+  inline bool HOT matches_item_locked_(const std::unique_ptr<SchedulerItem> &item, Component *component,
+                                       const char *name_cstr, SchedulerItem::Type type, bool match_retry,
+                                       bool skip_removed = true) const {
+    // THREAD SAFETY: Check for nullptr first to prevent LoadProhibited crashes. On multi-threaded
+    // platforms, items can be moved out of defer_queue_ during processing, leaving nullptr entries.
+    // PR #11305 added nullptr checks in callers (mark_matching_items_removed_locked_() and
+    // has_cancelled_timeout_in_container_locked_()), but this check provides defense-in-depth: helper
+    // functions should be safe regardless of caller behavior.
+    // Fixes: https://github.com/esphome/esphome/issues/11940
+    if (!item)
+      return false;
     if (item->component != component || item->type != type || (skip_removed && item->remove) ||
         (match_retry && !item->is_retry)) {
       return false;
@@ -304,8 +314,8 @@ class Scheduler {
         // 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)
+        // 2. Any code iterating defer_queue_ MUST check for nullptr items (see mark_matching_items_removed_locked_
+        //    and has_cancelled_timeout_in_container_locked_ 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_++;
@@ -393,10 +403,10 @@ class Scheduler {
 
   // Helper to mark matching items in a container as removed
   // Returns the number of items marked for removal
-  // IMPORTANT: Caller must hold the scheduler lock before calling this function.
+  // IMPORTANT: Must be called with scheduler lock held
   template<typename Container>
-  size_t mark_matching_items_removed_(Container &container, Component *component, const char *name_cstr,
-                                      SchedulerItem::Type type, bool match_retry) {
+  size_t mark_matching_items_removed_locked_(Container &container, Component *component, const char *name_cstr,
+                                             SchedulerItem::Type type, bool match_retry) {
     size_t count = 0;
     for (auto &item : container) {
       // Skip nullptr items (can happen in defer_queue_ when items are being processed)
@@ -405,7 +415,7 @@ class Scheduler {
       // the vector can still contain nullptr items from the processing loop. This check prevents crashes.
       if (!item)
         continue;
-      if (this->matches_item_(item, component, name_cstr, type, match_retry)) {
+      if (this->matches_item_locked_(item, component, name_cstr, type, match_retry)) {
         // Mark item for removal (platform-specific)
         this->set_item_removed_(item.get(), true);
         count++;
@@ -415,9 +425,10 @@ class Scheduler {
   }
 
   // Template helper to check if any item in a container matches our criteria
+  // IMPORTANT: Must be called with scheduler lock held
   template<typename Container>
-  bool has_cancelled_timeout_in_container_(const Container &container, Component *component, const char *name_cstr,
-                                           bool match_retry) const {
+  bool has_cancelled_timeout_in_container_locked_(const Container &container, Component *component,
+                                                  const char *name_cstr, bool match_retry) const {
     for (const auto &item : container) {
       // Skip nullptr items (can happen in defer_queue_ when items are being processed)
       // The defer_queue_ uses index-based processing: items are std::moved out but left in the
@@ -426,8 +437,8 @@ class Scheduler {
       if (!item)
         continue;
       if (is_item_removed_(item.get()) &&
-          this->matches_item_(item, component, name_cstr, SchedulerItem::TIMEOUT, match_retry,
-                              /* skip_removed= */ false)) {
+          this->matches_item_locked_(item, component, name_cstr, SchedulerItem::TIMEOUT, match_retry,
+                                     /* skip_removed= */ false)) {
         return true;
       }
     }

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/component_tests/ota/test_web_server_ota.py

@@ -1,6 +1,18 @@
 """Tests for the web_server OTA platform."""
 
+from __future__ import annotations
+
 from collections.abc import Callable
+import logging
+from typing import Any
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components.web_server.ota import _web_server_ota_final_validate
+from esphome.const import CONF_ID, CONF_OTA, CONF_PLATFORM, CONF_WEB_SERVER
+from esphome.core import ID
+import esphome.final_validate as fv
 
 
 def test_web_server_ota_generated(generate_main: Callable[[str], str]) -> None:
@@ -100,3 +112,144 @@ def test_web_server_ota_esp8266(generate_main: Callable[[str], str]) -> None:
     # Check web server OTA component is present
     assert "WebServerOTAComponent" in main_cpp
     assert "web_server::WebServerOTAComponent" in main_cpp
+
+
+@pytest.mark.parametrize(
+    ("ota_configs", "expected_count", "warning_expected"),
+    [
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web", is_manual=False),
+                }
+            ],
+            1,
+            False,
+            id="single_instance_no_merge",
+        ),
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web_1", is_manual=False),
+                },
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web_2", is_manual=False),
+                },
+            ],
+            1,
+            True,
+            id="two_instances_merged",
+        ),
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web_1", is_manual=False),
+                },
+                {
+                    CONF_PLATFORM: "esphome",
+                    CONF_ID: ID("ota_esphome", is_manual=False),
+                },
+                {
+                    CONF_PLATFORM: CONF_WEB_SERVER,
+                    CONF_ID: ID("ota_web_2", is_manual=False),
+                },
+            ],
+            2,
+            True,
+            id="mixed_platforms_web_server_merged",
+        ),
+    ],
+)
+def test_web_server_ota_instance_merging(
+    ota_configs: list[dict[str, Any]],
+    expected_count: int,
+    warning_expected: bool,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test web_server OTA instance merging behavior."""
+    full_conf = {CONF_OTA: ota_configs.copy()}
+
+    token = fv.full_config.set(full_conf)
+    try:
+        with caplog.at_level(logging.WARNING):
+            _web_server_ota_final_validate({})
+
+        updated_conf = fv.full_config.get()
+
+        # Verify total number of OTA platforms
+        assert len(updated_conf[CONF_OTA]) == expected_count
+
+        # Verify warning
+        if warning_expected:
+            assert any(
+                "Found and merged" in record.message
+                and "web_server OTA" in record.message
+                for record in caplog.records
+            ), "Expected merge warning not found in log"
+        else:
+            assert len(caplog.records) == 0, "Unexpected warnings logged"
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_web_server_ota_consistent_manual_ids(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that consistent manual IDs can be merged successfully."""
+    ota_configs = [
+        {
+            CONF_PLATFORM: CONF_WEB_SERVER,
+            CONF_ID: ID("ota_web", is_manual=True),
+        },
+        {
+            CONF_PLATFORM: CONF_WEB_SERVER,
+            CONF_ID: ID("ota_web", is_manual=True),
+        },
+    ]
+
+    full_conf = {CONF_OTA: ota_configs}
+
+    token = fv.full_config.set(full_conf)
+    try:
+        with caplog.at_level(logging.WARNING):
+            _web_server_ota_final_validate({})
+
+        updated_conf = fv.full_config.get()
+        assert len(updated_conf[CONF_OTA]) == 1
+        assert updated_conf[CONF_OTA][0][CONF_ID].id == "ota_web"
+        assert any(
+            "Found and merged" in record.message and "web_server OTA" in record.message
+            for record in caplog.records
+        )
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_web_server_ota_inconsistent_manual_ids() -> None:
+    """Test that inconsistent manual IDs raise an error."""
+    ota_configs = [
+        {
+            CONF_PLATFORM: CONF_WEB_SERVER,
+            CONF_ID: ID("ota_web_1", is_manual=True),
+        },
+        {
+            CONF_PLATFORM: CONF_WEB_SERVER,
+            CONF_ID: ID("ota_web_2", is_manual=True),
+        },
+    ]
+
+    full_conf = {CONF_OTA: ota_configs}
+
+    token = fv.full_config.set(full_conf)
+    try:
+        with pytest.raises(
+            cv.Invalid,
+            match="Found multiple web_server OTA configurations but id is inconsistent",
+        ):
+            _web_server_ota_final_validate({})
+    finally:
+        fv.full_config.reset(token)

tests/component_tests/sntp/__init__.py

@@ -0,0 +1 @@
+"""Tests for SNTP component."""

tests/component_tests/sntp/config/sntp_test.yaml

@@ -0,0 +1,22 @@
+esphome:
+  name: sntp-test
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+
+wifi:
+  ssid: "testssid"
+  password: "testpassword"
+
+# Test multiple SNTP instances that should be merged
+time:
+  - platform: sntp
+    servers:
+      - 192.168.1.1
+      - pool.ntp.org
+  - platform: sntp
+    servers:
+      - pool.ntp.org
+      - 192.168.1.2

tests/component_tests/sntp/test_init.py

@@ -0,0 +1,238 @@
+"""Tests for SNTP time configuration validation."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components.sntp.time import CONF_SNTP, _sntp_final_validate
+from esphome.const import CONF_ID, CONF_PLATFORM, CONF_SERVERS, CONF_TIME
+from esphome.core import ID
+import esphome.final_validate as fv
+
+
+@pytest.mark.parametrize(
+    ("time_configs", "expected_count", "expected_servers", "warning_messages"),
+    [
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time", is_manual=False),
+                    CONF_SERVERS: ["192.168.1.1", "pool.ntp.org"],
+                }
+            ],
+            1,
+            ["192.168.1.1", "pool.ntp.org"],
+            [],
+            id="single_instance_no_merge",
+        ),
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time_1", is_manual=False),
+                    CONF_SERVERS: ["192.168.1.1", "pool.ntp.org"],
+                },
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time_2", is_manual=False),
+                    CONF_SERVERS: ["192.168.1.2"],
+                },
+            ],
+            1,
+            ["192.168.1.1", "pool.ntp.org", "192.168.1.2"],
+            ["Found and merged 2 SNTP time configurations into one instance"],
+            id="two_instances_merged",
+        ),
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time_1", is_manual=False),
+                    CONF_SERVERS: ["192.168.1.1", "pool.ntp.org"],
+                },
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time_2", is_manual=False),
+                    CONF_SERVERS: ["pool.ntp.org", "192.168.1.2"],
+                },
+            ],
+            1,
+            ["192.168.1.1", "pool.ntp.org", "192.168.1.2"],
+            ["Found and merged 2 SNTP time configurations into one instance"],
+            id="deduplication_preserves_order",
+        ),
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time_1", is_manual=False),
+                    CONF_SERVERS: ["192.168.1.1", "pool.ntp.org"],
+                },
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time_2", is_manual=False),
+                    CONF_SERVERS: ["192.168.1.2", "pool2.ntp.org"],
+                },
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time_3", is_manual=False),
+                    CONF_SERVERS: ["pool3.ntp.org"],
+                },
+            ],
+            1,
+            ["192.168.1.1", "pool.ntp.org", "192.168.1.2"],
+            [
+                "SNTP supports maximum 3 servers. Dropped excess server(s): ['pool2.ntp.org', 'pool3.ntp.org']",
+                "Found and merged 3 SNTP time configurations into one instance",
+            ],
+            id="three_instances_drops_excess_servers",
+        ),
+        pytest.param(
+            [
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time_1", is_manual=False),
+                    CONF_SERVERS: [
+                        "192.168.1.1",
+                        "pool.ntp.org",
+                        "pool.ntp.org",
+                        "192.168.1.1",
+                    ],
+                },
+                {
+                    CONF_PLATFORM: CONF_SNTP,
+                    CONF_ID: ID("sntp_time_2", is_manual=False),
+                    CONF_SERVERS: ["pool.ntp.org", "192.168.1.2"],
+                },
+            ],
+            1,
+            ["192.168.1.1", "pool.ntp.org", "192.168.1.2"],
+            ["Found and merged 2 SNTP time configurations into one instance"],
+            id="deduplication_multiple_duplicates",
+        ),
+    ],
+)
+def test_sntp_instance_merging(
+    time_configs: list[dict[str, Any]],
+    expected_count: int,
+    expected_servers: list[str],
+    warning_messages: list[str],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test SNTP instance merging behavior."""
+    # Create a mock full config with time configs
+    full_conf = {CONF_TIME: time_configs.copy()}
+
+    # Set the context var
+    token = fv.full_config.set(full_conf)
+    try:
+        with caplog.at_level(logging.WARNING):
+            _sntp_final_validate({})
+
+        # Get the updated config
+        updated_conf = fv.full_config.get()
+
+        # Check if merging occurred
+        if len(time_configs) > 1:
+            # Verify only one SNTP instance remains
+            sntp_instances = [
+                tc
+                for tc in updated_conf[CONF_TIME]
+                if tc.get(CONF_PLATFORM) == CONF_SNTP
+            ]
+            assert len(sntp_instances) == expected_count
+
+            # Verify server list
+            assert sntp_instances[0][CONF_SERVERS] == expected_servers
+
+            # Verify warnings
+            for expected_msg in warning_messages:
+                assert any(
+                    expected_msg in record.message for record in caplog.records
+                ), f"Expected warning message '{expected_msg}' not found in log"
+        else:
+            # Single instance should not trigger merging or warnings
+            assert len(caplog.records) == 0
+            # Config should be unchanged
+            assert updated_conf[CONF_TIME] == time_configs
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_sntp_inconsistent_manual_ids() -> None:
+    """Test that inconsistent manual IDs raise an error."""
+    # Create configs with manual IDs that are inconsistent
+    time_configs = [
+        {
+            CONF_PLATFORM: CONF_SNTP,
+            CONF_ID: ID("sntp_time_1", is_manual=True),
+            CONF_SERVERS: ["192.168.1.1"],
+        },
+        {
+            CONF_PLATFORM: CONF_SNTP,
+            CONF_ID: ID("sntp_time_2", is_manual=True),
+            CONF_SERVERS: ["192.168.1.2"],
+        },
+    ]
+
+    full_conf = {CONF_TIME: time_configs}
+
+    token = fv.full_config.set(full_conf)
+    try:
+        with pytest.raises(
+            cv.Invalid,
+            match="Found multiple SNTP configurations but id is inconsistent",
+        ):
+            _sntp_final_validate({})
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_sntp_with_other_time_platforms(caplog: pytest.LogCaptureFixture) -> None:
+    """Test that SNTP merging doesn't affect other time platforms."""
+    time_configs = [
+        {
+            CONF_PLATFORM: CONF_SNTP,
+            CONF_ID: ID("sntp_time_1", is_manual=False),
+            CONF_SERVERS: ["192.168.1.1"],
+        },
+        {
+            CONF_PLATFORM: "homeassistant",
+            CONF_ID: ID("homeassistant_time", is_manual=False),
+        },
+        {
+            CONF_PLATFORM: CONF_SNTP,
+            CONF_ID: ID("sntp_time_2", is_manual=False),
+            CONF_SERVERS: ["192.168.1.2"],
+        },
+    ]
+
+    full_conf = {CONF_TIME: time_configs.copy()}
+
+    token = fv.full_config.set(full_conf)
+    try:
+        with caplog.at_level(logging.WARNING):
+            _sntp_final_validate({})
+
+        updated_conf = fv.full_config.get()
+
+        # Should have 2 time platforms: 1 merged SNTP + 1 homeassistant
+        assert len(updated_conf[CONF_TIME]) == 2
+
+        # Find the platforms
+        platforms = {tc[CONF_PLATFORM] for tc in updated_conf[CONF_TIME]}
+        assert platforms == {CONF_SNTP, "homeassistant"}
+
+        # Verify SNTP was merged
+        sntp_instances = [
+            tc for tc in updated_conf[CONF_TIME] if tc[CONF_PLATFORM] == CONF_SNTP
+        ]
+        assert len(sntp_instances) == 1
+        assert sntp_instances[0][CONF_SERVERS] == ["192.168.1.1", "192.168.1.2"]
+    finally:
+        fv.full_config.reset(token)

tests/components/esp32/test.esp32-p4-idf.yaml

@@ -0,0 +1,27 @@
+esp32:
+  variant: esp32p4
+  flash_size: 32MB
+  cpu_frequency: 400MHz
+  framework:
+    type: esp-idf
+    advanced:
+      enable_idf_experimental_features: yes
+
+ota:
+  platform: esphome
+
+wifi:
+  ssid: MySSID
+  password: password1
+
+esp32_hosted:
+  variant: ESP32C6
+  slot: 1
+  active_high: true
+  reset_pin: GPIO15
+  cmd_pin: GPIO13
+  clk_pin: GPIO12
+  d0_pin: GPIO11
+  d1_pin: GPIO10
+  d2_pin: GPIO9
+  d3_pin: GPIO8

tests/components/esphome/common.yaml

@@ -2,6 +2,9 @@ esphome:
   debug_scheduler: true
   platformio_options:
     board_build.flash_mode: dio
+  environment_variables:
+    TEST_ENV_VAR: "test_value"
+    BUILD_NUMBER: "12345"
   area:
     id: testing_area
     name: Testing Area

tests/components/lvgl/common.yaml

@@ -115,8 +115,8 @@ wifi:
   password: PASSWORD123
 
 time:
-  platform: sntp
-  id: time_id
+  - platform: sntp
+    id: sntp_time
 
 text:
   - id: lvgl_text

tests/components/lvgl/lvgl-package.yaml

@@ -478,19 +478,19 @@ lvgl:
                   id: hello_label
                   text:
                     time_format: "%c"
-                    time: time_id
+                    time: sntp_time
               - lvgl.label.update:
                   id: hello_label
                   text:
                     time_format: "%c"
-                    time: !lambda return id(time_id).now();
+                    time: !lambda return id(sntp_time).now();
               - lvgl.label.update:
                   id: hello_label
                   text:
                     time_format: "%c"
                     time: !lambda |-
                         ESP_LOGD("label", "multi-line lambda");
-                        return id(time_id).now();
+                        return id(sntp_time).now();
             on_value:
               logger.log:
                 format: "state now %d"
@@ -703,7 +703,9 @@ lvgl:
             on_value:
               - lvgl.spinbox.update:
                   id: spinbox_id
-                  value: !lambda return x;
+                  value: !lambda |-
+                      static float yyy = 83.0;
+                      return yyy + .8;
         - button:
             styles: spin_button
             id: spin_up

tests/components/mqtt/common.yaml

@@ -4,6 +4,7 @@ wifi:
 
 time:
   - platform: sntp
+    id: sntp_time
 
 mqtt:
   broker: "192.168.178.84"

tests/components/uptime/common.yaml

@@ -3,6 +3,7 @@ wifi:
 
 time:
   - platform: sntp
+    id: sntp_time
 
 sensor:
   - platform: uptime

tests/components/wireguard/common.yaml

@@ -4,8 +4,10 @@ wifi:
 
 time:
   - platform: sntp
+    id: sntp_time
 
 wireguard:
+  time_id: sntp_time
   address: 172.16.34.100
   netmask: 255.255.255.0
   # NEVER use the following keys for your VPN -- they are now public!

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/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_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,