[wifi] Store credentials in PROGMEM on ESP8266 to reduce RAM usage

Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>

esphome/__main__.py

@@ -731,13 +731,6 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
-    # Set memory analysis options in config
-    if args.analyze_memory:
-        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
-
-    if args.memory_report:
-        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
-
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -1199,17 +1192,6 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
-    parser_compile.add_argument(
-        "--analyze-memory",
-        help="Analyze and display memory usage by component after compilation.",
-        action="store_true",
-    )
-    parser_compile.add_argument(
-        "--memory-report",
-        help="Save memory analysis report to a file (supports .json or .txt).",
-        type=str,
-        metavar="FILE",
-    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/analyze_memory/cli.py

@@ -1,7 +1,6 @@
 """CLI interface for memory analysis with report generation."""
 
 from collections import defaultdict
-import json
 import sys
 
 from . import (
@@ -284,28 +283,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
         return "\n".join(lines)
 
-    def to_json(self) -> str:
-        """Export analysis results as JSON."""
-        data = {
-            "components": {
-                name: {
-                    "text": mem.text_size,
-                    "rodata": mem.rodata_size,
-                    "data": mem.data_size,
-                    "bss": mem.bss_size,
-                    "flash_total": mem.flash_total,
-                    "ram_total": mem.ram_total,
-                    "symbol_count": mem.symbol_count,
-                }
-                for name, mem in self.components.items()
-            },
-            "totals": {
-                "flash": sum(c.flash_total for c in self.components.values()),
-                "ram": sum(c.ram_total for c in self.components.values()),
-            },
-        }
-        return json.dumps(data, indent=2)
-
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:
         """Dump uncategorized symbols for analysis."""
         # Sort by size descending

esphome/codegen.py

@@ -62,6 +62,7 @@ from esphome.cpp_types import (  # noqa: F401
     EntityBase,
     EntityCategory,
     ESPTime,
+    FixedVector,
     GPIOPin,
     InternalGPIOPin,
     JsonObject,

esphome/components/api/__init__.py

@@ -71,10 +71,12 @@ SERVICE_ARG_NATIVE_TYPES = {
     "int": cg.int32,
     "float": float,
     "string": cg.std_string,
-    "bool[]": cg.std_vector.template(bool),
-    "int[]": cg.std_vector.template(cg.int32),
-    "float[]": cg.std_vector.template(float),
-    "string[]": cg.std_vector.template(cg.std_string),
+    "bool[]": cg.FixedVector.template(bool).operator("const").operator("ref"),
+    "int[]": cg.FixedVector.template(cg.int32).operator("const").operator("ref"),
+    "float[]": cg.FixedVector.template(float).operator("const").operator("ref"),
+    "string[]": cg.FixedVector.template(cg.std_string)
+    .operator("const")
+    .operator("ref"),
 }
 CONF_ENCRYPTION = "encryption"
 CONF_BATCH_DELAY = "batch_delay"

esphome/components/api/api.proto

@@ -425,7 +425,7 @@ message ListEntitiesFanResponse {
   bool disabled_by_default = 9;
   string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 11;
-  repeated string supported_preset_modes = 12 [(container_pointer) = "std::vector"];
+  repeated string supported_preset_modes = 12 [(container_pointer) = "std::set"];
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
 }
 // Deprecated in API version 1.6 - only used in deprecated fields
@@ -989,7 +989,7 @@ message ListEntitiesClimateResponse {
 
   bool supports_current_temperature = 5; // Deprecated: use feature_flags
   bool supports_two_point_target_temperature = 6; // Deprecated: use feature_flags
-  repeated ClimateMode supported_modes = 7 [(container_pointer_no_template) = "climate::ClimateModeMask"];
+  repeated ClimateMode supported_modes = 7 [(container_pointer) = "std::set<climate::ClimateMode>"];
   float visual_min_temperature = 8;
   float visual_max_temperature = 9;
   float visual_target_temperature_step = 10;
@@ -998,11 +998,11 @@ message ListEntitiesClimateResponse {
   // Deprecated in API version 1.5
   bool legacy_supports_away = 11 [deprecated=true];
   bool supports_action = 12; // Deprecated: use feature_flags
-  repeated ClimateFanMode supported_fan_modes = 13 [(container_pointer_no_template) = "climate::ClimateFanModeMask"];
-  repeated ClimateSwingMode supported_swing_modes = 14 [(container_pointer_no_template) = "climate::ClimateSwingModeMask"];
-  repeated string supported_custom_fan_modes = 15 [(container_pointer) = "std::vector"];
-  repeated ClimatePreset supported_presets = 16 [(container_pointer_no_template) = "climate::ClimatePresetMask"];
-  repeated string supported_custom_presets = 17 [(container_pointer) = "std::vector"];
+  repeated ClimateFanMode supported_fan_modes = 13 [(container_pointer) = "std::set<climate::ClimateFanMode>"];
+  repeated ClimateSwingMode supported_swing_modes = 14 [(container_pointer) = "std::set<climate::ClimateSwingMode>"];
+  repeated string supported_custom_fan_modes = 15 [(container_pointer) = "std::set"];
+  repeated ClimatePreset supported_presets = 16 [(container_pointer) = "std::set<climate::ClimatePreset>"];
+  repeated string supported_custom_presets = 17 [(container_pointer) = "std::set"];
   bool disabled_by_default = 18;
   string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 20;
@@ -1143,7 +1143,7 @@ message ListEntitiesSelectResponse {
   reserved 4; // Deprecated: was string unique_id
 
   string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
-  repeated string options = 6 [(container_pointer_no_template) = "FixedVector<const char *>"];
+  repeated string options = 6 [(container_pointer) = "std::vector"];
   bool disabled_by_default = 7;
   EntityCategory entity_category = 8;
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];

esphome/components/api/api_connection.cpp

@@ -669,18 +669,18 @@ uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection
   msg.supports_action = traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION);
   // Current feature flags and other supported parameters
   msg.feature_flags = traits.get_feature_flags();
-  msg.supported_modes = &traits.get_supported_modes();
+  msg.supported_modes = &traits.get_supported_modes_for_api_();
   msg.visual_min_temperature = traits.get_visual_min_temperature();
   msg.visual_max_temperature = traits.get_visual_max_temperature();
   msg.visual_target_temperature_step = traits.get_visual_target_temperature_step();
   msg.visual_current_temperature_step = traits.get_visual_current_temperature_step();
   msg.visual_min_humidity = traits.get_visual_min_humidity();
   msg.visual_max_humidity = traits.get_visual_max_humidity();
-  msg.supported_fan_modes = &traits.get_supported_fan_modes();
-  msg.supported_custom_fan_modes = &traits.get_supported_custom_fan_modes();
-  msg.supported_presets = &traits.get_supported_presets();
-  msg.supported_custom_presets = &traits.get_supported_custom_presets();
-  msg.supported_swing_modes = &traits.get_supported_swing_modes();
+  msg.supported_fan_modes = &traits.get_supported_fan_modes_for_api_();
+  msg.supported_custom_fan_modes = &traits.get_supported_custom_fan_modes_for_api_();
+  msg.supported_presets = &traits.get_supported_presets_for_api_();
+  msg.supported_custom_presets = &traits.get_supported_custom_presets_for_api_();
+  msg.supported_swing_modes = &traits.get_supported_swing_modes_for_api_();
   return fill_and_encode_entity_info(climate, msg, ListEntitiesClimateResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }

esphome/components/api/api_frame_helper_noise.cpp

@@ -142,11 +142,6 @@ APIError APINoiseFrameHelper::loop() {
  * errno API_ERROR_HANDSHAKE_PACKET_LEN: Packet too big for this phase.
  */
 APIError APINoiseFrameHelper::try_read_frame_() {
-  // Clear buffer when starting a new frame (rx_buf_len_ == 0 means not resuming after WOULD_BLOCK)
-  if (this->rx_buf_len_ == 0) {
-    this->rx_buf_.clear();
-  }
-
   // read header
   if (rx_header_buf_len_ < 3) {
     // no header information yet

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -54,11 +54,6 @@ APIError APIPlaintextFrameHelper::loop() {
  * error API_ERROR_BAD_INDICATOR: Bad indicator byte at start of frame.
  */
 APIError APIPlaintextFrameHelper::try_read_frame_() {
-  // Clear buffer when starting a new frame (rx_buf_len_ == 0 means not resuming after WOULD_BLOCK)
-  if (this->rx_buf_len_ == 0) {
-    this->rx_buf_.clear();
-  }
-
   // read header
   while (!rx_header_parsed_) {
     // Now that we know when the socket is ready, we can read up to 3 bytes

esphome/components/api/api_pb2.cpp

@@ -1475,8 +1475,8 @@ void ListEntitiesSelectResponse::encode(ProtoWriteBuffer buffer) const {
 #ifdef USE_ENTITY_ICON
   buffer.encode_string(5, this->icon_ref_);
 #endif
-  for (const char *it : *this->options) {
-    buffer.encode_string(6, it, strlen(it), true);
+  for (const auto &it : *this->options) {
+    buffer.encode_string(6, it, true);
   }
   buffer.encode_bool(7, this->disabled_by_default);
   buffer.encode_uint32(8, static_cast<uint32_t>(this->entity_category));
@@ -1492,8 +1492,8 @@ void ListEntitiesSelectResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->icon_ref_.size());
 #endif
   if (!this->options->empty()) {
-    for (const char *it : *this->options) {
-      size.add_length_force(1, strlen(it));
+    for (const auto &it : *this->options) {
+      size.add_length_force(1, it.size());
     }
   }
   size.add_bool(1, this->disabled_by_default);

esphome/components/api/api_pb2.h

@@ -725,7 +725,7 @@ class ListEntitiesFanResponse final : public InfoResponseProtoMessage {
   bool supports_speed{false};
   bool supports_direction{false};
   int32_t supported_speed_count{0};
-  const std::vector<std::string> *supported_preset_modes{};
+  const std::set<std::string> *supported_preset_modes{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1377,16 +1377,16 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
 #endif
   bool supports_current_temperature{false};
   bool supports_two_point_target_temperature{false};
-  const climate::ClimateModeMask *supported_modes{};
+  const std::set<climate::ClimateMode> *supported_modes{};
   float visual_min_temperature{0.0f};
   float visual_max_temperature{0.0f};
   float visual_target_temperature_step{0.0f};
   bool supports_action{false};
-  const climate::ClimateFanModeMask *supported_fan_modes{};
-  const climate::ClimateSwingModeMask *supported_swing_modes{};
-  const std::vector<std::string> *supported_custom_fan_modes{};
-  const climate::ClimatePresetMask *supported_presets{};
-  const std::vector<std::string> *supported_custom_presets{};
+  const std::set<climate::ClimateFanMode> *supported_fan_modes{};
+  const std::set<climate::ClimateSwingMode> *supported_swing_modes{};
+  const std::set<std::string> *supported_custom_fan_modes{};
+  const std::set<climate::ClimatePreset> *supported_presets{};
+  const std::set<std::string> *supported_custom_presets{};
   float visual_current_temperature_step{0.0f};
   bool supports_current_humidity{false};
   bool supports_target_humidity{false};
@@ -1534,7 +1534,7 @@ class ListEntitiesSelectResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_select_response"; }
 #endif
-  const FixedVector<const char *> *options{};
+  const std::vector<std::string> *options{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/api/api_pb2_dump.cpp

@@ -88,12 +88,6 @@ static void dump_field(std::string &out, const char *field_name, StringRef value
   out.append("\n");
 }
 
-static void dump_field(std::string &out, const char *field_name, const char *value, int indent = 2) {
-  append_field_prefix(out, field_name, indent);
-  out.append("'").append(value).append("'");
-  out.append("\n");
-}
-
 template<typename T> static void dump_field(std::string &out, const char *field_name, T value, int indent = 2) {
   append_field_prefix(out, field_name, indent);
   out.append(proto_enum_to_string<T>(value));

esphome/components/api/user_services.cpp

@@ -11,23 +11,58 @@ template<> int32_t get_execute_arg_value<int32_t>(const ExecuteServiceArgument &
 }
 template<> float get_execute_arg_value<float>(const ExecuteServiceArgument &arg) { return arg.float_; }
 template<> std::string get_execute_arg_value<std::string>(const ExecuteServiceArgument &arg) { return arg.string_; }
+
+// Legacy std::vector versions for external components using custom_api_device.h - optimized with reserve
 template<> std::vector<bool> get_execute_arg_value<std::vector<bool>>(const ExecuteServiceArgument &arg) {
-  return std::vector<bool>(arg.bool_array.begin(), arg.bool_array.end());
+  std::vector<bool> result;
+  result.reserve(arg.bool_array.size());
+  result.insert(result.end(), arg.bool_array.begin(), arg.bool_array.end());
+  return result;
 }
 template<> std::vector<int32_t> get_execute_arg_value<std::vector<int32_t>>(const ExecuteServiceArgument &arg) {
-  return std::vector<int32_t>(arg.int_array.begin(), arg.int_array.end());
+  std::vector<int32_t> result;
+  result.reserve(arg.int_array.size());
+  result.insert(result.end(), arg.int_array.begin(), arg.int_array.end());
+  return result;
 }
 template<> std::vector<float> get_execute_arg_value<std::vector<float>>(const ExecuteServiceArgument &arg) {
-  return std::vector<float>(arg.float_array.begin(), arg.float_array.end());
+  std::vector<float> result;
+  result.reserve(arg.float_array.size());
+  result.insert(result.end(), arg.float_array.begin(), arg.float_array.end());
+  return result;
 }
 template<> std::vector<std::string> get_execute_arg_value<std::vector<std::string>>(const ExecuteServiceArgument &arg) {
-  return std::vector<std::string>(arg.string_array.begin(), arg.string_array.end());
+  std::vector<std::string> result;
+  result.reserve(arg.string_array.size());
+  result.insert(result.end(), arg.string_array.begin(), arg.string_array.end());
+  return result;
+}
+
+// New FixedVector const reference versions for YAML-generated services - zero-copy
+template<>
+const FixedVector<bool> &get_execute_arg_value<const FixedVector<bool> &>(const ExecuteServiceArgument &arg) {
+  return arg.bool_array;
+}
+template<>
+const FixedVector<int32_t> &get_execute_arg_value<const FixedVector<int32_t> &>(const ExecuteServiceArgument &arg) {
+  return arg.int_array;
+}
+template<>
+const FixedVector<float> &get_execute_arg_value<const FixedVector<float> &>(const ExecuteServiceArgument &arg) {
+  return arg.float_array;
+}
+template<>
+const FixedVector<std::string> &get_execute_arg_value<const FixedVector<std::string> &>(
+    const ExecuteServiceArgument &arg) {
+  return arg.string_array;
 }
 
 template<> enums::ServiceArgType to_service_arg_type<bool>() { return enums::SERVICE_ARG_TYPE_BOOL; }
 template<> enums::ServiceArgType to_service_arg_type<int32_t>() { return enums::SERVICE_ARG_TYPE_INT; }
 template<> enums::ServiceArgType to_service_arg_type<float>() { return enums::SERVICE_ARG_TYPE_FLOAT; }
 template<> enums::ServiceArgType to_service_arg_type<std::string>() { return enums::SERVICE_ARG_TYPE_STRING; }
+
+// Legacy std::vector versions for external components using custom_api_device.h
 template<> enums::ServiceArgType to_service_arg_type<std::vector<bool>>() { return enums::SERVICE_ARG_TYPE_BOOL_ARRAY; }
 template<> enums::ServiceArgType to_service_arg_type<std::vector<int32_t>>() {
   return enums::SERVICE_ARG_TYPE_INT_ARRAY;
@@ -39,4 +74,18 @@ template<> enums::ServiceArgType to_service_arg_type<std::vector<std::string>>()
   return enums::SERVICE_ARG_TYPE_STRING_ARRAY;
 }
 
+// New FixedVector const reference versions for YAML-generated services
+template<> enums::ServiceArgType to_service_arg_type<const FixedVector<bool> &>() {
+  return enums::SERVICE_ARG_TYPE_BOOL_ARRAY;
+}
+template<> enums::ServiceArgType to_service_arg_type<const FixedVector<int32_t> &>() {
+  return enums::SERVICE_ARG_TYPE_INT_ARRAY;
+}
+template<> enums::ServiceArgType to_service_arg_type<const FixedVector<float> &>() {
+  return enums::SERVICE_ARG_TYPE_FLOAT_ARRAY;
+}
+template<> enums::ServiceArgType to_service_arg_type<const FixedVector<std::string> &>() {
+  return enums::SERVICE_ARG_TYPE_STRING_ARRAY;
+}
+
 }  // namespace esphome::api

esphome/components/bedjet/bedjet_const.h

@@ -99,8 +99,9 @@ enum BedjetCommand : uint8_t {
 
 static const uint8_t BEDJET_FAN_SPEED_COUNT = 20;
 
-static constexpr const char *const BEDJET_FAN_STEP_NAMES[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
+static const char *const BEDJET_FAN_STEP_NAMES[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
 static const std::string BEDJET_FAN_STEP_NAME_STRINGS[BEDJET_FAN_SPEED_COUNT] = BEDJET_FAN_STEP_NAMES_;
+static const std::set<std::string> BEDJET_FAN_STEP_NAMES_SET BEDJET_FAN_STEP_NAMES_;
 
 }  // namespace bedjet
 }  // namespace esphome

esphome/components/bedjet/climate/bedjet_climate.h

@@ -43,7 +43,7 @@ class BedJetClimate : public climate::Climate, public BedJetClient, public Polli
     });
 
     // It would be better if we had a slider for the fan modes.
-    traits.set_supported_custom_fan_modes(BEDJET_FAN_STEP_NAMES);
+    traits.set_supported_custom_fan_modes(BEDJET_FAN_STEP_NAMES_SET);
     traits.set_supported_presets({
         // If we support NONE, then have to decide what happens if the user switches to it (turn off?)
         // climate::CLIMATE_PRESET_NONE,

esphome/components/climate/climate.cpp

@@ -385,7 +385,7 @@ void Climate::save_state_() {
   if (!traits.get_supported_custom_fan_modes().empty() && custom_fan_mode.has_value()) {
     state.uses_custom_fan_mode = true;
     const auto &supported = traits.get_supported_custom_fan_modes();
-    // std::vector maintains insertion order
+    // std::set has consistent order (lexicographic for strings)
     size_t i = 0;
     for (const auto &mode : supported) {
       if (mode == custom_fan_mode) {
@@ -402,7 +402,7 @@ void Climate::save_state_() {
   if (!traits.get_supported_custom_presets().empty() && custom_preset.has_value()) {
     state.uses_custom_preset = true;
     const auto &supported = traits.get_supported_custom_presets();
-    // std::vector maintains insertion order
+    // std::set has consistent order (lexicographic for strings)
     size_t i = 0;
     for (const auto &preset : supported) {
       if (preset == custom_preset) {

esphome/components/climate/climate_mode.h

@@ -7,7 +7,6 @@ namespace esphome {
 namespace climate {
 
 /// Enum for all modes a climate device can be in.
-/// NOTE: If adding values, update ClimateModeMask in climate_traits.h to use the new last value
 enum ClimateMode : uint8_t {
   /// The climate device is off
   CLIMATE_MODE_OFF = 0,
@@ -25,7 +24,7 @@ enum ClimateMode : uint8_t {
    * For example, the target temperature can be adjusted based on a schedule, or learned behavior.
    * The target temperature can't be adjusted when in this mode.
    */
-  CLIMATE_MODE_AUTO = 6  // Update ClimateModeMask in climate_traits.h if adding values after this
+  CLIMATE_MODE_AUTO = 6
 };
 
 /// Enum for the current action of the climate device. Values match those of ClimateMode.
@@ -44,7 +43,6 @@ enum ClimateAction : uint8_t {
   CLIMATE_ACTION_FAN = 6,
 };
 
-/// NOTE: If adding values, update ClimateFanModeMask in climate_traits.h to use the new last value
 enum ClimateFanMode : uint8_t {
   /// The fan mode is set to On
   CLIMATE_FAN_ON = 0,
@@ -65,11 +63,10 @@ enum ClimateFanMode : uint8_t {
   /// The fan mode is set to Diffuse
   CLIMATE_FAN_DIFFUSE = 8,
   /// The fan mode is set to Quiet
-  CLIMATE_FAN_QUIET = 9,  // Update ClimateFanModeMask in climate_traits.h if adding values after this
+  CLIMATE_FAN_QUIET = 9,
 };
 
 /// Enum for all modes a climate swing can be in
-/// NOTE: If adding values, update ClimateSwingModeMask in climate_traits.h to use the new last value
 enum ClimateSwingMode : uint8_t {
   /// The swing mode is set to Off
   CLIMATE_SWING_OFF = 0,
@@ -78,11 +75,10 @@ enum ClimateSwingMode : uint8_t {
   /// The fan mode is set to Vertical
   CLIMATE_SWING_VERTICAL = 2,
   /// The fan mode is set to Horizontal
-  CLIMATE_SWING_HORIZONTAL = 3,  // Update ClimateSwingModeMask in climate_traits.h if adding values after this
+  CLIMATE_SWING_HORIZONTAL = 3,
 };
 
 /// Enum for all preset modes
-/// NOTE: If adding values, update ClimatePresetMask in climate_traits.h to use the new last value
 enum ClimatePreset : uint8_t {
   /// No preset is active
   CLIMATE_PRESET_NONE = 0,
@@ -99,7 +95,7 @@ enum ClimatePreset : uint8_t {
   /// Device is prepared for sleep
   CLIMATE_PRESET_SLEEP = 6,
   /// Device is reacting to activity (e.g., movement sensors)
-  CLIMATE_PRESET_ACTIVITY = 7,  // Update ClimatePresetMask in climate_traits.h if adding values after this
+  CLIMATE_PRESET_ACTIVITY = 7,
 };
 
 enum ClimateFeature : uint32_t {

esphome/components/climate/climate_traits.h

@@ -1,33 +1,19 @@
 #pragma once
 
-#include <vector>
+#include <set>
 #include "climate_mode.h"
-#include "esphome/core/finite_set_mask.h"
 #include "esphome/core/helpers.h"
 
 namespace esphome {
+
+#ifdef USE_API
+namespace api {
+class APIConnection;
+}  // namespace api
+#endif
+
 namespace climate {
 
-// Type aliases for climate enum bitmasks
-// These replace std::set<EnumType> to eliminate red-black tree overhead
-// For contiguous enums starting at 0, DefaultBitPolicy provides 1:1 mapping (enum value = bit position)
-// Bitmask size is automatically calculated from the last enum value
-using ClimateModeMask = FiniteSetMask<ClimateMode, DefaultBitPolicy<ClimateMode, CLIMATE_MODE_AUTO + 1>>;
-using ClimateFanModeMask = FiniteSetMask<ClimateFanMode, DefaultBitPolicy<ClimateFanMode, CLIMATE_FAN_QUIET + 1>>;
-using ClimateSwingModeMask =
-    FiniteSetMask<ClimateSwingMode, DefaultBitPolicy<ClimateSwingMode, CLIMATE_SWING_HORIZONTAL + 1>>;
-using ClimatePresetMask = FiniteSetMask<ClimatePreset, DefaultBitPolicy<ClimatePreset, CLIMATE_PRESET_ACTIVITY + 1>>;
-
-// Lightweight linear search for small vectors (1-20 items)
-// Avoids std::find template overhead
-template<typename T> inline bool vector_contains(const std::vector<T> &vec, const T &value) {
-  for (const auto &item : vec) {
-    if (item == value)
-      return true;
-  }
-  return false;
-}
-
 /** This class contains all static data for climate devices.
  *
  * All climate devices must support these features:
@@ -121,60 +107,48 @@ class ClimateTraits {
     }
   }
 
-  void set_supported_modes(ClimateModeMask modes) { this->supported_modes_ = modes; }
+  void set_supported_modes(std::set<ClimateMode> modes) { this->supported_modes_ = std::move(modes); }
   void add_supported_mode(ClimateMode mode) { this->supported_modes_.insert(mode); }
   bool supports_mode(ClimateMode mode) const { return this->supported_modes_.count(mode); }
-  const ClimateModeMask &get_supported_modes() const { return this->supported_modes_; }
+  const std::set<ClimateMode> &get_supported_modes() const { return this->supported_modes_; }
 
-  void set_supported_fan_modes(ClimateFanModeMask modes) { this->supported_fan_modes_ = modes; }
+  void set_supported_fan_modes(std::set<ClimateFanMode> modes) { this->supported_fan_modes_ = std::move(modes); }
   void add_supported_fan_mode(ClimateFanMode mode) { this->supported_fan_modes_.insert(mode); }
-  void add_supported_custom_fan_mode(const std::string &mode) { this->supported_custom_fan_modes_.push_back(mode); }
+  void add_supported_custom_fan_mode(const std::string &mode) { this->supported_custom_fan_modes_.insert(mode); }
   bool supports_fan_mode(ClimateFanMode fan_mode) const { return this->supported_fan_modes_.count(fan_mode); }
   bool get_supports_fan_modes() const {
     return !this->supported_fan_modes_.empty() || !this->supported_custom_fan_modes_.empty();
   }
-  const ClimateFanModeMask &get_supported_fan_modes() const { return this->supported_fan_modes_; }
+  const std::set<ClimateFanMode> &get_supported_fan_modes() const { return this->supported_fan_modes_; }
 
-  void set_supported_custom_fan_modes(std::vector<std::string> supported_custom_fan_modes) {
+  void set_supported_custom_fan_modes(std::set<std::string> supported_custom_fan_modes) {
     this->supported_custom_fan_modes_ = std::move(supported_custom_fan_modes);
   }
-  void set_supported_custom_fan_modes(std::initializer_list<std::string> modes) {
-    this->supported_custom_fan_modes_ = modes;
-  }
-  template<size_t N> void set_supported_custom_fan_modes(const char *const (&modes)[N]) {
-    this->supported_custom_fan_modes_.assign(modes, modes + N);
-  }
-  const std::vector<std::string> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
+  const std::set<std::string> &get_supported_custom_fan_modes() const { return this->supported_custom_fan_modes_; }
   bool supports_custom_fan_mode(const std::string &custom_fan_mode) const {
-    return vector_contains(this->supported_custom_fan_modes_, custom_fan_mode);
+    return this->supported_custom_fan_modes_.count(custom_fan_mode);
   }
 
-  void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
+  void set_supported_presets(std::set<ClimatePreset> presets) { this->supported_presets_ = std::move(presets); }
   void add_supported_preset(ClimatePreset preset) { this->supported_presets_.insert(preset); }
-  void add_supported_custom_preset(const std::string &preset) { this->supported_custom_presets_.push_back(preset); }
+  void add_supported_custom_preset(const std::string &preset) { this->supported_custom_presets_.insert(preset); }
   bool supports_preset(ClimatePreset preset) const { return this->supported_presets_.count(preset); }
   bool get_supports_presets() const { return !this->supported_presets_.empty(); }
-  const ClimatePresetMask &get_supported_presets() const { return this->supported_presets_; }
+  const std::set<climate::ClimatePreset> &get_supported_presets() const { return this->supported_presets_; }
 
-  void set_supported_custom_presets(std::vector<std::string> supported_custom_presets) {
+  void set_supported_custom_presets(std::set<std::string> supported_custom_presets) {
     this->supported_custom_presets_ = std::move(supported_custom_presets);
   }
-  void set_supported_custom_presets(std::initializer_list<std::string> presets) {
-    this->supported_custom_presets_ = presets;
-  }
-  template<size_t N> void set_supported_custom_presets(const char *const (&presets)[N]) {
-    this->supported_custom_presets_.assign(presets, presets + N);
-  }
-  const std::vector<std::string> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
+  const std::set<std::string> &get_supported_custom_presets() const { return this->supported_custom_presets_; }
   bool supports_custom_preset(const std::string &custom_preset) const {
-    return vector_contains(this->supported_custom_presets_, custom_preset);
+    return this->supported_custom_presets_.count(custom_preset);
   }
 
-  void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
+  void set_supported_swing_modes(std::set<ClimateSwingMode> modes) { this->supported_swing_modes_ = std::move(modes); }
   void add_supported_swing_mode(ClimateSwingMode mode) { this->supported_swing_modes_.insert(mode); }
   bool supports_swing_mode(ClimateSwingMode swing_mode) const { return this->supported_swing_modes_.count(swing_mode); }
   bool get_supports_swing_modes() const { return !this->supported_swing_modes_.empty(); }
-  const ClimateSwingModeMask &get_supported_swing_modes() const { return this->supported_swing_modes_; }
+  const std::set<ClimateSwingMode> &get_supported_swing_modes() const { return this->supported_swing_modes_; }
 
   float get_visual_min_temperature() const { return this->visual_min_temperature_; }
   void set_visual_min_temperature(float visual_min_temperature) {
@@ -205,6 +179,23 @@ class ClimateTraits {
   void set_visual_max_humidity(float visual_max_humidity) { this->visual_max_humidity_ = visual_max_humidity; }
 
  protected:
+#ifdef USE_API
+  // The API connection is a friend class to access internal methods
+  friend class api::APIConnection;
+  // These methods return references to internal data structures.
+  // They are used by the API to avoid copying data when encoding messages.
+  // Warning: Do not use these methods outside of the API connection code.
+  // They return references to internal data that can be invalidated.
+  const std::set<ClimateMode> &get_supported_modes_for_api_() const { return this->supported_modes_; }
+  const std::set<ClimateFanMode> &get_supported_fan_modes_for_api_() const { return this->supported_fan_modes_; }
+  const std::set<std::string> &get_supported_custom_fan_modes_for_api_() const {
+    return this->supported_custom_fan_modes_;
+  }
+  const std::set<climate::ClimatePreset> &get_supported_presets_for_api_() const { return this->supported_presets_; }
+  const std::set<std::string> &get_supported_custom_presets_for_api_() const { return this->supported_custom_presets_; }
+  const std::set<ClimateSwingMode> &get_supported_swing_modes_for_api_() const { return this->supported_swing_modes_; }
+#endif
+
   void set_mode_support_(climate::ClimateMode mode, bool supported) {
     if (supported) {
       this->supported_modes_.insert(mode);
@@ -235,12 +226,12 @@ class ClimateTraits {
   float visual_min_humidity_{30};
   float visual_max_humidity_{99};
 
-  climate::ClimateModeMask supported_modes_{climate::CLIMATE_MODE_OFF};
-  climate::ClimateFanModeMask supported_fan_modes_;
-  climate::ClimateSwingModeMask supported_swing_modes_;
-  climate::ClimatePresetMask supported_presets_;
-  std::vector<std::string> supported_custom_fan_modes_;
-  std::vector<std::string> supported_custom_presets_;
+  std::set<climate::ClimateMode> supported_modes_ = {climate::CLIMATE_MODE_OFF};
+  std::set<climate::ClimateFanMode> supported_fan_modes_;
+  std::set<climate::ClimateSwingMode> supported_swing_modes_;
+  std::set<climate::ClimatePreset> supported_presets_;
+  std::set<std::string> supported_custom_fan_modes_;
+  std::set<std::string> supported_custom_presets_;
 };
 
 }  // namespace climate

esphome/components/climate_ir/climate_ir.h

@@ -24,18 +24,16 @@ class ClimateIR : public Component,
                   public remote_base::RemoteTransmittable {
  public:
   ClimateIR(float minimum_temperature, float maximum_temperature, float temperature_step = 1.0f,
-            bool supports_dry = false, bool supports_fan_only = false,
-            climate::ClimateFanModeMask fan_modes = climate::ClimateFanModeMask(),
-            climate::ClimateSwingModeMask swing_modes = climate::ClimateSwingModeMask(),
-            climate::ClimatePresetMask presets = climate::ClimatePresetMask()) {
+            bool supports_dry = false, bool supports_fan_only = false, std::set<climate::ClimateFanMode> fan_modes = {},
+            std::set<climate::ClimateSwingMode> swing_modes = {}, std::set<climate::ClimatePreset> presets = {}) {
     this->minimum_temperature_ = minimum_temperature;
     this->maximum_temperature_ = maximum_temperature;
     this->temperature_step_ = temperature_step;
     this->supports_dry_ = supports_dry;
     this->supports_fan_only_ = supports_fan_only;
-    this->fan_modes_ = fan_modes;
-    this->swing_modes_ = swing_modes;
-    this->presets_ = presets;
+    this->fan_modes_ = std::move(fan_modes);
+    this->swing_modes_ = std::move(swing_modes);
+    this->presets_ = std::move(presets);
   }
 
   void setup() override;
@@ -62,9 +60,9 @@ class ClimateIR : public Component,
   bool supports_heat_{true};
   bool supports_dry_{false};
   bool supports_fan_only_{false};
-  climate::ClimateFanModeMask fan_modes_{};
-  climate::ClimateSwingModeMask swing_modes_{};
-  climate::ClimatePresetMask presets_{};
+  std::set<climate::ClimateFanMode> fan_modes_ = {};
+  std::set<climate::ClimateSwingMode> swing_modes_ = {};
+  std::set<climate::ClimatePreset> presets_ = {};
 
   sensor::Sensor *sensor_{nullptr};
 };

esphome/components/esp32_ble/ble.cpp

@@ -76,10 +76,6 @@ void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->advertising_set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void ESP32BLE::advertising_set_manufacturer_data(std::span<const uint8_t> data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
   this->advertising_start();

esphome/components/esp32_ble/ble.h

@@ -118,7 +118,6 @@ class ESP32BLE : public Component {
   void advertising_start();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
-  void advertising_set_manufacturer_data(std::span<const uint8_t> data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
   void advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name);
   void advertising_add_service_uuid(ESPBTUUID uuid);

esphome/components/esp32_ble/ble_advertising.cpp

@@ -59,10 +59,6 @@ void BLEAdvertising::set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void BLEAdvertising::set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void BLEAdvertising::set_manufacturer_data(std::span<const uint8_t> data) {
   delete[] this->advertising_data_.p_manufacturer_data;
   this->advertising_data_.p_manufacturer_data = nullptr;
   this->advertising_data_.manufacturer_len = data.size();

esphome/components/esp32_ble/ble_advertising.h

@@ -37,7 +37,6 @@ class BLEAdvertising {
   void set_scan_response(bool scan_response) { this->scan_response_ = scan_response; }
   void set_min_preferred_interval(uint16_t interval) { this->advertising_data_.min_interval = interval; }
   void set_manufacturer_data(const std::vector<uint8_t> &data);
-  void set_manufacturer_data(std::span<const uint8_t> data);
   void set_appearance(uint16_t appearance) { this->advertising_data_.appearance = appearance; }
   void set_service_data(const std::vector<uint8_t> &data);
   void set_service_data(std::span<const uint8_t> data);

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -1,6 +1,5 @@
 #include "esp32_ble_beacon.h"
 #include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -15,10 +15,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;
@@ -30,10 +27,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;

esphome/components/ethernet/__init__.py

@@ -14,7 +14,7 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
 )
-from esphome.components.network import IPAddress
+from esphome.components.network import ip_address_literal
 from esphome.components.spi import CONF_INTERFACE_INDEX, get_spi_interface
 import esphome.config_validation as cv
 from esphome.const import (
@@ -320,11 +320,11 @@ def _final_validate_spi(config):
 def manual_ip(config):
     return cg.StructInitializer(
         ManualIP,
-        ("static_ip", IPAddress(str(config[CONF_STATIC_IP]))),
-        ("gateway", IPAddress(str(config[CONF_GATEWAY]))),
-        ("subnet", IPAddress(str(config[CONF_SUBNET]))),
-        ("dns1", IPAddress(str(config[CONF_DNS1]))),
-        ("dns2", IPAddress(str(config[CONF_DNS2]))),
+        ("static_ip", ip_address_literal(config[CONF_STATIC_IP])),
+        ("gateway", ip_address_literal(config[CONF_GATEWAY])),
+        ("subnet", ip_address_literal(config[CONF_SUBNET])),
+        ("dns1", ip_address_literal(config[CONF_DNS1])),
+        ("dns2", ip_address_literal(config[CONF_DNS2])),
     )
 
 

esphome/components/fan/fan.cpp

@@ -51,14 +51,7 @@ void FanCall::validate_() {
 
   if (!this->preset_mode_.empty()) {
     const auto &preset_modes = traits.supported_preset_modes();
-    bool found = false;
-    for (const auto &mode : preset_modes) {
-      if (mode == this->preset_mode_) {
-        found = true;
-        break;
-      }
-    }
-    if (!found) {
+    if (preset_modes.find(this->preset_mode_) == preset_modes.end()) {
       ESP_LOGW(TAG, "%s: Preset mode '%s' not supported", this->parent_.get_name().c_str(), this->preset_mode_.c_str());
       this->preset_mode_.clear();
     }
@@ -198,14 +191,9 @@ void Fan::save_state_() {
   if (this->get_traits().supports_preset_modes() && !this->preset_mode.empty()) {
     const auto &preset_modes = this->get_traits().supported_preset_modes();
     // Store index of current preset mode
-    size_t i = 0;
-    for (const auto &mode : preset_modes) {
-      if (mode == this->preset_mode) {
-        state.preset_mode = i;
-        break;
-      }
-      i++;
-    }
+    auto preset_iterator = preset_modes.find(this->preset_mode);
+    if (preset_iterator != preset_modes.end())
+      state.preset_mode = std::distance(preset_modes.begin(), preset_iterator);
   }
 
   this->rtc_.save(&state);

esphome/components/fan/fan_traits.h

@@ -1,6 +1,7 @@
-#pragma once
+#include <set>
+#include <utility>
 
-#include <vector>
+#pragma once
 
 namespace esphome {
 
@@ -35,9 +36,9 @@ class FanTraits {
   /// Set whether this fan supports changing direction
   void set_direction(bool direction) { this->direction_ = direction; }
   /// Return the preset modes supported by the fan.
-  const std::vector<std::string> &supported_preset_modes() const { return this->preset_modes_; }
+  std::set<std::string> supported_preset_modes() const { return this->preset_modes_; }
   /// Set the preset modes supported by the fan.
-  void set_supported_preset_modes(const std::vector<std::string> &preset_modes) { this->preset_modes_ = preset_modes; }
+  void set_supported_preset_modes(const std::set<std::string> &preset_modes) { this->preset_modes_ = preset_modes; }
   /// Return if preset modes are supported
   bool supports_preset_modes() const { return !this->preset_modes_.empty(); }
 
@@ -45,17 +46,17 @@ class FanTraits {
 #ifdef USE_API
   // The API connection is a friend class to access internal methods
   friend class api::APIConnection;
-  // This method returns a reference to the internal preset modes.
+  // This method returns a reference to the internal preset modes set.
   // It is used by the API to avoid copying data when encoding messages.
   // Warning: Do not use this method outside of the API connection code.
   // It returns a reference to internal data that can be invalidated.
-  const std::vector<std::string> &supported_preset_modes_for_api_() const { return this->preset_modes_; }
+  const std::set<std::string> &supported_preset_modes_for_api_() const { return this->preset_modes_; }
 #endif
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
   int speed_count_{};
-  std::vector<std::string> preset_modes_{};
+  std::set<std::string> preset_modes_{};
 };
 
 }  // namespace fan

esphome/components/haier/haier_base.cpp

@@ -171,7 +171,7 @@ void HaierClimateBase::toggle_power() {
       PendingAction({ActionRequest::TOGGLE_POWER, esphome::optional<haier_protocol::HaierMessage>()});
 }
 
-void HaierClimateBase::set_supported_swing_modes(climate::ClimateSwingModeMask modes) {
+void HaierClimateBase::set_supported_swing_modes(const std::set<climate::ClimateSwingMode> &modes) {
   this->traits_.set_supported_swing_modes(modes);
   if (!modes.empty())
     this->traits_.add_supported_swing_mode(climate::CLIMATE_SWING_OFF);
@@ -179,13 +179,13 @@ void HaierClimateBase::set_supported_swing_modes(climate::ClimateSwingModeMask m
 
 void HaierClimateBase::set_answer_timeout(uint32_t timeout) { this->haier_protocol_.set_answer_timeout(timeout); }
 
-void HaierClimateBase::set_supported_modes(climate::ClimateModeMask modes) {
+void HaierClimateBase::set_supported_modes(const std::set<climate::ClimateMode> &modes) {
   this->traits_.set_supported_modes(modes);
   this->traits_.add_supported_mode(climate::CLIMATE_MODE_OFF);        // Always available
   this->traits_.add_supported_mode(climate::CLIMATE_MODE_HEAT_COOL);  // Always available
 }
 
-void HaierClimateBase::set_supported_presets(climate::ClimatePresetMask presets) {
+void HaierClimateBase::set_supported_presets(const std::set<climate::ClimatePreset> &presets) {
   this->traits_.set_supported_presets(presets);
   if (!presets.empty())
     this->traits_.add_supported_preset(climate::CLIMATE_PRESET_NONE);

esphome/components/haier/haier_base.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <chrono>
+#include <set>
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/automation.h"
@@ -59,9 +60,9 @@ class HaierClimateBase : public esphome::Component,
   void send_power_off_command();
   void toggle_power();
   void reset_protocol() { this->reset_protocol_request_ = true; };
-  void set_supported_modes(esphome::climate::ClimateModeMask modes);
-  void set_supported_swing_modes(esphome::climate::ClimateSwingModeMask modes);
-  void set_supported_presets(esphome::climate::ClimatePresetMask presets);
+  void set_supported_modes(const std::set<esphome::climate::ClimateMode> &modes);
+  void set_supported_swing_modes(const std::set<esphome::climate::ClimateSwingMode> &modes);
+  void set_supported_presets(const std::set<esphome::climate::ClimatePreset> &presets);
   bool valid_connection() const { return this->protocol_phase_ >= ProtocolPhases::IDLE; };
   size_t available() noexcept override { return esphome::uart::UARTDevice::available(); };
   size_t read_array(uint8_t *data, size_t len) noexcept override {

esphome/components/haier/hon_climate.cpp

@@ -1033,9 +1033,9 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
   {
     // Swing mode
     ClimateSwingMode old_swing_mode = this->swing_mode;
-    const auto &swing_modes = traits_.get_supported_swing_modes();
-    bool vertical_swing_supported = swing_modes.count(CLIMATE_SWING_VERTICAL);
-    bool horizontal_swing_supported = swing_modes.count(CLIMATE_SWING_HORIZONTAL);
+    const std::set<ClimateSwingMode> &swing_modes = traits_.get_supported_swing_modes();
+    bool vertical_swing_supported = swing_modes.find(CLIMATE_SWING_VERTICAL) != swing_modes.end();
+    bool horizontal_swing_supported = swing_modes.find(CLIMATE_SWING_HORIZONTAL) != swing_modes.end();
     if (horizontal_swing_supported &&
         (packet.control.horizontal_swing_mode == (uint8_t) hon_protocol::HorizontalSwingMode::AUTO)) {
       if (vertical_swing_supported &&
@@ -1218,13 +1218,13 @@ void HonClimate::fill_control_messages_queue_() {
                                                 (uint8_t) hon_protocol::DataParameters::QUIET_MODE,
                                             quiet_mode_buf, 2);
     }
-    if ((fast_mode_buf[1] != 0xFF) && presets.count(climate::ClimatePreset::CLIMATE_PRESET_BOOST)) {
+    if ((fast_mode_buf[1] != 0xFF) && ((presets.find(climate::ClimatePreset::CLIMATE_PRESET_BOOST) != presets.end()))) {
       this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                             (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                 (uint8_t) hon_protocol::DataParameters::FAST_MODE,
                                             fast_mode_buf, 2);
     }
-    if ((away_mode_buf[1] != 0xFF) && presets.count(climate::ClimatePreset::CLIMATE_PRESET_AWAY)) {
+    if ((away_mode_buf[1] != 0xFF) && ((presets.find(climate::ClimatePreset::CLIMATE_PRESET_AWAY) != presets.end()))) {
       this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
                                             (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                                 (uint8_t) hon_protocol::DataParameters::TEN_DEGREE,

esphome/components/hbridge/fan/hbridge_fan.h

@@ -22,7 +22,7 @@ class HBridgeFan : public Component, public fan::Fan {
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
   void set_enable_pin(output::FloatOutput *enable) { enable_ = enable; }
-  void set_preset_modes(const std::vector<std::string> &presets) { preset_modes_ = presets; }
+  void set_preset_modes(const std::set<std::string> &presets) { preset_modes_ = presets; }
 
   void setup() override;
   void dump_config() override;
@@ -38,7 +38,7 @@ class HBridgeFan : public Component, public fan::Fan {
   int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
-  std::vector<std::string> preset_modes_{};
+  std::set<std::string> preset_modes_{};
 
   void control(const fan::FanCall &call) override;
   void write_state_();

esphome/components/heatpumpir/heatpumpir.h

@@ -97,11 +97,12 @@ const float TEMP_MAX = 100;  // Celsius
 class HeatpumpIRClimate : public climate_ir::ClimateIR {
  public:
   HeatpumpIRClimate()
-      : climate_ir::ClimateIR(TEMP_MIN, TEMP_MAX, 1.0f, true, true,
-                              {climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH,
-                               climate::CLIMATE_FAN_AUTO},
-                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL,
-                               climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_BOTH}) {}
+      : climate_ir::ClimateIR(
+            TEMP_MIN, TEMP_MAX, 1.0f, true, true,
+            std::set<climate::ClimateFanMode>{climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM,
+                                              climate::CLIMATE_FAN_HIGH, climate::CLIMATE_FAN_AUTO},
+            std::set<climate::ClimateSwingMode>{climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL,
+                                                climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_BOTH}) {}
   void setup() override;
   void set_protocol(Protocol protocol) { this->protocol_ = protocol; }
   void set_horizontal_default(HorizontalDirection horizontal_direction) {

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -107,7 +107,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/light/addressable_light_effect.h

@@ -57,9 +57,9 @@ class AddressableLightEffect : public LightEffect {
 
 class AddressableLambdaLightEffect : public AddressableLightEffect {
  public:
-  AddressableLambdaLightEffect(const char *name, std::function<void(AddressableLight &, Color, bool initial_run)> f,
+  AddressableLambdaLightEffect(const char *name, void (*f)(AddressableLight &, Color, bool initial_run),
                                uint32_t update_interval)
-      : AddressableLightEffect(name), f_(std::move(f)), update_interval_(update_interval) {}
+      : AddressableLightEffect(name), f_(f), update_interval_(update_interval) {}
   void start() override { this->initial_run_ = true; }
   void apply(AddressableLight &it, const Color &current_color) override {
     const uint32_t now = millis();
@@ -72,7 +72,7 @@ class AddressableLambdaLightEffect : public AddressableLightEffect {
   }
 
  protected:
-  std::function<void(AddressableLight &, Color, bool initial_run)> f_;
+  void (*f_)(AddressableLight &, Color, bool initial_run);
   uint32_t update_interval_;
   uint32_t last_run_{0};
   bool initial_run_;

esphome/components/light/base_light_effects.h

@@ -112,8 +112,8 @@ class RandomLightEffect : public LightEffect {
 
 class LambdaLightEffect : public LightEffect {
  public:
-  LambdaLightEffect(const char *name, std::function<void(bool initial_run)> f, uint32_t update_interval)
-      : LightEffect(name), f_(std::move(f)), update_interval_(update_interval) {}
+  LambdaLightEffect(const char *name, void (*f)(bool initial_run), uint32_t update_interval)
+      : LightEffect(name), f_(f), update_interval_(update_interval) {}
 
   void start() override { this->initial_run_ = true; }
   void apply() override {
@@ -130,7 +130,7 @@ class LambdaLightEffect : public LightEffect {
   uint32_t get_current_index() const { return this->get_index(); }
 
  protected:
-  std::function<void(bool initial_run)> f_;
+  void (*f_)(bool initial_run);
   uint32_t update_interval_;
   uint32_t last_run_{0};
   bool initial_run_;

esphome/components/lvgl/lvgl_esphome.h

@@ -358,7 +358,7 @@ class LvSelectable : public LvCompound {
   virtual void set_selected_index(size_t index, lv_anim_enable_t anim) = 0;
   void set_selected_text(const std::string &text, lv_anim_enable_t anim);
   std::string get_selected_text();
-  const std::vector<std::string> &get_options() { return this->options_; }
+  std::vector<std::string> get_options() { return this->options_; }
   void set_options(std::vector<std::string> options);
 
  protected:

esphome/components/lvgl/select/lvgl_select.h

@@ -53,17 +53,7 @@ class LVGLSelect : public select::Select, public Component {
     this->widget_->set_selected_text(value, this->anim_);
     this->publish();
   }
-  void set_options_() {
-    // Widget uses std::vector<std::string>, SelectTraits uses FixedVector<const char*>
-    // Convert by extracting c_str() pointers
-    const auto &opts = this->widget_->get_options();
-    FixedVector<const char *> opt_ptrs;
-    opt_ptrs.init(opts.size());
-    for (size_t i = 0; i < opts.size(); i++) {
-      opt_ptrs[i] = opts[i].c_str();
-    }
-    this->traits.set_options(opt_ptrs);
-  }
+  void set_options_() { this->traits.set_options(this->widget_->get_options()); }
 
   LvSelectable *widget_;
   lv_anim_enable_t anim_;

esphome/components/mcp23016/mcp23016.cpp

@@ -56,7 +56,7 @@ void MCP23016::pin_mode(uint8_t pin, gpio::Flags flags) {
     this->update_reg_(pin, false, iodir);
   }
 }
-float MCP23016::get_setup_priority() const { return setup_priority::IO; }
+float MCP23016::get_setup_priority() const { return setup_priority::HARDWARE; }
 bool MCP23016::read_reg_(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;

esphome/components/midea/air_conditioner.h

@@ -19,9 +19,6 @@ using climate::ClimateTraits;
 using climate::ClimateMode;
 using climate::ClimateSwingMode;
 using climate::ClimateFanMode;
-using climate::ClimateModeMask;
-using climate::ClimateSwingModeMask;
-using climate::ClimatePresetMask;
 
 class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>, public climate::Climate {
  public:
@@ -43,20 +40,20 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   void do_power_on() { this->base_.setPowerState(true); }
   void do_power_off() { this->base_.setPowerState(false); }
   void do_power_toggle() { this->base_.setPowerState(this->mode == ClimateMode::CLIMATE_MODE_OFF); }
-  void set_supported_modes(ClimateModeMask modes) { this->supported_modes_ = modes; }
-  void set_supported_swing_modes(ClimateSwingModeMask modes) { this->supported_swing_modes_ = modes; }
-  void set_supported_presets(ClimatePresetMask presets) { this->supported_presets_ = presets; }
-  void set_custom_presets(const std::vector<std::string> &presets) { this->supported_custom_presets_ = presets; }
-  void set_custom_fan_modes(const std::vector<std::string> &modes) { this->supported_custom_fan_modes_ = modes; }
+  void set_supported_modes(const std::set<ClimateMode> &modes) { this->supported_modes_ = modes; }
+  void set_supported_swing_modes(const std::set<ClimateSwingMode> &modes) { this->supported_swing_modes_ = modes; }
+  void set_supported_presets(const std::set<ClimatePreset> &presets) { this->supported_presets_ = presets; }
+  void set_custom_presets(const std::set<std::string> &presets) { this->supported_custom_presets_ = presets; }
+  void set_custom_fan_modes(const std::set<std::string> &modes) { this->supported_custom_fan_modes_ = modes; }
 
  protected:
   void control(const ClimateCall &call) override;
   ClimateTraits traits() override;
-  ClimateModeMask supported_modes_{};
-  ClimateSwingModeMask supported_swing_modes_{};
-  ClimatePresetMask supported_presets_{};
-  std::vector<std::string> supported_custom_presets_{};
-  std::vector<std::string> supported_custom_fan_modes_{};
+  std::set<ClimateMode> supported_modes_{};
+  std::set<ClimateSwingMode> supported_swing_modes_{};
+  std::set<ClimatePreset> supported_presets_{};
+  std::set<std::string> supported_custom_presets_{};
+  std::set<std::string> supported_custom_fan_modes_{};
   Sensor *outdoor_sensor_{nullptr};
   Sensor *humidity_sensor_{nullptr};
   Sensor *power_sensor_{nullptr};

esphome/components/modbus_controller/select/modbus_select.cpp

@@ -28,7 +28,7 @@ void ModbusSelect::parse_and_publish(const std::vector<uint8_t> &data) {
 
     if (map_it != this->mapping_.cend()) {
       size_t idx = std::distance(this->mapping_.cbegin(), map_it);
-      new_state = std::string(this->traits.get_options()[idx]);
+      new_state = this->traits.get_options()[idx];
       ESP_LOGV(TAG, "Found option %s for value %lld", new_state->c_str(), value);
     } else {
       ESP_LOGE(TAG, "No option found for mapping %lld", value);
@@ -41,12 +41,10 @@ void ModbusSelect::parse_and_publish(const std::vector<uint8_t> &data) {
 }
 
 void ModbusSelect::control(const std::string &value) {
-  auto idx = this->index_of(value);
-  if (!idx.has_value()) {
-    ESP_LOGW(TAG, "Invalid option '%s'", value.c_str());
-    return;
-  }
-  optional<int64_t> mapval = this->mapping_[idx.value()];
+  auto options = this->traits.get_options();
+  auto opt_it = std::find(options.cbegin(), options.cend(), value);
+  size_t idx = std::distance(options.cbegin(), opt_it);
+  optional<int64_t> mapval = this->mapping_[idx];
   ESP_LOGD(TAG, "Found value %lld for option '%s'", *mapval, value.c_str());
 
   std::vector<uint16_t> data;

esphome/components/network/__init__.py

@@ -1,3 +1,5 @@
+import ipaddress
+
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_sdkconfig_option
 import esphome.config_validation as cv
@@ -10,6 +12,41 @@ AUTO_LOAD = ["mdns"]
 network_ns = cg.esphome_ns.namespace("network")
 IPAddress = network_ns.class_("IPAddress")
 
+
+def ip_address_literal(ip: str | int | None) -> cg.MockObj:
+    """Generate an IPAddress with compile-time initialization instead of runtime parsing.
+
+    This function parses the IP address in Python during code generation and generates
+    a call to the 4-octet constructor (IPAddress(192, 168, 1, 1)) instead of the
+    string constructor (IPAddress("192.168.1.1")). This eliminates runtime string
+    parsing overhead and reduces flash usage on embedded systems.
+
+    Args:
+        ip: IP address as string (e.g., "192.168.1.1"), ipaddress.IPv4Address, or None
+
+    Returns:
+        IPAddress expression that uses 4-octet constructor for efficiency
+    """
+    if ip is None:
+        return IPAddress(0, 0, 0, 0)
+
+    try:
+        # Parse using Python's ipaddress module
+        ip_obj = ipaddress.ip_address(ip)
+    except (ValueError, TypeError):
+        pass
+    else:
+        # Only support IPv4 for now
+        if isinstance(ip_obj, ipaddress.IPv4Address):
+            # Extract octets from the packed bytes representation
+            octets = ip_obj.packed
+            # Generate call to 4-octet constructor: IPAddress(192, 168, 1, 1)
+            return IPAddress(octets[0], octets[1], octets[2], octets[3])
+
+    # Fallback to string constructor if parsing fails
+    return IPAddress(str(ip))
+
+
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.SplitDefault(

esphome/components/nextion/nextion.h

@@ -540,6 +540,23 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    */
   void goto_page(uint8_t page);
 
+  /**
+   * Set the visibility of a component.
+   *
+   * @param component The component name.
+   * @param show True to show the component, false to hide it.
+   *
+   * @see show_component()
+   * @see hide_component()
+   *
+   * Example:
+   * ```cpp
+   * it.set_component_visibility("textview", true);   // Equivalent to show_component("textview")
+   * it.set_component_visibility("textview", false);  // Equivalent to hide_component("textview")
+   * ```
+   */
+  void set_component_visibility(const char *component, bool show) override;
+
   /**
    * Hide a component.
    * @param component The component name.

esphome/components/nextion/nextion_base.h

@@ -45,6 +45,7 @@ class NextionBase {
   virtual void set_component_pressed_font_color(const char *component, Color color) = 0;
   virtual void set_component_font(const char *component, uint8_t font_id) = 0;
 
+  virtual void set_component_visibility(const char *component, bool show) = 0;
   virtual void show_component(const char *component) = 0;
   virtual void hide_component(const char *component) = 0;
 

esphome/components/nextion/nextion_commands.cpp

@@ -201,13 +201,13 @@ void Nextion::set_component_font(const char *component, uint8_t font_id) {
   this->add_no_result_to_queue_with_printf_("set_component_font", "%s.font=%" PRIu8, component, font_id);
 }
 
-void Nextion::hide_component(const char *component) {
-  this->add_no_result_to_queue_with_printf_("hide_component", "vis %s,0", component);
+void Nextion::set_component_visibility(const char *component, bool show) {
+  this->add_no_result_to_queue_with_printf_("set_component_visibility", "vis %s,%d", component, show ? 1 : 0);
 }
 
-void Nextion::show_component(const char *component) {
-  this->add_no_result_to_queue_with_printf_("show_component", "vis %s,1", component);
-}
+void Nextion::hide_component(const char *component) { this->set_component_visibility(component, false); }
+
+void Nextion::show_component(const char *component) { this->set_component_visibility(component, true); }
 
 void Nextion::enable_component_touch(const char *component) {
   this->add_no_result_to_queue_with_printf_("enable_component_touch", "tsw %s,1", component);

esphome/components/nextion/nextion_component.cpp

@@ -81,13 +81,11 @@ void NextionComponent::update_component_settings(bool force_update) {
 
     this->component_flags_.visible_needs_update = false;
 
-    if (this->component_flags_.visible) {
-      this->nextion_->show_component(name_to_send.c_str());
-      this->send_state_to_nextion();
-    } else {
-      this->nextion_->hide_component(name_to_send.c_str());
+    this->nextion_->set_component_visibility(name_to_send.c_str(), this->component_flags_.visible);
+    if (!this->component_flags_.visible) {
       return;
     }
+    this->send_state_to_nextion();
   }
 
   if (this->component_flags_.bco_needs_update || (force_update && this->component_flags_.bco2_is_set)) {

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -174,11 +174,6 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   // Check if baud rate is supported
   this->original_baud_rate_ = this->parent_->get_baud_rate();
-  static const std::vector<uint32_t> SUPPORTED_BAUD_RATES = {2400,   4800,   9600,   19200,  31250,  38400, 57600,
-                                                             115200, 230400, 250000, 256000, 512000, 921600};
-  if (std::find(SUPPORTED_BAUD_RATES.begin(), SUPPORTED_BAUD_RATES.end(), baud_rate) == SUPPORTED_BAUD_RATES.end()) {
-    baud_rate = this->original_baud_rate_;
-  }
   ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
 
   // Define the configuration for the HTTP client

esphome/components/nextion/nextion_upload_idf.cpp

@@ -177,11 +177,6 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   // Check if baud rate is supported
   this->original_baud_rate_ = this->parent_->get_baud_rate();
-  static const std::vector<uint32_t> SUPPORTED_BAUD_RATES = {2400,   4800,   9600,   19200,  31250,  38400, 57600,
-                                                             115200, 230400, 250000, 256000, 512000, 921600};
-  if (std::find(SUPPORTED_BAUD_RATES.begin(), SUPPORTED_BAUD_RATES.end(), baud_rate) == SUPPORTED_BAUD_RATES.end()) {
-    baud_rate = this->original_baud_rate_;
-  }
   ESP_LOGD(TAG, "Baud rate: %" PRIu32, baud_rate);
 
   // Define the configuration for the HTTP client

esphome/components/select/select.cpp

@@ -1,6 +1,5 @@
 #include "select.h"
 #include "esphome/core/log.h"
-#include <cstring>
 
 namespace esphome {
 namespace select {
@@ -36,7 +35,7 @@ size_t Select::size() const {
 optional<size_t> Select::index_of(const std::string &option) const {
   const auto &options = traits.get_options();
   for (size_t i = 0; i < options.size(); i++) {
-    if (strcmp(options[i], option.c_str()) == 0) {
+    if (options[i] == option) {
       return i;
     }
   }
@@ -54,7 +53,7 @@ optional<size_t> Select::active_index() const {
 optional<std::string> Select::at(size_t index) const {
   if (this->has_index(index)) {
     const auto &options = traits.get_options();
-    return std::string(options.at(index));
+    return options.at(index);
   } else {
     return {};
   }

esphome/components/select/select_traits.cpp

@@ -3,16 +3,9 @@
 namespace esphome {
 namespace select {
 
-void SelectTraits::set_options(const std::initializer_list<const char *> &options) { this->options_ = options; }
+void SelectTraits::set_options(std::vector<std::string> options) { this->options_ = std::move(options); }
 
-void SelectTraits::set_options(const FixedVector<const char *> &options) {
-  this->options_.init(options.size());
-  for (size_t i = 0; i < options.size(); i++) {
-    this->options_[i] = options[i];
-  }
-}
-
-const FixedVector<const char *> &SelectTraits::get_options() const { return this->options_; }
+const std::vector<std::string> &SelectTraits::get_options() const { return this->options_; }
 
 }  // namespace select
 }  // namespace esphome

esphome/components/select/select_traits.h

@@ -1,19 +1,18 @@
 #pragma once
 
-#include "esphome/core/helpers.h"
-#include <initializer_list>
+#include <vector>
+#include <string>
 
 namespace esphome {
 namespace select {
 
 class SelectTraits {
  public:
-  void set_options(const std::initializer_list<const char *> &options);
-  void set_options(const FixedVector<const char *> &options);
-  const FixedVector<const char *> &get_options() const;
+  void set_options(std::vector<std::string> options);
+  const std::vector<std::string> &get_options() const;
 
  protected:
-  FixedVector<const char *> options_;
+  std::vector<std::string> options_;
 };
 
 }  // namespace select

esphome/components/speed/fan/speed_fan.h

@@ -18,7 +18,7 @@ class SpeedFan : public Component, public fan::Fan {
   void set_output(output::FloatOutput *output) { this->output_ = output; }
   void set_oscillating(output::BinaryOutput *oscillating) { this->oscillating_ = oscillating; }
   void set_direction(output::BinaryOutput *direction) { this->direction_ = direction; }
-  void set_preset_modes(const std::vector<std::string> &presets) { this->preset_modes_ = presets; }
+  void set_preset_modes(const std::set<std::string> &presets) { this->preset_modes_ = presets; }
   fan::FanTraits get_traits() override { return this->traits_; }
 
  protected:
@@ -30,7 +30,7 @@ class SpeedFan : public Component, public fan::Fan {
   output::BinaryOutput *direction_{nullptr};
   int speed_count_{};
   fan::FanTraits traits_;
-  std::vector<std::string> preset_modes_{};
+  std::set<std::string> preset_modes_{};
 };
 
 }  // namespace speed

esphome/components/substitutions/__init__.py

@@ -1,4 +1,6 @@
 import logging
+from re import Match
+from typing import Any
 
 from esphome import core
 from esphome.config_helpers import Extend, Remove, merge_config, merge_dicts_ordered
@@ -39,7 +41,34 @@ async def to_code(config):
     pass
 
 
-def _expand_jinja(value, orig_value, path, jinja, ignore_missing):
+def _restore_data_base(value: Any, orig_value: ESPHomeDataBase) -> ESPHomeDataBase:
+    """This function restores ESPHomeDataBase metadata held by the original string.
+    This is needed because during jinja evaluation, strings can be replaced by other types,
+    but we want to keep the original metadata for error reporting and source mapping.
+    For example, if a substitution replaces a string with a dictionary, we want that items
+    in the dictionary to still point to the original document location
+    """
+    if isinstance(value, ESPHomeDataBase):
+        return value
+    if isinstance(value, dict):
+        return {
+            _restore_data_base(k, orig_value): _restore_data_base(v, orig_value)
+            for k, v in value.items()
+        }
+    if isinstance(value, list):
+        return [_restore_data_base(v, orig_value) for v in value]
+    if isinstance(value, str):
+        return make_data_base(value, orig_value)
+    return value
+
+
+def _expand_jinja(
+    value: str | JinjaStr,
+    orig_value: str | JinjaStr,
+    path,
+    jinja: Jinja,
+    ignore_missing: bool,
+) -> Any:
     if has_jinja(value):
         # If the original value passed in to this function is a JinjaStr, it means it contains an unresolved
         # Jinja expression from a previous pass.
@@ -65,10 +94,17 @@ def _expand_jinja(value, orig_value, path, jinja, ignore_missing):
                 f"\nSee {'->'.join(str(x) for x in path)}",
                 path,
             )
+        # If the original, unexpanded string, contained document metadata (ESPHomeDatabase),
+        # assign this same document metadata to the resulting value.
+        if isinstance(orig_value, ESPHomeDataBase):
+            value = _restore_data_base(value, orig_value)
+
     return value
 
 
-def _expand_substitutions(substitutions, value, path, jinja, ignore_missing):
+def _expand_substitutions(
+    substitutions: dict, value: str, path, jinja: Jinja, ignore_missing: bool
+) -> Any:
     if "$" not in value:
         return value
 
@@ -76,14 +112,14 @@ def _expand_substitutions(substitutions, value, path, jinja, ignore_missing):
 
     i = 0
     while True:
-        m = cv.VARIABLE_PROG.search(value, i)
+        m: Match[str] = cv.VARIABLE_PROG.search(value, i)
         if not m:
             # No more variable substitutions found. See if the remainder looks like a jinja template
             value = _expand_jinja(value, orig_value, path, jinja, ignore_missing)
             break
 
         i, j = m.span(0)
-        name = m.group(1)
+        name: str = m.group(1)
         if name.startswith("{") and name.endswith("}"):
             name = name[1:-1]
         if name not in substitutions:
@@ -98,7 +134,7 @@ def _expand_substitutions(substitutions, value, path, jinja, ignore_missing):
             i = j
             continue
 
-        sub = substitutions[name]
+        sub: Any = substitutions[name]
 
         if i == 0 and j == len(value):
             # The variable spans the whole expression, e.g., "${varName}". Return its resolved value directly
@@ -121,7 +157,13 @@ def _expand_substitutions(substitutions, value, path, jinja, ignore_missing):
     return value
 
 
-def _substitute_item(substitutions, item, path, jinja, ignore_missing):
+def _substitute_item(
+    substitutions: dict,
+    item: Any,
+    path: list[int | str],
+    jinja: Jinja,
+    ignore_missing: bool,
+) -> Any | None:
     if isinstance(item, ESPLiteralValue):
         return None  # do not substitute inside literal blocks
     if isinstance(item, list):
@@ -160,7 +202,9 @@ def _substitute_item(substitutions, item, path, jinja, ignore_missing):
     return None
 
 
-def do_substitution_pass(config, command_line_substitutions, ignore_missing=False):
+def do_substitution_pass(
+    config: dict, command_line_substitutions: dict, ignore_missing: bool = False
+) -> None:
     if CONF_SUBSTITUTIONS not in config and not command_line_substitutions:
         return
 

esphome/components/substitutions/jinja.py

@@ -1,10 +1,14 @@
 from ast import literal_eval
+from collections.abc import Iterator
+from itertools import chain, islice
 import logging
 import math
 import re
+from types import GeneratorType
+from typing import Any
 
 import jinja2 as jinja
-from jinja2.sandbox import SandboxedEnvironment
+from jinja2.nativetypes import NativeCodeGenerator, NativeTemplate
 
 from esphome.yaml_util import ESPLiteralValue
 
@@ -24,7 +28,7 @@ detect_jinja_re = re.compile(
 )
 
 
-def has_jinja(st):
+def has_jinja(st: str) -> bool:
     return detect_jinja_re.search(st) is not None
 
 
@@ -109,12 +113,56 @@ class TrackerContext(jinja.runtime.Context):
         return val
 
 
-class Jinja(SandboxedEnvironment):
+def _concat_nodes_override(values: Iterator[Any]) -> Any:
+    """
+    This function customizes how Jinja preserves native types when concatenating
+    multiple result nodes together. If the result is a single node, its value
+    is returned. Otherwise, the nodes are concatenated as strings. If
+    the result can be parsed with `ast.literal_eval`, the parsed
+    value is returned. Otherwise, the string is returned.
+    This helps preserve metadata such as ESPHomeDataBase from original values
+    and mimicks how HomeAssistant deals with template evaluation and preserving
+    the original datatype.
+    """
+    head: list[Any] = list(islice(values, 2))
+
+    if not head:
+        return None
+
+    if len(head) == 1:
+        raw = head[0]
+        if not isinstance(raw, str):
+            return raw
+    else:
+        if isinstance(values, GeneratorType):
+            values = chain(head, values)
+        raw = "".join([str(v) for v in values])
+
+    try:
+        # Attempt to parse the concatenated string into a Python literal.
+        # This allows expressions like "1 + 2" to be evaluated to the integer 3.
+        # If the result is also a string or there is a parsing error,
+        # fall back to returning the raw string. This is consistent with
+        #  Home Assistant's behavior when evaluating templates
+        result = literal_eval(raw)
+        if not isinstance(result, str):
+            return result
+
+    except (ValueError, SyntaxError, MemoryError, TypeError):
+        pass
+    return raw
+
+
+class Jinja(jinja.Environment):
     """
     Wraps a Jinja environment
     """
 
-    def __init__(self, context_vars):
+    # jinja environment customization overrides
+    code_generator_class = NativeCodeGenerator
+    concat = staticmethod(_concat_nodes_override)
+
+    def __init__(self, context_vars: dict):
         super().__init__(
             trim_blocks=True,
             lstrip_blocks=True,
@@ -142,19 +190,10 @@ class Jinja(SandboxedEnvironment):
             **SAFE_GLOBALS,
         }
 
-    def safe_eval(self, expr):
-        try:
-            result = literal_eval(expr)
-            if not isinstance(result, str):
-                return result
-        except (ValueError, SyntaxError, MemoryError, TypeError):
-            pass
-        return expr
-
-    def expand(self, content_str):
+    def expand(self, content_str: str | JinjaStr) -> Any:
         """
         Renders a string that may contain Jinja expressions or statements
-        Returns the resulting processed string if all values could be resolved.
+        Returns the resulting value if all variables and expressions could be resolved.
         Otherwise, it returns a tagged (JinjaStr) string that captures variables
         in scope (upvalues), like a closure for later evaluation.
         """
@@ -172,7 +211,7 @@ class Jinja(SandboxedEnvironment):
         self.context_trace = {}
         try:
             template = self.from_string(content_str)
-            result = self.safe_eval(template.render(override_vars))
+            result = template.render(override_vars)
             if isinstance(result, Undefined):
                 print("" + result)  # force a UndefinedError exception
         except (TemplateSyntaxError, UndefinedError) as err:
@@ -201,3 +240,10 @@ class Jinja(SandboxedEnvironment):
             content_str.result = result
 
         return result, None
+
+
+class JinjaTemplate(NativeTemplate):
+    environment_class = Jinja
+
+
+Jinja.template_class = JinjaTemplate

esphome/components/template/binary_sensor/__init__.py

@@ -10,9 +10,6 @@ from .. import template_ns
 TemplateBinarySensor = template_ns.class_(
     "TemplateBinarySensor", binary_sensor.BinarySensor, cg.Component
 )
-StatelessTemplateBinarySensor = template_ns.class_(
-    "StatelessTemplateBinarySensor", binary_sensor.BinarySensor, cg.Component
-)
 
 CONFIG_SCHEMA = (
     binary_sensor.binary_sensor_schema(TemplateBinarySensor)
@@ -29,33 +26,28 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
-    # Check if we have a lambda first - determines which class to instantiate
+    var = await binary_sensor.new_binary_sensor(config)
+    await cg.register_component(var, config)
+
     if lamb := config.get(CONF_LAMBDA):
-        # Use new_lambda_pvariable to create either TemplateBinarySensor or StatelessTemplateBinarySensor
         template_ = await cg.process_lambda(
             lamb, [], return_type=cg.optional.template(bool)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateBinarySensor
-        )
-        # Manually register as binary sensor since we didn't use new_binary_sensor
-        await binary_sensor.register_binary_sensor(var, config)
-        await cg.register_component(var, config)
-    elif condition := config.get(CONF_CONDITION):
-        # For conditions, create stateful version and set template
-        var = await binary_sensor.new_binary_sensor(config)
-        await cg.register_component(var, config)
+        cg.add(var.set_template(template_))
+    if condition := config.get(CONF_CONDITION):
         condition = await automation.build_condition(
             condition, cg.TemplateArguments(), []
         )
+        # Generate a stateless lambda that calls condition.check()
+        # capture="" is safe because condition is a global variable in generated C++ code
+        # and doesn't need to be captured. This allows implicit conversion to function pointer.
         template_ = LambdaExpression(
-            f"return {condition.check()};", [], return_type=cg.optional.template(bool)
+            f"return {condition.check()};",
+            [],
+            return_type=cg.optional.template(bool),
+            capture="",
         )
         cg.add(var.set_template(template_))
-    else:
-        # No lambda or condition - just create the base template sensor
-        var = await binary_sensor.new_binary_sensor(config)
-        await cg.register_component(var, config)
 
 
 @automation.register_action(

esphome/components/template/binary_sensor/template_binary_sensor.cpp

@@ -6,13 +6,18 @@ namespace template_ {
 
 static const char *const TAG = "template.binary_sensor";
 
-// Template instantiations
-template<typename F> void TemplateBinarySensorBase<F>::dump_config() {
-  LOG_BINARY_SENSOR("", "Template Binary Sensor", this);
-}
+void TemplateBinarySensor::setup() { this->loop(); }
 
-template class TemplateBinarySensorBase<std::function<optional<bool>()>>;
-template class TemplateBinarySensorBase<optional<bool> (*)()>;
+void TemplateBinarySensor::loop() {
+  if (!this->f_.has_value())
+    return;
+
+  auto s = (*this->f_)();
+  if (s.has_value()) {
+    this->publish_state(*s);
+  }
+}
+void TemplateBinarySensor::dump_config() { LOG_BINARY_SENSOR("", "Template Binary Sensor", this); }
 
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/binary_sensor/template_binary_sensor.h

@@ -6,41 +6,18 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateBinarySensorBase : public Component, public binary_sensor::BinarySensor {
+class TemplateBinarySensor : public Component, public binary_sensor::BinarySensor {
  public:
-  void setup() override { this->loop(); }
-
-  void loop() override {
-    if (this->f_ == nullptr)
-      return;
-    auto s = this->f_();
-    if (s.has_value()) {
-      this->publish_state(*s);
-    }
-  }
+  void set_template(optional<bool> (*f)()) { this->f_ = f; }
 
+  void setup() override;
+  void loop() override;
   void dump_config() override;
 
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
  protected:
-  F f_;
-};
-
-class TemplateBinarySensor : public TemplateBinarySensorBase<std::function<optional<bool>()>> {
- public:
-  TemplateBinarySensor() { this->f_ = nullptr; }
-  void set_template(std::function<optional<bool>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template binary sensor for stateless lambdas (no capture).
- *
- * Uses function pointer instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function).
- */
-class StatelessTemplateBinarySensor : public TemplateBinarySensorBase<optional<bool> (*)()> {
- public:
-  explicit StatelessTemplateBinarySensor(optional<bool> (*f)()) { this->f_ = f; }
+  optional<optional<bool> (*)()> f_;
 };
 
 }  // namespace template_

esphome/components/template/cover/__init__.py

@@ -23,9 +23,6 @@ from esphome.const import (
 from .. import template_ns
 
 TemplateCover = template_ns.class_("TemplateCover", cover.Cover, cg.Component)
-StatelessTemplateCover = template_ns.class_(
-    "StatelessTemplateCover", cover.Cover, cg.Component
-)
 
 TemplateCoverRestoreMode = template_ns.enum("TemplateCoverRestoreMode")
 RESTORE_MODES = {
@@ -66,22 +63,13 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
+    var = await cover.new_cover(config)
+    await cg.register_component(var, config)
     if CONF_LAMBDA in config:
-        # Use new_lambda_pvariable to create either TemplateCover or StatelessTemplateCover
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(float)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateCover
-        )
-        # Manually register as cover since we didn't use new_cover
-        await cover.register_cover(var, config)
-        await cg.register_component(var, config)
-    else:
-        # No state lambda - just create the base template cover
-        var = await cover.new_cover(config)
-        await cg.register_component(var, config)
-
+        cg.add(var.set_state_lambda(template_))
     if CONF_OPEN_ACTION in config:
         await automation.build_automation(
             var.get_open_trigger(), [], config[CONF_OPEN_ACTION]

esphome/components/template/cover/template_cover.cpp

@@ -8,8 +8,14 @@ using namespace esphome::cover;
 
 static const char *const TAG = "template.cover";
 
-// Template instantiations
-template<typename StateF, typename TiltF> void TemplateCoverBase<StateF, TiltF>::setup() {
+TemplateCover::TemplateCover()
+    : open_trigger_(new Trigger<>()),
+      close_trigger_(new Trigger<>),
+      stop_trigger_(new Trigger<>()),
+      toggle_trigger_(new Trigger<>()),
+      position_trigger_(new Trigger<float>()),
+      tilt_trigger_(new Trigger<float>()) {}
+void TemplateCover::setup() {
   switch (this->restore_mode_) {
     case COVER_NO_RESTORE:
       break;
@@ -28,12 +34,43 @@ template<typename StateF, typename TiltF> void TemplateCoverBase<StateF, TiltF>:
     }
   }
 }
+void TemplateCover::loop() {
+  bool changed = false;
 
-template<typename StateF, typename TiltF> void TemplateCoverBase<StateF, TiltF>::dump_config() {
-  LOG_COVER("", "Template Cover", this);
+  if (this->state_f_.has_value()) {
+    auto s = (*this->state_f_)();
+    if (s.has_value()) {
+      auto pos = clamp(*s, 0.0f, 1.0f);
+      if (pos != this->position) {
+        this->position = pos;
+        changed = true;
+      }
+    }
+  }
+  if (this->tilt_f_.has_value()) {
+    auto s = (*this->tilt_f_)();
+    if (s.has_value()) {
+      auto tilt = clamp(*s, 0.0f, 1.0f);
+      if (tilt != this->tilt) {
+        this->tilt = tilt;
+        changed = true;
+      }
+    }
+  }
+
+  if (changed)
+    this->publish_state();
 }
-
-template<typename StateF, typename TiltF> void TemplateCoverBase<StateF, TiltF>::control(const CoverCall &call) {
+void TemplateCover::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+void TemplateCover::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
+void TemplateCover::set_state_lambda(optional<float> (*f)()) { this->state_f_ = f; }
+float TemplateCover::get_setup_priority() const { return setup_priority::HARDWARE; }
+Trigger<> *TemplateCover::get_open_trigger() const { return this->open_trigger_; }
+Trigger<> *TemplateCover::get_close_trigger() const { return this->close_trigger_; }
+Trigger<> *TemplateCover::get_stop_trigger() const { return this->stop_trigger_; }
+Trigger<> *TemplateCover::get_toggle_trigger() const { return this->toggle_trigger_; }
+void TemplateCover::dump_config() { LOG_COVER("", "Template Cover", this); }
+void TemplateCover::control(const CoverCall &call) {
   if (call.get_stop()) {
     this->stop_prev_trigger_();
     this->stop_trigger_->trigger();
@@ -76,8 +113,7 @@ template<typename StateF, typename TiltF> void TemplateCoverBase<StateF, TiltF>:
 
   this->publish_state();
 }
-
-template<typename StateF, typename TiltF> CoverTraits TemplateCoverBase<StateF, TiltF>::get_traits() {
+CoverTraits TemplateCover::get_traits() {
   auto traits = CoverTraits();
   traits.set_is_assumed_state(this->assumed_state_);
   traits.set_supports_stop(this->has_stop_);
@@ -86,16 +122,19 @@ template<typename StateF, typename TiltF> CoverTraits TemplateCoverBase<StateF,
   traits.set_supports_tilt(this->has_tilt_);
   return traits;
 }
-
-template<typename StateF, typename TiltF> void TemplateCoverBase<StateF, TiltF>::stop_prev_trigger_() {
+Trigger<float> *TemplateCover::get_position_trigger() const { return this->position_trigger_; }
+Trigger<float> *TemplateCover::get_tilt_trigger() const { return this->tilt_trigger_; }
+void TemplateCover::set_tilt_lambda(optional<float> (*tilt_f)()) { this->tilt_f_ = tilt_f; }
+void TemplateCover::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
+void TemplateCover::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
+void TemplateCover::set_has_position(bool has_position) { this->has_position_ = has_position; }
+void TemplateCover::set_has_tilt(bool has_tilt) { this->has_tilt_ = has_tilt; }
+void TemplateCover::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();
     this->prev_command_trigger_ = nullptr;
   }
 }
 
-template class TemplateCoverBase<std::function<optional<float>()>, std::function<optional<float>()>>;
-template class TemplateCoverBase<optional<float> (*)(), optional<float> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/cover/template_cover.h

@@ -13,59 +13,31 @@ enum TemplateCoverRestoreMode {
   COVER_RESTORE_AND_CALL,
 };
 
-template<typename StateF, typename TiltF> class TemplateCoverBase : public cover::Cover, public Component {
+class TemplateCover : public cover::Cover, public Component {
  public:
-  TemplateCoverBase()
-      : open_trigger_(new Trigger<>()),
-        close_trigger_(new Trigger<>()),
-        stop_trigger_(new Trigger<>()),
-        toggle_trigger_(new Trigger<>()),
-        position_trigger_(new Trigger<float>()),
-        tilt_trigger_(new Trigger<float>()) {}
+  TemplateCover();
 
-  void loop() override {
-    bool changed = false;
-    if (this->state_f_.has_value()) {
-      auto s = (*this->state_f_)();
-      if (s.has_value()) {
-        auto pos = clamp(*s, 0.0f, 1.0f);
-        if (pos != this->position) {
-          this->position = pos;
-          changed = true;
-        }
-      }
-    }
-    if (this->tilt_f_.has_value()) {
-      auto s = (*this->tilt_f_)();
-      if (s.has_value()) {
-        auto tilt = clamp(*s, 0.0f, 1.0f);
-        if (tilt != this->tilt) {
-          this->tilt = tilt;
-          changed = true;
-        }
-      }
-    }
-    if (changed)
-      this->publish_state();
-  }
+  void set_state_lambda(optional<float> (*f)());
+  Trigger<> *get_open_trigger() const;
+  Trigger<> *get_close_trigger() const;
+  Trigger<> *get_stop_trigger() const;
+  Trigger<> *get_toggle_trigger() const;
+  Trigger<float> *get_position_trigger() const;
+  Trigger<float> *get_tilt_trigger() const;
+  void set_optimistic(bool optimistic);
+  void set_assumed_state(bool assumed_state);
+  void set_tilt_lambda(optional<float> (*tilt_f)());
+  void set_has_stop(bool has_stop);
+  void set_has_position(bool has_position);
+  void set_has_tilt(bool has_tilt);
+  void set_has_toggle(bool has_toggle);
+  void set_restore_mode(TemplateCoverRestoreMode restore_mode) { restore_mode_ = restore_mode; }
 
   void setup() override;
+  void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
-  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
-  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
-  Trigger<> *get_toggle_trigger() const { return this->toggle_trigger_; }
-  Trigger<float> *get_position_trigger() const { return this->position_trigger_; }
-  Trigger<float> *get_tilt_trigger() const { return this->tilt_trigger_; }
-  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-  void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
-  void set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
-  void set_has_position(bool has_position) { this->has_position_ = has_position; }
-  void set_has_tilt(bool has_tilt) { this->has_tilt_ = has_tilt; }
-  void set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
-  void set_restore_mode(TemplateCoverRestoreMode restore_mode) { restore_mode_ = restore_mode; }
+  float get_setup_priority() const override;
 
  protected:
   void control(const cover::CoverCall &call) override;
@@ -73,8 +45,8 @@ template<typename StateF, typename TiltF> class TemplateCoverBase : public cover
   void stop_prev_trigger_();
 
   TemplateCoverRestoreMode restore_mode_{COVER_RESTORE};
-  optional<StateF> state_f_;
-  optional<TiltF> tilt_f_;
+  optional<optional<float> (*)()> state_f_;
+  optional<optional<float> (*)()> tilt_f_;
   bool assumed_state_{false};
   bool optimistic_{false};
   Trigger<> *open_trigger_;
@@ -90,22 +62,5 @@ template<typename StateF, typename TiltF> class TemplateCoverBase : public cover
   bool has_tilt_{false};
 };
 
-class TemplateCover : public TemplateCoverBase<std::function<optional<float>()>, std::function<optional<float>()>> {
- public:
-  void set_state_lambda(std::function<optional<float>()> &&f) { this->state_f_ = f; }
-  void set_tilt_lambda(std::function<optional<float>()> &&tilt_f) { this->tilt_f_ = tilt_f; }
-};
-
-/** Optimized template cover for stateless lambdas (no capture).
- *
- * Uses function pointers instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function) per lambda.
- */
-class StatelessTemplateCover : public TemplateCoverBase<optional<float> (*)(), optional<float> (*)()> {
- public:
-  explicit StatelessTemplateCover(optional<float> (*state_f)()) { this->state_f_ = state_f; }
-  void set_tilt_lambda(optional<float> (*tilt_f)()) { this->tilt_f_ = tilt_f; }
-};
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/datetime/__init__.py

@@ -5,7 +5,6 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_DAY,
     CONF_HOUR,
-    CONF_ID,
     CONF_INITIAL_VALUE,
     CONF_LAMBDA,
     CONF_MINUTE,
@@ -26,23 +25,14 @@ CODEOWNERS = ["@rfdarter"]
 TemplateDate = template_ns.class_(
     "TemplateDate", datetime.DateEntity, cg.PollingComponent
 )
-StatelessTemplateDate = template_ns.class_(
-    "StatelessTemplateDate", datetime.DateEntity, cg.PollingComponent
-)
 
 TemplateTime = template_ns.class_(
     "TemplateTime", datetime.TimeEntity, cg.PollingComponent
 )
-StatelessTemplateTime = template_ns.class_(
-    "StatelessTemplateTime", datetime.TimeEntity, cg.PollingComponent
-)
 
 TemplateDateTime = template_ns.class_(
     "TemplateDateTime", datetime.DateTimeEntity, cg.PollingComponent
 )
-StatelessTemplateDateTime = template_ns.class_(
-    "StatelessTemplateDateTime", datetime.DateTimeEntity, cg.PollingComponent
-)
 
 
 def validate(config):
@@ -109,30 +99,15 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
+    var = await datetime.new_datetime(config)
+
     if CONF_LAMBDA in config:
-        # Use new_lambda_pvariable to create either Template* or StatelessTemplate*
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(cg.ESPTime)
         )
-        # Determine the appropriate stateless class based on type
-        if config[CONF_TYPE] == "DATE":
-            stateless_class = StatelessTemplateDate
-        elif config[CONF_TYPE] == "TIME":
-            stateless_class = StatelessTemplateTime
-        else:  # DATETIME
-            stateless_class = StatelessTemplateDateTime
+        cg.add(var.set_template(template_))
 
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, stateless_class
-        )
-        # Manually register as datetime since we didn't use new_datetime
-        await datetime.register_datetime(var, config)
-        await cg.register_component(var, config)
     else:
-        # No lambda - just create the base template datetime
-        var = await datetime.new_datetime(config)
-        await cg.register_component(var, config)
-
         cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
         cg.add(var.set_restore_value(config[CONF_RESTORE_VALUE]))
 
@@ -171,3 +146,5 @@ async def to_code(config):
             [(cg.ESPTime, "x")],
             config[CONF_SET_ACTION],
         )
+
+    await cg.register_component(var, config)

esphome/components/template/datetime/template_date.cpp

@@ -9,8 +9,7 @@ namespace template_ {
 
 static const char *const TAG = "template.date";
 
-// Template instantiations
-template<typename F> void TemplateDateBase<F>::setup() {
+void TemplateDate::setup() {
   if (this->f_.has_value())
     return;
 
@@ -37,7 +36,21 @@ template<typename F> void TemplateDateBase<F>::setup() {
   this->publish_state();
 }
 
-template<typename F> void TemplateDateBase<F>::control(const datetime::DateCall &call) {
+void TemplateDate::update() {
+  if (!this->f_.has_value())
+    return;
+
+  auto val = (*this->f_)();
+  if (!val.has_value())
+    return;
+
+  this->year_ = val->year;
+  this->month_ = val->month;
+  this->day_ = val->day_of_month;
+  this->publish_state();
+}
+
+void TemplateDate::control(const datetime::DateCall &call) {
   bool has_year = call.get_year().has_value();
   bool has_month = call.get_month().has_value();
   bool has_day = call.get_day().has_value();
@@ -86,15 +99,12 @@ template<typename F> void TemplateDateBase<F>::control(const datetime::DateCall
   }
 }
 
-template<typename F> void TemplateDateBase<F>::dump_config() {
+void TemplateDate::dump_config() {
   LOG_DATETIME_DATE("", "Template Date", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
   LOG_UPDATE_INTERVAL(this);
 }
 
-template class TemplateDateBase<std::function<optional<ESPTime>()>>;
-template class TemplateDateBase<optional<ESPTime> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome
 

esphome/components/template/datetime/template_date.h

@@ -13,23 +13,12 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateDateBase : public datetime::DateEntity, public PollingComponent {
+class TemplateDate : public datetime::DateEntity, public PollingComponent {
  public:
-  void update() override {
-    if (!this->f_.has_value())
-      return;
-
-    auto val = (*this->f_)();
-    if (!val.has_value())
-      return;
-
-    this->year_ = val->year;
-    this->month_ = val->month;
-    this->day_ = val->day_of_month;
-    this->publish_state();
-  }
+  void set_template(optional<ESPTime> (*f)()) { this->f_ = f; }
 
   void setup() override;
+  void update() override;
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
@@ -46,26 +35,11 @@ template<typename F> class TemplateDateBase : public datetime::DateEntity, publi
   ESPTime initial_value_{};
   bool restore_value_{false};
   Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
-  optional<F> f_;
+  optional<optional<ESPTime> (*)()> f_;
 
   ESPPreferenceObject pref_;
 };
 
-class TemplateDate : public TemplateDateBase<std::function<optional<ESPTime>()>> {
- public:
-  void set_template(std::function<optional<ESPTime>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template date for stateless lambdas (no capture).
- *
- * Uses function pointers instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function) per lambda.
- */
-class StatelessTemplateDate : public TemplateDateBase<optional<ESPTime> (*)()> {
- public:
-  explicit StatelessTemplateDate(optional<ESPTime> (*f)()) { this->f_ = f; }
-};
-
 }  // namespace template_
 }  // namespace esphome
 

esphome/components/template/datetime/template_datetime.cpp

@@ -9,8 +9,7 @@ namespace template_ {
 
 static const char *const TAG = "template.datetime";
 
-// Template instantiations
-template<typename F> void TemplateDateTimeBase<F>::setup() {
+void TemplateDateTime::setup() {
   if (this->f_.has_value())
     return;
 
@@ -40,7 +39,24 @@ template<typename F> void TemplateDateTimeBase<F>::setup() {
   this->publish_state();
 }
 
-template<typename F> void TemplateDateTimeBase<F>::control(const datetime::DateTimeCall &call) {
+void TemplateDateTime::update() {
+  if (!this->f_.has_value())
+    return;
+
+  auto val = (*this->f_)();
+  if (!val.has_value())
+    return;
+
+  this->year_ = val->year;
+  this->month_ = val->month;
+  this->day_ = val->day_of_month;
+  this->hour_ = val->hour;
+  this->minute_ = val->minute;
+  this->second_ = val->second;
+  this->publish_state();
+}
+
+void TemplateDateTime::control(const datetime::DateTimeCall &call) {
   bool has_year = call.get_year().has_value();
   bool has_month = call.get_month().has_value();
   bool has_day = call.get_day().has_value();
@@ -122,15 +138,12 @@ template<typename F> void TemplateDateTimeBase<F>::control(const datetime::DateT
   }
 }
 
-template<typename F> void TemplateDateTimeBase<F>::dump_config() {
+void TemplateDateTime::dump_config() {
   LOG_DATETIME_DATETIME("", "Template DateTime", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
   LOG_UPDATE_INTERVAL(this);
 }
 
-template class TemplateDateTimeBase<std::function<optional<ESPTime>()>>;
-template class TemplateDateTimeBase<optional<ESPTime> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome
 

esphome/components/template/datetime/template_datetime.h

@@ -13,26 +13,12 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateDateTimeBase : public datetime::DateTimeEntity, public PollingComponent {
+class TemplateDateTime : public datetime::DateTimeEntity, public PollingComponent {
  public:
-  void update() override {
-    if (!this->f_.has_value())
-      return;
-
-    auto val = (*this->f_)();
-    if (!val.has_value())
-      return;
-
-    this->year_ = val->year;
-    this->month_ = val->month;
-    this->day_ = val->day_of_month;
-    this->hour_ = val->hour;
-    this->minute_ = val->minute;
-    this->second_ = val->second;
-    this->publish_state();
-  }
+  void set_template(optional<ESPTime> (*f)()) { this->f_ = f; }
 
   void setup() override;
+  void update() override;
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
@@ -49,26 +35,11 @@ template<typename F> class TemplateDateTimeBase : public datetime::DateTimeEntit
   ESPTime initial_value_{};
   bool restore_value_{false};
   Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
-  optional<F> f_;
+  optional<optional<ESPTime> (*)()> f_;
 
   ESPPreferenceObject pref_;
 };
 
-class TemplateDateTime : public TemplateDateTimeBase<std::function<optional<ESPTime>()>> {
- public:
-  void set_template(std::function<optional<ESPTime>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template datetime for stateless lambdas (no capture).
- *
- * Uses function pointers instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function) per lambda.
- */
-class StatelessTemplateDateTime : public TemplateDateTimeBase<optional<ESPTime> (*)()> {
- public:
-  explicit StatelessTemplateDateTime(optional<ESPTime> (*f)()) { this->f_ = f; }
-};
-
 }  // namespace template_
 }  // namespace esphome
 

esphome/components/template/datetime/template_time.cpp

@@ -9,8 +9,7 @@ namespace template_ {
 
 static const char *const TAG = "template.time";
 
-// Template instantiations
-template<typename F> void TemplateTimeBase<F>::setup() {
+void TemplateTime::setup() {
   if (this->f_.has_value())
     return;
 
@@ -37,7 +36,21 @@ template<typename F> void TemplateTimeBase<F>::setup() {
   this->publish_state();
 }
 
-template<typename F> void TemplateTimeBase<F>::control(const datetime::TimeCall &call) {
+void TemplateTime::update() {
+  if (!this->f_.has_value())
+    return;
+
+  auto val = (*this->f_)();
+  if (!val.has_value())
+    return;
+
+  this->hour_ = val->hour;
+  this->minute_ = val->minute;
+  this->second_ = val->second;
+  this->publish_state();
+}
+
+void TemplateTime::control(const datetime::TimeCall &call) {
   bool has_hour = call.get_hour().has_value();
   bool has_minute = call.get_minute().has_value();
   bool has_second = call.get_second().has_value();
@@ -86,15 +99,12 @@ template<typename F> void TemplateTimeBase<F>::control(const datetime::TimeCall
   }
 }
 
-template<typename F> void TemplateTimeBase<F>::dump_config() {
+void TemplateTime::dump_config() {
   LOG_DATETIME_TIME("", "Template Time", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
   LOG_UPDATE_INTERVAL(this);
 }
 
-template class TemplateTimeBase<std::function<optional<ESPTime>()>>;
-template class TemplateTimeBase<optional<ESPTime> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome
 

esphome/components/template/datetime/template_time.h

@@ -13,23 +13,12 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateTimeBase : public datetime::TimeEntity, public PollingComponent {
+class TemplateTime : public datetime::TimeEntity, public PollingComponent {
  public:
-  void update() override {
-    if (!this->f_.has_value())
-      return;
-
-    auto val = (*this->f_)();
-    if (!val.has_value())
-      return;
-
-    this->hour_ = val->hour;
-    this->minute_ = val->minute;
-    this->second_ = val->second;
-    this->publish_state();
-  }
+  void set_template(optional<ESPTime> (*f)()) { this->f_ = f; }
 
   void setup() override;
+  void update() override;
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
@@ -46,26 +35,11 @@ template<typename F> class TemplateTimeBase : public datetime::TimeEntity, publi
   ESPTime initial_value_{};
   bool restore_value_{false};
   Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
-  optional<F> f_;
+  optional<optional<ESPTime> (*)()> f_;
 
   ESPPreferenceObject pref_;
 };
 
-class TemplateTime : public TemplateTimeBase<std::function<optional<ESPTime>()>> {
- public:
-  void set_template(std::function<optional<ESPTime>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template time for stateless lambdas (no capture).
- *
- * Uses function pointers instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function) per lambda.
- */
-class StatelessTemplateTime : public TemplateTimeBase<optional<ESPTime> (*)()> {
- public:
-  explicit StatelessTemplateTime(optional<ESPTime> (*f)()) { this->f_ = f; }
-};
-
 }  // namespace template_
 }  // namespace esphome
 

esphome/components/template/fan/template_fan.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <vector>
+#include <set>
 
 #include "esphome/core/component.h"
 #include "esphome/components/fan/fan.h"
@@ -16,7 +16,7 @@ class TemplateFan : public Component, public fan::Fan {
   void set_has_direction(bool has_direction) { this->has_direction_ = has_direction; }
   void set_has_oscillating(bool has_oscillating) { this->has_oscillating_ = has_oscillating; }
   void set_speed_count(int count) { this->speed_count_ = count; }
-  void set_preset_modes(const std::initializer_list<std::string> &presets) { this->preset_modes_ = presets; }
+  void set_preset_modes(const std::set<std::string> &presets) { this->preset_modes_ = presets; }
   fan::FanTraits get_traits() override { return this->traits_; }
 
  protected:
@@ -26,7 +26,7 @@ class TemplateFan : public Component, public fan::Fan {
   bool has_direction_{false};
   int speed_count_{0};
   fan::FanTraits traits_;
-  std::vector<std::string> preset_modes_{};
+  std::set<std::string> preset_modes_{};
 };
 
 }  // namespace template_

esphome/components/template/lock/__init__.py

@@ -16,9 +16,6 @@ from esphome.const import (
 from .. import template_ns
 
 TemplateLock = template_ns.class_("TemplateLock", lock.Lock, cg.Component)
-StatelessTemplateLock = template_ns.class_(
-    "StatelessTemplateLock", lock.Lock, cg.Component
-)
 
 TemplateLockPublishAction = template_ns.class_(
     "TemplateLockPublishAction",
@@ -58,22 +55,14 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
+    var = await lock.new_lock(config)
+    await cg.register_component(var, config)
+
     if CONF_LAMBDA in config:
-        # Use new_lambda_pvariable to create either TemplateLock or StatelessTemplateLock
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(lock.LockState)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateLock
-        )
-        # Manually register as lock since we didn't use new_lock
-        await lock.register_lock(var, config)
-        await cg.register_component(var, config)
-    else:
-        # No lambda - just create the base template lock
-        var = await lock.new_lock(config)
-        await cg.register_component(var, config)
-
+        cg.add(var.set_state_lambda(template_))
     if CONF_UNLOCK_ACTION in config:
         await automation.build_automation(
             var.get_unlock_trigger(), [], config[CONF_UNLOCK_ACTION]

esphome/components/template/lock/template_lock.cpp

@@ -8,8 +8,19 @@ using namespace esphome::lock;
 
 static const char *const TAG = "template.lock";
 
-// Template instantiations
-template<typename F> void TemplateLockBase<F>::control(const lock::LockCall &call) {
+TemplateLock::TemplateLock()
+    : lock_trigger_(new Trigger<>()), unlock_trigger_(new Trigger<>()), open_trigger_(new Trigger<>()) {}
+
+void TemplateLock::loop() {
+  if (!this->f_.has_value())
+    return;
+  auto val = (*this->f_)();
+  if (!val.has_value())
+    return;
+
+  this->publish_state(*val);
+}
+void TemplateLock::control(const lock::LockCall &call) {
   if (this->prev_trigger_ != nullptr) {
     this->prev_trigger_->stop_action();
   }
@@ -26,22 +37,23 @@ template<typename F> void TemplateLockBase<F>::control(const lock::LockCall &cal
   if (this->optimistic_)
     this->publish_state(state);
 }
-
-template<typename F> void TemplateLockBase<F>::open_latch() {
+void TemplateLock::open_latch() {
   if (this->prev_trigger_ != nullptr) {
     this->prev_trigger_->stop_action();
   }
   this->prev_trigger_ = this->open_trigger_;
   this->open_trigger_->trigger();
 }
-
-template<typename F> void TemplateLockBase<F>::dump_config() {
+void TemplateLock::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+void TemplateLock::set_state_lambda(optional<lock::LockState> (*f)()) { this->f_ = f; }
+float TemplateLock::get_setup_priority() const { return setup_priority::HARDWARE; }
+Trigger<> *TemplateLock::get_lock_trigger() const { return this->lock_trigger_; }
+Trigger<> *TemplateLock::get_unlock_trigger() const { return this->unlock_trigger_; }
+Trigger<> *TemplateLock::get_open_trigger() const { return this->open_trigger_; }
+void TemplateLock::dump_config() {
   LOG_LOCK("", "Template Lock", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
 }
 
-template class TemplateLockBase<std::function<optional<lock::LockState>()>>;
-template class TemplateLockBase<optional<lock::LockState> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/lock/template_lock.h

@@ -7,35 +7,26 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateLockBase : public lock::Lock, public Component {
+class TemplateLock : public lock::Lock, public Component {
  public:
-  TemplateLockBase()
-      : lock_trigger_(new Trigger<>()), unlock_trigger_(new Trigger<>()), open_trigger_(new Trigger<>()) {}
-
-  void loop() override {
-    if (!this->f_.has_value())
-      return;
-    auto val = (*this->f_)();
-    if (!val.has_value())
-      return;
-
-    this->publish_state(*val);
-  }
+  TemplateLock();
 
   void dump_config() override;
 
-  Trigger<> *get_lock_trigger() const { return this->lock_trigger_; }
-  Trigger<> *get_unlock_trigger() const { return this->unlock_trigger_; }
-  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
-  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+  void set_state_lambda(optional<lock::LockState> (*f)());
+  Trigger<> *get_lock_trigger() const;
+  Trigger<> *get_unlock_trigger() const;
+  Trigger<> *get_open_trigger() const;
+  void set_optimistic(bool optimistic);
+  void loop() override;
 
-  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+  float get_setup_priority() const override;
 
  protected:
   void control(const lock::LockCall &call) override;
   void open_latch() override;
 
-  optional<F> f_;
+  optional<optional<lock::LockState> (*)()> f_;
   bool optimistic_{false};
   Trigger<> *lock_trigger_;
   Trigger<> *unlock_trigger_;
@@ -43,20 +34,5 @@ template<typename F> class TemplateLockBase : public lock::Lock, public Componen
   Trigger<> *prev_trigger_{nullptr};
 };
 
-class TemplateLock : public TemplateLockBase<std::function<optional<lock::LockState>()>> {
- public:
-  void set_state_lambda(std::function<optional<lock::LockState>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template lock for stateless lambdas (no capture).
- *
- * Uses function pointers instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function) per lambda.
- */
-class StatelessTemplateLock : public TemplateLockBase<optional<lock::LockState> (*)()> {
- public:
-  explicit StatelessTemplateLock(optional<lock::LockState> (*f)()) { this->f_ = f; }
-};
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/number/__init__.py

@@ -19,9 +19,6 @@ from .. import template_ns
 TemplateNumber = template_ns.class_(
     "TemplateNumber", number.Number, cg.PollingComponent
 )
-StatelessTemplateNumber = template_ns.class_(
-    "StatelessTemplateNumber", number.Number, cg.PollingComponent
-)
 
 
 def validate_min_max(config):
@@ -69,33 +66,23 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await number.register_number(
+        var,
+        config,
+        min_value=config[CONF_MIN_VALUE],
+        max_value=config[CONF_MAX_VALUE],
+        step=config[CONF_STEP],
+    )
+
     if CONF_LAMBDA in config:
-        # Use new_lambda_pvariable to create either TemplateNumber or StatelessTemplateNumber
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(float)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateNumber
-        )
-        await cg.register_component(var, config)
-        await number.register_number(
-            var,
-            config,
-            min_value=config[CONF_MIN_VALUE],
-            max_value=config[CONF_MAX_VALUE],
-            step=config[CONF_STEP],
-        )
+        cg.add(var.set_template(template_))
+
     else:
-        # No lambda - just create the base template number
-        var = cg.new_Pvariable(config[CONF_ID])
-        await cg.register_component(var, config)
-        await number.register_number(
-            var,
-            config,
-            min_value=config[CONF_MIN_VALUE],
-            max_value=config[CONF_MAX_VALUE],
-            step=config[CONF_STEP],
-        )
         cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
         cg.add(var.set_initial_value(config[CONF_INITIAL_VALUE]))
         if CONF_RESTORE_VALUE in config:

esphome/components/template/number/template_number.cpp

@@ -6,8 +6,7 @@ namespace template_ {
 
 static const char *const TAG = "template.number";
 
-// Template instantiations
-template<typename F> void TemplateNumberBase<F>::setup() {
+void TemplateNumber::setup() {
   if (this->f_.has_value())
     return;
 
@@ -27,7 +26,18 @@ template<typename F> void TemplateNumberBase<F>::setup() {
   this->publish_state(value);
 }
 
-template<typename F> void TemplateNumberBase<F>::control(float value) {
+void TemplateNumber::update() {
+  if (!this->f_.has_value())
+    return;
+
+  auto val = (*this->f_)();
+  if (!val.has_value())
+    return;
+
+  this->publish_state(*val);
+}
+
+void TemplateNumber::control(float value) {
   this->set_trigger_->trigger(value);
 
   if (this->optimistic_)
@@ -36,15 +46,11 @@ template<typename F> void TemplateNumberBase<F>::control(float value) {
   if (this->restore_value_)
     this->pref_.save(&value);
 }
-
-template<typename F> void TemplateNumberBase<F>::dump_config() {
+void TemplateNumber::dump_config() {
   LOG_NUMBER("", "Template Number", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
   LOG_UPDATE_INTERVAL(this);
 }
 
-template class TemplateNumberBase<std::function<optional<float>()>>;
-template class TemplateNumberBase<optional<float> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/number/template_number.h

@@ -8,22 +8,13 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateNumberBase : public number::Number, public PollingComponent {
+class TemplateNumber : public number::Number, public PollingComponent {
  public:
-  TemplateNumberBase() : set_trigger_(new Trigger<float>()) {}
+  void set_template(optional<float> (*f)()) { this->f_ = f; }
 
   void setup() override;
+  void update() override;
   void dump_config() override;
-
-  void update() override {
-    if (!this->f_.has_value())
-      return;
-    auto val = (*this->f_)();
-    if (!val.has_value())
-      return;
-    this->publish_state(*val);
-  }
-
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
   Trigger<float> *get_set_trigger() const { return set_trigger_; }
@@ -36,26 +27,11 @@ template<typename F> class TemplateNumberBase : public number::Number, public Po
   bool optimistic_{false};
   float initial_value_{NAN};
   bool restore_value_{false};
-  Trigger<float> *set_trigger_;
-  optional<F> f_;
+  Trigger<float> *set_trigger_ = new Trigger<float>();
+  optional<optional<float> (*)()> f_;
 
   ESPPreferenceObject pref_;
 };
 
-class TemplateNumber : public TemplateNumberBase<std::function<optional<float>()>> {
- public:
-  void set_template(std::function<optional<float>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template number for stateless lambdas (no capture).
- *
- * Uses function pointer instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function).
- */
-class StatelessTemplateNumber : public TemplateNumberBase<optional<float> (*)()> {
- public:
-  explicit StatelessTemplateNumber(optional<float> (*f)()) { this->f_ = f; }
-};
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/select/__init__.py

@@ -17,9 +17,6 @@ from .. import template_ns
 TemplateSelect = template_ns.class_(
     "TemplateSelect", select.Select, cg.PollingComponent
 )
-StatelessTemplateSelect = template_ns.class_(
-    "StatelessTemplateSelect", select.Select, cg.PollingComponent
-)
 
 
 def validate(config):
@@ -65,22 +62,17 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await select.register_select(var, config, options=config[CONF_OPTIONS])
+
     if CONF_LAMBDA in config:
-        # Use new_lambda_pvariable to create either TemplateSelect or StatelessTemplateSelect
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(cg.std_string)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateSelect
-        )
-        await cg.register_component(var, config)
-        await select.register_select(var, config, options=config[CONF_OPTIONS])
-    else:
-        # No lambda - just create the base template select
-        var = cg.new_Pvariable(config[CONF_ID])
-        await cg.register_component(var, config)
-        await select.register_select(var, config, options=config[CONF_OPTIONS])
+        cg.add(var.set_template(template_))
 
+    else:
         # Only set if non-default to avoid bloating setup() function
         if config[CONF_OPTIMISTIC]:
             cg.add(var.set_optimistic(True))

esphome/components/template/select/template_select.cpp

@@ -6,8 +6,7 @@ namespace template_ {
 
 static const char *const TAG = "template.select";
 
-// Template instantiations
-template<typename F> void TemplateSelectBase<F>::setup() {
+void TemplateSelect::setup() {
   if (this->f_.has_value())
     return;
 
@@ -28,7 +27,23 @@ template<typename F> void TemplateSelectBase<F>::setup() {
   this->publish_state(this->at(index).value());
 }
 
-template<typename F> void TemplateSelectBase<F>::control(const std::string &value) {
+void TemplateSelect::update() {
+  if (!this->f_.has_value())
+    return;
+
+  auto val = (*this->f_)();
+  if (!val.has_value())
+    return;
+
+  if (!this->has_option(*val)) {
+    ESP_LOGE(TAG, "Lambda returned an invalid option: %s", (*val).c_str());
+    return;
+  }
+
+  this->publish_state(*val);
+}
+
+void TemplateSelect::control(const std::string &value) {
   this->set_trigger_->trigger(value);
 
   if (this->optimistic_)
@@ -40,7 +55,7 @@ template<typename F> void TemplateSelectBase<F>::control(const std::string &valu
   }
 }
 
-template<typename F> void TemplateSelectBase<F>::dump_config() {
+void TemplateSelect::dump_config() {
   LOG_SELECT("", "Template Select", this);
   LOG_UPDATE_INTERVAL(this);
   if (this->f_.has_value())
@@ -53,8 +68,5 @@ template<typename F> void TemplateSelectBase<F>::dump_config() {
                 YESNO(this->restore_value_));
 }
 
-template class TemplateSelectBase<std::function<optional<std::string>()>>;
-template class TemplateSelectBase<optional<std::string> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/select/template_select.h

@@ -8,26 +8,13 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateSelectBase : public select::Select, public PollingComponent {
+class TemplateSelect : public select::Select, public PollingComponent {
  public:
-  TemplateSelectBase() : set_trigger_(new Trigger<std::string>()) {}
+  void set_template(optional<std::string> (*f)()) { this->f_ = f; }
 
   void setup() override;
+  void update() override;
   void dump_config() override;
-
-  void update() override {
-    if (!this->f_.has_value())
-      return;
-    auto val = (*this->f_)();
-    if (!val.has_value())
-      return;
-    if (!this->has_option(*val)) {
-      ESP_LOGE("template.select", "Lambda returned an invalid option: %s", (*val).c_str());
-      return;
-    }
-    this->publish_state(*val);
-  }
-
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
   Trigger<std::string> *get_set_trigger() const { return this->set_trigger_; }
@@ -40,26 +27,11 @@ template<typename F> class TemplateSelectBase : public select::Select, public Po
   bool optimistic_ = false;
   size_t initial_option_index_{0};
   bool restore_value_ = false;
-  Trigger<std::string> *set_trigger_;
-  optional<F> f_;
+  Trigger<std::string> *set_trigger_ = new Trigger<std::string>();
+  optional<optional<std::string> (*)()> f_;
 
   ESPPreferenceObject pref_;
 };
 
-class TemplateSelect : public TemplateSelectBase<std::function<optional<std::string>()>> {
- public:
-  void set_template(std::function<optional<std::string>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template select for stateless lambdas (no capture).
- *
- * Uses function pointer instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function).
- */
-class StatelessTemplateSelect : public TemplateSelectBase<optional<std::string> (*)()> {
- public:
-  explicit StatelessTemplateSelect(optional<std::string> (*f)()) { this->f_ = f; }
-};
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/sensor/__init__.py

@@ -9,9 +9,6 @@ from .. import template_ns
 TemplateSensor = template_ns.class_(
     "TemplateSensor", sensor.Sensor, cg.PollingComponent
 )
-StatelessTemplateSensor = template_ns.class_(
-    "StatelessTemplateSensor", sensor.Sensor, cg.PollingComponent
-)
 
 CONFIG_SCHEMA = (
     sensor.sensor_schema(
@@ -28,21 +25,14 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
+    var = await sensor.new_sensor(config)
+    await cg.register_component(var, config)
+
     if CONF_LAMBDA in config:
-        # Use new_lambda_pvariable to create either TemplateSensor or StatelessTemplateSensor
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(float)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateSensor
-        )
-        # Manually register as sensor since we didn't use new_sensor
-        await sensor.register_sensor(var, config)
-        await cg.register_component(var, config)
-    else:
-        # No lambda - just create the base template sensor
-        var = await sensor.new_sensor(config)
-        await cg.register_component(var, config)
+        cg.add(var.set_template(template_))
 
 
 @automation.register_action(

esphome/components/template/sensor/template_sensor.cpp

@@ -7,14 +7,21 @@ namespace template_ {
 
 static const char *const TAG = "template.sensor";
 
-// Template instantiations
-template<typename F> void TemplateSensorBase<F>::dump_config() {
+void TemplateSensor::update() {
+  if (!this->f_.has_value())
+    return;
+
+  auto val = (*this->f_)();
+  if (val.has_value()) {
+    this->publish_state(*val);
+  }
+}
+float TemplateSensor::get_setup_priority() const { return setup_priority::HARDWARE; }
+void TemplateSensor::set_template(optional<float> (*f)()) { this->f_ = f; }
+void TemplateSensor::dump_config() {
   LOG_SENSOR("", "Template Sensor", this);
   LOG_UPDATE_INTERVAL(this);
 }
 
-template class TemplateSensorBase<std::function<optional<float>()>>;
-template class TemplateSensorBase<optional<float> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/sensor/template_sensor.h

@@ -6,38 +6,18 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateSensorBase : public sensor::Sensor, public PollingComponent {
+class TemplateSensor : public sensor::Sensor, public PollingComponent {
  public:
-  void update() override {
-    if (!this->f_.has_value())
-      return;
-    auto val = (*this->f_)();
-    if (val.has_value()) {
-      this->publish_state(*val);
-    }
-  }
+  void set_template(optional<float> (*f)());
+
+  void update() override;
 
   void dump_config() override;
 
-  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+  float get_setup_priority() const override;
 
  protected:
-  optional<F> f_;
-};
-
-class TemplateSensor : public TemplateSensorBase<std::function<optional<float>()>> {
- public:
-  void set_template(std::function<optional<float>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template sensor for stateless lambdas (no capture).
- *
- * Uses function pointer instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function).
- */
-class StatelessTemplateSensor : public TemplateSensorBase<optional<float> (*)()> {
- public:
-  explicit StatelessTemplateSensor(optional<float> (*f)()) { this->f_ = f; }
+  optional<optional<float> (*)()> f_;
 };
 
 }  // namespace template_

esphome/components/template/switch/__init__.py

@@ -16,9 +16,6 @@ from esphome.const import (
 from .. import template_ns
 
 TemplateSwitch = template_ns.class_("TemplateSwitch", switch.Switch, cg.Component)
-StatelessTemplateSwitch = template_ns.class_(
-    "StatelessTemplateSwitch", switch.Switch, cg.Component
-)
 
 
 def validate(config):
@@ -58,22 +55,14 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
+    var = await switch.new_switch(config)
+    await cg.register_component(var, config)
+
     if CONF_LAMBDA in config:
-        # Use new_lambda_pvariable to create either TemplateSwitch or StatelessTemplateSwitch
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(bool)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateSwitch
-        )
-        # Manually register as switch since we didn't use new_switch
-        await switch.register_switch(var, config)
-        await cg.register_component(var, config)
-    else:
-        # No lambda - just create the base template switch
-        var = await switch.new_switch(config)
-        await cg.register_component(var, config)
-
+        cg.add(var.set_state_lambda(template_))
     if CONF_TURN_OFF_ACTION in config:
         await automation.build_automation(
             var.get_turn_off_trigger(), [], config[CONF_TURN_OFF_ACTION]

esphome/components/template/switch/template_switch.cpp

@@ -6,8 +6,18 @@ namespace template_ {
 
 static const char *const TAG = "template.switch";
 
-// Template instantiations
-template<typename F> void TemplateSwitchBase<F>::write_state(bool state) {
+TemplateSwitch::TemplateSwitch() : turn_on_trigger_(new Trigger<>()), turn_off_trigger_(new Trigger<>()) {}
+
+void TemplateSwitch::loop() {
+  if (!this->f_.has_value())
+    return;
+  auto s = (*this->f_)();
+  if (!s.has_value())
+    return;
+
+  this->publish_state(*s);
+}
+void TemplateSwitch::write_state(bool state) {
   if (this->prev_trigger_ != nullptr) {
     this->prev_trigger_->stop_action();
   }
@@ -23,8 +33,13 @@ template<typename F> void TemplateSwitchBase<F>::write_state(bool state) {
   if (this->optimistic_)
     this->publish_state(state);
 }
-
-template<typename F> void TemplateSwitchBase<F>::setup() {
+void TemplateSwitch::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+bool TemplateSwitch::assumed_state() { return this->assumed_state_; }
+void TemplateSwitch::set_state_lambda(optional<bool> (*f)()) { this->f_ = f; }
+float TemplateSwitch::get_setup_priority() const { return setup_priority::HARDWARE - 2.0f; }
+Trigger<> *TemplateSwitch::get_turn_on_trigger() const { return this->turn_on_trigger_; }
+Trigger<> *TemplateSwitch::get_turn_off_trigger() const { return this->turn_off_trigger_; }
+void TemplateSwitch::setup() {
   optional<bool> initial_state = this->get_initial_state_with_restore_mode();
 
   if (initial_state.has_value()) {
@@ -37,14 +52,11 @@ template<typename F> void TemplateSwitchBase<F>::setup() {
     }
   }
 }
-
-template<typename F> void TemplateSwitchBase<F>::dump_config() {
+void TemplateSwitch::dump_config() {
   LOG_SWITCH("", "Template Switch", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
 }
-
-template class TemplateSwitchBase<std::function<optional<bool>()>>;
-template class TemplateSwitchBase<optional<bool> (*)()>;
+void TemplateSwitch::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/switch/template_switch.h

@@ -7,35 +7,28 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateSwitchBase : public switch_::Switch, public Component {
+class TemplateSwitch : public switch_::Switch, public Component {
  public:
-  TemplateSwitchBase() : turn_on_trigger_(new Trigger<>()), turn_off_trigger_(new Trigger<>()) {}
+  TemplateSwitch();
 
   void setup() override;
   void dump_config() override;
 
-  void loop() override {
-    if (!this->f_.has_value())
-      return;
-    auto s = (*this->f_)();
-    if (!s.has_value())
-      return;
-    this->publish_state(*s);
-  }
+  void set_state_lambda(optional<bool> (*f)());
+  Trigger<> *get_turn_on_trigger() const;
+  Trigger<> *get_turn_off_trigger() const;
+  void set_optimistic(bool optimistic);
+  void set_assumed_state(bool assumed_state);
+  void loop() override;
 
-  Trigger<> *get_turn_on_trigger() const { return this->turn_on_trigger_; }
-  Trigger<> *get_turn_off_trigger() const { return this->turn_off_trigger_; }
-  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-  void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
-
-  float get_setup_priority() const override { return setup_priority::HARDWARE - 2.0f; }
+  float get_setup_priority() const override;
 
  protected:
-  bool assumed_state() override { return this->assumed_state_; }
+  bool assumed_state() override;
 
   void write_state(bool state) override;
 
-  optional<F> f_;
+  optional<optional<bool> (*)()> f_;
   bool optimistic_{false};
   bool assumed_state_{false};
   Trigger<> *turn_on_trigger_;
@@ -43,20 +36,5 @@ template<typename F> class TemplateSwitchBase : public switch_::Switch, public C
   Trigger<> *prev_trigger_{nullptr};
 };
 
-class TemplateSwitch : public TemplateSwitchBase<std::function<optional<bool>()>> {
- public:
-  void set_state_lambda(std::function<optional<bool>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template switch for stateless lambdas (no capture).
- *
- * Uses function pointer instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function).
- */
-class StatelessTemplateSwitch : public TemplateSwitchBase<optional<bool> (*)()> {
- public:
-  explicit StatelessTemplateSwitch(optional<bool> (*f)()) { this->f_ = f; }
-};
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/text/__init__.py

@@ -3,7 +3,6 @@ import esphome.codegen as cg
 from esphome.components import text
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ID,
     CONF_INITIAL_VALUE,
     CONF_LAMBDA,
     CONF_MAX_LENGTH,
@@ -17,9 +16,6 @@ from esphome.const import (
 from .. import template_ns
 
 TemplateText = template_ns.class_("TemplateText", text.Text, cg.PollingComponent)
-StatelessTemplateText = template_ns.class_(
-    "StatelessTemplateText", text.Text, cg.PollingComponent
-)
 
 TextSaverBase = template_ns.class_("TemplateTextSaverBase")
 TextSaverTemplate = template_ns.class_("TextSaver", TextSaverBase)
@@ -69,31 +65,21 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
+    var = await text.new_text(
+        config,
+        min_length=config[CONF_MIN_LENGTH],
+        max_length=config[CONF_MAX_LENGTH],
+        pattern=config.get(CONF_PATTERN),
+    )
+    await cg.register_component(var, config)
+
     if CONF_LAMBDA in config:
-        # Use new_lambda_pvariable to create either TemplateText or StatelessTemplateText
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(cg.std_string)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateText
-        )
-        await cg.register_component(var, config)
-        await text.register_text(
-            var,
-            config,
-            min_length=config[CONF_MIN_LENGTH],
-            max_length=config[CONF_MAX_LENGTH],
-            pattern=config.get(CONF_PATTERN),
-        )
+        cg.add(var.set_template(template_))
+
     else:
-        # No lambda - just create the base template text
-        var = await text.new_text(
-            config,
-            min_length=config[CONF_MIN_LENGTH],
-            max_length=config[CONF_MAX_LENGTH],
-            pattern=config.get(CONF_PATTERN),
-        )
-        await cg.register_component(var, config)
         cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
         if initial_value_config := config.get(CONF_INITIAL_VALUE):
             cg.add(var.set_initial_value(initial_value_config))

esphome/components/template/text/template_text.cpp

@@ -6,8 +6,7 @@ namespace template_ {
 
 static const char *const TAG = "template.text";
 
-// Template instantiations
-template<typename F> void TemplateTextBase<F>::setup() {
+void TemplateText::setup() {
   if (!(this->f_ == nullptr)) {
     if (this->f_.has_value())
       return;
@@ -26,7 +25,21 @@ template<typename F> void TemplateTextBase<F>::setup() {
     this->publish_state(value);
 }
 
-template<typename F> void TemplateTextBase<F>::control(const std::string &value) {
+void TemplateText::update() {
+  if (this->f_ == nullptr)
+    return;
+
+  if (!this->f_.has_value())
+    return;
+
+  auto val = (*this->f_)();
+  if (!val.has_value())
+    return;
+
+  this->publish_state(*val);
+}
+
+void TemplateText::control(const std::string &value) {
   this->set_trigger_->trigger(value);
 
   if (this->optimistic_)
@@ -38,15 +51,11 @@ template<typename F> void TemplateTextBase<F>::control(const std::string &value)
     }
   }
 }
-
-template<typename F> void TemplateTextBase<F>::dump_config() {
+void TemplateText::dump_config() {
   LOG_TEXT("", "Template Text Input", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
   LOG_UPDATE_INTERVAL(this);
 }
 
-template class TemplateTextBase<std::function<optional<std::string>()>>;
-template class TemplateTextBase<optional<std::string> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/text/template_text.h

@@ -59,24 +59,13 @@ template<uint8_t SZ> class TextSaver : public TemplateTextSaverBase {
   }
 };
 
-template<typename F> class TemplateTextBase : public text::Text, public PollingComponent {
+class TemplateText : public text::Text, public PollingComponent {
  public:
-  TemplateTextBase() : set_trigger_(new Trigger<std::string>()) {}
+  void set_template(optional<std::string> (*f)()) { this->f_ = f; }
 
   void setup() override;
+  void update() override;
   void dump_config() override;
-
-  void update() override {
-    if (this->f_ == nullptr)
-      return;
-    if (!this->f_.has_value())
-      return;
-    auto val = (*this->f_)();
-    if (!val.has_value())
-      return;
-    this->publish_state(*val);
-  }
-
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
   Trigger<std::string> *get_set_trigger() const { return this->set_trigger_; }
@@ -88,26 +77,11 @@ template<typename F> class TemplateTextBase : public text::Text, public PollingC
   void control(const std::string &value) override;
   bool optimistic_ = false;
   std::string initial_value_;
-  Trigger<std::string> *set_trigger_;
-  optional<F> f_{nullptr};
+  Trigger<std::string> *set_trigger_ = new Trigger<std::string>();
+  optional<optional<std::string> (*)()> f_{nullptr};
 
   TemplateTextSaverBase *pref_ = nullptr;
 };
 
-class TemplateText : public TemplateTextBase<std::function<optional<std::string>()>> {
- public:
-  void set_template(std::function<optional<std::string>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template text for stateless lambdas (no capture).
- *
- * Uses function pointer instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function).
- */
-class StatelessTemplateText : public TemplateTextBase<optional<std::string> (*)()> {
- public:
-  explicit StatelessTemplateText(optional<std::string> (*f)()) { this->f_ = f; }
-};
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/text_sensor/__init__.py

@@ -10,9 +10,6 @@ from .. import template_ns
 TemplateTextSensor = template_ns.class_(
     "TemplateTextSensor", text_sensor.TextSensor, cg.PollingComponent
 )
-StatelessTemplateTextSensor = template_ns.class_(
-    "StatelessTemplateTextSensor", text_sensor.TextSensor, cg.PollingComponent
-)
 
 CONFIG_SCHEMA = (
     text_sensor.text_sensor_schema()
@@ -27,21 +24,14 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
+    var = await text_sensor.new_text_sensor(config)
+    await cg.register_component(var, config)
+
     if CONF_LAMBDA in config:
-        # Use new_lambda_pvariable to create either TemplateTextSensor or StatelessTemplateTextSensor
         template_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(cg.std_string)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateTextSensor
-        )
-        # Manually register as text sensor since we didn't use new_text_sensor
-        await text_sensor.register_text_sensor(var, config)
-        await cg.register_component(var, config)
-    else:
-        # No lambda - just create the base template text sensor
-        var = await text_sensor.new_text_sensor(config)
-        await cg.register_component(var, config)
+        cg.add(var.set_template(template_))
 
 
 @automation.register_action(

esphome/components/template/text_sensor/template_text_sensor.cpp

@@ -6,11 +6,18 @@ namespace template_ {
 
 static const char *const TAG = "template.text_sensor";
 
-// Template instantiations
-template<typename F> void TemplateTextSensorBase<F>::dump_config() { LOG_TEXT_SENSOR("", "Template Sensor", this); }
+void TemplateTextSensor::update() {
+  if (!this->f_.has_value())
+    return;
 
-template class TemplateTextSensorBase<std::function<optional<std::string>()>>;
-template class TemplateTextSensorBase<optional<std::string> (*)()>;
+  auto val = (*this->f_)();
+  if (val.has_value()) {
+    this->publish_state(*val);
+  }
+}
+float TemplateTextSensor::get_setup_priority() const { return setup_priority::HARDWARE; }
+void TemplateTextSensor::set_template(optional<std::string> (*f)()) { this->f_ = f; }
+void TemplateTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Template Sensor", this); }
 
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/text_sensor/template_text_sensor.h

@@ -7,38 +7,18 @@
 namespace esphome {
 namespace template_ {
 
-template<typename F> class TemplateTextSensorBase : public text_sensor::TextSensor, public PollingComponent {
+class TemplateTextSensor : public text_sensor::TextSensor, public PollingComponent {
  public:
-  void update() override {
-    if (!this->f_.has_value())
-      return;
-    auto val = (*this->f_)();
-    if (val.has_value()) {
-      this->publish_state(*val);
-    }
-  }
+  void set_template(optional<std::string> (*f)());
 
-  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+  void update() override;
+
+  float get_setup_priority() const override;
 
   void dump_config() override;
 
  protected:
-  optional<F> f_;
-};
-
-class TemplateTextSensor : public TemplateTextSensorBase<std::function<optional<std::string>()>> {
- public:
-  void set_template(std::function<optional<std::string>()> &&f) { this->f_ = f; }
-};
-
-/** Optimized template text sensor for stateless lambdas (no capture).
- *
- * Uses function pointer instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function).
- */
-class StatelessTemplateTextSensor : public TemplateTextSensorBase<optional<std::string> (*)()> {
- public:
-  explicit StatelessTemplateTextSensor(optional<std::string> (*f)()) { this->f_ = f; }
+  optional<optional<std::string> (*)()> f_{};
 };
 
 }  // namespace template_

esphome/components/template/valve/__init__.py

@@ -20,9 +20,6 @@ from esphome.const import (
 from .. import template_ns
 
 TemplateValve = template_ns.class_("TemplateValve", valve.Valve, cg.Component)
-StatelessTemplateValve = template_ns.class_(
-    "StatelessTemplateValve", valve.Valve, cg.Component
-)
 
 TemplateValvePublishAction = template_ns.class_(
     "TemplateValvePublishAction", automation.Action, cg.Parented.template(TemplateValve)
@@ -65,22 +62,13 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
+    var = await valve.new_valve(config)
+    await cg.register_component(var, config)
     if lambda_config := config.get(CONF_LAMBDA):
-        # Use new_lambda_pvariable to create either TemplateValve or StatelessTemplateValve
         template_ = await cg.process_lambda(
             lambda_config, [], return_type=cg.optional.template(float)
         )
-        var = automation.new_lambda_pvariable(
-            config[CONF_ID], template_, StatelessTemplateValve
-        )
-        # Manually register as valve since we didn't use new_valve
-        await valve.register_valve(var, config)
-        await cg.register_component(var, config)
-    else:
-        # No lambda - just create the base template valve
-        var = await valve.new_valve(config)
-        await cg.register_component(var, config)
-
+        cg.add(var.set_state_lambda(template_))
     if open_action_config := config.get(CONF_OPEN_ACTION):
         await automation.build_automation(
             var.get_open_trigger(), [], open_action_config

esphome/components/template/valve/template_valve.cpp

@@ -8,8 +8,14 @@ using namespace esphome::valve;
 
 static const char *const TAG = "template.valve";
 
-// Template instantiations
-template<typename F> void TemplateValveBase<F>::setup() {
+TemplateValve::TemplateValve()
+    : open_trigger_(new Trigger<>()),
+      close_trigger_(new Trigger<>),
+      stop_trigger_(new Trigger<>()),
+      toggle_trigger_(new Trigger<>()),
+      position_trigger_(new Trigger<float>()) {}
+
+void TemplateValve::setup() {
   switch (this->restore_mode_) {
     case VALVE_NO_RESTORE:
       break;
@@ -29,7 +35,35 @@ template<typename F> void TemplateValveBase<F>::setup() {
   }
 }
 
-template<typename F> void TemplateValveBase<F>::dump_config() {
+void TemplateValve::loop() {
+  bool changed = false;
+
+  if (this->state_f_.has_value()) {
+    auto s = (*this->state_f_)();
+    if (s.has_value()) {
+      auto pos = clamp(*s, 0.0f, 1.0f);
+      if (pos != this->position) {
+        this->position = pos;
+        changed = true;
+      }
+    }
+  }
+
+  if (changed)
+    this->publish_state();
+}
+
+void TemplateValve::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+void TemplateValve::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
+void TemplateValve::set_state_lambda(optional<float> (*f)()) { this->state_f_ = f; }
+float TemplateValve::get_setup_priority() const { return setup_priority::HARDWARE; }
+
+Trigger<> *TemplateValve::get_open_trigger() const { return this->open_trigger_; }
+Trigger<> *TemplateValve::get_close_trigger() const { return this->close_trigger_; }
+Trigger<> *TemplateValve::get_stop_trigger() const { return this->stop_trigger_; }
+Trigger<> *TemplateValve::get_toggle_trigger() const { return this->toggle_trigger_; }
+
+void TemplateValve::dump_config() {
   LOG_VALVE("", "Template Valve", this);
   ESP_LOGCONFIG(TAG,
                 "  Has position: %s\n"
@@ -37,7 +71,7 @@ template<typename F> void TemplateValveBase<F>::dump_config() {
                 YESNO(this->has_position_), YESNO(this->optimistic_));
 }
 
-template<typename F> void TemplateValveBase<F>::control(const ValveCall &call) {
+void TemplateValve::control(const ValveCall &call) {
   if (call.get_stop()) {
     this->stop_prev_trigger_();
     this->stop_trigger_->trigger();
@@ -72,7 +106,7 @@ template<typename F> void TemplateValveBase<F>::control(const ValveCall &call) {
   this->publish_state();
 }
 
-template<typename F> valve::ValveTraits TemplateValveBase<F>::get_traits() {
+ValveTraits TemplateValve::get_traits() {
   auto traits = ValveTraits();
   traits.set_is_assumed_state(this->assumed_state_);
   traits.set_supports_stop(this->has_stop_);
@@ -81,15 +115,18 @@ template<typename F> valve::ValveTraits TemplateValveBase<F>::get_traits() {
   return traits;
 }
 
-template<typename F> void TemplateValveBase<F>::stop_prev_trigger_() {
+Trigger<float> *TemplateValve::get_position_trigger() const { return this->position_trigger_; }
+
+void TemplateValve::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
+void TemplateValve::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
+void TemplateValve::set_has_position(bool has_position) { this->has_position_ = has_position; }
+
+void TemplateValve::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();
     this->prev_command_trigger_ = nullptr;
   }
 }
 
-template class TemplateValveBase<std::function<optional<float>()>>;
-template class TemplateValveBase<optional<float> (*)()>;
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/template/valve/template_valve.h

@@ -13,48 +13,28 @@ enum TemplateValveRestoreMode {
   VALVE_RESTORE_AND_CALL,
 };
 
-template<typename F> class TemplateValveBase : public valve::Valve, public Component {
+class TemplateValve : public valve::Valve, public Component {
  public:
-  TemplateValveBase()
-      : open_trigger_(new Trigger<>()),
-        close_trigger_(new Trigger<>()),
-        stop_trigger_(new Trigger<>()),
-        toggle_trigger_(new Trigger<>()),
-        position_trigger_(new Trigger<float>()) {}
+  TemplateValve();
 
-  void loop() override {
-    bool changed = false;
-
-    if (this->state_f_.has_value()) {
-      auto s = (*this->state_f_)();
-      if (s.has_value()) {
-        auto pos = clamp(*s, 0.0f, 1.0f);
-        if (pos != this->position) {
-          this->position = pos;
-          changed = true;
-        }
-      }
-    }
-
-    if (changed)
-      this->publish_state();
-  }
+  void set_state_lambda(optional<float> (*f)());
+  Trigger<> *get_open_trigger() const;
+  Trigger<> *get_close_trigger() const;
+  Trigger<> *get_stop_trigger() const;
+  Trigger<> *get_toggle_trigger() const;
+  Trigger<float> *get_position_trigger() const;
+  void set_optimistic(bool optimistic);
+  void set_assumed_state(bool assumed_state);
+  void set_has_stop(bool has_stop);
+  void set_has_position(bool has_position);
+  void set_has_toggle(bool has_toggle);
+  void set_restore_mode(TemplateValveRestoreMode restore_mode) { restore_mode_ = restore_mode; }
 
   void setup() override;
+  void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
-  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
-  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
-  Trigger<> *get_toggle_trigger() const { return this->toggle_trigger_; }
-  Trigger<float> *get_position_trigger() const { return this->position_trigger_; }
-  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-  void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
-  void set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
-  void set_has_position(bool has_position) { this->has_position_ = has_position; }
-  void set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
-  void set_restore_mode(TemplateValveRestoreMode restore_mode) { restore_mode_ = restore_mode; }
+  float get_setup_priority() const override;
 
  protected:
   void control(const valve::ValveCall &call) override;
@@ -62,7 +42,7 @@ template<typename F> class TemplateValveBase : public valve::Valve, public Compo
   void stop_prev_trigger_();
 
   TemplateValveRestoreMode restore_mode_{VALVE_NO_RESTORE};
-  optional<F> state_f_;
+  optional<optional<float> (*)()> state_f_;
   bool assumed_state_{false};
   bool optimistic_{false};
   Trigger<> *open_trigger_;
@@ -76,20 +56,5 @@ template<typename F> class TemplateValveBase : public valve::Valve, public Compo
   bool has_position_{false};
 };
 
-class TemplateValve : public TemplateValveBase<std::function<optional<float>()>> {
- public:
-  void set_state_lambda(std::function<optional<float>()> &&f) { this->state_f_ = f; }
-};
-
-/** Optimized template valve for stateless lambdas (no capture).
- *
- * Uses function pointers instead of std::function to reduce memory overhead.
- * Memory: 4 bytes (function pointer on 32-bit) vs 32 bytes (std::function) per lambda.
- */
-class StatelessTemplateValve : public TemplateValveBase<optional<float> (*)()> {
- public:
-  explicit StatelessTemplateValve(optional<float> (*f)()) { this->state_f_ = f; }
-};
-
 }  // namespace template_
 }  // namespace esphome

esphome/components/thermostat/thermostat_climate.h

@@ -40,10 +40,6 @@ enum OnBootRestoreFrom : uint8_t {
 };
 
 struct ThermostatClimateTimer {
-  ThermostatClimateTimer() = default;
-  ThermostatClimateTimer(bool active, uint32_t time, uint32_t started, std::function<void()> func)
-      : active(active), time(time), started(started), func(std::move(func)) {}
-
   bool active;
   uint32_t time;
   uint32_t started;

esphome/components/toshiba/toshiba.cpp

@@ -405,7 +405,7 @@ void ToshibaClimate::setup() {
   this->swing_modes_ = this->toshiba_swing_modes_();
 
   // Ensure swing mode is always initialized to a valid value
-  if (this->swing_modes_.empty() || !this->swing_modes_.count(this->swing_mode)) {
+  if (this->swing_modes_.empty() || this->swing_modes_.find(this->swing_mode) == this->swing_modes_.end()) {
     // No swing support for this model or current swing mode not supported, reset to OFF
     this->swing_mode = climate::CLIMATE_SWING_OFF;
   }

esphome/components/toshiba/toshiba.h

@@ -71,10 +71,10 @@ class ToshibaClimate : public climate_ir::ClimateIR {
       return TOSHIBA_RAS_2819T_TEMP_C_MAX;
     return TOSHIBA_GENERIC_TEMP_C_MAX;  // Default to GENERIC for unknown models
   }
-  climate::ClimateSwingModeMask toshiba_swing_modes_() {
+  std::set<climate::ClimateSwingMode> toshiba_swing_modes_() {
     return (this->model_ == MODEL_GENERIC)
-               ? climate::ClimateSwingModeMask()
-               : climate::ClimateSwingModeMask{climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL};
+               ? std::set<climate::ClimateSwingMode>{}
+               : std::set<climate::ClimateSwingMode>{climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL};
   }
   void encode_(remote_base::RemoteTransmitData *data, const uint8_t *message, uint8_t nbytes, uint8_t repeat);
   bool decode_(remote_base::RemoteReceiveData *data, uint8_t *message, uint8_t nbytes);

esphome/components/tuya/climate/tuya_climate.cpp

@@ -67,7 +67,9 @@ void TuyaClimate::setup() {
   }
   if (this->eco_id_.has_value()) {
     this->parent_->register_listener(*this->eco_id_, [this](const TuyaDatapoint &datapoint) {
+      // Whether data type is BOOL or ENUM, it will still be a 1 or a 0, so the functions below are valid in both cases
       this->eco_ = datapoint.value_bool;
+      this->eco_type_ = datapoint.type;
       ESP_LOGV(TAG, "MCU reported eco is: %s", ONOFF(this->eco_));
       this->compute_preset_();
       this->compute_target_temperature_();
@@ -176,7 +178,11 @@ void TuyaClimate::control(const climate::ClimateCall &call) {
     if (this->eco_id_.has_value()) {
       const bool eco = preset == climate::CLIMATE_PRESET_ECO;
       ESP_LOGV(TAG, "Setting eco: %s", ONOFF(eco));
-      this->parent_->set_boolean_datapoint_value(*this->eco_id_, eco);
+      if (this->eco_type_ == TuyaDatapointType::ENUM) {
+        this->parent_->set_enum_datapoint_value(*this->eco_id_, eco);
+      } else {
+        this->parent_->set_boolean_datapoint_value(*this->eco_id_, eco);
+      }
     }
     if (this->sleep_id_.has_value()) {
       const bool sleep = preset == climate::CLIMATE_PRESET_SLEEP;
@@ -306,12 +312,18 @@ climate::ClimateTraits TuyaClimate::traits() {
     traits.add_supported_preset(climate::CLIMATE_PRESET_NONE);
   }
   if (this->swing_vertical_id_.has_value() && this->swing_horizontal_id_.has_value()) {
-    traits.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH,
-                                      climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_HORIZONTAL});
+    std::set<climate::ClimateSwingMode> supported_swing_modes = {
+        climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH, climate::CLIMATE_SWING_VERTICAL,
+        climate::CLIMATE_SWING_HORIZONTAL};
+    traits.set_supported_swing_modes(std::move(supported_swing_modes));
   } else if (this->swing_vertical_id_.has_value()) {
-    traits.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL});
+    std::set<climate::ClimateSwingMode> supported_swing_modes = {climate::CLIMATE_SWING_OFF,
+                                                                 climate::CLIMATE_SWING_VERTICAL};
+    traits.set_supported_swing_modes(std::move(supported_swing_modes));
   } else if (this->swing_horizontal_id_.has_value()) {
-    traits.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL});
+    std::set<climate::ClimateSwingMode> supported_swing_modes = {climate::CLIMATE_SWING_OFF,
+                                                                 climate::CLIMATE_SWING_HORIZONTAL};
+    traits.set_supported_swing_modes(std::move(supported_swing_modes));
   }
 
   if (fan_speed_id_) {

esphome/components/tuya/climate/tuya_climate.h

@@ -104,6 +104,7 @@ class TuyaClimate : public climate::Climate, public Component {
   optional<uint8_t> eco_id_{};
   optional<uint8_t> sleep_id_{};
   optional<float> eco_temperature_{};
+  TuyaDatapointType eco_type_{};
   uint8_t active_state_;
   uint8_t fan_state_;
   optional<uint8_t> swing_vertical_id_{};

esphome/components/tuya/select/tuya_select.cpp

@@ -10,6 +10,7 @@ void TuyaSelect::setup() {
   this->parent_->register_listener(this->select_id_, [this](const TuyaDatapoint &datapoint) {
     uint8_t enum_value = datapoint.value_enum;
     ESP_LOGV(TAG, "MCU reported select %u value %u", this->select_id_, enum_value);
+    auto options = this->traits.get_options();
     auto mappings = this->mappings_;
     auto it = std::find(mappings.cbegin(), mappings.cend(), enum_value);
     if (it == mappings.end()) {
@@ -48,9 +49,9 @@ void TuyaSelect::dump_config() {
                 "  Data type: %s\n"
                 "  Options are:",
                 this->select_id_, this->is_int_ ? "int" : "enum");
-  const auto &options = this->traits.get_options();
+  auto options = this->traits.get_options();
   for (size_t i = 0; i < this->mappings_.size(); i++) {
-    ESP_LOGCONFIG(TAG, "    %i: %s", this->mappings_.at(i), options.at(i));
+    ESP_LOGCONFIG(TAG, "    %i: %s", this->mappings_.at(i), options.at(i).c_str());
   }
 }
 

esphome/components/uart/uart_component_esp_idf.cpp

@@ -99,10 +99,26 @@ void IDFUARTComponent::setup() {
 }
 
 void IDFUARTComponent::load_settings(bool dump_config) {
-  uart_config_t uart_config = this->get_config_();
-  esp_err_t err = uart_param_config(this->uart_num_, &uart_config);
+  esp_err_t err;
+
+  if (uart_is_driver_installed(this->uart_num_)) {
+    err = uart_driver_delete(this->uart_num_);
+    if (err != ESP_OK) {
+      ESP_LOGW(TAG, "uart_driver_delete failed: %s", esp_err_to_name(err));
+      this->mark_failed();
+      return;
+    }
+  }
+  err = uart_driver_install(this->uart_num_,        // UART number
+                            this->rx_buffer_size_,  // RX ring buffer size
+                            0,   // TX ring buffer size. If zero, driver will not use a TX buffer and TX function will
+                                 // block task until all data has been sent out
+                            20,  // event queue size/depth
+                            &this->uart_event_queue_,  // event queue
+                            0                          // Flags used to allocate the interrupt
+  );
   if (err != ESP_OK) {
-    ESP_LOGW(TAG, "uart_param_config failed: %s", esp_err_to_name(err));
+    ESP_LOGW(TAG, "uart_driver_install failed: %s", esp_err_to_name(err));
     this->mark_failed();
     return;
   }
@@ -119,10 +135,12 @@ void IDFUARTComponent::load_settings(bool dump_config) {
   int8_t flow_control = this->flow_control_pin_ != nullptr ? this->flow_control_pin_->get_pin() : -1;
 
   uint32_t invert = 0;
-  if (this->tx_pin_ != nullptr && this->tx_pin_->is_inverted())
+  if (this->tx_pin_ != nullptr && this->tx_pin_->is_inverted()) {
     invert |= UART_SIGNAL_TXD_INV;
-  if (this->rx_pin_ != nullptr && this->rx_pin_->is_inverted())
+  }
+  if (this->rx_pin_ != nullptr && this->rx_pin_->is_inverted()) {
     invert |= UART_SIGNAL_RXD_INV;
+  }
 
   err = uart_set_line_inverse(this->uart_num_, invert);
   if (err != ESP_OK) {
@@ -138,26 +156,6 @@ void IDFUARTComponent::load_settings(bool dump_config) {
     return;
   }
 
-  if (uart_is_driver_installed(this->uart_num_)) {
-    uart_driver_delete(this->uart_num_);
-    if (err != ESP_OK) {
-      ESP_LOGW(TAG, "uart_driver_delete failed: %s", esp_err_to_name(err));
-      this->mark_failed();
-      return;
-    }
-  }
-  err = uart_driver_install(this->uart_num_, /* UART RX ring buffer size. */ this->rx_buffer_size_,
-                            /* UART TX ring buffer size. If set to zero, driver will not use TX buffer, TX function will
-                               block task until all data have been sent out.*/
-                            0,
-                            /* UART event queue size/depth. */ 20, &(this->uart_event_queue_),
-                            /* Flags used to allocate the interrupt. */ 0);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "uart_driver_install failed: %s", esp_err_to_name(err));
-    this->mark_failed();
-    return;
-  }
-
   err = uart_set_rx_full_threshold(this->uart_num_, this->rx_full_threshold_);
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "uart_set_rx_full_threshold failed: %s", esp_err_to_name(err));
@@ -173,24 +171,32 @@ void IDFUARTComponent::load_settings(bool dump_config) {
   }
 
   auto mode = this->flow_control_pin_ != nullptr ? UART_MODE_RS485_HALF_DUPLEX : UART_MODE_UART;
-  err = uart_set_mode(this->uart_num_, mode);
+  err = uart_set_mode(this->uart_num_, mode);  // per docs, must be called only after uart_driver_install()
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "uart_set_mode failed: %s", esp_err_to_name(err));
     this->mark_failed();
     return;
   }
 
+  uart_config_t uart_config = this->get_config_();
+  err = uart_param_config(this->uart_num_, &uart_config);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "uart_param_config failed: %s", esp_err_to_name(err));
+    this->mark_failed();
+    return;
+  }
+
   if (dump_config) {
-    ESP_LOGCONFIG(TAG, "UART %u was reloaded.", this->uart_num_);
+    ESP_LOGCONFIG(TAG, "Reloaded UART %u", this->uart_num_);
     this->dump_config();
   }
 }
 
 void IDFUARTComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "UART Bus %u:", this->uart_num_);
-  LOG_PIN("  TX Pin: ", tx_pin_);
-  LOG_PIN("  RX Pin: ", rx_pin_);
-  LOG_PIN("  Flow Control Pin: ", flow_control_pin_);
+  LOG_PIN("  TX Pin: ", this->tx_pin_);
+  LOG_PIN("  RX Pin: ", this->rx_pin_);
+  LOG_PIN("  Flow Control Pin: ", this->flow_control_pin_);
   if (this->rx_pin_ != nullptr) {
     ESP_LOGCONFIG(TAG,
                   "  RX Buffer Size: %u\n"

esphome/components/usb_host/usb_host.h

@@ -82,12 +82,6 @@ struct TransferStatus {
 
 using transfer_cb_t = std::function<void(const TransferStatus &)>;
 
-enum TransferResult : uint8_t {
-  TRANSFER_OK = 0,
-  TRANSFER_ERROR_NO_SLOTS,
-  TRANSFER_ERROR_SUBMIT_FAILED,
-};
-
 class USBClient;
 
 // struct used to capture all data needed for a transfer
@@ -140,7 +134,7 @@ class USBClient : public Component {
   void on_opened(uint8_t addr);
   void on_removed(usb_device_handle_t handle);
   void control_transfer_callback(const usb_transfer_t *xfer) const;
-  TransferResult transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length);
+  void transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length);
   void transfer_out(uint8_t ep_address, const transfer_cb_t &callback, const uint8_t *data, uint16_t length);
   void dump_config() override;
   void release_trq(TransferRequest *trq);

esphome/components/usb_host/usb_host_client.cpp

@@ -334,7 +334,7 @@ static void control_callback(const usb_transfer_t *xfer) {
 // This multi-threaded access is intentional for performance - USB task can
 // immediately restart transfers without waiting for main loop scheduling.
 TransferRequest *USBClient::get_trq_() {
-  trq_bitmask_t mask = this->trq_in_use_.load(std::memory_order_acquire);
+  trq_bitmask_t mask = this->trq_in_use_.load(std::memory_order_relaxed);
 
   // Find first available slot (bit = 0) and try to claim it atomically
   // We use a while loop to allow retrying the same slot after CAS failure
@@ -443,15 +443,14 @@ static void transfer_callback(usb_transfer_t *xfer) {
  * @param ep_address The endpoint address.
  * @param callback The callback function to be called when the transfer is complete.
  * @param length The length of the data to be transferred.
- * @return TransferResult indicating success or specific failure reason
  *
  * @throws None.
  */
-TransferResult USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length) {
+void USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length) {
   auto *trq = this->get_trq_();
   if (trq == nullptr) {
     ESP_LOGE(TAG, "Too many requests queued");
-    return TRANSFER_ERROR_NO_SLOTS;
+    return;
   }
   trq->callback = callback;
   trq->transfer->callback = transfer_callback;
@@ -461,9 +460,7 @@ TransferResult USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &c
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "Failed to submit transfer, address=%x, length=%d, err=%x", ep_address, length, err);
     this->release_trq(trq);
-    return TRANSFER_ERROR_SUBMIT_FAILED;
   }
-  return TRANSFER_OK;
 }
 
 /**