Merge remote-tracking branch 'upstream/dev' into light-addr

CODEOWNERS

@@ -201,7 +201,6 @@ esphome/components/havells_solar/* @sourabhjaiswal
 esphome/components/hbridge/fan/* @WeekendWarrior
 esphome/components/hbridge/light/* @DotNetDann
 esphome/components/hbridge/switch/* @dwmw2
-esphome/components/hdc2010/* @optimusprimespace @ssieb
 esphome/components/he60r/* @clydebarrow
 esphome/components/heatpumpir/* @rob-deutsch
 esphome/components/hitachi_ac424/* @sourabhjaiswal

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

@@ -16,12 +16,7 @@ from esphome.const import (
     CONF_UPDATE_INTERVAL,
 )
 from esphome.core import ID
-from esphome.cpp_generator import (
-    LambdaExpression,
-    MockObj,
-    MockObjClass,
-    TemplateArgsType,
-)
+from esphome.cpp_generator import MockObj, MockObjClass, TemplateArgsType
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 from esphome.types import ConfigType
 from esphome.util import Registry
@@ -92,7 +87,6 @@ def validate_potentially_or_condition(value):
 
 DelayAction = cg.esphome_ns.class_("DelayAction", Action, cg.Component)
 LambdaAction = cg.esphome_ns.class_("LambdaAction", Action)
-StatelessLambdaAction = cg.esphome_ns.class_("StatelessLambdaAction", Action)
 IfAction = cg.esphome_ns.class_("IfAction", Action)
 WhileAction = cg.esphome_ns.class_("WhileAction", Action)
 RepeatAction = cg.esphome_ns.class_("RepeatAction", Action)
@@ -103,40 +97,9 @@ ResumeComponentAction = cg.esphome_ns.class_("ResumeComponentAction", Action)
 Automation = cg.esphome_ns.class_("Automation")
 
 LambdaCondition = cg.esphome_ns.class_("LambdaCondition", Condition)
-StatelessLambdaCondition = cg.esphome_ns.class_("StatelessLambdaCondition", Condition)
 ForCondition = cg.esphome_ns.class_("ForCondition", Condition, cg.Component)
 
 
-def new_lambda_pvariable(
-    id_obj: ID,
-    lambda_expr: LambdaExpression,
-    stateless_class: MockObjClass,
-    template_arg: cg.TemplateArguments | None = None,
-) -> MockObj:
-    """Create Pvariable for lambda, using stateless class if applicable.
-
-    Combines ID selection and Pvariable creation in one call. For stateless
-    lambdas (empty capture), uses function pointer instead of std::function.
-
-    Args:
-        id_obj: The ID object (action_id, condition_id, or filter_id)
-        lambda_expr: The lambda expression object
-        stateless_class: The stateless class to use for stateless lambdas
-        template_arg: Optional template arguments (for actions/conditions)
-
-    Returns:
-        The created Pvariable
-    """
-    # For stateless lambdas, use function pointer instead of std::function
-    if lambda_expr.capture == "":
-        id_obj = id_obj.copy()
-        id_obj.type = stateless_class
-
-    if template_arg is not None:
-        return cg.new_Pvariable(id_obj, template_arg, lambda_expr)
-    return cg.new_Pvariable(id_obj, lambda_expr)
-
-
 def validate_automation(extra_schema=None, extra_validators=None, single=False):
     if extra_schema is None:
         extra_schema = {}
@@ -277,9 +240,7 @@ async def lambda_condition_to_code(
     args: TemplateArgsType,
 ) -> MockObj:
     lambda_ = await cg.process_lambda(config, args, return_type=bool)
-    return new_lambda_pvariable(
-        condition_id, lambda_, StatelessLambdaCondition, template_arg
-    )
+    return cg.new_Pvariable(condition_id, template_arg, lambda_)
 
 
 @register_condition(
@@ -445,7 +406,7 @@ async def lambda_action_to_code(
     args: TemplateArgsType,
 ) -> MockObj:
     lambda_ = await cg.process_lambda(config, args, return_type=cg.void)
-    return new_lambda_pvariable(action_id, lambda_, StatelessLambdaAction, template_arg)
+    return cg.new_Pvariable(action_id, template_arg, lambda_)
 
 
 @register_action(

esphome/components/adalight/adalight_light_effect.cpp

@@ -9,7 +9,7 @@ static const char *const TAG = "adalight_light_effect";
 static const uint32_t ADALIGHT_ACK_INTERVAL = 1000;
 static const uint32_t ADALIGHT_RECEIVE_TIMEOUT = 1000;
 
-AdalightLightEffect::AdalightLightEffect(const char *name) : AddressableLightEffect(name) {}
+AdalightLightEffect::AdalightLightEffect(const std::string &name) : AddressableLightEffect(name) {}
 
 void AdalightLightEffect::start() {
   AddressableLightEffect::start();

esphome/components/adalight/adalight_light_effect.h

@@ -11,7 +11,7 @@ namespace adalight {
 
 class AdalightLightEffect : public light::AddressableLightEffect, public uart::UARTDevice {
  public:
-  AdalightLightEffect(const char *name);
+  AdalightLightEffect(const std::string &name);
 
   void start() override;
   void stop() override;

esphome/components/api/__init__.py

@@ -258,10 +258,6 @@ async def to_code(config):
     if config.get(CONF_ACTIONS) or config[CONF_CUSTOM_SERVICES]:
         cg.add_define("USE_API_SERVICES")
 
-    # Set USE_API_CUSTOM_SERVICES if external components need dynamic service registration
-    if config[CONF_CUSTOM_SERVICES]:
-        cg.add_define("USE_API_CUSTOM_SERVICES")
-
     if config[CONF_HOMEASSISTANT_SERVICES]:
         cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
 
@@ -269,8 +265,6 @@ async def to_code(config):
         cg.add_define("USE_API_HOMEASSISTANT_STATES")
 
     if actions := config.get(CONF_ACTIONS, []):
-        # Collect all triggers first, then register all at once with initializer_list
-        triggers: list[cg.Pvariable] = []
         for conf in actions:
             template_args = []
             func_args = []
@@ -284,10 +278,8 @@ async def to_code(config):
             trigger = cg.new_Pvariable(
                 conf[CONF_TRIGGER_ID], templ, conf[CONF_ACTION], service_arg_names
             )
-            triggers.append(trigger)
+            cg.add(var.register_user_service(trigger))
             await automation.build_automation(trigger, func_args, conf)
-        # Register all services at once - single allocation, no reallocations
-        cg.add(var.initialize_user_services(triggers))
 
     if CONF_ON_CLIENT_CONNECTED in config:
         cg.add_define("USE_API_CLIENT_CONNECTED_TRIGGER")

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

@@ -486,7 +486,7 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
   if (light->supports_effects()) {
     msg.effects.emplace_back("None");
     for (auto *effect : light->get_effects()) {
-      msg.effects.emplace_back(effect->get_name());
+      msg.effects.push_back(effect->get_name());
     }
   }
   return fill_and_encode_entity_info(light, msg, ListEntitiesLightResponse::MESSAGE_TYPE, conn, remaining_size,
@@ -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/api_server.h

@@ -125,14 +125,8 @@ class APIServer : public Component, public Controller {
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #endif  // USE_API_HOMEASSISTANT_SERVICES
 #ifdef USE_API_SERVICES
-  void initialize_user_services(std::initializer_list<UserServiceDescriptor *> services) {
-    this->user_services_.assign(services);
-  }
-#ifdef USE_API_CUSTOM_SERVICES
-  // Only compile push_back method when custom_services: true (external components)
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
 #endif
-#endif
 #ifdef USE_HOMEASSISTANT_TIME
   void request_time();
 #endif

esphome/components/api/custom_api_device.h

@@ -53,14 +53,8 @@ class CustomAPIDevice {
   template<typename T, typename... Ts>
   void register_service(void (T::*callback)(Ts...), const std::string &name,
                         const std::array<std::string, sizeof...(Ts)> &arg_names) {
-#ifdef USE_API_CUSTOM_SERVICES
     auto *service = new CustomAPIDeviceService<T, Ts...>(name, arg_names, (T *) this, callback);  // NOLINT
     global_api_server->register_user_service(service);
-#else
-    static_assert(
-        sizeof(T) == 0,
-        "register_service() requires 'custom_services: true' in the 'api:' section of your YAML configuration");
-#endif
   }
 #else
   template<typename T, typename... Ts>
@@ -92,14 +86,8 @@ class CustomAPIDevice {
    */
 #ifdef USE_API_SERVICES
   template<typename T> void register_service(void (T::*callback)(), const std::string &name) {
-#ifdef USE_API_CUSTOM_SERVICES
     auto *service = new CustomAPIDeviceService<T>(name, {}, (T *) this, callback);  // NOLINT
     global_api_server->register_user_service(service);
-#else
-    static_assert(
-        sizeof(T) == 0,
-        "register_service() requires 'custom_services: true' in the 'api:' section of your YAML configuration");
-#endif
   }
 #else
   template<typename T> void register_service(void (T::*callback)(), const std::string &name) {

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

@@ -155,7 +155,6 @@ DelayedOffFilter = binary_sensor_ns.class_("DelayedOffFilter", Filter, cg.Compon
 InvertFilter = binary_sensor_ns.class_("InvertFilter", Filter)
 AutorepeatFilter = binary_sensor_ns.class_("AutorepeatFilter", Filter, cg.Component)
 LambdaFilter = binary_sensor_ns.class_("LambdaFilter", Filter)
-StatelessLambdaFilter = binary_sensor_ns.class_("StatelessLambdaFilter", Filter)
 SettleFilter = binary_sensor_ns.class_("SettleFilter", Filter, cg.Component)
 
 _LOGGER = getLogger(__name__)
@@ -300,7 +299,7 @@ async def lambda_filter_to_code(config, filter_id):
     lambda_ = await cg.process_lambda(
         config, [(bool, "x")], return_type=cg.optional.template(bool)
     )
-    return automation.new_lambda_pvariable(filter_id, lambda_, StatelessLambdaFilter)
+    return cg.new_Pvariable(filter_id, lambda_)
 
 
 @register_filter(

esphome/components/binary_sensor/filter.h

@@ -111,21 +111,6 @@ class LambdaFilter : public Filter {
   std::function<optional<bool>(bool)> f_;
 };
 
-/** Optimized lambda filter 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 StatelessLambdaFilter : public Filter {
- public:
-  explicit StatelessLambdaFilter(optional<bool> (*f)(bool)) : f_(f) {}
-
-  optional<bool> new_value(bool value) override { return this->f_(value); }
-
- protected:
-  optional<bool> (*f_)(bool);
-};
-
 class SettleFilter : public Filter, public Component {
  public:
   optional<bool> new_value(bool value) override;

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) {
@@ -524,23 +524,13 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY)) {
     call.set_target_humidity(this->target_humidity);
   }
-  if (this->uses_custom_fan_mode) {
-    if (this->custom_fan_mode < traits.get_supported_custom_fan_modes().size()) {
-      call.fan_mode_.reset();
-      call.custom_fan_mode_ = *std::next(traits.get_supported_custom_fan_modes().cbegin(), this->custom_fan_mode);
-    }
-  } else if (traits.supports_fan_mode(this->fan_mode)) {
+  if (traits.get_supports_fan_modes() || !traits.get_supported_custom_fan_modes().empty()) {
     call.set_fan_mode(this->fan_mode);
   }
-  if (this->uses_custom_preset) {
-    if (this->custom_preset < traits.get_supported_custom_presets().size()) {
-      call.preset_.reset();
-      call.custom_preset_ = *std::next(traits.get_supported_custom_presets().cbegin(), this->custom_preset);
-    }
-  } else if (traits.supports_preset(this->preset)) {
+  if (traits.get_supports_presets() || !traits.get_supported_custom_presets().empty()) {
     call.set_preset(this->preset);
   }
-  if (traits.supports_swing_mode(this->swing_mode)) {
+  if (traits.get_supports_swing_modes()) {
     call.set_swing_mode(this->swing_mode);
   }
   return call;
@@ -559,25 +549,41 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY)) {
     climate->target_humidity = this->target_humidity;
   }
-  if (this->uses_custom_fan_mode) {
-    if (this->custom_fan_mode < traits.get_supported_custom_fan_modes().size()) {
-      climate->fan_mode.reset();
-      climate->custom_fan_mode = *std::next(traits.get_supported_custom_fan_modes().cbegin(), this->custom_fan_mode);
-    }
-  } else if (traits.supports_fan_mode(this->fan_mode)) {
+  if (traits.get_supports_fan_modes() && !this->uses_custom_fan_mode) {
     climate->fan_mode = this->fan_mode;
-    climate->custom_fan_mode.reset();
   }
-  if (this->uses_custom_preset) {
-    if (this->custom_preset < traits.get_supported_custom_presets().size()) {
-      climate->preset.reset();
-      climate->custom_preset = *std::next(traits.get_supported_custom_presets().cbegin(), this->custom_preset);
+  if (!traits.get_supported_custom_fan_modes().empty() && this->uses_custom_fan_mode) {
+    // std::set has consistent order (lexicographic for strings)
+    const auto &modes = traits.get_supported_custom_fan_modes();
+    if (custom_fan_mode < modes.size()) {
+      size_t i = 0;
+      for (const auto &mode : modes) {
+        if (i == this->custom_fan_mode) {
+          climate->custom_fan_mode = mode;
+          break;
+        }
+        i++;
+      }
     }
-  } else if (traits.supports_preset(this->preset)) {
-    climate->preset = this->preset;
-    climate->custom_preset.reset();
   }
-  if (traits.supports_swing_mode(this->swing_mode)) {
+  if (traits.get_supports_presets() && !this->uses_custom_preset) {
+    climate->preset = this->preset;
+  }
+  if (!traits.get_supported_custom_presets().empty() && uses_custom_preset) {
+    // std::set has consistent order (lexicographic for strings)
+    const auto &presets = traits.get_supported_custom_presets();
+    if (custom_preset < presets.size()) {
+      size_t i = 0;
+      for (const auto &preset : presets) {
+        if (i == this->custom_preset) {
+          climate->custom_preset = preset;
+          break;
+        }
+        i++;
+      }
+    }
+  }
+  if (traits.get_supports_swing_modes()) {
     climate->swing_mode = this->swing_mode;
   }
   climate->publish_state();

esphome/components/climate/climate.h

@@ -33,7 +33,6 @@ class Climate;
 class ClimateCall {
  public:
   explicit ClimateCall(Climate *parent) : parent_(parent) {}
-  friend struct ClimateDeviceRestoreState;
 
   /// Set the mode of the climate device.
   ClimateCall &set_mode(ClimateMode mode);

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/e131/e131.cpp

@@ -80,8 +80,8 @@ void E131Component::add_effect(E131AddressableLightEffect *light_effect) {
     return;
   }
 
-  ESP_LOGD(TAG, "Registering '%s' for universes %d-%d.", light_effect->get_name(), light_effect->get_first_universe(),
-           light_effect->get_last_universe());
+  ESP_LOGD(TAG, "Registering '%s' for universes %d-%d.", light_effect->get_name().c_str(),
+           light_effect->get_first_universe(), light_effect->get_last_universe());
 
   light_effects_.insert(light_effect);
 
@@ -95,8 +95,8 @@ void E131Component::remove_effect(E131AddressableLightEffect *light_effect) {
     return;
   }
 
-  ESP_LOGD(TAG, "Unregistering '%s' for universes %d-%d.", light_effect->get_name(), light_effect->get_first_universe(),
-           light_effect->get_last_universe());
+  ESP_LOGD(TAG, "Unregistering '%s' for universes %d-%d.", light_effect->get_name().c_str(),
+           light_effect->get_first_universe(), light_effect->get_last_universe());
 
   light_effects_.erase(light_effect);
 

esphome/components/e131/e131_addressable_light_effect.cpp

@@ -9,7 +9,7 @@ namespace e131 {
 static const char *const TAG = "e131_addressable_light_effect";
 static const int MAX_DATA_SIZE = (sizeof(E131Packet::values) - 1);
 
-E131AddressableLightEffect::E131AddressableLightEffect(const char *name) : AddressableLightEffect(name) {}
+E131AddressableLightEffect::E131AddressableLightEffect(const std::string &name) : AddressableLightEffect(name) {}
 
 int E131AddressableLightEffect::get_data_per_universe() const { return get_lights_per_universe() * channels_; }
 
@@ -58,8 +58,8 @@ bool E131AddressableLightEffect::process_(int universe, const E131Packet &packet
       std::min(it->size(), std::min(output_offset + get_lights_per_universe(), output_offset + packet.count - 1));
   auto *input_data = packet.values + 1;
 
-  ESP_LOGV(TAG, "Applying data for '%s' on %d universe, for %" PRId32 "-%d.", get_name(), universe, output_offset,
-           output_end);
+  ESP_LOGV(TAG, "Applying data for '%s' on %d universe, for %" PRId32 "-%d.", get_name().c_str(), universe,
+           output_offset, output_end);
 
   switch (channels_) {
     case E131_MONO:

esphome/components/e131/e131_addressable_light_effect.h

@@ -13,7 +13,7 @@ enum E131LightChannels { E131_MONO = 1, E131_RGB = 3, E131_RGBW = 4 };
 
 class E131AddressableLightEffect : public light::AddressableLightEffect {
  public:
-  E131AddressableLightEffect(const char *name);
+  E131AddressableLightEffect(const std::string &name);
 
   void start() override;
   void stop() override;

esphome/components/esp32/__init__.py

@@ -304,13 +304,9 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
 def _format_framework_espidf_version(ver: cv.Version, release: str) -> str:
     # format the given espidf (https://github.com/pioarduino/esp-idf/releases) version to
     # a PIO platformio/framework-espidf value
-    if ver == cv.Version(5, 4, 3) or ver >= cv.Version(5, 5, 1):
-        ext = "tar.xz"
-    else:
-        ext = "zip"
     if release:
-        return f"pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v{str(ver)}.{release}/esp-idf-v{str(ver)}.{ext}"
-    return f"pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v{str(ver)}/esp-idf-v{str(ver)}.{ext}"
+        return f"pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v{str(ver)}.{release}/esp-idf-v{str(ver)}.zip"
+    return f"pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v{str(ver)}/esp-idf-v{str(ver)}.zip"
 
 
 def _is_framework_url(source: str) -> str:
@@ -359,7 +355,6 @@ ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
     cv.Version(5, 5, 1): cv.Version(55, 3, 31, "1"),
     cv.Version(5, 5, 0): cv.Version(55, 3, 31, "1"),
-    cv.Version(5, 4, 3): cv.Version(55, 3, 32),
     cv.Version(5, 4, 2): cv.Version(54, 3, 21, "2"),
     cv.Version(5, 4, 1): cv.Version(54, 3, 21, "2"),
     cv.Version(5, 4, 0): cv.Version(54, 3, 21, "2"),
@@ -882,11 +877,6 @@ async def to_code(config):
     for clean_var in ("IDF_PATH", "IDF_TOOLS_PATH"):
         os.environ.pop(clean_var, None)
 
-    # Set the location of the IDF component manager cache
-    os.environ["IDF_COMPONENT_CACHE_PATH"] = str(
-        CORE.relative_internal_path(".espressif")
-    )
-
     add_extra_script(
         "post",
         "post_build.py",

esphome/components/esp32/gpio.h

@@ -40,13 +40,13 @@ class ESP32InternalGPIOPin : public InternalGPIOPin {
   // - 3 bytes for members below
   // - 1 byte padding for alignment
   // - 4 bytes for vtable pointer
-  uint8_t pin_;          // GPIO pin number (0-255, actual max ~54 on ESP32)
-  gpio::Flags flags_{};  // GPIO flags (1 byte)
+  uint8_t pin_;        // GPIO pin number (0-255, actual max ~54 on ESP32)
+  gpio::Flags flags_;  // GPIO flags (1 byte)
   struct PinFlags {
     uint8_t inverted : 1;        // Invert pin logic (1 bit)
     uint8_t drive_strength : 2;  // Drive strength 0-3 (2 bits)
     uint8_t reserved : 5;        // Reserved for future use (5 bits)
-  } pin_flags_{};                // Total: 1 byte
+  } pin_flags_;                  // Total: 1 byte
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   static bool isr_service_installed;
 };

esphome/components/esp32/gpio.py

@@ -223,10 +223,7 @@ async def esp32_pin_to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     num = config[CONF_NUMBER]
     cg.add(var.set_pin(getattr(gpio_num_t, f"GPIO_NUM_{num}")))
-    # Only set if true to avoid bloating setup() function
-    # (inverted bit in pin_flags_ bitfield is zero-initialized to false)
-    if config[CONF_INVERTED]:
-        cg.add(var.set_inverted(True))
+    cg.add(var.set_inverted(config[CONF_INVERTED]))
     if CONF_DRIVE_STRENGTH in config:
         cg.add(var.set_drive_strength(config[CONF_DRIVE_STRENGTH]))
     cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))

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/esp8266/gpio.h

@@ -29,8 +29,8 @@ class ESP8266GPIOPin : public InternalGPIOPin {
   void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;
 
   uint8_t pin_;
-  bool inverted_{};
-  gpio::Flags flags_{};
+  bool inverted_;
+  gpio::Flags flags_;
 };
 
 }  // namespace esp8266

esphome/components/esp8266/gpio.py

@@ -165,10 +165,7 @@ async def esp8266_pin_to_code(config):
     num = config[CONF_NUMBER]
     mode = config[CONF_MODE]
     cg.add(var.set_pin(num))
-    # Only set if true to avoid bloating setup() function
-    # (inverted bit in pin_flags_ bitfield is zero-initialized to false)
-    if config[CONF_INVERTED]:
-        cg.add(var.set_inverted(True))
+    cg.add(var.set_inverted(config[CONF_INVERTED]))
     cg.add(var.set_flags(pins.gpio_flags_expr(mode)))
     if num < 16:
         initial_state: PinInitialState = CORE.data[KEY_ESP8266][KEY_PIN_INITIAL_STATES][

esphome/components/ethernet/__init__.py

@@ -32,7 +32,6 @@ from esphome.const import (
     CONF_MISO_PIN,
     CONF_MODE,
     CONF_MOSI_PIN,
-    CONF_NUMBER,
     CONF_PAGE_ID,
     CONF_PIN,
     CONF_POLLING_INTERVAL,
@@ -53,36 +52,12 @@ from esphome.core import (
     coroutine_with_priority,
 )
 import esphome.final_validate as fv
-from esphome.types import ConfigType
 
 CONFLICTS_WITH = ["wifi"]
 DEPENDENCIES = ["esp32"]
 AUTO_LOAD = ["network"]
 LOGGER = logging.getLogger(__name__)
 
-# RMII pins that are hardcoded on ESP32 classic and cannot be changed
-# These pins are used by the internal Ethernet MAC when using RMII PHYs
-ESP32_RMII_FIXED_PINS = {
-    19: "EMAC_TXD0",
-    21: "EMAC_TX_EN",
-    22: "EMAC_TXD1",
-    25: "EMAC_RXD0",
-    26: "EMAC_RXD1",
-    27: "EMAC_RX_CRS_DV",
-}
-
-# RMII default pins for ESP32-P4
-# These are the default pins used by ESP-IDF and are configurable in principle,
-# but ESPHome's ethernet component currently has no way to change them
-ESP32P4_RMII_DEFAULT_PINS = {
-    34: "EMAC_TXD0",
-    35: "EMAC_TXD1",
-    28: "EMAC_RX_CRS_DV",
-    29: "EMAC_RXD0",
-    30: "EMAC_RXD1",
-    49: "EMAC_TX_EN",
-}
-
 ethernet_ns = cg.esphome_ns.namespace("ethernet")
 PHYRegister = ethernet_ns.struct("PHYRegister")
 CONF_PHY_ADDR = "phy_addr"
@@ -298,7 +273,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def _final_validate_spi(config):
+def _final_validate(config):
     if config[CONF_TYPE] not in SPI_ETHERNET_TYPES:
         return
     if spi_configs := fv.full_config.get().get(CONF_SPI):
@@ -317,6 +292,9 @@ def _final_validate_spi(config):
                     )
 
 
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 def manual_ip(config):
     return cg.StructInitializer(
         ManualIP,
@@ -405,57 +383,3 @@ async def to_code(config):
 
     if CORE.using_arduino:
         cg.add_library("WiFi", None)
-
-
-def _final_validate_rmii_pins(config: ConfigType) -> None:
-    """Validate that RMII pins are not used by other components."""
-    # Only validate for RMII-based PHYs on ESP32/ESP32P4
-    if config[CONF_TYPE] in SPI_ETHERNET_TYPES or config[CONF_TYPE] == "OPENETH":
-        return  # SPI and OPENETH don't use RMII
-
-    variant = get_esp32_variant()
-    if variant == VARIANT_ESP32:
-        rmii_pins = ESP32_RMII_FIXED_PINS
-        is_configurable = False
-    elif variant == VARIANT_ESP32P4:
-        rmii_pins = ESP32P4_RMII_DEFAULT_PINS
-        is_configurable = True
-    else:
-        return  # No RMII validation needed for other variants
-
-    # Check all used pins against RMII reserved pins
-    for pin_list in pins.PIN_SCHEMA_REGISTRY.pins_used.values():
-        for pin_path, _, pin_config in pin_list:
-            pin_num = pin_config.get(CONF_NUMBER)
-            if pin_num not in rmii_pins:
-                continue
-            # Found a conflict - show helpful error message
-            pin_function = rmii_pins[pin_num]
-            component_path = ".".join(str(p) for p in pin_path)
-            if is_configurable:
-                error_msg = (
-                    f"GPIO{pin_num} is used by Ethernet RMII "
-                    f"({pin_function}) with the current default "
-                    f"configuration. This conflicts with '{component_path}'. "
-                    f"Please choose a different GPIO pin for "
-                    f"'{component_path}'."
-                )
-            else:
-                error_msg = (
-                    f"GPIO{pin_num} is reserved for Ethernet RMII "
-                    f"({pin_function}) and cannot be used. This pin is "
-                    f"hardcoded by ESP-IDF and cannot be changed when using "
-                    f"RMII Ethernet PHYs. Please choose a different GPIO pin "
-                    f"for '{component_path}'."
-                )
-            raise cv.Invalid(error_msg, path=pin_path)
-
-
-def _final_validate(config: ConfigType) -> ConfigType:
-    """Final validation for Ethernet component."""
-    _final_validate_spi(config)
-    _final_validate_rmii_pins(config)
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate

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

@@ -1 +0,0 @@
-CODEOWNERS = ["@optimusprimespace", "@ssieb"]

esphome/components/hdc2010/hdc2010.cpp

@@ -1,111 +0,0 @@
-#include "esphome/core/hal.h"
-#include "hdc2010.h"
-// https://github.com/vigsterkr/homebridge-hdc2010/blob/main/src/hdc2010.js
-// https://github.com/lime-labs/HDC2080-Arduino/blob/master/src/HDC2080.cpp
-namespace esphome {
-namespace hdc2010 {
-
-static const char *const TAG = "hdc2010";
-
-static const uint8_t HDC2010_ADDRESS = 0x40;  // 0b1000000 or 0b1000001 from datasheet
-static const uint8_t HDC2010_CMD_CONFIGURATION_MEASUREMENT = 0x8F;
-static const uint8_t HDC2010_CMD_START_MEASUREMENT = 0xF9;
-static const uint8_t HDC2010_CMD_TEMPERATURE_LOW = 0x00;
-static const uint8_t HDC2010_CMD_TEMPERATURE_HIGH = 0x01;
-static const uint8_t HDC2010_CMD_HUMIDITY_LOW = 0x02;
-static const uint8_t HDC2010_CMD_HUMIDITY_HIGH = 0x03;
-static const uint8_t CONFIG = 0x0E;
-static const uint8_t MEASUREMENT_CONFIG = 0x0F;
-
-void HDC2010Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
-  const uint8_t data[2] = {
-      0b00000000,  // resolution 14bit for both humidity and temperature
-      0b00000000   // reserved
-  };
-
-  if (!this->write_bytes(HDC2010_CMD_CONFIGURATION_MEASUREMENT, data, 2)) {
-    ESP_LOGW(TAG, "Initial config instruction error");
-    this->status_set_warning();
-    return;
-  }
-
-  // Set measurement mode to temperature and humidity
-  uint8_t config_contents;
-  this->read_register(MEASUREMENT_CONFIG, &config_contents, 1);
-  config_contents = (config_contents & 0xF9);  // Always set to TEMP_AND_HUMID mode
-  this->write_bytes(MEASUREMENT_CONFIG, &config_contents, 1);
-
-  // Set rate to manual
-  this->read_register(CONFIG, &config_contents, 1);
-  config_contents &= 0x8F;
-  this->write_bytes(CONFIG, &config_contents, 1);
-
-  // Set temperature resolution to 14bit
-  this->read_register(CONFIG, &config_contents, 1);
-  config_contents &= 0x3F;
-  this->write_bytes(CONFIG, &config_contents, 1);
-
-  // Set humidity resolution to 14bit
-  this->read_register(CONFIG, &config_contents, 1);
-  config_contents &= 0xCF;
-  this->write_bytes(CONFIG, &config_contents, 1);
-}
-
-void HDC2010Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "HDC2010:");
-  LOG_I2C_DEVICE(this);
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
-  }
-  LOG_UPDATE_INTERVAL(this);
-  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
-  LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
-}
-
-void HDC2010Component::update() {
-  // Trigger measurement
-  uint8_t config_contents;
-  this->read_register(CONFIG, &config_contents, 1);
-  config_contents |= 0x01;
-  this->write_bytes(MEASUREMENT_CONFIG, &config_contents, 1);
-
-  // 1ms delay after triggering the sample
-  set_timeout(1, [this]() {
-    if (this->temperature_sensor_ != nullptr) {
-      float temp = this->read_temp();
-      this->temperature_sensor_->publish_state(temp);
-      ESP_LOGD(TAG, "Temp=%.1f°C", temp);
-    }
-
-    if (this->humidity_sensor_ != nullptr) {
-      float humidity = this->read_humidity();
-      this->humidity_sensor_->publish_state(humidity);
-      ESP_LOGD(TAG, "Humidity=%.1f%%", humidity);
-    }
-  });
-}
-
-float HDC2010Component::read_temp() {
-  uint8_t byte[2];
-
-  this->read_register(HDC2010_CMD_TEMPERATURE_LOW, &byte[0], 1);
-  this->read_register(HDC2010_CMD_TEMPERATURE_HIGH, &byte[1], 1);
-
-  uint16_t temp = encode_uint16(byte[1], byte[0]);
-  return (float) temp * 0.0025177f - 40.0f;
-}
-
-float HDC2010Component::read_humidity() {
-  uint8_t byte[2];
-
-  this->read_register(HDC2010_CMD_HUMIDITY_LOW, &byte[0], 1);
-  this->read_register(HDC2010_CMD_HUMIDITY_HIGH, &byte[1], 1);
-
-  uint16_t humidity = encode_uint16(byte[1], byte[0]);
-  return (float) humidity * 0.001525879f;
-}
-
-}  // namespace hdc2010
-}  // namespace esphome

esphome/components/hdc2010/hdc2010.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/i2c/i2c.h"
-
-namespace esphome {
-namespace hdc2010 {
-
-class HDC2010Component : public PollingComponent, public i2c::I2CDevice {
- public:
-  void set_temperature_sensor(sensor::Sensor *temperature) { this->temperature_sensor_ = temperature; }
-
-  void set_humidity_sensor(sensor::Sensor *humidity) { this->humidity_sensor_ = humidity; }
-
-  /// Setup the sensor and check for connection.
-  void setup() override;
-  void dump_config() override;
-  /// Retrieve the latest sensor values. This operation takes approximately 16ms.
-  void update() override;
-
-  float read_temp();
-
-  float read_humidity();
-
- protected:
-  sensor::Sensor *temperature_sensor_{nullptr};
-  sensor::Sensor *humidity_sensor_{nullptr};
-};
-
-}  // namespace hdc2010
-}  // namespace esphome

esphome/components/hdc2010/sensor.py

@@ -1,56 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import i2c, sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_HUMIDITY,
-    CONF_ID,
-    CONF_TEMPERATURE,
-    DEVICE_CLASS_HUMIDITY,
-    DEVICE_CLASS_TEMPERATURE,
-    STATE_CLASS_MEASUREMENT,
-    UNIT_CELSIUS,
-    UNIT_PERCENT,
-)
-
-DEPENDENCIES = ["i2c"]
-
-hdc2010_ns = cg.esphome_ns.namespace("hdc2010")
-HDC2010Component = hdc2010_ns.class_(
-    "HDC2010Component", cg.PollingComponent, i2c.I2CDevice
-)
-
-CONFIG_SCHEMA = (
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(HDC2010Component),
-            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
-                unit_of_measurement=UNIT_CELSIUS,
-                accuracy_decimals=1,
-                device_class=DEVICE_CLASS_TEMPERATURE,
-                state_class=STATE_CLASS_MEASUREMENT,
-            ),
-            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
-                unit_of_measurement=UNIT_PERCENT,
-                accuracy_decimals=0,
-                device_class=DEVICE_CLASS_HUMIDITY,
-                state_class=STATE_CLASS_MEASUREMENT,
-            ),
-        }
-    )
-    .extend(cv.polling_component_schema("60s"))
-    .extend(i2c.i2c_device_schema(0x40))
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await i2c.register_i2c_device(var, config)
-
-    if temperature_config := config.get(CONF_TEMPERATURE):
-        sens = await sensor.new_sensor(temperature_config)
-        cg.add(var.set_temperature_sensor(sens))
-
-    if humidity_config := config.get(CONF_HUMIDITY):
-        sens = await sensor.new_sensor(humidity_config)
-        cg.add(var.set_humidity_sensor(sens))

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/host/gpio.h

@@ -28,8 +28,8 @@ class HostGPIOPin : public InternalGPIOPin {
   void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;
 
   uint8_t pin_;
-  bool inverted_{};
-  gpio::Flags flags_{};
+  bool inverted_;
+  gpio::Flags flags_;
 };
 
 }  // namespace host

esphome/components/host/gpio.py

@@ -57,9 +57,6 @@ async def host_pin_to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     num = config[CONF_NUMBER]
     cg.add(var.set_pin(num))
-    # Only set if true to avoid bloating setup() function
-    # (inverted bit in pin_flags_ bitfield is zero-initialized to false)
-    if config[CONF_INVERTED]:
-        cg.add(var.set_inverted(True))
+    cg.add(var.set_inverted(config[CONF_INVERTED]))
     cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
     return var

esphome/components/http_request/http_request.h

@@ -169,7 +169,7 @@ class HttpRequestComponent : public Component {
  protected:
   virtual std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method,
                                                  const std::string &body, const std::list<Header> &request_headers,
-                                                 const std::set<std::string> &collect_headers) = 0;
+                                                 std::set<std::string> collect_headers) = 0;
   const char *useragent_{nullptr};
   bool follow_redirects_{};
   uint16_t redirect_limit_{};

esphome/components/http_request/http_request_arduino.cpp

@@ -17,7 +17,7 @@ static const char *const TAG = "http_request.arduino";
 std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &url, const std::string &method,
                                                            const std::string &body,
                                                            const std::list<Header> &request_headers,
-                                                           const std::set<std::string> &collect_headers) {
+                                                           std::set<std::string> collect_headers) {
   if (!network::is_connected()) {
     this->status_momentary_error("failed", 1000);
     ESP_LOGW(TAG, "HTTP Request failed; Not connected to network");

esphome/components/http_request/http_request_arduino.h

@@ -33,7 +33,7 @@ class HttpRequestArduino : public HttpRequestComponent {
  protected:
   std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
                                          const std::list<Header> &request_headers,
-                                         const std::set<std::string> &collect_headers) override;
+                                         std::set<std::string> collect_headers) override;
 };
 
 }  // namespace http_request

esphome/components/http_request/http_request_host.cpp

@@ -20,7 +20,7 @@ static const char *const TAG = "http_request.host";
 std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url, const std::string &method,
                                                         const std::string &body,
                                                         const std::list<Header> &request_headers,
-                                                        const std::set<std::string> &response_headers) {
+                                                        std::set<std::string> response_headers) {
   if (!network::is_connected()) {
     this->status_momentary_error("failed", 1000);
     ESP_LOGW(TAG, "HTTP Request failed; Not connected to network");

esphome/components/http_request/http_request_host.h

@@ -20,7 +20,7 @@ class HttpRequestHost : public HttpRequestComponent {
  public:
   std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
                                          const std::list<Header> &request_headers,
-                                         const std::set<std::string> &response_headers) override;
+                                         std::set<std::string> response_headers) override;
   void set_ca_path(const char *ca_path) { this->ca_path_ = ca_path; }
 
  protected:

esphome/components/http_request/http_request_idf.cpp

@@ -55,7 +55,7 @@ esp_err_t HttpRequestIDF::http_event_handler(esp_http_client_event_t *evt) {
 std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, const std::string &method,
                                                        const std::string &body,
                                                        const std::list<Header> &request_headers,
-                                                       const std::set<std::string> &collect_headers) {
+                                                       std::set<std::string> collect_headers) {
   if (!network::is_connected()) {
     this->status_momentary_error("failed", 1000);
     ESP_LOGE(TAG, "HTTP Request failed; Not connected to network");

esphome/components/http_request/http_request_idf.h

@@ -39,7 +39,7 @@ class HttpRequestIDF : public HttpRequestComponent {
  protected:
   std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
                                          const std::list<Header> &request_headers,
-                                         const std::set<std::string> &collect_headers) override;
+                                         std::set<std::string> collect_headers) override;
   // if zero ESP-IDF will use DEFAULT_HTTP_BUF_SIZE
   uint16_t buffer_size_rx_{};
   uint16_t buffer_size_tx_{};

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/improv_serial/improv_serial_component.cpp

@@ -28,38 +28,6 @@ void ImprovSerialComponent::setup() {
   }
 }
 
-void ImprovSerialComponent::loop() {
-  if (this->last_read_byte_ && (millis() - this->last_read_byte_ > IMPROV_SERIAL_TIMEOUT)) {
-    this->last_read_byte_ = 0;
-    this->rx_buffer_.clear();
-    ESP_LOGV(TAG, "Timeout");
-  }
-
-  auto byte = this->read_byte_();
-  while (byte.has_value()) {
-    if (this->parse_improv_serial_byte_(byte.value())) {
-      this->last_read_byte_ = millis();
-    } else {
-      this->last_read_byte_ = 0;
-      this->rx_buffer_.clear();
-    }
-    byte = this->read_byte_();
-  }
-
-  if (this->state_ == improv::STATE_PROVISIONING) {
-    if (wifi::global_wifi_component->is_connected()) {
-      wifi::global_wifi_component->save_wifi_sta(this->connecting_sta_.get_ssid(),
-                                                 this->connecting_sta_.get_password());
-      this->connecting_sta_ = {};
-      this->cancel_timeout("wifi-connect-timeout");
-      this->set_state_(improv::STATE_PROVISIONED);
-
-      std::vector<uint8_t> url = this->build_rpc_settings_response_(improv::WIFI_SETTINGS);
-      this->send_response_(url);
-    }
-  }
-}
-
 void ImprovSerialComponent::dump_config() { ESP_LOGCONFIG(TAG, "Improv Serial:"); }
 
 optional<uint8_t> ImprovSerialComponent::read_byte_() {
@@ -110,28 +78,8 @@ optional<uint8_t> ImprovSerialComponent::read_byte_() {
   return byte;
 }
 
-void ImprovSerialComponent::write_data_(const uint8_t *data, const size_t size) {
-  // First, set length field
-  this->tx_header_[TX_LENGTH_IDX] = this->tx_header_[TX_TYPE_IDX] == TYPE_RPC_RESPONSE ? size : 1;
-
-  const bool there_is_data = data != nullptr && size > 0;
-  // If there_is_data, checksum must not include our optional data byte
-  const uint8_t header_checksum_len = there_is_data ? TX_BUFFER_SIZE - 3 : TX_BUFFER_SIZE - 2;
-  // Only transmit the full buffer length if there is no data (only state/error byte is provided in this case)
-  const uint8_t header_tx_len = there_is_data ? TX_BUFFER_SIZE - 3 : TX_BUFFER_SIZE;
-  // Calculate checksum for message
-  uint8_t checksum = 0;
-  for (uint8_t i = 0; i < header_checksum_len; i++) {
-    checksum += this->tx_header_[i];
-  }
-  if (there_is_data) {
-    // Include data in checksum
-    for (size_t i = 0; i < size; i++) {
-      checksum += data[i];
-    }
-  }
-  this->tx_header_[TX_CHECKSUM_IDX] = checksum;
-
+void ImprovSerialComponent::write_data_(std::vector<uint8_t> &data) {
+  data.push_back('\n');
 #ifdef USE_ESP32
   switch (logger::global_logger->get_uart()) {
     case logger::UART_SELECTION_UART0:
@@ -139,45 +87,63 @@ void ImprovSerialComponent::write_data_(const uint8_t *data, const size_t size)
 #if !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32C6) && \
     !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32S3)
     case logger::UART_SELECTION_UART2:
-#endif
-      uart_write_bytes(this->uart_num_, this->tx_header_, header_tx_len);
-      if (there_is_data) {
-        uart_write_bytes(this->uart_num_, data, size);
-        uart_write_bytes(this->uart_num_, &this->tx_header_[TX_CHECKSUM_IDX], 2);  // Footer: checksum and newline
-      }
+#endif  // !USE_ESP32_VARIANT_ESP32C3 && !USE_ESP32_VARIANT_ESP32S2 && !USE_ESP32_VARIANT_ESP32S3
+      uart_write_bytes(this->uart_num_, data.data(), data.size());
       break;
 #if defined(USE_LOGGER_USB_CDC) && defined(CONFIG_ESP_CONSOLE_USB_CDC)
-    case logger::UART_SELECTION_USB_CDC:
-      esp_usb_console_write_buf((const char *) this->tx_header_, header_tx_len);
-      if (there_is_data) {
-        esp_usb_console_write_buf((const char *) data, size);
-        esp_usb_console_write_buf((const char *) &this->tx_header_[TX_CHECKSUM_IDX],
-                                  2);  // Footer: checksum and newline
-      }
+    case logger::UART_SELECTION_USB_CDC: {
+      const char *msg = (char *) data.data();
+      esp_usb_console_write_buf(msg, data.size());
       break;
-#endif
+    }
+#endif  // USE_LOGGER_USB_CDC
 #ifdef USE_LOGGER_USB_SERIAL_JTAG
     case logger::UART_SELECTION_USB_SERIAL_JTAG:
-      usb_serial_jtag_write_bytes((const char *) this->tx_header_, header_tx_len, 20 / portTICK_PERIOD_MS);
-      if (there_is_data) {
-        usb_serial_jtag_write_bytes((const char *) data, size, 20 / portTICK_PERIOD_MS);
-        usb_serial_jtag_write_bytes((const char *) &this->tx_header_[TX_CHECKSUM_IDX], 2,
-                                    20 / portTICK_PERIOD_MS);  // Footer: checksum and newline
-      }
+      usb_serial_jtag_write_bytes((char *) data.data(), data.size(), 20 / portTICK_PERIOD_MS);
+      delay(10);
+      usb_serial_jtag_ll_txfifo_flush();  // fixes for issue in IDF 4.4.7
       break;
-#endif
+#endif  // USE_LOGGER_USB_SERIAL_JTAG
     default:
       break;
   }
 #elif defined(USE_ARDUINO)
-  this->hw_serial_->write(this->tx_header_, header_tx_len);
-  if (there_is_data) {
-    this->hw_serial_->write(data, size);
-    this->hw_serial_->write(&this->tx_header_[TX_CHECKSUM_IDX], 2);  // Footer: checksum and newline
-  }
+  this->hw_serial_->write(data.data(), data.size());
 #endif
 }
 
+void ImprovSerialComponent::loop() {
+  if (this->last_read_byte_ && (millis() - this->last_read_byte_ > IMPROV_SERIAL_TIMEOUT)) {
+    this->last_read_byte_ = 0;
+    this->rx_buffer_.clear();
+    ESP_LOGV(TAG, "Improv Serial timeout");
+  }
+
+  auto byte = this->read_byte_();
+  while (byte.has_value()) {
+    if (this->parse_improv_serial_byte_(byte.value())) {
+      this->last_read_byte_ = millis();
+    } else {
+      this->last_read_byte_ = 0;
+      this->rx_buffer_.clear();
+    }
+    byte = this->read_byte_();
+  }
+
+  if (this->state_ == improv::STATE_PROVISIONING) {
+    if (wifi::global_wifi_component->is_connected()) {
+      wifi::global_wifi_component->save_wifi_sta(this->connecting_sta_.get_ssid(),
+                                                 this->connecting_sta_.get_password());
+      this->connecting_sta_ = {};
+      this->cancel_timeout("wifi-connect-timeout");
+      this->set_state_(improv::STATE_PROVISIONED);
+
+      std::vector<uint8_t> url = this->build_rpc_settings_response_(improv::WIFI_SETTINGS);
+      this->send_response_(url);
+    }
+  }
+}
+
 std::vector<uint8_t> ImprovSerialComponent::build_rpc_settings_response_(improv::Command command) {
   std::vector<std::string> urls;
 #ifdef USE_IMPROV_SERIAL_NEXT_URL
@@ -211,13 +177,13 @@ std::vector<uint8_t> ImprovSerialComponent::build_version_info_() {
 bool ImprovSerialComponent::parse_improv_serial_byte_(uint8_t byte) {
   size_t at = this->rx_buffer_.size();
   this->rx_buffer_.push_back(byte);
-  ESP_LOGV(TAG, "Byte: 0x%02X", byte);
+  ESP_LOGV(TAG, "Improv Serial byte: 0x%02X", byte);
   const uint8_t *raw = &this->rx_buffer_[0];
 
   return improv::parse_improv_serial_byte(
       at, byte, raw, [this](improv::ImprovCommand command) -> bool { return this->parse_improv_payload_(command); },
       [this](improv::Error error) -> void {
-        ESP_LOGW(TAG, "Error decoding payload");
+        ESP_LOGW(TAG, "Error decoding Improv payload");
         this->set_error_(error);
       });
 }
@@ -233,7 +199,7 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
       wifi::global_wifi_component->set_sta(sta);
       wifi::global_wifi_component->start_connecting(sta, false);
       this->set_state_(improv::STATE_PROVISIONING);
-      ESP_LOGD(TAG, "Received settings: SSID=%s, password=" LOG_SECRET("%s"), command.ssid.c_str(),
+      ESP_LOGD(TAG, "Received Improv wifi settings ssid=%s, password=" LOG_SECRET("%s"), command.ssid.c_str(),
                command.password.c_str());
 
       auto f = std::bind(&ImprovSerialComponent::on_wifi_connect_timeout_, this);
@@ -274,7 +240,7 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
       return true;
     }
     default: {
-      ESP_LOGW(TAG, "Unknown payload");
+      ESP_LOGW(TAG, "Unknown Improv payload");
       this->set_error_(improv::ERROR_UNKNOWN_RPC);
       return false;
     }
@@ -283,26 +249,57 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
 
 void ImprovSerialComponent::set_state_(improv::State state) {
   this->state_ = state;
-  this->tx_header_[TX_TYPE_IDX] = TYPE_CURRENT_STATE;
-  this->tx_header_[TX_DATA_IDX] = state;
-  this->write_data_();
+
+  std::vector<uint8_t> data = {'I', 'M', 'P', 'R', 'O', 'V'};
+  data.resize(11);
+  data[6] = IMPROV_SERIAL_VERSION;
+  data[7] = TYPE_CURRENT_STATE;
+  data[8] = 1;
+  data[9] = state;
+
+  uint8_t checksum = 0x00;
+  for (uint8_t d : data)
+    checksum += d;
+  data[10] = checksum;
+
+  this->write_data_(data);
 }
 
 void ImprovSerialComponent::set_error_(improv::Error error) {
-  this->tx_header_[TX_TYPE_IDX] = TYPE_ERROR_STATE;
-  this->tx_header_[TX_DATA_IDX] = error;
-  this->write_data_();
+  std::vector<uint8_t> data = {'I', 'M', 'P', 'R', 'O', 'V'};
+  data.resize(11);
+  data[6] = IMPROV_SERIAL_VERSION;
+  data[7] = TYPE_ERROR_STATE;
+  data[8] = 1;
+  data[9] = error;
+
+  uint8_t checksum = 0x00;
+  for (uint8_t d : data)
+    checksum += d;
+  data[10] = checksum;
+  this->write_data_(data);
 }
 
 void ImprovSerialComponent::send_response_(std::vector<uint8_t> &response) {
-  this->tx_header_[TX_TYPE_IDX] = TYPE_RPC_RESPONSE;
-  this->write_data_(response.data(), response.size());
+  std::vector<uint8_t> data = {'I', 'M', 'P', 'R', 'O', 'V'};
+  data.resize(9);
+  data[6] = IMPROV_SERIAL_VERSION;
+  data[7] = TYPE_RPC_RESPONSE;
+  data[8] = response.size();
+  data.insert(data.end(), response.begin(), response.end());
+
+  uint8_t checksum = 0x00;
+  for (uint8_t d : data)
+    checksum += d;
+  data.push_back(checksum);
+
+  this->write_data_(data);
 }
 
 void ImprovSerialComponent::on_wifi_connect_timeout_() {
   this->set_error_(improv::ERROR_UNABLE_TO_CONNECT);
   this->set_state_(improv::STATE_AUTHORIZED);
-  ESP_LOGW(TAG, "Timed out while connecting to Wi-Fi network");
+  ESP_LOGW(TAG, "Timed out trying to connect to given WiFi network");
   wifi::global_wifi_component->clear_sta();
 }
 

esphome/components/improv_serial/improv_serial_component.h

@@ -26,16 +26,6 @@
 namespace esphome {
 namespace improv_serial {
 
-// TX buffer layout constants
-static constexpr uint8_t TX_HEADER_SIZE = 6;  // Bytes 0-5 = "IMPROV"
-static constexpr uint8_t TX_VERSION_IDX = 6;
-static constexpr uint8_t TX_TYPE_IDX = 7;
-static constexpr uint8_t TX_LENGTH_IDX = 8;
-static constexpr uint8_t TX_DATA_IDX = 9;  // For state/error messages only
-static constexpr uint8_t TX_CHECKSUM_IDX = 10;
-static constexpr uint8_t TX_NEWLINE_IDX = 11;
-static constexpr uint8_t TX_BUFFER_SIZE = 12;
-
 enum ImprovSerialType : uint8_t {
   TYPE_CURRENT_STATE = 0x01,
   TYPE_ERROR_STATE = 0x02,
@@ -67,22 +57,7 @@ class ImprovSerialComponent : public Component, public improv_base::ImprovBase {
   std::vector<uint8_t> build_version_info_();
 
   optional<uint8_t> read_byte_();
-  void write_data_(const uint8_t *data = nullptr, size_t size = 0);
-
-  uint8_t tx_header_[TX_BUFFER_SIZE] = {
-      'I',                    // 0: Header
-      'M',                    // 1: Header
-      'P',                    // 2: Header
-      'R',                    // 3: Header
-      'O',                    // 4: Header
-      'V',                    // 5: Header
-      IMPROV_SERIAL_VERSION,  // 6: Version
-      0,                      // 7: ImprovSerialType
-      0,                      // 8: Length
-      0,                      // 9...X: Data (here, one byte reserved for state/error)
-      0,                      // X + 10: Checksum
-      '\n',
-  };
+  void write_data_(std::vector<uint8_t> &data);
 
 #ifdef USE_ESP32
   uart_port_t uart_num_;

esphome/components/libretiny/gpio.py

@@ -199,9 +199,6 @@ async def component_pin_to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     num = config[CONF_NUMBER]
     cg.add(var.set_pin(num))
-    # Only set if true to avoid bloating setup() function
-    # (inverted bit in pin_flags_ bitfield is zero-initialized to false)
-    if config[CONF_INVERTED]:
-        cg.add(var.set_inverted(True))
+    cg.add(var.set_inverted(config[CONF_INVERTED]))
     cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
     return var

esphome/components/libretiny/gpio_arduino.h

@@ -27,8 +27,8 @@ class ArduinoInternalGPIOPin : public InternalGPIOPin {
   void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;
 
   uint8_t pin_;
-  bool inverted_{};
-  gpio::Flags flags_{};
+  bool inverted_;
+  gpio::Flags flags_;
 };
 
 }  // namespace libretiny

esphome/components/light/addressable_light_effect.h

@@ -30,7 +30,7 @@ inline static uint8_t half_sin8(uint8_t v) { return sin16_c(uint16_t(v) * 128u)
 
 class AddressableLightEffect : public LightEffect {
  public:
-  explicit AddressableLightEffect(const char *name) : LightEffect(name) {}
+  explicit AddressableLightEffect(const std::string &name) : LightEffect(name) {}
   void start_internal() override {
     this->get_addressable_()->set_effect_active(true);
     this->get_addressable_()->clear_effect_data();
@@ -57,7 +57,8 @@ class AddressableLightEffect : public LightEffect {
 
 class AddressableLambdaLightEffect : public AddressableLightEffect {
  public:
-  AddressableLambdaLightEffect(const char *name, std::function<void(AddressableLight &, Color, bool initial_run)> f,
+  AddressableLambdaLightEffect(const std::string &name,
+                               std::function<void(AddressableLight &, Color, bool initial_run)> f,
                                uint32_t update_interval)
       : AddressableLightEffect(name), f_(std::move(f)), update_interval_(update_interval) {}
   void start() override { this->initial_run_ = true; }
@@ -80,7 +81,7 @@ class AddressableLambdaLightEffect : public AddressableLightEffect {
 
 class AddressableRainbowLightEffect : public AddressableLightEffect {
  public:
-  explicit AddressableRainbowLightEffect(const char *name) : AddressableLightEffect(name) {}
+  explicit AddressableRainbowLightEffect(const std::string &name) : AddressableLightEffect(name) {}
   void apply(AddressableLight &it, const Color &current_color) override {
     ESPHSVColor hsv;
     hsv.value = 255;
@@ -111,7 +112,7 @@ struct AddressableColorWipeEffectColor {
 
 class AddressableColorWipeEffect : public AddressableLightEffect {
  public:
-  explicit AddressableColorWipeEffect(const char *name) : AddressableLightEffect(name) {}
+  explicit AddressableColorWipeEffect(const std::string &name) : AddressableLightEffect(name) {}
   void set_colors(const std::initializer_list<AddressableColorWipeEffectColor> &colors) { this->colors_ = colors; }
   void set_add_led_interval(uint32_t add_led_interval) { this->add_led_interval_ = add_led_interval; }
   void set_reverse(bool reverse) { this->reverse_ = reverse; }
@@ -164,7 +165,7 @@ class AddressableColorWipeEffect : public AddressableLightEffect {
 
 class AddressableScanEffect : public AddressableLightEffect {
  public:
-  explicit AddressableScanEffect(const char *name) : AddressableLightEffect(name) {}
+  explicit AddressableScanEffect(const std::string &name) : AddressableLightEffect(name) {}
   void set_move_interval(uint32_t move_interval) { this->move_interval_ = move_interval; }
   void set_scan_width(uint32_t scan_width) { this->scan_width_ = scan_width; }
   void apply(AddressableLight &it, const Color &current_color) override {
@@ -201,7 +202,7 @@ class AddressableScanEffect : public AddressableLightEffect {
 
 class AddressableTwinkleEffect : public AddressableLightEffect {
  public:
-  explicit AddressableTwinkleEffect(const char *name) : AddressableLightEffect(name) {}
+  explicit AddressableTwinkleEffect(const std::string &name) : AddressableLightEffect(name) {}
   void apply(AddressableLight &addressable, const Color &current_color) override {
     const uint32_t now = millis();
     uint8_t pos_add = 0;
@@ -243,7 +244,7 @@ class AddressableTwinkleEffect : public AddressableLightEffect {
 
 class AddressableRandomTwinkleEffect : public AddressableLightEffect {
  public:
-  explicit AddressableRandomTwinkleEffect(const char *name) : AddressableLightEffect(name) {}
+  explicit AddressableRandomTwinkleEffect(const std::string &name) : AddressableLightEffect(name) {}
   void apply(AddressableLight &it, const Color &current_color) override {
     const uint32_t now = millis();
     uint8_t pos_add = 0;
@@ -292,7 +293,7 @@ class AddressableRandomTwinkleEffect : public AddressableLightEffect {
 
 class AddressableFireworksEffect : public AddressableLightEffect {
  public:
-  explicit AddressableFireworksEffect(const char *name) : AddressableLightEffect(name) {}
+  explicit AddressableFireworksEffect(const std::string &name) : AddressableLightEffect(name) {}
   void start() override {
     auto &it = *this->get_addressable_();
     it.all() = Color::BLACK;
@@ -341,7 +342,7 @@ class AddressableFireworksEffect : public AddressableLightEffect {
 
 class AddressableFlickerEffect : public AddressableLightEffect {
  public:
-  explicit AddressableFlickerEffect(const char *name) : AddressableLightEffect(name) {}
+  explicit AddressableFlickerEffect(const std::string &name) : AddressableLightEffect(name) {}
   void apply(AddressableLight &it, const Color &current_color) override {
     const uint32_t now = millis();
     const uint8_t intensity = this->intensity_;

esphome/components/light/base_light_effects.h

@@ -17,7 +17,7 @@ inline static float random_cubic_float() {
 /// Pulse effect.
 class PulseLightEffect : public LightEffect {
  public:
-  explicit PulseLightEffect(const char *name) : LightEffect(name) {}
+  explicit PulseLightEffect(const std::string &name) : LightEffect(name) {}
 
   void apply() override {
     const uint32_t now = millis();
@@ -60,7 +60,7 @@ class PulseLightEffect : public LightEffect {
 /// Random effect. Sets random colors every 10 seconds and slowly transitions between them.
 class RandomLightEffect : public LightEffect {
  public:
-  explicit RandomLightEffect(const char *name) : LightEffect(name) {}
+  explicit RandomLightEffect(const std::string &name) : LightEffect(name) {}
 
   void apply() override {
     const uint32_t now = millis();
@@ -112,7 +112,7 @@ class RandomLightEffect : public LightEffect {
 
 class LambdaLightEffect : public LightEffect {
  public:
-  LambdaLightEffect(const char *name, std::function<void(bool initial_run)> f, uint32_t update_interval)
+  LambdaLightEffect(const std::string &name, std::function<void(bool initial_run)> f, uint32_t update_interval)
       : LightEffect(name), f_(std::move(f)), update_interval_(update_interval) {}
 
   void start() override { this->initial_run_ = true; }
@@ -138,7 +138,7 @@ class LambdaLightEffect : public LightEffect {
 
 class AutomationLightEffect : public LightEffect {
  public:
-  AutomationLightEffect(const char *name) : LightEffect(name) {}
+  AutomationLightEffect(const std::string &name) : LightEffect(name) {}
   void stop() override { this->trig_->stop_action(); }
   void apply() override {
     if (!this->trig_->is_action_running()) {
@@ -163,7 +163,7 @@ struct StrobeLightEffectColor {
 
 class StrobeLightEffect : public LightEffect {
  public:
-  explicit StrobeLightEffect(const char *name) : LightEffect(name) {}
+  explicit StrobeLightEffect(const std::string &name) : LightEffect(name) {}
   void apply() override {
     const uint32_t now = millis();
     if (now - this->last_switch_ < this->colors_[this->at_color_].duration)
@@ -198,7 +198,7 @@ class StrobeLightEffect : public LightEffect {
 
 class FlickerLightEffect : public LightEffect {
  public:
-  explicit FlickerLightEffect(const char *name) : LightEffect(name) {}
+  explicit FlickerLightEffect(const std::string &name) : LightEffect(name) {}
 
   void apply() override {
     LightColorValues remote = this->state_->remote_values;

esphome/components/light/color_mode.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <cstdint>
-#include "esphome/core/finite_set_mask.h"
 
 namespace esphome {
 namespace light {
@@ -108,9 +107,13 @@ constexpr ColorModeHelper operator|(ColorModeHelper lhs, ColorMode rhs) {
 // Type alias for raw color mode bitmask values
 using color_mode_bitmask_t = uint16_t;
 
-// Lookup table for ColorMode bit mapping
-// This array defines the canonical order of color modes (bit 0-9)
-constexpr ColorMode COLOR_MODE_LOOKUP[] = {
+// Constants for ColorMode count and bit range
+static constexpr int COLOR_MODE_COUNT = 10;                             // UNKNOWN through RGB_COLD_WARM_WHITE
+static constexpr int MAX_BIT_INDEX = sizeof(color_mode_bitmask_t) * 8;  // Number of bits in bitmask type
+
+// Compile-time array of all ColorMode values in declaration order
+// Bit positions (0-9) map directly to enum declaration order
+static constexpr ColorMode COLOR_MODES[COLOR_MODE_COUNT] = {
     ColorMode::UNKNOWN,                // bit 0
     ColorMode::ON_OFF,                 // bit 1
     ColorMode::BRIGHTNESS,             // bit 2
@@ -123,42 +126,33 @@ constexpr ColorMode COLOR_MODE_LOOKUP[] = {
     ColorMode::RGB_COLD_WARM_WHITE,    // bit 9
 };
 
-/// Bit mapping policy for ColorMode
-/// Uses lookup table for non-contiguous enum values
-struct ColorModeBitPolicy {
-  using mask_t = uint16_t;  // 10 bits requires uint16_t
-  static constexpr int MAX_BITS = sizeof(COLOR_MODE_LOOKUP) / sizeof(COLOR_MODE_LOOKUP[0]);
-
-  static constexpr unsigned to_bit(ColorMode mode) {
-    // Linear search through lookup table
-    // Compiler optimizes this to efficient code since array is constexpr
-    for (int i = 0; i < MAX_BITS; ++i) {
-      if (COLOR_MODE_LOOKUP[i] == mode)
-        return i;
-    }
-    return 0;
+/// Map ColorMode enum values to bit positions (0-9)
+/// Bit positions follow the enum declaration order
+static constexpr int mode_to_bit(ColorMode mode) {
+  // Linear search through COLOR_MODES array
+  // Compiler optimizes this to efficient code since array is constexpr
+  for (int i = 0; i < COLOR_MODE_COUNT; ++i) {
+    if (COLOR_MODES[i] == mode)
+      return i;
   }
+  return 0;
+}
 
-  static constexpr ColorMode from_bit(unsigned bit) {
-    return (bit < MAX_BITS) ? COLOR_MODE_LOOKUP[bit] : ColorMode::UNKNOWN;
-  }
-};
-
-// Type alias for ColorMode bitmask using policy-based design
-using ColorModeMask = FiniteSetMask<ColorMode, ColorModeBitPolicy>;
-
-// Number of ColorCapability enum values
-constexpr int COLOR_CAPABILITY_COUNT = 6;
+/// Map bit positions (0-9) to ColorMode enum values
+/// Bit positions follow the enum declaration order
+static constexpr ColorMode bit_to_mode(int bit) {
+  // Direct lookup in COLOR_MODES array
+  return (bit >= 0 && bit < COLOR_MODE_COUNT) ? COLOR_MODES[bit] : ColorMode::UNKNOWN;
+}
 
 /// Helper to compute capability bitmask at compile time
-constexpr uint16_t compute_capability_bitmask(ColorCapability capability) {
-  uint16_t mask = 0;
+static constexpr color_mode_bitmask_t compute_capability_bitmask(ColorCapability capability) {
+  color_mode_bitmask_t mask = 0;
   uint8_t cap_bit = static_cast<uint8_t>(capability);
 
   // Check each ColorMode to see if it has this capability
-  constexpr int color_mode_count = sizeof(COLOR_MODE_LOOKUP) / sizeof(COLOR_MODE_LOOKUP[0]);
-  for (int bit = 0; bit < color_mode_count; ++bit) {
-    uint8_t mode_val = static_cast<uint8_t>(COLOR_MODE_LOOKUP[bit]);
+  for (int bit = 0; bit < COLOR_MODE_COUNT; ++bit) {
+    uint8_t mode_val = static_cast<uint8_t>(bit_to_mode(bit));
     if ((mode_val & cap_bit) != 0) {
       mask |= (1 << bit);
     }
@@ -166,9 +160,12 @@ constexpr uint16_t compute_capability_bitmask(ColorCapability capability) {
   return mask;
 }
 
+// Number of ColorCapability enum values
+static constexpr int COLOR_CAPABILITY_COUNT = 6;
+
 /// Compile-time lookup table mapping ColorCapability to bitmask
 /// This array is computed at compile time using constexpr
-constexpr uint16_t CAPABILITY_BITMASKS[] = {
+static constexpr color_mode_bitmask_t CAPABILITY_BITMASKS[] = {
     compute_capability_bitmask(ColorCapability::ON_OFF),             // 1 << 0
     compute_capability_bitmask(ColorCapability::BRIGHTNESS),         // 1 << 1
     compute_capability_bitmask(ColorCapability::WHITE),              // 1 << 2
@@ -177,38 +174,130 @@ constexpr uint16_t CAPABILITY_BITMASKS[] = {
     compute_capability_bitmask(ColorCapability::RGB),                // 1 << 5
 };
 
-/**
- * @brief Helper function to convert a power-of-2 ColorCapability value to an array index for CAPABILITY_BITMASKS
- * lookup.
- *
- * This function maps ColorCapability values (1, 2, 4, 8, 16, 32) to array indices (0, 1, 2, 3, 4, 5).
- * Used to index into the CAPABILITY_BITMASKS lookup table.
- *
- * @param capability A ColorCapability enum value (must be a power of 2).
- * @return The corresponding array index (0-based).
- */
-inline int capability_to_index(ColorCapability capability) {
-  uint8_t cap_val = static_cast<uint8_t>(capability);
-#if defined(__GNUC__) || defined(__clang__)
-  // Use compiler intrinsic for efficient bit position lookup (O(1) vs O(log n))
-  return __builtin_ctz(cap_val);
-#else
-  // Fallback for compilers without __builtin_ctz
-  int index = 0;
-  while (cap_val > 1) {
-    cap_val >>= 1;
-    ++index;
-  }
-  return index;
-#endif
-}
+/// Bitmask for storing a set of ColorMode values efficiently.
+/// Replaces std::set<ColorMode> to eliminate red-black tree overhead (~586 bytes).
+class ColorModeMask {
+ public:
+  constexpr ColorModeMask() = default;
 
-/// Check if any mode in the bitmask has a specific capability
-/// Used for checking if a light supports a capability (e.g., BRIGHTNESS, RGB)
-inline bool has_capability(const ColorModeMask &mask, ColorCapability capability) {
-  // Lookup the pre-computed bitmask for this capability and check intersection with our mask
-  return (mask.get_mask() & CAPABILITY_BITMASKS[capability_to_index(capability)]) != 0;
-}
+  /// Support initializer list syntax: {ColorMode::RGB, ColorMode::WHITE}
+  constexpr ColorModeMask(std::initializer_list<ColorMode> modes) {
+    for (auto mode : modes) {
+      this->add(mode);
+    }
+  }
+
+  constexpr void add(ColorMode mode) { this->mask_ |= (1 << mode_to_bit(mode)); }
+
+  /// Add multiple modes at once using initializer list
+  constexpr void add(std::initializer_list<ColorMode> modes) {
+    for (auto mode : modes) {
+      this->add(mode);
+    }
+  }
+
+  constexpr bool contains(ColorMode mode) const { return (this->mask_ & (1 << mode_to_bit(mode))) != 0; }
+
+  constexpr size_t size() const {
+    // Count set bits using Brian Kernighan's algorithm
+    // More efficient for sparse bitmasks (typical case: 2-4 modes out of 10)
+    uint16_t n = this->mask_;
+    size_t count = 0;
+    while (n) {
+      n &= n - 1;  // Clear the least significant set bit
+      count++;
+    }
+    return count;
+  }
+
+  constexpr bool empty() const { return this->mask_ == 0; }
+
+  /// Iterator support for API encoding
+  class Iterator {
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = ColorMode;
+    using difference_type = std::ptrdiff_t;
+    using pointer = const ColorMode *;
+    using reference = ColorMode;
+
+    constexpr Iterator(color_mode_bitmask_t mask, int bit) : mask_(mask), bit_(bit) { advance_to_next_set_bit_(); }
+
+    constexpr ColorMode operator*() const { return bit_to_mode(bit_); }
+
+    constexpr Iterator &operator++() {
+      ++bit_;
+      advance_to_next_set_bit_();
+      return *this;
+    }
+
+    constexpr bool operator==(const Iterator &other) const { return bit_ == other.bit_; }
+
+    constexpr bool operator!=(const Iterator &other) const { return !(*this == other); }
+
+   private:
+    constexpr void advance_to_next_set_bit_() { bit_ = ColorModeMask::find_next_set_bit(mask_, bit_); }
+
+    color_mode_bitmask_t mask_;
+    int bit_;
+  };
+
+  constexpr Iterator begin() const { return Iterator(mask_, 0); }
+  constexpr Iterator end() const { return Iterator(mask_, MAX_BIT_INDEX); }
+
+  /// Get the raw bitmask value for API encoding
+  constexpr color_mode_bitmask_t get_mask() const { return this->mask_; }
+
+  /// Find the next set bit in a bitmask starting from a given position
+  /// Returns the bit position, or MAX_BIT_INDEX if no more bits are set
+  static constexpr int find_next_set_bit(color_mode_bitmask_t mask, int start_bit) {
+    int bit = start_bit;
+    while (bit < MAX_BIT_INDEX && !(mask & (1 << bit))) {
+      ++bit;
+    }
+    return bit;
+  }
+
+  /// Find the first set bit in a bitmask and return the corresponding ColorMode
+  /// Used for optimizing compute_color_mode_() intersection logic
+  static constexpr ColorMode first_mode_from_mask(color_mode_bitmask_t mask) {
+    return bit_to_mode(find_next_set_bit(mask, 0));
+  }
+
+  /// Check if a ColorMode is present in a raw bitmask value
+  /// Useful for checking intersection results without creating a temporary ColorModeMask
+  static constexpr bool mask_contains(color_mode_bitmask_t mask, ColorMode mode) {
+    return (mask & (1 << mode_to_bit(mode))) != 0;
+  }
+
+  /// Check if any mode in the bitmask has a specific capability
+  /// Used for checking if a light supports a capability (e.g., BRIGHTNESS, RGB)
+  bool has_capability(ColorCapability capability) const {
+    // Lookup the pre-computed bitmask for this capability and check intersection with our mask
+    // ColorCapability values: 1, 2, 4, 8, 16, 32 -> array indices: 0, 1, 2, 3, 4, 5
+    // We need to convert the power-of-2 value to an index
+    uint8_t cap_val = static_cast<uint8_t>(capability);
+#if defined(__GNUC__) || defined(__clang__)
+    // Use compiler intrinsic for efficient bit position lookup (O(1) vs O(log n))
+    int index = __builtin_ctz(cap_val);
+#else
+    // Fallback for compilers without __builtin_ctz
+    int index = 0;
+    while (cap_val > 1) {
+      cap_val >>= 1;
+      ++index;
+    }
+#endif
+    return (this->mask_ & CAPABILITY_BITMASKS[index]) != 0;
+  }
+
+ private:
+  // Using uint16_t instead of uint32_t for more efficient iteration (fewer bits to scan).
+  // Currently only 10 ColorMode values exist, so 16 bits is sufficient.
+  // Can be changed to uint32_t if more than 16 color modes are needed in the future.
+  // Note: Due to struct padding, uint16_t and uint32_t result in same LightTraits size (12 bytes).
+  color_mode_bitmask_t mask_{0};
+};
 
 }  // namespace light
 }  // namespace esphome

esphome/components/light/light_call.cpp

@@ -156,7 +156,7 @@ void LightCall::perform() {
     if (this->effect_ == 0u) {
       effect_s = "None";
     } else {
-      effect_s = this->parent_->effects_[this->effect_ - 1]->get_name();
+      effect_s = this->parent_->effects_[this->effect_ - 1]->get_name().c_str();
     }
 
     if (publish) {
@@ -437,7 +437,7 @@ ColorMode LightCall::compute_color_mode_() {
 
   // Use the preferred suitable mode.
   if (intersection != 0) {
-    ColorMode mode = ColorModeMask::first_value_from_mask(intersection);
+    ColorMode mode = ColorModeMask::first_mode_from_mask(intersection);
     ESP_LOGI(TAG, "'%s': color mode not specified; using %s", this->parent_->get_name().c_str(),
              LOG_STR_ARG(color_mode_to_human(mode)));
     return mode;
@@ -511,7 +511,7 @@ LightCall &LightCall::set_effect(const std::string &effect) {
   for (uint32_t i = 0; i < this->parent_->effects_.size(); i++) {
     LightEffect *e = this->parent_->effects_[i];
 
-    if (strcasecmp(effect.c_str(), e->get_name()) == 0) {
+    if (strcasecmp(effect.c_str(), e->get_name().c_str()) == 0) {
       this->set_effect(i + 1);
       found = true;
       break;

esphome/components/light/light_effect.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <utility>
+
 #include "esphome/core/component.h"
 
 namespace esphome {
@@ -9,7 +11,7 @@ class LightState;
 
 class LightEffect {
  public:
-  explicit LightEffect(const char *name) : name_(name) {}
+  explicit LightEffect(std::string name) : name_(std::move(name)) {}
 
   /// Initialize this LightEffect. Will be called once after creation.
   virtual void start() {}
@@ -22,11 +24,7 @@ class LightEffect {
   /// Apply this effect. Use the provided state for starting transitions, ...
   virtual void apply() = 0;
 
-  /**
-   * Returns the name of this effect.
-   * The returned pointer is valid for the lifetime of the program and must not be freed.
-   */
-  const char *get_name() const { return this->name_; }
+  const std::string &get_name() { return this->name_; }
 
   /// Internal method called by the LightState when this light effect is registered in it.
   virtual void init() {}
@@ -49,7 +47,7 @@ class LightEffect {
 
  protected:
   LightState *state_{nullptr};
-  const char *name_;
+  std::string name_;
 
   /// Internal method to find this effect's index in the parent light's effect list.
   uint32_t get_index_in_parent_() const;

esphome/components/light/light_state.cpp

@@ -178,9 +178,12 @@ void LightState::set_restore_mode(LightRestoreMode restore_mode) { this->restore
 void LightState::set_initial_state(const LightStateRTCState &initial_state) { this->initial_state_ = initial_state; }
 bool LightState::supports_effects() { return !this->effects_.empty(); }
 const FixedVector<LightEffect *> &LightState::get_effects() const { return this->effects_; }
-void LightState::add_effects(const std::initializer_list<LightEffect *> &effects) {
+void LightState::add_effects(const std::vector<LightEffect *> &effects) {
   // Called once from Python codegen during setup with all effects from YAML config
-  this->effects_ = effects;
+  this->effects_.init(effects.size());
+  for (auto *effect : effects) {
+    this->effects_.push_back(effect);
+  }
 }
 
 void LightState::current_values_as_binary(bool *binary) { this->current_values.as_binary(binary); }

esphome/components/light/light_state.h

@@ -163,7 +163,7 @@ class LightState : public EntityBase, public Component {
   const FixedVector<LightEffect *> &get_effects() const;
 
   /// Add effects for this light state.
-  void add_effects(const std::initializer_list<LightEffect *> &effects);
+  void add_effects(const std::vector<LightEffect *> &effects);
 
   /// Get the total number of effects available for this light.
   size_t get_effect_count() const { return this->effects_.size(); }
@@ -177,7 +177,7 @@ class LightState : public EntityBase, public Component {
       return 0;
     }
     for (size_t i = 0; i < this->effects_.size(); i++) {
-      if (strcasecmp(effect_name.c_str(), this->effects_[i]->get_name()) == 0) {
+      if (strcasecmp(effect_name.c_str(), this->effects_[i]->get_name().c_str()) == 0) {
         return i + 1;  // Effects are 1-indexed in active_effect_index_
       }
     }

esphome/components/light/light_traits.h

@@ -26,9 +26,9 @@ class LightTraits {
     this->supported_color_modes_ = ColorModeMask(modes);
   }
 
-  bool supports_color_mode(ColorMode color_mode) const { return this->supported_color_modes_.count(color_mode) > 0; }
+  bool supports_color_mode(ColorMode color_mode) const { return this->supported_color_modes_.contains(color_mode); }
   bool supports_color_capability(ColorCapability color_capability) const {
-    return has_capability(this->supported_color_modes_, color_capability);
+    return this->supported_color_modes_.has_capability(color_capability);
   }
 
   float get_min_mireds() const { return this->min_mireds_; }

esphome/components/logger/__init__.py

@@ -1,7 +1,7 @@
 import re
 
 from esphome import automation
-from esphome.automation import LambdaAction, StatelessLambdaAction
+from esphome.automation import LambdaAction
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_sdkconfig_option, get_esp32_variant
 from esphome.components.esp32.const import (
@@ -430,9 +430,7 @@ async def logger_log_action_to_code(config, action_id, template_arg, args):
     text = str(cg.statement(esp_log(config[CONF_TAG], config[CONF_FORMAT], *args_)))
 
     lambda_ = await cg.process_lambda(Lambda(text), args, return_type=cg.void)
-    return automation.new_lambda_pvariable(
-        action_id, lambda_, StatelessLambdaAction, template_arg
-    )
+    return cg.new_Pvariable(action_id, template_arg, lambda_)
 
 
 @automation.register_action(
@@ -457,9 +455,7 @@ async def logger_set_level_to_code(config, action_id, template_arg, args):
         text = str(cg.statement(logger.set_log_level(level)))
 
     lambda_ = await cg.process_lambda(Lambda(text), args, return_type=cg.void)
-    return automation.new_lambda_pvariable(
-        action_id, lambda_, StatelessLambdaAction, template_arg
-    )
+    return cg.new_Pvariable(action_id, template_arg, lambda_)
 
 
 FILTER_SOURCE_FILES = filter_source_files_from_platform(

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/util.cpp

@@ -99,11 +99,7 @@ const std::string &get_use_address() {
   return wifi::global_wifi_component->get_use_address();
 #endif
 
-#ifdef USE_OPENTHREAD
-  return openthread::global_openthread_component->get_use_address();
-#endif
-
-#if !defined(USE_ETHERNET) && !defined(USE_MODEM) && !defined(USE_WIFI) && !defined(USE_OPENTHREAD)
+#if !defined(USE_ETHERNET) && !defined(USE_MODEM) && !defined(USE_WIFI)
   // Fallback when no network component is defined (e.g., host platform)
   static const std::string empty;
   return empty;

esphome/components/nrf52/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import logging
 from pathlib import Path
 
@@ -278,19 +277,3 @@ def upload_program(config: ConfigType, args, host: str) -> bool:
         raise EsphomeError(f"Upload failed with result: {result}")
 
     return handled
-
-
-def show_logs(config: ConfigType, args, devices: list[str]) -> bool:
-    address = devices[0]
-    from .ble_logger import is_mac_address, logger_connect, logger_scan
-
-    if devices[0] == "BLE":
-        ble_device = asyncio.run(logger_scan(CORE.config["esphome"]["name"]))
-        if ble_device:
-            address = ble_device.address
-        else:
-            return True
-    if is_mac_address(address):
-        asyncio.run(logger_connect(address))
-        return True
-    return False

esphome/components/nrf52/ble_logger.py

@@ -1,60 +0,0 @@
-import asyncio
-import logging
-import re
-from typing import Final
-
-from bleak import BleakClient, BleakScanner, BLEDevice
-from bleak.exc import (
-    BleakCharacteristicNotFoundError,
-    BleakDBusError,
-    BleakDeviceNotFoundError,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-
-NUS_SERVICE_UUID = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
-NUS_TX_CHAR_UUID = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
-
-MAC_ADDRESS_PATTERN: Final = re.compile(
-    r"([0-9A-F]{2}[:]){5}[0-9A-F]{2}$", flags=re.IGNORECASE
-)
-
-
-def is_mac_address(value: str) -> bool:
-    return MAC_ADDRESS_PATTERN.match(value)
-
-
-async def logger_scan(name: str) -> BLEDevice | None:
-    _LOGGER.info("Scanning bluetooth for %s...", name)
-    device = await BleakScanner.find_device_by_name(name)
-    if not device:
-        _LOGGER.error("%s Bluetooth LE device was not found!", name)
-    return device
-
-
-async def logger_connect(host: str) -> int | None:
-    disconnected_event = asyncio.Event()
-
-    def handle_disconnect(client):
-        disconnected_event.set()
-
-    def handle_rx(_, data: bytearray):
-        print(data.decode("utf-8"), end="")
-
-    _LOGGER.info("Connecting %s...", host)
-    try:
-        async with BleakClient(host, disconnected_callback=handle_disconnect) as client:
-            _LOGGER.info("Connected %s...", host)
-            try:
-                await client.start_notify(NUS_TX_CHAR_UUID, handle_rx)
-            except BleakDBusError as e:
-                _LOGGER.error("Bluetooth LE logger: %s", e)
-                disconnected_event.set()
-            await disconnected_event.wait()
-    except BleakDeviceNotFoundError:
-        _LOGGER.error("Device %s not found", host)
-        return 1
-    except BleakCharacteristicNotFoundError:
-        _LOGGER.error("Device %s has no NUS characteristic", host)
-        return 1

esphome/components/nrf52/gpio.py

@@ -74,9 +74,6 @@ async def nrf52_pin_to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     num = config[CONF_NUMBER]
     cg.add(var.set_pin(num))
-    # Only set if true to avoid bloating setup() function
-    # (inverted bit in pin_flags_ bitfield is zero-initialized to false)
-    if config[CONF_INVERTED]:
-        cg.add(var.set_inverted(True))
+    cg.add(var.set_inverted(config[CONF_INVERTED]))
     cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
     return var

esphome/components/number/__init__.py

@@ -252,10 +252,7 @@ async def setup_number_core_(
     cg.add(var.traits.set_max_value(max_value))
     cg.add(var.traits.set_step(step))
 
-    # Only set if non-default to avoid bloating setup() function
-    # (mode_ is initialized to NUMBER_MODE_AUTO in the header)
-    if config[CONF_MODE] != NumberMode.NUMBER_MODE_AUTO:
-        cg.add(var.traits.set_mode(config[CONF_MODE]))
+    cg.add(var.traits.set_mode(config[CONF_MODE]))
 
     for conf in config.get(CONF_ON_VALUE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)

esphome/components/openthread/__init__.py

@@ -8,10 +8,8 @@ from esphome.components.esp32 import (
 )
 from esphome.components.mdns import MDNSComponent, enable_mdns_storage
 import esphome.config_validation as cv
-from esphome.const import CONF_CHANNEL, CONF_ENABLE_IPV6, CONF_ID, CONF_USE_ADDRESS
-from esphome.core import CORE
+from esphome.const import CONF_CHANNEL, CONF_ENABLE_IPV6, CONF_ID
 import esphome.final_validate as fv
-from esphome.types import ConfigType
 
 from .const import (
     CONF_DEVICE_TYPE,
@@ -110,12 +108,6 @@ _CONNECTION_SCHEMA = cv.Schema(
 )
 
 
-def _validate(config: ConfigType) -> ConfigType:
-    if CONF_USE_ADDRESS not in config:
-        config[CONF_USE_ADDRESS] = f"{CORE.name}.local"
-    return config
-
-
 def _require_vfs_select(config):
     """Register VFS select requirement during config validation."""
     # OpenThread uses esp_vfs_eventfd which requires VFS select support
@@ -134,13 +126,11 @@ CONFIG_SCHEMA = cv.All(
             ),
             cv.Optional(CONF_FORCE_DATASET): cv.boolean,
             cv.Optional(CONF_TLV): cv.string_strict,
-            cv.Optional(CONF_USE_ADDRESS): cv.string_strict,
         }
     ).extend(_CONNECTION_SCHEMA),
     cv.has_exactly_one_key(CONF_NETWORK_KEY, CONF_TLV),
     cv.only_with_esp_idf,
     only_on_variant(supported=[VARIANT_ESP32C6, VARIANT_ESP32H2]),
-    _validate,
     _require_vfs_select,
 )
 
@@ -165,7 +155,6 @@ async def to_code(config):
     enable_mdns_storage()
 
     ot = cg.new_Pvariable(config[CONF_ID])
-    cg.add(ot.set_use_address(config[CONF_USE_ADDRESS]))
     await cg.register_component(ot, config)
 
     srp = cg.new_Pvariable(config[CONF_SRP_ID])

esphome/components/openthread/openthread.cpp

@@ -252,12 +252,6 @@ void OpenThreadComponent::on_factory_reset(std::function<void()> callback) {
   ESP_LOGD(TAG, "Waiting on Confirmation Removal SRP Host and Services");
 }
 
-// set_use_address() is guaranteed to be called during component setup by Python code generation,
-// so use_address_ will always be valid when get_use_address() is called - no fallback needed.
-const std::string &OpenThreadComponent::get_use_address() const { return this->use_address_; }
-
-void OpenThreadComponent::set_use_address(const std::string &use_address) { this->use_address_ = use_address; }
-
 }  // namespace openthread
 }  // namespace esphome
 

esphome/components/openthread/openthread.h

@@ -33,15 +33,11 @@ class OpenThreadComponent : public Component {
   void on_factory_reset(std::function<void()> callback);
   void defer_factory_reset_external_callback();
 
-  const std::string &get_use_address() const;
-  void set_use_address(const std::string &use_address);
-
  protected:
   std::optional<otIp6Address> get_omr_address_(InstanceLock &lock);
   bool teardown_started_{false};
   bool teardown_complete_{false};
   std::function<void()> factory_reset_external_callback_;
-  std::string use_address_;
 };
 
 extern OpenThreadComponent *global_openthread_component;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/pipsolar/pipsolar.cpp

@@ -38,6 +38,7 @@ void Pipsolar::loop() {
   }
   if (this->state_ == STATE_COMMAND_COMPLETE) {
     if (this->check_incoming_length_(4)) {
+      ESP_LOGD(TAG, "response length for command OK");
       if (this->check_incoming_crc_()) {
         // crc ok
         if (this->read_buffer_[1] == 'A' && this->read_buffer_[2] == 'C' && this->read_buffer_[3] == 'K') {
@@ -48,15 +49,15 @@ void Pipsolar::loop() {
         this->command_queue_[this->command_queue_position_] = std::string("");
         this->command_queue_position_ = (command_queue_position_ + 1) % COMMAND_QUEUE_LENGTH;
         this->state_ = STATE_IDLE;
+
       } else {
         // crc failed
-        // no log message necessary, check_incoming_crc_() logs
         this->command_queue_[this->command_queue_position_] = std::string("");
         this->command_queue_position_ = (command_queue_position_ + 1) % COMMAND_QUEUE_LENGTH;
         this->state_ = STATE_IDLE;
       }
     } else {
-      ESP_LOGD(TAG, "command %s response length not OK: with length %zu",
+      ESP_LOGD(TAG, "response length for command %s not OK: with length %zu",
                this->command_queue_[this->command_queue_position_].c_str(), this->read_pos_);
       this->command_queue_[this->command_queue_position_] = std::string("");
       this->command_queue_position_ = (command_queue_position_ + 1) % COMMAND_QUEUE_LENGTH;
@@ -65,10 +66,46 @@ void Pipsolar::loop() {
   }
 
   if (this->state_ == STATE_POLL_CHECKED) {
-    ESP_LOGD(TAG, "poll %s decode", this->enabled_polling_commands_[this->last_polling_command_].command);
-    this->handle_poll_response_(this->enabled_polling_commands_[this->last_polling_command_].identifier,
-                                (const char *) this->read_buffer_);
-    this->state_ = STATE_IDLE;
+    switch (this->enabled_polling_commands_[this->last_polling_command_].identifier) {
+      case POLLING_QPIRI:
+        ESP_LOGD(TAG, "Decode QPIRI");
+        handle_qpiri_((const char *) this->read_buffer_);
+        this->state_ = STATE_IDLE;
+        break;
+      case POLLING_QPIGS:
+        ESP_LOGD(TAG, "Decode QPIGS");
+        handle_qpigs_((const char *) this->read_buffer_);
+        this->state_ = STATE_IDLE;
+        break;
+      case POLLING_QMOD:
+        ESP_LOGD(TAG, "Decode QMOD");
+        handle_qmod_((const char *) this->read_buffer_);
+        this->state_ = STATE_IDLE;
+        break;
+      case POLLING_QFLAG:
+        ESP_LOGD(TAG, "Decode QFLAG");
+        handle_qflag_((const char *) this->read_buffer_);
+        this->state_ = STATE_IDLE;
+        break;
+      case POLLING_QPIWS:
+        ESP_LOGD(TAG, "Decode QPIWS");
+        handle_qpiws_((const char *) this->read_buffer_);
+        this->state_ = STATE_IDLE;
+        break;
+      case POLLING_QT:
+        ESP_LOGD(TAG, "Decode QT");
+        handle_qt_((const char *) this->read_buffer_);
+        this->state_ = STATE_IDLE;
+        break;
+      case POLLING_QMN:
+        ESP_LOGD(TAG, "Decode QMN");
+        handle_qmn_((const char *) this->read_buffer_);
+        this->state_ = STATE_IDLE;
+        break;
+      default:
+        this->state_ = STATE_IDLE;
+        break;
+    }
     return;
   }
 
@@ -76,8 +113,6 @@ void Pipsolar::loop() {
     if (this->check_incoming_crc_()) {
       if (this->read_buffer_[0] == '(' && this->read_buffer_[1] == 'N' && this->read_buffer_[2] == 'A' &&
           this->read_buffer_[3] == 'K') {
-        ESP_LOGD(TAG, "poll %s NACK", this->enabled_polling_commands_[this->last_polling_command_].command);
-        this->handle_poll_error_(this->enabled_polling_commands_[this->last_polling_command_].identifier);
         this->state_ = STATE_IDLE;
         return;
       }
@@ -86,9 +121,6 @@ void Pipsolar::loop() {
       this->state_ = STATE_POLL_CHECKED;
       return;
     } else {
-      // crc failed
-      // no log message necessary, check_incoming_crc_() logs
-      this->handle_poll_error_(this->enabled_polling_commands_[this->last_polling_command_].identifier);
       this->state_ = STATE_IDLE;
     }
   }
@@ -126,19 +158,21 @@ void Pipsolar::loop() {
       // command timeout
       const char *command = this->command_queue_[this->command_queue_position_].c_str();
       this->command_start_millis_ = millis();
-      ESP_LOGD(TAG, "command %s timeout", command);
+      ESP_LOGD(TAG, "timeout command from queue: %s", command);
       this->command_queue_[this->command_queue_position_] = std::string("");
       this->command_queue_position_ = (command_queue_position_ + 1) % COMMAND_QUEUE_LENGTH;
       this->state_ = STATE_IDLE;
       return;
+    } else {
     }
   }
   if (this->state_ == STATE_POLL) {
     if (millis() - this->command_start_millis_ > esphome::pipsolar::Pipsolar::COMMAND_TIMEOUT) {
       // command timeout
-      ESP_LOGD(TAG, "poll %s timeout", this->enabled_polling_commands_[this->last_polling_command_].command);
-      this->handle_poll_error_(this->enabled_polling_commands_[this->last_polling_command_].identifier);
+      ESP_LOGD(TAG, "timeout command to poll: %s",
+               this->enabled_polling_commands_[this->last_polling_command_].command);
       this->state_ = STATE_IDLE;
+    } else {
     }
   }
 }
@@ -153,6 +187,7 @@ uint8_t Pipsolar::check_incoming_length_(uint8_t length) {
 uint8_t Pipsolar::check_incoming_crc_() {
   uint16_t crc16;
   crc16 = this->pipsolar_crc_(read_buffer_, read_pos_ - 3);
+  ESP_LOGD(TAG, "checking crc on incoming message");
   if (((uint8_t) ((crc16) >> 8)) == read_buffer_[read_pos_ - 3] &&
       ((uint8_t) ((crc16) &0xff)) == read_buffer_[read_pos_ - 2]) {
     ESP_LOGD(TAG, "CRC OK");
@@ -218,7 +253,7 @@ bool Pipsolar::send_next_poll_() {
     this->write(((uint8_t) ((crc16) &0xff)));  // lowbyte
     // end Byte
     this->write(0x0D);
-    ESP_LOGD(TAG, "Sending polling command: %s with length %d",
+    ESP_LOGD(TAG, "Sending polling command : %s with length %d",
              this->enabled_polling_commands_[this->last_polling_command_].command,
              this->enabled_polling_commands_[this->last_polling_command_].length);
     return true;
@@ -239,38 +274,6 @@ void Pipsolar::queue_command(const std::string &command) {
   ESP_LOGD(TAG, "Command queue full dropping command: %s", command.c_str());
 }
 
-void Pipsolar::handle_poll_response_(ENUMPollingCommand polling_command, const char *message) {
-  switch (polling_command) {
-    case POLLING_QPIRI:
-      handle_qpiri_(message);
-      break;
-    case POLLING_QPIGS:
-      handle_qpigs_(message);
-      break;
-    case POLLING_QMOD:
-      handle_qmod_(message);
-      break;
-    case POLLING_QFLAG:
-      handle_qflag_(message);
-      break;
-    case POLLING_QPIWS:
-      handle_qpiws_(message);
-      break;
-    case POLLING_QT:
-      handle_qt_(message);
-      break;
-    case POLLING_QMN:
-      handle_qmn_(message);
-      break;
-    default:
-      break;
-  }
-}
-void Pipsolar::handle_poll_error_(ENUMPollingCommand polling_command) {
-  // handlers are designed in a way that an empty message sets all sensors to unknown
-  this->handle_poll_response_(polling_command, "");
-}
-
 void Pipsolar::handle_qpiri_(const char *message) {
   if (this->last_qpiri_) {
     this->last_qpiri_->publish_state(message);

esphome/components/pipsolar/pipsolar.h

@@ -204,9 +204,6 @@ class Pipsolar : public uart::UARTDevice, public PollingComponent {
   bool send_next_command_();
   bool send_next_poll_();
 
-  void handle_poll_response_(ENUMPollingCommand polling_command, const char *message);
-  void handle_poll_error_(ENUMPollingCommand polling_command);
-  // these handlers are designed in a way that an empty message sets all sensors to unknown
   void handle_qpiri_(const char *message);
   void handle_qpigs_(const char *message);
   void handle_qmod_(const char *message);

esphome/components/pipsolar/sensor/__init__.py

@@ -4,18 +4,11 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_BATTERY_VOLTAGE,
     CONF_BUS_VOLTAGE,
-    DEVICE_CLASS_APPARENT_POWER,
-    DEVICE_CLASS_BATTERY,
     DEVICE_CLASS_CURRENT,
-    DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_TEMPERATURE,
     DEVICE_CLASS_VOLTAGE,
-    ICON_BATTERY,
     ICON_CURRENT_AC,
-    ICON_FLASH,
-    ICON_GAUGE,
-    STATE_CLASS_MEASUREMENT,
     UNIT_AMPERE,
     UNIT_CELSIUS,
     UNIT_HERTZ,
@@ -29,10 +22,6 @@ from .. import CONF_PIPSOLAR_ID, PIPSOLAR_COMPONENT_SCHEMA
 
 DEPENDENCIES = ["uart"]
 
-ICON_SOLAR_POWER = "mdi:solar-power"
-ICON_SOLAR_PANEL = "mdi:solar-panel"
-ICON_CURRENT_DC = "mdi:current-dc"
-
 # QPIRI sensors
 CONF_GRID_RATING_VOLTAGE = "grid_rating_voltage"
 CONF_GRID_RATING_CURRENT = "grid_rating_current"
@@ -86,19 +75,16 @@ TYPES = {
         unit_of_measurement=UNIT_VOLT,
         accuracy_decimals=1,
         device_class=DEVICE_CLASS_VOLTAGE,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_GRID_RATING_CURRENT: sensor.sensor_schema(
         unit_of_measurement=UNIT_AMPERE,
         accuracy_decimals=1,
         device_class=DEVICE_CLASS_CURRENT,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_AC_OUTPUT_RATING_VOLTAGE: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT,
         accuracy_decimals=1,
         device_class=DEVICE_CLASS_VOLTAGE,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_AC_OUTPUT_RATING_FREQUENCY: sensor.sensor_schema(
         unit_of_measurement=UNIT_HERTZ,
@@ -112,12 +98,11 @@ TYPES = {
     ),
     CONF_AC_OUTPUT_RATING_APPARENT_POWER: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT_AMPS,
-        accuracy_decimals=0,
-        device_class=DEVICE_CLASS_APPARENT_POWER,
+        accuracy_decimals=1,
     ),
     CONF_AC_OUTPUT_RATING_ACTIVE_POWER: sensor.sensor_schema(
         unit_of_measurement=UNIT_WATT,
-        accuracy_decimals=0,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_POWER,
     ),
     CONF_BATTERY_RATING_VOLTAGE: sensor.sensor_schema(
@@ -146,151 +131,124 @@ TYPES = {
         device_class=DEVICE_CLASS_VOLTAGE,
     ),
     CONF_BATTERY_TYPE: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_CURRENT_MAX_AC_CHARGING_CURRENT: sensor.sensor_schema(
         unit_of_measurement=UNIT_AMPERE,
-        accuracy_decimals=0,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_CURRENT,
     ),
     CONF_CURRENT_MAX_CHARGING_CURRENT: sensor.sensor_schema(
         unit_of_measurement=UNIT_AMPERE,
-        accuracy_decimals=0,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_CURRENT,
     ),
     CONF_INPUT_VOLTAGE_RANGE: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_OUTPUT_SOURCE_PRIORITY: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_CHARGER_SOURCE_PRIORITY: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_PARALLEL_MAX_NUM: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_MACHINE_TYPE: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_TOPOLOGY: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_OUTPUT_MODE: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_BATTERY_REDISCHARGE_VOLTAGE: sensor.sensor_schema(
         accuracy_decimals=1,
     ),
     CONF_PV_OK_CONDITION_FOR_PARALLEL: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_PV_POWER_BALANCE: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_GRID_VOLTAGE: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT,
         accuracy_decimals=1,
         device_class=DEVICE_CLASS_VOLTAGE,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_GRID_FREQUENCY: sensor.sensor_schema(
         unit_of_measurement=UNIT_HERTZ,
         icon=ICON_CURRENT_AC,
         accuracy_decimals=1,
-        device_class=DEVICE_CLASS_FREQUENCY,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_AC_OUTPUT_VOLTAGE: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT,
         accuracy_decimals=1,
         device_class=DEVICE_CLASS_VOLTAGE,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_AC_OUTPUT_FREQUENCY: sensor.sensor_schema(
         unit_of_measurement=UNIT_HERTZ,
         icon=ICON_CURRENT_AC,
         accuracy_decimals=1,
-        device_class=DEVICE_CLASS_FREQUENCY,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_AC_OUTPUT_APPARENT_POWER: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT_AMPS,
-        accuracy_decimals=0,
-        device_class=DEVICE_CLASS_APPARENT_POWER,
-        state_class=STATE_CLASS_MEASUREMENT,
+        accuracy_decimals=1,
     ),
     CONF_AC_OUTPUT_ACTIVE_POWER: sensor.sensor_schema(
         unit_of_measurement=UNIT_WATT,
-        accuracy_decimals=0,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_POWER,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_OUTPUT_LOAD_PERCENT: sensor.sensor_schema(
         unit_of_measurement=UNIT_PERCENT,
-        icon=ICON_GAUGE,
-        accuracy_decimals=0,
-        state_class=STATE_CLASS_MEASUREMENT,
+        accuracy_decimals=1,
     ),
     CONF_BUS_VOLTAGE: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT,
-        icon=ICON_FLASH,
-        accuracy_decimals=0,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_VOLTAGE,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_BATTERY_VOLTAGE: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT,
-        icon=ICON_BATTERY,
-        accuracy_decimals=2,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_VOLTAGE,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_BATTERY_CHARGING_CURRENT: sensor.sensor_schema(
         unit_of_measurement=UNIT_AMPERE,
-        icon=ICON_CURRENT_DC,
-        accuracy_decimals=0,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_CURRENT,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_BATTERY_CAPACITY_PERCENT: sensor.sensor_schema(
         unit_of_measurement=UNIT_PERCENT,
-        accuracy_decimals=0,
-        device_class=DEVICE_CLASS_BATTERY,
-        state_class=STATE_CLASS_MEASUREMENT,
+        accuracy_decimals=1,
     ),
     CONF_INVERTER_HEAT_SINK_TEMPERATURE: sensor.sensor_schema(
         unit_of_measurement=UNIT_CELSIUS,
-        accuracy_decimals=0,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_TEMPERATURE,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_PV_INPUT_CURRENT_FOR_BATTERY: sensor.sensor_schema(
         unit_of_measurement=UNIT_AMPERE,
-        icon=ICON_SOLAR_PANEL,
         accuracy_decimals=1,
         device_class=DEVICE_CLASS_CURRENT,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_PV_INPUT_VOLTAGE: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT,
-        icon=ICON_SOLAR_PANEL,
         accuracy_decimals=1,
         device_class=DEVICE_CLASS_VOLTAGE,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_BATTERY_VOLTAGE_SCC: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT,
-        accuracy_decimals=2,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_VOLTAGE,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_BATTERY_DISCHARGE_CURRENT: sensor.sensor_schema(
         unit_of_measurement=UNIT_AMPERE,
-        icon=ICON_CURRENT_DC,
-        accuracy_decimals=0,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_CURRENT,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
     CONF_BATTERY_VOLTAGE_OFFSET_FOR_FANS_ON: sensor.sensor_schema(
         unit_of_measurement=UNIT_VOLT,
@@ -298,14 +256,12 @@ TYPES = {
         device_class=DEVICE_CLASS_VOLTAGE,
     ),
     CONF_EEPROM_VERSION: sensor.sensor_schema(
-        accuracy_decimals=0,
+        accuracy_decimals=1,
     ),
     CONF_PV_CHARGING_POWER: sensor.sensor_schema(
         unit_of_measurement=UNIT_WATT,
-        icon=ICON_SOLAR_POWER,
-        accuracy_decimals=0,
+        accuracy_decimals=1,
         device_class=DEVICE_CLASS_POWER,
-        state_class=STATE_CLASS_MEASUREMENT,
     ),
 }
 

esphome/components/remote_transmitter/remote_transmitter.h

@@ -12,25 +12,6 @@
 namespace esphome {
 namespace remote_transmitter {
 
-#ifdef USE_ESP32
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
-// IDF version 5.5.1 and above is required because of a bug in
-// the RMT encoder: https://github.com/espressif/esp-idf/issues/17244
-typedef union {  // NOLINT(modernize-use-using)
-  struct {
-    uint16_t duration : 15;
-    uint16_t level : 1;
-  };
-  uint16_t val;
-} rmt_symbol_half_t;
-
-struct RemoteTransmitterComponentStore {
-  uint32_t times{0};
-  uint32_t index{0};
-};
-#endif
-#endif
-
 class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
                                    public Component
 #ifdef USE_ESP32
@@ -75,14 +56,9 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 #ifdef USE_ESP32
   void configure_rmt_();
 
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
-  RemoteTransmitterComponentStore store_{};
-  std::vector<rmt_symbol_half_t> rmt_temp_;
-#else
-  std::vector<rmt_symbol_word_t> rmt_temp_;
-#endif
   uint32_t current_carrier_frequency_{38000};
   bool initialized_{false};
+  std::vector<rmt_symbol_word_t> rmt_temp_;
   bool with_dma_{false};
   bool eot_level_{false};
   rmt_channel_handle_t channel_{NULL};

esphome/components/remote_transmitter/remote_transmitter_esp32.cpp

@@ -10,46 +10,6 @@ namespace remote_transmitter {
 
 static const char *const TAG = "remote_transmitter";
 
-// Maximum RMT symbol duration (15-bit field)
-static constexpr uint32_t RMT_SYMBOL_DURATION_MAX = 0x7FFF;
-
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
-static size_t IRAM_ATTR HOT encoder_callback(const void *data, size_t size, size_t written, size_t free,
-                                             rmt_symbol_word_t *symbols, bool *done, void *arg) {
-  auto *store = static_cast<RemoteTransmitterComponentStore *>(arg);
-  const auto *encoded = static_cast<const rmt_symbol_half_t *>(data);
-  size_t length = size / sizeof(rmt_symbol_half_t);
-  size_t count = 0;
-
-  // copy symbols
-  for (size_t i = 0; i < free; i++) {
-    uint16_t sym_0 = encoded[store->index++].val;
-    if (store->index >= length) {
-      store->index = 0;
-      store->times--;
-      if (store->times == 0) {
-        *done = true;
-        symbols[count++].val = sym_0;
-        return count;
-      }
-    }
-    uint16_t sym_1 = encoded[store->index++].val;
-    if (store->index >= length) {
-      store->index = 0;
-      store->times--;
-      if (store->times == 0) {
-        *done = true;
-        symbols[count++].val = sym_0 | (sym_1 << 16);
-        return count;
-      }
-    }
-    symbols[count++].val = sym_0 | (sym_1 << 16);
-  }
-  *done = false;
-  return count;
-}
-#endif
-
 void RemoteTransmitterComponent::setup() {
   this->inverted_ = this->pin_->is_inverted();
   this->configure_rmt_();
@@ -74,17 +34,6 @@ void RemoteTransmitterComponent::dump_config() {
 }
 
 void RemoteTransmitterComponent::digital_write(bool value) {
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
-  rmt_symbol_half_t symbol = {
-      .duration = 1,
-      .level = value,
-  };
-  rmt_transmit_config_t config;
-  memset(&config, 0, sizeof(config));
-  config.flags.eot_level = value;
-  this->store_.times = 1;
-  this->store_.index = 0;
-#else
   rmt_symbol_word_t symbol = {
       .duration0 = 1,
       .level0 = value,
@@ -93,8 +42,8 @@ void RemoteTransmitterComponent::digital_write(bool value) {
   };
   rmt_transmit_config_t config;
   memset(&config, 0, sizeof(config));
+  config.loop_count = 0;
   config.flags.eot_level = value;
-#endif
   esp_err_t error = rmt_transmit(this->channel_, this->encoder_, &symbol, sizeof(symbol), &config);
   if (error != ESP_OK) {
     ESP_LOGW(TAG, "rmt_transmit failed: %s", esp_err_to_name(error));
@@ -141,20 +90,6 @@ void RemoteTransmitterComponent::configure_rmt_() {
       gpio_pullup_dis(gpio_num_t(this->pin_->get_pin()));
     }
 
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
-    rmt_simple_encoder_config_t encoder;
-    memset(&encoder, 0, sizeof(encoder));
-    encoder.callback = encoder_callback;
-    encoder.arg = &this->store_;
-    encoder.min_chunk_size = 1;
-    error = rmt_new_simple_encoder(&encoder, &this->encoder_);
-    if (error != ESP_OK) {
-      this->error_code_ = error;
-      this->error_string_ = "in rmt_new_simple_encoder";
-      this->mark_failed();
-      return;
-    }
-#else
     rmt_copy_encoder_config_t encoder;
     memset(&encoder, 0, sizeof(encoder));
     error = rmt_new_copy_encoder(&encoder, &this->encoder_);
@@ -164,7 +99,6 @@ void RemoteTransmitterComponent::configure_rmt_() {
       this->mark_failed();
       return;
     }
-#endif
 
     error = rmt_enable(this->channel_);
     if (error != ESP_OK) {
@@ -196,79 +130,6 @@ void RemoteTransmitterComponent::configure_rmt_() {
   }
 }
 
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
-void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {
-  if (this->is_failed()) {
-    return;
-  }
-
-  if (this->current_carrier_frequency_ != this->temp_.get_carrier_frequency()) {
-    this->current_carrier_frequency_ = this->temp_.get_carrier_frequency();
-    this->configure_rmt_();
-  }
-
-  this->rmt_temp_.clear();
-  this->rmt_temp_.reserve(this->temp_.get_data().size() + 1);
-
-  // encode any delay at the start of the buffer to simplify the encoder callback
-  // this will be skipped the first time around
-  send_wait = this->from_microseconds_(static_cast<uint32_t>(send_wait));
-  while (send_wait > 0) {
-    int32_t duration = std::min(send_wait, uint32_t(RMT_SYMBOL_DURATION_MAX));
-    this->rmt_temp_.push_back({
-        .duration = static_cast<uint16_t>(duration),
-        .level = static_cast<uint16_t>(this->eot_level_),
-    });
-    send_wait -= duration;
-  }
-
-  // encode data
-  size_t offset = this->rmt_temp_.size();
-  for (int32_t value : this->temp_.get_data()) {
-    bool level = value >= 0;
-    if (!level) {
-      value = -value;
-    }
-    value = this->from_microseconds_(static_cast<uint32_t>(value));
-    while (value > 0) {
-      int32_t duration = std::min(value, int32_t(RMT_SYMBOL_DURATION_MAX));
-      this->rmt_temp_.push_back({
-          .duration = static_cast<uint16_t>(duration),
-          .level = static_cast<uint16_t>(level ^ this->inverted_),
-      });
-      value -= duration;
-    }
-  }
-
-  if ((this->rmt_temp_.data() == nullptr) || this->rmt_temp_.size() <= offset) {
-    ESP_LOGE(TAG, "Empty data");
-    return;
-  }
-
-  this->transmit_trigger_->trigger();
-
-  rmt_transmit_config_t config;
-  memset(&config, 0, sizeof(config));
-  config.flags.eot_level = this->eot_level_;
-  this->store_.times = send_times;
-  this->store_.index = offset;
-  esp_err_t error = rmt_transmit(this->channel_, this->encoder_, this->rmt_temp_.data(),
-                                 this->rmt_temp_.size() * sizeof(rmt_symbol_half_t), &config);
-  if (error != ESP_OK) {
-    ESP_LOGW(TAG, "rmt_transmit failed: %s", esp_err_to_name(error));
-    this->status_set_warning();
-  } else {
-    this->status_clear_warning();
-  }
-  error = rmt_tx_wait_all_done(this->channel_, -1);
-  if (error != ESP_OK) {
-    ESP_LOGW(TAG, "rmt_tx_wait_all_done failed: %s", esp_err_to_name(error));
-    this->status_set_warning();
-  }
-
-  this->complete_trigger_->trigger();
-}
-#else
 void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {
   if (this->is_failed())
     return;
@@ -290,7 +151,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     val = this->from_microseconds_(static_cast<uint32_t>(val));
 
     do {
-      int32_t item = std::min(val, int32_t(RMT_SYMBOL_DURATION_MAX));
+      int32_t item = std::min(val, int32_t(32767));
       val -= item;
 
       if (rmt_i % 2 == 0) {
@@ -319,6 +180,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
   for (uint32_t i = 0; i < send_times; i++) {
     rmt_transmit_config_t config;
     memset(&config, 0, sizeof(config));
+    config.loop_count = 0;
     config.flags.eot_level = this->eot_level_;
     esp_err_t error = rmt_transmit(this->channel_, this->encoder_, this->rmt_temp_.data(),
                                    this->rmt_temp_.size() * sizeof(rmt_symbol_word_t), &config);
@@ -338,7 +200,6 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
   }
   this->complete_trigger_->trigger();
 }
-#endif
 
 }  // namespace remote_transmitter
 }  // namespace esphome

esphome/components/rp2040/gpio.h

@@ -29,8 +29,8 @@ class RP2040GPIOPin : public InternalGPIOPin {
   void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;
 
   uint8_t pin_;
-  bool inverted_{};
-  gpio::Flags flags_{};
+  bool inverted_;
+  gpio::Flags flags_;
 };
 
 }  // namespace rp2040

esphome/components/rp2040/gpio.py

@@ -94,9 +94,6 @@ async def rp2040_pin_to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     num = config[CONF_NUMBER]
     cg.add(var.set_pin(num))
-    # Only set if true to avoid bloating setup() function
-    # (inverted bit in pin_flags_ bitfield is zero-initialized to false)
-    if config[CONF_INVERTED]:
-        cg.add(var.set_inverted(True))
+    cg.add(var.set_inverted(config[CONF_INVERTED]))
     cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
     return var

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

@@ -261,7 +261,6 @@ ExponentialMovingAverageFilter = sensor_ns.class_(
 )
 ThrottleAverageFilter = sensor_ns.class_("ThrottleAverageFilter", Filter, cg.Component)
 LambdaFilter = sensor_ns.class_("LambdaFilter", Filter)
-StatelessLambdaFilter = sensor_ns.class_("StatelessLambdaFilter", Filter)
 OffsetFilter = sensor_ns.class_("OffsetFilter", Filter)
 MultiplyFilter = sensor_ns.class_("MultiplyFilter", Filter)
 ValueListFilter = sensor_ns.class_("ValueListFilter", Filter)
@@ -574,7 +573,7 @@ async def lambda_filter_to_code(config, filter_id):
     lambda_ = await cg.process_lambda(
         config, [(float, "x")], return_type=cg.optional.template(float)
     )
-    return automation.new_lambda_pvariable(filter_id, lambda_, StatelessLambdaFilter)
+    return cg.new_Pvariable(filter_id, lambda_)
 
 
 DELTA_SCHEMA = cv.Schema(
@@ -879,9 +878,7 @@ async def setup_sensor_core_(var, config):
         cg.add(var.set_unit_of_measurement(unit_of_measurement))
     if (accuracy_decimals := config.get(CONF_ACCURACY_DECIMALS)) is not None:
         cg.add(var.set_accuracy_decimals(accuracy_decimals))
-    # Only set force_update if True (default is False)
-    if config[CONF_FORCE_UPDATE]:
-        cg.add(var.set_force_update(True))
+    cg.add(var.set_force_update(config[CONF_FORCE_UPDATE]))
     if config.get(CONF_FILTERS):  # must exist and not be empty
         filters = await build_filters(config[CONF_FILTERS])
         cg.add(var.set_filters(filters))

esphome/components/sensor/filter.h

@@ -296,21 +296,6 @@ class LambdaFilter : public Filter {
   lambda_filter_t lambda_filter_;
 };
 
-/** Optimized lambda filter 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 StatelessLambdaFilter : public Filter {
- public:
-  explicit StatelessLambdaFilter(optional<float> (*lambda_filter)(float)) : lambda_filter_(lambda_filter) {}
-
-  optional<float> new_value(float value) override { return this->lambda_filter_(value); }
-
- protected:
-  optional<float> (*lambda_filter_)(float);
-};
-
 /// A simple filter that adds `offset` to each value it receives.
 class OffsetFilter : public Filter {
  public:

esphome/components/sntp/sntp_component.cpp

@@ -27,7 +27,7 @@ void SNTPComponent::setup() {
   esp_sntp_setoperatingmode(ESP_SNTP_OPMODE_POLL);
   size_t i = 0;
   for (auto &server : this->servers_) {
-    esp_sntp_setservername(i++, server);
+    esp_sntp_setservername(i++, server.c_str());
   }
   esp_sntp_set_sync_interval(this->get_update_interval());
   esp_sntp_set_time_sync_notification_cb([](struct timeval *tv) {
@@ -42,7 +42,7 @@ void SNTPComponent::setup() {
 
   size_t i = 0;
   for (auto &server : this->servers_) {
-    sntp_setservername(i++, server);
+    sntp_setservername(i++, server.c_str());
   }
 
 #if defined(USE_ESP8266)
@@ -59,7 +59,7 @@ void SNTPComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "SNTP Time:");
   size_t i = 0;
   for (auto &server : this->servers_) {
-    ESP_LOGCONFIG(TAG, "  Server %zu: '%s'", i++, server);
+    ESP_LOGCONFIG(TAG, "  Server %zu: '%s'", i++, server.c_str());
   }
 }
 void SNTPComponent::update() {