Merge branch 'dev' into mqtt_formatting

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

esphome/codegen.py

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

esphome/components/cse7766/cse7766.cpp

@@ -207,24 +207,20 @@ void CSE7766Component::parse_data_() {
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   {
-    // 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:");
+    std::string buf = "Parsed:";
     if (have_voltage) {
-      pos = buf_append_printf(buf, sizeof(buf), pos, " V=%.4fV", voltage);
+      buf += str_sprintf(" V=%fV", voltage);
     }
     if (have_current) {
-      pos = buf_append_printf(buf, sizeof(buf), pos, " I=%.4fmA (~%.4fmA)", current * 1000.0f,
-                              calculated_current * 1000.0f);
+      buf += str_sprintf(" I=%fmA (~%fmA)", current * 1000.0f, calculated_current * 1000.0f);
     }
     if (have_power) {
-      pos = buf_append_printf(buf, sizeof(buf), pos, " P=%.4fW", power);
+      buf += str_sprintf(" P=%fW", power);
     }
     if (energy != 0.0f) {
-      buf_append_printf(buf, sizeof(buf), pos, " E=%.4fkWh (%u)", energy, cf_pulses);
+      buf += str_sprintf(" E=%fkWh (%u)", energy, cf_pulses);
     }
-    ESP_LOGVV(TAG, "%s", buf);
+    ESP_LOGVV(TAG, "%s", buf.c_str());
   }
 #endif
 }

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/dfrobot_sen0395/commands.cpp

@@ -127,9 +127,7 @@ 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;
 
-    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;
+    this->cmd_ = str_sprintf("detRangeCfg -1 %.0f %.0f", min1 / 0.15, max1 / 0.15);
   } else if (min3 < 0 || max3 < 0) {
     this->min1_ = min1 = round(min1 / 0.15) * 0.15;
     this->max1_ = max1 = round(max1 / 0.15) * 0.15;
@@ -137,10 +135,7 @@ 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;
 
-    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;
+    this->cmd_ = str_sprintf("detRangeCfg -1 %.0f %.0f %.0f %.0f", min1 / 0.15, max1 / 0.15, min2 / 0.15, max2 / 0.15);
   } else if (min4 < 0 || max4 < 0) {
     this->min1_ = min1 = round(min1 / 0.15) * 0.15;
     this->max1_ = max1 = round(max1 / 0.15) * 0.15;
@@ -150,10 +145,9 @@ 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;
 
-    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;
+    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);
   } else {
     this->min1_ = min1 = round(min1 / 0.15) * 0.15;
     this->max1_ = max1 = round(max1 / 0.15) * 0.15;
@@ -164,10 +158,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;
 
-    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->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);
   }
 
   this->min1_ = min1;
@@ -209,10 +203,7 @@ 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);
-  // 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;
+  this->cmd_ = str_sprintf("setLatency %.03f %.03f", this->delay_after_detection_, this->delay_after_disappear_);
 };
 
 uint8_t SetLatencyCommand::on_message(std::string &message) {

esphome/components/ezo/ezo.cpp

@@ -160,7 +160,7 @@ void EZOSensor::loop() {
   this->commands_.pop_front();
 }
 
-void EZOSensor::add_command_(const char *command, EzoCommandType command_type, uint16_t delay_ms) {
+void EZOSensor::add_command_(const std::string &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,17 +169,13 @@ void EZOSensor::add_command_(const char *command, EzoCommandType command_type, u
 }
 
 void EZOSensor::set_calibration_point_(EzoCalibrationType type, float 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);
+  std::string payload = str_sprintf("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) {
-    // max 8: "I2C,"(4) + uint8(3) + null
-    char payload[8];
-    snprintf(payload, sizeof(payload), "I2C,%u", address);
+    std::string payload = str_sprintf("I2C,%u", address);
     this->new_address_ = address;
     this->add_command_(payload, EzoCommandType::EZO_I2C);
   } else {
@@ -198,9 +194,7 @@ 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) {
-  // 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);
+  std::string payload = str_sprintf("T,%0.2f", value);
   this->add_command_(payload, EzoCommandType::EZO_T);
 }
 
@@ -221,9 +215,7 @@ void EZOSensor::set_calibration_point_high(float value) {
 }
 
 void EZOSensor::set_calibration_generic(float 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);
+  std::string payload = str_sprintf("Cal,%0.2f", value);
   this->add_command_(payload, EzoCommandType::EZO_CALIBRATION, 900);
 }
 
@@ -231,11 +223,13 @@ 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) { 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.c_str(), EzoCommandType::EZO_CUSTOM);
+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::send_custom(const std::string &to_send) { this->add_command_(to_send, 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 char *command, EzoCommandType command_type, uint16_t delay_ms = 300);
+  void add_command_(const std::string &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.StringRef)
+    "FanPresetSetTrigger", automation.Trigger.template(cg.std_string)
 )
 
 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.StringRef, "x")], conf)
+        await automation.build_automation(trigger, [(cg.std_string, "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<StringRef> {
+class FanPresetSetTrigger : public Trigger<std::string> {
  public:
   FanPresetSetTrigger(Fan *state) {
     state->add_on_state_callback([this, state]() {
@@ -216,7 +216,7 @@ class FanPresetSetTrigger : public Trigger<StringRef> {
       auto should_trigger = preset_mode != this->last_preset_mode_;
       this->last_preset_mode_ = preset_mode;
       if (should_trigger) {
-        this->trigger(preset_mode);
+        this->trigger(std::string(preset_mode));
       }
     });
     this->last_preset_mode_ = state->get_preset_mode();

esphome/components/gdk101/gdk101.cpp

@@ -163,10 +163,9 @@ bool GDK101Component::read_fw_version_(uint8_t *data) {
       return false;
     }
 
-    // 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);
+    const std::string fw_version_str = str_sprintf("%d.%d", data[0], data[1]);
+
+    this->fw_version_text_sensor_->publish_state(fw_version_str);
   }
 #endif  // USE_TEXT_SENSOR
   return true;

esphome/components/mqtt/custom_mqtt_device.cpp

@@ -18,7 +18,7 @@ bool CustomMQTTDevice::publish(const std::string &topic, float value, int8_t num
 }
 bool CustomMQTTDevice::publish(const std::string &topic, int value) {
   char buffer[24];
-  int len = snprintf(buffer, sizeof(buffer), "%d", value);
+  size_t len = buf_append_printf(buffer, sizeof(buffer), 0, "%d", value);
   return global_mqtt_client->publish(topic, buffer, len);
 }
 bool CustomMQTTDevice::publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos, bool retain) {

esphome/components/mqtt/mqtt_client.cpp

@@ -91,7 +91,17 @@ void MQTTClientComponent::send_device_info_() {
         uint8_t index = 0;
         for (auto &ip : network::get_ip_addresses()) {
           if (ip.is_set()) {
-            root["ip" + (index == 0 ? "" : esphome::to_string(index))] = ip.str();
+            char key[8];  // "ip" + up to 3 digits + null
+            char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
+            if (index == 0) {
+              key[0] = 'i';
+              key[1] = 'p';
+              key[2] = '\0';
+            } else {
+              buf_append_printf(key, sizeof(key), 0, "ip%u", index);
+            }
+            ip.str_to(ip_buf);
+            root[key] = ip_buf;
             index++;
           }
         }

esphome/components/mqtt/mqtt_component.cpp

@@ -190,27 +190,37 @@ bool MQTTComponent::send_discovery_() {
         StringRef object_id = this->get_default_object_id_to_(object_id_buf);
         if (discovery_info.unique_id_generator == MQTT_MAC_ADDRESS_UNIQUE_ID_GENERATOR) {
           char friendly_name_hash[9];
-          snprintf(friendly_name_hash, sizeof(friendly_name_hash), "%08" PRIx32, fnv1_hash(this->friendly_name_()));
+          buf_append_printf(friendly_name_hash, sizeof(friendly_name_hash), 0, "%08" PRIx32,
+                            fnv1_hash(this->friendly_name_()));
           // Format: mac-component_type-hash (e.g. "aabbccddeeff-sensor-12345678")
           // MAC (12) + "-" (1) + domain (max 20) + "-" (1) + hash (8) + null (1) = 43
           char unique_id[MAC_ADDRESS_BUFFER_SIZE + ESPHOME_DOMAIN_MAX_LEN + 11];
           char mac_buf[MAC_ADDRESS_BUFFER_SIZE];
           get_mac_address_into_buffer(mac_buf);
-          snprintf(unique_id, sizeof(unique_id), "%s-%s-%s", mac_buf, this->component_type(), friendly_name_hash);
+          buf_append_printf(unique_id, sizeof(unique_id), 0, "%s-%s-%s", mac_buf, this->component_type(),
+                            friendly_name_hash);
           root[MQTT_UNIQUE_ID] = unique_id;
         } else {
           // default to almost-unique ID. It's a hack but the only way to get that
           // gorgeous device registry view.
-          root[MQTT_UNIQUE_ID] = "ESP" + std::string(this->component_type()) + object_id.c_str();
+          // "ESP" (3) + component_type (max 20) + object_id (max 128) + null
+          char unique_id_buf[3 + MQTT_COMPONENT_TYPE_MAX_LEN + OBJECT_ID_MAX_LEN + 1];
+          buf_append_printf(unique_id_buf, sizeof(unique_id_buf), 0, "ESP%s%s", this->component_type(),
+                            object_id.c_str());
+          root[MQTT_UNIQUE_ID] = unique_id_buf;
         }
 
         const std::string &node_name = App.get_name();
-        if (discovery_info.object_id_generator == MQTT_DEVICE_NAME_OBJECT_ID_GENERATOR)
-          root[MQTT_OBJECT_ID] = node_name + "_" + object_id.c_str();
+        if (discovery_info.object_id_generator == MQTT_DEVICE_NAME_OBJECT_ID_GENERATOR) {
+          // node_name (max 31) + "_" (1) + object_id (max 128) + null
+          char object_id_full[ESPHOME_DEVICE_NAME_MAX_LEN + 1 + OBJECT_ID_MAX_LEN + 1];
+          buf_append_printf(object_id_full, sizeof(object_id_full), 0, "%s_%s", node_name.c_str(), object_id.c_str());
+          root[MQTT_OBJECT_ID] = object_id_full;
+        }
 
         const std::string &friendly_name_ref = App.get_friendly_name();
         const std::string &node_friendly_name = friendly_name_ref.empty() ? node_name : friendly_name_ref;
-        std::string node_area = App.get_area();
+        const char *node_area = App.get_area();
 
         JsonObject device_info = root[MQTT_DEVICE].to<JsonObject>();
         char mac[MAC_ADDRESS_BUFFER_SIZE];
@@ -221,18 +231,29 @@ bool MQTTComponent::send_discovery_() {
         device_info[MQTT_DEVICE_SW_VERSION] = ESPHOME_PROJECT_VERSION " (ESPHome " ESPHOME_VERSION ")";
         const char *model = std::strchr(ESPHOME_PROJECT_NAME, '.');
         device_info[MQTT_DEVICE_MODEL] = model == nullptr ? ESPHOME_BOARD : model + 1;
-        device_info[MQTT_DEVICE_MANUFACTURER] =
-            model == nullptr ? ESPHOME_PROJECT_NAME : std::string(ESPHOME_PROJECT_NAME, model - ESPHOME_PROJECT_NAME);
+        if (model == nullptr) {
+          device_info[MQTT_DEVICE_MANUFACTURER] = ESPHOME_PROJECT_NAME;
+        } else {
+          // Extract manufacturer (part before '.') using stack buffer to avoid heap allocation
+          // memcpy is used instead of strncpy since we know the exact length and strncpy
+          // would still require manual null-termination
+          char manufacturer[sizeof(ESPHOME_PROJECT_NAME)];
+          size_t len = model - ESPHOME_PROJECT_NAME;
+          memcpy(manufacturer, ESPHOME_PROJECT_NAME, len);
+          manufacturer[len] = '\0';
+          device_info[MQTT_DEVICE_MANUFACTURER] = manufacturer;
+        }
 #else
         static const char ver_fmt[] PROGMEM = ESPHOME_VERSION " (config hash 0x%08" PRIx32 ")";
+        // Buffer sized for format string expansion: ~4 bytes net growth from format specifier to 8 hex digits, plus
+        // safety margin
+        char version_buf[sizeof(ver_fmt) + 8];
 #ifdef USE_ESP8266
-        char fmt_buf[sizeof(ver_fmt)];
-        strcpy_P(fmt_buf, ver_fmt);
-        const char *fmt = fmt_buf;
+        snprintf_P(version_buf, sizeof(version_buf), ver_fmt, App.get_config_hash());
 #else
-        const char *fmt = ver_fmt;
+        snprintf(version_buf, sizeof(version_buf), ver_fmt, App.get_config_hash());
 #endif
-        device_info[MQTT_DEVICE_SW_VERSION] = str_sprintf(fmt, App.get_config_hash());
+        device_info[MQTT_DEVICE_SW_VERSION] = version_buf;
         device_info[MQTT_DEVICE_MODEL] = ESPHOME_BOARD;
 #if defined(USE_ESP8266) || defined(USE_ESP32)
         device_info[MQTT_DEVICE_MANUFACTURER] = "Espressif";
@@ -246,7 +267,7 @@ bool MQTTComponent::send_discovery_() {
         device_info[MQTT_DEVICE_MANUFACTURER] = "Host";
 #endif
 #endif
-        if (!node_area.empty()) {
+        if (node_area[0] != '\0') {
           device_info[MQTT_DEVICE_SUGGESTED_AREA] = node_area;
         }
 

esphome/components/mqtt/mqtt_fan.cpp

@@ -175,7 +175,7 @@ bool MQTTFanComponent::publish_state() {
   auto traits = this->state_->get_traits();
   if (traits.supports_speed()) {
     char buf[12];
-    int len = snprintf(buf, sizeof(buf), "%d", this->state_->speed);
+    size_t len = buf_append_printf(buf, sizeof(buf), 0, "%d", this->state_->speed);
     bool success = this->publish(this->get_speed_level_state_topic(), buf, len);
     failed = failed || !success;
   }

esphome/components/mqtt/mqtt_number.cpp

@@ -75,7 +75,7 @@ bool MQTTNumberComponent::send_initial_state() {
 }
 bool MQTTNumberComponent::publish_state(float value) {
   char buffer[64];
-  snprintf(buffer, sizeof(buffer), "%f", value);
+  buf_append_printf(buffer, sizeof(buffer), 0, "%f", value);
   return this->publish(this->get_state_topic_(), buffer);
 }
 

esphome/components/select/__init__.py

@@ -33,7 +33,7 @@ SelectPtr = Select.operator("ptr")
 # Triggers
 SelectStateTrigger = select_ns.class_(
     "SelectStateTrigger",
-    automation.Trigger.template(cg.StringRef, cg.size_t),
+    automation.Trigger.template(cg.std_string, 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.StringRef, "x"), (cg.size_t, "i")], conf
+            trigger, [(cg.std_string, "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<StringRef, size_t> {
+class SelectStateTrigger : public Trigger<std::string, size_t> {
  public:
   explicit SelectStateTrigger(Select *parent) : parent_(parent) {
     parent->add_on_state_callback(
-        [this](size_t index) { this->trigger(StringRef(this->parent_->option_at(index)), index); });
+        [this](size_t index) { this->trigger(std::string(this->parent_->option_at(index)), index); });
   }
 
  protected:

esphome/components/toshiba/toshiba.cpp

@@ -1,6 +1,5 @@
 #include "toshiba.h"
 #include "esphome/components/remote_base/toshiba_ac_protocol.h"
-#include "esphome/core/helpers.h"
 
 #include <vector>
 
@@ -428,17 +427,10 @@ 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
-  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,
+  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",
            static_cast<int>(this->swing_mode), this->target_temperature);
-#endif
 }
 
 void ToshibaClimate::transmit_state() {

esphome/core/scheduler.h

@@ -403,9 +403,7 @@ class Scheduler {
       for (size_t i = 0; i < remaining; i++) {
         this->defer_queue_[i] = std::move(this->defer_queue_[this->defer_queue_front_ + i]);
       }
-      // 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_.resize(remaining);
     }
     this->defer_queue_front_ = 0;
   }

esphome/core/string_ref.h

@@ -72,7 +72,6 @@ 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); }
 
@@ -81,32 +80,6 @@ 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_;
@@ -187,43 +160,6 @@ 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/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);

esphome/cpp_types.py

@@ -44,4 +44,3 @@ 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")

tests/integration/fixtures/select_stringref_trigger.yaml

@@ -1,85 +0,0 @@
-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

@@ -1,143 +0,0 @@
-"""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}")