pipsolar_teleinfo

esphome/__main__.py

@@ -1,6 +1,5 @@
 # PYTHON_ARGCOMPLETE_OK
 import argparse
-from collections.abc import Callable
 from datetime import datetime
 import functools
 import getpass
@@ -944,21 +943,11 @@ def command_dashboard(args: ArgsProtocol) -> int | None:
     return dashboard.start_dashboard(args)
 
 
-def run_multiple_configs(
-    files: list, command_builder: Callable[[str], list[str]]
-) -> int:
-    """Run a command for each configuration file in a subprocess.
-
-    Args:
-        files: List of configuration files to process.
-        command_builder: Callable that takes a file path and returns a command list.
-
-    Returns:
-        Number of failed files.
-    """
+def command_update_all(args: ArgsProtocol) -> int | None:
     import click
 
     success = {}
+    files = list_yaml_files(args.configuration)
     twidth = 60
 
     def print_bar(middle_text):
@@ -968,19 +957,17 @@ def run_multiple_configs(
         safe_print(f"{half_line}{middle_text}{half_line}")
 
     for f in files:
-        f_path = Path(f) if not isinstance(f, Path) else f
-
-        if any(f_path.name == x for x in SECRETS_FILES):
-            _LOGGER.warning("Skipping secrets file %s", f_path)
-            continue
-
-        safe_print(f"Processing {color(AnsiFore.CYAN, str(f))}")
+        safe_print(f"Updating {color(AnsiFore.CYAN, str(f))}")
         safe_print("-" * twidth)
         safe_print()
-
-        cmd = command_builder(f)
-        rc = run_external_process(*cmd)
-
+        if CORE.dashboard:
+            rc = run_external_process(
+                "esphome", "--dashboard", "run", f, "--no-logs", "--device", "OTA"
+            )
+        else:
+            rc = run_external_process(
+                "esphome", "run", f, "--no-logs", "--device", "OTA"
+            )
         if rc == 0:
             print_bar(f"[{color(AnsiFore.BOLD_GREEN, 'SUCCESS')}] {str(f)}")
             success[f] = True
@@ -995,8 +982,6 @@ def run_multiple_configs(
     print_bar(f"[{color(AnsiFore.BOLD_WHITE, 'SUMMARY')}]")
     failed = 0
     for f in files:
-        if f not in success:
-            continue  # Skipped file
         if success[f]:
             safe_print(f"  - {str(f)}: {color(AnsiFore.GREEN, 'SUCCESS')}")
         else:
@@ -1005,17 +990,6 @@ def run_multiple_configs(
     return failed
 
 
-def command_update_all(args: ArgsProtocol) -> int | None:
-    files = list_yaml_files(args.configuration)
-
-    def build_command(f):
-        if CORE.dashboard:
-            return ["esphome", "--dashboard", "run", f, "--no-logs", "--device", "OTA"]
-        return ["esphome", "run", f, "--no-logs", "--device", "OTA"]
-
-    return run_multiple_configs(files, build_command)
-
-
 def command_idedata(args: ArgsProtocol, config: ConfigType) -> int:
     import json
 
@@ -1577,48 +1551,38 @@ def run_esphome(argv):
 
     _LOGGER.info("ESPHome %s", const.__version__)
 
-    # Multiple configurations: use subprocesses to avoid state leakage
-    # between compilations (e.g., LVGL touchscreen state in module globals)
-    if len(args.configuration) > 1:
-        # Build command by reusing argv, replacing all configs with single file
-        # argv[0] is the program path, skip it since we prefix with "esphome"
-        def build_command(f):
-            return (
-                ["esphome"]
-                + [arg for arg in argv[1:] if arg not in args.configuration]
-                + [str(f)]
-            )
+    for conf_path in args.configuration:
+        conf_path = Path(conf_path)
+        if any(conf_path.name == x for x in SECRETS_FILES):
+            _LOGGER.warning("Skipping secrets file %s", conf_path)
+            continue
 
-        return run_multiple_configs(args.configuration, build_command)
+        CORE.config_path = conf_path
+        CORE.dashboard = args.dashboard
 
-    # Single configuration
-    conf_path = Path(args.configuration[0])
-    if any(conf_path.name == x for x in SECRETS_FILES):
-        _LOGGER.warning("Skipping secrets file %s", conf_path)
-        return 0
+        # For logs command, skip updating external components
+        skip_external = args.command == "logs"
+        config = read_config(
+            dict(args.substitution) if args.substitution else {},
+            skip_external_update=skip_external,
+        )
+        if config is None:
+            return 2
+        CORE.config = config
 
-    CORE.config_path = conf_path
-    CORE.dashboard = args.dashboard
+        if args.command not in POST_CONFIG_ACTIONS:
+            safe_print(f"Unknown command {args.command}")
 
-    # For logs command, skip updating external components
-    skip_external = args.command == "logs"
-    config = read_config(
-        dict(args.substitution) if args.substitution else {},
-        skip_external_update=skip_external,
-    )
-    if config is None:
-        return 2
-    CORE.config = config
+        try:
+            rc = POST_CONFIG_ACTIONS[args.command](args, config)
+        except EsphomeError as e:
+            _LOGGER.error(e, exc_info=args.verbose)
+            return 1
+        if rc != 0:
+            return rc
 
-    if args.command not in POST_CONFIG_ACTIONS:
-        safe_print(f"Unknown command {args.command}")
-        return 1
-
-    try:
-        return POST_CONFIG_ACTIONS[args.command](args, config)
-    except EsphomeError as e:
-        _LOGGER.error(e, exc_info=args.verbose)
-        return 1
+        CORE.reset()
+    return 0
 
 
 def main():

esphome/components/alarm_control_panel/alarm_control_panel.cpp

@@ -67,29 +67,52 @@ void AlarmControlPanel::add_on_ready_callback(std::function<void()> &&callback)
   this->ready_callback_.add(std::move(callback));
 }
 
-void AlarmControlPanel::arm_with_code_(AlarmControlPanelCall &(AlarmControlPanelCall::*arm_method)(),
-                                       const char *code) {
+void AlarmControlPanel::arm_away(optional<std::string> code) {
   auto call = this->make_call();
-  (call.*arm_method)();
-  if (code != nullptr)
-    call.set_code(code);
+  call.arm_away();
+  if (code.has_value())
+    call.set_code(code.value());
   call.perform();
 }
 
-void AlarmControlPanel::arm_away(const char *code) { this->arm_with_code_(&AlarmControlPanelCall::arm_away, code); }
-
-void AlarmControlPanel::arm_home(const char *code) { this->arm_with_code_(&AlarmControlPanelCall::arm_home, code); }
-
-void AlarmControlPanel::arm_night(const char *code) { this->arm_with_code_(&AlarmControlPanelCall::arm_night, code); }
-
-void AlarmControlPanel::arm_vacation(const char *code) {
-  this->arm_with_code_(&AlarmControlPanelCall::arm_vacation, code);
+void AlarmControlPanel::arm_home(optional<std::string> code) {
+  auto call = this->make_call();
+  call.arm_home();
+  if (code.has_value())
+    call.set_code(code.value());
+  call.perform();
 }
 
-void AlarmControlPanel::arm_custom_bypass(const char *code) {
-  this->arm_with_code_(&AlarmControlPanelCall::arm_custom_bypass, code);
+void AlarmControlPanel::arm_night(optional<std::string> code) {
+  auto call = this->make_call();
+  call.arm_night();
+  if (code.has_value())
+    call.set_code(code.value());
+  call.perform();
 }
 
-void AlarmControlPanel::disarm(const char *code) { this->arm_with_code_(&AlarmControlPanelCall::disarm, code); }
+void AlarmControlPanel::arm_vacation(optional<std::string> code) {
+  auto call = this->make_call();
+  call.arm_vacation();
+  if (code.has_value())
+    call.set_code(code.value());
+  call.perform();
+}
+
+void AlarmControlPanel::arm_custom_bypass(optional<std::string> code) {
+  auto call = this->make_call();
+  call.arm_custom_bypass();
+  if (code.has_value())
+    call.set_code(code.value());
+  call.perform();
+}
+
+void AlarmControlPanel::disarm(optional<std::string> code) {
+  auto call = this->make_call();
+  call.disarm();
+  if (code.has_value())
+    call.set_code(code.value());
+  call.perform();
+}
 
 }  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel.h

@@ -76,53 +76,37 @@ class AlarmControlPanel : public EntityBase {
    *
    * @param code The code
    */
-  void arm_away(const char *code = nullptr);
-  void arm_away(const optional<std::string> &code) {
-    this->arm_away(code.has_value() ? code.value().c_str() : nullptr);
-  }
+  void arm_away(optional<std::string> code = nullopt);
 
   /** arm the alarm in home mode
    *
    * @param code The code
    */
-  void arm_home(const char *code = nullptr);
-  void arm_home(const optional<std::string> &code) {
-    this->arm_home(code.has_value() ? code.value().c_str() : nullptr);
-  }
+  void arm_home(optional<std::string> code = nullopt);
 
   /** arm the alarm in night mode
    *
    * @param code The code
    */
-  void arm_night(const char *code = nullptr);
-  void arm_night(const optional<std::string> &code) {
-    this->arm_night(code.has_value() ? code.value().c_str() : nullptr);
-  }
+  void arm_night(optional<std::string> code = nullopt);
 
   /** arm the alarm in vacation mode
    *
    * @param code The code
    */
-  void arm_vacation(const char *code = nullptr);
-  void arm_vacation(const optional<std::string> &code) {
-    this->arm_vacation(code.has_value() ? code.value().c_str() : nullptr);
-  }
+  void arm_vacation(optional<std::string> code = nullopt);
 
   /** arm the alarm in custom bypass mode
    *
    * @param code The code
    */
-  void arm_custom_bypass(const char *code = nullptr);
-  void arm_custom_bypass(const optional<std::string> &code) {
-    this->arm_custom_bypass(code.has_value() ? code.value().c_str() : nullptr);
-  }
+  void arm_custom_bypass(optional<std::string> code = nullopt);
 
   /** disarm the alarm
    *
    * @param code The code
    */
-  void disarm(const char *code = nullptr);
-  void disarm(const optional<std::string> &code) { this->disarm(code.has_value() ? code.value().c_str() : nullptr); }
+  void disarm(optional<std::string> code = nullopt);
 
   /** Get the state
    *
@@ -134,8 +118,6 @@ class AlarmControlPanel : public EntityBase {
 
  protected:
   friend AlarmControlPanelCall;
-  // Helper to reduce code duplication for arm/disarm methods
-  void arm_with_code_(AlarmControlPanelCall &(AlarmControlPanelCall::*arm_method)(), const char *code);
   // in order to store last panel state in flash
   ESPPreferenceObject pref_;
   // current state

esphome/components/alarm_control_panel/alarm_control_panel_call.cpp

@@ -10,10 +10,8 @@ static const char *const TAG = "alarm_control_panel";
 
 AlarmControlPanelCall::AlarmControlPanelCall(AlarmControlPanel *parent) : parent_(parent) {}
 
-AlarmControlPanelCall &AlarmControlPanelCall::set_code(const char *code) {
-  if (code != nullptr) {
-    this->code_ = std::string(code);
-  }
+AlarmControlPanelCall &AlarmControlPanelCall::set_code(const std::string &code) {
+  this->code_ = code;
   return *this;
 }
 

esphome/components/alarm_control_panel/alarm_control_panel_call.h

@@ -14,8 +14,7 @@ class AlarmControlPanelCall {
  public:
   AlarmControlPanelCall(AlarmControlPanel *parent);
 
-  AlarmControlPanelCall &set_code(const char *code);
-  AlarmControlPanelCall &set_code(const std::string &code) { return this->set_code(code.c_str()); }
+  AlarmControlPanelCall &set_code(const std::string &code);
   AlarmControlPanelCall &arm_away();
   AlarmControlPanelCall &arm_home();
   AlarmControlPanelCall &arm_night();

esphome/components/alarm_control_panel/automation.h

@@ -66,7 +66,15 @@ template<typename... Ts> class ArmAwayAction : public Action<Ts...> {
 
   TEMPLATABLE_VALUE(std::string, code)
 
-  void play(const Ts &...x) override { this->alarm_control_panel_->arm_away(this->code_.optional_value(x...)); }
+  void play(const Ts &...x) override {
+    auto call = this->alarm_control_panel_->make_call();
+    auto code = this->code_.optional_value(x...);
+    if (code.has_value()) {
+      call.set_code(code.value());
+    }
+    call.arm_away();
+    call.perform();
+  }
 
  protected:
   AlarmControlPanel *alarm_control_panel_;
@@ -78,7 +86,15 @@ template<typename... Ts> class ArmHomeAction : public Action<Ts...> {
 
   TEMPLATABLE_VALUE(std::string, code)
 
-  void play(const Ts &...x) override { this->alarm_control_panel_->arm_home(this->code_.optional_value(x...)); }
+  void play(const Ts &...x) override {
+    auto call = this->alarm_control_panel_->make_call();
+    auto code = this->code_.optional_value(x...);
+    if (code.has_value()) {
+      call.set_code(code.value());
+    }
+    call.arm_home();
+    call.perform();
+  }
 
  protected:
   AlarmControlPanel *alarm_control_panel_;
@@ -90,7 +106,15 @@ template<typename... Ts> class ArmNightAction : public Action<Ts...> {
 
   TEMPLATABLE_VALUE(std::string, code)
 
-  void play(const Ts &...x) override { this->alarm_control_panel_->arm_night(this->code_.optional_value(x...)); }
+  void play(const Ts &...x) override {
+    auto call = this->alarm_control_panel_->make_call();
+    auto code = this->code_.optional_value(x...);
+    if (code.has_value()) {
+      call.set_code(code.value());
+    }
+    call.arm_night();
+    call.perform();
+  }
 
  protected:
   AlarmControlPanel *alarm_control_panel_;

esphome/components/anova/anova_base.cpp

@@ -18,31 +18,31 @@ AnovaPacket *AnovaCodec::clean_packet_() {
 
 AnovaPacket *AnovaCodec::get_read_device_status_request() {
   this->current_query_ = READ_DEVICE_STATUS;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_DEVICE_STATUS);
+  strncpy((char *) this->packet_.data, CMD_READ_DEVICE_STATUS, sizeof(this->packet_.data));
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_read_target_temp_request() {
   this->current_query_ = READ_TARGET_TEMPERATURE;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_TARGET_TEMP);
+  strncpy((char *) this->packet_.data, CMD_READ_TARGET_TEMP, sizeof(this->packet_.data));
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_read_current_temp_request() {
   this->current_query_ = READ_CURRENT_TEMPERATURE;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_CURRENT_TEMP);
+  strncpy((char *) this->packet_.data, CMD_READ_CURRENT_TEMP, sizeof(this->packet_.data));
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_read_unit_request() {
   this->current_query_ = READ_UNIT;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_UNIT);
+  strncpy((char *) this->packet_.data, CMD_READ_UNIT, sizeof(this->packet_.data));
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_read_data_request() {
   this->current_query_ = READ_DATA;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_DATA);
+  strncpy((char *) this->packet_.data, CMD_READ_DATA, sizeof(this->packet_.data));
   return this->clean_packet_();
 }
 
@@ -62,13 +62,13 @@ AnovaPacket *AnovaCodec::get_set_unit_request(char unit) {
 
 AnovaPacket *AnovaCodec::get_start_request() {
   this->current_query_ = START;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_START);
+  strncpy((char *) this->packet_.data, CMD_START, sizeof(this->packet_.data));
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_stop_request() {
   this->current_query_ = STOP;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_STOP);
+  strncpy((char *) this->packet_.data, CMD_STOP, sizeof(this->packet_.data));
   return this->clean_packet_();
 }
 

esphome/components/api/api_connection.cpp

@@ -1712,16 +1712,17 @@ void APIConnection::on_home_assistant_state_response(const HomeAssistantStateRes
     }
 
     // Create null-terminated state for callback (parse_number needs null-termination)
-    // HA state max length is 255 characters, but attributes can be much longer
-    // Use stack buffer for common case (states), heap fallback for large attributes
-    size_t state_len = msg.state.size();
-    SmallBufferWithHeapFallback<MAX_STATE_LEN + 1> state_buf_alloc(state_len + 1);
-    char *state_buf = reinterpret_cast<char *>(state_buf_alloc.get());
-    if (state_len > 0) {
-      memcpy(state_buf, msg.state.c_str(), state_len);
+    // HA state max length is 255, so 256 byte buffer covers all cases
+    char state_buf[256];
+    size_t copy_len = msg.state.size();
+    if (copy_len >= sizeof(state_buf)) {
+      copy_len = sizeof(state_buf) - 1;  // Truncate to leave space for null terminator
     }
-    state_buf[state_len] = '\0';
-    it.callback(StringRef(state_buf, state_len));
+    if (copy_len > 0) {
+      memcpy(state_buf, msg.state.c_str(), copy_len);
+    }
+    state_buf[copy_len] = '\0';
+    it.callback(StringRef(state_buf, copy_len));
   }
 }
 #endif

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -135,8 +135,8 @@ void BluetoothConnection::loop() {
   // - For V3_WITH_CACHE: Services are never sent, disable after INIT state
   // - For V3_WITHOUT_CACHE: Disable only after service discovery is complete
   //   (send_service_ == DONE_SENDING_SERVICES, which is only set after services are sent)
-  if (this->state() != espbt::ClientState::INIT && (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
-                                                    this->send_service_ == DONE_SENDING_SERVICES)) {
+  if (this->state_ != espbt::ClientState::INIT && (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
+                                                   this->send_service_ == DONE_SENDING_SERVICES)) {
     this->disable_loop();
   }
 }

esphome/components/cs5460a/cs5460a.h

@@ -76,6 +76,7 @@ class CS5460AComponent : public Component,
   void restart() { restart_(); }
 
   void setup() override;
+  void loop() override {}
   void dump_config() override;
 
  protected:

esphome/components/datetime/date_entity.cpp

@@ -106,9 +106,9 @@ DateCall &DateCall::set_date(uint16_t year, uint8_t month, uint8_t day) {
 
 DateCall &DateCall::set_date(ESPTime time) { return this->set_date(time.year, time.month, time.day_of_month); };
 
-DateCall &DateCall::set_date(const char *date, size_t len) {
+DateCall &DateCall::set_date(const std::string &date) {
   ESPTime val{};
-  if (!ESPTime::strptime(date, len, val)) {
+  if (!ESPTime::strptime(date, val)) {
     ESP_LOGE(TAG, "Could not convert the date string to an ESPTime object");
     return *this;
   }

esphome/components/datetime/date_entity.h

@@ -67,9 +67,7 @@ class DateCall {
   void perform();
   DateCall &set_date(uint16_t year, uint8_t month, uint8_t day);
   DateCall &set_date(ESPTime time);
-  DateCall &set_date(const char *date, size_t len);
-  DateCall &set_date(const char *date) { return this->set_date(date, strlen(date)); }
-  DateCall &set_date(const std::string &date) { return this->set_date(date.c_str(), date.size()); }
+  DateCall &set_date(const std::string &date);
 
   DateCall &set_year(uint16_t year) {
     this->year_ = year;

esphome/components/datetime/datetime_entity.cpp

@@ -163,9 +163,9 @@ DateTimeCall &DateTimeCall::set_datetime(ESPTime datetime) {
                             datetime.second);
 };
 
-DateTimeCall &DateTimeCall::set_datetime(const char *datetime, size_t len) {
+DateTimeCall &DateTimeCall::set_datetime(const std::string &datetime) {
   ESPTime val{};
-  if (!ESPTime::strptime(datetime, len, val)) {
+  if (!ESPTime::strptime(datetime, val)) {
     ESP_LOGE(TAG, "Could not convert the time string to an ESPTime object");
     return *this;
   }

esphome/components/datetime/datetime_entity.h

@@ -71,11 +71,7 @@ class DateTimeCall {
   void perform();
   DateTimeCall &set_datetime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second);
   DateTimeCall &set_datetime(ESPTime datetime);
-  DateTimeCall &set_datetime(const char *datetime, size_t len);
-  DateTimeCall &set_datetime(const char *datetime) { return this->set_datetime(datetime, strlen(datetime)); }
-  DateTimeCall &set_datetime(const std::string &datetime) {
-    return this->set_datetime(datetime.c_str(), datetime.size());
-  }
+  DateTimeCall &set_datetime(const std::string &datetime);
   DateTimeCall &set_datetime(time_t epoch_seconds);
 
   DateTimeCall &set_year(uint16_t year) {

esphome/components/datetime/time_entity.cpp

@@ -74,9 +74,9 @@ TimeCall &TimeCall::set_time(uint8_t hour, uint8_t minute, uint8_t second) {
 
 TimeCall &TimeCall::set_time(ESPTime time) { return this->set_time(time.hour, time.minute, time.second); };
 
-TimeCall &TimeCall::set_time(const char *time, size_t len) {
+TimeCall &TimeCall::set_time(const std::string &time) {
   ESPTime val{};
-  if (!ESPTime::strptime(time, len, val)) {
+  if (!ESPTime::strptime(time, val)) {
     ESP_LOGE(TAG, "Could not convert the time string to an ESPTime object");
     return *this;
   }

esphome/components/datetime/time_entity.h

@@ -69,9 +69,7 @@ class TimeCall {
   void perform();
   TimeCall &set_time(uint8_t hour, uint8_t minute, uint8_t second);
   TimeCall &set_time(ESPTime time);
-  TimeCall &set_time(const char *time, size_t len);
-  TimeCall &set_time(const char *time) { return this->set_time(time, strlen(time)); }
-  TimeCall &set_time(const std::string &time) { return this->set_time(time.c_str(), time.size()); }
+  TimeCall &set_time(const std::string &time);
 
   TimeCall &set_hour(uint8_t hour) {
     this->hour_ = hour;

esphome/components/debug/debug_esp8266.cpp

@@ -3,80 +3,21 @@
 #include "esphome/core/log.h"
 #include <Esp.h>
 
-extern "C" {
-#include <user_interface.h>
-
-// Global reset info struct populated by SDK at boot
-extern struct rst_info resetInfo;
-
-// Core version - either a string pointer or a version number to format as hex
-extern uint32_t core_version;
-extern const char *core_release;
-}
-
 namespace esphome {
 namespace debug {
 
 static const char *const TAG = "debug";
 
-// Get reset reason string from reason code (no heap allocation)
-// Returns LogString* pointing to flash (PROGMEM) on ESP8266
-static const LogString *get_reset_reason_str(uint32_t reason) {
-  switch (reason) {
-    case REASON_DEFAULT_RST:
-      return LOG_STR("Power On");
-    case REASON_WDT_RST:
-      return LOG_STR("Hardware Watchdog");
-    case REASON_EXCEPTION_RST:
-      return LOG_STR("Exception");
-    case REASON_SOFT_WDT_RST:
-      return LOG_STR("Software Watchdog");
-    case REASON_SOFT_RESTART:
-      return LOG_STR("Software/System restart");
-    case REASON_DEEP_SLEEP_AWAKE:
-      return LOG_STR("Deep-Sleep Wake");
-    case REASON_EXT_SYS_RST:
-      return LOG_STR("External System");
-    default:
-      return LOG_STR("Unknown");
-  }
-}
-
-// Size for core version hex buffer
-static constexpr size_t CORE_VERSION_BUFFER_SIZE = 12;
-
-// Get core version string (no heap allocation)
-// Returns either core_release directly or formats core_version as hex into provided buffer
-static const char *get_core_version_str(std::span<char, CORE_VERSION_BUFFER_SIZE> buffer) {
-  if (core_release != nullptr) {
-    return core_release;
-  }
-  snprintf_P(buffer.data(), CORE_VERSION_BUFFER_SIZE, PSTR("%08x"), core_version);
-  return buffer.data();
-}
-
-// Size for reset info buffer
-static constexpr size_t RESET_INFO_BUFFER_SIZE = 200;
-
-// Get detailed reset info string (no heap allocation)
-// For watchdog/exception resets, includes detailed exception info
-static const char *get_reset_info_str(std::span<char, RESET_INFO_BUFFER_SIZE> buffer, uint32_t reason) {
-  if (reason >= REASON_WDT_RST && reason <= REASON_SOFT_WDT_RST) {
-    snprintf_P(buffer.data(), RESET_INFO_BUFFER_SIZE,
-               PSTR("Fatal exception:%d flag:%d (%s) epc1:0x%08x epc2:0x%08x epc3:0x%08x excvaddr:0x%08x depc:0x%08x"),
-               static_cast<int>(resetInfo.exccause), static_cast<int>(reason),
-               LOG_STR_ARG(get_reset_reason_str(reason)), resetInfo.epc1, resetInfo.epc2, resetInfo.epc3,
-               resetInfo.excvaddr, resetInfo.depc);
-    return buffer.data();
-  }
-  return LOG_STR_ARG(get_reset_reason_str(reason));
-}
-
 const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
-  // Copy from flash to provided buffer
-  strncpy_P(buffer.data(), (PGM_P) get_reset_reason_str(resetInfo.reason), RESET_REASON_BUFFER_SIZE - 1);
-  buffer[RESET_REASON_BUFFER_SIZE - 1] = '\0';
-  return buffer.data();
+  char *buf = buffer.data();
+#if !defined(CLANG_TIDY)
+  String reason = ESP.getResetReason();  // NOLINT
+  snprintf_P(buf, RESET_REASON_BUFFER_SIZE, PSTR("%s"), reason.c_str());
+  return buf;
+#else
+  buf[0] = '\0';
+  return buf;
+#endif
 }
 
 const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
@@ -92,42 +33,37 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
   char *buf = buffer.data();
 
-  const LogString *flash_mode;
+  const char *flash_mode;
   switch (ESP.getFlashChipMode()) {  // NOLINT(readability-static-accessed-through-instance)
     case FM_QIO:
-      flash_mode = LOG_STR("QIO");
+      flash_mode = "QIO";
       break;
     case FM_QOUT:
-      flash_mode = LOG_STR("QOUT");
+      flash_mode = "QOUT";
       break;
     case FM_DIO:
-      flash_mode = LOG_STR("DIO");
+      flash_mode = "DIO";
       break;
     case FM_DOUT:
-      flash_mode = LOG_STR("DOUT");
+      flash_mode = "DOUT";
       break;
     default:
-      flash_mode = LOG_STR("UNKNOWN");
+      flash_mode = "UNKNOWN";
   }
-  uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT(readability-static-accessed-through-instance)
-  uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT(readability-static-accessed-through-instance)
-  ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed,
-           LOG_STR_ARG(flash_mode));
+  uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT
+  uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT
+  ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed, flash_mode);
   pos = buf_append_printf(buf, size, pos, "|Flash: %" PRIu32 "kB Speed:%" PRIu32 "MHz Mode:%s", flash_size, flash_speed,
-                          LOG_STR_ARG(flash_mode));
+                          flash_mode);
 
+#if !defined(CLANG_TIDY)
   char reason_buffer[RESET_REASON_BUFFER_SIZE];
-  const char *reset_reason = get_reset_reason_(reason_buffer);
-  char core_version_buffer[CORE_VERSION_BUFFER_SIZE];
-  char reset_info_buffer[RESET_INFO_BUFFER_SIZE];
-  // NOLINTBEGIN(readability-static-accessed-through-instance)
+  const char *reset_reason = get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE>(reason_buffer));
   uint32_t chip_id = ESP.getChipId();
   uint8_t boot_version = ESP.getBootVersion();
   uint8_t boot_mode = ESP.getBootMode();
   uint8_t cpu_freq = ESP.getCpuFreqMHz();
   uint32_t flash_chip_id = ESP.getFlashChipId();
-  const char *sdk_version = ESP.getSdkVersion();
-  // NOLINTEND(readability-static-accessed-through-instance)
 
   ESP_LOGD(TAG,
            "Chip ID: 0x%08" PRIX32 "\n"
@@ -138,18 +74,19 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
            "Flash Chip ID=0x%08" PRIX32 "\n"
            "Reset Reason: %s\n"
            "Reset Info: %s",
-           chip_id, sdk_version, get_core_version_str(core_version_buffer), boot_version, boot_mode, cpu_freq,
-           flash_chip_id, reset_reason, get_reset_info_str(reset_info_buffer, resetInfo.reason));
+           chip_id, ESP.getSdkVersion(), ESP.getCoreVersion().c_str(), boot_version, boot_mode, cpu_freq, flash_chip_id,
+           reset_reason, ESP.getResetInfo().c_str());
 
   pos = buf_append_printf(buf, size, pos, "|Chip: 0x%08" PRIX32, chip_id);
-  pos = buf_append_printf(buf, size, pos, "|SDK: %s", sdk_version);
-  pos = buf_append_printf(buf, size, pos, "|Core: %s", get_core_version_str(core_version_buffer));
+  pos = buf_append_printf(buf, size, pos, "|SDK: %s", ESP.getSdkVersion());
+  pos = buf_append_printf(buf, size, pos, "|Core: %s", ESP.getCoreVersion().c_str());
   pos = buf_append_printf(buf, size, pos, "|Boot: %u", boot_version);
   pos = buf_append_printf(buf, size, pos, "|Mode: %u", boot_mode);
   pos = buf_append_printf(buf, size, pos, "|CPU: %u", cpu_freq);
   pos = buf_append_printf(buf, size, pos, "|Flash: 0x%08" PRIX32, flash_chip_id);
   pos = buf_append_printf(buf, size, pos, "|Reset: %s", reset_reason);
-  pos = buf_append_printf(buf, size, pos, "|%s", get_reset_info_str(reset_info_buffer, resetInfo.reason));
+  pos = buf_append_printf(buf, size, pos, "|%s", ESP.getResetInfo().c_str());
+#endif
 
   return pos;
 }

esphome/components/dsmr/dsmr.cpp

@@ -1,5 +1,4 @@
 #include "dsmr.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #include <AES.h>
@@ -295,8 +294,8 @@ void Dsmr::dump_config() {
   DSMR_TEXT_SENSOR_LIST(DSMR_LOG_TEXT_SENSOR, )
 }
 
-void Dsmr::set_decryption_key(const char *decryption_key) {
-  if (decryption_key == nullptr || decryption_key[0] == '\0') {
+void Dsmr::set_decryption_key(const std::string &decryption_key) {
+  if (decryption_key.empty()) {
     ESP_LOGI(TAG, "Disabling decryption");
     this->decryption_key_.clear();
     if (this->crypt_telegram_ != nullptr) {
@@ -306,14 +305,21 @@ void Dsmr::set_decryption_key(const char *decryption_key) {
     return;
   }
 
-  if (!parse_hex(decryption_key, this->decryption_key_, 16)) {
-    ESP_LOGE(TAG, "Error, decryption key must be 32 hex characters");
+  if (decryption_key.length() != 32) {
+    ESP_LOGE(TAG, "Error, decryption key must be 32 character long");
     return;
   }
+  this->decryption_key_.clear();
 
   ESP_LOGI(TAG, "Decryption key is set");
   // Verbose level prints decryption key
-  ESP_LOGV(TAG, "Using decryption key: %s", decryption_key);
+  ESP_LOGV(TAG, "Using decryption key: %s", decryption_key.c_str());
+
+  char temp[3] = {0};
+  for (int i = 0; i < 16; i++) {
+    strncpy(temp, &(decryption_key.c_str()[i * 2]), 2);
+    this->decryption_key_.push_back(std::strtoul(temp, nullptr, 16));
+  }
 
   if (this->crypt_telegram_ == nullptr) {
     this->crypt_telegram_ = new uint8_t[this->max_telegram_len_];  // NOLINT

esphome/components/dsmr/dsmr.h

@@ -63,7 +63,7 @@ class Dsmr : public Component, public uart::UARTDevice {
 
   void dump_config() override;
 
-  void set_decryption_key(const char *decryption_key);
+  void set_decryption_key(const std::string &decryption_key);
   void set_max_telegram_length(size_t length) { this->max_telegram_len_ = length; }
   void set_request_pin(GPIOPin *request_pin) { this->request_pin_ = request_pin; }
   void set_request_interval(uint32_t interval) { this->request_interval_ = interval; }

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -50,7 +50,7 @@ void BLEClientBase::loop() {
     this->set_state(espbt::ClientState::INIT);
     return;
   }
-  if (this->state() == espbt::ClientState::INIT) {
+  if (this->state_ == espbt::ClientState::INIT) {
     auto ret = esp_ble_gattc_app_register(this->app_id);
     if (ret) {
       ESP_LOGE(TAG, "gattc app register failed. app_id=%d code=%d", this->app_id, ret);
@@ -60,7 +60,7 @@ void BLEClientBase::loop() {
   }
   // If idle, we can disable the loop as connect()
   // will enable it again when a connection is needed.
-  else if (this->state() == espbt::ClientState::IDLE) {
+  else if (this->state_ == espbt::ClientState::IDLE) {
     this->disable_loop();
   }
 }
@@ -86,7 +86,7 @@ bool BLEClientBase::parse_device(const espbt::ESPBTDevice &device) {
     return false;
   if (this->address_ == 0 || device.address_uint64() != this->address_)
     return false;
-  if (this->state() != espbt::ClientState::IDLE)
+  if (this->state_ != espbt::ClientState::IDLE)
     return false;
 
   this->log_event_("Found device");
@@ -102,10 +102,10 @@ bool BLEClientBase::parse_device(const espbt::ESPBTDevice &device) {
 
 void BLEClientBase::connect() {
   // Prevent duplicate connection attempts
-  if (this->state() == espbt::ClientState::CONNECTING || this->state() == espbt::ClientState::CONNECTED ||
-      this->state() == espbt::ClientState::ESTABLISHED) {
+  if (this->state_ == espbt::ClientState::CONNECTING || this->state_ == espbt::ClientState::CONNECTED ||
+      this->state_ == espbt::ClientState::ESTABLISHED) {
     ESP_LOGW(TAG, "[%d] [%s] Connection already in progress, state=%s", this->connection_index_, this->address_str_,
-             espbt::client_state_to_string(this->state()));
+             espbt::client_state_to_string(this->state_));
     return;
   }
   ESP_LOGI(TAG, "[%d] [%s] 0x%02x Connecting", this->connection_index_, this->address_str_, this->remote_addr_type_);
@@ -133,12 +133,12 @@ void BLEClientBase::connect() {
 esp_err_t BLEClientBase::pair() { return esp_ble_set_encryption(this->remote_bda_, ESP_BLE_SEC_ENCRYPT); }
 
 void BLEClientBase::disconnect() {
-  if (this->state() == espbt::ClientState::IDLE || this->state() == espbt::ClientState::DISCONNECTING) {
+  if (this->state_ == espbt::ClientState::IDLE || this->state_ == espbt::ClientState::DISCONNECTING) {
     ESP_LOGI(TAG, "[%d] [%s] Disconnect requested, but already %s", this->connection_index_, this->address_str_,
-             espbt::client_state_to_string(this->state()));
+             espbt::client_state_to_string(this->state_));
     return;
   }
-  if (this->state() == espbt::ClientState::CONNECTING || this->conn_id_ == UNSET_CONN_ID) {
+  if (this->state_ == espbt::ClientState::CONNECTING || this->conn_id_ == UNSET_CONN_ID) {
     ESP_LOGD(TAG, "[%d] [%s] Disconnect before connected, disconnect scheduled", this->connection_index_,
              this->address_str_);
     this->want_disconnect_ = true;
@@ -150,7 +150,7 @@ void BLEClientBase::disconnect() {
 void BLEClientBase::unconditional_disconnect() {
   // Disconnect without checking the state.
   ESP_LOGI(TAG, "[%d] [%s] Disconnecting (conn_id: %d).", this->connection_index_, this->address_str_, this->conn_id_);
-  if (this->state() == espbt::ClientState::DISCONNECTING) {
+  if (this->state_ == espbt::ClientState::DISCONNECTING) {
     this->log_error_("Already disconnecting");
     return;
   }
@@ -170,7 +170,7 @@ void BLEClientBase::unconditional_disconnect() {
     this->log_gattc_warning_("esp_ble_gattc_close", err);
   }
 
-  if (this->state() == espbt::ClientState::DISCOVERED) {
+  if (this->state_ == espbt::ClientState::DISCOVERED) {
     this->set_address(0);
     this->set_state(espbt::ClientState::IDLE);
   } else {
@@ -295,18 +295,18 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       // ESP-IDF's BLE stack may send ESP_GATTC_OPEN_EVT after esp_ble_gattc_open() returns an
       // error, if the error occurred at the BTA/GATT layer. This can result in the event
       // arriving after we've already transitioned to IDLE state.
-      if (this->state() == espbt::ClientState::IDLE) {
+      if (this->state_ == espbt::ClientState::IDLE) {
         ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in IDLE state (status=%d), ignoring", this->connection_index_,
                  this->address_str_, param->open.status);
         break;
       }
 
-      if (this->state() != espbt::ClientState::CONNECTING) {
+      if (this->state_ != espbt::ClientState::CONNECTING) {
         // This should not happen but lets log it in case it does
         // because it means we have a bad assumption about how the
         // ESP BT stack works.
         ESP_LOGE(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in %s state (status=%d)", this->connection_index_,
-                 this->address_str_, espbt::client_state_to_string(this->state()), param->open.status);
+                 this->address_str_, espbt::client_state_to_string(this->state_), param->open.status);
       }
       if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
         this->log_gattc_warning_("Connection open", param->open.status);
@@ -327,7 +327,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
         // Cached connections already connected with medium parameters, no update needed
         // only set our state, subclients might have more stuff to do yet.
-        this->set_state_internal_(espbt::ClientState::ESTABLISHED);
+        this->state_ = espbt::ClientState::ESTABLISHED;
         break;
       }
       // For V3_WITHOUT_CACHE, we already set fast params before connecting
@@ -356,7 +356,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         return false;
       // Check if we were disconnected while waiting for service discovery
       if (param->disconnect.reason == ESP_GATT_CONN_TERMINATE_PEER_USER &&
-          this->state() == espbt::ClientState::CONNECTED) {
+          this->state_ == espbt::ClientState::CONNECTED) {
         this->log_warning_("Remote closed during discovery");
       } else {
         ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_DISCONNECT_EVT, reason 0x%02x", this->connection_index_, this->address_str_,
@@ -433,7 +433,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
 #endif
       }
       ESP_LOGI(TAG, "[%d] [%s] Service discovery complete", this->connection_index_, this->address_str_);
-      this->set_state_internal_(espbt::ClientState::ESTABLISHED);
+      this->state_ = espbt::ClientState::ESTABLISHED;
       break;
     }
     case ESP_GATTC_READ_DESCR_EVT: {

esphome/components/esp32_ble_client/ble_client_base.h

@@ -44,7 +44,7 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   void unconditional_disconnect();
   void release_services();
 
-  bool connected() { return this->state() == espbt::ClientState::ESTABLISHED; }
+  bool connected() { return this->state_ == espbt::ClientState::ESTABLISHED; }
 
   void set_auto_connect(bool auto_connect) { this->auto_connect_ = auto_connect; }
 

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -105,13 +105,15 @@ void ESP32BLETracker::loop() {
   }
 
   // Check for scan timeout - moved here from scheduler to avoid false reboots
-  // when the loop is blocked. This must run every iteration for safety.
+  // when the loop is blocked
   if (this->scanner_state_ == ScannerState::RUNNING) {
     switch (this->scan_timeout_state_) {
       case ScanTimeoutState::MONITORING: {
+        uint32_t now = App.get_loop_component_start_time();
+        uint32_t timeout_ms = this->scan_duration_ * 2000;
         // Robust time comparison that handles rollover correctly
         // This works because unsigned arithmetic wraps around predictably
-        if ((App.get_loop_component_start_time() - this->scan_start_time_) > this->scan_timeout_ms_) {
+        if ((now - this->scan_start_time_) > timeout_ms) {
           // First time we've seen the timeout exceeded - wait one more loop iteration
           // This ensures all components have had a chance to process pending events
           // This is because esp32_ble may not have run yet and called
@@ -126,31 +128,13 @@ void ESP32BLETracker::loop() {
         ESP_LOGE(TAG, "Scan never terminated, rebooting");
         App.reboot();
         break;
+
       case ScanTimeoutState::INACTIVE:
+        // This case should be unreachable - scanner and timeout states are always synchronized
         break;
     }
   }
 
-  // Fast path: skip expensive client state counting and processing
-  // if no state has changed since last loop iteration.
-  //
-  // How state changes ensure we reach the code below:
-  // - handle_scanner_failure_(): scanner_state_ becomes FAILED via set_scanner_state_(), or
-  //   scan_set_param_failed_ requires scanner_state_==RUNNING which can only be reached via
-  //   set_scanner_state_(RUNNING) in gap_scan_start_complete_() (scan params are set during
-  //   STARTING, not RUNNING, so version is always incremented before this condition is true)
-  // - start_scan_(): scanner_state_ becomes IDLE via set_scanner_state_() in cleanup_scan_state_()
-  // - try_promote_discovered_clients_(): client enters DISCOVERED via set_state(), or
-  //   connecting client finishes (state change), or scanner reaches RUNNING/IDLE
-  //
-  // All conditions that affect the logic below are tied to state changes that increment
-  // state_version_, so the fast path is safe.
-  if (this->state_version_ == this->last_processed_version_) {
-    return;
-  }
-  this->last_processed_version_ = this->state_version_;
-
-  // State changed - do full processing
   ClientStateCounts counts = this->count_client_states_();
   if (counts != this->client_state_counts_) {
     this->client_state_counts_ = counts;
@@ -158,7 +142,6 @@ void ESP32BLETracker::loop() {
              this->client_state_counts_.discovered, this->client_state_counts_.disconnecting);
   }
 
-  // Scanner failure: reached when set_scanner_state_(FAILED) or scan_set_param_failed_ set
   if (this->scanner_state_ == ScannerState::FAILED ||
       (this->scan_set_param_failed_ && this->scanner_state_ == ScannerState::RUNNING)) {
     this->handle_scanner_failure_();
@@ -177,8 +160,6 @@ void ESP32BLETracker::loop() {
 
   */
 
-  // Start scan: reached when scanner_state_ becomes IDLE (via set_scanner_state_()) and
-  // all clients are idle (their state changes increment version when they finish)
   if (this->scanner_state_ == ScannerState::IDLE && !counts.connecting && !counts.disconnecting && !counts.discovered) {
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
     this->update_coex_preference_(false);
@@ -187,9 +168,8 @@ void ESP32BLETracker::loop() {
       this->start_scan_(false);  // first = false
     }
   }
-  // Promote discovered clients: reached when a client's state becomes DISCOVERED (via set_state()),
-  // or when a blocking condition clears (connecting client finishes, scanner reaches RUNNING/IDLE).
-  // All these trigger state_version_ increment, so we'll process and check promotion eligibility.
+  // If there is a discovered client and no connecting
+  // clients, then promote the discovered client to ready to connect.
   // We check both RUNNING and IDLE states because:
   // - RUNNING: gap_scan_event_handler initiates stop_scan_() but promotion can happen immediately
   // - IDLE: Scanner has already stopped (naturally or by gap_scan_event_handler)
@@ -256,7 +236,6 @@ void ESP32BLETracker::start_scan_(bool first) {
   // Start timeout monitoring in loop() instead of using scheduler
   // This prevents false reboots when the loop is blocked
   this->scan_start_time_ = App.get_loop_component_start_time();
-  this->scan_timeout_ms_ = this->scan_duration_ * 2000;
   this->scan_timeout_state_ = ScanTimeoutState::MONITORING;
 
   esp_err_t err = esp_ble_gap_set_scan_params(&this->scan_params_);
@@ -274,10 +253,6 @@ void ESP32BLETracker::start_scan_(bool first) {
 void ESP32BLETracker::register_client(ESPBTClient *client) {
 #ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   client->app_id = ++this->app_id_;
-  // Give client a pointer to our state_version_ so it can notify us of state changes.
-  // This enables loop() fast-path optimization - we skip expensive work when no state changed.
-  // Safe because ESP32BLETracker (singleton) outlives all registered clients.
-  client->set_tracker_state_version(&this->state_version_);
   this->clients_.push_back(client);
   this->recalculate_advertisement_parser_types();
 #endif
@@ -407,7 +382,6 @@ void ESP32BLETracker::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
 
 void ESP32BLETracker::set_scanner_state_(ScannerState state) {
   this->scanner_state_ = state;
-  this->state_version_++;
   for (auto *listener : this->scanner_state_listeners_) {
     listener->on_scanner_state(state);
   }

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -216,19 +216,6 @@ enum class ConnectionType : uint8_t {
   V3_WITHOUT_CACHE
 };
 
-/// Base class for BLE GATT clients that connect to remote devices.
-///
-/// State Change Tracking Design:
-/// -----------------------------
-/// ESP32BLETracker::loop() needs to know when client states change to avoid
-/// expensive polling. Rather than checking all clients every iteration (~7000/min),
-/// we use a version counter owned by ESP32BLETracker that clients increment on
-/// state changes. The tracker compares versions to skip work when nothing changed.
-///
-/// Ownership: ESP32BLETracker owns state_version_. Clients hold a non-owning
-/// pointer (tracker_state_version_) set during register_client(). Clients
-/// increment the counter through this pointer when their state changes.
-/// The pointer may be null if the client is not registered with a tracker.
 class ESPBTClient : public ESPBTDeviceListener {
  public:
   virtual bool gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
@@ -238,49 +225,26 @@ class ESPBTClient : public ESPBTDeviceListener {
   virtual void disconnect() = 0;
   bool disconnect_pending() const { return this->want_disconnect_; }
   void cancel_pending_disconnect() { this->want_disconnect_ = false; }
-
-  /// Set the client state with IDLE handling (clears want_disconnect_).
-  /// Notifies the tracker of state change for loop optimization.
   virtual void set_state(ClientState st) {
-    this->set_state_internal_(st);
+    this->state_ = st;
     if (st == ClientState::IDLE) {
       this->want_disconnect_ = false;
     }
   }
-  ClientState state() const { return this->state_; }
-
-  /// Called by ESP32BLETracker::register_client() to enable state change notifications.
-  /// The pointer must remain valid for the lifetime of the client (guaranteed since
-  /// ESP32BLETracker is a singleton that outlives all clients).
-  void set_tracker_state_version(uint8_t *version) { this->tracker_state_version_ = version; }
+  ClientState state() const { return state_; }
 
   // Memory optimized layout
   uint8_t app_id;  // App IDs are small integers assigned sequentially
 
  protected:
-  /// Set state without IDLE handling - use for direct state transitions.
-  /// Increments the tracker's state version counter to signal that loop()
-  /// should do full processing on the next iteration.
-  void set_state_internal_(ClientState st) {
-    this->state_ = st;
-    // Notify tracker that state changed (tracker_state_version_ is owned by ESP32BLETracker)
-    if (this->tracker_state_version_ != nullptr) {
-      (*this->tracker_state_version_)++;
-    }
-  }
-
+  // Group 1: 1-byte types
+  ClientState state_{ClientState::INIT};
   // want_disconnect_ is set to true when a disconnect is requested
   // while the client is connecting. This is used to disconnect the
   // client as soon as we get the connection id (conn_id_) from the
   // ESP_GATTC_OPEN_EVT event.
   bool want_disconnect_{false};
-
- private:
-  ClientState state_{ClientState::INIT};
-  /// Non-owning pointer to ESP32BLETracker::state_version_. When this client's
-  /// state changes, we increment the tracker's counter to signal that loop()
-  /// should perform full processing. Null if client not registered with tracker.
-  uint8_t *tracker_state_version_{nullptr};
+  // 2 bytes used, 2 bytes padding
 };
 
 class ESP32BLETracker : public Component,
@@ -416,16 +380,6 @@ class ESP32BLETracker : public Component,
   // Group 4: 1-byte types (enums, uint8_t, bool)
   uint8_t app_id_{0};
   uint8_t scan_start_fail_count_{0};
-  /// Version counter for loop() fast-path optimization. Incremented when:
-  /// - Scanner state changes (via set_scanner_state_())
-  /// - Any registered client's state changes (clients hold pointer to this counter)
-  /// Owned by this class; clients receive non-owning pointer via register_client().
-  /// When loop() sees state_version_ == last_processed_version_, it skips expensive
-  /// client state counting and takes the fast path (just timeout check + return).
-  uint8_t state_version_{0};
-  /// Last state_version_ value when loop() did full processing. Compared against
-  /// state_version_ to detect if any state changed since last iteration.
-  uint8_t last_processed_version_{0};
   ScannerState scanner_state_{ScannerState::IDLE};
   bool scan_continuous_;
   bool scan_active_;
@@ -442,8 +396,6 @@ class ESP32BLETracker : public Component,
     EXCEEDED_WAIT,  // Timeout exceeded, waiting one loop before reboot
   };
   uint32_t scan_start_time_{0};
-  /// Precomputed timeout value: scan_duration_ * 2000
-  uint32_t scan_timeout_ms_{0};
   ScanTimeoutState scan_timeout_state_{ScanTimeoutState::INACTIVE};
 };
 

esphome/components/esp8266/core.cpp

@@ -6,11 +6,7 @@
 #include "esphome/core/helpers.h"
 #include "preferences.h"
 #include <Arduino.h>
-#include <core_esp8266_features.h>
-
-extern "C" {
-#include <user_interface.h>
-}
+#include <Esp.h>
 
 namespace esphome {
 
@@ -20,19 +16,23 @@ void IRAM_ATTR HOT delay(uint32_t ms) { ::delay(ms); }
 uint32_t IRAM_ATTR HOT micros() { return ::micros(); }
 void IRAM_ATTR HOT delayMicroseconds(uint32_t us) { delay_microseconds_safe(us); }
 void arch_restart() {
-  system_restart();
+  ESP.restart();  // NOLINT(readability-static-accessed-through-instance)
   // restart() doesn't always end execution
   while (true) {  // NOLINT(clang-diagnostic-unreachable-code)
     yield();
   }
 }
 void arch_init() {}
-void IRAM_ATTR HOT arch_feed_wdt() { system_soft_wdt_feed(); }
+void IRAM_ATTR HOT arch_feed_wdt() {
+  ESP.wdtFeed();  // NOLINT(readability-static-accessed-through-instance)
+}
 
 uint8_t progmem_read_byte(const uint8_t *addr) {
   return pgm_read_byte(addr);  // NOLINT
 }
-uint32_t IRAM_ATTR HOT arch_get_cpu_cycle_count() { return esp_get_cycle_count(); }
+uint32_t IRAM_ATTR HOT arch_get_cpu_cycle_count() {
+  return ESP.getCycleCount();  // NOLINT(readability-static-accessed-through-instance)
+}
 uint32_t arch_get_cpu_freq_hz() { return F_CPU; }
 
 void force_link_symbols() {

esphome/components/globals/__init__.py

@@ -6,7 +6,6 @@ from esphome.const import (
     CONF_INITIAL_VALUE,
     CONF_RESTORE_VALUE,
     CONF_TYPE,
-    CONF_UPDATE_INTERVAL,
     CONF_VALUE,
 )
 from esphome.core import CoroPriority, coroutine_with_priority
@@ -14,37 +13,25 @@ from esphome.core import CoroPriority, coroutine_with_priority
 CODEOWNERS = ["@esphome/core"]
 globals_ns = cg.esphome_ns.namespace("globals")
 GlobalsComponent = globals_ns.class_("GlobalsComponent", cg.Component)
-RestoringGlobalsComponent = globals_ns.class_(
-    "RestoringGlobalsComponent", cg.PollingComponent
-)
+RestoringGlobalsComponent = globals_ns.class_("RestoringGlobalsComponent", cg.Component)
 RestoringGlobalStringComponent = globals_ns.class_(
-    "RestoringGlobalStringComponent", cg.PollingComponent
+    "RestoringGlobalStringComponent", cg.Component
 )
 GlobalVarSetAction = globals_ns.class_("GlobalVarSetAction", automation.Action)
 
 CONF_MAX_RESTORE_DATA_LENGTH = "max_restore_data_length"
 
 
-def validate_update_interval(config):
-    if CONF_UPDATE_INTERVAL in config and not config.get(CONF_RESTORE_VALUE, False):
-        raise cv.Invalid("update_interval requires restore_value to be true")
-    return config
-
-
 MULTI_CONF = True
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.Required(CONF_ID): cv.declare_id(GlobalsComponent),
-            cv.Required(CONF_TYPE): cv.string_strict,
-            cv.Optional(CONF_INITIAL_VALUE): cv.string_strict,
-            cv.Optional(CONF_RESTORE_VALUE, default=False): cv.boolean,
-            cv.Optional(CONF_MAX_RESTORE_DATA_LENGTH): cv.int_range(0, 254),
-            cv.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
-        }
-    ).extend(cv.COMPONENT_SCHEMA),
-    validate_update_interval,
-)
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.declare_id(GlobalsComponent),
+        cv.Required(CONF_TYPE): cv.string_strict,
+        cv.Optional(CONF_INITIAL_VALUE): cv.string_strict,
+        cv.Optional(CONF_RESTORE_VALUE, default=False): cv.boolean,
+        cv.Optional(CONF_MAX_RESTORE_DATA_LENGTH): cv.int_range(0, 254),
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
 
 # Run with low priority so that namespaces are registered first
@@ -78,8 +65,6 @@ async def to_code(config):
             value = value.encode()
         hash_ = int(hashlib.md5(value).hexdigest()[:8], 16)
         cg.add(glob.set_name_hash(hash_))
-        if CONF_UPDATE_INTERVAL in config:
-            cg.add(glob.set_update_interval(config[CONF_UPDATE_INTERVAL]))
 
 
 @automation.register_action(

esphome/components/globals/globals_component.h

@@ -5,7 +5,8 @@
 #include "esphome/core/helpers.h"
 #include <cstring>
 
-namespace esphome::globals {
+namespace esphome {
+namespace globals {
 
 template<typename T> class GlobalsComponent : public Component {
  public:
@@ -23,14 +24,13 @@ template<typename T> class GlobalsComponent : public Component {
   T value_{};
 };
 
-template<typename T> class RestoringGlobalsComponent : public PollingComponent {
+template<typename T> class RestoringGlobalsComponent : public Component {
  public:
   using value_type = T;
-  explicit RestoringGlobalsComponent() : PollingComponent(1000) {}
-  explicit RestoringGlobalsComponent(T initial_value) : PollingComponent(1000), value_(initial_value) {}
+  explicit RestoringGlobalsComponent() = default;
+  explicit RestoringGlobalsComponent(T initial_value) : value_(initial_value) {}
   explicit RestoringGlobalsComponent(
-      std::array<typename std::remove_extent<T>::type, std::extent<T>::value> initial_value)
-      : PollingComponent(1000) {
+      std::array<typename std::remove_extent<T>::type, std::extent<T>::value> initial_value) {
     memcpy(this->value_, initial_value.data(), sizeof(T));
   }
 
@@ -44,7 +44,7 @@ template<typename T> class RestoringGlobalsComponent : public PollingComponent {
 
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  void update() override { store_value_(); }
+  void loop() override { store_value_(); }
 
   void on_shutdown() override { store_value_(); }
 
@@ -66,14 +66,13 @@ template<typename T> class RestoringGlobalsComponent : public PollingComponent {
 };
 
 // Use with string or subclasses of strings
-template<typename T, uint8_t SZ> class RestoringGlobalStringComponent : public PollingComponent {
+template<typename T, uint8_t SZ> class RestoringGlobalStringComponent : public Component {
  public:
   using value_type = T;
-  explicit RestoringGlobalStringComponent() : PollingComponent(1000) {}
-  explicit RestoringGlobalStringComponent(T initial_value) : PollingComponent(1000) { this->value_ = initial_value; }
+  explicit RestoringGlobalStringComponent() = default;
+  explicit RestoringGlobalStringComponent(T initial_value) { this->value_ = initial_value; }
   explicit RestoringGlobalStringComponent(
-      std::array<typename std::remove_extent<T>::type, std::extent<T>::value> initial_value)
-      : PollingComponent(1000) {
+      std::array<typename std::remove_extent<T>::type, std::extent<T>::value> initial_value) {
     memcpy(this->value_, initial_value.data(), sizeof(T));
   }
 
@@ -91,7 +90,7 @@ template<typename T, uint8_t SZ> class RestoringGlobalStringComponent : public P
 
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  void update() override { store_value_(); }
+  void loop() override { store_value_(); }
 
   void on_shutdown() override { store_value_(); }
 
@@ -145,4 +144,5 @@ template<typename T> T &id(GlobalsComponent<T> *value) { return value->value();
 template<typename T> T &id(RestoringGlobalsComponent<T> *value) { return value->value(); }
 template<typename T, uint8_t SZ> T &id(RestoringGlobalStringComponent<T, SZ> *value) { return value->value(); }
 
-}  // namespace esphome::globals
+}  // namespace globals
+}  // namespace esphome

esphome/components/i2c/i2c.cpp

@@ -42,8 +42,8 @@ ErrorCode I2CDevice::read_register16(uint16_t a_register, uint8_t *data, size_t
 }
 
 ErrorCode I2CDevice::write_register(uint8_t a_register, const uint8_t *data, size_t len) const {
-  SmallBufferWithHeapFallback<17> buffer_alloc(len + 1);  // Most I2C writes are <= 16 bytes
-  uint8_t *buffer = buffer_alloc.get();
+  SmallBufferWithHeapFallback<17> buffer_alloc;  // Most I2C writes are <= 16 bytes
+  uint8_t *buffer = buffer_alloc.get(len + 1);
 
   buffer[0] = a_register;
   std::copy(data, data + len, buffer + 1);
@@ -51,8 +51,8 @@ ErrorCode I2CDevice::write_register(uint8_t a_register, const uint8_t *data, siz
 }
 
 ErrorCode I2CDevice::write_register16(uint16_t a_register, const uint8_t *data, size_t len) const {
-  SmallBufferWithHeapFallback<18> buffer_alloc(len + 2);  // Most I2C writes are <= 16 bytes + 2 for register
-  uint8_t *buffer = buffer_alloc.get();
+  SmallBufferWithHeapFallback<18> buffer_alloc;  // Most I2C writes are <= 16 bytes + 2 for register
+  uint8_t *buffer = buffer_alloc.get(len + 2);
 
   buffer[0] = a_register >> 8;
   buffer[1] = a_register;

esphome/components/i2c/i2c_bus.h

@@ -11,6 +11,22 @@
 namespace esphome {
 namespace i2c {
 
+/// @brief Helper class for efficient buffer allocation - uses stack for small sizes, heap for large
+template<size_t STACK_SIZE> class SmallBufferWithHeapFallback {
+ public:
+  uint8_t *get(size_t size) {
+    if (size <= STACK_SIZE) {
+      return this->stack_buffer_;
+    }
+    this->heap_buffer_ = std::unique_ptr<uint8_t[]>(new uint8_t[size]);
+    return this->heap_buffer_.get();
+  }
+
+ private:
+  uint8_t stack_buffer_[STACK_SIZE];
+  std::unique_ptr<uint8_t[]> heap_buffer_;
+};
+
 /// @brief Error codes returned by I2CBus and I2CDevice methods
 enum ErrorCode {
   NO_ERROR = 0,                ///< No error found during execution of method
@@ -76,8 +92,8 @@ class I2CBus {
       total_len += read_buffers[i].len;
     }
 
-    SmallBufferWithHeapFallback<128> buffer_alloc(total_len);  // Most I2C reads are small
-    uint8_t *buffer = buffer_alloc.get();
+    SmallBufferWithHeapFallback<128> buffer_alloc;  // Most I2C reads are small
+    uint8_t *buffer = buffer_alloc.get(total_len);
 
     auto err = this->write_readv(address, nullptr, 0, buffer, total_len);
     if (err != ERROR_OK)
@@ -100,8 +116,8 @@ class I2CBus {
       total_len += write_buffers[i].len;
     }
 
-    SmallBufferWithHeapFallback<128> buffer_alloc(total_len);  // Most I2C writes are small
-    uint8_t *buffer = buffer_alloc.get();
+    SmallBufferWithHeapFallback<128> buffer_alloc;  // Most I2C writes are small
+    uint8_t *buffer = buffer_alloc.get(total_len);
 
     size_t pos = 0;
     for (size_t i = 0; i != count; i++) {

esphome/components/lock/lock.cpp

@@ -28,14 +28,16 @@ const LogString *lock_state_to_string(LockState state) {
 Lock::Lock() : state(LOCK_STATE_NONE) {}
 LockCall Lock::make_call() { return LockCall(this); }
 
-void Lock::set_state_(LockState state) {
+void Lock::lock() {
   auto call = this->make_call();
-  call.set_state(state);
+  call.set_state(LOCK_STATE_LOCKED);
+  this->control(call);
+}
+void Lock::unlock() {
+  auto call = this->make_call();
+  call.set_state(LOCK_STATE_UNLOCKED);
   this->control(call);
 }
-
-void Lock::lock() { this->set_state_(LOCK_STATE_LOCKED); }
-void Lock::unlock() { this->set_state_(LOCK_STATE_UNLOCKED); }
 void Lock::open() {
   if (traits.get_supports_open()) {
     ESP_LOGD(TAG, "'%s' Opening.", this->get_name().c_str());

esphome/components/lock/lock.h

@@ -156,9 +156,6 @@ class Lock : public EntityBase {
  protected:
   friend LockCall;
 
-  /// Helper for lock/unlock convenience methods
-  void set_state_(LockState state);
-
   /** Perform the open latch action with hardware. This method is optional to implement
    * when creating a new lock.
    *

esphome/components/logger/logger.h

@@ -234,7 +234,6 @@ class Logger : public Component {
 #endif
 
  protected:
-  void write_msg_(const char *msg, size_t len);
   // RAII guard for recursion flags - sets flag on construction, clears on destruction
   class RecursionGuard {
    public:
@@ -261,6 +260,7 @@ class Logger : public Component {
 #endif
 #endif
   void process_messages_();
+  void write_msg_(const char *msg, size_t len);
 
   // Format a log message with printf-style arguments and write it to a buffer with header, footer, and null terminator
   // It's the caller's responsibility to initialize buffer_at (typically to 0)

esphome/components/mipi_spi/mipi_spi.h

@@ -224,9 +224,12 @@ class MipiSpi : public display::Display,
                     this->madctl_ & MADCTL_BGR ? "BGR" : "RGB", DISPLAYPIXEL * 8, IS_BIG_ENDIAN ? "Big" : "Little");
     if (this->brightness_.has_value())
       esph_log_config(TAG, "  Brightness: %u", this->brightness_.value());
-    log_pin(TAG, "  CS Pin: ", this->cs_);
-    log_pin(TAG, "  Reset Pin: ", this->reset_pin_);
-    log_pin(TAG, "  DC Pin: ", this->dc_pin_);
+    if (this->cs_ != nullptr)
+      esph_log_config(TAG, "  CS Pin: %s", this->cs_->dump_summary().c_str());
+    if (this->reset_pin_ != nullptr)
+      esph_log_config(TAG, "  Reset Pin: %s", this->reset_pin_->dump_summary().c_str());
+    if (this->dc_pin_ != nullptr)
+      esph_log_config(TAG, "  DC Pin: %s", this->dc_pin_->dump_summary().c_str());
     esph_log_config(TAG,
                     "  SPI Mode: %d\n"
                     "  SPI Data rate: %dMHz\n"

esphome/components/mipi_spi/models/adafruit.py

@@ -26,3 +26,5 @@ ST7789V.extend(
     reset_pin=40,
     invert_colors=True,
 )
+
+models = {}

esphome/components/mipi_spi/models/amoled.py

@@ -105,3 +105,6 @@ CO5300 = DriverChip(
         (WCE, 0x00),
     ),
 )
+
+
+models = {}

esphome/components/mipi_spi/models/cyd.py

@@ -1,45 +1,10 @@
-from .ili import ILI9341, ILI9342, ST7789V
+from .ili import ILI9341
 
 ILI9341.extend(
-    # ESP32-2432S028 CYD board with Micro USB, has ILI9341 controller
     "ESP32-2432S028",
     data_rate="40MHz",
-    cs_pin={"number": 15, "ignore_strapping_warning": True},
-    dc_pin={"number": 2, "ignore_strapping_warning": True},
+    cs_pin=15,
+    dc_pin=2,
 )
 
-ST7789V.extend(
-    # ESP32-2432S028 CYD board with USB C + Micro USB, has ST7789V controller
-    "ESP32-2432S028-7789",
-    data_rate="40MHz",
-    cs_pin={"number": 15, "ignore_strapping_warning": True},
-    dc_pin={"number": 2, "ignore_strapping_warning": True},
-)
-
-# fmt: off
-
-ILI9342.extend(
-    # ESP32-2432S028 CYD board with USB C + Micro USB, has ILI9342 controller
-    "ESP32-2432S028-9342",
-    data_rate="40MHz",
-    cs_pin={"number": 15, "ignore_strapping_warning": True},
-    dc_pin={"number": 2, "ignore_strapping_warning": True},
-    initsequence=(
-        (0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02),  # Power Control A
-        (0xCF, 0x00, 0xC1, 0x30),  # Power Control B
-        (0xE8, 0x85, 0x00, 0x78),  # Driver timing control A
-        (0xEA, 0x00, 0x00),  # Driver timing control B
-        (0xED, 0x64, 0x03, 0x12, 0x81),  # Power on sequence control
-        (0xF7, 0x20),  # Pump ratio control
-        (0xC0, 0x23),  # Power Control 1
-        (0xC1, 0x10),  # Power Control 2
-        (0xC5, 0x3E, 0x28),  # VCOM Control 1
-        (0xC7, 0x86),  # VCOM Control 2
-        (0xB1, 0x00, 0x1B),  # Frame Rate Control
-        (0xB6, 0x0A, 0xA2, 0x27, 0x00),  # Display Function Control
-        (0xF2, 0x00),  # Enable 3G
-        (0x26, 0x01),  # Gamma Set
-        (0xE0, 0x00, 0x0C, 0x11, 0x04, 0x11, 0x08, 0x37, 0x89, 0x4C, 0x06, 0x0C, 0x0A, 0x2E, 0x34, 0x0F),  # Positive Gamma Correction
-        (0xE1, 0x00, 0x0B, 0x11, 0x05, 0x13, 0x09, 0x33, 0x67, 0x48, 0x07, 0x0E, 0x0B, 0x23, 0x33, 0x0F),  # Negative Gamma Correction
-    )
-)
+models = {}

esphome/components/mipi_spi/models/ili.py

@@ -148,34 +148,6 @@ ILI9341 = DriverChip(
         ),
     ),
 )
-
-# fmt: off
-
-ILI9342 = DriverChip(
-    "ILI9342",
-    width=320,
-    height=240,
-    mirror_x=True,
-    initsequence=(
-        (0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02),  # Power Control A
-        (0xCF, 0x00, 0xC1, 0x30),  # Power Control B
-        (0xE8, 0x85, 0x00, 0x78),  # Driver timing control A
-        (0xEA, 0x00, 0x00),  # Driver timing control B
-        (0xED, 0x64, 0x03, 0x12, 0x81),  # Power on sequence control
-        (0xF7, 0x20),  # Pump ratio control
-        (0xC0, 0x23),  # Power Control 1
-        (0xC1, 0x10),  # Power Control 2
-        (0xC5, 0x3E, 0x28),  # VCOM Control 1
-        (0xC7, 0x86),  # VCOM Control 2
-        (0xB1, 0x00, 0x1B),  # Frame Rate Control
-        (0xB6, 0x0A, 0xA2, 0x27, 0x00),  # Display Function Control
-        (0xF2, 0x00),  # Enable 3G
-        (0x26, 0x01),  # Gamma Set
-        (0xE0, 0x0F, 0x1F, 0x1C, 0x0C, 0x0F, 0x08, 0x48, 0x98, 0x37, 0x0A, 0x13, 0x04, 0x11, 0x0D, 0x00),  # Positive Gamma
-        (0xE1, 0x0F, 0x32, 0x2E, 0x0B, 0x0D, 0x05, 0x47, 0x75, 0x37, 0x06, 0x10, 0x03, 0x24, 0x20, 0x00),  # Negative Gamma
-    ),
-)
-
 # M5Stack Core2 uses ILI9341 chip - mirror_x disabled for correct orientation
 ILI9341.extend(
     "M5CORE2",
@@ -786,3 +758,5 @@ ST7796.extend(
     dc_pin=0,
     invert_colors=True,
 )
+
+models = {}

esphome/components/mipi_spi/models/jc.py

@@ -588,3 +588,5 @@ DriverChip(
         (0x29, 0x00),
     ),
 )
+
+models = {}

esphome/components/mipi_spi/models/lanbon.py

@@ -11,3 +11,5 @@ ST7789V.extend(
     dc_pin=21,
     reset_pin=18,
 )
+
+models = {}

esphome/components/mipi_spi/models/lilygo.py

@@ -56,3 +56,5 @@ ST7796.extend(
     backlight_pin=48,
     invert_colors=True,
 )
+
+models = {}

esphome/components/modbus_controller/modbus_controller.h

@@ -271,9 +271,9 @@ class ServerRegister {
 
   // Formats a raw value into a string representation based on the value type for debugging
   std::string format_value(int64_t value) const {
-    // max 44: float with %.1f can be up to 42 chars (3.4e38 → 39 integer digits + sign + decimal + 1 digit)
-    // plus null terminator = 43, rounded to 44 for 4-byte alignment
-    char buf[44];
+    // max 48: float with %.1f can be up to 42 chars (3.4e38 → 38 integer digits + decimal + 1 digit + sign + null)
+    // int64_t max is 20 chars + sign + null = 22, so 48 covers both
+    char buf[48];
     switch (this->value_type) {
       case SensorValueType::U_WORD:
       case SensorValueType::U_DWORD:

esphome/components/mqtt/mqtt_alarm_control_panel.cpp

@@ -43,7 +43,7 @@ void MQTTAlarmControlPanelComponent::setup() {
 
 void MQTTAlarmControlPanelComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT alarm_control_panel '%s':", this->alarm_control_panel_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true);
+  LOG_MQTT_COMPONENT(true, true)
   ESP_LOGCONFIG(TAG,
                 "  Supported Features: %" PRIu32 "\n"
                 "  Requires Code to Disarm: %s\n"

esphome/components/mqtt/mqtt_binary_sensor.cpp

@@ -19,7 +19,7 @@ void MQTTBinarySensorComponent::setup() {
 
 void MQTTBinarySensorComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Binary Sensor '%s':", this->binary_sensor_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, false);
+  LOG_MQTT_COMPONENT(true, false)
 }
 MQTTBinarySensorComponent::MQTTBinarySensorComponent(binary_sensor::BinarySensor *binary_sensor)
     : binary_sensor_(binary_sensor) {

esphome/components/mqtt/mqtt_client.cpp

@@ -5,7 +5,6 @@
 #include <utility>
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
-#include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/version.h"
@@ -67,13 +66,10 @@ void MQTTClientComponent::setup() {
         "esphome/discover", [this](const std::string &topic, const std::string &payload) { this->send_device_info_(); },
         2);
 
-    // Format topic on stack - subscribe() copies it
-    // "esphome/ping/" (13) + name (ESPHOME_DEVICE_NAME_MAX_LEN) + null (1)
-    constexpr size_t ping_topic_buffer_size = 13 + ESPHOME_DEVICE_NAME_MAX_LEN + 1;
-    char ping_topic[ping_topic_buffer_size];
-    buf_append_printf(ping_topic, sizeof(ping_topic), 0, "esphome/ping/%s", App.get_name().c_str());
+    std::string topic = "esphome/ping/";
+    topic.append(App.get_name());
     this->subscribe(
-        ping_topic, [this](const std::string &topic, const std::string &payload) { this->send_device_info_(); }, 2);
+        topic, [this](const std::string &topic, const std::string &payload) { this->send_device_info_(); }, 2);
   }
 
   if (this->enable_on_boot_) {
@@ -85,11 +81,8 @@ void MQTTClientComponent::send_device_info_() {
   if (!this->is_connected() or !this->is_discovery_ip_enabled()) {
     return;
   }
-  // Format topic on stack to avoid heap allocation
-  // "esphome/discover/" (17) + name (ESPHOME_DEVICE_NAME_MAX_LEN) + null (1)
-  constexpr size_t topic_buffer_size = 17 + ESPHOME_DEVICE_NAME_MAX_LEN + 1;
-  char topic[topic_buffer_size];
-  buf_append_printf(topic, sizeof(topic), 0, "esphome/discover/%s", App.get_name().c_str());
+  std::string topic = "esphome/discover/";
+  topic.append(App.get_name());
 
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   this->publish_json(
@@ -413,12 +406,6 @@ void MQTTClientComponent::loop() {
 
         this->last_connected_ = now;
         this->resubscribe_subscriptions_();
-
-        // Process pending resends for all MQTT components centrally
-        // This is more efficient than each component polling in its own loop
-        for (MQTTComponent *component : this->children_) {
-          component->process_resend();
-        }
       }
       break;
   }
@@ -523,49 +510,39 @@ bool MQTTClientComponent::publish(const std::string &topic, const std::string &p
 
 bool MQTTClientComponent::publish(const std::string &topic, const char *payload, size_t payload_length, uint8_t qos,
                                   bool retain) {
-  return this->publish(topic.c_str(), payload, payload_length, qos, retain);
+  return publish({.topic = topic, .payload = std::string(payload, payload_length), .qos = qos, .retain = retain});
 }
 
 bool MQTTClientComponent::publish(const MQTTMessage &message) {
-  return this->publish(message.topic.c_str(), message.payload.c_str(), message.payload.length(), message.qos,
-                       message.retain);
-}
-bool MQTTClientComponent::publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos,
-                                       bool retain) {
-  return this->publish_json(topic.c_str(), f, qos, retain);
-}
-
-bool MQTTClientComponent::publish(const char *topic, const char *payload, size_t payload_length, uint8_t qos,
-                                  bool retain) {
   if (!this->is_connected()) {
+    // critical components will re-transmit their messages
     return false;
   }
-  size_t topic_len = strlen(topic);
-  bool logging_topic = (topic_len == this->log_message_.topic.size()) &&
-                       (memcmp(this->log_message_.topic.c_str(), topic, topic_len) == 0);
-  bool ret = this->mqtt_backend_.publish(topic, payload, payload_length, qos, retain);
+  bool logging_topic = this->log_message_.topic == message.topic;
+  bool ret = this->mqtt_backend_.publish(message);
   delay(0);
   if (!ret && !logging_topic && this->is_connected()) {
     delay(0);
-    ret = this->mqtt_backend_.publish(topic, payload, payload_length, qos, retain);
+    ret = this->mqtt_backend_.publish(message);
     delay(0);
   }
 
   if (!logging_topic) {
     if (ret) {
-      ESP_LOGV(TAG, "Publish(topic='%s' retain=%d qos=%d)", topic, retain, qos);
-      ESP_LOGVV(TAG, "Publish payload (len=%u): '%.*s'", payload_length, static_cast<int>(payload_length), payload);
+      ESP_LOGV(TAG, "Publish(topic='%s' payload='%s' retain=%d qos=%d)", message.topic.c_str(), message.payload.c_str(),
+               message.retain, message.qos);
     } else {
-      ESP_LOGV(TAG, "Publish failed for topic='%s' (len=%u). Will retry", topic, payload_length);
+      ESP_LOGV(TAG, "Publish failed for topic='%s' (len=%u). Will retry", message.topic.c_str(),
+               message.payload.length());
       this->status_momentary_warning("publish", 1000);
     }
   }
   return ret != 0;
 }
-
-bool MQTTClientComponent::publish_json(const char *topic, const json::json_build_t &f, uint8_t qos, bool retain) {
+bool MQTTClientComponent::publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos,
+                                       bool retain) {
   std::string message = json::build_json(f);
-  return this->publish(topic, message.c_str(), message.length(), qos, retain);
+  return this->publish(topic, message, qos, retain);
 }
 
 void MQTTClientComponent::enable() {
@@ -643,10 +620,18 @@ static bool topic_match(const char *message, const char *subscription) {
 }
 
 void MQTTClientComponent::on_message(const std::string &topic, const std::string &payload) {
-  for (auto &subscription : this->subscriptions_) {
-    if (topic_match(topic.c_str(), subscription.topic.c_str()))
-      subscription.callback(topic, payload);
-  }
+#ifdef USE_ESP8266
+  // on ESP8266, this is called in lwIP/AsyncTCP task; some components do not like running
+  // from a different task.
+  this->defer([this, topic, payload]() {
+#endif
+    for (auto &subscription : this->subscriptions_) {
+      if (topic_match(topic.c_str(), subscription.topic.c_str()))
+        subscription.callback(topic, payload);
+    }
+#ifdef USE_ESP8266
+  });
+#endif
 }
 
 // Setters

esphome/components/mqtt/mqtt_client.h

@@ -229,9 +229,6 @@ class MQTTClientComponent : public Component
   bool publish(const std::string &topic, const char *payload, size_t payload_length, uint8_t qos = 0,
                bool retain = false);
 
-  /// Publish directly without creating MQTTMessage (avoids heap allocation for topic)
-  bool publish(const char *topic, const char *payload, size_t payload_length, uint8_t qos = 0, bool retain = false);
-
   /** Construct and send a JSON MQTT message.
    *
    * @param topic The topic.
@@ -240,9 +237,6 @@ class MQTTClientComponent : public Component
    */
   bool publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos = 0, bool retain = false);
 
-  /// Publish JSON directly without heap allocation for topic
-  bool publish_json(const char *topic, const json::json_build_t &f, uint8_t qos = 0, bool retain = false);
-
   /// Setup the MQTT client, registering a bunch of callbacks and attempting to connect.
   void setup() override;
   void dump_config() override;

esphome/components/mqtt/mqtt_component.cpp

@@ -27,23 +27,20 @@ inline char *append_char(char *p, char c) {
 // Max lengths for stack-based topic building.
 // These limits are enforced at Python config validation time in mqtt/__init__.py
 // using cv.Length() validators for topic_prefix and discovery_prefix.
-// MQTT_COMPONENT_TYPE_MAX_LEN, MQTT_SUFFIX_MAX_LEN, and MQTT_DEFAULT_TOPIC_MAX_LEN are in mqtt_component.h.
+// MQTT_COMPONENT_TYPE_MAX_LEN and MQTT_SUFFIX_MAX_LEN are defined in mqtt_component.h.
 // ESPHOME_DEVICE_NAME_MAX_LEN and OBJECT_ID_MAX_LEN are defined in entity_base.h.
 // This ensures the stack buffers below are always large enough.
+static constexpr size_t TOPIC_PREFIX_MAX_LEN = 64;      // Validated in Python: cv.Length(max=64)
 static constexpr size_t DISCOVERY_PREFIX_MAX_LEN = 64;  // Validated in Python: cv.Length(max=64)
+
+// Stack buffer sizes - safe because all inputs are length-validated at config time
+// Format: prefix + "/" + type + "/" + object_id + "/" + suffix + null
+static constexpr size_t DEFAULT_TOPIC_MAX_LEN =
+    TOPIC_PREFIX_MAX_LEN + 1 + MQTT_COMPONENT_TYPE_MAX_LEN + 1 + OBJECT_ID_MAX_LEN + 1 + MQTT_SUFFIX_MAX_LEN + 1;
 // Format: prefix + "/" + type + "/" + name + "/" + object_id + "/config" + null
 static constexpr size_t DISCOVERY_TOPIC_MAX_LEN = DISCOVERY_PREFIX_MAX_LEN + 1 + MQTT_COMPONENT_TYPE_MAX_LEN + 1 +
                                                   ESPHOME_DEVICE_NAME_MAX_LEN + 1 + OBJECT_ID_MAX_LEN + 7 + 1;
 
-// Function implementation of LOG_MQTT_COMPONENT macro to reduce code size
-void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, bool command_topic) {
-  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (state_topic)
-    ESP_LOGCONFIG(tag, "  State Topic: '%s'", obj->get_state_topic_to_(buf).c_str());
-  if (command_topic)
-    ESP_LOGCONFIG(tag, "  Command Topic: '%s'", obj->get_command_topic_to_(buf).c_str());
-}
-
 void MQTTComponent::set_qos(uint8_t qos) { this->qos_ = qos; }
 
 void MQTTComponent::set_subscribe_qos(uint8_t qos) { this->subscribe_qos_ = qos; }
@@ -72,18 +69,19 @@ std::string MQTTComponent::get_discovery_topic_(const MQTTDiscoveryInfo &discove
   return std::string(buf, p - buf);
 }
 
-StringRef MQTTComponent::get_default_topic_for_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf, const char *suffix,
-                                                   size_t suffix_len) const {
+std::string MQTTComponent::get_default_topic_for_(const std::string &suffix) const {
   const std::string &topic_prefix = global_mqtt_client->get_topic_prefix();
   if (topic_prefix.empty()) {
-    return StringRef();  // Empty topic_prefix means no default topic
+    // If the topic_prefix is null, the default topic should be null
+    return "";
   }
 
   const char *comp_type = this->component_type();
   char object_id_buf[OBJECT_ID_MAX_LEN];
   StringRef object_id = this->get_default_object_id_to_(object_id_buf);
 
-  char *p = buf.data();
+  char buf[DEFAULT_TOPIC_MAX_LEN];
+  char *p = buf;
 
   p = append_str(p, topic_prefix.data(), topic_prefix.size());
   p = append_char(p, '/');
@@ -91,44 +89,21 @@ StringRef MQTTComponent::get_default_topic_for_to_(std::span<char, MQTT_DEFAULT_
   p = append_char(p, '/');
   p = append_str(p, object_id.c_str(), object_id.size());
   p = append_char(p, '/');
-  p = append_str(p, suffix, suffix_len);
-  *p = '\0';
+  p = append_str(p, suffix.data(), suffix.size());
 
-  return StringRef(buf.data(), p - buf.data());
-}
-
-std::string MQTTComponent::get_default_topic_for_(const std::string &suffix) const {
-  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  StringRef ref = this->get_default_topic_for_to_(buf, suffix.data(), suffix.size());
-  return std::string(ref.c_str(), ref.size());
-}
-
-StringRef MQTTComponent::get_state_topic_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const {
-  if (this->custom_state_topic_.has_value()) {
-    // Returns ref to existing data for static/value, uses buf only for lambda case
-    return this->custom_state_topic_.ref_or_copy_to(buf.data(), buf.size());
-  }
-  return this->get_default_topic_for_to_(buf, "state", 5);
-}
-
-StringRef MQTTComponent::get_command_topic_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const {
-  if (this->custom_command_topic_.has_value()) {
-    // Returns ref to existing data for static/value, uses buf only for lambda case
-    return this->custom_command_topic_.ref_or_copy_to(buf.data(), buf.size());
-  }
-  return this->get_default_topic_for_to_(buf, "command", 7);
+  return std::string(buf, p - buf);
 }
 
 std::string MQTTComponent::get_state_topic_() const {
-  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  StringRef ref = this->get_state_topic_to_(buf);
-  return std::string(ref.c_str(), ref.size());
+  if (this->custom_state_topic_.has_value())
+    return this->custom_state_topic_.value();
+  return this->get_default_topic_for_("state");
 }
 
 std::string MQTTComponent::get_command_topic_() const {
-  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  StringRef ref = this->get_command_topic_to_(buf);
-  return std::string(ref.c_str(), ref.size());
+  if (this->custom_command_topic_.has_value())
+    return this->custom_command_topic_.value();
+  return this->get_default_topic_for_("command");
 }
 
 bool MQTTComponent::publish(const std::string &topic, const std::string &payload) {
@@ -193,14 +168,10 @@ bool MQTTComponent::send_discovery_() {
             break;
         }
 
-        if (config.state_topic) {
-          char state_topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-          root[MQTT_STATE_TOPIC] = this->get_state_topic_to_(state_topic_buf);
-        }
-        if (config.command_topic) {
-          char command_topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-          root[MQTT_COMMAND_TOPIC] = this->get_command_topic_to_(command_topic_buf);
-        }
+        if (config.state_topic)
+          root[MQTT_STATE_TOPIC] = this->get_state_topic_();
+        if (config.command_topic)
+          root[MQTT_COMMAND_TOPIC] = this->get_command_topic_();
         if (this->command_retain_)
           root[MQTT_COMMAND_RETAIN] = true;
 
@@ -338,9 +309,7 @@ void MQTTComponent::set_availability(std::string topic, std::string payload_avai
 }
 void MQTTComponent::disable_availability() { this->set_availability("", "", ""); }
 void MQTTComponent::call_setup() {
-  // Cache is_internal result once during setup - topics don't change after this
-  this->is_internal_ = this->compute_is_internal_();
-  if (this->is_internal_)
+  if (this->is_internal())
     return;
 
   this->setup();
@@ -360,12 +329,16 @@ void MQTTComponent::call_setup() {
   }
 }
 
-void MQTTComponent::process_resend() {
-  // Called by MQTTClientComponent when connected to process pending resends
-  // Note: is_internal() check not needed - internal components are never registered
-  if (!this->resend_state_)
+void MQTTComponent::call_loop() {
+  if (this->is_internal())
     return;
 
+  this->loop();
+
+  if (!this->resend_state_ || !this->is_connected_()) {
+    return;
+  }
+
   this->resend_state_ = false;
   if (this->is_discovery_enabled()) {
     if (!this->send_discovery_()) {
@@ -392,28 +365,26 @@ StringRef MQTTComponent::get_default_object_id_to_(std::span<char, OBJECT_ID_MAX
 }
 StringRef MQTTComponent::get_icon_ref_() const { return this->get_entity()->get_icon_ref(); }
 bool MQTTComponent::is_disabled_by_default_() const { return this->get_entity()->is_disabled_by_default(); }
-bool MQTTComponent::compute_is_internal_() {
+bool MQTTComponent::is_internal() {
   if (this->custom_state_topic_.has_value()) {
-    // If the custom state_topic is empty, return true as it is internal and should not publish
+    // If the custom state_topic is null, return true as it is internal and should not publish
     // else, return false, as it is explicitly set to a topic, so it is not internal and should publish
-    // Using is_empty() avoids heap allocation for non-lambda cases
-    return this->custom_state_topic_.is_empty();
+    return this->get_state_topic_().empty();
   }
 
   if (this->custom_command_topic_.has_value()) {
-    // If the custom command_topic is empty, return true as it is internal and should not publish
+    // If the custom command_topic is null, return true as it is internal and should not publish
     // else, return false, as it is explicitly set to a topic, so it is not internal and should publish
-    // Using is_empty() avoids heap allocation for non-lambda cases
-    return this->custom_command_topic_.is_empty();
+    return this->get_command_topic_().empty();
   }
 
-  // No custom topics have been set - check topic_prefix directly to avoid allocation
-  if (global_mqtt_client->get_topic_prefix().empty()) {
-    // If the default topic prefix is empty, then the component, by default, is internal and should not publish
+  // No custom topics have been set
+  if (this->get_default_topic_for_("").empty()) {
+    // If the default topic prefix is null, then the component, by default, is internal and should not publish
     return true;
   }
 
-  // Use ESPHome's component internal state if topic_prefix is not empty with no custom state_topic or command_topic
+  // Use ESPHome's component internal state if topic_prefix is not null with no custom state_topic or command_topic
   return this->get_entity()->is_internal();
 }
 

esphome/components/mqtt/mqtt_component.h

@@ -20,22 +20,17 @@ struct SendDiscoveryConfig {
   bool command_topic{true};  ///< If the command topic should be included. Default to true.
 };
 
-// Max lengths for stack-based topic building.
-// These limits are enforced at Python config validation time in mqtt/__init__.py
-// using cv.Length() validators for topic_prefix and discovery_prefix.
-// This ensures the stack buffers are always large enough.
+// Max lengths for stack-based topic building (must match mqtt_component.cpp)
 static constexpr size_t MQTT_COMPONENT_TYPE_MAX_LEN = 20;
 static constexpr size_t MQTT_SUFFIX_MAX_LEN = 32;
-static constexpr size_t MQTT_TOPIC_PREFIX_MAX_LEN = 64;  // Validated in Python: cv.Length(max=64)
-// Stack buffer size - safe because all inputs are length-validated at config time
-// Format: prefix + "/" + type + "/" + object_id + "/" + suffix + null
-static constexpr size_t MQTT_DEFAULT_TOPIC_MAX_LEN =
-    MQTT_TOPIC_PREFIX_MAX_LEN + 1 + MQTT_COMPONENT_TYPE_MAX_LEN + 1 + OBJECT_ID_MAX_LEN + 1 + MQTT_SUFFIX_MAX_LEN + 1;
 
-class MQTTComponent;  // Forward declaration
-void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, bool command_topic);
-
-#define LOG_MQTT_COMPONENT(state_topic, command_topic) log_mqtt_component(TAG, this, state_topic, command_topic)
+#define LOG_MQTT_COMPONENT(state_topic, command_topic) \
+  if (state_topic) { \
+    ESP_LOGCONFIG(TAG, "  State Topic: '%s'", this->get_state_topic_().c_str()); \
+  } \
+  if (command_topic) { \
+    ESP_LOGCONFIG(TAG, "  Command Topic: '%s'", this->get_command_topic_().c_str()); \
+  }
 
 // Macro to define component_type() with compile-time length verification
 // Usage: MQTT_COMPONENT_TYPE(MQTTSensorComponent, "sensor")
@@ -79,8 +74,6 @@ void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, b
  * a clean separation.
  */
 class MQTTComponent : public Component {
-  friend void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, bool command_topic);
-
  public:
   /// Constructs a MQTTComponent.
   explicit MQTTComponent();
@@ -88,6 +81,8 @@ class MQTTComponent : public Component {
   /// Override setup_ so that we can call send_discovery() when needed.
   void call_setup() override;
 
+  void call_loop() override;
+
   void call_dump_config() override;
 
   /// Send discovery info the Home Assistant, override this.
@@ -95,8 +90,7 @@ class MQTTComponent : public Component {
 
   virtual bool send_initial_state() = 0;
 
-  /// Returns cached is_internal result (computed once during setup).
-  bool is_internal() const { return this->is_internal_; }
+  virtual bool is_internal();
 
   /// Set QOS for state messages.
   void set_qos(uint8_t qos);
@@ -139,9 +133,6 @@ class MQTTComponent : public Component {
   /// Internal method for the MQTT client base to schedule a resend of the state on reconnect.
   void schedule_resend_state();
 
-  /// Process pending resend if needed (called by MQTTClientComponent)
-  void process_resend();
-
   /** Send a MQTT message.
    *
    * @param topic The topic.
@@ -187,16 +178,7 @@ class MQTTComponent : public Component {
   /// Helper method to get the discovery topic for this component.
   std::string get_discovery_topic_(const MQTTDiscoveryInfo &discovery_info) const;
 
-  /** Get this components state/command/... topic into a buffer.
-   *
-   * @param buf The buffer to write to (must be exactly MQTT_DEFAULT_TOPIC_MAX_LEN).
-   * @param suffix The suffix/key such as "state" or "command".
-   * @return StringRef pointing to the buffer with the topic.
-   */
-  StringRef get_default_topic_for_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf, const char *suffix,
-                                      size_t suffix_len) const;
-
-  /** Get this components state/command/... topic (allocates std::string).
+  /** Get this components state/command/... topic.
    *
    * @param suffix The suffix/key such as "state" or "command".
    * @return The full topic.
@@ -217,20 +199,10 @@ class MQTTComponent : public Component {
   /// Get whether the underlying Entity is disabled by default
   bool is_disabled_by_default_() const;
 
-  /// Get the MQTT state topic into a buffer (no heap allocation for non-lambda custom topics).
-  /// @param buf Buffer of exactly MQTT_DEFAULT_TOPIC_MAX_LEN bytes.
-  /// @return StringRef pointing to the topic in the buffer.
-  StringRef get_state_topic_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const;
-
-  /// Get the MQTT command topic into a buffer (no heap allocation for non-lambda custom topics).
-  /// @param buf Buffer of exactly MQTT_DEFAULT_TOPIC_MAX_LEN bytes.
-  /// @return StringRef pointing to the topic in the buffer.
-  StringRef get_command_topic_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const;
-
-  /// Get the MQTT topic that new states will be shared to (allocates std::string).
+  /// Get the MQTT topic that new states will be shared to.
   std::string get_state_topic_() const;
 
-  /// Get the MQTT topic for listening to commands (allocates std::string).
+  /// Get the MQTT topic for listening to commands.
   std::string get_command_topic_() const;
 
   bool is_connected_() const;
@@ -248,18 +220,12 @@ class MQTTComponent : public Component {
 
   std::unique_ptr<Availability> availability_;
 
-  // Packed bitfields - QoS values are 0-2, bools are flags
-  uint8_t qos_ : 2 {0};
-  uint8_t subscribe_qos_ : 2 {0};
-  bool command_retain_ : 1 {false};
-  bool retain_ : 1 {true};
-  bool discovery_enabled_ : 1 {true};
-  bool resend_state_ : 1 {false};
-  bool is_internal_ : 1 {false};  ///< Cached result of compute_is_internal_(), set during setup
-
-  /// Compute is_internal status based on topics and entity state.
-  /// Called once during setup to cache the result.
-  bool compute_is_internal_();
+  bool command_retain_{false};
+  bool retain_{true};
+  uint8_t qos_{0};
+  uint8_t subscribe_qos_{0};
+  bool discovery_enabled_{true};
+  bool resend_state_{false};
 };
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_cover.cpp

@@ -51,7 +51,7 @@ void MQTTCoverComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT cover '%s':", this->cover_->get_name().c_str());
   auto traits = this->cover_->get_traits();
   bool has_command_topic = traits.get_supports_position() || !traits.get_supports_tilt();
-  LOG_MQTT_COMPONENT(true, has_command_topic);
+  LOG_MQTT_COMPONENT(true, has_command_topic)
   if (traits.get_supports_position()) {
     ESP_LOGCONFIG(TAG,
                   "  Position State Topic: '%s'\n"

esphome/components/mqtt/mqtt_date.cpp

@@ -36,7 +36,7 @@ void MQTTDateComponent::setup() {
 
 void MQTTDateComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Date '%s':", this->date_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true);
+  LOG_MQTT_COMPONENT(true, true)
 }
 
 MQTT_COMPONENT_TYPE(MQTTDateComponent, "date")

esphome/components/mqtt/mqtt_datetime.cpp

@@ -47,7 +47,7 @@ void MQTTDateTimeComponent::setup() {
 
 void MQTTDateTimeComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT DateTime '%s':", this->datetime_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true);
+  LOG_MQTT_COMPONENT(true, true)
 }
 
 MQTT_COMPONENT_TYPE(MQTTDateTimeComponent, "datetime")

esphome/components/mqtt/mqtt_light.cpp

@@ -90,7 +90,7 @@ void MQTTJSONLightComponent::send_discovery(JsonObject root, mqtt::SendDiscovery
 bool MQTTJSONLightComponent::send_initial_state() { return this->publish_state_(); }
 void MQTTJSONLightComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Light '%s':", this->state_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true);
+  LOG_MQTT_COMPONENT(true, true)
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_number.cpp

@@ -30,7 +30,7 @@ void MQTTNumberComponent::setup() {
 
 void MQTTNumberComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Number '%s':", this->number_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, false);
+  LOG_MQTT_COMPONENT(true, false)
 }
 
 MQTT_COMPONENT_TYPE(MQTTNumberComponent, "number")

esphome/components/mqtt/mqtt_select.cpp

@@ -25,7 +25,7 @@ void MQTTSelectComponent::setup() {
 
 void MQTTSelectComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Select '%s':", this->select_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, false);
+  LOG_MQTT_COMPONENT(true, false)
 }
 
 MQTT_COMPONENT_TYPE(MQTTSelectComponent, "select")

esphome/components/mqtt/mqtt_sensor.cpp

@@ -28,7 +28,7 @@ void MQTTSensorComponent::dump_config() {
   if (this->get_expire_after() > 0) {
     ESP_LOGCONFIG(TAG, "  Expire After: %" PRIu32 "s", this->get_expire_after() / 1000);
   }
-  LOG_MQTT_COMPONENT(true, false);
+  LOG_MQTT_COMPONENT(true, false)
 }
 
 MQTT_COMPONENT_TYPE(MQTTSensorComponent, "sensor")

esphome/components/mqtt/mqtt_text.cpp

@@ -26,7 +26,7 @@ void MQTTTextComponent::setup() {
 
 void MQTTTextComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT text '%s':", this->text_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true);
+  LOG_MQTT_COMPONENT(true, true)
 }
 
 MQTT_COMPONENT_TYPE(MQTTTextComponent, "text")

esphome/components/mqtt/mqtt_time.cpp

@@ -36,7 +36,7 @@ void MQTTTimeComponent::setup() {
 
 void MQTTTimeComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Time '%s':", this->time_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true);
+  LOG_MQTT_COMPONENT(true, true)
 }
 
 MQTT_COMPONENT_TYPE(MQTTTimeComponent, "time")

esphome/components/mqtt/mqtt_valve.cpp

@@ -39,7 +39,7 @@ void MQTTValveComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT valve '%s':", this->valve_->get_name().c_str());
   auto traits = this->valve_->get_traits();
   bool has_command_topic = traits.get_supports_position();
-  LOG_MQTT_COMPONENT(true, has_command_topic);
+  LOG_MQTT_COMPONENT(true, has_command_topic)
   if (traits.get_supports_position()) {
     ESP_LOGCONFIG(TAG,
                   "  Position State Topic: '%s'\n"

esphome/components/pipsolar/output/pipsolar_output.cpp

@@ -8,12 +8,12 @@ namespace pipsolar {
 static const char *const TAG = "pipsolar.output";
 
 void PipsolarOutput::write_state(float state) {
-  char tmp[16];
+  char tmp[10];
   snprintf(tmp, sizeof(tmp), this->set_command_, state);
 
   if (std::find(this->possible_values_.begin(), this->possible_values_.end(), state) != this->possible_values_.end()) {
     ESP_LOGD(TAG, "Will write: %s out of value %f / %02.0f", tmp, state, state);
-    this->parent_->queue_command(std::string(tmp));
+    this->parent_->queue_command(tmp);
   } else {
     ESP_LOGD(TAG, "Will not write: %s as it is not in list of allowed values", tmp);
   }

esphome/components/pipsolar/pipsolar.cpp

@@ -45,20 +45,20 @@ void Pipsolar::loop() {
         } else {
           ESP_LOGD(TAG, "command not successful");
         }
-        this->command_queue_[this->command_queue_position_] = std::string("");
+        this->command_queue_[this->command_queue_position_].clear();
         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_[this->command_queue_position_].clear();
         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",
                this->command_queue_[this->command_queue_position_].c_str(), this->read_pos_);
-      this->command_queue_[this->command_queue_position_] = std::string("");
+      this->command_queue_[this->command_queue_position_].clear();
       this->command_queue_position_ = (command_queue_position_ + 1) % COMMAND_QUEUE_LENGTH;
       this->state_ = STATE_IDLE;
     }
@@ -127,7 +127,7 @@ void Pipsolar::loop() {
       const char *command = this->command_queue_[this->command_queue_position_].c_str();
       this->command_start_millis_ = millis();
       ESP_LOGD(TAG, "command %s timeout", command);
-      this->command_queue_[this->command_queue_position_] = std::string("");
+      this->command_queue_[this->command_queue_position_].clear();
       this->command_queue_position_ = (command_queue_position_ + 1) % COMMAND_QUEUE_LENGTH;
       this->state_ = STATE_IDLE;
       return;
@@ -722,7 +722,7 @@ void Pipsolar::publish_binary_sensor_(esphome::optional<bool> b, binary_sensor::
   }
 }
 
-esphome::optional<bool> Pipsolar::get_bit_(std::string bits, uint8_t bit_pos) {
+esphome::optional<bool> Pipsolar::get_bit_(const std::string &bits, uint8_t bit_pos) {
   if (bit_pos >= bits.length()) {
     return {};
   }

esphome/components/pipsolar/pipsolar.h

@@ -224,7 +224,7 @@ class Pipsolar : public uart::UARTDevice, public PollingComponent {
 
   void publish_binary_sensor_(esphome::optional<bool> b, binary_sensor::BinarySensor *sensor);
 
-  esphome::optional<bool> get_bit_(std::string bits, uint8_t bit_pos);
+  esphome::optional<bool> get_bit_(const std::string &bits, uint8_t bit_pos);
 
   std::string command_queue_[COMMAND_QUEUE_LENGTH];
   uint8_t command_queue_position_ = 0;

esphome/components/sim800l/sim800l.cpp

@@ -51,7 +51,7 @@ void Sim800LComponent::update() {
   } else if (state_ == STATE_RECEIVED_SMS) {
     // Serial Buffer should have flushed.
     // Send cmd to delete received sms
-    char delete_cmd[20];  // "AT+CMGD=" (8) + uint8_t (max 3) + null = 12 <= 20
+    char delete_cmd[20];  // "AT+CMGD=" (8) + int (max 11) + null = 20
     buf_append_printf(delete_cmd, sizeof(delete_cmd), 0, "AT+CMGD=%d", this->parse_index_);
     this->send_cmd_(delete_cmd);
     this->state_ = STATE_CHECK_SMS;

esphome/components/sml/sml_parser.cpp

@@ -106,7 +106,7 @@ std::string bytes_repr(const BytesView &buffer) {
   for (auto const value : buffer) {
     // max 3: 2 hex digits + null
     char hex_buf[3];
-    snprintf(hex_buf, sizeof(hex_buf), "%02x", static_cast<unsigned int>(value));
+    snprintf(hex_buf, sizeof(hex_buf), "%02x", value & 0xff);
     repr += hex_buf;
   }
   return repr;

esphome/components/status/binary_sensor.py

@@ -7,14 +7,14 @@ DEPENDENCIES = ["network"]
 
 status_ns = cg.esphome_ns.namespace("status")
 StatusBinarySensor = status_ns.class_(
-    "StatusBinarySensor", binary_sensor.BinarySensor, cg.PollingComponent
+    "StatusBinarySensor", binary_sensor.BinarySensor, cg.Component
 )
 
 CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(
     StatusBinarySensor,
     device_class=DEVICE_CLASS_CONNECTIVITY,
     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-).extend(cv.polling_component_schema("1s"))
+).extend(cv.COMPONENT_SCHEMA)
 
 
 async def to_code(config):

esphome/components/status/status_binary_sensor.cpp

@@ -10,11 +10,12 @@
 #include "esphome/components/api/api_server.h"
 #endif
 
-namespace esphome::status {
+namespace esphome {
+namespace status {
 
 static const char *const TAG = "status";
 
-void StatusBinarySensor::update() {
+void StatusBinarySensor::loop() {
   bool status = network::is_connected();
 #ifdef USE_MQTT
   if (mqtt::global_mqtt_client != nullptr) {
@@ -32,4 +33,5 @@ void StatusBinarySensor::update() {
 void StatusBinarySensor::setup() { this->publish_initial_state(false); }
 void StatusBinarySensor::dump_config() { LOG_BINARY_SENSOR("", "Status Binary Sensor", this); }
 
-}  // namespace esphome::status
+}  // namespace status
+}  // namespace esphome

esphome/components/status/status_binary_sensor.h

@@ -3,11 +3,12 @@
 #include "esphome/core/component.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
-namespace esphome::status {
+namespace esphome {
+namespace status {
 
-class StatusBinarySensor : public binary_sensor::BinarySensor, public PollingComponent {
+class StatusBinarySensor : public binary_sensor::BinarySensor, public Component {
  public:
-  void update() override;
+  void loop() override;
 
   void setup() override;
   void dump_config() override;
@@ -15,4 +16,5 @@ class StatusBinarySensor : public binary_sensor::BinarySensor, public PollingCom
   bool is_status_binary_sensor() const override { return true; }
 };
 
-}  // namespace esphome::status
+}  // namespace status
+}  // namespace esphome

esphome/components/teleinfo/sensor/teleinfo_sensor.cpp

@@ -4,8 +4,7 @@ namespace esphome {
 namespace teleinfo {
 
 static const char *const TAG = "teleinfo_sensor";
-TeleInfoSensor::TeleInfoSensor(const char *tag) { this->tag = std::string(tag); }
-void TeleInfoSensor::publish_val(const std::string &val) {
+void TeleInfoSensor::publish_val(const char *val) {
   auto newval = parse_number<float>(val).value_or(0.0f);
   publish_state(newval);
 }

esphome/components/teleinfo/sensor/teleinfo_sensor.h

@@ -7,8 +7,8 @@ namespace teleinfo {
 
 class TeleInfoSensor : public TeleInfoListener, public sensor::Sensor, public Component {
  public:
-  TeleInfoSensor(const char *tag);
-  void publish_val(const std::string &val) override;
+  TeleInfoSensor(const char *tag) { this->tag = tag; }
+  void publish_val(const char *val) override;
   void dump_config() override;
 };
 

esphome/components/teleinfo/teleinfo.cpp

@@ -172,15 +172,15 @@ void TeleInfo::loop() {
         /* Advance buf_finger to end of group */
         buf_finger += field_len + 1 + 1 + 1;
 
-        publish_value_(std::string(tag_), std::string(val_));
+        publish_value_(tag_, val_);
       }
       state_ = OFF;
       break;
   }
 }
-void TeleInfo::publish_value_(const std::string &tag, const std::string &val) {
+void TeleInfo::publish_value_(const char *tag, const char *val) {
   for (auto *element : teleinfo_listeners_) {
-    if (tag != element->tag)
+    if (strcmp(tag, element->tag) != 0)
       continue;
     element->publish_val(val);
   }

esphome/components/teleinfo/teleinfo.h

@@ -18,8 +18,8 @@ static const uint16_t MAX_TIMESTAMP_SIZE = 14;
 
 class TeleInfoListener {
  public:
-  std::string tag;
-  virtual void publish_val(const std::string &val){};
+  const char *tag{nullptr};
+  virtual void publish_val(const char *val){};
 };
 class TeleInfo : public PollingComponent, public uart::UARTDevice {
  public:
@@ -48,7 +48,7 @@ class TeleInfo : public PollingComponent, public uart::UARTDevice {
   } state_{OFF};
   bool read_chars_until_(bool drop, uint8_t c);
   bool check_crc_(const char *grp, const char *grp_end);
-  void publish_value_(const std::string &tag, const std::string &val);
+  void publish_value_(const char *tag, const char *val);
 };
 }  // namespace teleinfo
 }  // namespace esphome

esphome/components/teleinfo/text_sensor/teleinfo_text_sensor.cpp

@@ -4,8 +4,7 @@ namespace esphome {
 namespace teleinfo {
 
 static const char *const TAG = "teleinfo_text_sensor";
-TeleInfoTextSensor::TeleInfoTextSensor(const char *tag) { this->tag = std::string(tag); }
-void TeleInfoTextSensor::publish_val(const std::string &val) { publish_state(val); }
+void TeleInfoTextSensor::publish_val(const char *val) { publish_state(val); }
 void TeleInfoTextSensor::dump_config() { LOG_TEXT_SENSOR("  ", "Teleinfo Text Sensor", this); }
 }  // namespace teleinfo
 }  // namespace esphome

esphome/components/teleinfo/text_sensor/teleinfo_text_sensor.h

@@ -5,8 +5,8 @@ namespace esphome {
 namespace teleinfo {
 class TeleInfoTextSensor : public TeleInfoListener, public text_sensor::TextSensor, public Component {
  public:
-  TeleInfoTextSensor(const char *tag);
-  void publish_val(const std::string &val) override;
+  TeleInfoTextSensor(const char *tag) { this->tag = tag; }
+  void publish_val(const char *val) override;
   void dump_config() override;
 };
 }  // namespace teleinfo

esphome/components/tuya/text_sensor/tuya_text_sensor.cpp

@@ -24,7 +24,7 @@ void TuyaTextSensor::setup() {
       }
       case TuyaDatapointType::ENUM: {
         char buf[4];  // uint8_t max is 3 digits + null
-        buf_append_printf(buf, sizeof(buf), 0, "%u", datapoint.value_enum);
+        snprintf(buf, sizeof(buf), "%u", datapoint.value_enum);
         ESP_LOGD(TAG, "MCU reported text sensor %u is: %s", datapoint.id, buf);
         this->publish_state(buf);
         break;

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -920,16 +920,7 @@ bssid_t WiFiComponent::wifi_bssid() {
   }
   return bssid;
 }
-std::string WiFiComponent::wifi_ssid() {
-  struct station_config conf {};
-  if (!wifi_station_get_config(&conf)) {
-    return "";
-  }
-  // conf.ssid is uint8[32], not null-terminated if full
-  auto *ssid_s = reinterpret_cast<const char *>(conf.ssid);
-  size_t len = strnlen(ssid_s, sizeof(conf.ssid));
-  return {ssid_s, len};
-}
+std::string WiFiComponent::wifi_ssid() { return WiFi.SSID().c_str(); }
 const char *WiFiComponent::wifi_ssid_to(std::span<char, SSID_BUFFER_SIZE> buffer) {
   struct station_config conf {};
   if (!wifi_station_get_config(&conf)) {
@@ -943,24 +934,16 @@ const char *WiFiComponent::wifi_ssid_to(std::span<char, SSID_BUFFER_SIZE> buffer
   return buffer.data();
 }
 int8_t WiFiComponent::wifi_rssi() {
-  if (wifi_station_get_connect_status() != STATION_GOT_IP)
+  if (WiFi.status() != WL_CONNECTED)
     return WIFI_RSSI_DISCONNECTED;
-  sint8 rssi = wifi_station_get_rssi();
+  int8_t rssi = WiFi.RSSI();
   // Values >= 31 are error codes per NONOS SDK API, not valid RSSI readings
   return rssi >= 31 ? WIFI_RSSI_DISCONNECTED : rssi;
 }
-int32_t WiFiComponent::get_wifi_channel() { return wifi_get_channel(); }
-network::IPAddress WiFiComponent::wifi_subnet_mask_() {
-  struct ip_info ip {};
-  wifi_get_ip_info(STATION_IF, &ip);
-  return network::IPAddress(&ip.netmask);
-}
-network::IPAddress WiFiComponent::wifi_gateway_ip_() {
-  struct ip_info ip {};
-  wifi_get_ip_info(STATION_IF, &ip);
-  return network::IPAddress(&ip.gw);
-}
-network::IPAddress WiFiComponent::wifi_dns_ip_(int num) { return network::IPAddress(dns_getserver(num)); }
+int32_t WiFiComponent::get_wifi_channel() { return WiFi.channel(); }
+network::IPAddress WiFiComponent::wifi_subnet_mask_() { return {(const ip_addr_t *) WiFi.subnetMask()}; }
+network::IPAddress WiFiComponent::wifi_gateway_ip_() { return {(const ip_addr_t *) WiFi.gatewayIP()}; }
+network::IPAddress WiFiComponent::wifi_dns_ip_(int num) { return {(const ip_addr_t *) WiFi.dnsIP(num)}; }
 void WiFiComponent::wifi_loop_() {}
 
 }  // namespace esphome::wifi

esphome/components/wifi/wifi_component_libretiny.cpp

@@ -660,27 +660,21 @@ void WiFiComponent::wifi_scan_done_callback_() {
   this->scan_result_.clear();
   this->scan_done_ = true;
 
-  // Access scan data directly to avoid String allocation from WiFi.SSID(i)
-  // WiFi.scan is public in LibreTiny (WiFi.h)
-  if (WiFi.scan == nullptr || WiFi.scan->running)
+  int16_t num = WiFi.scanComplete();
+  if (num < 0)
     return;
 
-  uint8_t num = WiFi.scan->count;
-  if (num == 0) {
-    WiFi.scanDelete();
-    return;
-  }
+  this->scan_result_.init(static_cast<unsigned int>(num));
+  for (int i = 0; i < num; i++) {
+    String ssid = WiFi.SSID(i);
+    wifi_auth_mode_t authmode = WiFi.encryptionType(i);
+    int32_t rssi = WiFi.RSSI(i);
+    uint8_t *bssid = WiFi.BSSID(i);
+    int32_t channel = WiFi.channel(i);
 
-  this->scan_result_.init(num);
-  for (uint8_t i = 0; i < num; i++) {
-    const auto &ap = WiFi.scan->ap[i];
-    const char *ssid_cstr = ap.ssid;
-    size_t ssid_len = ssid_cstr ? strlen(ssid_cstr) : 0;
-
-    this->scan_result_.emplace_back(bssid_t{ap.bssid.addr[0], ap.bssid.addr[1], ap.bssid.addr[2], ap.bssid.addr[3],
-                                            ap.bssid.addr[4], ap.bssid.addr[5]},
-                                    std::string(ssid_cstr ? ssid_cstr : "", ssid_len), ap.channel, ap.rssi,
-                                    ap.auth != WIFI_AUTH_OPEN, ssid_len == 0);
+    this->scan_result_.emplace_back(bssid_t{bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]},
+                                    std::string(ssid.c_str()), channel, rssi, authmode != WIFI_AUTH_OPEN,
+                                    ssid.length() == 0);
   }
   WiFi.scanDelete();
 #ifdef USE_WIFI_SCAN_RESULTS_LISTENERS

esphome/core/automation.h

@@ -4,7 +4,6 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
-#include "esphome/core/string_ref.h"
 #include <concepts>
 #include <functional>
 #include <utility>
@@ -191,55 +190,15 @@ template<typename T, typename... X> class TemplatableValue {
   /// Get the static string pointer (only valid if is_static_string() returns true)
   const char *get_static_string() const { return this->static_str_; }
 
-  /// Check if the string value is empty without allocating (for std::string specialization).
-  /// For NONE, returns true. For STATIC_STRING/VALUE, checks without allocation.
-  /// For LAMBDA/STATELESS_LAMBDA, must call value() which may allocate.
-  bool is_empty() const requires std::same_as<T, std::string> {
-    switch (this->type_) {
-      case NONE:
-        return true;
-      case STATIC_STRING:
-        return this->static_str_ == nullptr || this->static_str_[0] == '\0';
-      case VALUE:
-        return this->value_->empty();
-      default:  // LAMBDA/STATELESS_LAMBDA - must call value()
-        return this->value().empty();
-    }
-  }
+ protected:
+  enum : uint8_t {
+    NONE,
+    VALUE,
+    LAMBDA,
+    STATELESS_LAMBDA,
+    STATIC_STRING,  // For const char* when T is std::string - avoids heap allocation
+  } type_;
 
-  /// Get a StringRef to the string value without heap allocation when possible.
-  /// For STATIC_STRING/VALUE, returns reference to existing data (no allocation).
-  /// For LAMBDA/STATELESS_LAMBDA, calls value(), copies to provided buffer, returns ref to buffer.
-  /// @param lambda_buf Buffer used only for lambda case (must remain valid while StringRef is used).
-  /// @param lambda_buf_size Size of the buffer.
-  /// @return StringRef pointing to the string data.
-  StringRef ref_or_copy_to(char *lambda_buf, size_t lambda_buf_size) const requires std::same_as<T, std::string> {
-    switch (this->type_) {
-      case NONE:
-        return StringRef();
-      case STATIC_STRING:
-        if (this->static_str_ == nullptr)
-          return StringRef();
-        return StringRef(this->static_str_, strlen(this->static_str_));
-      case VALUE:
-        return StringRef(this->value_->data(), this->value_->size());
-      default: {  // LAMBDA/STATELESS_LAMBDA - must call value() and copy
-        std::string result = this->value();
-        size_t copy_len = std::min(result.size(), lambda_buf_size - 1);
-        memcpy(lambda_buf, result.data(), copy_len);
-        lambda_buf[copy_len] = '\0';
-        return StringRef(lambda_buf, copy_len);
-      }
-    }
-  }
-
- protected : enum : uint8_t {
-   NONE,
-   VALUE,
-   LAMBDA,
-   STATELESS_LAMBDA,
-   STATIC_STRING,  // For const char* when T is std::string - avoids heap allocation
- } type_;
   // For std::string, use heap pointer to minimize union size (4 bytes vs 12+).
   // For other types, store value inline as before.
   using ValueStorage = std::conditional_t<USE_HEAP_STORAGE, T *, T>;

esphome/core/helpers.h

@@ -441,35 +441,6 @@ template<typename T> class FixedVector {
   const T *end() const { return data_ + size_; }
 };
 
-/// @brief Helper class for efficient buffer allocation - uses stack for small sizes, heap for large
-/// This is useful when most operations need a small buffer but occasionally need larger ones.
-/// The stack buffer avoids heap allocation in the common case, while heap fallback handles edge cases.
-template<size_t STACK_SIZE> class SmallBufferWithHeapFallback {
- public:
-  explicit SmallBufferWithHeapFallback(size_t size) {
-    if (size <= STACK_SIZE) {
-      this->buffer_ = this->stack_buffer_;
-    } else {
-      this->heap_buffer_ = new uint8_t[size];
-      this->buffer_ = this->heap_buffer_;
-    }
-  }
-  ~SmallBufferWithHeapFallback() { delete[] this->heap_buffer_; }
-
-  // Delete copy and move operations to prevent double-delete
-  SmallBufferWithHeapFallback(const SmallBufferWithHeapFallback &) = delete;
-  SmallBufferWithHeapFallback &operator=(const SmallBufferWithHeapFallback &) = delete;
-  SmallBufferWithHeapFallback(SmallBufferWithHeapFallback &&) = delete;
-  SmallBufferWithHeapFallback &operator=(SmallBufferWithHeapFallback &&) = delete;
-
-  uint8_t *get() { return this->buffer_; }
-
- private:
-  uint8_t stack_buffer_[STACK_SIZE];
-  uint8_t *heap_buffer_{nullptr};
-  uint8_t *buffer_;
-};
-
 ///@}
 
 /// @name Mathematics

esphome/core/time.cpp

@@ -67,7 +67,7 @@ std::string ESPTime::strftime(const char *format) {
 
 std::string ESPTime::strftime(const std::string &format) { return this->strftime(format.c_str()); }
 
-bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time) {
+bool ESPTime::strptime(const std::string &time_to_parse, ESPTime &esp_time) {
   uint16_t year;
   uint8_t month;
   uint8_t day;
@@ -75,41 +75,40 @@ bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time)
   uint8_t minute;
   uint8_t second;
   int num;
-  const int ilen = static_cast<int>(len);
 
-  if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
-             &hour,                                                                              // NOLINT
-             &minute,                                                                            // NOLINT
-             &second, &num) == 6 &&                                                              // NOLINT
-      num == ilen) {
+  if (sscanf(time_to_parse.c_str(), "%04hu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
+             &hour,                                                                                      // NOLINT
+             &minute,                                                                                    // NOLINT
+             &second, &num) == 6 &&                                                                      // NOLINT
+      num == static_cast<int>(time_to_parse.size())) {
     esp_time.year = year;
     esp_time.month = month;
     esp_time.day_of_month = day;
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = second;
-  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
-                    &hour,                                                                       // NOLINT
-                    &minute, &num) == 5 &&                                                       // NOLINT
-             num == ilen) {
+  } else if (sscanf(time_to_parse.c_str(), "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
+                    &hour,                                                                               // NOLINT
+                    &minute, &num) == 5 &&                                                               // NOLINT
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.year = year;
     esp_time.month = month;
     esp_time.day_of_month = day;
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = 0;
-  } else if (sscanf(time_to_parse, "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
-             num == ilen) {
+  } else if (sscanf(time_to_parse.c_str(), "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = second;
-  } else if (sscanf(time_to_parse, "%02hhu:%02hhu %n", &hour, &minute, &num) == 2 &&  // NOLINT
-             num == ilen) {
+  } else if (sscanf(time_to_parse.c_str(), "%02hhu:%02hhu %n", &hour, &minute, &num) == 2 &&  // NOLINT
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = 0;
-  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %n", &year, &month, &day, &num) == 3 &&  // NOLINT
-             num == ilen) {
+  } else if (sscanf(time_to_parse.c_str(), "%04hu-%02hhu-%02hhu %n", &year, &month, &day, &num) == 3 &&  // NOLINT
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.year = year;
     esp_time.month = month;
     esp_time.day_of_month = day;

esphome/core/time.h

@@ -2,7 +2,6 @@
 
 #include <cstdint>
 #include <cstdlib>
-#include <cstring>
 #include <ctime>
 #include <span>
 #include <string>
@@ -81,20 +80,11 @@ struct ESPTime {
   }
 
   /** Convert a string to ESPTime struct as specified by the format argument.
-   * @param time_to_parse c string formatted like this: 2020-08-25 05:30:00.
-   * @param len length of the string (not including null terminator if present)
+   * @param time_to_parse null-terminated c string formatet like this: 2020-08-25 05:30:00.
    * @param esp_time an instance of a ESPTime struct
-   * @return the success state of the parsing
+   * @return the success sate of the parsing
    */
-  static bool strptime(const char *time_to_parse, size_t len, ESPTime &esp_time);
-  /// @copydoc strptime(const char *, size_t, ESPTime &)
-  static bool strptime(const char *time_to_parse, ESPTime &esp_time) {
-    return strptime(time_to_parse, strlen(time_to_parse), esp_time);
-  }
-  /// @copydoc strptime(const char *, size_t, ESPTime &)
-  static bool strptime(const std::string &time_to_parse, ESPTime &esp_time) {
-    return strptime(time_to_parse.c_str(), time_to_parse.size(), esp_time);
-  }
+  static bool strptime(const std::string &time_to_parse, ESPTime &esp_time);
 
   /// Convert a C tm struct instance with a C unix epoch timestamp to an ESPTime instance.
   static ESPTime from_c_tm(struct tm *c_tm, time_t c_time);

tests/integration/fixtures/api_homeassistant.yaml

@@ -108,25 +108,6 @@ text_sensor:
             format: "HA Empty state updated: %s"
             args: ['x.c_str()']
 
-  # Test long attribute handling (>255 characters)
-  # HA states are limited to 255 chars, but attributes are not
-  - platform: homeassistant
-    name: "HA Long Attribute"
-    entity_id: sensor.long_data
-    attribute: long_value
-    id: ha_long_attribute
-    on_value:
-      then:
-        - logger.log:
-            format: "HA Long attribute received, length: %d"
-            args: ['x.size()']
-        # Log the first 50 and last 50 chars to verify no truncation
-        - lambda: |-
-            if (x.size() >= 100) {
-              ESP_LOGI("test", "Long attribute first 50 chars: %.50s", x.c_str());
-              ESP_LOGI("test", "Long attribute last 50 chars: %s", x.c_str() + x.size() - 50);
-            }
-
 # Number component for testing HA number control
 number:
   - platform: template

tests/integration/test_api_homeassistant.py

@@ -40,7 +40,6 @@ async def test_api_homeassistant(
     humidity_update_future = loop.create_future()
     motion_update_future = loop.create_future()
     weather_update_future = loop.create_future()
-    long_attr_future = loop.create_future()
 
     # Number future
     ha_number_future = loop.create_future()
@@ -59,7 +58,6 @@ async def test_api_homeassistant(
     humidity_update_pattern = re.compile(r"HA Humidity state updated: ([\d.]+)")
     motion_update_pattern = re.compile(r"HA Motion state changed: (ON|OFF)")
     weather_update_pattern = re.compile(r"HA Weather condition updated: (\w+)")
-    long_attr_pattern = re.compile(r"HA Long attribute received, length: (\d+)")
 
     # Number pattern
     ha_number_pattern = re.compile(r"Setting HA number to: ([\d.]+)")
@@ -145,14 +143,8 @@ async def test_api_homeassistant(
         elif not weather_update_future.done() and weather_update_pattern.search(line):
             weather_update_future.set_result(line)
 
-        # Check long attribute pattern - separate if since it can come at different times
-        if not long_attr_future.done():
-            match = long_attr_pattern.search(line)
-            if match:
-                long_attr_future.set_result(int(match.group(1)))
-
-        # Check number pattern - separate if since it can come at different times
-        if not ha_number_future.done():
+        # Check number pattern
+        elif not ha_number_future.done() and ha_number_pattern.search(line):
             match = ha_number_pattern.search(line)
             if match:
                 ha_number_future.set_result(match.group(1))
@@ -187,14 +179,6 @@ async def test_api_homeassistant(
         client.send_home_assistant_state("binary_sensor.external_motion", "", "ON")
         client.send_home_assistant_state("weather.home", "condition", "sunny")
 
-        # Send a long attribute (300 characters) to test that attributes aren't truncated
-        # HA states are limited to 255 chars, but attributes are NOT limited
-        # This tests the fix for the 256-byte buffer truncation bug
-        long_attr_value = "X" * 300  # 300 chars - enough to expose truncation bug
-        client.send_home_assistant_state(
-            "sensor.long_data", "long_value", long_attr_value
-        )
-
         # Test edge cases for zero-copy implementation safety
         # Empty entity_id should be silently ignored (no crash)
         client.send_home_assistant_state("", "", "should_be_ignored")
@@ -241,13 +225,6 @@ async def test_api_homeassistant(
             number_value = await asyncio.wait_for(ha_number_future, timeout=5.0)
             assert number_value == "42.5", f"Unexpected number value: {number_value}"
 
-            # Long attribute test - verify 300 chars weren't truncated to 255
-            long_attr_len = await asyncio.wait_for(long_attr_future, timeout=5.0)
-            assert long_attr_len == 300, (
-                f"Long attribute was truncated! Expected 300 chars, got {long_attr_len}. "
-                "This indicates the 256-byte truncation bug."
-            )
-
             # Wait for completion
             await asyncio.wait_for(tests_complete_future, timeout=5.0)
 

tests/unit_tests/test_main.py

@@ -34,7 +34,6 @@ from esphome.__main__ import (
     has_non_ip_address,
     has_resolvable_address,
     mqtt_get_ip,
-    run_esphome,
     run_miniterm,
     show_logs,
     upload_program,
@@ -1989,7 +1988,7 @@ esp32:
     clean_output = strip_ansi_codes(captured.out)
 
     assert "test-device_123.yaml" in clean_output
-    assert "Processing" in clean_output
+    assert "Updating" in clean_output
     assert "SUCCESS" in clean_output
     assert "SUMMARY" in clean_output
 
@@ -3173,66 +3172,3 @@ def test_run_miniterm_buffer_limit_prevents_unbounded_growth() -> None:
     x_count = printed_line.count("X")
     assert x_count < 150, f"Expected truncation but got {x_count} X's"
     assert x_count == 95, f"Expected 95 X's after truncation but got {x_count}"
-
-
-def test_run_esphome_multiple_configs_with_secrets(
-    tmp_path: Path,
-    mock_run_external_process: Mock,
-    capfd: CaptureFixture[str],
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """Test run_esphome with multiple configs and secrets file.
-
-    Verifies:
-    - Multiple configs use subprocess isolation
-    - Secrets files are skipped with warning
-    - Secrets files don't appear in summary
-    """
-    # Create two config files and a secrets file
-    yaml_file1 = tmp_path / "device1.yaml"
-    yaml_file1.write_text("""
-esphome:
-  name: device1
-
-esp32:
-  board: nodemcu-32s
-""")
-    yaml_file2 = tmp_path / "device2.yaml"
-    yaml_file2.write_text("""
-esphome:
-  name: device2
-
-esp32:
-  board: nodemcu-32s
-""")
-    secrets_file = tmp_path / "secrets.yaml"
-    secrets_file.write_text("wifi_password: secret123\n")
-
-    setup_core(tmp_path=tmp_path)
-    mock_run_external_process.return_value = 0
-
-    # run_esphome expects argv[0] to be the program name (gets sliced off by parse_args)
-    with caplog.at_level(logging.WARNING):
-        result = run_esphome(
-            ["esphome", "compile", str(yaml_file1), str(secrets_file), str(yaml_file2)]
-        )
-
-    assert result == 0
-
-    # Check secrets file was skipped with warning
-    assert "Skipping secrets file" in caplog.text
-    assert "secrets.yaml" in caplog.text
-
-    captured = capfd.readouterr()
-    clean_output = strip_ansi_codes(captured.out)
-
-    # Both config files should be processed
-    assert "device1.yaml" in clean_output
-    assert "device2.yaml" in clean_output
-    assert "SUMMARY" in clean_output
-
-    # Secrets should not appear in summary
-    summary_section = (
-        clean_output.split("SUMMARY")[1] if "SUMMARY" in clean_output else ""
-    )
-    assert "secrets.yaml" not in summary_section