[web_server] Use ESPHOME_F for canHandle domain checks to reduce ESP8266 RAM (#13315)

Co-authored-by: Keith Burzinski <kbx81x@gmail.com>

esphome/components/api/proto.cpp

@@ -48,14 +48,14 @@ uint32_t ProtoDecodableMessage::count_repeated_field(const uint8_t *buffer, size
         }
         uint32_t field_length = res->as_uint32();
         ptr += consumed;
-        if (ptr + field_length > end) {
+        if (field_length > static_cast<size_t>(end - ptr)) {
           return count;  // Out of bounds
         }
         ptr += field_length;
         break;
       }
       case WIRE_TYPE_FIXED32: {  // 32-bit - skip 4 bytes
-        if (ptr + 4 > end) {
+        if (end - ptr < 4) {
           return count;
         }
         ptr += 4;
@@ -110,7 +110,7 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
         }
         uint32_t field_length = res->as_uint32();
         ptr += consumed;
-        if (ptr + field_length > end) {
+        if (field_length > static_cast<size_t>(end - ptr)) {
           ESP_LOGV(TAG, "Out-of-bounds Length Delimited at offset %ld", (long) (ptr - buffer));
           return;
         }
@@ -121,7 +121,7 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
         break;
       }
       case WIRE_TYPE_FIXED32: {  // 32-bit
-        if (ptr + 4 > end) {
+        if (end - ptr < 4) {
           ESP_LOGV(TAG, "Out-of-bounds Fixed32-bit at offset %ld", (long) (ptr - buffer));
           return;
         }

esphome/components/hmac_sha256/hmac_sha256.cpp

@@ -1,4 +1,3 @@
-#include <cstdio>
 #include <cstring>
 #include "hmac_sha256.h"
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_HOST)
@@ -26,9 +25,7 @@ void HmacSHA256::calculate() { mbedtls_md_hmac_finish(&this->ctx_, this->digest_
 void HmacSHA256::get_bytes(uint8_t *output) { memcpy(output, this->digest_, SHA256_DIGEST_SIZE); }
 
 void HmacSHA256::get_hex(char *output) {
-  for (size_t i = 0; i < SHA256_DIGEST_SIZE; i++) {
-    sprintf(output + (i * 2), "%02x", this->digest_[i]);
-  }
+  format_hex_to(output, SHA256_DIGEST_SIZE * 2 + 1, this->digest_, SHA256_DIGEST_SIZE);
 }
 
 bool HmacSHA256::equals_bytes(const uint8_t *expected) {

esphome/components/http_request/http_request.h

@@ -242,9 +242,7 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
       return;
     }
 
-    size_t content_length = container->content_length;
-    size_t max_length = std::min(content_length, this->max_response_buffer_size_);
-
+    size_t max_length = this->max_response_buffer_size_;
 #ifdef USE_HTTP_REQUEST_RESPONSE
     if (this->capture_response_.value(x...)) {
       std::string response_body;

esphome/components/http_request/http_request_idf.cpp

@@ -213,18 +213,12 @@ int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
   const uint32_t start = millis();
   watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
 
-  int bufsize = std::min(max_len, this->content_length - this->bytes_read_);
-
-  if (bufsize == 0) {
-    this->duration_ms += (millis() - start);
-    return 0;
+  this->feed_wdt();
+  int read_len = esp_http_client_read(this->client_, (char *) buf, max_len);
+  this->feed_wdt();
+  if (read_len > 0) {
+    this->bytes_read_ += read_len;
   }
-
-  this->feed_wdt();
-  int read_len = esp_http_client_read(this->client_, (char *) buf, bufsize);
-  this->feed_wdt();
-  this->bytes_read_ += read_len;
-
   this->duration_ms += (millis() - start);
 
   return read_len;

esphome/components/hub75/display.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Any
 
 from esphome import automation, pins
@@ -18,13 +19,16 @@ from esphome.const import (
     CONF_ROTATION,
     CONF_UPDATE_INTERVAL,
 )
-from esphome.core import ID
+from esphome.core import ID, EnumValue
 from esphome.cpp_generator import MockObj, TemplateArgsType
 import esphome.final_validate as fv
+from esphome.helpers import add_class_to_obj
 from esphome.types import ConfigType
 
 from . import boards, hub75_ns
 
+_LOGGER = logging.getLogger(__name__)
+
 DEPENDENCIES = ["esp32"]
 CODEOWNERS = ["@stuartparmenter"]
 
@@ -120,13 +124,51 @@ PANEL_LAYOUTS = {
 }
 
 Hub75ScanWiring = cg.global_ns.enum("Hub75ScanWiring", is_class=True)
-SCAN_PATTERNS = {
+SCAN_WIRINGS = {
     "STANDARD_TWO_SCAN": Hub75ScanWiring.STANDARD_TWO_SCAN,
-    "FOUR_SCAN_16PX_HIGH": Hub75ScanWiring.FOUR_SCAN_16PX_HIGH,
-    "FOUR_SCAN_32PX_HIGH": Hub75ScanWiring.FOUR_SCAN_32PX_HIGH,
-    "FOUR_SCAN_64PX_HIGH": Hub75ScanWiring.FOUR_SCAN_64PX_HIGH,
+    "SCAN_1_4_16PX_HIGH": Hub75ScanWiring.SCAN_1_4_16PX_HIGH,
+    "SCAN_1_8_32PX_HIGH": Hub75ScanWiring.SCAN_1_8_32PX_HIGH,
+    "SCAN_1_8_40PX_HIGH": Hub75ScanWiring.SCAN_1_8_40PX_HIGH,
+    "SCAN_1_8_64PX_HIGH": Hub75ScanWiring.SCAN_1_8_64PX_HIGH,
 }
 
+# Deprecated scan wiring names - mapped to new names
+DEPRECATED_SCAN_WIRINGS = {
+    "FOUR_SCAN_16PX_HIGH": "SCAN_1_4_16PX_HIGH",
+    "FOUR_SCAN_32PX_HIGH": "SCAN_1_8_32PX_HIGH",
+    "FOUR_SCAN_64PX_HIGH": "SCAN_1_8_64PX_HIGH",
+}
+
+
+def _validate_scan_wiring(value):
+    """Validate scan_wiring with deprecation warnings for old names."""
+    value = cv.string(value).upper().replace(" ", "_")
+
+    # Check if using deprecated name
+    # Remove deprecated names in 2026.7.0
+    if value in DEPRECATED_SCAN_WIRINGS:
+        new_name = DEPRECATED_SCAN_WIRINGS[value]
+        _LOGGER.warning(
+            "Scan wiring '%s' is deprecated and will be removed in ESPHome 2026.7.0. "
+            "Please use '%s' instead.",
+            value,
+            new_name,
+        )
+        value = new_name
+
+    # Validate against allowed values
+    if value not in SCAN_WIRINGS:
+        raise cv.Invalid(
+            f"Unknown scan wiring '{value}'. "
+            f"Valid options are: {', '.join(sorted(SCAN_WIRINGS.keys()))}"
+        )
+
+    # Return as EnumValue like cv.enum does
+    result = add_class_to_obj(value, EnumValue)
+    result.enum_value = SCAN_WIRINGS[value]
+    return result
+
+
 Hub75ClockSpeed = cg.global_ns.enum("Hub75ClockSpeed", is_class=True)
 CLOCK_SPEEDS = {
     "8MHZ": Hub75ClockSpeed.HZ_8M,
@@ -382,9 +424,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_LAYOUT_COLS): cv.positive_int,
             cv.Optional(CONF_LAYOUT): cv.enum(PANEL_LAYOUTS, upper=True, space="_"),
             # Panel hardware configuration
-            cv.Optional(CONF_SCAN_WIRING): cv.enum(
-                SCAN_PATTERNS, upper=True, space="_"
-            ),
+            cv.Optional(CONF_SCAN_WIRING): _validate_scan_wiring,
             cv.Optional(CONF_SHIFT_DRIVER): cv.enum(SHIFT_DRIVERS, upper=True),
             # Display configuration
             cv.Optional(CONF_DOUBLE_BUFFER): cv.boolean,
@@ -547,7 +587,7 @@ def _build_config_struct(
 async def to_code(config: ConfigType) -> None:
     add_idf_component(
         name="esphome/esp-hub75",
-        ref="0.2.2",
+        ref="0.3.0",
     )
 
     # Set compile-time configuration via build flags (so external library sees them)

esphome/components/infrared/infrared.cpp

@@ -19,12 +19,12 @@ InfraredCall &InfraredCall::set_carrier_frequency(uint32_t frequency) {
 InfraredCall &InfraredCall::set_raw_timings(const std::vector<int32_t> &timings) {
   this->raw_timings_ = &timings;
   this->packed_data_ = nullptr;
-  this->base85_ptr_ = nullptr;
+  this->base64url_ptr_ = nullptr;
   return *this;
 }
 
-InfraredCall &InfraredCall::set_raw_timings_base85(const std::string &base85) {
-  this->base85_ptr_ = &base85;
+InfraredCall &InfraredCall::set_raw_timings_base64url(const std::string &base64url) {
+  this->base64url_ptr_ = &base64url;
   this->raw_timings_ = nullptr;
   this->packed_data_ = nullptr;
   return *this;
@@ -35,7 +35,7 @@ InfraredCall &InfraredCall::set_raw_timings_packed(const uint8_t *data, uint16_t
   this->packed_length_ = length;
   this->packed_count_ = count;
   this->raw_timings_ = nullptr;
-  this->base85_ptr_ = nullptr;
+  this->base64url_ptr_ = nullptr;
   return *this;
 }
 
@@ -101,13 +101,22 @@ void Infrared::control(const InfraredCall &call) {
                                                call.get_packed_count());
     ESP_LOGD(TAG, "Transmitting packed raw timings: count=%u, repeat=%u", call.get_packed_count(),
              call.get_repeat_count());
-  } else if (call.is_base85()) {
-    // Decode base85 directly into transmit buffer (zero heap allocations)
-    if (!transmit_data->set_data_from_base85(call.get_base85_data())) {
-      ESP_LOGE(TAG, "Invalid base85 data");
+  } else if (call.is_base64url()) {
+    // Decode base64url (URL-safe) into transmit buffer
+    if (!transmit_data->set_data_from_base64url(call.get_base64url_data())) {
+      ESP_LOGE(TAG, "Invalid base64url data");
       return;
     }
-    ESP_LOGD(TAG, "Transmitting base85 raw timings: count=%zu, repeat=%u", transmit_data->get_data().size(),
+    // Sanity check: validate timing values are within reasonable bounds
+    constexpr int32_t max_timing_us = 500000;  // 500ms absolute max
+    for (int32_t timing : transmit_data->get_data()) {
+      int32_t abs_timing = timing < 0 ? -timing : timing;
+      if (abs_timing > max_timing_us) {
+        ESP_LOGE(TAG, "Invalid timing value: %d µs (max %d)", timing, max_timing_us);
+        return;
+      }
+    }
+    ESP_LOGD(TAG, "Transmitting base64url raw timings: count=%zu, repeat=%u", transmit_data->get_data().size(),
              call.get_repeat_count());
   } else {
     // From vector (lambdas/automations)

esphome/components/infrared/infrared.h

@@ -40,11 +40,11 @@ class InfraredCall {
   /// @note Usage: Primarily for lambdas/automations where the vector is in scope.
   InfraredCall &set_raw_timings(const std::vector<int32_t> &timings);
 
-  /// Set the raw timings from base85-encoded int32 data
+  /// Set the raw timings from base64url-encoded little-endian int32 data
   /// @note Lifetime: Stores a pointer to the string. The string must outlive perform().
-  /// @note Usage: For web_server where the encoded string is on the stack.
+  /// @note Usage: For web_server - base64url is fully URL-safe (uses '-' and '_').
   /// @note Decoding happens at perform() time, directly into the transmit buffer.
-  InfraredCall &set_raw_timings_base85(const std::string &base85);
+  InfraredCall &set_raw_timings_base64url(const std::string &base64url);
 
   /// Set the raw timings from packed protobuf sint32 data (zigzag + varint encoded)
   /// @note Lifetime: Stores a pointer to the buffer. The buffer must outlive perform().
@@ -59,18 +59,18 @@ class InfraredCall {
 
   /// Get the carrier frequency
   const optional<uint32_t> &get_carrier_frequency() const { return this->carrier_frequency_; }
-  /// Get the raw timings (only valid if set via set_raw_timings, not packed or base85)
+  /// Get the raw timings (only valid if set via set_raw_timings)
   const std::vector<int32_t> &get_raw_timings() const { return *this->raw_timings_; }
-  /// Check if raw timings have been set (vector, packed, or base85)
+  /// Check if raw timings have been set (any format)
   bool has_raw_timings() const {
-    return this->raw_timings_ != nullptr || this->packed_data_ != nullptr || this->base85_ptr_ != nullptr;
+    return this->raw_timings_ != nullptr || this->packed_data_ != nullptr || this->base64url_ptr_ != nullptr;
   }
   /// Check if using packed data format
   bool is_packed() const { return this->packed_data_ != nullptr; }
-  /// Check if using base85 data format
-  bool is_base85() const { return this->base85_ptr_ != nullptr; }
-  /// Get the base85 data string
-  const std::string &get_base85_data() const { return *this->base85_ptr_; }
+  /// Check if using base64url data format
+  bool is_base64url() const { return this->base64url_ptr_ != nullptr; }
+  /// Get the base64url data string
+  const std::string &get_base64url_data() const { return *this->base64url_ptr_; }
   /// Get packed data (only valid if set via set_raw_timings_packed)
   const uint8_t *get_packed_data() const { return this->packed_data_; }
   uint16_t get_packed_length() const { return this->packed_length_; }
@@ -84,8 +84,8 @@ class InfraredCall {
   optional<uint32_t> carrier_frequency_;
   // Pointer to vector-based timings (caller-owned, must outlive perform())
   const std::vector<int32_t> *raw_timings_{nullptr};
-  // Pointer to base85-encoded string (caller-owned, must outlive perform())
-  const std::string *base85_ptr_{nullptr};
+  // Pointer to base64url-encoded string (caller-owned, must outlive perform())
+  const std::string *base64url_ptr_{nullptr};
   // Pointer to packed protobuf buffer (caller-owned, must outlive perform())
   const uint8_t *packed_data_{nullptr};
   uint16_t packed_length_{0};

esphome/components/light/light_json_schema.cpp

@@ -1,4 +1,5 @@
 #include "light_json_schema.h"
+#include "color_mode.h"
 #include "light_output.h"
 #include "esphome/core/progmem.h"
 
@@ -8,29 +9,32 @@ 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 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];
+// 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;
   }
-  return nullptr;
 }
 
 void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
@@ -44,7 +48,7 @@ void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
   auto values = state.remote_values;
 
   const auto color_mode = values.get_color_mode();
-  const char *mode_str = get_color_mode_json_str(color_mode);
+  const auto *mode_str = get_color_mode_json_str(color_mode);
   if (mode_str != nullptr) {
     root[ESPHOME_F("color_mode")] = mode_str;
   }

esphome/components/opentherm/opentherm.cpp

@@ -561,8 +561,9 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
 }
 
 void OpenTherm::debug_data(OpenthermData &data) {
-  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());
+  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, "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/remote_base/aeha_protocol.cpp

@@ -85,8 +85,8 @@ optional<AEHAData> AEHAProtocol::decode(RemoteReceiveData src) {
 std::string AEHAProtocol::format_data_(const std::vector<uint8_t> &data) {
   std::string out;
   for (uint8_t byte : data) {
-    char buf[6];
-    sprintf(buf, "0x%02X,", byte);
+    char buf[8];  // "0x%02X," = 5 chars + null + margin
+    snprintf(buf, sizeof(buf), "0x%02X,", byte);
     out += buf;
   }
   out.pop_back();

esphome/components/remote_base/raw_protocol.cpp

@@ -1,4 +1,5 @@
 #include "raw_protocol.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -8,36 +9,30 @@ static const char *const TAG = "remote.raw";
 
 bool RawDumper::dump(RemoteReceiveData src) {
   char buffer[256];
-  uint32_t buffer_offset = 0;
-  buffer_offset += sprintf(buffer, "Received Raw: ");
+  size_t pos = buf_append_printf(buffer, sizeof(buffer), 0, "Received Raw: ");
 
   for (int32_t i = 0; i < src.size() - 1; i++) {
     const int32_t value = src[i];
-    const uint32_t remaining_length = sizeof(buffer) - buffer_offset;
-    int written;
+    size_t prev_pos = pos;
 
     if (i + 1 < src.size() - 1) {
-      written = snprintf(buffer + buffer_offset, remaining_length, "%" PRId32 ", ", value);
+      pos = buf_append_printf(buffer, sizeof(buffer), pos, "%" PRId32 ", ", value);
     } else {
-      written = snprintf(buffer + buffer_offset, remaining_length, "%" PRId32, value);
+      pos = buf_append_printf(buffer, sizeof(buffer), pos, "%" PRId32, value);
     }
 
-    if (written < 0 || written >= int(remaining_length)) {
-      // write failed, flush...
-      buffer[buffer_offset] = '\0';
+    if (pos >= sizeof(buffer) - 1) {
+      // buffer full, flush and continue
+      buffer[prev_pos] = '\0';
       ESP_LOGI(TAG, "%s", buffer);
-      buffer_offset = 0;
-      written = sprintf(buffer, "  ");
       if (i + 1 < src.size() - 1) {
-        written += sprintf(buffer + written, "%" PRId32 ", ", value);
+        pos = buf_append_printf(buffer, sizeof(buffer), 0, "  %" PRId32 ", ", value);
       } else {
-        written += sprintf(buffer + written, "%" PRId32, value);
+        pos = buf_append_printf(buffer, sizeof(buffer), 0, "  %" PRId32, value);
       }
     }
-
-    buffer_offset += written;
   }
-  if (buffer_offset != 0) {
+  if (pos != 0) {
     ESP_LOGI(TAG, "%s", buffer);
   }
   return true;

esphome/components/remote_base/remote_base.cpp

@@ -1,8 +1,7 @@
 #include "remote_base.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-#include <cinttypes>
-
 namespace esphome {
 namespace remote_base {
 
@@ -159,8 +158,8 @@ void RemoteTransmitData::set_data_from_packed_sint32(const uint8_t *data, size_t
   }
 }
 
-bool RemoteTransmitData::set_data_from_base85(const std::string &base85) {
-  return base85_decode_int32_vector(base85, this->data_);
+bool RemoteTransmitData::set_data_from_base64url(const std::string &base64url) {
+  return base64_decode_int32_vector(base64url, this->data_);
 }
 
 /* RemoteTransmitterBase */
@@ -169,36 +168,31 @@ void RemoteTransmitterBase::send_(uint32_t send_times, uint32_t send_wait) {
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
   const auto &vec = this->temp_.get_data();
   char buffer[256];
-  uint32_t buffer_offset = 0;
-  buffer_offset += sprintf(buffer, "Sending times=%" PRIu32 " wait=%" PRIu32 "ms: ", send_times, send_wait);
+  size_t pos = buf_append_printf(buffer, sizeof(buffer), 0,
+                                 "Sending times=%" PRIu32 " wait=%" PRIu32 "ms: ", send_times, send_wait);
 
   for (size_t i = 0; i < vec.size(); i++) {
     const int32_t value = vec[i];
-    const uint32_t remaining_length = sizeof(buffer) - buffer_offset;
-    int written;
+    size_t prev_pos = pos;
 
     if (i + 1 < vec.size()) {
-      written = snprintf(buffer + buffer_offset, remaining_length, "%" PRId32 ", ", value);
+      pos = buf_append_printf(buffer, sizeof(buffer), pos, "%" PRId32 ", ", value);
     } else {
-      written = snprintf(buffer + buffer_offset, remaining_length, "%" PRId32, value);
+      pos = buf_append_printf(buffer, sizeof(buffer), pos, "%" PRId32, value);
     }
 
-    if (written < 0 || written >= int(remaining_length)) {
-      // write failed, flush...
-      buffer[buffer_offset] = '\0';
+    if (pos >= sizeof(buffer) - 1) {
+      // buffer full, flush and continue
+      buffer[prev_pos] = '\0';
       ESP_LOGVV(TAG, "%s", buffer);
-      buffer_offset = 0;
-      written = sprintf(buffer, "  ");
       if (i + 1 < vec.size()) {
-        written += sprintf(buffer + written, "%" PRId32 ", ", value);
+        pos = buf_append_printf(buffer, sizeof(buffer), 0, "  %" PRId32 ", ", value);
       } else {
-        written += sprintf(buffer + written, "%" PRId32, value);
+        pos = buf_append_printf(buffer, sizeof(buffer), 0, "  %" PRId32, value);
       }
     }
-
-    buffer_offset += written;
   }
-  if (buffer_offset != 0) {
+  if (pos != 0) {
     ESP_LOGVV(TAG, "%s", buffer);
   }
 #endif

esphome/components/remote_base/remote_base.h

@@ -36,11 +36,11 @@ class RemoteTransmitData {
   /// @param len Length of the buffer in bytes
   /// @param count Number of values (for reserve optimization)
   void set_data_from_packed_sint32(const uint8_t *data, size_t len, size_t count);
-  /// Set data from base85-encoded int32 values
-  /// Decodes directly into internal buffer (zero heap allocations)
-  /// @param base85 Base85-encoded string (5 chars per int32 value)
+  /// Set data from base64url-encoded little-endian int32 values
+  /// Base64url is URL-safe: uses '-' instead of '+', '_' instead of '/'
+  /// @param base64url Base64url-encoded string of little-endian int32 values
   /// @return true if successful, false if decode failed or invalid size
-  bool set_data_from_base85(const std::string &base85);
+  bool set_data_from_base64url(const std::string &base64url);
   void reset() {
     this->data_.clear();
     this->carrier_frequency_ = 0;

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/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) {
-  // Infrared web_server support not yet implemented - this stub acknowledges the entity
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::infrared_all_json_generator);
   return true;
 }
 #endif

esphome/components/web_server/web_server.cpp

@@ -33,6 +33,10 @@
 #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"
@@ -658,6 +662,24 @@ std::string WebServer::text_sensor_json_(text_sensor::TextSensor *obj, const std
 #endif
 
 #ifdef USE_SWITCH
+enum SwitchAction : uint8_t { SWITCH_ACTION_NONE, SWITCH_ACTION_TOGGLE, SWITCH_ACTION_TURN_ON, SWITCH_ACTION_TURN_OFF };
+
+static void execute_switch_action(switch_::Switch *obj, SwitchAction action) {
+  switch (action) {
+    case SWITCH_ACTION_TOGGLE:
+      obj->toggle();
+      break;
+    case SWITCH_ACTION_TURN_ON:
+      obj->turn_on();
+      break;
+    case SWITCH_ACTION_TURN_OFF:
+      obj->turn_off();
+      break;
+    default:
+      break;
+  }
+}
+
 void WebServer::on_switch_update(switch_::Switch *obj) {
   if (!this->include_internal_ && obj->is_internal())
     return;
@@ -676,34 +698,22 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
       return;
     }
 
-    // Handle action methods with single defer and response
-    enum SwitchAction { NONE, TOGGLE, TURN_ON, TURN_OFF };
-    SwitchAction action = NONE;
+    SwitchAction action = SWITCH_ACTION_NONE;
 
     if (match.method_equals(ESPHOME_F("toggle"))) {
-      action = TOGGLE;
+      action = SWITCH_ACTION_TOGGLE;
     } else if (match.method_equals(ESPHOME_F("turn_on"))) {
-      action = TURN_ON;
+      action = SWITCH_ACTION_TURN_ON;
     } else if (match.method_equals(ESPHOME_F("turn_off"))) {
-      action = TURN_OFF;
+      action = SWITCH_ACTION_TURN_OFF;
     }
 
-    if (action != NONE) {
-      this->defer([obj, action]() {
-        switch (action) {
-          case TOGGLE:
-            obj->toggle();
-            break;
-          case TURN_ON:
-            obj->turn_on();
-            break;
-          case TURN_OFF:
-            obj->turn_off();
-            break;
-          default:
-            break;
-        }
-      });
+    if (action != SWITCH_ACTION_NONE) {
+#ifdef USE_ESP8266
+      execute_switch_action(obj, action);
+#else
+      this->defer([obj, action]() { execute_switch_action(obj, action); });
+#endif
       request->send(200);
     } else {
       request->send(404);
@@ -743,7 +753,7 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
       std::string data = this->button_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("press"))) {
-      this->defer([obj]() { obj->press(); });
+      DEFER_ACTION(obj, obj->press());
       request->send(200);
       return;
     } else {
@@ -828,7 +838,7 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
       std::string data = this->fan_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("toggle"))) {
-      this->defer([obj]() { obj->toggle().perform(); });
+      DEFER_ACTION(obj, obj->toggle().perform());
       request->send(200);
     } else {
       bool is_on = match.method_equals(ESPHOME_F("turn_on"));
@@ -859,7 +869,7 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
             return;
         }
       }
-      this->defer([call]() mutable { call.perform(); });
+      DEFER_ACTION(call, call.perform());
       request->send(200);
     }
     return;
@@ -909,7 +919,7 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
       std::string data = this->light_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("toggle"))) {
-      this->defer([obj]() { obj->toggle().perform(); });
+      DEFER_ACTION(obj, obj->toggle().perform());
       request->send(200);
     } else {
       bool is_on = match.method_equals(ESPHOME_F("turn_on"));
@@ -938,7 +948,7 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
         parse_string_param_(request, ESPHOME_F("effect"), call, &decltype(call)::set_effect);
       }
 
-      this->defer([call]() mutable { call.perform(); });
+      DEFER_ACTION(call, call.perform());
       request->send(200);
     }
     return;
@@ -1027,7 +1037,7 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
     parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
     parse_float_param_(request, ESPHOME_F("tilt"), call, &decltype(call)::set_tilt);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1086,7 +1096,7 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
     auto call = obj->make_call();
     parse_float_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1159,7 +1169,7 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
 
     parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_date);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1223,7 +1233,7 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
 
     parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_time);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1286,7 +1296,7 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
 
     parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_datetime);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1346,7 +1356,7 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
     auto call = obj->make_call();
     parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1404,7 +1414,7 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
     auto call = obj->make_call();
     parse_string_param_(request, ESPHOME_F("option"), call, &decltype(call)::set_option);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1473,7 +1483,7 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
     parse_float_param_(request, ESPHOME_F("target_temperature_low"), call, &decltype(call)::set_target_temperature_low);
     parse_float_param_(request, ESPHOME_F("target_temperature"), call, &decltype(call)::set_target_temperature);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1589,6 +1599,24 @@ std::string WebServer::climate_json_(climate::Climate *obj, JsonDetail start_con
 #endif
 
 #ifdef USE_LOCK
+enum LockAction : uint8_t { LOCK_ACTION_NONE, LOCK_ACTION_LOCK, LOCK_ACTION_UNLOCK, LOCK_ACTION_OPEN };
+
+static void execute_lock_action(lock::Lock *obj, LockAction action) {
+  switch (action) {
+    case LOCK_ACTION_LOCK:
+      obj->lock();
+      break;
+    case LOCK_ACTION_UNLOCK:
+      obj->unlock();
+      break;
+    case LOCK_ACTION_OPEN:
+      obj->open();
+      break;
+    default:
+      break;
+  }
+}
+
 void WebServer::on_lock_update(lock::Lock *obj) {
   if (!this->include_internal_ && obj->is_internal())
     return;
@@ -1607,34 +1635,22 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
       return;
     }
 
-    // Handle action methods with single defer and response
-    enum LockAction { NONE, LOCK, UNLOCK, OPEN };
-    LockAction action = NONE;
+    LockAction action = LOCK_ACTION_NONE;
 
     if (match.method_equals(ESPHOME_F("lock"))) {
-      action = LOCK;
+      action = LOCK_ACTION_LOCK;
     } else if (match.method_equals(ESPHOME_F("unlock"))) {
-      action = UNLOCK;
+      action = LOCK_ACTION_UNLOCK;
     } else if (match.method_equals(ESPHOME_F("open"))) {
-      action = OPEN;
+      action = LOCK_ACTION_OPEN;
     }
 
-    if (action != NONE) {
-      this->defer([obj, action]() {
-        switch (action) {
-          case LOCK:
-            obj->lock();
-            break;
-          case UNLOCK:
-            obj->unlock();
-            break;
-          case OPEN:
-            obj->open();
-            break;
-          default:
-            break;
-        }
-      });
+    if (action != LOCK_ACTION_NONE) {
+#ifdef USE_ESP8266
+      execute_lock_action(obj, action);
+#else
+      this->defer([obj, action]() { execute_lock_action(obj, action); });
+#endif
       request->send(200);
     } else {
       request->send(404);
@@ -1717,7 +1733,7 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
 
     parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1796,7 +1812,7 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
       return;
     }
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1872,7 +1888,7 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
     // Parse on/off parameter
     parse_bool_param_(request, ESPHOME_F("is_on"), base_call, &water_heater::WaterHeaterCall::set_on);
 
-    this->defer([call]() mutable { call.perform(); });
+    DEFER_ACTION(call, call.perform());
     request->send(200);
     return;
   }
@@ -1940,6 +1956,110 @@ 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())
@@ -2032,7 +2152,7 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
       return;
     }
 
-    this->defer([obj]() mutable { obj->perform(); });
+    DEFER_ACTION(obj, obj->perform());
     request->send(200);
     return;
   }
@@ -2071,24 +2191,21 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   const auto &url = request->url();
   const auto method = request->method();
 
-  // Static URL checks
-  static const char *const STATIC_URLS[] = {
-    "/",
+  // Static URL checks - use ESPHOME_F to keep strings in flash on ESP8266
+  if (url == ESPHOME_F("/"))
+    return true;
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
-    "/events",
+  if (url == ESPHOME_F("/events"))
+    return true;
 #endif
 #ifdef USE_WEBSERVER_CSS_INCLUDE
-    "/0.css",
+  if (url == ESPHOME_F("/0.css"))
+    return true;
 #endif
 #ifdef USE_WEBSERVER_JS_INCLUDE
-    "/0.js",
+  if (url == ESPHOME_F("/0.js"))
+    return true;
 #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")))
@@ -2108,90 +2225,100 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   if (!is_get_or_post)
     return false;
 
-  // Use lookup tables for domain checks
-  static const char *const GET_ONLY_DOMAINS[] = {
+  // Check GET-only domains - use ESPHOME_F to keep strings in flash on ESP8266
+  if (is_get) {
 #ifdef USE_SENSOR
-      "sensor",
+    if (match.domain_equals(ESPHOME_F("sensor")))
+      return true;
 #endif
 #ifdef USE_BINARY_SENSOR
-      "binary_sensor",
+    if (match.domain_equals(ESPHOME_F("binary_sensor")))
+      return true;
 #endif
 #ifdef USE_TEXT_SENSOR
-      "text_sensor",
+    if (match.domain_equals(ESPHOME_F("text_sensor")))
+      return true;
 #endif
 #ifdef USE_EVENT
-      "event",
+    if (match.domain_equals(ESPHOME_F("event")))
+      return true;
 #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) {
-    for (const auto &domain : GET_POST_DOMAINS) {
-      if (match.domain_equals(domain))
-        return true;
-    }
+#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
   }
 
   return false;
@@ -2340,6 +2467,11 @@ 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

@@ -42,6 +42,14 @@ using ParamNameType = const __FlashStringHelper *;
 using ParamNameType = const char *;
 #endif
 
+// ESP8266 is single-threaded, so actions can execute directly in request context.
+// Multi-core platforms need to defer to main loop thread for thread safety.
+#ifdef USE_ESP8266
+#define DEFER_ACTION(capture, action) action
+#else
+#define DEFER_ACTION(capture, action) this->defer([capture]() mutable { action; })
+#endif
+
 /// Result of matching a URL against an entity
 struct EntityMatchResult {
   bool matched;          ///< True if entity matched the URL
@@ -452,6 +460,13 @@ 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;
 
@@ -654,6 +669,9 @@ 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,15 +404,31 @@ 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);
-  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';
-    }
-  }
-
+  format_bin_to(&result[0], length * 8 + 1, data, length);
   return result;
 }
 
@@ -624,53 +640,44 @@ std::vector<uint8_t> base64_decode(const std::string &encoded_string) {
   return ret;
 }
 
-/// Encode int32 to 5 base85 characters + null terminator
-/// Standard ASCII85 alphabet: '!' (33) = 0 through 'u' (117) = 84
-inline void base85_encode_int32(int32_t value, std::span<char, BASE85_INT32_ENCODED_SIZE> output) {
-  uint32_t v = static_cast<uint32_t>(value);
-  // Encode least significant digit first, then reverse
-  for (int i = 4; i >= 0; i--) {
-    output[i] = static_cast<char>('!' + (v % 85));
-    v /= 85;
-  }
-  output[5] = '\0';
-}
-
-/// Decode 5 base85 characters to int32
-inline bool base85_decode_int32(const char *input, int32_t &out) {
-  uint8_t c0 = static_cast<uint8_t>(input[0] - '!');
-  uint8_t c1 = static_cast<uint8_t>(input[1] - '!');
-  uint8_t c2 = static_cast<uint8_t>(input[2] - '!');
-  uint8_t c3 = static_cast<uint8_t>(input[3] - '!');
-  uint8_t c4 = static_cast<uint8_t>(input[4] - '!');
-
-  // Each digit must be 0-84. Since uint8_t wraps, chars below '!' become > 84
-  if (c0 > 84 || c1 > 84 || c2 > 84 || c3 > 84 || c4 > 84)
-    return false;
-
-  // 85^4 = 52200625, 85^3 = 614125, 85^2 = 7225, 85^1 = 85
-  out = static_cast<int32_t>(c0 * 52200625u + c1 * 614125u + c2 * 7225u + c3 * 85u + c4);
-  return true;
-}
-
-/// Decode base85 string directly into vector (no intermediate buffer)
-bool base85_decode_int32_vector(const std::string &base85, std::vector<int32_t> &out) {
-  size_t len = base85.size();
-  if (len % 5 != 0)
-    return false;
+/// Decode base64/base64url string directly into vector of little-endian int32 values
+/// @param base64 Base64 or base64url encoded string (both +/ and -_ accepted)
+/// @param out Output vector (cleared and filled with decoded int32 values)
+/// @return true if successful, false if decode failed or invalid size
+bool base64_decode_int32_vector(const std::string &base64, std::vector<int32_t> &out) {
+  // Decode in chunks to minimize stack usage
+  constexpr size_t chunk_bytes = 48;  // 12 int32 values
+  constexpr size_t chunk_chars = 64;  // 48 * 4/3 = 64 chars
+  uint8_t chunk[chunk_bytes];
 
   out.clear();
-  const char *ptr = base85.data();
-  const char *end = ptr + len;
 
-  while (ptr < end) {
-    int32_t value;
-    if (!base85_decode_int32(ptr, value))
+  const uint8_t *input = reinterpret_cast<const uint8_t *>(base64.data());
+  size_t remaining = base64.size();
+  size_t pos = 0;
+
+  while (remaining > 0) {
+    size_t chars_to_decode = std::min(remaining, chunk_chars);
+    size_t decoded_len = base64_decode(input + pos, chars_to_decode, chunk, chunk_bytes);
+
+    if (decoded_len == 0)
       return false;
-    out.push_back(value);
-    ptr += 5;
+
+    // Parse little-endian int32 values
+    for (size_t i = 0; i + 3 < decoded_len; i += 4) {
+      int32_t timing = static_cast<int32_t>(encode_uint32(chunk[i + 3], chunk[i + 2], chunk[i + 1], chunk[i]));
+      out.push_back(timing);
+    }
+
+    // Check for incomplete int32 in last chunk
+    if (remaining <= chunk_chars && (decoded_len % 4) != 0)
+      return false;
+
+    pos += chars_to_decode;
+    remaining -= chars_to_decode;
   }
-  return true;
+
+  return !out.empty();
 }
 
 // Colors

esphome/core/helpers.h

@@ -1096,9 +1096,66 @@ 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));
@@ -1137,13 +1194,11 @@ std::vector<uint8_t> base64_decode(const std::string &encoded_string);
 size_t base64_decode(std::string const &encoded_string, uint8_t *buf, size_t buf_len);
 size_t base64_decode(const uint8_t *encoded_data, size_t encoded_len, uint8_t *buf, size_t buf_len);
 
-/// Size of buffer needed for base85 encoded int32 (5 chars + null terminator)
-static constexpr size_t BASE85_INT32_ENCODED_SIZE = 6;
-
-void base85_encode_int32(int32_t value, std::span<char, BASE85_INT32_ENCODED_SIZE> output);
-
-bool base85_decode_int32(const char *input, int32_t &out);
-bool base85_decode_int32_vector(const std::string &base85, std::vector<int32_t> &out);
+/// Decode base64/base64url string directly into vector of little-endian int32 values
+/// @param base64 Base64 or base64url encoded string (both +/ and -_ accepted)
+/// @param out Output vector (cleared and filled with decoded int32 values)
+/// @return true if successful, false if decode failed or invalid size
+bool base64_decode_int32_vector(const std::string &base64, std::vector<int32_t> &out);
 
 ///@}
 

esphome/core/progmem.h

@@ -12,6 +12,8 @@
 #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 *
@@ -19,4 +21,6 @@
 #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

esphome/idf_component.yml

@@ -28,8 +28,8 @@ dependencies:
     rules:
       - if: "target in [esp32s2, esp32s3, esp32p4]"
   esphome/esp-hub75:
-    version: 0.2.2
+    version: 0.3.0
     rules:
-      - if: "target in [esp32, esp32s2, esp32s3, esp32p4]"
+      - if: "target in [esp32, esp32s2, esp32s3, esp32c6, esp32p4]"
   esp32async/asynctcp:
     version: 3.4.91

script/ci-custom.py

@@ -682,6 +682,7 @@ 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",
@@ -699,6 +700,7 @@ 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|"