still de-dupe

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           category: "/language:${{matrix.language}}"

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.5
+    rev: v0.14.4
     hooks:
       # Run the linter.
       - id: ruff

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.12.0-dev
+PROJECT_NUMBER         = 2025.11.0b1
 
 # 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/components/api/api_connection.cpp

@@ -476,9 +476,8 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
   auto *light = static_cast<light::LightState *>(entity);
   ListEntitiesLightResponse msg;
   auto traits = light->get_traits();
-  auto supported_modes = traits.get_supported_color_modes();
   // Pass pointer to ColorModeMask so the iterator can encode actual ColorMode enum values
-  msg.supported_color_modes = &supported_modes;
+  msg.supported_color_modes = &traits.get_supported_color_modes();
   if (traits.supports_color_capability(light::ColorCapability::COLOR_TEMPERATURE) ||
       traits.supports_color_capability(light::ColorCapability::COLD_WARM_WHITE)) {
     msg.min_mireds = traits.get_min_mireds();
@@ -1296,8 +1295,8 @@ void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRe
 
 #ifdef USE_EVENT
 void APIConnection::send_event(event::Event *event, const char *event_type) {
-  this->send_message_smart_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
-                            EventResponse::ESTIMATED_SIZE);
+  this->schedule_message_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
+                          EventResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_event_response(event::Event *event, const char *event_type, APIConnection *conn,
                                                 uint32_t remaining_size, bool is_single) {

esphome/components/api/api_connection.h

@@ -650,30 +650,21 @@ class APIConnection final : public APIServerConnection {
   }
 #endif
 
-  // Helper to check if a message type should bypass batching
-  // Returns true if:
-  // 1. It's an UpdateStateResponse (always send immediately to handle cases where
-  //    the main loop is blocked, e.g., during OTA updates)
-  // 2. It's an EventResponse (events are edge-triggered - every occurrence matters)
-  // 3. OR: User has opted into immediate sending (should_try_send_immediately = true
-  //    AND batch_delay = 0)
-  inline bool should_send_immediately_(uint8_t message_type) const {
-    return (
-#ifdef USE_UPDATE
-        message_type == UpdateStateResponse::MESSAGE_TYPE ||
-#endif
-#ifdef USE_EVENT
-        message_type == EventResponse::MESSAGE_TYPE ||
-#endif
-        (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0));
-  }
-
   // Helper method to send a message either immediately or via batching
-  // Tries immediate send if should_send_immediately_() returns true and buffer has space
-  // Falls back to batching if immediate send fails or isn't applicable
   bool send_message_smart_(EntityBase *entity, MessageCreatorPtr creator, uint8_t message_type,
                            uint8_t estimated_size) {
-    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
+    // Try to send immediately if:
+    // 1. It's an UpdateStateResponse (always send immediately to handle cases where
+    //    the main loop is blocked, e.g., during OTA updates)
+    // 2. OR: We should try to send immediately (should_try_send_immediately = true)
+    //        AND Batch delay is 0 (user has opted in to immediate sending)
+    // 3. AND: Buffer has space available
+    if ((
+#ifdef USE_UPDATE
+            message_type == UpdateStateResponse::MESSAGE_TYPE ||
+#endif
+            (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0)) &&
+        this->helper_->can_write_without_blocking()) {
       // Now actually encode and send
       if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true) &&
           this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
@@ -691,27 +682,6 @@ class APIConnection final : public APIServerConnection {
     return this->schedule_message_(entity, creator, message_type, estimated_size);
   }
 
-  // Overload for MessageCreator (used by events which need to capture event_type)
-  bool send_message_smart_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
-    // Try to send immediately if message type should bypass batching and buffer has space
-    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
-      // Now actually encode and send
-      if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true, message_type) &&
-          this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
-#ifdef HAS_PROTO_MESSAGE_DUMP
-        // Log the message in verbose mode
-        this->log_proto_message_(entity, creator, message_type);
-#endif
-        return true;
-      }
-
-      // If immediate send failed, fall through to batching
-    }
-
-    // Fall back to scheduled batching
-    return this->schedule_message_(entity, std::move(creator), message_type, estimated_size);
-  }
-
   // Helper function to schedule a deferred message with known message type
   bool schedule_message_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
     this->deferred_batch_.add_item(entity, std::move(creator), message_type, estimated_size);

esphome/components/api/user_services.h

@@ -51,14 +51,13 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
       return false;
     if (req.args.size() != sizeof...(Ts))
       return false;
-    this->execute_(req.args, std::make_index_sequence<sizeof...(Ts)>{});
+    this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
     return true;
   }
 
  protected:
   virtual void execute(Ts... x) = 0;
-  template<typename ArgsContainer, size_t... S>
-  void execute_(const ArgsContainer &args, std::index_sequence<S...> type) {
+  template<typename ArgsContainer, int... S> void execute_(const ArgsContainer &args, seq<S...> type) {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 
@@ -96,14 +95,13 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
       return false;
     if (req.args.size() != sizeof...(Ts))
       return false;
-    this->execute_(req.args, std::make_index_sequence<sizeof...(Ts)>{});
+    this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
     return true;
   }
 
  protected:
   virtual void execute(Ts... x) = 0;
-  template<typename ArgsContainer, size_t... S>
-  void execute_(const ArgsContainer &args, std::index_sequence<S...> type) {
+  template<typename ArgsContainer, int... S> void execute_(const ArgsContainer &args, seq<S...> type) {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 

esphome/components/esp32/__init__.py

@@ -381,9 +381,8 @@ PLATFORM_VERSION_LOOKUP = {
 }
 
 
-def _check_versions(config):
-    config = config.copy()
-    value = config[CONF_FRAMEWORK]
+def _check_versions(value):
+    value = value.copy()
 
     if value[CONF_VERSION] in PLATFORM_VERSION_LOOKUP:
         if CONF_SOURCE in value or CONF_PLATFORM_VERSION in value:
@@ -448,7 +447,7 @@ def _check_versions(config):
             "If there are connectivity or build issues please remove the manual version."
         )
 
-    return config
+    return value
 
 
 def _parse_platform_version(value):
@@ -498,8 +497,6 @@ 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"
@@ -516,14 +513,22 @@ def final_validate(config):
                     f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
                 )
             )
-    if config[CONF_VARIANT] != VARIANT_ESP32 and advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
+    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]
+    ):
         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 advanced[CONF_EXECUTE_FROM_PSRAM]:
+    if (
+        config.get(CONF_FRAMEWORK, {})
+        .get(CONF_ADVANCED, {})
+        .get(CONF_EXECUTE_FROM_PSRAM)
+    ):
         if config[CONF_VARIANT] != VARIANT_ESP32S3:
             errs.append(
                 cv.Invalid(
@@ -539,17 +544,6 @@ 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)
 
@@ -604,74 +598,89 @@ def _validate_idf_component(config: ConfigType) -> ConfigType:
 
 FRAMEWORK_ESP_IDF = "esp-idf"
 FRAMEWORK_ARDUINO = "arduino"
-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,
-            )
-        ),
-    }
+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,
 )
 
 
@@ -734,11 +743,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[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
-    if CONF_TYPE not in config[CONF_FRAMEWORK]:
+        config = config.copy()
+
         variant = config[CONF_VARIANT]
+        config[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
         if variant in ARDUINO_ALLOWED_VARIANTS:
             config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ARDUINO
             _show_framework_migration_message(
@@ -778,7 +787,6 @@ CONFIG_SCHEMA = cv.All(
     ),
     _detect_variant,
     _set_default_framework,
-    _check_versions,
     set_core_data,
     cv.has_at_least_one_key(CONF_BOARD, CONF_VARIANT),
 )
@@ -797,7 +805,9 @@ 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[CONF_SDKCONFIG_OPTIONS].get("CONFIG_LWIP_MAX_SOCKETS")
+    user_max_sockets = conf.get(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())
@@ -967,18 +977,23 @@ 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 advanced.get(CONF_ENABLE_LWIP_DHCP_SERVER) is False and not (
-        conf[CONF_TYPE] == FRAMEWORK_ARDUINO and "ethernet" in CORE.loaded_integrations
+    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
+        )
     ):
         add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
-    if not advanced[CONF_ENABLE_LWIP_MDNS_QUERIES]:
+    if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, True):
         add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
-    if not advanced[CONF_ENABLE_LWIP_BRIDGE_INTERFACE]:
+    if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
         add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
 
     _configure_lwip_max_sockets(conf)
 
-    if advanced[CONF_EXECUTE_FROM_PSRAM]:
+    if advanced.get(CONF_EXECUTE_FROM_PSRAM, False):
         add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True)
         add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True)
 
@@ -989,22 +1004,23 @@ 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[CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING]:
+    if advanced.get(CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, True):
         add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_CORE_LOCKING", True)
-    if advanced[CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY]:
+    if advanced.get(CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, True):
         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[CONF_DISABLE_LIBC_LOCKS_IN_IRAM]:
+    if advanced.get(CONF_DISABLE_LIBC_LOCKS_IN_IRAM, True):
         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[CONF_DISABLE_VFS_SUPPORT_TERMIOS]
+        "CONFIG_VFS_SUPPORT_TERMIOS",
+        not advanced.get(CONF_DISABLE_VFS_SUPPORT_TERMIOS, True),
     )
 
     # Disable VFS support for select() with file descriptors
@@ -1018,7 +1034,8 @@ 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[CONF_DISABLE_VFS_SUPPORT_SELECT]
+            "CONFIG_VFS_SUPPORT_SELECT",
+            not advanced.get(CONF_DISABLE_VFS_SUPPORT_SELECT, True),
         )
 
     # Disable VFS support for directory functions (opendir, readdir, mkdir, etc.)
@@ -1031,7 +1048,8 @@ 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[CONF_DISABLE_VFS_SUPPORT_DIR]
+            "CONFIG_VFS_SUPPORT_DIR",
+            not advanced.get(CONF_DISABLE_VFS_SUPPORT_DIR, True),
         )
 
     cg.add_platformio_option("board_build.partitions", "partitions.csv")
@@ -1045,7 +1063,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[CONF_COMPILER_OPTIMIZATION]
+    compiler_optimization = advanced.get(CONF_COMPILER_OPTIMIZATION)
     for key, flag in COMPILER_OPTIMIZATIONS.items():
         add_idf_sdkconfig_option(flag, compiler_optimization == key)
 
@@ -1054,20 +1072,18 @@ async def to_code(config):
         conf[CONF_ADVANCED][CONF_ENABLE_LWIP_ASSERT],
     )
 
-    if advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
+    if advanced.get(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[CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES]:
+    if advanced.get(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[CONF_LOOP_TASK_STACK_SIZE])
+    cg.add_define(
+        "ESPHOME_LOOP_TASK_STACK_SIZE", advanced.get(CONF_LOOP_TASK_STACK_SIZE)
+    )
 
     cg.add_define(
         "USE_ESP_IDF_VERSION_CODE",

esphome/components/ethernet/ethernet_component.cpp

@@ -381,10 +381,7 @@ void EthernetComponent::dump_config() {
       break;
   }
 
-  ESP_LOGCONFIG(TAG,
-                "Ethernet:\n"
-                "  Connected: %s",
-                YESNO(this->is_connected()));
+  ESP_LOGCONFIG(TAG, "Ethernet:");
   this->dump_connect_params_();
 #ifdef USE_ETHERNET_SPI
   ESP_LOGCONFIG(TAG,

esphome/components/ld2450/ld2450.cpp

@@ -181,6 +181,17 @@ static inline bool validate_header_footer(const uint8_t *header_footer, const ui
   return std::memcmp(header_footer, buffer, HEADER_FOOTER_SIZE) == 0;
 }
 
+// Helper function to calculate direction based on speed
+static inline Direction calculate_direction(int16_t speed) {
+  if (speed > 0) {
+    return DIRECTION_MOVING_AWAY;
+  }
+  if (speed < 0) {
+    return DIRECTION_APPROACHING;
+  }
+  return DIRECTION_STATIONARY;
+}
+
 void LD2450Component::setup() {
 #ifdef USE_NUMBER
   if (this->presence_timeout_number_ != nullptr) {
@@ -293,6 +304,51 @@ uint8_t LD2450Component::count_targets_in_zone_(const Zone &zone, bool is_moving
   return count;
 }
 
+// Store target info for zone target counting
+void LD2450Component::set_target_info_(uint8_t index, int16_t x, int16_t y, bool is_moving) {
+  this->target_info_[index].x = x;
+  this->target_info_[index].y = y;
+  this->target_info_[index].is_moving = is_moving;
+}
+
+#ifdef USE_TEXT_SENSOR
+// Publish direction text sensor with deduplication
+void LD2450Component::publish_direction_(uint8_t index, Direction direction) {
+  text_sensor::TextSensor *sensor = this->direction_text_sensors_[index];
+  if (sensor == nullptr) {
+    return;
+  }
+  const auto *dir_str = find_str(ld2450::DIRECTION_BY_UINT, direction);
+  if (!sensor->has_state() || sensor->get_state() != dir_str) {
+    sensor->publish_state(dir_str);
+  }
+}
+#endif
+
+#ifdef USE_SENSOR
+// Publish all target sensor values with deduplication
+void LD2450Component::publish_target_sensors_(uint8_t index, int16_t x, int16_t y, uint16_t resolution, int16_t speed,
+                                              uint16_t distance, float angle) {
+  SAFE_PUBLISH_SENSOR(this->move_x_sensors_[index], x);
+  SAFE_PUBLISH_SENSOR(this->move_y_sensors_[index], y);
+  SAFE_PUBLISH_SENSOR(this->move_resolution_sensors_[index], resolution);
+  SAFE_PUBLISH_SENSOR(this->move_speed_sensors_[index], speed);
+  SAFE_PUBLISH_SENSOR(this->move_distance_sensors_[index], distance);
+  SAFE_PUBLISH_SENSOR(this->move_angle_sensors_[index], angle);
+}
+
+// Force clear all target sensor values to 0, bypassing throttle but still using deduplication
+void LD2450Component::force_clear_target_sensors_(uint8_t index) {
+  // Use publish_state() to bypass throttle filters, with manual dedup check
+  SAFE_PUBLISH_SENSOR_WITHOUT_FILTERS(this->move_x_sensors_[index], 0);
+  SAFE_PUBLISH_SENSOR_WITHOUT_FILTERS(this->move_y_sensors_[index], 0);
+  SAFE_PUBLISH_SENSOR_WITHOUT_FILTERS(this->move_resolution_sensors_[index], 0);
+  SAFE_PUBLISH_SENSOR_WITHOUT_FILTERS(this->move_speed_sensors_[index], 0);
+  SAFE_PUBLISH_SENSOR_WITHOUT_FILTERS(this->move_distance_sensors_[index], 0);
+  SAFE_PUBLISH_SENSOR_WITHOUT_FILTERS(this->move_angle_sensors_[index], 0);
+}
+#endif
+
 // Service reset_radar_zone
 void LD2450Component::reset_radar_zone() {
   this->zone_type_ = 0;
@@ -444,13 +500,13 @@ void LD2450Component::handle_periodic_data_() {
   int16_t target_count = 0;
   int16_t still_target_count = 0;
   int16_t moving_target_count = 0;
-  int16_t res = 0;
-  int16_t start = 0;
-  int16_t tx = 0;
-  int16_t ty = 0;
-  int16_t td = 0;
-  int16_t ts = 0;
-  int16_t angle = 0;
+  int16_t res = 0;    // Target resolution in mm
+  int16_t start = 0;  // Buffer offset for current data field
+  int16_t tx = 0;     // Target X coordinate in mm
+  int16_t ty = 0;     // Target Y coordinate in mm
+  int16_t td = 0;     // Target distance in mm (calculated from tx and ty)
+  int16_t ts = 0;     // Target speed in mm/s
+  int16_t angle = 0;  // Target angle in degrees
   uint8_t index = 0;
   Direction direction{DIRECTION_UNDEFINED};
   bool is_moving = false;
@@ -464,15 +520,12 @@ void LD2450Component::handle_periodic_data_() {
     is_moving = false;
     // tx is used for further calculations, so always needs to be populated
     tx = ld2450::decode_coordinate(this->buffer_data_[start], this->buffer_data_[start + 1]);
-    SAFE_PUBLISH_SENSOR(this->move_x_sensors_[index], tx);
     // Y
     start = TARGET_Y + index * 8;
     ty = ld2450::decode_coordinate(this->buffer_data_[start], this->buffer_data_[start + 1]);
-    SAFE_PUBLISH_SENSOR(this->move_y_sensors_[index], ty);
     // RESOLUTION
     start = TARGET_RESOLUTION + index * 8;
     res = (this->buffer_data_[start + 1] << 8) | this->buffer_data_[start];
-    SAFE_PUBLISH_SENSOR(this->move_resolution_sensors_[index], res);
 #endif
     // SPEED
     start = TARGET_SPEED + index * 8;
@@ -481,48 +534,43 @@ void LD2450Component::handle_periodic_data_() {
       is_moving = true;
       moving_target_count++;
     }
-#ifdef USE_SENSOR
-    SAFE_PUBLISH_SENSOR(this->move_speed_sensors_[index], ts);
-#endif
-    // DISTANCE
+    // DISTANCE (td = target distance in mm, calculated from X and Y coordinates)
     // Optimized: use already decoded tx and ty values, replace pow() with multiplication
     int32_t x_squared = (int32_t) tx * tx;
     int32_t y_squared = (int32_t) ty * ty;
-    td = (uint16_t) sqrtf(x_squared + y_squared);
-    if (td > 0) {
+    td = (uint16_t) sqrtf(x_squared + y_squared);  // Pythagorean theorem: distance = sqrt(x² + y²)
+
+    // Only publish sensor values when a target is actually detected (resolution > 0)
+    // The radar sets resolution=0 when no target is present, even if X/Y coordinates
+    // haven't been cleared from the buffer yet. This prevents stale/ghost readings.
+    if (res > 0) {
       target_count++;
-    }
 #ifdef USE_SENSOR
-    SAFE_PUBLISH_SENSOR(this->move_distance_sensors_[index], td);
-    // ANGLE
-    angle = ld2450::calculate_angle(static_cast<float>(ty), static_cast<float>(td));
-    if (tx > 0) {
-      angle = angle * -1;
-    }
-    SAFE_PUBLISH_SENSOR(this->move_angle_sensors_[index], angle);
+      // ANGLE
+      angle = ld2450::calculate_angle(static_cast<float>(ty), static_cast<float>(td));
+      if (tx > 0) {
+        angle = angle * -1;
+      }
+      this->publish_target_sensors_(index, tx, ty, res, ts, td, angle);
 #endif
 #ifdef USE_TEXT_SENSOR
-    // DIRECTION
-    if (td == 0) {
-      direction = DIRECTION_NA;
-    } else if (ts > 0) {
-      direction = DIRECTION_MOVING_AWAY;
-    } else if (ts < 0) {
-      direction = DIRECTION_APPROACHING;
-    } else {
-      direction = DIRECTION_STATIONARY;
-    }
-    text_sensor::TextSensor *tsd = this->direction_text_sensors_[index];
-    const auto *dir_str = find_str(ld2450::DIRECTION_BY_UINT, direction);
-    if (tsd != nullptr && (!tsd->has_state() || tsd->get_state() != dir_str)) {
-      tsd->publish_state(dir_str);
-    }
+      // DIRECTION
+      this->publish_direction_(index, calculate_direction(ts));
 #endif
-
-    // Store target info for zone target count
-    this->target_info_[index].x = tx;
-    this->target_info_[index].y = ty;
-    this->target_info_[index].is_moving = is_moving;
+      // Store target info for zone target count
+      this->set_target_info_(index, tx, ty, is_moving);
+    } else {
+      // No target detected - force clear all sensor values to 0, bypassing throttle/dedup
+#ifdef USE_SENSOR
+      this->force_clear_target_sensors_(index);
+#endif
+#ifdef USE_TEXT_SENSOR
+      // Set direction to NA when no target
+      this->publish_direction_(index, DIRECTION_NA);
+#endif
+      // Clear target info
+      this->set_target_info_(index, /* x= */ 0, /* y= */ 0, /* is_moving= */ false);
+    }
 
   }  // End loop thru targets
 

esphome/components/ld2450/ld2450.h

@@ -159,6 +159,15 @@ class LD2450Component : public Component, public uart::UARTDevice {
   float restore_from_flash_();
   bool get_timeout_status_(uint32_t check_millis);
   uint8_t count_targets_in_zone_(const Zone &zone, bool is_moving);
+  void set_target_info_(uint8_t index, int16_t x, int16_t y, bool is_moving);
+#ifdef USE_SENSOR
+  void publish_target_sensors_(uint8_t index, int16_t x, int16_t y, uint16_t resolution, int16_t speed,
+                               uint16_t distance, float angle);
+  void force_clear_target_sensors_(uint8_t index);
+#endif
+#ifdef USE_TEXT_SENSOR
+  void publish_direction_(uint8_t index, Direction direction);
+#endif
 
   uint32_t presence_millis_ = 0;
   uint32_t still_presence_millis_ = 0;

esphome/components/ld24xx/ld24xx.h

@@ -33,6 +33,13 @@
     (sensor)->publish_state_unknown(); \
   }
 
+#define SAFE_PUBLISH_SENSOR_WITHOUT_FILTERS(sensor, value) \
+  if ((sensor) != nullptr && (sensor)->sens->state != static_cast<float>(value)) { \
+    (sensor)->publish_dedup.next(value); \
+    (sensor)->sens->raw_state = static_cast<float>(value); \
+    (sensor)->sens->internal_send_state_to_frontend(static_cast<float>(value)); \
+  }
+
 #define highbyte(val) (uint8_t)((val) >> 8)
 #define lowbyte(val) (uint8_t)((val) &0xff)
 

esphome/components/light/light_call.cpp

@@ -52,10 +52,8 @@ 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::ON_OFF)
-    return LOG_STR("On/Off");
-  if (color_mode == ColorMode::BRIGHTNESS)
-    return LOG_STR("Brightness");
+  if (color_mode == ColorMode::UNKNOWN)
+    return LOG_STR("Unknown");
   if (color_mode == ColorMode::WHITE)
     return LOG_STR("White");
   if (color_mode == ColorMode::COLOR_TEMPERATURE)
@@ -70,7 +68,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("Unknown");
+  return LOG_STR("");
 }
 
 // Helper to log percentage values
@@ -408,7 +406,7 @@ void LightCall::transform_parameters_() {
   }
 }
 ColorMode LightCall::compute_color_mode_() {
-  auto supported_modes = this->parent_->get_traits().get_supported_color_modes();
+  const auto &supported_modes = this->parent_->get_traits().get_supported_color_modes();
   int supported_count = supported_modes.size();
 
   // Some lights don't support any color modes (e.g. monochromatic light), leave it at unknown.

esphome/components/light/light_traits.h

@@ -18,8 +18,7 @@ class LightTraits {
  public:
   LightTraits() = default;
 
-  // Return by value to avoid dangling reference when get_traits() returns a temporary
-  ColorModeMask get_supported_color_modes() const { return this->supported_color_modes_; }
+  const ColorModeMask &get_supported_color_modes() const { return this->supported_color_modes_; }
   void set_supported_color_modes(ColorModeMask supported_color_modes) {
     this->supported_color_modes_ = supported_color_modes;
   }

esphome/components/nrf52/__init__.py

@@ -103,7 +103,6 @@ nrf52_ns = cg.esphome_ns.namespace("nrf52")
 DeviceFirmwareUpdate = nrf52_ns.class_("DeviceFirmwareUpdate", cg.Component)
 
 CONF_DFU = "dfu"
-CONF_DCDC = "dcdc"
 CONF_REG0 = "reg0"
 CONF_UICR_ERASE = "uicr_erase"
 
@@ -122,7 +121,6 @@ CONFIG_SCHEMA = cv.All(
                     cv.Required(CONF_RESET_PIN): pins.gpio_output_pin_schema,
                 }
             ),
-            cv.Optional(CONF_DCDC, default=True): cv.boolean,
             cv.Optional(CONF_REG0): cv.Schema(
                 {
                     cv.Required(CONF_VOLTAGE): cv.All(
@@ -198,7 +196,6 @@ async def to_code(config: ConfigType) -> None:
 
     if dfu_config := config.get(CONF_DFU):
         CORE.add_job(_dfu_to_code, dfu_config)
-    zephyr_add_prj_conf("BOARD_ENABLE_DCDC", config[CONF_DCDC])
 
     if reg0_config := config.get(CONF_REG0):
         value = VOLTAGE_LEVELS.index(reg0_config[CONF_VOLTAGE])

esphome/components/script/script.h

@@ -46,14 +46,14 @@ template<typename... Ts> class Script : public ScriptLogger, public Trigger<Ts..
 
   // execute this script using a tuple that contains the arguments
   void execute_tuple(const std::tuple<Ts...> &tuple) {
-    this->execute_tuple_(tuple, std::make_index_sequence<sizeof...(Ts)>{});
+    this->execute_tuple_(tuple, typename gens<sizeof...(Ts)>::type());
   }
 
   // Internal function to give scripts readable names.
   void set_name(const LogString *name) { name_ = name; }
 
  protected:
-  template<size_t... S> void execute_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+  template<int... S> void execute_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     this->execute(std::get<S>(tuple)...);
   }
 
@@ -157,7 +157,7 @@ template<typename... Ts> class QueueingScript : public Script<Ts...>, public Com
       const size_t queue_capacity = static_cast<size_t>(this->max_runs_ - 1);
       auto tuple_ptr = std::move(this->var_queue_[this->queue_front_]);
       this->queue_front_ = (this->queue_front_ + 1) % queue_capacity;
-      this->trigger_tuple_(*tuple_ptr, std::make_index_sequence<sizeof...(Ts)>{});
+      this->trigger_tuple_(*tuple_ptr, typename gens<sizeof...(Ts)>::type());
     }
   }
 
@@ -174,7 +174,7 @@ template<typename... Ts> class QueueingScript : public Script<Ts...>, public Com
     }
   }
 
-  template<size_t... S> void trigger_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+  template<int... S> void trigger_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     this->trigger(std::get<S>(tuple)...);
   }
 
@@ -305,7 +305,7 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
 
     while (!this->param_queue_.empty()) {
       auto &params = this->param_queue_.front();
-      this->play_next_tuple_(params, std::make_index_sequence<sizeof...(Ts)>{});
+      this->play_next_tuple_(params, typename gens<sizeof...(Ts)>::type());
       this->param_queue_.pop_front();
     }
     // Queue is now empty - disable loop until next play_complex
@@ -321,7 +321,7 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
   }
 
  protected:
-  template<size_t... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+  template<int... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     this->play_next_(std::get<S>(tuple)...);
   }
 

esphome/components/thermostat/climate.py

@@ -945,10 +945,6 @@ async def to_code(config):
     cg.add(var.set_humidity_hysteresis(config[CONF_HUMIDITY_HYSTERESIS]))
 
     if CONF_PRESET in config:
-        # Separate standard and custom presets, and build preset config variables
-        standard_presets: list[tuple[cg.MockObj, cg.MockObj]] = []
-        custom_presets: list[tuple[str, cg.MockObj]] = []
-
         for preset_config in config[CONF_PRESET]:
             name = preset_config[CONF_NAME]
             standard_preset = None
@@ -991,39 +987,9 @@ async def to_code(config):
                 )
 
             if standard_preset is not None:
-                standard_presets.append((standard_preset, preset_target_variable))
+                cg.add(var.set_preset_config(standard_preset, preset_target_variable))
             else:
-                custom_presets.append((name, preset_target_variable))
-
-        # Build initializer list for standard presets
-        if standard_presets:
-            cg.add(
-                var.set_preset_config(
-                    [
-                        cg.StructInitializer(
-                            thermostat_ns.struct("ThermostatPresetEntry"),
-                            ("preset", preset),
-                            ("config", preset_var),
-                        )
-                        for preset, preset_var in standard_presets
-                    ]
-                )
-            )
-
-        # Build initializer list for custom presets
-        if custom_presets:
-            cg.add(
-                var.set_custom_preset_config(
-                    [
-                        cg.StructInitializer(
-                            thermostat_ns.struct("ThermostatCustomPresetEntry"),
-                            ("name", cg.RawExpression(f'"{name}"')),
-                            ("config", preset_var),
-                        )
-                        for name, preset_var in custom_presets
-                    ]
-                )
-            )
+                cg.add(var.set_custom_preset_config(name, preset_target_variable))
 
     if CONF_DEFAULT_PRESET in config:
         default_preset_name = config[CONF_DEFAULT_PRESET]

esphome/components/thermostat/thermostat_climate.cpp

@@ -53,8 +53,8 @@ void ThermostatClimate::setup() {
   if (use_default_preset) {
     if (this->default_preset_ != climate::ClimatePreset::CLIMATE_PRESET_NONE) {
       this->change_preset_(this->default_preset_);
-    } else if (this->default_custom_preset_ != nullptr) {
-      this->change_custom_preset_(this->default_custom_preset_);
+    } else if (!this->default_custom_preset_.empty()) {
+      this->change_custom_preset_(this->default_custom_preset_.c_str());
     }
   }
 
@@ -319,16 +319,16 @@ climate::ClimateTraits ThermostatClimate::traits() {
   if (this->supports_swing_mode_vertical_)
     traits.add_supported_swing_mode(climate::CLIMATE_SWING_VERTICAL);
 
-  for (const auto &entry : this->preset_config_) {
-    traits.add_supported_preset(entry.preset);
+  for (auto &it : this->preset_config_) {
+    traits.add_supported_preset(it.first);
   }
 
-  // Extract custom preset names from the custom_preset_config_ vector
+  // Extract custom preset names from the custom_preset_config_ map
   if (!this->custom_preset_config_.empty()) {
     std::vector<const char *> custom_preset_names;
     custom_preset_names.reserve(this->custom_preset_config_.size());
-    for (const auto &entry : this->custom_preset_config_) {
-      custom_preset_names.push_back(entry.name);
+    for (const auto &it : this->custom_preset_config_) {
+      custom_preset_names.push_back(it.first.c_str());
     }
     traits.set_supported_custom_presets(custom_preset_names);
   }
@@ -1154,18 +1154,12 @@ void ThermostatClimate::dump_preset_config_(const char *preset_name, const Therm
 }
 
 void ThermostatClimate::change_preset_(climate::ClimatePreset preset) {
-  // Linear search through preset configurations
-  const ThermostatClimateTargetTempConfig *config = nullptr;
-  for (const auto &entry : this->preset_config_) {
-    if (entry.preset == preset) {
-      config = &entry.config;
-      break;
-    }
-  }
+  auto config = this->preset_config_.find(preset);
 
-  if (config != nullptr) {
+  if (config != this->preset_config_.end()) {
     ESP_LOGV(TAG, "Preset %s requested", LOG_STR_ARG(climate::climate_preset_to_string(preset)));
-    if (this->change_preset_internal_(*config) || (!this->preset.has_value()) || this->preset.value() != preset) {
+    if (this->change_preset_internal_(config->second) || (!this->preset.has_value()) ||
+        this->preset.value() != preset) {
       // Fire any preset changed trigger if defined
       Trigger<> *trig = this->preset_change_trigger_;
       this->set_preset_(preset);
@@ -1184,18 +1178,11 @@ void ThermostatClimate::change_preset_(climate::ClimatePreset preset) {
 }
 
 void ThermostatClimate::change_custom_preset_(const char *custom_preset) {
-  // Linear search through custom preset configurations
-  const ThermostatClimateTargetTempConfig *config = nullptr;
-  for (const auto &entry : this->custom_preset_config_) {
-    if (strcmp(entry.name, custom_preset) == 0) {
-      config = &entry.config;
-      break;
-    }
-  }
+  auto config = this->custom_preset_config_.find(custom_preset);
 
-  if (config != nullptr) {
+  if (config != this->custom_preset_config_.end()) {
     ESP_LOGV(TAG, "Custom preset %s requested", custom_preset);
-    if (this->change_preset_internal_(*config) || !this->has_custom_preset() ||
+    if (this->change_preset_internal_(config->second) || !this->has_custom_preset() ||
         strcmp(this->get_custom_preset(), custom_preset) != 0) {
       // Fire any preset changed trigger if defined
       Trigger<> *trig = this->preset_change_trigger_;
@@ -1260,12 +1247,14 @@ bool ThermostatClimate::change_preset_internal_(const ThermostatClimateTargetTem
   return something_changed;
 }
 
-void ThermostatClimate::set_preset_config(std::initializer_list<PresetEntry> presets) {
-  this->preset_config_ = presets;
+void ThermostatClimate::set_preset_config(climate::ClimatePreset preset,
+                                          const ThermostatClimateTargetTempConfig &config) {
+  this->preset_config_[preset] = config;
 }
 
-void ThermostatClimate::set_custom_preset_config(std::initializer_list<CustomPresetEntry> presets) {
-  this->custom_preset_config_ = presets;
+void ThermostatClimate::set_custom_preset_config(const std::string &name,
+                                                 const ThermostatClimateTargetTempConfig &config) {
+  this->custom_preset_config_[name] = config;
 }
 
 ThermostatClimate::ThermostatClimate()
@@ -1304,16 +1293,8 @@ ThermostatClimate::ThermostatClimate()
       humidity_control_humidify_action_trigger_(new Trigger<>()),
       humidity_control_off_action_trigger_(new Trigger<>()) {}
 
-void ThermostatClimate::set_default_preset(const char *custom_preset) {
-  // Find the preset in custom_preset_config_ and store pointer from there
-  for (const auto &entry : this->custom_preset_config_) {
-    if (strcmp(entry.name, custom_preset) == 0) {
-      this->default_custom_preset_ = entry.name;
-      return;
-    }
-  }
-  // If not found, it will be caught during validation
-  this->default_custom_preset_ = nullptr;
+void ThermostatClimate::set_default_preset(const std::string &custom_preset) {
+  this->default_custom_preset_ = custom_preset;
 }
 
 void ThermostatClimate::set_default_preset(climate::ClimatePreset preset) { this->default_preset_ = preset; }
@@ -1624,22 +1605,19 @@ void ThermostatClimate::dump_config() {
 
   if (!this->preset_config_.empty()) {
     ESP_LOGCONFIG(TAG, "  Supported PRESETS:");
-    for (const auto &entry : this->preset_config_) {
-      const auto *preset_name = LOG_STR_ARG(climate::climate_preset_to_string(entry.preset));
-      ESP_LOGCONFIG(TAG, "    %s:%s", preset_name, entry.preset == this->default_preset_ ? " (default)" : "");
-      this->dump_preset_config_(preset_name, entry.config);
+    for (auto &it : this->preset_config_) {
+      const auto *preset_name = LOG_STR_ARG(climate::climate_preset_to_string(it.first));
+      ESP_LOGCONFIG(TAG, "    %s:%s", preset_name, it.first == this->default_preset_ ? " (default)" : "");
+      this->dump_preset_config_(preset_name, it.second);
     }
   }
 
   if (!this->custom_preset_config_.empty()) {
     ESP_LOGCONFIG(TAG, "  Supported CUSTOM PRESETS:");
-    for (const auto &entry : this->custom_preset_config_) {
-      const auto *preset_name = entry.name;
-      ESP_LOGCONFIG(TAG, "    %s:%s", preset_name,
-                    (this->default_custom_preset_ != nullptr && strcmp(entry.name, this->default_custom_preset_) == 0)
-                        ? " (default)"
-                        : "");
-      this->dump_preset_config_(preset_name, entry.config);
+    for (auto &it : this->custom_preset_config_) {
+      const auto *preset_name = it.first.c_str();
+      ESP_LOGCONFIG(TAG, "    %s:%s", preset_name, it.first == this->default_custom_preset_ ? " (default)" : "");
+      this->dump_preset_config_(preset_name, it.second);
     }
   }
 }

esphome/components/thermostat/thermostat_climate.h

@@ -3,12 +3,12 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/sensor/sensor.h"
 
 #include <array>
 #include <cinttypes>
+#include <map>
 
 namespace esphome {
 namespace thermostat {
@@ -72,29 +72,14 @@ struct ThermostatClimateTargetTempConfig {
   optional<climate::ClimateMode> mode_{};
 };
 
-/// Entry for standard preset lookup
-struct ThermostatPresetEntry {
-  climate::ClimatePreset preset;
-  ThermostatClimateTargetTempConfig config;
-};
-
-/// Entry for custom preset lookup
-struct ThermostatCustomPresetEntry {
-  const char *name;
-  ThermostatClimateTargetTempConfig config;
-};
-
 class ThermostatClimate : public climate::Climate, public Component {
  public:
-  using PresetEntry = ThermostatPresetEntry;
-  using CustomPresetEntry = ThermostatCustomPresetEntry;
-
   ThermostatClimate();
   void setup() override;
   void dump_config() override;
   void loop() override;
 
-  void set_default_preset(const char *custom_preset);
+  void set_default_preset(const std::string &custom_preset);
   void set_default_preset(climate::ClimatePreset preset);
   void set_on_boot_restore_from(OnBootRestoreFrom on_boot_restore_from);
   void set_set_point_minimum_differential(float differential);
@@ -146,8 +131,8 @@ class ThermostatClimate : public climate::Climate, public Component {
   void set_supports_humidification(bool supports_humidification);
   void set_supports_two_points(bool supports_two_points);
 
-  void set_preset_config(std::initializer_list<PresetEntry> presets);
-  void set_custom_preset_config(std::initializer_list<CustomPresetEntry> presets);
+  void set_preset_config(climate::ClimatePreset preset, const ThermostatClimateTargetTempConfig &config);
+  void set_custom_preset_config(const std::string &name, const ThermostatClimateTargetTempConfig &config);
 
   Trigger<> *get_cool_action_trigger() const;
   Trigger<> *get_supplemental_cool_action_trigger() const;
@@ -531,6 +516,9 @@ class ThermostatClimate : public climate::Climate, public Component {
   Trigger<> *prev_swing_mode_trigger_{nullptr};
   Trigger<> *prev_humidity_control_trigger_{nullptr};
 
+  /// Default custom preset to use on start up
+  std::string default_custom_preset_{};
+
   /// Climate action timers
   std::array<ThermostatClimateTimer, THERMOSTAT_TIMER_COUNT> timer_{
       ThermostatClimateTimer(false, 0, 0, std::bind(&ThermostatClimate::cooling_max_run_time_timer_callback_, this)),
@@ -546,12 +534,9 @@ class ThermostatClimate : public climate::Climate, public Component {
   };
 
   /// The set of standard preset configurations this thermostat supports (Eg. AWAY, ECO, etc)
-  FixedVector<PresetEntry> preset_config_{};
+  std::map<climate::ClimatePreset, ThermostatClimateTargetTempConfig> preset_config_{};
   /// The set of custom preset configurations this thermostat supports (eg. "My Custom Preset")
-  FixedVector<CustomPresetEntry> custom_preset_config_{};
-  /// Default custom preset to use on start up (pointer to entry in custom_preset_config_)
- private:
-  const char *default_custom_preset_{nullptr};
+  std::map<std::string, ThermostatClimateTargetTempConfig> custom_preset_config_{};
 };
 
 }  // namespace thermostat

esphome/components/uart/__init__.py

@@ -1,4 +1,3 @@
-from logging import getLogger
 import math
 import re
 
@@ -36,8 +35,6 @@ 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")
@@ -133,21 +130,6 @@ 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)
@@ -265,7 +247,6 @@ 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_esp_idf.cpp

@@ -91,16 +91,6 @@ 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);
@@ -247,12 +237,8 @@ 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);
-  int32_t write_len = uart_write_bytes(this->uart_num_, data, 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]);
@@ -281,7 +267,6 @@ 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);
@@ -292,31 +277,25 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
     this->has_peek_ = false;
   }
   if (length_to_read > 0)
-    read_len = uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
+    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 read_len == (int32_t) length_to_read;
+  return true;
 }
 
 int IDFUARTComponent::available() {
-  size_t available = 0;
-  esp_err_t err;
+  size_t available;
 
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  err = uart_get_buffered_data_len(this->uart_num_, &available);
+  uart_get_buffered_data_len(this->uart_num_, &available);
+  if (this->has_peek_)
+    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/wifi/__init__.py

@@ -12,6 +12,7 @@ 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,
@@ -351,7 +352,7 @@ CONFIG_SCHEMA = cv.All(
                 single=True
             ),
             cv.Optional(CONF_USE_PSRAM): cv.All(
-                cv.only_on_esp32, cv.requires_component("psram"), cv.boolean
+                only_with_esp_idf, cv.requires_component("psram"), cv.boolean
             ),
         }
     ),

esphome/components/wifi/wifi_component.cpp

@@ -465,8 +465,6 @@ void WiFiComponent::loop() {
         if (!this->is_connected()) {
           ESP_LOGW(TAG, "Connection lost; reconnecting");
           this->state_ = WIFI_COMPONENT_STATE_STA_CONNECTING;
-          // Clear error flag before reconnecting so first attempt is not seen as immediate failure
-          this->error_from_callback_ = false;
           this->retry_connect();
         } else {
           this->status_clear_warning();
@@ -745,14 +743,6 @@ void WiFiComponent::start_connecting(const WiFiAP &ap) {
 }
 
 const LogString *get_signal_bars(int8_t rssi) {
-  // Check for disconnected sentinel value first
-  if (rssi == WIFI_RSSI_DISCONNECTED) {
-    // MULTIPLICATION SIGN
-    // Unicode: U+00D7, UTF-8: C3 97
-    return LOG_STR("\033[0;31m"  // red
-                   "\xc3\x97\xc3\x97\xc3\x97\xc3\x97"
-                   "\033[0m");
-  }
   // LOWER ONE QUARTER BLOCK
   // Unicode: U+2582, UTF-8: E2 96 82
   // LOWER HALF BLOCK
@@ -1034,10 +1024,7 @@ void WiFiComponent::check_scanning_finished() {
 }
 
 void WiFiComponent::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "WiFi:\n"
-                "  Connected: %s",
-                YESNO(this->is_connected()));
+  ESP_LOGCONFIG(TAG, "WiFi:");
   this->print_connect_params_();
 }
 
@@ -1062,10 +1049,6 @@ void WiFiComponent::check_connecting_finished() {
     // Reset to initial phase on successful connection (don't log transition, just reset state)
     this->retry_phase_ = WiFiRetryPhase::INITIAL_CONNECT;
     this->num_retried_ = 0;
-    // Ensure next connection attempt does not inherit error state
-    // so when WiFi disconnects later we start fresh and don't see
-    // the first connection as a failure.
-    this->error_from_callback_ = false;
 
     this->print_connect_params_();
 
@@ -1152,11 +1135,6 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
         return WiFiRetryPhase::FAST_CONNECT_CYCLING_APS;  // Move to next AP
       }
 #endif
-      // Check if we should try explicit hidden networks before scanning
-      // This handles reconnection after connection loss where first network is hidden
-      if (!this->sta_.empty() && this->sta_[0].get_hidden()) {
-        return WiFiRetryPhase::EXPLICIT_HIDDEN;
-      }
       // No more APs to try, fall back to scan
       return WiFiRetryPhase::SCAN_CONNECTING;
 

esphome/components/wifi/wifi_component.h

@@ -52,9 +52,6 @@ extern "C" {
 namespace esphome {
 namespace wifi {
 
-/// Sentinel value for RSSI when WiFi is not connected
-static constexpr int8_t WIFI_RSSI_DISCONNECTED = -127;
-
 struct SavedWifiSettings {
   char ssid[33];
   char password[65];

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -872,7 +872,7 @@ 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() { return WiFi.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/components/wifi/wifi_component_esp_idf.cpp

@@ -1031,8 +1031,7 @@ bssid_t WiFiComponent::wifi_bssid() {
   wifi_ap_record_t info;
   esp_err_t err = esp_wifi_sta_get_ap_info(&info);
   if (err != ESP_OK) {
-    // Very verbose only: this is expected during dump_config() before connection is established (PR #9823)
-    ESP_LOGVV(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
+    ESP_LOGW(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
     return bssid;
   }
   std::copy(info.bssid, info.bssid + 6, bssid.begin());
@@ -1042,8 +1041,7 @@ std::string WiFiComponent::wifi_ssid() {
   wifi_ap_record_t info{};
   esp_err_t err = esp_wifi_sta_get_ap_info(&info);
   if (err != ESP_OK) {
-    // Very verbose only: this is expected during dump_config() before connection is established (PR #9823)
-    ESP_LOGVV(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
+    ESP_LOGW(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
     return "";
   }
   auto *ssid_s = reinterpret_cast<const char *>(info.ssid);
@@ -1054,9 +1052,8 @@ int8_t WiFiComponent::wifi_rssi() {
   wifi_ap_record_t info;
   esp_err_t err = esp_wifi_sta_get_ap_info(&info);
   if (err != ESP_OK) {
-    // Very verbose only: this is expected during dump_config() before connection is established (PR #9823)
-    ESP_LOGVV(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
-    return WIFI_RSSI_DISCONNECTED;
+    ESP_LOGW(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
+    return 0;
   }
   return info.rssi;
 }

esphome/components/wifi/wifi_component_libretiny.cpp

@@ -486,7 +486,7 @@ 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() { return WiFi.RSSI(); }
 int32_t WiFiComponent::get_wifi_channel() { return WiFi.channel(); }
 network::IPAddress WiFiComponent::wifi_subnet_mask_() { return {WiFi.subnetMask()}; }
 network::IPAddress WiFiComponent::wifi_gateway_ip_() { return {WiFi.gatewayIP()}; }

esphome/components/wifi/wifi_component_pico_w.cpp

@@ -200,7 +200,7 @@ 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() { return WiFi.RSSI(); }
 int32_t WiFiComponent::get_wifi_channel() { return WiFi.channel(); }
 
 network::IPAddresses WiFiComponent::wifi_sta_ip_addresses() {

esphome/const.py

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

esphome/core/automation.h

@@ -11,26 +11,10 @@
 
 namespace esphome {
 
-// C++20 std::index_sequence is now used for tuple unpacking
-// Legacy seq<>/gens<> pattern deprecated but kept for backwards compatibility
 // https://stackoverflow.com/questions/7858817/unpacking-a-tuple-to-call-a-matching-function-pointer/7858971#7858971
-// Remove before 2026.6.0
-// NOLINTBEGIN(readability-identifier-naming)
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-template<int...> struct ESPDEPRECATED("Use std::index_sequence instead. Removed in 2026.6.0", "2025.12.0") seq {};
-template<int N, int... S>
-struct ESPDEPRECATED("Use std::make_index_sequence instead. Removed in 2026.6.0", "2025.12.0") gens
-    : gens<N - 1, N - 1, S...> {};
-template<int... S> struct gens<0, S...> { using type = seq<S...>; };
-
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-// NOLINTEND(readability-identifier-naming)
+template<int...> struct seq {};                                       // NOLINT
+template<int N, int... S> struct gens : gens<N - 1, N - 1, S...> {};  // NOLINT
+template<int... S> struct gens<0, S...> { using type = seq<S...>; };  // NOLINT
 
 #define TEMPLATABLE_VALUE_(type, name) \
  protected: \
@@ -168,11 +152,11 @@ template<typename... Ts> class Condition {
 
   /// Call check with a tuple of values as parameter.
   bool check_tuple(const std::tuple<Ts...> &tuple) {
-    return this->check_tuple_(tuple, std::make_index_sequence<sizeof...(Ts)>{});
+    return this->check_tuple_(tuple, typename gens<sizeof...(Ts)>::type());
   }
 
  protected:
-  template<size_t... S> bool check_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+  template<int... S> bool check_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     return this->check(std::get<S>(tuple)...);
   }
 };
@@ -247,11 +231,11 @@ template<typename... Ts> class Action {
       }
     }
   }
-  template<size_t... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+  template<int... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     this->play_next_(std::get<S>(tuple)...);
   }
   void play_next_tuple_(const std::tuple<Ts...> &tuple) {
-    this->play_next_tuple_(tuple, std::make_index_sequence<sizeof...(Ts)>{});
+    this->play_next_tuple_(tuple, typename gens<sizeof...(Ts)>::type());
   }
 
   virtual void stop() {}
@@ -293,9 +277,7 @@ template<typename... Ts> class ActionList {
     if (this->actions_begin_ != nullptr)
       this->actions_begin_->play_complex(x...);
   }
-  void play_tuple(const std::tuple<Ts...> &tuple) {
-    this->play_tuple_(tuple, std::make_index_sequence<sizeof...(Ts)>{});
-  }
+  void play_tuple(const std::tuple<Ts...> &tuple) { this->play_tuple_(tuple, typename gens<sizeof...(Ts)>::type()); }
   void stop() {
     if (this->actions_begin_ != nullptr)
       this->actions_begin_->stop_complex();
@@ -316,7 +298,7 @@ template<typename... Ts> class ActionList {
   }
 
  protected:
-  template<size_t... S> void play_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+  template<int... S> void play_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     this->play(std::get<S>(tuple)...);
   }
 

esphome/mqtt.py

@@ -30,7 +30,6 @@ from esphome.const import (
 from esphome.core import CORE, EsphomeError
 from esphome.helpers import get_int_env, get_str_env
 from esphome.log import AnsiFore, color
-from esphome.types import ConfigType
 from esphome.util import safe_print
 
 _LOGGER = logging.getLogger(__name__)
@@ -155,12 +154,8 @@ def show_discover(config, username=None, password=None, client_id=None):
 
 
 def get_esphome_device_ip(
-    config: ConfigType,
-    username: str | None = None,
-    password: str | None = None,
-    client_id: str | None = None,
-    timeout: int | float = 25,
-) -> list[str]:
+    config, username=None, password=None, client_id=None, timeout=25
+):
     if CONF_MQTT not in config:
         raise EsphomeError(
             "Cannot discover IP via MQTT as the config does not include the mqtt: "
@@ -171,10 +166,6 @@ def get_esphome_device_ip(
             "Cannot discover IP via MQTT as the config does not include the device name: "
             "component"
         )
-    if not config[CONF_MQTT].get(CONF_BROKER):
-        raise EsphomeError(
-            "Cannot discover IP via MQTT as the broker is not configured"
-        )
 
     dev_name = config[CONF_ESPHOME][CONF_NAME]
     dev_ip = None

requirements_test.txt

@@ -1,6 +1,6 @@
-pylint==4.0.3
+pylint==4.0.2
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.14.5  # also change in .pre-commit-config.yaml when updating
+ruff==0.14.4  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.21.1  # also change in .pre-commit-config.yaml when updating
 pre-commit
 

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

@@ -1,27 +0,0 @@
-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/nrf52/test.nrf52-adafruit.yaml

@@ -15,7 +15,6 @@ nrf52:
       inverted: true
       mode:
         output: true
-  dcdc: False
   reg0:
     voltage: 2.1V
     uicr_erase: true

tests/integration/fixtures/climate_custom_fan_modes_and_presets.yaml

@@ -14,7 +14,6 @@ climate:
     id: test_thermostat
     name: Test Thermostat Custom Modes
     sensor: thermostat_sensor
-    default_preset: "Eco Plus"
     preset:
       - name: Away
         default_target_temperature_low: 16°C

tests/integration/test_climate_custom_modes.py

@@ -2,13 +2,9 @@
 
 from __future__ import annotations
 
-import asyncio
-
-import aioesphomeapi
-from aioesphomeapi import ClimateInfo, ClimatePreset, EntityState
+from aioesphomeapi import ClimateInfo, ClimatePreset
 import pytest
 
-from .state_utils import InitialStateHelper
 from .types import APIClientConnectedFactory, RunCompiledFunction
 
 
@@ -18,50 +14,15 @@ async def test_climate_custom_fan_modes_and_presets(
     run_compiled: RunCompiledFunction,
     api_client_connected: APIClientConnectedFactory,
 ) -> None:
-    """Test that custom presets are properly exposed and can be changed."""
-    loop = asyncio.get_running_loop()
+    """Test that custom presets are properly exposed via API."""
     async with run_compiled(yaml_config), api_client_connected() as client:
-        states: dict[int, EntityState] = {}
-        super_saver_future: asyncio.Future[EntityState] = loop.create_future()
-        vacation_future: asyncio.Future[EntityState] = loop.create_future()
-
-        def on_state(state: EntityState) -> None:
-            states[state.key] = state
-            if isinstance(state, aioesphomeapi.ClimateState):
-                # Wait for Super Saver preset
-                if (
-                    state.custom_preset == "Super Saver"
-                    and state.target_temperature_low == 20.0
-                    and state.target_temperature_high == 24.0
-                    and not super_saver_future.done()
-                ):
-                    super_saver_future.set_result(state)
-                # Wait for Vacation Mode preset
-                elif (
-                    state.custom_preset == "Vacation Mode"
-                    and state.target_temperature_low == 15.0
-                    and state.target_temperature_high == 18.0
-                    and not vacation_future.done()
-                ):
-                    vacation_future.set_result(state)
-
-        # Get entities and set up state synchronization
+        # Get entities and services
         entities, services = await client.list_entities_services()
-        initial_state_helper = InitialStateHelper(entities)
         climate_infos = [e for e in entities if isinstance(e, ClimateInfo)]
         assert len(climate_infos) == 1, "Expected exactly 1 climate entity"
 
         test_climate = climate_infos[0]
 
-        # Subscribe with the wrapper that filters initial states
-        client.subscribe_states(initial_state_helper.on_state_wrapper(on_state))
-
-        # Wait for all initial states to be broadcast
-        try:
-            await initial_state_helper.wait_for_initial_states()
-        except TimeoutError:
-            pytest.fail("Timeout waiting for initial states")
-
         # Verify enum presets are exposed (from preset: config map)
         assert ClimatePreset.AWAY in test_climate.supported_presets, (
             "Expected AWAY in enum presets"
@@ -79,43 +40,3 @@ async def test_climate_custom_fan_modes_and_presets(
         assert "Vacation Mode" in custom_presets, (
             "Expected 'Vacation Mode' in custom presets"
         )
-
-        # Get initial state and verify default preset
-        initial_state = initial_state_helper.initial_states.get(test_climate.key)
-        assert initial_state is not None, "Climate initial state not found"
-        assert isinstance(initial_state, aioesphomeapi.ClimateState)
-        assert initial_state.custom_preset == "Eco Plus", (
-            f"Expected default preset 'Eco Plus', got '{initial_state.custom_preset}'"
-        )
-        assert initial_state.target_temperature_low == 18.0, (
-            f"Expected low temp 18.0, got {initial_state.target_temperature_low}"
-        )
-        assert initial_state.target_temperature_high == 22.0, (
-            f"Expected high temp 22.0, got {initial_state.target_temperature_high}"
-        )
-
-        # Test changing to "Super Saver" custom preset
-        client.climate_command(test_climate.key, custom_preset="Super Saver")
-
-        try:
-            super_saver_state = await asyncio.wait_for(super_saver_future, timeout=5.0)
-        except TimeoutError:
-            pytest.fail("Super Saver preset change not received within 5 seconds")
-
-        assert isinstance(super_saver_state, aioesphomeapi.ClimateState)
-        assert super_saver_state.custom_preset == "Super Saver"
-        assert super_saver_state.target_temperature_low == 20.0
-        assert super_saver_state.target_temperature_high == 24.0
-
-        # Test changing to "Vacation Mode" custom preset
-        client.climate_command(test_climate.key, custom_preset="Vacation Mode")
-
-        try:
-            vacation_state = await asyncio.wait_for(vacation_future, timeout=5.0)
-        except TimeoutError:
-            pytest.fail("Vacation Mode preset change not received within 5 seconds")
-
-        assert isinstance(vacation_state, aioesphomeapi.ClimateState)
-        assert vacation_state.custom_preset == "Vacation Mode"
-        assert vacation_state.target_temperature_low == 15.0
-        assert vacation_state.target_temperature_high == 18.0

tests/unit_tests/test_main.py

@@ -1166,56 +1166,6 @@ def test_upload_program_ota_with_mqtt_resolution(
     )
 
 
-def test_upload_program_ota_with_mqtt_empty_broker(
-    mock_mqtt_get_ip: Mock,
-    mock_is_ip_address: Mock,
-    mock_run_ota: Mock,
-    tmp_path: Path,
-    caplog: CaptureFixture,
-) -> None:
-    """Test upload_program with OTA when MQTT broker is empty (issue #11653)."""
-    setup_core(address="192.168.1.50", platform=PLATFORM_ESP32, tmp_path=tmp_path)
-
-    mock_is_ip_address.return_value = True
-    mock_mqtt_get_ip.side_effect = EsphomeError(
-        "Cannot discover IP via MQTT as the broker is not configured"
-    )
-    mock_run_ota.return_value = (0, "192.168.1.50")
-
-    config = {
-        CONF_OTA: [
-            {
-                CONF_PLATFORM: CONF_ESPHOME,
-                CONF_PORT: 3232,
-            }
-        ],
-        CONF_MQTT: {
-            CONF_BROKER: "",
-        },
-        CONF_MDNS: {
-            CONF_DISABLED: True,
-        },
-    }
-    args = MockArgs(username="user", password="pass", client_id="client")
-    devices = ["MQTTIP", "192.168.1.50"]
-
-    exit_code, host = upload_program(config, args, devices)
-
-    assert exit_code == 0
-    assert host == "192.168.1.50"
-    # Verify MQTT was attempted but failed gracefully
-    mock_mqtt_get_ip.assert_called_once_with(config, "user", "pass", "client")
-    # Verify we fell back to the IP address
-    expected_firmware = (
-        tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin"
-    )
-    mock_run_ota.assert_called_once_with(
-        ["192.168.1.50"], 3232, None, expected_firmware
-    )
-    # Verify warning was logged
-    assert "MQTT IP discovery failed" in caplog.text
-
-
 @patch("esphome.__main__.importlib.import_module")
 def test_upload_program_platform_specific_handler(
     mock_import: Mock,

tests/unit_tests/test_mqtt.py

@@ -1,91 +0,0 @@
-"""Unit tests for esphome.mqtt module."""
-
-from __future__ import annotations
-
-import pytest
-
-from esphome.const import CONF_BROKER, CONF_ESPHOME, CONF_MQTT, CONF_NAME
-from esphome.core import EsphomeError
-from esphome.mqtt import get_esphome_device_ip
-
-
-def test_get_esphome_device_ip_empty_broker() -> None:
-    """Test that get_esphome_device_ip raises EsphomeError when broker is empty."""
-    config = {
-        CONF_MQTT: {
-            CONF_BROKER: "",
-        },
-        CONF_ESPHOME: {
-            CONF_NAME: "test-device",
-        },
-    }
-
-    with pytest.raises(
-        EsphomeError,
-        match="Cannot discover IP via MQTT as the broker is not configured",
-    ):
-        get_esphome_device_ip(config)
-
-
-def test_get_esphome_device_ip_none_broker() -> None:
-    """Test that get_esphome_device_ip raises EsphomeError when broker is None."""
-    config = {
-        CONF_MQTT: {
-            CONF_BROKER: None,
-        },
-        CONF_ESPHOME: {
-            CONF_NAME: "test-device",
-        },
-    }
-
-    with pytest.raises(
-        EsphomeError,
-        match="Cannot discover IP via MQTT as the broker is not configured",
-    ):
-        get_esphome_device_ip(config)
-
-
-def test_get_esphome_device_ip_missing_mqtt() -> None:
-    """Test that get_esphome_device_ip raises EsphomeError when mqtt config is missing."""
-    config = {
-        CONF_ESPHOME: {
-            CONF_NAME: "test-device",
-        },
-    }
-
-    with pytest.raises(
-        EsphomeError,
-        match="Cannot discover IP via MQTT as the config does not include the mqtt:",
-    ):
-        get_esphome_device_ip(config)
-
-
-def test_get_esphome_device_ip_missing_esphome() -> None:
-    """Test that get_esphome_device_ip raises EsphomeError when esphome config is missing."""
-    config = {
-        CONF_MQTT: {
-            CONF_BROKER: "mqtt.local",
-        },
-    }
-
-    with pytest.raises(
-        EsphomeError,
-        match="Cannot discover IP via MQTT as the config does not include the device name:",
-    ):
-        get_esphome_device_ip(config)
-
-
-def test_get_esphome_device_ip_missing_name() -> None:
-    """Test that get_esphome_device_ip raises EsphomeError when device name is missing."""
-    config = {
-        CONF_MQTT: {
-            CONF_BROKER: "mqtt.local",
-        },
-        CONF_ESPHOME: {},
-    }
-
-    with pytest.raises(
-        EsphomeError,
-        match="Cannot discover IP via MQTT as the config does not include the device name:",
-    ):
-        get_esphome_device_ip(config)