more

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

esphome/components/light/light_json_schema.cpp

@@ -1,5 +1,4 @@
 #include "light_json_schema.h"
-#include "color_mode.h"
 #include "light_output.h"
 #include "esphome/core/progmem.h"
 
@@ -9,32 +8,29 @@ namespace esphome::light {
 
 // See https://www.home-assistant.io/integrations/light.mqtt/#json-schema for documentation on the schema
 
-// Get JSON string for color mode.
-// ColorMode enum values are sparse bitmasks (0, 1, 3, 7, 11, 19, 35, 39, 47, 51) which would
-// generate a large jump table. Converting to bit index (0-9) allows a compact switch.
-static ProgmemStr get_color_mode_json_str(ColorMode mode) {
-  switch (ColorModeBitPolicy::to_bit(mode)) {
-    case 1:
-      return ESPHOME_F("onoff");
-    case 2:
-      return ESPHOME_F("brightness");
-    case 3:
-      return ESPHOME_F("white");
-    case 4:
-      return ESPHOME_F("color_temp");
-    case 5:
-      return ESPHOME_F("cwww");
-    case 6:
-      return ESPHOME_F("rgb");
-    case 7:
-      return ESPHOME_F("rgbw");
-    case 8:
-      return ESPHOME_F("rgbct");
-    case 9:
-      return ESPHOME_F("rgbww");
-    default:
-      return nullptr;
+// Get JSON string for color mode using linear search (avoids large switch jump table)
+static const char *get_color_mode_json_str(ColorMode mode) {
+  // Parallel arrays: mode values and their corresponding strings
+  // Uses less RAM than a switch jump table on sparse enum values
+  static constexpr ColorMode MODES[] = {
+      ColorMode::ON_OFF,
+      ColorMode::BRIGHTNESS,
+      ColorMode::WHITE,
+      ColorMode::COLOR_TEMPERATURE,
+      ColorMode::COLD_WARM_WHITE,
+      ColorMode::RGB,
+      ColorMode::RGB_WHITE,
+      ColorMode::RGB_COLOR_TEMPERATURE,
+      ColorMode::RGB_COLD_WARM_WHITE,
+  };
+  static constexpr const char *STRINGS[] = {
+      "onoff", "brightness", "white", "color_temp", "cwww", "rgb", "rgbw", "rgbct", "rgbww",
+  };
+  for (size_t i = 0; i < sizeof(MODES) / sizeof(MODES[0]); i++) {
+    if (MODES[i] == mode)
+      return STRINGS[i];
   }
+  return nullptr;
 }
 
 void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
@@ -48,7 +44,7 @@ void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
   auto values = state.remote_values;
 
   const auto color_mode = values.get_color_mode();
-  const auto *mode_str = get_color_mode_json_str(color_mode);
+  const char *mode_str = get_color_mode_json_str(color_mode);
   if (mode_str != nullptr) {
     root[ESPHOME_F("color_mode")] = mode_str;
   }

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

@@ -189,27 +189,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];
@@ -220,18 +230,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";
@@ -245,7 +266,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/opentherm/opentherm.cpp

@@ -561,9 +561,8 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
 }
 
 void OpenTherm::debug_data(OpenthermData &data) {
-  char type_buf[9], id_buf[9], hb_buf[9], lb_buf[9];
-  ESP_LOGD(TAG, "%s %s %s %s", format_bin_to(type_buf, data.type), format_bin_to(id_buf, data.id),
-           format_bin_to(hb_buf, data.valueHB), format_bin_to(lb_buf, data.valueLB));
+  ESP_LOGD(TAG, "%s %s %s %s", format_bin(data.type).c_str(), format_bin(data.id).c_str(),
+           format_bin(data.valueHB).c_str(), format_bin(data.valueLB).c_str());
   ESP_LOGD(TAG, "type: %s; id: %u; HB: %u; LB: %u; uint_16: %u; float: %f",
            this->message_type_to_str((MessageType) data.type), data.id, data.valueHB, data.valueLB, data.u16(),
            data.f88());

esphome/components/web_server/list_entities.cpp

@@ -143,7 +143,7 @@ bool ListEntitiesIterator::on_water_heater(water_heater::WaterHeater *obj) {
 
 #ifdef USE_INFRARED
 bool ListEntitiesIterator::on_infrared(infrared::Infrared *obj) {
-  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::infrared_all_json_generator);
+  // Infrared web_server support not yet implemented - this stub acknowledges the entity
   return true;
 }
 #endif

esphome/components/web_server/web_server.cpp

@@ -33,10 +33,6 @@
 #include "esphome/components/water_heater/water_heater.h"
 #endif
 
-#ifdef USE_INFRARED
-#include "esphome/components/infrared/infrared.h"
-#endif
-
 #ifdef USE_WEBSERVER_LOCAL
 #if USE_WEBSERVER_VERSION == 2
 #include "server_index_v2.h"
@@ -1956,110 +1952,6 @@ std::string WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDe
 }
 #endif
 
-#ifdef USE_INFRARED
-void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const UrlMatch &match) {
-  for (infrared::Infrared *obj : App.get_infrareds()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
-      continue;
-
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
-      auto detail = get_request_detail(request);
-      std::string data = this->infrared_json_(obj, detail);
-      request->send(200, ESPHOME_F("application/json"), data.c_str());
-      return;
-    }
-    if (!match.method_equals(ESPHOME_F("transmit"))) {
-      request->send(404);
-      return;
-    }
-
-    // Only allow transmit if the device supports it
-    if (!obj->has_transmitter()) {
-      request->send(400, ESPHOME_F("text/plain"), "Device does not support transmission");
-      return;
-    }
-
-    // Parse parameters
-    auto call = obj->make_call();
-
-    // Parse carrier frequency (optional)
-    if (request->hasParam(ESPHOME_F("carrier_frequency"))) {
-      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("carrier_frequency"))->value().c_str());
-      if (value.has_value()) {
-        call.set_carrier_frequency(*value);
-      }
-    }
-
-    // Parse repeat count (optional, defaults to 1)
-    if (request->hasParam(ESPHOME_F("repeat_count"))) {
-      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("repeat_count"))->value().c_str());
-      if (value.has_value()) {
-        call.set_repeat_count(*value);
-      }
-    }
-
-    // Parse base64url-encoded raw timings (required)
-    // Base64url is URL-safe: uses A-Za-z0-9-_ (no special characters needing escaping)
-    if (!request->hasParam(ESPHOME_F("data"))) {
-      request->send(400, ESPHOME_F("text/plain"), "Missing 'data' parameter");
-      return;
-    }
-
-    // .c_str() is required for Arduino framework where value() returns Arduino String instead of std::string
-    std::string encoded =
-        request->getParam(ESPHOME_F("data"))->value().c_str();  // NOLINT(readability-redundant-string-cstr)
-
-    // Validate base64url is not empty
-    if (encoded.empty()) {
-      request->send(400, ESPHOME_F("text/plain"), "Empty 'data' parameter");
-      return;
-    }
-
-#ifdef USE_ESP8266
-    // ESP8266 is single-threaded, call directly
-    call.set_raw_timings_base64url(encoded);
-    call.perform();
-#else
-    // Defer to main loop for thread safety. Move encoded string into lambda to ensure
-    // it outlives the call - set_raw_timings_base64url stores a pointer, so the string
-    // must remain valid until perform() completes.
-    this->defer([call, encoded = std::move(encoded)]() mutable {
-      call.set_raw_timings_base64url(encoded);
-      call.perform();
-    });
-#endif
-
-    request->send(200);
-    return;
-  }
-  request->send(404);
-}
-
-std::string WebServer::infrared_all_json_generator(WebServer *web_server, void *source) {
-  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  return web_server->infrared_json_(static_cast<infrared::Infrared *>(source), DETAIL_ALL);
-}
-
-std::string WebServer::infrared_json_(infrared::Infrared *obj, JsonDetail start_config) {
-  json::JsonBuilder builder;
-  JsonObject root = builder.root();
-
-  set_json_icon_state_value(root, obj, "infrared", "", 0, start_config);
-
-  auto traits = obj->get_traits();
-
-  root[ESPHOME_F("supports_transmitter")] = traits.get_supports_transmitter();
-  root[ESPHOME_F("supports_receiver")] = traits.get_supports_receiver();
-
-  if (start_config == DETAIL_ALL) {
-    this->add_sorting_info_(root, obj);
-  }
-
-  return builder.serialize();
-}
-#endif
-
 #ifdef USE_EVENT
 void WebServer::on_event(event::Event *obj) {
   if (!this->include_internal_ && obj->is_internal())
@@ -2191,21 +2083,24 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   const auto &url = request->url();
   const auto method = request->method();
 
-  // Static URL checks - use ESPHOME_F to keep strings in flash on ESP8266
-  if (url == ESPHOME_F("/"))
-    return true;
+  // Static URL checks
+  static const char *const STATIC_URLS[] = {
+    "/",
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
-  if (url == ESPHOME_F("/events"))
-    return true;
+    "/events",
 #endif
 #ifdef USE_WEBSERVER_CSS_INCLUDE
-  if (url == ESPHOME_F("/0.css"))
-    return true;
+    "/0.css",
 #endif
 #ifdef USE_WEBSERVER_JS_INCLUDE
-  if (url == ESPHOME_F("/0.js"))
-    return true;
+    "/0.js",
 #endif
+  };
+
+  for (const auto &static_url : STATIC_URLS) {
+    if (url == static_url)
+      return true;
+  }
 
 #ifdef USE_WEBSERVER_PRIVATE_NETWORK_ACCESS
   if (method == HTTP_OPTIONS && request->hasHeader(ESPHOME_F("Access-Control-Request-Private-Network")))
@@ -2225,100 +2120,90 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   if (!is_get_or_post)
     return false;
 
-  // Check GET-only domains - use ESPHOME_F to keep strings in flash on ESP8266
-  if (is_get) {
+  // Use lookup tables for domain checks
+  static const char *const GET_ONLY_DOMAINS[] = {
 #ifdef USE_SENSOR
-    if (match.domain_equals(ESPHOME_F("sensor")))
-      return true;
+      "sensor",
 #endif
 #ifdef USE_BINARY_SENSOR
-    if (match.domain_equals(ESPHOME_F("binary_sensor")))
-      return true;
+      "binary_sensor",
 #endif
 #ifdef USE_TEXT_SENSOR
-    if (match.domain_equals(ESPHOME_F("text_sensor")))
-      return true;
+      "text_sensor",
 #endif
 #ifdef USE_EVENT
-    if (match.domain_equals(ESPHOME_F("event")))
-      return true;
+      "event",
 #endif
+  };
+
+  static const char *const GET_POST_DOMAINS[] = {
+#ifdef USE_SWITCH
+      "switch",
+#endif
+#ifdef USE_BUTTON
+      "button",
+#endif
+#ifdef USE_FAN
+      "fan",
+#endif
+#ifdef USE_LIGHT
+      "light",
+#endif
+#ifdef USE_COVER
+      "cover",
+#endif
+#ifdef USE_NUMBER
+      "number",
+#endif
+#ifdef USE_DATETIME_DATE
+      "date",
+#endif
+#ifdef USE_DATETIME_TIME
+      "time",
+#endif
+#ifdef USE_DATETIME_DATETIME
+      "datetime",
+#endif
+#ifdef USE_TEXT
+      "text",
+#endif
+#ifdef USE_SELECT
+      "select",
+#endif
+#ifdef USE_CLIMATE
+      "climate",
+#endif
+#ifdef USE_LOCK
+      "lock",
+#endif
+#ifdef USE_VALVE
+      "valve",
+#endif
+#ifdef USE_ALARM_CONTROL_PANEL
+      "alarm_control_panel",
+#endif
+#ifdef USE_UPDATE
+      "update",
+#endif
+#ifdef USE_WATER_HEATER
+      "water_heater",
+#endif
+  };
+
+  // Check GET-only domains
+  if (is_get) {
+    for (const auto &domain : GET_ONLY_DOMAINS) {
+      if (match.domain_equals(domain))
+        return true;
+    }
   }
 
   // Check GET+POST domains
   if (is_get_or_post) {
-#ifdef USE_SWITCH
-    if (match.domain_equals(ESPHOME_F("switch")))
-      return true;
-#endif
-#ifdef USE_BUTTON
-    if (match.domain_equals(ESPHOME_F("button")))
-      return true;
-#endif
-#ifdef USE_FAN
-    if (match.domain_equals(ESPHOME_F("fan")))
-      return true;
-#endif
-#ifdef USE_LIGHT
-    if (match.domain_equals(ESPHOME_F("light")))
-      return true;
-#endif
-#ifdef USE_COVER
-    if (match.domain_equals(ESPHOME_F("cover")))
-      return true;
-#endif
-#ifdef USE_NUMBER
-    if (match.domain_equals(ESPHOME_F("number")))
-      return true;
-#endif
-#ifdef USE_DATETIME_DATE
-    if (match.domain_equals(ESPHOME_F("date")))
-      return true;
-#endif
-#ifdef USE_DATETIME_TIME
-    if (match.domain_equals(ESPHOME_F("time")))
-      return true;
-#endif
-#ifdef USE_DATETIME_DATETIME
-    if (match.domain_equals(ESPHOME_F("datetime")))
-      return true;
-#endif
-#ifdef USE_TEXT
-    if (match.domain_equals(ESPHOME_F("text")))
-      return true;
-#endif
-#ifdef USE_SELECT
-    if (match.domain_equals(ESPHOME_F("select")))
-      return true;
-#endif
-#ifdef USE_CLIMATE
-    if (match.domain_equals(ESPHOME_F("climate")))
-      return true;
-#endif
-#ifdef USE_LOCK
-    if (match.domain_equals(ESPHOME_F("lock")))
-      return true;
-#endif
-#ifdef USE_VALVE
-    if (match.domain_equals(ESPHOME_F("valve")))
-      return true;
-#endif
-#ifdef USE_ALARM_CONTROL_PANEL
-    if (match.domain_equals(ESPHOME_F("alarm_control_panel")))
-      return true;
-#endif
-#ifdef USE_UPDATE
-    if (match.domain_equals(ESPHOME_F("update")))
-      return true;
-#endif
-#ifdef USE_WATER_HEATER
-    if (match.domain_equals(ESPHOME_F("water_heater")))
-      return true;
-#endif
-#ifdef USE_INFRARED
-    if (match.domain_equals(ESPHOME_F("infrared")))
-      return true;
-#endif
+    for (const auto &domain : GET_POST_DOMAINS) {
+      if (match.domain_equals(domain))
+        return true;
+    }
   }
 
   return false;
@@ -2467,11 +2352,6 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
   else if (match.domain_equals(ESPHOME_F("water_heater"))) {
     this->handle_water_heater_request(request, match);
   }
-#endif
-#ifdef USE_INFRARED
-  else if (match.domain_equals(ESPHOME_F("infrared"))) {
-    this->handle_infrared_request(request, match);
-  }
 #endif
   else {
     // No matching handler found - send 404

esphome/components/web_server/web_server.h

@@ -460,13 +460,6 @@ class WebServer : public Controller,
   static std::string water_heater_all_json_generator(WebServer *web_server, void *source);
 #endif
 
-#ifdef USE_INFRARED
-  /// Handle an infrared request under '/infrared/<id>/transmit'.
-  void handle_infrared_request(AsyncWebServerRequest *request, const UrlMatch &match);
-
-  static std::string infrared_all_json_generator(WebServer *web_server, void *source);
-#endif
-
 #ifdef USE_EVENT
   void on_event(event::Event *obj) override;
 
@@ -669,9 +662,6 @@ class WebServer : public Controller,
 #ifdef USE_WATER_HEATER
   std::string water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config);
 #endif
-#ifdef USE_INFRARED
-  std::string infrared_json_(infrared::Infrared *obj, JsonDetail start_config);
-#endif
 #ifdef USE_UPDATE
   std::string update_json_(update::UpdateEntity *obj, JsonDetail start_config);
 #endif

esphome/core/helpers.cpp

@@ -404,31 +404,15 @@ std::string format_hex_pretty(const std::string &data, char separator, bool show
   return format_hex_pretty_uint8(reinterpret_cast<const uint8_t *>(data.data()), data.length(), separator, show_length);
 }
 
-char *format_bin_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length) {
-  if (buffer_size == 0) {
-    return buffer;
-  }
-  // Calculate max bytes we can format: each byte needs 8 chars
-  size_t max_bytes = (buffer_size - 1) / 8;
-  if (max_bytes == 0 || length == 0) {
-    buffer[0] = '\0';
-    return buffer;
-  }
-  size_t bytes_to_format = std::min(length, max_bytes);
-
-  for (size_t byte_idx = 0; byte_idx < bytes_to_format; byte_idx++) {
-    for (size_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-      buffer[byte_idx * 8 + bit_idx] = ((data[byte_idx] >> (7 - bit_idx)) & 1) + '0';
-    }
-  }
-  buffer[bytes_to_format * 8] = '\0';
-  return buffer;
-}
-
 std::string format_bin(const uint8_t *data, size_t length) {
   std::string result;
   result.resize(length * 8);
-  format_bin_to(&result[0], length * 8 + 1, data, length);
+  for (size_t byte_idx = 0; byte_idx < length; byte_idx++) {
+    for (size_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+      result[byte_idx * 8 + bit_idx] = ((data[byte_idx] >> (7 - bit_idx)) & 1) + '0';
+    }
+  }
+
   return result;
 }
 

esphome/core/helpers.h

@@ -1096,66 +1096,9 @@ std::string format_hex_pretty(T val, char separator = '.', bool show_length = tr
   return format_hex_pretty(reinterpret_cast<uint8_t *>(&val), sizeof(T), separator, show_length);
 }
 
-/// Calculate buffer size needed for format_bin_to: "01234567...\0" = bytes * 8 + 1
-constexpr size_t format_bin_size(size_t byte_count) { return byte_count * 8 + 1; }
-
-/** Format byte array as binary string to buffer.
- *
- * Each byte is formatted as 8 binary digits (MSB first).
- * Truncates output if data exceeds buffer capacity.
- *
- * @param buffer Output buffer to write to.
- * @param buffer_size Size of the output buffer.
- * @param data Pointer to the byte array to format.
- * @param length Number of bytes in the array.
- * @return Pointer to buffer.
- *
- * Buffer size needed: length * 8 + 1 (use format_bin_size()).
- *
- * Example:
- * @code
- * char buf[9];  // format_bin_size(1)
- * format_bin_to(buf, sizeof(buf), data, 1);  // "10101011"
- * @endcode
- */
-char *format_bin_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length);
-
-/// Format byte array as binary to buffer. Automatically deduces buffer size.
-template<size_t N> inline char *format_bin_to(char (&buffer)[N], const uint8_t *data, size_t length) {
-  static_assert(N >= 9, "Buffer must hold at least one binary byte (9 chars)");
-  return format_bin_to(buffer, N, data, length);
-}
-
-/** Format an unsigned integer in binary to buffer, MSB first.
- *
- * @tparam N Buffer size (must be >= sizeof(T) * 8 + 1).
- * @tparam T Unsigned integer type.
- * @param buffer Output buffer to write to.
- * @param val The unsigned integer value to format.
- * @return Pointer to buffer.
- *
- * Example:
- * @code
- * char buf[9];  // format_bin_size(sizeof(uint8_t))
- * format_bin_to(buf, uint8_t{0xAA});  // "10101010"
- * char buf16[17];  // format_bin_size(sizeof(uint16_t))
- * format_bin_to(buf16, uint16_t{0x1234});  // "0001001000110100"
- * @endcode
- */
-template<size_t N, typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
-inline char *format_bin_to(char (&buffer)[N], T val) {
-  static_assert(N >= sizeof(T) * 8 + 1, "Buffer too small for type");
-  val = convert_big_endian(val);
-  return format_bin_to(buffer, reinterpret_cast<const uint8_t *>(&val), sizeof(T));
-}
-
 /// Format the byte array \p data of length \p len in binary.
-/// @warning Allocates heap memory. Use format_bin_to() with a stack buffer instead.
-/// Causes heap fragmentation on long-running devices.
 std::string format_bin(const uint8_t *data, size_t length);
 /// Format an unsigned integer in binary, starting with the most significant byte.
-/// @warning Allocates heap memory. Use format_bin_to() with a stack buffer instead.
-/// Causes heap fragmentation on long-running devices.
 template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_bin(T val) {
   val = convert_big_endian(val);
   return format_bin(reinterpret_cast<uint8_t *>(&val), sizeof(T));

esphome/core/progmem.h

@@ -12,8 +12,6 @@
 #define ESPHOME_strncpy_P strncpy_P
 #define ESPHOME_strncat_P strncat_P
 #define ESPHOME_snprintf_P snprintf_P
-// Type for pointers to PROGMEM strings (for use with ESPHOME_F return values)
-using ProgmemStr = const __FlashStringHelper *;
 #else
 #define ESPHOME_F(string_literal) (string_literal)
 #define ESPHOME_PGM_P const char *
@@ -21,6 +19,4 @@ using ProgmemStr = const __FlashStringHelper *;
 #define ESPHOME_strncpy_P strncpy
 #define ESPHOME_strncat_P strncat
 #define ESPHOME_snprintf_P snprintf
-// Type for pointers to strings (no PROGMEM on non-ESP8266 platforms)
-using ProgmemStr = const char *;
 #endif

script/ci-custom.py

@@ -682,7 +682,6 @@ def lint_trailing_whitespace(fname, match):
 # Heap-allocating helpers that cause fragmentation on long-running embedded devices.
 # These return std::string and should be replaced with stack-based alternatives.
 HEAP_ALLOCATING_HELPERS = {
-    "format_bin": "format_bin_to() with a stack buffer",
     "format_hex": "format_hex_to() with a stack buffer",
     "format_hex_pretty": "format_hex_pretty_to() with a stack buffer",
     "format_mac_address_pretty": "format_mac_addr_upper() with a stack buffer",
@@ -700,7 +699,6 @@ HEAP_ALLOCATING_HELPERS = {
     # get_mac_address(?!_) ensures we don't match get_mac_address_into_buffer, etc.
     # CPP_RE_EOL captures rest of line so NOLINT comments are detected
     r"[^\w]("
-    r"format_bin(?!_)|"
     r"format_hex(?!_)|"
     r"format_hex_pretty(?!_)|"
     r"format_mac_address_pretty|"