Merge branch 'dev' into mqtt_formatting

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

esphome/components/api/homeassistant_service.h

@@ -25,9 +25,7 @@ template<typename... X> class TemplatableStringValue : public TemplatableValue<s
 
  private:
   // Helper to convert value to string - handles the case where value is already a string
-  template<typename T> static std::string value_to_string(T &&val) {
-    return to_string(std::forward<T>(val));  // NOLINT
-  }
+  template<typename T> static std::string value_to_string(T &&val) { return to_string(std::forward<T>(val)); }
 
   // Overloads for string types - needed because std::to_string doesn't support them
   static std::string value_to_string(char *val) {

esphome/components/cs5460a/cs5460a.h

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

esphome/components/esp32_ble/ble_uuid.h

@@ -48,7 +48,7 @@ class ESPBTUUID {
 
   // Remove before 2026.8.0
   ESPDEPRECATED("Use to_str() instead. Removed in 2026.8.0", "2026.2.0")
-  std::string to_string() const;  // NOLINT
+  std::string to_string() const;
   const char *to_str(std::span<char, UUID_STR_LEN> output) const;
 
  protected:

esphome/components/lock/lock.cpp

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

esphome/components/lock/lock.h

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

esphome/components/mapping/mapping.h

@@ -2,7 +2,6 @@
 
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include <cinttypes>
 #include <map>
 #include <string>
 
@@ -44,17 +43,8 @@ template<typename K, typename V> class Mapping {
       esph_log_e(TAG, "Key '%p' not found in mapping", key);
     } else if constexpr (std::is_same_v<K, std::string>) {
       esph_log_e(TAG, "Key '%s' not found in mapping", key.c_str());
-    } else if constexpr (std::is_integral_v<K>) {
-      char buf[24];  // enough for 64-bit integer
-      if constexpr (std::is_unsigned_v<K>) {
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRIu64, static_cast<uint64_t>(key));
-      } else {
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRId64, static_cast<int64_t>(key));
-      }
-      esph_log_e(TAG, "Key '%s' not found in mapping", buf);
     } else {
-      // All supported key types are handled above - this should never be reached
-      static_assert(sizeof(K) == 0, "Unsupported key type for Mapping error logging");
+      esph_log_e(TAG, "Key '%s' not found in mapping", to_string(key).c_str());
     }
     return {};
   }

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

@@ -98,7 +98,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++;
           }
         }
@@ -403,12 +413,6 @@ void MQTTClientComponent::loop() {
 
         this->last_connected_ = now;
         this->resubscribe_subscriptions_();
-
-        // Process pending resends for all MQTT components centrally
-        // This is more efficient than each component polling in its own loop
-        for (MQTTComponent *component : this->children_) {
-          component->process_resend();
-        }
       }
       break;
   }

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;
         }
 
@@ -308,12 +329,16 @@ void MQTTComponent::call_setup() {
   }
 }
 
-void MQTTComponent::process_resend() {
-  // Called by MQTTClientComponent when connected to process pending resends
-  // Note: is_internal() check not needed - internal components are never registered
-  if (!this->resend_state_)
+void MQTTComponent::call_loop() {
+  if (this->is_internal())
     return;
 
+  this->loop();
+
+  if (!this->resend_state_ || !this->is_connected_()) {
+    return;
+  }
+
   this->resend_state_ = false;
   if (this->is_discovery_enabled()) {
     if (!this->send_discovery_()) {

esphome/components/mqtt/mqtt_component.h

@@ -81,6 +81,8 @@ class MQTTComponent : public Component {
   /// Override setup_ so that we can call send_discovery() when needed.
   void call_setup() override;
 
+  void call_loop() override;
+
   void call_dump_config() override;
 
   /// Send discovery info the Home Assistant, override this.
@@ -131,9 +133,6 @@ class MQTTComponent : public Component {
   /// Internal method for the MQTT client base to schedule a resend of the state on reconnect.
   void schedule_resend_state();
 
-  /// Process pending resend if needed (called by MQTTClientComponent)
-  void process_resend();
-
   /** Send a MQTT message.
    *
    * @param topic The topic.

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/voice_assistant/voice_assistant.h

@@ -83,7 +83,7 @@ struct Timer {
   }
   // Remove before 2026.8.0
   ESPDEPRECATED("Use to_str() instead. Removed in 2026.8.0", "2026.2.0")
-  std::string to_string() const {  // NOLINT
+  std::string to_string() const {
     char buffer[TO_STR_BUFFER_SIZE];
     return this->to_str(buffer);
   }

script/ci-custom.py

@@ -732,47 +732,6 @@ def lint_no_heap_allocating_helpers(fname, match):
     )
 
 
-@lint_re_check(
-    # Match std::to_string() or unqualified to_string() calls
-    # The esphome namespace has "using std::to_string;" so unqualified calls resolve to std::to_string
-    # Use negative lookbehind to avoid matching:
-    #   - Function definitions: "const char *to_string(" or "std::string to_string("
-    #   - Method definitions: "Class::to_string("
-    #   - Method calls: ".to_string(" or "->to_string("
-    #   - Other identifiers: "_to_string("
-    r"(?<![*&.\w>:])to_string\s*\(" + CPP_RE_EOL,
-    include=cpp_include,
-    exclude=[
-        # Vendored library
-        "esphome/components/http_request/httplib.h",
-        # Deprecated helpers that return std::string
-        "esphome/core/helpers.cpp",
-        # The using declaration itself
-        "esphome/core/helpers.h",
-        # Test fixtures - not production embedded code
-        "tests/integration/fixtures/*",
-    ],
-)
-def lint_no_std_to_string(fname, match):
-    return (
-        f"{highlight('std::to_string()')} allocates heap memory. On long-running embedded "
-        f"devices, repeated heap allocations fragment memory over time.\n"
-        f"Please use {highlight('snprintf()')} with a stack buffer instead.\n"
-        f"\n"
-        f"Buffer sizes and format specifiers:\n"
-        f"  uint8_t/int8_t:   4 chars   - %u / %d (or PRIu8/PRId8)\n"
-        f"  uint16_t/int16_t: 6 chars   - %u / %d (or PRIu16/PRId16)\n"
-        f"  uint32_t/int32_t: 11 chars  - %" + "PRIu32 / %" + "PRId32\n"
-        "  uint64_t/int64_t: 21 chars  - %" + "PRIu64 / %" + "PRId64\n"
-        f"  float/double:     24 chars  - %.8g (15 digits + sign + decimal + e+XXX)\n"
-        f"                    317 chars - %f (for DBL_MAX: 309 int digits + decimal + 6 frac + sign)\n"
-        f"\n"
-        f"For sensor values, use value_accuracy_to_buf() from helpers.h.\n"
-        f'Example: char buf[11]; snprintf(buf, sizeof(buf), "%" PRIu32, value);\n'
-        f"(If strictly necessary, add `{highlight('// NOLINT')}` to the end of the line)"
-    )
-
-
 @lint_content_find_check(
     "ESP_LOG",
     include=["*.h", "*.tcc"],