Update esphome/core/automation.h

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

esphome/codegen.py

@@ -69,6 +69,7 @@ from esphome.cpp_types import (  # noqa: F401
     JsonObjectConst,
     Parented,
     PollingComponent,
+    StringRef,
     arduino_json_ns,
     bool_,
     const_char_ptr,

esphome/components/ccs811/ccs811.cpp

@@ -81,8 +81,8 @@ void CCS811Component::setup() {
            bootloader_version, application_version);
   if (this->version_ != nullptr) {
     char version[20];  // "15.15.15 (0xffff)" is 17 chars, plus NUL, plus wiggle room
-    sprintf(version, "%d.%d.%d (0x%02x)", (application_version >> 12 & 15), (application_version >> 8 & 15),
-            (application_version >> 4 & 15), application_version);
+    buf_append_printf(version, sizeof(version), 0, "%d.%d.%d (0x%02x)", (application_version >> 12 & 15),
+                      (application_version >> 8 & 15), (application_version >> 4 & 15), application_version);
     ESP_LOGD(TAG, "publishing version state: %s", version);
     this->version_->publish_state(version);
   }

esphome/components/ch422g/ch422g.cpp

@@ -133,7 +133,7 @@ bool CH422GGPIOPin::digital_read() { return this->parent_->digital_read(this->pi
 
 void CH422GGPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value ^ this->inverted_); }
 size_t CH422GGPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "EXIO%u via CH422G", this->pin_);
+  return buf_append_printf(buffer, len, 0, "EXIO%u via CH422G", this->pin_);
 }
 void CH422GGPIOPin::set_flags(gpio::Flags flags) {
   flags_ = flags;

esphome/components/cse7766/cse7766.cpp

@@ -207,20 +207,24 @@ void CSE7766Component::parse_data_() {
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   {
-    std::string buf = "Parsed:";
+    // Buffer: 7 + 15 + 33 + 15 + 25 = 95 chars max + null, rounded to 128 for safety margin.
+    // Float sizes with %.4f can be up to 11 chars for large values (e.g., 999999.9999).
+    char buf[128];
+    size_t pos = buf_append_printf(buf, sizeof(buf), 0, "Parsed:");
     if (have_voltage) {
-      buf += str_sprintf(" V=%fV", voltage);
+      pos = buf_append_printf(buf, sizeof(buf), pos, " V=%.4fV", voltage);
     }
     if (have_current) {
-      buf += str_sprintf(" I=%fmA (~%fmA)", current * 1000.0f, calculated_current * 1000.0f);
+      pos = buf_append_printf(buf, sizeof(buf), pos, " I=%.4fmA (~%.4fmA)", current * 1000.0f,
+                              calculated_current * 1000.0f);
     }
     if (have_power) {
-      buf += str_sprintf(" P=%fW", power);
+      pos = buf_append_printf(buf, sizeof(buf), pos, " P=%.4fW", power);
     }
     if (energy != 0.0f) {
-      buf += str_sprintf(" E=%fkWh (%u)", energy, cf_pulses);
+      buf_append_printf(buf, sizeof(buf), pos, " E=%.4fkWh (%u)", energy, cf_pulses);
     }
-    ESP_LOGVV(TAG, "%s", buf.c_str());
+    ESP_LOGVV(TAG, "%s", buf);
   }
 #endif
 }

esphome/components/daikin_arc/daikin_arc.cpp

@@ -258,8 +258,9 @@ bool DaikinArcClimate::parse_state_frame_(const uint8_t frame[]) {
   }
 
   char buf[DAIKIN_STATE_FRAME_SIZE * 3 + 1] = {0};
+  size_t pos = 0;
   for (size_t i = 0; i < DAIKIN_STATE_FRAME_SIZE; i++) {
-    sprintf(buf, "%s%02x ", buf, frame[i]);
+    pos = buf_append_printf(buf, sizeof(buf), pos, "%02x ", frame[i]);
   }
   ESP_LOGD(TAG, "FRAME %s", buf);
 
@@ -349,8 +350,9 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
   if (data.expect_item(DAIKIN_HEADER_MARK, DAIKIN_HEADER_SPACE)) {
     valid_daikin_frame = true;
     size_t bytes_count = data.size() / 2 / 8;
-    std::unique_ptr<char[]> buf(new char[bytes_count * 3 + 1]);
-    buf[0] = '\0';
+    size_t buf_size = bytes_count * 3 + 1;
+    std::unique_ptr<char[]> buf(new char[buf_size]());  // value-initialize (zero-fill)
+    size_t buf_pos = 0;
     for (size_t i = 0; i < bytes_count; i++) {
       uint8_t byte = 0;
       for (int8_t bit = 0; bit < 8; bit++) {
@@ -361,19 +363,19 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
           break;
         }
       }
-      sprintf(buf.get(), "%s%02x ", buf.get(), byte);
+      buf_pos = buf_append_printf(buf.get(), buf_size, buf_pos, "%02x ", byte);
     }
     ESP_LOGD(TAG, "WHOLE FRAME %s  size: %d", buf.get(), data.size());
   }
   if (!valid_daikin_frame) {
-    char sbuf[16 * 10 + 1];
-    sbuf[0] = '\0';
+    char sbuf[16 * 10 + 1] = {0};
+    size_t sbuf_pos = 0;
     for (size_t j = 0; j < static_cast<size_t>(data.size()); j++) {
       if ((j - 2) % 16 == 0) {
         if (j > 0) {
           ESP_LOGD(TAG, "DATA %04x: %s", (j - 16 > 0xffff ? 0 : j - 16), sbuf);
         }
-        sbuf[0] = '\0';
+        sbuf_pos = 0;
       }
       char type_ch = ' ';
       // debug_tolerance = 25%
@@ -401,9 +403,10 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
         type_ch = '0';
 
       if (abs(data[j]) > 100000) {
-        sprintf(sbuf, "%s%-5d[%c] ", sbuf, data[j] > 0 ? 99999 : -99999, type_ch);
+        sbuf_pos = buf_append_printf(sbuf, sizeof(sbuf), sbuf_pos, "%-5d[%c] ", data[j] > 0 ? 99999 : -99999, type_ch);
       } else {
-        sprintf(sbuf, "%s%-5d[%c] ", sbuf, (int) (round(data[j] / 10.) * 10), type_ch);
+        sbuf_pos =
+            buf_append_printf(sbuf, sizeof(sbuf), sbuf_pos, "%-5d[%c] ", (int) (round(data[j] / 10.) * 10), type_ch);
       }
       if (j + 1 == static_cast<size_t>(data.size())) {
         ESP_LOGD(TAG, "DATA %04x: %s", (j - 8 > 0xffff ? 0 : j - 8), sbuf);

esphome/components/dfrobot_sen0395/commands.cpp

@@ -127,7 +127,9 @@ DetRangeCfgCommand::DetRangeCfgCommand(float min1, float max1, float min2, float
     this->min2_ = min2 = this->max2_ = max2 = this->min3_ = min3 = this->max3_ = max3 = this->min4_ = min4 =
         this->max4_ = max4 = -1;
 
-    this->cmd_ = str_sprintf("detRangeCfg -1 %.0f %.0f", min1 / 0.15, max1 / 0.15);
+    char buf[72];  // max 72: "detRangeCfg -1 "(15) + 8 * (float(5) + space(1)) + null
+    snprintf(buf, sizeof(buf), "detRangeCfg -1 %.0f %.0f", min1 / 0.15, max1 / 0.15);
+    this->cmd_ = buf;
   } else if (min3 < 0 || max3 < 0) {
     this->min1_ = min1 = round(min1 / 0.15) * 0.15;
     this->max1_ = max1 = round(max1 / 0.15) * 0.15;
@@ -135,7 +137,10 @@ DetRangeCfgCommand::DetRangeCfgCommand(float min1, float max1, float min2, float
     this->max2_ = max2 = round(max2 / 0.15) * 0.15;
     this->min3_ = min3 = this->max3_ = max3 = this->min4_ = min4 = this->max4_ = max4 = -1;
 
-    this->cmd_ = str_sprintf("detRangeCfg -1 %.0f %.0f %.0f %.0f", min1 / 0.15, max1 / 0.15, min2 / 0.15, max2 / 0.15);
+    char buf[72];  // max 72: "detRangeCfg -1 "(15) + 8 * (float(5) + space(1)) + null
+    snprintf(buf, sizeof(buf), "detRangeCfg -1 %.0f %.0f %.0f %.0f", min1 / 0.15, max1 / 0.15, min2 / 0.15,
+             max2 / 0.15);
+    this->cmd_ = buf;
   } else if (min4 < 0 || max4 < 0) {
     this->min1_ = min1 = round(min1 / 0.15) * 0.15;
     this->max1_ = max1 = round(max1 / 0.15) * 0.15;
@@ -145,9 +150,10 @@ DetRangeCfgCommand::DetRangeCfgCommand(float min1, float max1, float min2, float
     this->max3_ = max3 = round(max3 / 0.15) * 0.15;
     this->min4_ = min4 = this->max4_ = max4 = -1;
 
-    this->cmd_ = str_sprintf("detRangeCfg -1 "
-                             "%.0f %.0f %.0f %.0f %.0f %.0f",
-                             min1 / 0.15, max1 / 0.15, min2 / 0.15, max2 / 0.15, min3 / 0.15, max3 / 0.15);
+    char buf[72];  // max 72: "detRangeCfg -1 "(15) + 8 * (float(5) + space(1)) + null
+    snprintf(buf, sizeof(buf), "detRangeCfg -1 %.0f %.0f %.0f %.0f %.0f %.0f", min1 / 0.15, max1 / 0.15, min2 / 0.15,
+             max2 / 0.15, min3 / 0.15, max3 / 0.15);
+    this->cmd_ = buf;
   } else {
     this->min1_ = min1 = round(min1 / 0.15) * 0.15;
     this->max1_ = max1 = round(max1 / 0.15) * 0.15;
@@ -158,10 +164,10 @@ DetRangeCfgCommand::DetRangeCfgCommand(float min1, float max1, float min2, float
     this->min4_ = min4 = round(min4 / 0.15) * 0.15;
     this->max4_ = max4 = round(max4 / 0.15) * 0.15;
 
-    this->cmd_ = str_sprintf("detRangeCfg -1 "
-                             "%.0f %.0f %.0f %.0f %.0f %.0f %.0f %.0f",
-                             min1 / 0.15, max1 / 0.15, min2 / 0.15, max2 / 0.15, min3 / 0.15, max3 / 0.15, min4 / 0.15,
-                             max4 / 0.15);
+    char buf[72];  // max 72: "detRangeCfg -1 "(15) + 8 * (float(5) + space(1)) + null
+    snprintf(buf, sizeof(buf), "detRangeCfg -1 %.0f %.0f %.0f %.0f %.0f %.0f %.0f %.0f", min1 / 0.15, max1 / 0.15,
+             min2 / 0.15, max2 / 0.15, min3 / 0.15, max3 / 0.15, min4 / 0.15, max4 / 0.15);
+    this->cmd_ = buf;
   }
 
   this->min1_ = min1;
@@ -203,7 +209,10 @@ SetLatencyCommand::SetLatencyCommand(float delay_after_detection, float delay_af
   delay_after_disappear = std::round(delay_after_disappear / 0.025f) * 0.025f;
   this->delay_after_detection_ = clamp(delay_after_detection, 0.0f, 1638.375f);
   this->delay_after_disappear_ = clamp(delay_after_disappear, 0.0f, 1638.375f);
-  this->cmd_ = str_sprintf("setLatency %.03f %.03f", this->delay_after_detection_, this->delay_after_disappear_);
+  // max 32: "setLatency "(11) + float(8) + " "(1) + float(8) + null, rounded to 32
+  char buf[32];
+  snprintf(buf, sizeof(buf), "setLatency %.03f %.03f", this->delay_after_detection_, this->delay_after_disappear_);
+  this->cmd_ = buf;
 };
 
 uint8_t SetLatencyCommand::on_message(std::string &message) {

esphome/components/esp32_hosted/update/esp32_hosted_update.cpp

@@ -69,7 +69,10 @@ void Esp32HostedUpdate::setup() {
   // Get coprocessor version
   esp_hosted_coprocessor_fwver_t ver_info;
   if (esp_hosted_get_coprocessor_fwversion(&ver_info) == ESP_OK) {
-    this->update_info_.current_version = str_sprintf("%d.%d.%d", ver_info.major1, ver_info.minor1, ver_info.patch1);
+    // 16 bytes: "255.255.255" (11 chars) + null + safety margin
+    char buf[16];
+    snprintf(buf, sizeof(buf), "%d.%d.%d", ver_info.major1, ver_info.minor1, ver_info.patch1);
+    this->update_info_.current_version = buf;
   } else {
     this->update_info_.current_version = "unknown";
   }

esphome/components/esp8266/core.cpp

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

esphome/components/esp8266/gpio.cpp

@@ -99,7 +99,7 @@ void ESP8266GPIOPin::pin_mode(gpio::Flags flags) {
 }
 
 size_t ESP8266GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "GPIO%u", this->pin_);
+  return buf_append_printf(buffer, len, 0, "GPIO%u", this->pin_);
 }
 
 bool ESP8266GPIOPin::digital_read() {

esphome/components/ezo/ezo.cpp

@@ -160,7 +160,7 @@ void EZOSensor::loop() {
   this->commands_.pop_front();
 }
 
-void EZOSensor::add_command_(const std::string &command, EzoCommandType command_type, uint16_t delay_ms) {
+void EZOSensor::add_command_(const char *command, EzoCommandType command_type, uint16_t delay_ms) {
   std::unique_ptr<EzoCommand> ezo_command(new EzoCommand);
   ezo_command->command = command;
   ezo_command->command_type = command_type;
@@ -169,13 +169,17 @@ void EZOSensor::add_command_(const std::string &command, EzoCommandType command_
 }
 
 void EZOSensor::set_calibration_point_(EzoCalibrationType type, float value) {
-  std::string payload = str_sprintf("Cal,%s,%0.2f", EZO_CALIBRATION_TYPE_STRINGS[type], value);
+  // max 21: "Cal,"(4) + type(4) + ","(1) + float(11) + null; use 24 for safety
+  char payload[24];
+  snprintf(payload, sizeof(payload), "Cal,%s,%0.2f", EZO_CALIBRATION_TYPE_STRINGS[type], value);
   this->add_command_(payload, EzoCommandType::EZO_CALIBRATION, 900);
 }
 
 void EZOSensor::set_address(uint8_t address) {
   if (address > 0 && address < 128) {
-    std::string payload = str_sprintf("I2C,%u", address);
+    // max 8: "I2C,"(4) + uint8(3) + null
+    char payload[8];
+    snprintf(payload, sizeof(payload), "I2C,%u", address);
     this->new_address_ = address;
     this->add_command_(payload, EzoCommandType::EZO_I2C);
   } else {
@@ -194,7 +198,9 @@ void EZOSensor::get_slope() { this->add_command_("Slope,?", EzoCommandType::EZO_
 void EZOSensor::get_t() { this->add_command_("T,?", EzoCommandType::EZO_T); }
 
 void EZOSensor::set_t(float value) {
-  std::string payload = str_sprintf("T,%0.2f", value);
+  // max 14 bytes: "T,"(2) + float with "%0.2f" (up to 11 chars) + null(1); use 16 for alignment
+  char payload[16];
+  snprintf(payload, sizeof(payload), "T,%0.2f", value);
   this->add_command_(payload, EzoCommandType::EZO_T);
 }
 
@@ -215,7 +221,9 @@ void EZOSensor::set_calibration_point_high(float value) {
 }
 
 void EZOSensor::set_calibration_generic(float value) {
-  std::string payload = str_sprintf("Cal,%0.2f", value);
+  // exact 16 bytes: "Cal," (4) + float with "%0.2f" (up to 11 chars, e.g. "-9999999.99") + null (1) = 16
+  char payload[16];
+  snprintf(payload, sizeof(payload), "Cal,%0.2f", value);
   this->add_command_(payload, EzoCommandType::EZO_CALIBRATION, 900);
 }
 
@@ -223,13 +231,11 @@ void EZOSensor::clear_calibration() { this->add_command_("Cal,clear", EzoCommand
 
 void EZOSensor::get_led_state() { this->add_command_("L,?", EzoCommandType::EZO_LED); }
 
-void EZOSensor::set_led_state(bool on) {
-  std::string to_send = "L,";
-  to_send += on ? "1" : "0";
-  this->add_command_(to_send, EzoCommandType::EZO_LED);
-}
+void EZOSensor::set_led_state(bool on) { this->add_command_(on ? "L,1" : "L,0", EzoCommandType::EZO_LED); }
 
-void EZOSensor::send_custom(const std::string &to_send) { this->add_command_(to_send, EzoCommandType::EZO_CUSTOM); }
+void EZOSensor::send_custom(const std::string &to_send) {
+  this->add_command_(to_send.c_str(), EzoCommandType::EZO_CUSTOM);
+}
 
 }  // namespace ezo
 }  // namespace esphome

esphome/components/ezo/ezo.h

@@ -92,7 +92,7 @@ class EZOSensor : public sensor::Sensor, public PollingComponent, public i2c::I2
   std::deque<std::unique_ptr<EzoCommand>> commands_;
   int new_address_;
 
-  void add_command_(const std::string &command, EzoCommandType command_type, uint16_t delay_ms = 300);
+  void add_command_(const char *command, EzoCommandType command_type, uint16_t delay_ms = 300);
 
   void set_calibration_point_(EzoCalibrationType type, float value);
 

esphome/components/fan/__init__.py

@@ -77,7 +77,7 @@ FanSpeedSetTrigger = fan_ns.class_(
     "FanSpeedSetTrigger", automation.Trigger.template(cg.int_)
 )
 FanPresetSetTrigger = fan_ns.class_(
-    "FanPresetSetTrigger", automation.Trigger.template(cg.std_string)
+    "FanPresetSetTrigger", automation.Trigger.template(cg.StringRef)
 )
 
 FanIsOnCondition = fan_ns.class_("FanIsOnCondition", automation.Condition.template())
@@ -287,7 +287,7 @@ async def setup_fan_core_(var, config):
         await automation.build_automation(trigger, [(cg.int_, "x")], conf)
     for conf in config.get(CONF_ON_PRESET_SET, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [(cg.std_string, "x")], conf)
+        await automation.build_automation(trigger, [(cg.StringRef, "x")], conf)
 
 
 async def register_fan(var, config):

esphome/components/fan/automation.h

@@ -208,7 +208,7 @@ class FanSpeedSetTrigger : public Trigger<int> {
   int last_speed_;
 };
 
-class FanPresetSetTrigger : public Trigger<std::string> {
+class FanPresetSetTrigger : public Trigger<StringRef> {
  public:
   FanPresetSetTrigger(Fan *state) {
     state->add_on_state_callback([this, state]() {
@@ -216,7 +216,7 @@ class FanPresetSetTrigger : public Trigger<std::string> {
       auto should_trigger = preset_mode != this->last_preset_mode_;
       this->last_preset_mode_ = preset_mode;
       if (should_trigger) {
-        this->trigger(std::string(preset_mode));
+        this->trigger(preset_mode);
       }
     });
     this->last_preset_mode_ = state->get_preset_mode();

esphome/components/gdk101/gdk101.cpp

@@ -163,9 +163,10 @@ bool GDK101Component::read_fw_version_(uint8_t *data) {
       return false;
     }
 
-    const std::string fw_version_str = str_sprintf("%d.%d", data[0], data[1]);
-
-    this->fw_version_text_sensor_->publish_state(fw_version_str);
+    // max 8: "255.255" (7 chars) + null
+    char buf[8];
+    snprintf(buf, sizeof(buf), "%d.%d", data[0], data[1]);
+    this->fw_version_text_sensor_->publish_state(buf);
   }
 #endif  // USE_TEXT_SENSOR
   return true;

esphome/components/homeassistant/number/homeassistant_number.cpp

@@ -97,7 +97,7 @@ void HomeassistantNumber::control(float value) {
   entity_value.key = VALUE_KEY;
   // Stack buffer - no heap allocation; %g produces shortest representation
   char value_buf[16];
-  snprintf(value_buf, sizeof(value_buf), "%g", value);
+  buf_append_printf(value_buf, sizeof(value_buf), 0, "%g", value);
   entity_value.value = StringRef(value_buf);
 
   api::global_api_server->send_homeassistant_action(resp);

esphome/components/max6956/max6956.cpp

@@ -162,7 +162,7 @@ void MAX6956GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this-
 bool MAX6956GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void MAX6956GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
 size_t MAX6956GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via Max6956", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via Max6956", this->pin_);
 }
 
 }  // namespace max6956

esphome/components/mcp23016/mcp23016.cpp

@@ -100,7 +100,7 @@ void MCP23016GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this
 bool MCP23016GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void MCP23016GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
 size_t MCP23016GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via MCP23016", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via MCP23016", this->pin_);
 }
 
 }  // namespace mcp23016

esphome/components/mcp23xxx_base/mcp23xxx_base.cpp

@@ -17,7 +17,7 @@ template<uint8_t N> void MCP23XXXGPIOPin<N>::digital_write(bool value) {
   this->parent_->digital_write(this->pin_, value != this->inverted_);
 }
 template<uint8_t N> size_t MCP23XXXGPIOPin<N>::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via MCP23XXX", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via MCP23XXX", this->pin_);
 }
 
 template class MCP23XXXGPIOPin<8>;

esphome/components/mpr121/mpr121.cpp

@@ -154,7 +154,7 @@ void MPR121GPIOPin::digital_write(bool value) {
 }
 
 size_t MPR121GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "ELE%u on MPR121", this->pin_);
+  return buf_append_printf(buffer, len, 0, "ELE%u on MPR121", this->pin_);
 }
 
 }  // namespace mpr121

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

@@ -635,7 +635,8 @@ void MQTTClientComponent::set_log_message_template(MQTTMessage &&message) { this
 const MQTTDiscoveryInfo &MQTTClientComponent::get_discovery_info() const { return this->discovery_info_; }
 void MQTTClientComponent::set_topic_prefix(const std::string &topic_prefix, const std::string &check_topic_prefix) {
   if (App.is_name_add_mac_suffix_enabled() && (topic_prefix == check_topic_prefix)) {
-    this->topic_prefix_ = str_sanitize(App.get_name());
+    char buf[ESPHOME_DEVICE_NAME_MAX_LEN + 1];
+    this->topic_prefix_ = str_sanitize_to(buf, App.get_name().c_str());
   } else {
     this->topic_prefix_ = topic_prefix;
   }

esphome/components/mqtt/mqtt_component.cpp

@@ -27,20 +27,23 @@ 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 and MQTT_SUFFIX_MAX_LEN are defined in mqtt_component.h.
+// MQTT_COMPONENT_TYPE_MAX_LEN, MQTT_SUFFIX_MAX_LEN, and MQTT_DEFAULT_TOPIC_MAX_LEN are 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; }
@@ -48,7 +51,8 @@ void MQTTComponent::set_subscribe_qos(uint8_t qos) { this->subscribe_qos_ = qos;
 void MQTTComponent::set_retain(bool retain) { this->retain_ = retain; }
 
 std::string MQTTComponent::get_discovery_topic_(const MQTTDiscoveryInfo &discovery_info) const {
-  std::string sanitized_name = str_sanitize(App.get_name());
+  char sanitized_name[ESPHOME_DEVICE_NAME_MAX_LEN + 1];
+  str_sanitize_to(sanitized_name, App.get_name().c_str());
   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);
@@ -60,7 +64,7 @@ std::string MQTTComponent::get_discovery_topic_(const MQTTDiscoveryInfo &discove
   p = append_char(p, '/');
   p = append_str(p, comp_type, strlen(comp_type));
   p = append_char(p, '/');
-  p = append_str(p, sanitized_name.data(), sanitized_name.size());
+  p = append_str(p, sanitized_name, strlen(sanitized_name));
   p = append_char(p, '/');
   p = append_str(p, object_id.c_str(), object_id.size());
   p = append_str(p, "/config", 7);
@@ -68,19 +72,18 @@ std::string MQTTComponent::get_discovery_topic_(const MQTTDiscoveryInfo &discove
   return std::string(buf, p - buf);
 }
 
-std::string MQTTComponent::get_default_topic_for_(const std::string &suffix) const {
+StringRef MQTTComponent::get_default_topic_for_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf, const char *suffix,
+                                                   size_t suffix_len) const {
   const std::string &topic_prefix = global_mqtt_client->get_topic_prefix();
   if (topic_prefix.empty()) {
-    // If the topic_prefix is null, the default topic should be null
-    return "";
+    return StringRef();  // Empty topic_prefix means no default topic
   }
 
   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 buf[DEFAULT_TOPIC_MAX_LEN];
-  char *p = buf;
+  char *p = buf.data();
 
   p = append_str(p, topic_prefix.data(), topic_prefix.size());
   p = append_char(p, '/');
@@ -88,21 +91,44 @@ std::string MQTTComponent::get_default_topic_for_(const std::string &suffix) con
   p = append_char(p, '/');
   p = append_str(p, object_id.c_str(), object_id.size());
   p = append_char(p, '/');
-  p = append_str(p, suffix.data(), suffix.size());
+  p = append_str(p, suffix, suffix_len);
+  *p = '\0';
 
-  return std::string(buf, p - buf);
+  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);
 }
 
 std::string MQTTComponent::get_state_topic_() const {
-  if (this->custom_state_topic_.has_value())
-    return this->custom_state_topic_.value();
-  return this->get_default_topic_for_("state");
+  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
+  StringRef ref = this->get_state_topic_to_(buf);
+  return std::string(ref.c_str(), ref.size());
 }
 
 std::string MQTTComponent::get_command_topic_() const {
-  if (this->custom_command_topic_.has_value())
-    return this->custom_command_topic_.value();
-  return this->get_default_topic_for_("command");
+  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
+  StringRef ref = this->get_command_topic_to_(buf);
+  return std::string(ref.c_str(), ref.size());
 }
 
 bool MQTTComponent::publish(const std::string &topic, const std::string &payload) {
@@ -167,10 +193,14 @@ bool MQTTComponent::send_discovery_() {
             break;
         }
 
-        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 (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 (this->command_retain_)
           root[MQTT_COMMAND_RETAIN] = true;
 
@@ -287,7 +317,9 @@ void MQTTComponent::set_availability(std::string topic, std::string payload_avai
 }
 void MQTTComponent::disable_availability() { this->set_availability("", "", ""); }
 void MQTTComponent::call_setup() {
-  if (this->is_internal())
+  // Cache is_internal result once during setup - topics don't change after this
+  this->is_internal_ = this->compute_is_internal_();
+  if (this->is_internal_)
     return;
 
   this->setup();
@@ -343,26 +375,28 @@ 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::is_internal() {
+bool MQTTComponent::compute_is_internal_() {
   if (this->custom_state_topic_.has_value()) {
-    // If the custom state_topic is null, return true as it is internal and should not publish
+    // If the custom state_topic is empty, 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
-    return this->get_state_topic_().empty();
+    // Using is_empty() avoids heap allocation for non-lambda cases
+    return this->custom_state_topic_.is_empty();
   }
 
   if (this->custom_command_topic_.has_value()) {
-    // If the custom command_topic is null, return true as it is internal and should not publish
+    // If the custom command_topic is empty, 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
-    return this->get_command_topic_().empty();
+    // Using is_empty() avoids heap allocation for non-lambda cases
+    return this->custom_command_topic_.is_empty();
   }
 
-  // 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
+  // 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
     return true;
   }
 
-  // Use ESPHome's component internal state if topic_prefix is not null with no custom state_topic or command_topic
+  // Use ESPHome's component internal state if topic_prefix is not empty with no custom state_topic or command_topic
   return this->get_entity()->is_internal();
 }
 

esphome/components/mqtt/mqtt_component.h

@@ -20,17 +20,22 @@ struct SendDiscoveryConfig {
   bool command_topic{true};  ///< If the command topic should be included. Default to true.
 };
 
-// Max lengths for stack-based topic building (must match mqtt_component.cpp)
+// 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.
 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;
 
-#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()); \
-  }
+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)
 
 // Macro to define component_type() with compile-time length verification
 // Usage: MQTT_COMPONENT_TYPE(MQTTSensorComponent, "sensor")
@@ -74,6 +79,8 @@ static constexpr size_t MQTT_SUFFIX_MAX_LEN = 32;
  * 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();
@@ -90,7 +97,8 @@ class MQTTComponent : public Component {
 
   virtual bool send_initial_state() = 0;
 
-  virtual bool is_internal();
+  /// Returns cached is_internal result (computed once during setup).
+  bool is_internal() const { return this->is_internal_; }
 
   /// Set QOS for state messages.
   void set_qos(uint8_t qos);
@@ -178,7 +186,16 @@ 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.
+  /** 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).
    *
    * @param suffix The suffix/key such as "state" or "command".
    * @return The full topic.
@@ -199,10 +216,20 @@ class MQTTComponent : public Component {
   /// Get whether the underlying Entity is disabled by default
   bool is_disabled_by_default_() const;
 
-  /// Get the MQTT topic that new states will be shared to.
+  /// 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).
   std::string get_state_topic_() const;
 
-  /// Get the MQTT topic for listening to commands.
+  /// Get the MQTT topic for listening to commands (allocates std::string).
   std::string get_command_topic_() const;
 
   bool is_connected_() const;
@@ -220,12 +247,18 @@ class MQTTComponent : public Component {
 
   std::unique_ptr<Availability> availability_;
 
-  bool command_retain_{false};
-  bool retain_{true};
-  uint8_t qos_{0};
-  uint8_t subscribe_qos_{0};
-  bool discovery_enabled_{true};
-  bool resend_state_{false};
+  // 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_();
 };
 
 }  // 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/nextion/nextion.cpp

@@ -1,6 +1,7 @@
 #include "nextion.h"
 #include <cinttypes>
 #include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
@@ -1283,8 +1284,9 @@ void Nextion::check_pending_waveform_() {
   size_t buffer_to_send = component->get_wave_buffer_size() < 255 ? component->get_wave_buffer_size()
                                                                   : 255;  // ADDT command can only send 255
 
-  std::string command = "addt " + to_string(component->get_component_id()) + "," +
-                        to_string(component->get_wave_channel_id()) + "," + to_string(buffer_to_send);
+  char command[24];  // "addt " + uint8 + "," + uint8 + "," + uint8 + null = max 17 chars
+  buf_append_printf(command, sizeof(command), 0, "addt %u,%u,%zu", component->get_component_id(),
+                    component->get_wave_channel_id(), buffer_to_send);
   if (!this->send_command_(command)) {
     delete nb;  // NOLINT(cppcoreguidelines-owning-memory)
     this->waveform_queue_.pop_front();

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -34,7 +34,7 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
   }
 
   char range_header[32];
-  sprintf(range_header, "bytes=%" PRIu32 "-%" PRIu32, range_start, range_end);
+  buf_append_printf(range_header, sizeof(range_header), 0, "bytes=%" PRIu32 "-%" PRIu32, range_start, range_end);
   ESP_LOGV(TAG, "Range: %s", range_header);
   http_client.addHeader("Range", range_header);
   int code = http_client.GET();

esphome/components/nextion/nextion_upload_esp32.cpp

@@ -36,7 +36,7 @@ int Nextion::upload_by_chunks_(esp_http_client_handle_t http_client, uint32_t &r
   }
 
   char range_header[32];
-  sprintf(range_header, "bytes=%" PRIu32 "-%" PRIu32, range_start, range_end);
+  buf_append_printf(range_header, sizeof(range_header), 0, "bytes=%" PRIu32 "-%" PRIu32, range_start, range_end);
   ESP_LOGV(TAG, "Range: %s", range_header);
   esp_http_client_set_header(http_client, "Range", range_header);
   ESP_LOGV(TAG, "Open HTTP");

esphome/components/pca6416a/pca6416a.cpp

@@ -181,7 +181,7 @@ void PCA6416AGPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this
 bool PCA6416AGPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void PCA6416AGPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
 size_t PCA6416AGPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via PCA6416A", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via PCA6416A", this->pin_);
 }
 
 }  // namespace pca6416a

esphome/components/pca9554/pca9554.cpp

@@ -130,7 +130,7 @@ void PCA9554GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this-
 bool PCA9554GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void PCA9554GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
 size_t PCA9554GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via PCA9554", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via PCA9554", this->pin_);
 }
 
 }  // namespace pca9554

esphome/components/pcf8574/pcf8574.cpp

@@ -107,7 +107,7 @@ void PCF8574GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this-
 bool PCF8574GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void PCF8574GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
 size_t PCF8574GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via PCF8574", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via PCF8574", this->pin_);
 }
 
 }  // namespace pcf8574

esphome/components/pi4ioe5v6408/pi4ioe5v6408.cpp

@@ -165,7 +165,7 @@ void PI4IOE5V6408GPIOPin::digital_write(bool value) {
   this->parent_->digital_write(this->pin_, value != this->inverted_);
 }
 size_t PI4IOE5V6408GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via PI4IOE5V6408", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via PI4IOE5V6408", this->pin_);
 }
 
 }  // namespace pi4ioe5v6408

esphome/components/rc522_spi/rc522_spi.cpp

@@ -1,4 +1,5 @@
 #include "rc522_spi.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 // Based on:
@@ -70,7 +71,7 @@ void RC522Spi::pcd_read_register(PcdRegister reg,  ///< The register to read fro
     index++;
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
-    sprintf(cstrb, " %x", values[0]);
+    buf_append_printf(cstrb, sizeof(cstrb), 0, " %x", values[0]);
     buf.append(cstrb);
 #endif
   }
@@ -78,7 +79,7 @@ void RC522Spi::pcd_read_register(PcdRegister reg,  ///< The register to read fro
     values[index] = transfer_byte(address);  // Read value and tell that we want to read the same address again.
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
-    sprintf(cstrb, " %x", values[index]);
+    buf_append_printf(cstrb, sizeof(cstrb), 0, " %x", values[index]);
     buf.append(cstrb);
 #endif
 
@@ -88,7 +89,7 @@ void RC522Spi::pcd_read_register(PcdRegister reg,  ///< The register to read fro
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
   buf = buf + " ";
-  sprintf(cstrb, "%x", values[index]);
+  buf_append_printf(cstrb, sizeof(cstrb), 0, "%x", values[index]);
   buf.append(cstrb);
 
   ESP_LOGVV(TAG, "read_register_array_(%x, %d, , %d) -> %s", reg, count, rx_align, buf.c_str());
@@ -127,7 +128,7 @@ void RC522Spi::pcd_write_register(PcdRegister reg,  ///< The register to write t
     transfer_byte(values[index]);
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
-    sprintf(cstrb, " %x", values[index]);
+    buf_append_printf(cstrb, sizeof(cstrb), 0, " %x", values[index]);
     buf.append(cstrb);
 #endif
   }

esphome/components/select/__init__.py

@@ -33,7 +33,7 @@ SelectPtr = Select.operator("ptr")
 # Triggers
 SelectStateTrigger = select_ns.class_(
     "SelectStateTrigger",
-    automation.Trigger.template(cg.std_string, cg.size_t),
+    automation.Trigger.template(cg.StringRef, cg.size_t),
 )
 
 # Actions
@@ -100,7 +100,7 @@ async def setup_select_core_(var, config, *, options: list[str]):
     for conf in config.get(CONF_ON_VALUE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(
-            trigger, [(cg.std_string, "x"), (cg.size_t, "i")], conf
+            trigger, [(cg.StringRef, "x"), (cg.size_t, "i")], conf
         )
 
     if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:

esphome/components/select/automation.h

@@ -6,11 +6,11 @@
 
 namespace esphome::select {
 
-class SelectStateTrigger : public Trigger<std::string, size_t> {
+class SelectStateTrigger : public Trigger<StringRef, size_t> {
  public:
   explicit SelectStateTrigger(Select *parent) : parent_(parent) {
     parent->add_on_state_callback(
-        [this](size_t index) { this->trigger(std::string(this->parent_->option_at(index)), index); });
+        [this](size_t index) { this->trigger(StringRef(this->parent_->option_at(index)), index); });
   }
 
  protected:

esphome/components/sml/sml_parser.cpp

@@ -104,7 +104,10 @@ std::vector<ObisInfo> SmlFile::get_obis_info() {
 std::string bytes_repr(const BytesView &buffer) {
   std::string repr;
   for (auto const value : buffer) {
-    repr += str_sprintf("%02x", value & 0xff);
+    // max 3: 2 hex digits + null
+    char hex_buf[3];
+    snprintf(hex_buf, sizeof(hex_buf), "%02x", static_cast<unsigned int>(value));
+    repr += hex_buf;
   }
   return repr;
 }
@@ -146,7 +149,11 @@ ObisInfo::ObisInfo(const BytesView &server_id, const SmlNode &val_list_entry) :
 }
 
 std::string ObisInfo::code_repr() const {
-  return str_sprintf("%d-%d:%d.%d.%d", this->code[0], this->code[1], this->code[2], this->code[3], this->code[4]);
+  // max 20: "255-255:255.255.255" (19 chars) + null
+  char buf[20];
+  snprintf(buf, sizeof(buf), "%d-%d:%d.%d.%d", this->code[0], this->code[1], this->code[2], this->code[3],
+           this->code[4]);
+  return buf;
 }
 
 }  // namespace sml

esphome/components/sn74hc165/sn74hc165.cpp

@@ -65,7 +65,7 @@ float SN74HC165Component::get_setup_priority() const { return setup_priority::IO
 bool SN74HC165GPIOPin::digital_read() { return this->parent_->digital_read_(this->pin_) != this->inverted_; }
 
 size_t SN74HC165GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via SN74HC165", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via SN74HC165", this->pin_);
 }
 
 }  // namespace sn74hc165

esphome/components/sn74hc595/sn74hc595.cpp

@@ -94,7 +94,7 @@ void SN74HC595GPIOPin::digital_write(bool value) {
   this->parent_->digital_write_(this->pin_, value != this->inverted_);
 }
 size_t SN74HC595GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via SN74HC595", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via SN74HC595", this->pin_);
 }
 
 }  // namespace sn74hc595

esphome/components/sx1509/sx1509_gpio_pin.cpp

@@ -13,7 +13,7 @@ void SX1509GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->
 bool SX1509GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void SX1509GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
 size_t SX1509GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via sx1509", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via sx1509", this->pin_);
 }
 
 }  // namespace sx1509

esphome/components/syslog/esphome_syslog.cpp

@@ -47,29 +47,27 @@ void Syslog::log_(const int level, const char *tag, const char *message, size_t
   size_t remaining = sizeof(packet);
 
   // Write PRI - abort if this fails as packet would be malformed
-  int ret = snprintf(packet, remaining, "<%d>", pri);
-  if (ret <= 0 || static_cast<size_t>(ret) >= remaining) {
-    return;
+  offset = buf_append_printf(packet, sizeof(packet), 0, "<%d>", pri);
+  if (offset == 0) {
+    return;  // PRI always produces at least "<0>" (3 chars), so 0 means error
   }
-  offset = ret;
-  remaining -= ret;
+  remaining -= offset;
 
   // Write timestamp directly into packet (RFC 5424: use "-" if time not valid or strftime fails)
   auto now = this->time_->now();
   size_t ts_written = now.is_valid() ? now.strftime(packet + offset, remaining, "%b %e %H:%M:%S") : 0;
   if (ts_written > 0) {
     offset += ts_written;
-    remaining -= ts_written;
   } else if (remaining > 0) {
     packet[offset++] = '-';
-    remaining--;
   }
 
   // Write hostname, tag, and message
-  ret = snprintf(packet + offset, remaining, " %s %s: %.*s", App.get_name().c_str(), tag, (int) len, message);
-  if (ret > 0) {
-    // snprintf returns chars that would be written; clamp to actual buffer space
-    offset += std::min(static_cast<size_t>(ret), remaining > 0 ? remaining - 1 : 0);
+  offset = buf_append_printf(packet, sizeof(packet), offset, " %s %s: %.*s", App.get_name().c_str(), tag, (int) len,
+                             message);
+  // Clamp to exclude null terminator position if buffer was filled
+  if (offset >= sizeof(packet)) {
+    offset = sizeof(packet) - 1;
   }
 
   if (offset > 0) {

esphome/components/tca9555/tca9555.cpp

@@ -139,7 +139,7 @@ void TCA9555GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this-
 bool TCA9555GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void TCA9555GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
 size_t TCA9555GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via TCA9555", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via TCA9555", this->pin_);
 }
 
 }  // namespace tca9555

esphome/components/tormatic/tormatic_protocol.h

@@ -55,6 +55,7 @@ enum MessageType : uint16_t {
   COMMAND = 0x0106,
 };
 
+// Max string length: 7 ("Unknown"/"Command"). Update print() buffer sizes if adding longer strings.
 inline const char *message_type_to_str(MessageType t) {
   switch (t) {
     case STATUS:
@@ -83,7 +84,11 @@ struct MessageHeader {
   }
 
   std::string print() {
-    return str_sprintf("MessageHeader: seq %d, len %d, type %s", this->seq, this->len, message_type_to_str(this->type));
+    // 64 bytes: "MessageHeader: seq " + uint16 + ", len " + uint32 + ", type " + type + safety margin
+    char buf[64];
+    buf_append_printf(buf, sizeof(buf), 0, "MessageHeader: seq %d, len %d, type %s", this->seq, this->len,
+                      message_type_to_str(this->type));
+    return buf;
   }
 
   void byteswap() {
@@ -131,6 +136,7 @@ inline CoverOperation gate_status_to_cover_operation(GateStatus s) {
   return COVER_OPERATION_IDLE;
 }
 
+// Max string length: 11 ("Ventilating"). Update print() buffer sizes if adding longer strings.
 inline const char *gate_status_to_str(GateStatus s) {
   switch (s) {
     case PAUSED:
@@ -170,7 +176,12 @@ struct StatusReply {
   GateStatus state;
   uint8_t trailer = 0x0;
 
-  std::string print() { return str_sprintf("StatusReply: state %s", gate_status_to_str(this->state)); }
+  std::string print() {
+    // 48 bytes: "StatusReply: state " (19) + state (11) + safety margin
+    char buf[48];
+    buf_append_printf(buf, sizeof(buf), 0, "StatusReply: state %s", gate_status_to_str(this->state));
+    return buf;
+  }
 
   void byteswap(){};
 } __attribute__((packed));
@@ -202,7 +213,12 @@ struct CommandRequestReply {
   CommandRequestReply() = default;
   CommandRequestReply(GateStatus state) { this->state = state; }
 
-  std::string print() { return str_sprintf("CommandRequestReply: state %s", gate_status_to_str(this->state)); }
+  std::string print() {
+    // 56 bytes: "CommandRequestReply: state " (27) + state (11) + safety margin
+    char buf[56];
+    buf_append_printf(buf, sizeof(buf), 0, "CommandRequestReply: state %s", gate_status_to_str(this->state));
+    return buf;
+  }
 
   void byteswap() { this->type = convert_big_endian(this->type); }
 } __attribute__((packed));

esphome/components/toshiba/toshiba.cpp

@@ -1,5 +1,6 @@
 #include "toshiba.h"
 #include "esphome/components/remote_base/toshiba_ac_protocol.h"
+#include "esphome/core/helpers.h"
 
 #include <vector>
 
@@ -427,10 +428,17 @@ void ToshibaClimate::setup() {
   // Never send nan to HA
   if (std::isnan(this->target_temperature))
     this->target_temperature = 24;
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   // Log final state for debugging HA errors
-  ESP_LOGV(TAG, "Setup complete - Mode: %d, Fan: %s, Swing: %d, Temp: %.1f", static_cast<int>(this->mode),
-           this->fan_mode.has_value() ? std::to_string(static_cast<int>(this->fan_mode.value())).c_str() : "NONE",
+  const char *fan_mode_str = "NONE";
+  char fan_mode_buf[4];  // max 3 digits for fan mode enum + null
+  if (this->fan_mode.has_value()) {
+    buf_append_printf(fan_mode_buf, sizeof(fan_mode_buf), 0, "%d", static_cast<int>(this->fan_mode.value()));
+    fan_mode_str = fan_mode_buf;
+  }
+  ESP_LOGV(TAG, "Setup complete - Mode: %d, Fan: %s, Swing: %d, Temp: %.1f", static_cast<int>(this->mode), fan_mode_str,
            static_cast<int>(this->swing_mode), this->target_temperature);
+#endif
 }
 
 void ToshibaClimate::transmit_state() {

esphome/components/tuya/light/tuya_light.cpp

@@ -191,7 +191,7 @@ void TuyaLight::write_state(light::LightState *state) {
       case TuyaColorType::RGB: {
         char buffer[7];
         const char *format_str = this->color_type_lowercase_ ? "%02x%02x%02x" : "%02X%02X%02X";
-        sprintf(buffer, format_str, int(red * 255), int(green * 255), int(blue * 255));
+        snprintf(buffer, sizeof(buffer), format_str, int(red * 255), int(green * 255), int(blue * 255));
         color_value = buffer;
         break;
       }
@@ -201,7 +201,7 @@ void TuyaLight::write_state(light::LightState *state) {
         rgb_to_hsv(red, green, blue, hue, saturation, value);
         char buffer[13];
         const char *format_str = this->color_type_lowercase_ ? "%04x%04x%04x" : "%04X%04X%04X";
-        sprintf(buffer, format_str, hue, int(saturation * 1000), int(value * 1000));
+        snprintf(buffer, sizeof(buffer), format_str, hue, int(saturation * 1000), int(value * 1000));
         color_value = buffer;
         break;
       }
@@ -211,8 +211,8 @@ void TuyaLight::write_state(light::LightState *state) {
         rgb_to_hsv(red, green, blue, hue, saturation, value);
         char buffer[15];
         const char *format_str = this->color_type_lowercase_ ? "%02x%02x%02x%04x%02x%02x" : "%02X%02X%02X%04X%02X%02X";
-        sprintf(buffer, format_str, int(red * 255), int(green * 255), int(blue * 255), hue, int(saturation * 255),
-                int(value * 255));
+        snprintf(buffer, sizeof(buffer), format_str, int(red * 255), int(green * 255), int(blue * 255), hue,
+                 int(saturation * 255), int(value * 255));
         color_value = buffer;
         break;
       }

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
-        snprintf(buf, sizeof(buf), "%u", datapoint.value_enum);
+        buf_append_printf(buf, sizeof(buf), 0, "%u", datapoint.value_enum);
         ESP_LOGD(TAG, "MCU reported text sensor %u is: %s", datapoint.id, buf);
         this->publish_state(buf);
         break;

esphome/components/uart/uart_debugger.cpp

@@ -107,7 +107,7 @@ void UARTDebug::log_hex(UARTDirection direction, std::vector<uint8_t> bytes, uin
     if (i > 0) {
       res += separator;
     }
-    sprintf(buf, "%02X", bytes[i]);
+    buf_append_printf(buf, sizeof(buf), 0, "%02X", bytes[i]);
     res += buf;
   }
   ESP_LOGD(TAG, "%s", res.c_str());
@@ -147,7 +147,7 @@ void UARTDebug::log_string(UARTDirection direction, std::vector<uint8_t> bytes)
     } else if (bytes[i] == 92) {
       res += "\\\\";
     } else if (bytes[i] < 32 || bytes[i] > 127) {
-      sprintf(buf, "\\x%02X", bytes[i]);
+      buf_append_printf(buf, sizeof(buf), 0, "\\x%02X", bytes[i]);
       res += buf;
     } else {
       res += bytes[i];
@@ -166,11 +166,13 @@ void UARTDebug::log_int(UARTDirection direction, std::vector<uint8_t> bytes, uin
   } else {
     res += ">>> ";
   }
+  char buf[4];  // max 3 digits for uint8_t (255) + null
   for (size_t i = 0; i < len; i++) {
     if (i > 0) {
       res += separator;
     }
-    res += to_string(bytes[i]);
+    buf_append_printf(buf, sizeof(buf), 0, "%u", bytes[i]);
+    res += buf;
   }
   ESP_LOGD(TAG, "%s", res.c_str());
   delay(10);
@@ -189,7 +191,7 @@ void UARTDebug::log_binary(UARTDirection direction, std::vector<uint8_t> bytes,
     if (i > 0) {
       res += separator;
     }
-    sprintf(buf, "0b" BYTE_TO_BINARY_PATTERN " (0x%02X)", BYTE_TO_BINARY(bytes[i]), bytes[i]);
+    buf_append_printf(buf, sizeof(buf), 0, "0b" BYTE_TO_BINARY_PATTERN " (0x%02X)", BYTE_TO_BINARY(bytes[i]), bytes[i]);
     res += buf;
   }
   ESP_LOGD(TAG, "%s", res.c_str());

esphome/components/uptime/text_sensor/uptime_text_sensor.cpp

@@ -9,17 +9,12 @@ namespace uptime {
 
 static const char *const TAG = "uptime.sensor";
 
-// Clamp position to valid buffer range when snprintf indicates truncation
-static size_t clamp_buffer_pos(size_t pos, size_t buf_size) { return pos < buf_size ? pos : buf_size - 1; }
-
 static void append_unit(char *buf, size_t buf_size, size_t &pos, const char *separator, unsigned value,
                         const char *label) {
   if (pos > 0) {
-    pos += snprintf(buf + pos, buf_size - pos, "%s", separator);
-    pos = clamp_buffer_pos(pos, buf_size);
+    pos = buf_append_printf(buf, buf_size, pos, "%s", separator);
   }
-  pos += snprintf(buf + pos, buf_size - pos, "%u%s", value, label);
-  pos = clamp_buffer_pos(pos, buf_size);
+  pos = buf_append_printf(buf, buf_size, pos, "%u%s", value, label);
 }
 
 void UptimeTextSensor::setup() {

esphome/components/web_server/web_server.cpp

@@ -1188,11 +1188,7 @@ std::string WebServer::date_json_(datetime::DateEntity *obj, JsonDetail start_co
 
   // Format: YYYY-MM-DD (max 10 chars + null)
   char value[12];
-#ifdef USE_ESP8266
-  snprintf_P(value, sizeof(value), PSTR("%d-%02d-%02d"), obj->year, obj->month, obj->day);
-#else
-  snprintf(value, sizeof(value), "%d-%02d-%02d", obj->year, obj->month, obj->day);
-#endif
+  buf_append_printf(value, sizeof(value), 0, "%d-%02d-%02d", obj->year, obj->month, obj->day);
   set_json_icon_state_value(root, obj, "date", value, value, start_config);
   if (start_config == DETAIL_ALL) {
     this->add_sorting_info_(root, obj);
@@ -1251,11 +1247,7 @@ std::string WebServer::time_json_(datetime::TimeEntity *obj, JsonDetail start_co
 
   // Format: HH:MM:SS (8 chars + null)
   char value[12];
-#ifdef USE_ESP8266
-  snprintf_P(value, sizeof(value), PSTR("%02d:%02d:%02d"), obj->hour, obj->minute, obj->second);
-#else
-  snprintf(value, sizeof(value), "%02d:%02d:%02d", obj->hour, obj->minute, obj->second);
-#endif
+  buf_append_printf(value, sizeof(value), 0, "%02d:%02d:%02d", obj->hour, obj->minute, obj->second);
   set_json_icon_state_value(root, obj, "time", value, value, start_config);
   if (start_config == DETAIL_ALL) {
     this->add_sorting_info_(root, obj);
@@ -1314,13 +1306,8 @@ std::string WebServer::datetime_json_(datetime::DateTimeEntity *obj, JsonDetail
 
   // Format: YYYY-MM-DD HH:MM:SS (max 19 chars + null)
   char value[24];
-#ifdef USE_ESP8266
-  snprintf_P(value, sizeof(value), PSTR("%d-%02d-%02d %02d:%02d:%02d"), obj->year, obj->month, obj->day, obj->hour,
-             obj->minute, obj->second);
-#else
-  snprintf(value, sizeof(value), "%d-%02d-%02d %02d:%02d:%02d", obj->year, obj->month, obj->day, obj->hour, obj->minute,
-           obj->second);
-#endif
+  buf_append_printf(value, sizeof(value), 0, "%d-%02d-%02d %02d:%02d:%02d", obj->year, obj->month, obj->day, obj->hour,
+                    obj->minute, obj->second);
   set_json_icon_state_value(root, obj, "datetime", value, value, start_config);
   if (start_config == DETAIL_ALL) {
     this->add_sorting_info_(root, obj);

esphome/components/weikai/weikai.cpp

@@ -246,7 +246,7 @@ void WeikaiGPIOPin::setup() {
 }
 
 size_t WeikaiGPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via WeiKai %s", this->pin_, this->parent_->get_name());
+  return buf_append_printf(buffer, len, 0, "%u via WeiKai %s", this->pin_, this->parent_->get_name());
 }
 
 ///////////////////////////////////////////////////////////////////////////////

esphome/components/wiegand/wiegand.cpp

@@ -1,4 +1,5 @@
 #include "wiegand.h"
+#include <cinttypes>
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
@@ -69,32 +70,35 @@ void Wiegand::loop() {
   for (auto *trigger : this->raw_triggers_)
     trigger->trigger(count, value);
   if (count == 26) {
-    std::string tag = to_string((value >> 1) & 0xffffff);
-    ESP_LOGD(TAG, "received 26-bit tag: %s", tag.c_str());
+    char tag_buf[12];  // max 8 digits for 24-bit value + null
+    buf_append_printf(tag_buf, sizeof(tag_buf), 0, "%" PRIu32, static_cast<uint32_t>((value >> 1) & 0xffffff));
+    ESP_LOGD(TAG, "received 26-bit tag: %s", tag_buf);
     if (!check_eparity(value, 13, 13) || !check_oparity(value, 0, 13)) {
       ESP_LOGW(TAG, "invalid parity");
       return;
     }
     for (auto *trigger : this->tag_triggers_)
-      trigger->trigger(tag);
+      trigger->trigger(tag_buf);
   } else if (count == 34) {
-    std::string tag = to_string((value >> 1) & 0xffffffff);
-    ESP_LOGD(TAG, "received 34-bit tag: %s", tag.c_str());
+    char tag_buf[12];  // max 10 digits for 32-bit value + null
+    buf_append_printf(tag_buf, sizeof(tag_buf), 0, "%" PRIu32, static_cast<uint32_t>((value >> 1) & 0xffffffff));
+    ESP_LOGD(TAG, "received 34-bit tag: %s", tag_buf);
     if (!check_eparity(value, 17, 17) || !check_oparity(value, 0, 17)) {
       ESP_LOGW(TAG, "invalid parity");
       return;
     }
     for (auto *trigger : this->tag_triggers_)
-      trigger->trigger(tag);
+      trigger->trigger(tag_buf);
   } else if (count == 37) {
-    std::string tag = to_string((value >> 1) & 0x7ffffffff);
-    ESP_LOGD(TAG, "received 37-bit tag: %s", tag.c_str());
+    char tag_buf[12];  // max 11 digits for 35-bit value + null
+    buf_append_printf(tag_buf, sizeof(tag_buf), 0, "%" PRIu64, static_cast<uint64_t>((value >> 1) & 0x7ffffffff));
+    ESP_LOGD(TAG, "received 37-bit tag: %s", tag_buf);
     if (!check_eparity(value, 18, 19) || !check_oparity(value, 0, 19)) {
       ESP_LOGW(TAG, "invalid parity");
       return;
     }
     for (auto *trigger : this->tag_triggers_)
-      trigger->trigger(tag);
+      trigger->trigger(tag_buf);
   } else if (count == 4) {
     for (auto *trigger : this->key_triggers_)
       trigger->trigger(value);

esphome/components/xl9535/xl9535.cpp

@@ -111,7 +111,7 @@ void XL9535Component::pin_mode(uint8_t pin, gpio::Flags mode) {
 void XL9535GPIOPin::setup() { this->pin_mode(this->flags_); }
 
 size_t XL9535GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return snprintf(buffer, len, "%u via XL9535", this->pin_);
+  return buf_append_printf(buffer, len, 0, "%u via XL9535", this->pin_);
 }
 
 void XL9535GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }

esphome/components/zephyr/preferences.cpp

@@ -5,6 +5,8 @@
 #include "esphome/core/preferences.h"
 #include "esphome/core/log.h"
 #include <zephyr/settings/settings.h>
+#include <cinttypes>
+#include <cstring>
 
 namespace esphome {
 namespace zephyr {
@@ -13,6 +15,9 @@ static const char *const TAG = "zephyr.preferences";
 
 #define ESPHOME_SETTINGS_KEY "esphome"
 
+// Buffer size for key: "esphome/" (8) + max hex uint32 (8) + null terminator (1) = 17; use 20 for safety margin
+static constexpr size_t KEY_BUFFER_SIZE = 20;
+
 class ZephyrPreferenceBackend : public ESPPreferenceBackend {
  public:
   ZephyrPreferenceBackend(uint32_t type) { this->type_ = type; }
@@ -27,7 +32,9 @@ class ZephyrPreferenceBackend : public ESPPreferenceBackend {
 
   bool load(uint8_t *data, size_t len) override {
     if (len != this->data.size()) {
-      ESP_LOGE(TAG, "size of setting key %s changed, from: %u, to: %u", get_key().c_str(), this->data.size(), len);
+      char key_buf[KEY_BUFFER_SIZE];
+      this->format_key(key_buf, sizeof(key_buf));
+      ESP_LOGE(TAG, "size of setting key %s changed, from: %u, to: %u", key_buf, this->data.size(), len);
       return false;
     }
     std::memcpy(data, this->data.data(), len);
@@ -36,7 +43,7 @@ class ZephyrPreferenceBackend : public ESPPreferenceBackend {
   }
 
   uint32_t get_type() const { return this->type_; }
-  std::string get_key() const { return str_sprintf(ESPHOME_SETTINGS_KEY "/%" PRIx32, this->type_); }
+  void format_key(char *buf, size_t size) const { snprintf(buf, size, ESPHOME_SETTINGS_KEY "/%" PRIx32, this->type_); }
 
   std::vector<uint8_t> data;
 
@@ -85,7 +92,9 @@ class ZephyrPreferences : public ESPPreferences {
     }
     printf("type %u size %u\n", type, this->backends_.size());
     auto *pref = new ZephyrPreferenceBackend(type);  // NOLINT(cppcoreguidelines-owning-memory)
-    ESP_LOGD(TAG, "Add new setting %s.", pref->get_key().c_str());
+    char key_buf[KEY_BUFFER_SIZE];
+    pref->format_key(key_buf, sizeof(key_buf));
+    ESP_LOGD(TAG, "Add new setting %s.", key_buf);
     this->backends_.push_back(pref);
     return ESPPreferenceObject(pref);
   }
@@ -134,9 +143,10 @@ class ZephyrPreferences : public ESPPreferences {
 
   static int export_settings(int (*cb)(const char *name, const void *value, size_t val_len)) {
     for (auto *backend : static_cast<ZephyrPreferences *>(global_preferences)->backends_) {
-      auto name = backend->get_key();
-      int err = cb(name.c_str(), backend->data.data(), backend->data.size());
-      ESP_LOGD(TAG, "save in flash, name %s, len %u, err %d", name.c_str(), backend->data.size(), err);
+      char name[KEY_BUFFER_SIZE];
+      backend->format_key(name, sizeof(name));
+      int err = cb(name, backend->data.data(), backend->data.size());
+      ESP_LOGD(TAG, "save in flash, name %s, len %u, err %d", name, backend->data.size(), err);
     }
     return 0;
   }

esphome/core/automation.h

@@ -4,6 +4,7 @@
 #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>
@@ -190,15 +191,55 @@ 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_; }
 
- protected:
-  enum : uint8_t {
-    NONE,
-    VALUE,
-    LAMBDA,
-    STATELESS_LAMBDA,
-    STATIC_STRING,  // For const char* when T is std::string - avoids heap allocation
-  } type_;
+  /// 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();
+    }
+  }
 
+  /// 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.cpp

@@ -206,11 +206,22 @@ std::string str_snake_case(const std::string &str) {
   }
   return result;
 }
-std::string str_sanitize(const std::string &str) {
-  std::string result = str;
-  for (char &c : result) {
-    c = to_sanitized_char(c);
+char *str_sanitize_to(char *buffer, size_t buffer_size, const char *str) {
+  if (buffer_size == 0) {
+    return buffer;
   }
+  size_t i = 0;
+  while (*str && i < buffer_size - 1) {
+    buffer[i++] = to_sanitized_char(*str++);
+  }
+  buffer[i] = '\0';
+  return buffer;
+}
+
+std::string str_sanitize(const std::string &str) {
+  std::string result;
+  result.resize(str.size());
+  str_sanitize_to(&result[0], str.size() + 1, str.c_str());
   return result;
 }
 std::string str_snprintf(const char *fmt, size_t len, ...) {

esphome/core/helpers.h

@@ -609,7 +609,25 @@ std::string str_snake_case(const std::string &str);
 constexpr char to_sanitized_char(char c) {
   return (c == '-' || c == '_' || (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) ? c : '_';
 }
+
+/** Sanitize a string to buffer, keeping only alphanumerics, dashes, and underscores.
+ *
+ * @param buffer Output buffer to write to.
+ * @param buffer_size Size of the output buffer.
+ * @param str Input string to sanitize.
+ * @return Pointer to buffer.
+ *
+ * Buffer size needed: strlen(str) + 1.
+ */
+char *str_sanitize_to(char *buffer, size_t buffer_size, const char *str);
+
+/// Sanitize a string to buffer. Automatically deduces buffer size.
+template<size_t N> inline char *str_sanitize_to(char (&buffer)[N], const char *str) {
+  return str_sanitize_to(buffer, N, str);
+}
+
 /// Sanitizes the input string by removing all characters but alphanumerics, dashes and underscores.
+/// @warning Allocates heap memory. Use str_sanitize_to() with a stack buffer instead.
 std::string str_sanitize(const std::string &str);
 
 /// Calculate FNV-1 hash of a string while applying snake_case + sanitize transformations.

esphome/core/scheduler.h

@@ -403,7 +403,9 @@ class Scheduler {
       for (size_t i = 0; i < remaining; i++) {
         this->defer_queue_[i] = std::move(this->defer_queue_[this->defer_queue_front_ + i]);
       }
-      this->defer_queue_.resize(remaining);
+      // Use erase() instead of resize() to avoid instantiating _M_default_append
+      // (saves ~156 bytes flash). Erasing from the end is O(1) - no shifting needed.
+      this->defer_queue_.erase(this->defer_queue_.begin() + remaining, this->defer_queue_.end());
     }
     this->defer_queue_front_ = 0;
   }

esphome/core/string_ref.h

@@ -72,6 +72,7 @@ class StringRef {
 
   constexpr const char *c_str() const { return base_; }
   constexpr size_type size() const { return len_; }
+  constexpr size_type length() const { return len_; }
   constexpr bool empty() const { return len_ == 0; }
   constexpr const_reference operator[](size_type pos) const { return *(base_ + pos); }
 
@@ -80,6 +81,32 @@ class StringRef {
 
   operator std::string() const { return str(); }
 
+  /// Find first occurrence of substring, returns std::string::npos if not found.
+  /// Note: Requires the underlying string to be null-terminated.
+  size_type find(const char *s, size_type pos = 0) const {
+    if (pos >= len_)
+      return std::string::npos;
+    const char *result = std::strstr(base_ + pos, s);
+    // Verify entire match is within bounds (strstr searches to null terminator)
+    if (result && result + std::strlen(s) <= base_ + len_)
+      return static_cast<size_type>(result - base_);
+    return std::string::npos;
+  }
+  size_type find(char c, size_type pos = 0) const {
+    if (pos >= len_)
+      return std::string::npos;
+    const void *result = std::memchr(base_ + pos, static_cast<unsigned char>(c), len_ - pos);
+    return result ? static_cast<size_type>(static_cast<const char *>(result) - base_) : std::string::npos;
+  }
+
+  /// Return substring as std::string
+  std::string substr(size_type pos = 0, size_type count = std::string::npos) const {
+    if (pos >= len_)
+      return std::string();
+    size_type actual_count = (count == std::string::npos || pos + count > len_) ? len_ - pos : count;
+    return std::string(base_ + pos, actual_count);
+  }
+
  private:
   const char *base_;
   size_type len_;
@@ -160,6 +187,43 @@ inline std::string operator+(const std::string &lhs, const StringRef &rhs) {
   str.append(rhs.c_str(), rhs.size());
   return str;
 }
+// String conversion functions for ADL compatibility (allows stoi(x) where x is StringRef)
+// Must be in esphome namespace for ADL to find them. Uses strtol/strtod directly to avoid heap allocation.
+namespace internal {
+// NOLINTBEGIN(google-runtime-int)
+template<typename R, typename F> inline R parse_number(const StringRef &str, size_t *pos, F conv) {
+  char *end;
+  R result = conv(str.c_str(), &end);
+  // Set pos to 0 on conversion failure (when no characters consumed), otherwise index after number
+  if (pos)
+    *pos = (end == str.c_str()) ? 0 : static_cast<size_t>(end - str.c_str());
+  return result;
+}
+template<typename R, typename F> inline R parse_number(const StringRef &str, size_t *pos, int base, F conv) {
+  char *end;
+  R result = conv(str.c_str(), &end, base);
+  // Set pos to 0 on conversion failure (when no characters consumed), otherwise index after number
+  if (pos)
+    *pos = (end == str.c_str()) ? 0 : static_cast<size_t>(end - str.c_str());
+  return result;
+}
+// NOLINTEND(google-runtime-int)
+}  // namespace internal
+// NOLINTBEGIN(readability-identifier-naming,google-runtime-int)
+inline int stoi(const StringRef &str, size_t *pos = nullptr, int base = 10) {
+  return static_cast<int>(internal::parse_number<long>(str, pos, base, std::strtol));
+}
+inline long stol(const StringRef &str, size_t *pos = nullptr, int base = 10) {
+  return internal::parse_number<long>(str, pos, base, std::strtol);
+}
+inline float stof(const StringRef &str, size_t *pos = nullptr) {
+  return internal::parse_number<float>(str, pos, std::strtof);
+}
+inline double stod(const StringRef &str, size_t *pos = nullptr) {
+  return internal::parse_number<double>(str, pos, std::strtod);
+}
+// NOLINTEND(readability-identifier-naming,google-runtime-int)
+
 #ifdef USE_JSON
 // NOLINTNEXTLINE(readability-identifier-naming)
 inline void convertToJson(const StringRef &src, JsonVariant dst) { dst.set(src.c_str()); }

esphome/cpp_types.py

@@ -44,3 +44,4 @@ gpio_Flags = gpio_ns.enum("Flags", is_class=True)
 EntityCategory = esphome_ns.enum("EntityCategory")
 Parented = esphome_ns.class_("Parented")
 ESPTime = esphome_ns.struct("ESPTime")
+StringRef = esphome_ns.class_("StringRef")

script/ci-custom.py

@@ -688,6 +688,7 @@ HEAP_ALLOCATING_HELPERS = {
     "format_mac_address_pretty": "format_mac_addr_upper() with a stack buffer",
     "get_mac_address": "get_mac_address_into_buffer() with a stack buffer",
     "get_mac_address_pretty": "get_mac_address_pretty_into_buffer() with a stack buffer",
+    "str_sanitize": "str_sanitize_to() with a stack buffer",
     "str_truncate": "removal (function is unused)",
     "str_upper_case": "removal (function is unused)",
     "str_snake_case": "removal (function is unused)",
@@ -706,6 +707,7 @@ HEAP_ALLOCATING_HELPERS = {
     r"format_mac_address_pretty|"
     r"get_mac_address_pretty(?!_)|"
     r"get_mac_address(?!_)|"
+    r"str_sanitize(?!_)|"
     r"str_truncate|"
     r"str_upper_case|"
     r"str_snake_case"

tests/integration/fixtures/select_stringref_trigger.yaml

@@ -0,0 +1,85 @@
+esphome:
+  name: select-stringref-test
+  friendly_name: Select StringRef Test
+
+host:
+
+logger:
+  level: DEBUG
+
+api:
+
+select:
+  - platform: template
+    name: "Test Select"
+    id: test_select
+    optimistic: true
+    options:
+      - "Option A"
+      - "Option B"
+      - "Option C"
+    initial_option: "Option A"
+    on_value:
+      then:
+        # Test 1: Log the value directly (StringRef -> const char* via c_str())
+        - logger.log:
+            format: "Select value: %s"
+            args: ['x.c_str()']
+        # Test 2: String concatenation (StringRef + const char* -> std::string)
+        - lambda: |-
+            std::string with_suffix = x + " selected";
+            ESP_LOGI("test", "Concatenated: %s", with_suffix.c_str());
+        # Test 3: Comparison (StringRef == const char*)
+        - lambda: |-
+            if (x == "Option B") {
+              ESP_LOGI("test", "Option B was selected");
+            }
+        # Test 4: Use index parameter (variable name is 'i')
+        - lambda: |-
+            ESP_LOGI("test", "Select index: %d", (int)i);
+        # Test 5: StringRef.length() method
+        - lambda: |-
+            ESP_LOGI("test", "Length: %d", (int)x.length());
+        # Test 6: StringRef.find() method with substring
+        - lambda: |-
+            if (x.find("Option") != std::string::npos) {
+              ESP_LOGI("test", "Found 'Option' in value");
+            }
+        # Test 7: StringRef.find() method with character
+        - lambda: |-
+            size_t space_pos = x.find(' ');
+            if (space_pos != std::string::npos) {
+              ESP_LOGI("test", "Space at position: %d", (int)space_pos);
+            }
+        # Test 8: StringRef.substr() method
+        - lambda: |-
+            std::string prefix = x.substr(0, 6);
+            ESP_LOGI("test", "Substr prefix: %s", prefix.c_str());
+
+  # Second select with numeric options to test ADL functions
+  - platform: template
+    name: "Baud Rate"
+    id: baud_select
+    optimistic: true
+    options:
+      - "9600"
+      - "115200"
+    initial_option: "9600"
+    on_value:
+      then:
+        # Test 9: stoi via ADL
+        - lambda: |-
+            int baud = stoi(x);
+            ESP_LOGI("test", "stoi result: %d", baud);
+        # Test 10: stol via ADL
+        - lambda: |-
+            long baud_long = stol(x);
+            ESP_LOGI("test", "stol result: %ld", baud_long);
+        # Test 11: stof via ADL
+        - lambda: |-
+            float baud_float = stof(x);
+            ESP_LOGI("test", "stof result: %.0f", baud_float);
+        # Test 12: stod via ADL
+        - lambda: |-
+            double baud_double = stod(x);
+            ESP_LOGI("test", "stod result: %.0f", baud_double);

tests/integration/test_select_stringref_trigger.py

@@ -0,0 +1,143 @@
+"""Integration test for select on_value trigger with StringRef parameter."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_select_stringref_trigger(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test select on_value trigger passes StringRef that works with string operations."""
+    loop = asyncio.get_running_loop()
+
+    # Track log messages to verify StringRef operations work
+    value_logged_future = loop.create_future()
+    concatenated_future = loop.create_future()
+    comparison_future = loop.create_future()
+    index_logged_future = loop.create_future()
+    length_future = loop.create_future()
+    find_substr_future = loop.create_future()
+    find_char_future = loop.create_future()
+    substr_future = loop.create_future()
+    # ADL functions
+    stoi_future = loop.create_future()
+    stol_future = loop.create_future()
+    stof_future = loop.create_future()
+    stod_future = loop.create_future()
+
+    # Patterns to match in logs
+    value_pattern = re.compile(r"Select value: Option B")
+    concatenated_pattern = re.compile(r"Concatenated: Option B selected")
+    comparison_pattern = re.compile(r"Option B was selected")
+    index_pattern = re.compile(r"Select index: 1")
+    length_pattern = re.compile(r"Length: 8")  # "Option B" is 8 chars
+    find_substr_pattern = re.compile(r"Found 'Option' in value")
+    find_char_pattern = re.compile(r"Space at position: 6")  # space at index 6
+    substr_pattern = re.compile(r"Substr prefix: Option")
+    # ADL function patterns (115200 from baud rate select)
+    stoi_pattern = re.compile(r"stoi result: 115200")
+    stol_pattern = re.compile(r"stol result: 115200")
+    stof_pattern = re.compile(r"stof result: 115200")
+    stod_pattern = re.compile(r"stod result: 115200")
+
+    def check_output(line: str) -> None:
+        """Check log output for expected messages."""
+        if not value_logged_future.done() and value_pattern.search(line):
+            value_logged_future.set_result(True)
+        if not concatenated_future.done() and concatenated_pattern.search(line):
+            concatenated_future.set_result(True)
+        if not comparison_future.done() and comparison_pattern.search(line):
+            comparison_future.set_result(True)
+        if not index_logged_future.done() and index_pattern.search(line):
+            index_logged_future.set_result(True)
+        if not length_future.done() and length_pattern.search(line):
+            length_future.set_result(True)
+        if not find_substr_future.done() and find_substr_pattern.search(line):
+            find_substr_future.set_result(True)
+        if not find_char_future.done() and find_char_pattern.search(line):
+            find_char_future.set_result(True)
+        if not substr_future.done() and substr_pattern.search(line):
+            substr_future.set_result(True)
+        # ADL functions
+        if not stoi_future.done() and stoi_pattern.search(line):
+            stoi_future.set_result(True)
+        if not stol_future.done() and stol_pattern.search(line):
+            stol_future.set_result(True)
+        if not stof_future.done() and stof_pattern.search(line):
+            stof_future.set_result(True)
+        if not stod_future.done() and stod_pattern.search(line):
+            stod_future.set_result(True)
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        # Verify device info
+        device_info = await client.device_info()
+        assert device_info is not None
+        assert device_info.name == "select-stringref-test"
+
+        # List entities to find our select
+        entities, _ = await client.list_entities_services()
+
+        select_entity = next(
+            (e for e in entities if hasattr(e, "options") and e.name == "Test Select"),
+            None,
+        )
+        assert select_entity is not None, "Test Select entity not found"
+
+        baud_entity = next(
+            (e for e in entities if hasattr(e, "options") and e.name == "Baud Rate"),
+            None,
+        )
+        assert baud_entity is not None, "Baud Rate entity not found"
+
+        # Change select to Option B - this should trigger on_value with StringRef
+        client.select_command(select_entity.key, "Option B")
+        # Change baud to 115200 - this tests ADL functions (stoi, stol, stof, stod)
+        client.select_command(baud_entity.key, "115200")
+
+        # Wait for all log messages confirming StringRef operations work
+        try:
+            await asyncio.wait_for(
+                asyncio.gather(
+                    value_logged_future,
+                    concatenated_future,
+                    comparison_future,
+                    index_logged_future,
+                    length_future,
+                    find_substr_future,
+                    find_char_future,
+                    substr_future,
+                    stoi_future,
+                    stol_future,
+                    stof_future,
+                    stod_future,
+                ),
+                timeout=5.0,
+            )
+        except TimeoutError:
+            results = {
+                "value_logged": value_logged_future.done(),
+                "concatenated": concatenated_future.done(),
+                "comparison": comparison_future.done(),
+                "index_logged": index_logged_future.done(),
+                "length": length_future.done(),
+                "find_substr": find_substr_future.done(),
+                "find_char": find_char_future.done(),
+                "substr": substr_future.done(),
+                "stoi": stoi_future.done(),
+                "stol": stol_future.done(),
+                "stof": stof_future.done(),
+                "stod": stod_future.done(),
+            }
+            pytest.fail(f"StringRef operations failed - received: {results}")