[esp32_hosted] Replace sscanf with strtol for version parsing

Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>
Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Co-authored-by: J. Nick Koston <nick@home-assistant.io>

.clang-tidy.hash

@@ -1 +1 @@
-cf3d341206b4184ec8b7fe85141aef4fe4696aa720c3f8a06d4e57930574bdab
+069fa9526c52f7c580a9ec17c7678d12f142221387e9b561c18f95394d4629a3

esphome/components/api/user_services.h

@@ -264,9 +264,9 @@ template<typename... Ts> class APIRespondAction : public Action<Ts...> {
       // Build and send JSON response
       json::JsonBuilder builder;
       this->json_builder_(x..., builder.root());
-      auto json_buf = builder.serialize();
+      std::string json_str = builder.serialize();
       this->parent_->send_action_response(call_id, success, StringRef(error_message),
-                                          reinterpret_cast<const uint8_t *>(json_buf.data()), json_buf.size());
+                                          reinterpret_cast<const uint8_t *>(json_str.data()), json_str.size());
       return;
     }
 #endif

esphome/components/esp32/__init__.py

@@ -739,9 +739,10 @@ CONF_DISABLE_REGI2C_IN_IRAM = "disable_regi2c_in_iram"
 CONF_DISABLE_FATFS = "disable_fatfs"
 
 # VFS requirement tracking
-# Components that need VFS features can call require_vfs_select() or require_vfs_dir()
+# Components that need VFS features can call require_vfs_*() functions
 KEY_VFS_SELECT_REQUIRED = "vfs_select_required"
 KEY_VFS_DIR_REQUIRED = "vfs_dir_required"
+KEY_VFS_TERMIOS_REQUIRED = "vfs_termios_required"
 # Feature requirement tracking - components can call require_* functions to re-enable
 # These are stored in CORE.data[KEY_ESP32] dict
 KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED = "usb_serial_jtag_secondary_required"
@@ -768,6 +769,15 @@ def require_vfs_dir() -> None:
     CORE.data[KEY_VFS_DIR_REQUIRED] = True
 
 
+def require_vfs_termios() -> None:
+    """Mark that VFS termios support is required by a component.
+
+    Call this from components that use terminal I/O functions (usb_serial_jtag_vfs_*, etc.).
+    This prevents CONFIG_VFS_SUPPORT_TERMIOS from being disabled.
+    """
+    CORE.data[KEY_VFS_TERMIOS_REQUIRED] = True
+
+
 def require_full_certificate_bundle() -> None:
     """Request the full certificate bundle instead of the common-CAs-only bundle.
 
@@ -1372,11 +1382,18 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_LIBC_LOCKS_PLACE_IN_IRAM", False)
 
     # Disable VFS support for termios (terminal I/O functions)
-    # ESPHome doesn't use termios functions on ESP32 (only used in host UART driver).
+    # USB Serial JTAG VFS functions require termios support.
+    # Components that need it (e.g., logger when USB_SERIAL_JTAG is supported but not selected
+    # as the logger output) call require_vfs_termios().
     # Saves approximately 1.8KB of flash when disabled (default).
-    add_idf_sdkconfig_option(
-        "CONFIG_VFS_SUPPORT_TERMIOS", not advanced[CONF_DISABLE_VFS_SUPPORT_TERMIOS]
-    )
+    if CORE.data.get(KEY_VFS_TERMIOS_REQUIRED, False):
+        # Component requires VFS termios - force enable regardless of user setting
+        add_idf_sdkconfig_option("CONFIG_VFS_SUPPORT_TERMIOS", True)
+    else:
+        # No component needs it - allow user to control (default: disabled)
+        add_idf_sdkconfig_option(
+            "CONFIG_VFS_SUPPORT_TERMIOS", not advanced[CONF_DISABLE_VFS_SUPPORT_TERMIOS]
+        )
 
     # Disable VFS support for select() with file descriptors
     # ESPHome only uses select() with sockets via lwip_select(), which still works.

esphome/components/esp32_hosted/update/esp32_hosted_update.cpp

@@ -34,14 +34,29 @@ static const char *const ESP_HOSTED_VERSION_STR = STRINGIFY(ESP_HOSTED_VERSION_M
     ESP_HOSTED_VERSION_MINOR_1) "." STRINGIFY(ESP_HOSTED_VERSION_PATCH_1);
 
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
+// Parse an integer from str, advancing ptr past the number
+// Returns false if no digits were parsed
+static bool parse_int(const char *&ptr, int &value) {
+  char *end;
+  value = static_cast<int>(strtol(ptr, &end, 10));
+  if (end == ptr)
+    return false;
+  ptr = end;
+  return true;
+}
+
 // Parse version string "major.minor.patch" into components
-// Returns true if parsing succeeded
+// Returns true if at least major.minor was parsed
 static bool parse_version(const std::string &version_str, int &major, int &minor, int &patch) {
   major = minor = patch = 0;
-  if (sscanf(version_str.c_str(), "%d.%d.%d", &major, &minor, &patch) >= 2) {
-    return true;
-  }
-  return false;
+  const char *ptr = version_str.c_str();
+
+  if (!parse_int(ptr, major) || *ptr++ != '.' || !parse_int(ptr, minor))
+    return false;
+  if (*ptr == '.')
+    parse_int(++ptr, patch);
+
+  return true;
 }
 
 // Compare two versions, returns:

esphome/components/json/json_util.cpp

@@ -15,7 +15,7 @@ static const char *const TAG = "json";
 static SpiRamAllocator global_json_allocator;
 #endif
 
-SerializationBuffer<> build_json(const json_build_t &f) {
+std::string build_json(const json_build_t &f) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   JsonBuilder builder;
   JsonObject root = builder.root();
@@ -61,62 +61,14 @@ JsonDocument parse_json(const uint8_t *data, size_t len) {
   // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 
-SerializationBuffer<> JsonBuilder::serialize() {
-  // ===========================================================================================
-  // CRITICAL: NRVO (Named Return Value Optimization) - DO NOT REFACTOR WITHOUT UNDERSTANDING
-  // ===========================================================================================
-  //
-  // This function is carefully structured to enable NRVO. The compiler constructs `result`
-  // directly in the caller's stack frame, eliminating the move constructor call entirely.
-  //
-  // WITHOUT NRVO: Each return would trigger SerializationBuffer's move constructor, which
-  // must memcpy up to 768 bytes of stack buffer content. This happens on EVERY JSON
-  // serialization (sensor updates, web server responses, MQTT publishes, etc.).
-  //
-  // WITH NRVO: Zero memcpy, zero move constructor overhead. The buffer lives directly
-  // where the caller needs it.
-  //
-  // Requirements for NRVO to work:
-  //   1. Single named variable (`result`) returned from ALL paths
-  //   2. All paths must return the SAME variable (not different variables)
-  //   3. No std::move() on the return statement
-  //
-  // If you must modify this function:
-  //   - Keep a single `result` variable declared at the top
-  //   - All code paths must return `result` (not a different variable)
-  //   - Verify NRVO still works by checking the disassembly for move constructor calls
-  //   - Test: objdump -d -C firmware.elf | grep "SerializationBuffer.*SerializationBuffer"
-  //     Should show only destructor, NOT move constructor
-  //
-  // Why we avoid measureJson(): It instantiates DummyWriter templates adding ~1KB flash.
-  // Instead, try stack buffer first. 768 bytes covers 99.9% of JSON payloads (sensors ~200B,
-  // lights ~170B, climate ~700B). Only entities with 40+ options exceed this.
-  //
-  // ===========================================================================================
-  constexpr size_t buf_size = SerializationBuffer<>::BUFFER_SIZE;
-  SerializationBuffer<> result(buf_size - 1);  // Max content size (reserve 1 for null)
-
+std::string JsonBuilder::serialize() {
   if (doc_.overflowed()) {
     ESP_LOGE(TAG, "JSON document overflow");
-    auto *buf = result.data_writable_();
-    buf[0] = '{';
-    buf[1] = '}';
-    buf[2] = '\0';
-    result.set_size_(2);
-    return result;
+    return "{}";
   }
-
-  size_t size = serializeJson(doc_, result.data_writable_(), buf_size);
-  if (size < buf_size) {
-    // Fits in stack buffer - update size to actual length
-    result.set_size_(size);
-    return result;
-  }
-
-  // Needs heap allocation - reallocate and serialize again with exact size
-  result.reallocate_heap_(size);
-  serializeJson(doc_, result.data_writable_(), size + 1);
-  return result;
+  std::string output;
+  serializeJson(doc_, output);
+  return output;
 }
 
 }  // namespace json

esphome/components/json/json_util.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cstring>
-#include <string>
 #include <vector>
 
 #include "esphome/core/defines.h"
@@ -16,108 +14,6 @@
 namespace esphome {
 namespace json {
 
-/// Buffer for JSON serialization that uses stack allocation for small payloads.
-/// Template parameter STACK_SIZE specifies the stack buffer size (default 768 bytes).
-/// Supports move semantics for efficient return-by-value.
-template<size_t STACK_SIZE = 768> class SerializationBuffer {
- public:
-  static constexpr size_t BUFFER_SIZE = STACK_SIZE;  ///< Stack buffer size for this instantiation
-
-  /// Construct with known size (typically from measureJson)
-  explicit SerializationBuffer(size_t size) : size_(size) {
-    if (size + 1 <= STACK_SIZE) {
-      buffer_ = stack_buffer_;
-    } else {
-      heap_buffer_ = new char[size + 1];
-      buffer_ = heap_buffer_;
-    }
-    buffer_[0] = '\0';
-  }
-
-  ~SerializationBuffer() { delete[] heap_buffer_; }
-
-  // Move constructor - works with same template instantiation
-  SerializationBuffer(SerializationBuffer &&other) noexcept : heap_buffer_(other.heap_buffer_), size_(other.size_) {
-    if (other.buffer_ == other.stack_buffer_) {
-      // Stack buffer - must copy content
-      std::memcpy(stack_buffer_, other.stack_buffer_, size_ + 1);
-      buffer_ = stack_buffer_;
-    } else {
-      // Heap buffer - steal ownership
-      buffer_ = heap_buffer_;
-      other.heap_buffer_ = nullptr;
-    }
-    // Leave moved-from object in valid empty state
-    other.stack_buffer_[0] = '\0';
-    other.buffer_ = other.stack_buffer_;
-    other.size_ = 0;
-  }
-
-  // Move assignment
-  SerializationBuffer &operator=(SerializationBuffer &&other) noexcept {
-    if (this != &other) {
-      delete[] heap_buffer_;
-      heap_buffer_ = other.heap_buffer_;
-      size_ = other.size_;
-      if (other.buffer_ == other.stack_buffer_) {
-        std::memcpy(stack_buffer_, other.stack_buffer_, size_ + 1);
-        buffer_ = stack_buffer_;
-      } else {
-        buffer_ = heap_buffer_;
-        other.heap_buffer_ = nullptr;
-      }
-      // Leave moved-from object in valid empty state
-      other.stack_buffer_[0] = '\0';
-      other.buffer_ = other.stack_buffer_;
-      other.size_ = 0;
-    }
-    return *this;
-  }
-
-  // Delete copy operations
-  SerializationBuffer(const SerializationBuffer &) = delete;
-  SerializationBuffer &operator=(const SerializationBuffer &) = delete;
-
-  /// Get null-terminated C string
-  const char *c_str() const { return buffer_; }
-  /// Get data pointer
-  const char *data() const { return buffer_; }
-  /// Get string length (excluding null terminator)
-  size_t size() const { return size_; }
-
-  /// Implicit conversion to std::string for backward compatibility
-  /// WARNING: This allocates a new std::string on the heap. Prefer using
-  /// c_str() or data()/size() directly when possible to avoid allocation.
-  operator std::string() const { return std::string(buffer_, size_); }  // NOLINT(google-explicit-constructor)
-
- private:
-  friend class JsonBuilder;  ///< Allows JsonBuilder::serialize() to call private methods
-
-  /// Get writable buffer (for serialization)
-  char *data_writable_() { return buffer_; }
-  /// Set actual size after serialization (must not exceed allocated size)
-  /// Also ensures null termination for c_str() safety
-  void set_size_(size_t size) {
-    size_ = size;
-    buffer_[size] = '\0';
-  }
-
-  /// Reallocate to heap buffer with new size (for when stack buffer is too small)
-  /// This invalidates any previous buffer content. Used by JsonBuilder::serialize().
-  void reallocate_heap_(size_t size) {
-    delete[] heap_buffer_;
-    heap_buffer_ = new char[size + 1];
-    buffer_ = heap_buffer_;
-    size_ = size;
-    buffer_[0] = '\0';
-  }
-
-  char stack_buffer_[STACK_SIZE];
-  char *heap_buffer_{nullptr};
-  char *buffer_;
-  size_t size_;
-};
-
 #ifdef USE_PSRAM
 // Build an allocator for the JSON Library using the RAMAllocator class
 // This is only compiled when PSRAM is enabled
@@ -150,8 +46,7 @@ using json_parse_t = std::function<bool(JsonObject)>;
 using json_build_t = std::function<void(JsonObject)>;
 
 /// Build a JSON string with the provided json build function.
-/// Returns SerializationBuffer for stack-first allocation; implicitly converts to std::string.
-SerializationBuffer<> build_json(const json_build_t &f);
+std::string build_json(const json_build_t &f);
 
 /// Parse a JSON string and run the provided json parse function if it's valid.
 bool parse_json(const std::string &data, const json_parse_t &f);
@@ -174,9 +69,7 @@ class JsonBuilder {
     return root_;
   }
 
-  /// Serialize the JSON document to a SerializationBuffer (stack-first allocation)
-  /// Uses 768-byte stack buffer by default, falls back to heap for larger JSON
-  SerializationBuffer<> serialize();
+  std::string serialize();
 
  private:
 #ifdef USE_PSRAM

esphome/components/logger/__init__.py

@@ -16,6 +16,8 @@ from esphome.components.esp32 import (
     VARIANT_ESP32S3,
     add_idf_sdkconfig_option,
     get_esp32_variant,
+    require_usb_serial_jtag_secondary,
+    require_vfs_termios,
 )
 from esphome.components.libretiny import get_libretiny_component, get_libretiny_family
 from esphome.components.libretiny.const import (
@@ -397,9 +399,15 @@ async def to_code(config):
         elif config[CONF_HARDWARE_UART] == USB_SERIAL_JTAG:
             add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG", True)
             cg.add_define("USE_LOGGER_UART_SELECTION_USB_SERIAL_JTAG")
+    # Define platform support flags for components that need auto-detection
     try:
         uart_selection(USB_SERIAL_JTAG)
         cg.add_define("USE_LOGGER_USB_SERIAL_JTAG")
+        # USB Serial JTAG code is compiled when platform supports it.
+        # Enable secondary USB serial JTAG console so the VFS functions are available.
+        if CORE.is_esp32 and config[CONF_HARDWARE_UART] != USB_SERIAL_JTAG:
+            require_usb_serial_jtag_secondary()
+            require_vfs_termios()
     except cv.Invalid:
         pass
     try:

esphome/components/mipi_spi/mipi_spi.cpp

@@ -1,6 +1,39 @@
 #include "mipi_spi.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace mipi_spi {}  // namespace mipi_spi
-}  // namespace esphome
+namespace esphome::mipi_spi {
+
+void internal_dump_config(const char *model, int width, int height, int offset_width, int offset_height, uint8_t madctl,
+                          bool invert_colors, int display_bits, bool is_big_endian, const optional<uint8_t> &brightness,
+                          GPIOPin *cs, GPIOPin *reset, GPIOPin *dc, int spi_mode, uint32_t data_rate, int bus_width) {
+  ESP_LOGCONFIG(TAG,
+                "MIPI_SPI Display\n"
+                "  Model: %s\n"
+                "  Width: %d\n"
+                "  Height: %d\n"
+                "  Swap X/Y: %s\n"
+                "  Mirror X: %s\n"
+                "  Mirror Y: %s\n"
+                "  Invert colors: %s\n"
+                "  Color order: %s\n"
+                "  Display pixels: %d bits\n"
+                "  Endianness: %s\n"
+                "  SPI Mode: %d\n"
+                "  SPI Data rate: %uMHz\n"
+                "  SPI Bus width: %d",
+                model, width, height, YESNO(madctl & MADCTL_MV), YESNO(madctl & (MADCTL_MX | MADCTL_XFLIP)),
+                YESNO(madctl & (MADCTL_MY | MADCTL_YFLIP)), YESNO(invert_colors), (madctl & MADCTL_BGR) ? "BGR" : "RGB",
+                display_bits, is_big_endian ? "Big" : "Little", spi_mode, static_cast<unsigned>(data_rate / 1000000),
+                bus_width);
+  LOG_PIN("  CS Pin: ", cs);
+  LOG_PIN("  Reset Pin: ", reset);
+  LOG_PIN("  DC Pin: ", dc);
+  if (offset_width != 0)
+    ESP_LOGCONFIG(TAG, "  Offset width: %d", offset_width);
+  if (offset_height != 0)
+    ESP_LOGCONFIG(TAG, "  Offset height: %d", offset_height);
+  if (brightness.has_value())
+    ESP_LOGCONFIG(TAG, "  Brightness: %u", brightness.value());
+}
+
+}  // namespace esphome::mipi_spi

esphome/components/mipi_spi/mipi_spi.h

@@ -63,6 +63,11 @@ enum BusType {
   BUS_TYPE_SINGLE_16 = 16,  // Single bit bus, but 16 bits per transfer
 };
 
+// Helper function for dump_config - defined in mipi_spi.cpp to allow use of LOG_PIN macro
+void internal_dump_config(const char *model, int width, int height, int offset_width, int offset_height, uint8_t madctl,
+                          bool invert_colors, int display_bits, bool is_big_endian, const optional<uint8_t> &brightness,
+                          GPIOPin *cs, GPIOPin *reset, GPIOPin *dc, int spi_mode, uint32_t data_rate, int bus_width);
+
 /**
  * Base class for MIPI SPI displays.
  * All the methods are defined here in the header file, as it is not possible to define templated methods in a cpp file.
@@ -201,37 +206,9 @@ class MipiSpi : public display::Display,
   }
 
   void dump_config() override {
-    esph_log_config(TAG,
-                    "MIPI_SPI Display\n"
-                    "  Model: %s\n"
-                    "  Width: %u\n"
-                    "  Height: %u",
-                    this->model_, WIDTH, HEIGHT);
-    if constexpr (OFFSET_WIDTH != 0)
-      esph_log_config(TAG, "  Offset width: %u", OFFSET_WIDTH);
-    if constexpr (OFFSET_HEIGHT != 0)
-      esph_log_config(TAG, "  Offset height: %u", OFFSET_HEIGHT);
-    esph_log_config(TAG,
-                    "  Swap X/Y: %s\n"
-                    "  Mirror X: %s\n"
-                    "  Mirror Y: %s\n"
-                    "  Invert colors: %s\n"
-                    "  Color order: %s\n"
-                    "  Display pixels: %d bits\n"
-                    "  Endianness: %s\n",
-                    YESNO(this->madctl_ & MADCTL_MV), YESNO(this->madctl_ & (MADCTL_MX | MADCTL_XFLIP)),
-                    YESNO(this->madctl_ & (MADCTL_MY | MADCTL_YFLIP)), YESNO(this->invert_colors_),
-                    this->madctl_ & MADCTL_BGR ? "BGR" : "RGB", DISPLAYPIXEL * 8, IS_BIG_ENDIAN ? "Big" : "Little");
-    if (this->brightness_.has_value())
-      esph_log_config(TAG, "  Brightness: %u", this->brightness_.value());
-    log_pin(TAG, "  CS Pin: ", this->cs_);
-    log_pin(TAG, "  Reset Pin: ", this->reset_pin_);
-    log_pin(TAG, "  DC Pin: ", this->dc_pin_);
-    esph_log_config(TAG,
-                    "  SPI Mode: %d\n"
-                    "  SPI Data rate: %dMHz\n"
-                    "  SPI Bus width: %d",
-                    this->mode_, static_cast<unsigned>(this->data_rate_ / 1000000), BUS_TYPE);
+    internal_dump_config(this->model_, WIDTH, HEIGHT, OFFSET_WIDTH, OFFSET_HEIGHT, this->madctl_, this->invert_colors_,
+                         DISPLAYPIXEL * 8, IS_BIG_ENDIAN, this->brightness_, this->cs_, this->reset_pin_, this->dc_pin_,
+                         this->mode_, this->data_rate_, BUS_TYPE);
   }
 
  protected:

esphome/components/mqtt/mqtt_client.cpp

@@ -564,8 +564,8 @@ bool MQTTClientComponent::publish(const char *topic, const char *payload, size_t
 }
 
 bool MQTTClientComponent::publish_json(const char *topic, const json::json_build_t &f, uint8_t qos, bool retain) {
-  auto message = json::build_json(f);
-  return this->publish(topic, message.c_str(), message.size(), qos, retain);
+  std::string message = json::build_json(f);
+  return this->publish(topic, message.c_str(), message.length(), qos, retain);
 }
 
 void MQTTClientComponent::enable() {
@@ -643,10 +643,34 @@ static bool topic_match(const char *message, const char *subscription) {
 }
 
 void MQTTClientComponent::on_message(const std::string &topic, const std::string &payload) {
-  for (auto &subscription : this->subscriptions_) {
-    if (topic_match(topic.c_str(), subscription.topic.c_str()))
-      subscription.callback(topic, payload);
-  }
+#ifdef USE_ESP8266
+  // IMPORTANT: This defer is REQUIRED to prevent stack overflow crashes on ESP8266.
+  //
+  // On ESP8266, this callback is invoked directly from the lwIP/AsyncTCP network stack
+  // which runs in the "sys" context with a very limited stack (~4KB). By the time we
+  // reach this function, the stack is already partially consumed by the network
+  // processing chain: tcp_input -> AsyncClient::_recv -> AsyncMqttClient::_onMessage -> here.
+  //
+  // MQTT subscription callbacks can trigger arbitrary user actions (automations, HTTP
+  // requests, sensor updates, etc.) which may have deep call stacks of their own.
+  // For example, an HTTP request action requires: DNS lookup -> TCP connect -> TLS
+  // handshake (if HTTPS) -> request formatting. This easily overflows the remaining
+  // system stack space, causing a LoadStoreAlignmentCause exception or silent corruption.
+  //
+  // By deferring to the main loop, we ensure callbacks execute with a fresh, full-size
+  // stack in the normal application context rather than the constrained network task.
+  //
+  // DO NOT REMOVE THIS DEFER without understanding the above. It may appear to work
+  // in simple tests but will cause crashes with complex automations.
+  this->defer([this, topic, payload]() {
+#endif
+    for (auto &subscription : this->subscriptions_) {
+      if (topic_match(topic.c_str(), subscription.topic.c_str()))
+        subscription.callback(topic, payload);
+    }
+#ifdef USE_ESP8266
+  });
+#endif
 }
 
 // Setters

esphome/components/pmsx003/pmsx003.cpp

@@ -2,21 +2,20 @@
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
 
-namespace esphome {
-namespace pmsx003 {
+namespace esphome::pmsx003 {
 
 static const char *const TAG = "pmsx003";
 
 static const uint8_t START_CHARACTER_1 = 0x42;
 static const uint8_t START_CHARACTER_2 = 0x4D;
 
-static const uint16_t PMS_STABILISING_MS = 30000;  // time taken for the sensor to become stable after power on in ms
+static const uint16_t STABILISING_MS = 30000;  // time taken for the sensor to become stable after power on in ms
 
-static const uint16_t PMS_CMD_MEASUREMENT_MODE_PASSIVE =
-    0x0000;  // use `PMS_CMD_MANUAL_MEASUREMENT` to trigger a measurement
-static const uint16_t PMS_CMD_MEASUREMENT_MODE_ACTIVE = 0x0001;  // automatically perform measurements
-static const uint16_t PMS_CMD_SLEEP_MODE_SLEEP = 0x0000;         // go to sleep mode
-static const uint16_t PMS_CMD_SLEEP_MODE_WAKEUP = 0x0001;        // wake up from sleep mode
+static const uint16_t CMD_MEASUREMENT_MODE_PASSIVE =
+    0x0000;  // use `Command::MANUAL_MEASUREMENT` to trigger a measurement
+static const uint16_t CMD_MEASUREMENT_MODE_ACTIVE = 0x0001;  // automatically perform measurements
+static const uint16_t CMD_SLEEP_MODE_SLEEP = 0x0000;         // go to sleep mode
+static const uint16_t CMD_SLEEP_MODE_WAKEUP = 0x0001;        // wake up from sleep mode
 
 void PMSX003Component::setup() {}
 
@@ -42,7 +41,7 @@ void PMSX003Component::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 
-  if (this->update_interval_ <= PMS_STABILISING_MS) {
+  if (this->update_interval_ <= STABILISING_MS) {
     ESP_LOGCONFIG(TAG, "  Mode: active continuous (sensor default)");
   } else {
     ESP_LOGCONFIG(TAG, "  Mode: passive with sleep/wake cycles");
@@ -55,44 +54,44 @@ void PMSX003Component::loop() {
   const uint32_t now = App.get_loop_component_start_time();
 
   // Initialize sensor mode on first loop
-  if (this->initialised_ == 0) {
-    if (this->update_interval_ > PMS_STABILISING_MS) {
+  if (!this->initialised_) {
+    if (this->update_interval_ > STABILISING_MS) {
       // Long update interval: use passive mode with sleep/wake cycles
-      this->send_command_(PMS_CMD_MEASUREMENT_MODE, PMS_CMD_MEASUREMENT_MODE_PASSIVE);
-      this->send_command_(PMS_CMD_SLEEP_MODE, PMS_CMD_SLEEP_MODE_WAKEUP);
+      this->send_command_(Command::MEASUREMENT_MODE, CMD_MEASUREMENT_MODE_PASSIVE);
+      this->send_command_(Command::SLEEP_MODE, CMD_SLEEP_MODE_WAKEUP);
     } else {
       // Short/zero update interval: use active continuous mode
-      this->send_command_(PMS_CMD_MEASUREMENT_MODE, PMS_CMD_MEASUREMENT_MODE_ACTIVE);
+      this->send_command_(Command::MEASUREMENT_MODE, CMD_MEASUREMENT_MODE_ACTIVE);
     }
-    this->initialised_ = 1;
+    this->initialised_ = true;
   }
 
   // If we update less often than it takes the device to stabilise, spin the fan down
   // rather than running it constantly. It does take some time to stabilise, so we
   // need to keep track of what state we're in.
-  if (this->update_interval_ > PMS_STABILISING_MS) {
+  if (this->update_interval_ > STABILISING_MS) {
     switch (this->state_) {
-      case PMSX003_STATE_IDLE:
+      case State::IDLE:
         // Power on the sensor now so it'll be ready when we hit the update time
-        if (now - this->last_update_ < (this->update_interval_ - PMS_STABILISING_MS))
+        if (now - this->last_update_ < (this->update_interval_ - STABILISING_MS))
           return;
 
-        this->state_ = PMSX003_STATE_STABILISING;
-        this->send_command_(PMS_CMD_SLEEP_MODE, PMS_CMD_SLEEP_MODE_WAKEUP);
+        this->state_ = State::STABILISING;
+        this->send_command_(Command::SLEEP_MODE, CMD_SLEEP_MODE_WAKEUP);
         this->fan_on_time_ = now;
         return;
-      case PMSX003_STATE_STABILISING:
+      case State::STABILISING:
         // wait for the sensor to be stable
-        if (now - this->fan_on_time_ < PMS_STABILISING_MS)
+        if (now - this->fan_on_time_ < STABILISING_MS)
           return;
         // consume any command responses that are in the serial buffer
         while (this->available())
           this->read_byte(&this->data_[0]);
         // Trigger a new read
-        this->send_command_(PMS_CMD_MANUAL_MEASUREMENT, 0);
-        this->state_ = PMSX003_STATE_WAITING;
+        this->send_command_(Command::MANUAL_MEASUREMENT, 0);
+        this->state_ = State::WAITING;
         break;
-      case PMSX003_STATE_WAITING:
+      case State::WAITING:
         // Just go ahead and read stuff
         break;
     }
@@ -180,27 +179,31 @@ optional<bool> PMSX003Component::check_byte_() {
 }
 
 bool PMSX003Component::check_payload_length_(uint16_t payload_length) {
+  // https://avaldebe.github.io/PyPMS/sensors/Plantower/
   switch (this->type_) {
-    case PMSX003_TYPE_X003:
-      // The expected payload length is typically 28 bytes.
-      // However, a 20-byte payload check was already present in the code.
-      // No official documentation was found confirming this.
-      // Retaining this check to avoid breaking existing behavior.
+    case Type::PMS1003:
+      return payload_length == 28;  // 2*13+2
+    case Type::PMS3003:             // Data 7/8/9 not set/reserved
+      return payload_length == 20;  // 2*9+2
+    case Type::PMSX003:             // Data 13 not set/reserved
+      // Deprecated: Length 20 is for PMS3003 backwards compatibility
       return payload_length == 28 || payload_length == 20;  // 2*13+2
-    case PMSX003_TYPE_5003T:
-    case PMSX003_TYPE_5003S:
-      return payload_length == 28;  // 2*13+2 (Data 13 not set/reserved)
-    case PMSX003_TYPE_5003ST:
-      return payload_length == 36;  // 2*17+2 (Data 16 not set/reserved)
+    case Type::PMS5003S:
+    case Type::PMS5003T:            // Data 13 not set/reserved
+      return payload_length == 28;  // 2*13+2
+    case Type::PMS5003ST:           // Data 16 not set/reserved
+      return payload_length == 36;  // 2*17+2
+    case Type::PMS9003M:
+      return payload_length == 28;  // 2*13+2
   }
   return false;
 }
 
-void PMSX003Component::send_command_(PMSX0003Command cmd, uint16_t data) {
+void PMSX003Component::send_command_(Command cmd, uint16_t data) {
   uint8_t send_data[7] = {
       START_CHARACTER_1,            // Start Byte 1
       START_CHARACTER_2,            // Start Byte 2
-      cmd,                          // Command
+      static_cast<uint8_t>(cmd),    // Command
       uint8_t((data >> 8) & 0xFF),  // Data 1
       uint8_t((data >> 0) & 0xFF),  // Data 2
       0,                            // Verify Byte 1
@@ -265,7 +268,7 @@ void PMSX003Component::parse_data_() {
   if (this->pm_particles_25um_sensor_ != nullptr)
     this->pm_particles_25um_sensor_->publish_state(pm_particles_25um);
 
-  if (this->type_ == PMSX003_TYPE_5003T) {
+  if (this->type_ == Type::PMS5003T) {
     ESP_LOGD(TAG,
              "Got PM0.3 Particles: %u Count/0.1L, PM0.5 Particles: %u Count/0.1L, PM1.0 Particles: %u Count/0.1L, "
              "PM2.5 Particles %u Count/0.1L",
@@ -289,7 +292,7 @@ void PMSX003Component::parse_data_() {
   }
 
   // Formaldehyde
-  if (this->type_ == PMSX003_TYPE_5003ST || this->type_ == PMSX003_TYPE_5003S) {
+  if (this->type_ == Type::PMS5003S || this->type_ == Type::PMS5003ST) {
     const uint16_t formaldehyde = this->get_16_bit_uint_(28);
 
     ESP_LOGD(TAG, "Got Formaldehyde: %u µg/m^3", formaldehyde);
@@ -299,8 +302,8 @@ void PMSX003Component::parse_data_() {
   }
 
   // Temperature and Humidity
-  if (this->type_ == PMSX003_TYPE_5003ST || this->type_ == PMSX003_TYPE_5003T) {
-    const uint8_t temperature_offset = (this->type_ == PMSX003_TYPE_5003T) ? 24 : 30;
+  if (this->type_ == Type::PMS5003T || this->type_ == Type::PMS5003ST) {
+    const uint8_t temperature_offset = (this->type_ == Type::PMS5003T) ? 24 : 30;
 
     const float temperature = static_cast<int16_t>(this->get_16_bit_uint_(temperature_offset)) / 10.0f;
     const float humidity = this->get_16_bit_uint_(temperature_offset + 2) / 10.0f;
@@ -314,22 +317,22 @@ void PMSX003Component::parse_data_() {
   }
 
   // Firmware Version and Error Code
-  if (this->type_ == PMSX003_TYPE_5003ST) {
-    const uint8_t firmware_version = this->data_[36];
-    const uint8_t error_code = this->data_[37];
+  if (this->type_ == Type::PMS1003 || this->type_ == Type::PMS5003ST || this->type_ == Type::PMS9003M) {
+    const uint8_t firmware_error_code_offset = (this->type_ == Type::PMS5003ST) ? 36 : 28;
+    const uint8_t firmware_version = this->data_[firmware_error_code_offset];
+    const uint8_t error_code = this->data_[firmware_error_code_offset + 1];
 
     ESP_LOGD(TAG, "Got Firmware Version: 0x%02X, Error Code: 0x%02X", firmware_version, error_code);
   }
 
   // Spin down the sensor again if we aren't going to need it until more time has
   // passed than it takes to stabilise
-  if (this->update_interval_ > PMS_STABILISING_MS) {
-    this->send_command_(PMS_CMD_SLEEP_MODE, PMS_CMD_SLEEP_MODE_SLEEP);
-    this->state_ = PMSX003_STATE_IDLE;
+  if (this->update_interval_ > STABILISING_MS) {
+    this->send_command_(Command::SLEEP_MODE, CMD_SLEEP_MODE_SLEEP);
+    this->state_ = State::IDLE;
   }
 
   this->status_clear_warning();
 }
 
-}  // namespace pmsx003
-}  // namespace esphome
+}  // namespace esphome::pmsx003

esphome/components/pmsx003/pmsx003.h

@@ -5,27 +5,28 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
 
-namespace esphome {
-namespace pmsx003 {
+namespace esphome::pmsx003 {
 
-enum PMSX0003Command : uint8_t {
-  PMS_CMD_MEASUREMENT_MODE =
-      0xE1,  // Data Options: `PMS_CMD_MEASUREMENT_MODE_PASSIVE`, `PMS_CMD_MEASUREMENT_MODE_ACTIVE`
-  PMS_CMD_MANUAL_MEASUREMENT = 0xE2,
-  PMS_CMD_SLEEP_MODE = 0xE4,  // Data Options: `PMS_CMD_SLEEP_MODE_SLEEP`, `PMS_CMD_SLEEP_MODE_WAKEUP`
+enum class Type : uint8_t {
+  PMS1003 = 0,
+  PMS3003,
+  PMSX003,  // PMS5003, PMS6003, PMS7003, PMSA003 (NOT PMSA003I - see `pmsa003i` component)
+  PMS5003S,
+  PMS5003T,
+  PMS5003ST,
+  PMS9003M,
 };
 
-enum PMSX003Type {
-  PMSX003_TYPE_X003 = 0,
-  PMSX003_TYPE_5003T,
-  PMSX003_TYPE_5003ST,
-  PMSX003_TYPE_5003S,
+enum class Command : uint8_t {
+  MEASUREMENT_MODE = 0xE1,  // Data Options: `CMD_MEASUREMENT_MODE_PASSIVE`, `CMD_MEASUREMENT_MODE_ACTIVE`
+  MANUAL_MEASUREMENT = 0xE2,
+  SLEEP_MODE = 0xE4,  // Data Options: `CMD_SLEEP_MODE_SLEEP`, `CMD_SLEEP_MODE_WAKEUP`
 };
 
-enum PMSX003State {
-  PMSX003_STATE_IDLE = 0,
-  PMSX003_STATE_STABILISING,
-  PMSX003_STATE_WAITING,
+enum class State : uint8_t {
+  IDLE = 0,
+  STABILISING,
+  WAITING,
 };
 
 class PMSX003Component : public uart::UARTDevice, public Component {
@@ -37,7 +38,7 @@ class PMSX003Component : public uart::UARTDevice, public Component {
 
   void set_update_interval(uint32_t update_interval) { this->update_interval_ = update_interval; }
 
-  void set_type(PMSX003Type type) { this->type_ = type; }
+  void set_type(Type type) { this->type_ = type; }
 
   void set_pm_1_0_std_sensor(sensor::Sensor *pm_1_0_std_sensor) { this->pm_1_0_std_sensor_ = pm_1_0_std_sensor; }
   void set_pm_2_5_std_sensor(sensor::Sensor *pm_2_5_std_sensor) { this->pm_2_5_std_sensor_ = pm_2_5_std_sensor; }
@@ -77,20 +78,20 @@ class PMSX003Component : public uart::UARTDevice, public Component {
   optional<bool> check_byte_();
   void parse_data_();
   bool check_payload_length_(uint16_t payload_length);
-  void send_command_(PMSX0003Command cmd, uint16_t data);
+  void send_command_(Command cmd, uint16_t data);
   uint16_t get_16_bit_uint_(uint8_t start_index) const {
     return encode_uint16(this->data_[start_index], this->data_[start_index + 1]);
   }
 
+  Type type_;
+  State state_{State::IDLE};
+  bool initialised_{false};
   uint8_t data_[64];
   uint8_t data_index_{0};
-  uint8_t initialised_{0};
   uint32_t fan_on_time_{0};
   uint32_t last_update_{0};
   uint32_t last_transmission_{0};
   uint32_t update_interval_{0};
-  PMSX003State state_{PMSX003_STATE_IDLE};
-  PMSX003Type type_;
 
   // "Standard Particle"
   sensor::Sensor *pm_1_0_std_sensor_{nullptr};
@@ -118,5 +119,4 @@ class PMSX003Component : public uart::UARTDevice, public Component {
   sensor::Sensor *humidity_sensor_{nullptr};
 };
 
-}  // namespace pmsx003
-}  // namespace esphome
+}  // namespace esphome::pmsx003

esphome/components/pmsx003/sensor.py

@@ -40,34 +40,128 @@ pmsx003_ns = cg.esphome_ns.namespace("pmsx003")
 PMSX003Component = pmsx003_ns.class_("PMSX003Component", uart.UARTDevice, cg.Component)
 PMSX003Sensor = pmsx003_ns.class_("PMSX003Sensor", sensor.Sensor)
 
-TYPE_PMSX003 = "PMSX003"
+TYPE_PMS1003 = "PMS1003"
+TYPE_PMS3003 = "PMS3003"
+TYPE_PMSX003 = "PMSX003"  # PMS5003, PMS6003, PMS7003, PMSA003 (NOT PMSA003I - see `pmsa003i` component)
+TYPE_PMS5003S = "PMS5003S"
 TYPE_PMS5003T = "PMS5003T"
 TYPE_PMS5003ST = "PMS5003ST"
-TYPE_PMS5003S = "PMS5003S"
+TYPE_PMS9003M = "PMS9003M"
 
-PMSX003Type = pmsx003_ns.enum("PMSX003Type")
+Type = pmsx003_ns.enum("Type", is_class=True)
 
 PMSX003_TYPES = {
-    TYPE_PMSX003: PMSX003Type.PMSX003_TYPE_X003,
-    TYPE_PMS5003T: PMSX003Type.PMSX003_TYPE_5003T,
-    TYPE_PMS5003ST: PMSX003Type.PMSX003_TYPE_5003ST,
-    TYPE_PMS5003S: PMSX003Type.PMSX003_TYPE_5003S,
+    TYPE_PMS1003: Type.PMS1003,
+    TYPE_PMS3003: Type.PMS3003,
+    TYPE_PMSX003: Type.PMSX003,
+    TYPE_PMS5003S: Type.PMS5003S,
+    TYPE_PMS5003T: Type.PMS5003T,
+    TYPE_PMS5003ST: Type.PMS5003ST,
+    TYPE_PMS9003M: Type.PMS9003M,
 }
 
 SENSORS_TO_TYPE = {
-    CONF_PM_1_0: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_2_5: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_10_0: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_1_0_STD: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_2_5_STD: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_10_0_STD: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_0_3UM: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_0_5UM: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_1_0UM: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_2_5UM: [TYPE_PMSX003, TYPE_PMS5003T, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_5_0UM: [TYPE_PMSX003, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_PM_10_0UM: [TYPE_PMSX003, TYPE_PMS5003ST, TYPE_PMS5003S],
-    CONF_FORMALDEHYDE: [TYPE_PMS5003ST, TYPE_PMS5003S],
+    CONF_PM_1_0_STD: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_2_5_STD: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_10_0_STD: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_1_0: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_2_5: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_10_0: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_0_3UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_0_5UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_1_0UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_2_5UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_5_0UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_10_0UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_FORMALDEHYDE: [TYPE_PMS5003S, TYPE_PMS5003ST],
     CONF_TEMPERATURE: [TYPE_PMS5003T, TYPE_PMS5003ST],
     CONF_HUMIDITY: [TYPE_PMS5003T, TYPE_PMS5003ST],
 }

esphome/components/web_server/web_server.cpp

@@ -209,7 +209,7 @@ void DeferredUpdateEventSource::deq_push_back_with_dedup_(void *source, message_
 void DeferredUpdateEventSource::process_deferred_queue_() {
   while (!deferred_queue_.empty()) {
     DeferredEvent &de = deferred_queue_.front();
-    auto message = de.message_generator_(web_server_, de.source_);
+    std::string message = de.message_generator_(web_server_, de.source_);
     if (this->send(message.c_str(), "state") != DISCARDED) {
       // O(n) but memory efficiency is more important than speed here which is why std::vector was chosen
       deferred_queue_.erase(deferred_queue_.begin());
@@ -266,7 +266,7 @@ void DeferredUpdateEventSource::deferrable_send_state(void *source, const char *
     // deferred queue still not empty which means downstream event queue full, no point trying to send first
     deq_push_back_with_dedup_(source, message_generator);
   } else {
-    auto message = message_generator(web_server_, source);
+    std::string message = message_generator(web_server_, source);
     if (this->send(message.c_str(), "state") == DISCARDED) {
       deq_push_back_with_dedup_(source, message_generator);
     } else {
@@ -320,7 +320,7 @@ void DeferredUpdateEventSourceList::on_client_connect_(DeferredUpdateEventSource
   ws->defer([ws, source]() {
     // Configure reconnect timeout and send config
     // this should always go through since the AsyncEventSourceClient event queue is empty on connect
-    auto message = ws->get_config_json();
+    std::string message = ws->get_config_json();
     source->try_send_nodefer(message.c_str(), "ping", millis(), 30000);
 
 #ifdef USE_WEBSERVER_SORTING
@@ -329,10 +329,10 @@ void DeferredUpdateEventSourceList::on_client_connect_(DeferredUpdateEventSource
       JsonObject root = builder.root();
       root[ESPHOME_F("name")] = group.second.name;
       root[ESPHOME_F("sorting_weight")] = group.second.weight;
-      auto group_msg = builder.serialize();
+      message = builder.serialize();
 
       // up to 31 groups should be able to be queued initially without defer
-      source->try_send_nodefer(group_msg.c_str(), "sorting_group");
+      source->try_send_nodefer(message.c_str(), "sorting_group");
     }
 #endif
 
@@ -365,7 +365,7 @@ void WebServer::set_css_include(const char *css_include) { this->css_include_ =
 void WebServer::set_js_include(const char *js_include) { this->js_include_ = js_include; }
 #endif
 
-json::SerializationBuffer<> WebServer::get_config_json() {
+std::string WebServer::get_config_json() {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -597,20 +597,20 @@ void WebServer::handle_sensor_request(AsyncWebServerRequest *request, const UrlM
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
     if (entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->sensor_json_(obj, obj->state, detail);
+      std::string data = this->sensor_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::sensor_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::sensor_state_json_generator(WebServer *web_server, void *source) {
   return web_server->sensor_json_((sensor::Sensor *) (source), ((sensor::Sensor *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::sensor_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::sensor_all_json_generator(WebServer *web_server, void *source) {
   return web_server->sensor_json_((sensor::Sensor *) (source), ((sensor::Sensor *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config) {
+std::string WebServer::sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -644,23 +644,23 @@ void WebServer::handle_text_sensor_request(AsyncWebServerRequest *request, const
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
     if (entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->text_sensor_json_(obj, obj->state, detail);
+      std::string data = this->text_sensor_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::text_sensor_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::text_sensor_state_json_generator(WebServer *web_server, void *source) {
   return web_server->text_sensor_json_((text_sensor::TextSensor *) (source),
                                        ((text_sensor::TextSensor *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::text_sensor_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::text_sensor_all_json_generator(WebServer *web_server, void *source) {
   return web_server->text_sensor_json_((text_sensor::TextSensor *) (source),
                                        ((text_sensor::TextSensor *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value,
-                                                         JsonDetail start_config) {
+std::string WebServer::text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value,
+                                         JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -705,7 +705,7 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->switch_json_(obj, obj->state, detail);
+      std::string data = this->switch_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -734,13 +734,13 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::switch_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::switch_state_json_generator(WebServer *web_server, void *source) {
   return web_server->switch_json_((switch_::Switch *) (source), ((switch_::Switch *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::switch_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::switch_all_json_generator(WebServer *web_server, void *source) {
   return web_server->switch_json_((switch_::Switch *) (source), ((switch_::Switch *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config) {
+std::string WebServer::switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -762,7 +762,7 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
       continue;
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->button_json_(obj, detail);
+      std::string data = this->button_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("press"))) {
       DEFER_ACTION(obj, obj->press());
@@ -775,10 +775,10 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::button_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::button_all_json_generator(WebServer *web_server, void *source) {
   return web_server->button_json_((button::Button *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::button_json_(button::Button *obj, JsonDetail start_config) {
+std::string WebServer::button_json_(button::Button *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -805,23 +805,22 @@ void WebServer::handle_binary_sensor_request(AsyncWebServerRequest *request, con
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
     if (entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->binary_sensor_json_(obj, obj->state, detail);
+      std::string data = this->binary_sensor_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::binary_sensor_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::binary_sensor_state_json_generator(WebServer *web_server, void *source) {
   return web_server->binary_sensor_json_((binary_sensor::BinarySensor *) (source),
                                          ((binary_sensor::BinarySensor *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::binary_sensor_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::binary_sensor_all_json_generator(WebServer *web_server, void *source) {
   return web_server->binary_sensor_json_((binary_sensor::BinarySensor *) (source),
                                          ((binary_sensor::BinarySensor *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value,
-                                                           JsonDetail start_config) {
+std::string WebServer::binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -848,7 +847,7 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->fan_json_(obj, detail);
+      std::string data = this->fan_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("toggle"))) {
       DEFER_ACTION(obj, obj->toggle().perform());
@@ -889,13 +888,13 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::fan_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::fan_state_json_generator(WebServer *web_server, void *source) {
   return web_server->fan_json_((fan::Fan *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::fan_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::fan_all_json_generator(WebServer *web_server, void *source) {
   return web_server->fan_json_((fan::Fan *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::fan_json_(fan::Fan *obj, JsonDetail start_config) {
+std::string WebServer::fan_json_(fan::Fan *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -929,7 +928,7 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->light_json_(obj, detail);
+      std::string data = this->light_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("toggle"))) {
       DEFER_ACTION(obj, obj->toggle().perform());
@@ -968,13 +967,13 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::light_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::light_state_json_generator(WebServer *web_server, void *source) {
   return web_server->light_json_((light::LightState *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::light_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::light_all_json_generator(WebServer *web_server, void *source) {
   return web_server->light_json_((light::LightState *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::light_json_(light::LightState *obj, JsonDetail start_config) {
+std::string WebServer::light_json_(light::LightState *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1008,7 +1007,7 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->cover_json_(obj, detail);
+      std::string data = this->cover_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1056,13 +1055,13 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::cover_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::cover_state_json_generator(WebServer *web_server, void *source) {
   return web_server->cover_json_((cover::Cover *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::cover_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::cover_all_json_generator(WebServer *web_server, void *source) {
   return web_server->cover_json_((cover::Cover *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::cover_json_(cover::Cover *obj, JsonDetail start_config) {
+std::string WebServer::cover_json_(cover::Cover *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1097,7 +1096,7 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->number_json_(obj, obj->state, detail);
+      std::string data = this->number_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1116,13 +1115,13 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::number_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::number_state_json_generator(WebServer *web_server, void *source) {
   return web_server->number_json_((number::Number *) (source), ((number::Number *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::number_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::number_all_json_generator(WebServer *web_server, void *source) {
   return web_server->number_json_((number::Number *) (source), ((number::Number *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::number_json_(number::Number *obj, float value, JsonDetail start_config) {
+std::string WebServer::number_json_(number::Number *obj, float value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1164,7 +1163,7 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
       continue;
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->date_json_(obj, detail);
+      std::string data = this->date_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1189,13 +1188,13 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::date_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::date_state_json_generator(WebServer *web_server, void *source) {
   return web_server->date_json_((datetime::DateEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::date_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::date_all_json_generator(WebServer *web_server, void *source) {
   return web_server->date_json_((datetime::DateEntity *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::date_json_(datetime::DateEntity *obj, JsonDetail start_config) {
+std::string WebServer::date_json_(datetime::DateEntity *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1224,7 +1223,7 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
       continue;
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->time_json_(obj, detail);
+      std::string data = this->time_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1248,13 +1247,13 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::time_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::time_state_json_generator(WebServer *web_server, void *source) {
   return web_server->time_json_((datetime::TimeEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::time_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::time_all_json_generator(WebServer *web_server, void *source) {
   return web_server->time_json_((datetime::TimeEntity *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::time_json_(datetime::TimeEntity *obj, JsonDetail start_config) {
+std::string WebServer::time_json_(datetime::TimeEntity *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1283,7 +1282,7 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
       continue;
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->datetime_json_(obj, detail);
+      std::string data = this->datetime_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1307,13 +1306,13 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::datetime_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::datetime_state_json_generator(WebServer *web_server, void *source) {
   return web_server->datetime_json_((datetime::DateTimeEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::datetime_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::datetime_all_json_generator(WebServer *web_server, void *source) {
   return web_server->datetime_json_((datetime::DateTimeEntity *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config) {
+std::string WebServer::datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1344,7 +1343,7 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->text_json_(obj, obj->state, detail);
+      std::string data = this->text_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1363,13 +1362,13 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::text_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::text_state_json_generator(WebServer *web_server, void *source) {
   return web_server->text_json_((text::Text *) (source), ((text::Text *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::text_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::text_all_json_generator(WebServer *web_server, void *source) {
   return web_server->text_json_((text::Text *) (source), ((text::Text *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::text_json_(text::Text *obj, const std::string &value, JsonDetail start_config) {
+std::string WebServer::text_json_(text::Text *obj, const std::string &value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1401,7 +1400,7 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), detail);
+      std::string data = this->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1420,15 +1419,15 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::select_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::select_state_json_generator(WebServer *web_server, void *source) {
   auto *obj = (select::Select *) (source);
   return web_server->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::select_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::select_all_json_generator(WebServer *web_server, void *source) {
   auto *obj = (select::Select *) (source);
   return web_server->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::select_json_(select::Select *obj, StringRef value, JsonDetail start_config) {
+std::string WebServer::select_json_(select::Select *obj, StringRef value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1460,7 +1459,7 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->climate_json_(obj, detail);
+      std::string data = this->climate_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1489,15 +1488,15 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::climate_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::climate_state_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->climate_json_((climate::Climate *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::climate_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::climate_all_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->climate_json_((climate::Climate *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::climate_json_(climate::Climate *obj, JsonDetail start_config) {
+std::string WebServer::climate_json_(climate::Climate *obj, JsonDetail start_config) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   json::JsonBuilder builder;
   JsonObject root = builder.root();
@@ -1630,7 +1629,7 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->lock_json_(obj, obj->state, detail);
+      std::string data = this->lock_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1659,13 +1658,13 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::lock_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::lock_state_json_generator(WebServer *web_server, void *source) {
   return web_server->lock_json_((lock::Lock *) (source), ((lock::Lock *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::lock_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::lock_all_json_generator(WebServer *web_server, void *source) {
   return web_server->lock_json_((lock::Lock *) (source), ((lock::Lock *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config) {
+std::string WebServer::lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1693,7 +1692,7 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->valve_json_(obj, detail);
+      std::string data = this->valve_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1739,13 +1738,13 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::valve_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::valve_state_json_generator(WebServer *web_server, void *source) {
   return web_server->valve_json_((valve::Valve *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::valve_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::valve_all_json_generator(WebServer *web_server, void *source) {
   return web_server->valve_json_((valve::Valve *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::valve_json_(valve::Valve *obj, JsonDetail start_config) {
+std::string WebServer::valve_json_(valve::Valve *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1778,7 +1777,7 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->alarm_control_panel_json_(obj, obj->get_state(), detail);
+      std::string data = this->alarm_control_panel_json_(obj, obj->get_state(), detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1818,19 +1817,19 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::alarm_control_panel_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::alarm_control_panel_state_json_generator(WebServer *web_server, void *source) {
   return web_server->alarm_control_panel_json_((alarm_control_panel::AlarmControlPanel *) (source),
                                                ((alarm_control_panel::AlarmControlPanel *) (source))->get_state(),
                                                DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::alarm_control_panel_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::alarm_control_panel_all_json_generator(WebServer *web_server, void *source) {
   return web_server->alarm_control_panel_json_((alarm_control_panel::AlarmControlPanel *) (source),
                                                ((alarm_control_panel::AlarmControlPanel *) (source))->get_state(),
                                                DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
-                                                                 alarm_control_panel::AlarmControlPanelState value,
-                                                                 JsonDetail start_config) {
+std::string WebServer::alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
+                                                 alarm_control_panel::AlarmControlPanelState value,
+                                                 JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1859,7 +1858,7 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->water_heater_json_(obj, detail);
+      std::string data = this->water_heater_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1895,14 +1894,14 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::water_heater_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::water_heater_state_json_generator(WebServer *web_server, void *source) {
   return web_server->water_heater_json_(static_cast<water_heater::WaterHeater *>(source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::water_heater_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::water_heater_all_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->water_heater_json_(static_cast<water_heater::WaterHeater *>(source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config) {
+std::string WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
   char buf[PSTR_LOCAL_SIZE];
@@ -1965,7 +1964,7 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->infrared_json_(obj, detail);
+      std::string data = this->infrared_json_(obj, detail);
       request->send(200, ESPHOME_F("application/json"), data.c_str());
       return;
     }
@@ -2036,12 +2035,12 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::infrared_all_json_generator(WebServer *web_server, void *source) {
+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);
 }
 
-json::SerializationBuffer<> WebServer::infrared_json_(infrared::Infrared *obj, JsonDetail start_config) {
+std::string WebServer::infrared_json_(infrared::Infrared *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -2076,7 +2075,7 @@ void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMa
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
     if (entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->event_json_(obj, StringRef(), detail);
+      std::string data = this->event_json_(obj, StringRef(), detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -2086,16 +2085,16 @@ void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMa
 
 static StringRef get_event_type(event::Event *event) { return event ? event->get_last_event_type() : StringRef(); }
 
-json::SerializationBuffer<> WebServer::event_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::event_state_json_generator(WebServer *web_server, void *source) {
   auto *event = static_cast<event::Event *>(source);
   return web_server->event_json_(event, get_event_type(event), DETAIL_STATE);
 }
 // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-json::SerializationBuffer<> WebServer::event_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::event_all_json_generator(WebServer *web_server, void *source) {
   auto *event = static_cast<event::Event *>(source);
   return web_server->event_json_(event, get_event_type(event), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config) {
+std::string WebServer::event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -2142,7 +2141,7 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->update_json_(obj, detail);
+      std::string data = this->update_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -2158,15 +2157,15 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::update_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::update_state_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->update_json_((update::UpdateEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::update_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::update_all_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->update_json_((update::UpdateEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::update_json_(update::UpdateEntity *obj, JsonDetail start_config) {
+std::string WebServer::update_json_(update::UpdateEntity *obj, JsonDetail start_config) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   json::JsonBuilder builder;
   JsonObject root = builder.root();

esphome/components/web_server/web_server.h

@@ -2,7 +2,6 @@
 
 #include "list_entities.h"
 
-#include "esphome/components/json/json_util.h"
 #include "esphome/components/web_server_base/web_server_base.h"
 #ifdef USE_WEBSERVER
 #include "esphome/core/component.h"
@@ -105,7 +104,7 @@ enum JsonDetail { DETAIL_ALL, DETAIL_STATE };
   can be forgotten.
 */
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
-using message_generator_t = json::SerializationBuffer<>(WebServer *, void *);
+using message_generator_t = std::string(WebServer *, void *);
 
 class DeferredUpdateEventSourceList;
 class DeferredUpdateEventSource : public AsyncEventSource {
@@ -264,7 +263,7 @@ class WebServer : public Controller,
   void handle_index_request(AsyncWebServerRequest *request);
 
   /// Return the webserver configuration as JSON.
-  json::SerializationBuffer<> get_config_json();
+  std::string get_config_json();
 
 #ifdef USE_WEBSERVER_CSS_INCLUDE
   /// Handle included css request under '/0.css'.
@@ -286,8 +285,8 @@ class WebServer : public Controller,
   /// Handle a sensor request under '/sensor/<id>'.
   void handle_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> sensor_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> sensor_all_json_generator(WebServer *web_server, void *source);
+  static std::string sensor_state_json_generator(WebServer *web_server, void *source);
+  static std::string sensor_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_SWITCH
@@ -296,8 +295,8 @@ class WebServer : public Controller,
   /// Handle a switch request under '/switch/<id>/</turn_on/turn_off/toggle>'.
   void handle_switch_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> switch_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> switch_all_json_generator(WebServer *web_server, void *source);
+  static std::string switch_state_json_generator(WebServer *web_server, void *source);
+  static std::string switch_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_BUTTON
@@ -305,7 +304,7 @@ class WebServer : public Controller,
   void handle_button_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
   // Buttons are stateless, so there is no button_state_json_generator
-  static json::SerializationBuffer<> button_all_json_generator(WebServer *web_server, void *source);
+  static std::string button_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_BINARY_SENSOR
@@ -314,8 +313,8 @@ class WebServer : public Controller,
   /// Handle a binary sensor request under '/binary_sensor/<id>'.
   void handle_binary_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> binary_sensor_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> binary_sensor_all_json_generator(WebServer *web_server, void *source);
+  static std::string binary_sensor_state_json_generator(WebServer *web_server, void *source);
+  static std::string binary_sensor_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_FAN
@@ -324,8 +323,8 @@ class WebServer : public Controller,
   /// Handle a fan request under '/fan/<id>/</turn_on/turn_off/toggle>'.
   void handle_fan_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> fan_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> fan_all_json_generator(WebServer *web_server, void *source);
+  static std::string fan_state_json_generator(WebServer *web_server, void *source);
+  static std::string fan_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_LIGHT
@@ -334,8 +333,8 @@ class WebServer : public Controller,
   /// Handle a light request under '/light/<id>/</turn_on/turn_off/toggle>'.
   void handle_light_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> light_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> light_all_json_generator(WebServer *web_server, void *source);
+  static std::string light_state_json_generator(WebServer *web_server, void *source);
+  static std::string light_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_TEXT_SENSOR
@@ -344,8 +343,8 @@ class WebServer : public Controller,
   /// Handle a text sensor request under '/text_sensor/<id>'.
   void handle_text_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> text_sensor_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> text_sensor_all_json_generator(WebServer *web_server, void *source);
+  static std::string text_sensor_state_json_generator(WebServer *web_server, void *source);
+  static std::string text_sensor_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_COVER
@@ -354,8 +353,8 @@ class WebServer : public Controller,
   /// Handle a cover request under '/cover/<id>/<open/close/stop/set>'.
   void handle_cover_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> cover_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> cover_all_json_generator(WebServer *web_server, void *source);
+  static std::string cover_state_json_generator(WebServer *web_server, void *source);
+  static std::string cover_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_NUMBER
@@ -363,8 +362,8 @@ class WebServer : public Controller,
   /// Handle a number request under '/number/<id>'.
   void handle_number_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> number_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> number_all_json_generator(WebServer *web_server, void *source);
+  static std::string number_state_json_generator(WebServer *web_server, void *source);
+  static std::string number_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_DATETIME_DATE
@@ -372,8 +371,8 @@ class WebServer : public Controller,
   /// Handle a date request under '/date/<id>'.
   void handle_date_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> date_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> date_all_json_generator(WebServer *web_server, void *source);
+  static std::string date_state_json_generator(WebServer *web_server, void *source);
+  static std::string date_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_DATETIME_TIME
@@ -381,8 +380,8 @@ class WebServer : public Controller,
   /// Handle a time request under '/time/<id>'.
   void handle_time_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> time_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> time_all_json_generator(WebServer *web_server, void *source);
+  static std::string time_state_json_generator(WebServer *web_server, void *source);
+  static std::string time_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_DATETIME_DATETIME
@@ -390,8 +389,8 @@ class WebServer : public Controller,
   /// Handle a datetime request under '/datetime/<id>'.
   void handle_datetime_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> datetime_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> datetime_all_json_generator(WebServer *web_server, void *source);
+  static std::string datetime_state_json_generator(WebServer *web_server, void *source);
+  static std::string datetime_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_TEXT
@@ -399,8 +398,8 @@ class WebServer : public Controller,
   /// Handle a text input request under '/text/<id>'.
   void handle_text_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> text_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> text_all_json_generator(WebServer *web_server, void *source);
+  static std::string text_state_json_generator(WebServer *web_server, void *source);
+  static std::string text_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_SELECT
@@ -408,8 +407,8 @@ class WebServer : public Controller,
   /// Handle a select request under '/select/<id>'.
   void handle_select_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> select_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> select_all_json_generator(WebServer *web_server, void *source);
+  static std::string select_state_json_generator(WebServer *web_server, void *source);
+  static std::string select_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_CLIMATE
@@ -417,8 +416,8 @@ class WebServer : public Controller,
   /// Handle a climate request under '/climate/<id>'.
   void handle_climate_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> climate_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> climate_all_json_generator(WebServer *web_server, void *source);
+  static std::string climate_state_json_generator(WebServer *web_server, void *source);
+  static std::string climate_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_LOCK
@@ -427,8 +426,8 @@ class WebServer : public Controller,
   /// Handle a lock request under '/lock/<id>/</lock/unlock/open>'.
   void handle_lock_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> lock_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> lock_all_json_generator(WebServer *web_server, void *source);
+  static std::string lock_state_json_generator(WebServer *web_server, void *source);
+  static std::string lock_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_VALVE
@@ -437,8 +436,8 @@ class WebServer : public Controller,
   /// Handle a valve request under '/valve/<id>/<open/close/stop/set>'.
   void handle_valve_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> valve_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> valve_all_json_generator(WebServer *web_server, void *source);
+  static std::string valve_state_json_generator(WebServer *web_server, void *source);
+  static std::string valve_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
@@ -447,8 +446,8 @@ class WebServer : public Controller,
   /// Handle a alarm_control_panel request under '/alarm_control_panel/<id>'.
   void handle_alarm_control_panel_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> alarm_control_panel_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> alarm_control_panel_all_json_generator(WebServer *web_server, void *source);
+  static std::string alarm_control_panel_state_json_generator(WebServer *web_server, void *source);
+  static std::string alarm_control_panel_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_WATER_HEATER
@@ -457,22 +456,22 @@ class WebServer : public Controller,
   /// Handle a water_heater request under '/water_heater/<id>/<mode/set>'.
   void handle_water_heater_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> water_heater_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> water_heater_all_json_generator(WebServer *web_server, void *source);
+  static std::string water_heater_state_json_generator(WebServer *web_server, void *source);
+  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 json::SerializationBuffer<> infrared_all_json_generator(WebServer *web_server, void *source);
+  static std::string infrared_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_EVENT
   void on_event(event::Event *obj) override;
 
-  static json::SerializationBuffer<> event_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> event_all_json_generator(WebServer *web_server, void *source);
+  static std::string event_state_json_generator(WebServer *web_server, void *source);
+  static std::string event_all_json_generator(WebServer *web_server, void *source);
 
   /// Handle a event request under '/event<id>'.
   void handle_event_request(AsyncWebServerRequest *request, const UrlMatch &match);
@@ -484,8 +483,8 @@ class WebServer : public Controller,
   /// Handle a update request under '/update/<id>'.
   void handle_update_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> update_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> update_all_json_generator(WebServer *web_server, void *source);
+  static std::string update_state_json_generator(WebServer *web_server, void *source);
+  static std::string update_all_json_generator(WebServer *web_server, void *source);
 #endif
 
   /// Override the web handler's canHandle method.
@@ -610,74 +609,71 @@ class WebServer : public Controller,
 
  private:
 #ifdef USE_SENSOR
-  json::SerializationBuffer<> sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config);
+  std::string sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config);
 #endif
 #ifdef USE_SWITCH
-  json::SerializationBuffer<> switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config);
+  std::string switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config);
 #endif
 #ifdef USE_BUTTON
-  json::SerializationBuffer<> button_json_(button::Button *obj, JsonDetail start_config);
+  std::string button_json_(button::Button *obj, JsonDetail start_config);
 #endif
 #ifdef USE_BINARY_SENSOR
-  json::SerializationBuffer<> binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value,
-                                                  JsonDetail start_config);
+  std::string binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value, JsonDetail start_config);
 #endif
 #ifdef USE_FAN
-  json::SerializationBuffer<> fan_json_(fan::Fan *obj, JsonDetail start_config);
+  std::string fan_json_(fan::Fan *obj, JsonDetail start_config);
 #endif
 #ifdef USE_LIGHT
-  json::SerializationBuffer<> light_json_(light::LightState *obj, JsonDetail start_config);
+  std::string light_json_(light::LightState *obj, JsonDetail start_config);
 #endif
 #ifdef USE_TEXT_SENSOR
-  json::SerializationBuffer<> text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value,
-                                                JsonDetail start_config);
+  std::string text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value, JsonDetail start_config);
 #endif
 #ifdef USE_COVER
-  json::SerializationBuffer<> cover_json_(cover::Cover *obj, JsonDetail start_config);
+  std::string cover_json_(cover::Cover *obj, JsonDetail start_config);
 #endif
 #ifdef USE_NUMBER
-  json::SerializationBuffer<> number_json_(number::Number *obj, float value, JsonDetail start_config);
+  std::string number_json_(number::Number *obj, float value, JsonDetail start_config);
 #endif
 #ifdef USE_DATETIME_DATE
-  json::SerializationBuffer<> date_json_(datetime::DateEntity *obj, JsonDetail start_config);
+  std::string date_json_(datetime::DateEntity *obj, JsonDetail start_config);
 #endif
 #ifdef USE_DATETIME_TIME
-  json::SerializationBuffer<> time_json_(datetime::TimeEntity *obj, JsonDetail start_config);
+  std::string time_json_(datetime::TimeEntity *obj, JsonDetail start_config);
 #endif
 #ifdef USE_DATETIME_DATETIME
-  json::SerializationBuffer<> datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config);
+  std::string datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config);
 #endif
 #ifdef USE_TEXT
-  json::SerializationBuffer<> text_json_(text::Text *obj, const std::string &value, JsonDetail start_config);
+  std::string text_json_(text::Text *obj, const std::string &value, JsonDetail start_config);
 #endif
 #ifdef USE_SELECT
-  json::SerializationBuffer<> select_json_(select::Select *obj, StringRef value, JsonDetail start_config);
+  std::string select_json_(select::Select *obj, StringRef value, JsonDetail start_config);
 #endif
 #ifdef USE_CLIMATE
-  json::SerializationBuffer<> climate_json_(climate::Climate *obj, JsonDetail start_config);
+  std::string climate_json_(climate::Climate *obj, JsonDetail start_config);
 #endif
 #ifdef USE_LOCK
-  json::SerializationBuffer<> lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config);
+  std::string lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config);
 #endif
 #ifdef USE_VALVE
-  json::SerializationBuffer<> valve_json_(valve::Valve *obj, JsonDetail start_config);
+  std::string valve_json_(valve::Valve *obj, JsonDetail start_config);
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
-  json::SerializationBuffer<> alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
-                                                        alarm_control_panel::AlarmControlPanelState value,
-                                                        JsonDetail start_config);
+  std::string alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
+                                        alarm_control_panel::AlarmControlPanelState value, JsonDetail start_config);
 #endif
 #ifdef USE_EVENT
-  json::SerializationBuffer<> event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config);
+  std::string event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config);
 #endif
 #ifdef USE_WATER_HEATER
-  json::SerializationBuffer<> water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config);
+  std::string water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config);
 #endif
 #ifdef USE_INFRARED
-  json::SerializationBuffer<> infrared_json_(infrared::Infrared *obj, JsonDetail start_config);
+  std::string infrared_json_(infrared::Infrared *obj, JsonDetail start_config);
 #endif
 #ifdef USE_UPDATE
-  json::SerializationBuffer<> update_json_(update::UpdateEntity *obj, JsonDetail start_config);
+  std::string update_json_(update::UpdateEntity *obj, JsonDetail start_config);
 #endif
 };
 

esphome/components/web_server_base/__init__.py

@@ -53,4 +53,4 @@ async def to_code(config):
                 "lib_ignore", ["ESPAsyncTCP", "AsyncTCP", "AsyncTCP_RP2040W"]
             )
         # https://github.com/ESP32Async/ESPAsyncWebServer/blob/main/library.json
-        cg.add_library("ESP32Async/ESPAsyncWebServer", "3.9.5")
+        cg.add_library("ESP32Async/ESPAsyncWebServer", "3.9.6")

esphome/components/web_server_idf/web_server_idf.cpp

@@ -507,7 +507,7 @@ AsyncEventSourceResponse::AsyncEventSourceResponse(const AsyncWebServerRequest *
 
   // Configure reconnect timeout and send config
   // this should always go through since the tcp send buffer is empty on connect
-  auto message = ws->get_config_json();
+  std::string message = ws->get_config_json();
   this->try_send_nodefer(message.c_str(), "ping", millis(), 30000);
 
 #ifdef USE_WEBSERVER_SORTING
@@ -561,7 +561,7 @@ void AsyncEventSourceResponse::deq_push_back_with_dedup_(void *source, message_g
 void AsyncEventSourceResponse::process_deferred_queue_() {
   while (!deferred_queue_.empty()) {
     DeferredEvent &de = deferred_queue_.front();
-    auto message = de.message_generator_(web_server_, de.source_);
+    std::string message = de.message_generator_(web_server_, de.source_);
     if (this->try_send_nodefer(message.c_str(), "state")) {
       // O(n) but memory efficiency is more important than speed here which is why std::vector was chosen
       deferred_queue_.erase(deferred_queue_.begin());
@@ -798,7 +798,7 @@ void AsyncEventSourceResponse::deferrable_send_state(void *source, const char *e
     // trying to send first
     deq_push_back_with_dedup_(source, message_generator);
   } else {
-    auto message = message_generator(web_server_, source);
+    std::string message = message_generator(web_server_, source);
     if (!this->try_send_nodefer(message.c_str(), "state")) {
       deq_push_back_with_dedup_(source, message_generator);
     }

esphome/components/web_server_idf/web_server_idf.h

@@ -16,7 +16,6 @@
 #include <vector>
 
 #ifdef USE_WEBSERVER
-#include "esphome/components/json/json_util.h"
 #include "esphome/components/web_server/list_entities.h"
 #endif
 
@@ -251,7 +250,7 @@ class AsyncWebHandler {
 class AsyncEventSource;
 class AsyncEventSourceResponse;
 
-using message_generator_t = json::SerializationBuffer<>(esphome::web_server::WebServer *, void *);
+using message_generator_t = std::string(esphome::web_server::WebServer *, void *);
 
 /*
   This class holds a pointer to the source component that wants to publish a state event, and a pointer to a function

esphome/core/application.cpp

@@ -210,7 +210,7 @@ void Application::loop() {
 #ifdef USE_ESP32
       esp_chip_info_t chip_info;
       esp_chip_info(&chip_info);
-      ESP_LOGI(TAG, "ESP32 Chip: %s r%d.%d, %d core(s)", ESPHOME_VARIANT, chip_info.revision / 100,
+      ESP_LOGI(TAG, "ESP32 Chip: %s rev%d.%d, %d core(s)", ESPHOME_VARIANT, chip_info.revision / 100,
                chip_info.revision % 100, chip_info.cores);
 #if defined(USE_ESP32_VARIANT_ESP32) && !defined(USE_ESP32_MIN_CHIP_REVISION_SET)
       // Suggest optimization for chips that don't need the PSRAM cache workaround

platformio.ini

@@ -114,7 +114,7 @@ lib_deps =
     ESP8266WiFi                           ; wifi (Arduino built-in)
     Update                                ; ota (Arduino built-in)
     ESP32Async/ESPAsyncTCP@2.0.0          ; async_tcp
-    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
     makuna/NeoPixelBus@2.7.3              ; neopixelbus
     ESP8266HTTPClient                     ; http_request (Arduino built-in)
     ESP8266mDNS                           ; mdns (Arduino built-in)
@@ -202,7 +202,7 @@ lib_deps =
     ${common:arduino.lib_deps}
     ayushsharma82/RPAsyncTCP@1.3.2        ; async_tcp
     bblanchon/ArduinoJson@7.4.2           ; json
-    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
 build_flags =
     ${common:arduino.build_flags}
     -DUSE_RP2040
@@ -218,7 +218,7 @@ framework = arduino
 lib_compat_mode = soft
 lib_deps =
     bblanchon/ArduinoJson@7.4.2           ; json
-    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
     droscy/esp_wireguard@0.4.2            ; wireguard
 build_flags =
     ${common:arduino.build_flags}

tests/components/json/common.yaml

@@ -4,16 +4,15 @@ interval:
   - interval: 60s
     then:
       - lambda: |-
-          // Test build_json - returns SerializationBuffer, use auto to avoid heap allocation
-          auto json_buf = esphome::json::build_json([](JsonObject root) {
+          // Test build_json
+          std::string json_str = esphome::json::build_json([](JsonObject root) {
             root["sensor"] = "temperature";
             root["value"] = 23.5;
             root["unit"] = "°C";
           });
-          ESP_LOGD("test", "Built JSON: %s", json_buf.c_str());
+          ESP_LOGD("test", "Built JSON: %s", json_str.c_str());
 
-          // Test parse_json - implicit conversion to std::string for backward compatibility
-          std::string json_str = json_buf;
+          // Test parse_json
           bool parse_ok = esphome::json::parse_json(json_str, [](JsonObject root) {
             if (root["sensor"].is<const char*>() && root["value"].is<float>()) {
               const char* sensor = root["sensor"];
@@ -27,10 +26,10 @@ interval:
           });
           ESP_LOGD("test", "Parse result (JSON syntax only): %s", parse_ok ? "success" : "failed");
 
-          // Test JsonBuilder class - returns SerializationBuffer
+          // Test JsonBuilder class
           esphome::json::JsonBuilder builder;
           JsonObject obj = builder.root();
           obj["test"] = "direct_builder";
           obj["count"] = 42;
-          auto result = builder.serialize();
+          std::string result = builder.serialize();
           ESP_LOGD("test", "JsonBuilder result: %s", result.c_str());

tests/components/mipi_spi/test.esp8266-ard.yaml

@@ -0,0 +1,10 @@
+substitutions:
+  dc_pin: GPIO15
+  cs_pin: GPIO5
+  enable_pin: GPIO4
+  reset_pin: GPIO16
+
+packages:
+  spi: !include ../../test_build_components/common/spi/esp8266-ard.yaml
+
+<<: !include common.yaml

tests/components/pmsx003/common.yaml

@@ -8,11 +8,11 @@ sensor:
     pm_10_0:
       name: PM 10.0 Concentration
     pm_1_0_std:
-      name: PM 1.0 Standard Atmospher Concentration
+      name: PM 1.0 Standard Atmospheric Concentration
     pm_2_5_std:
-      name: PM 2.5 Standard Atmospher Concentration
+      name: PM 2.5 Standard Atmospheric Concentration
     pm_10_0_std:
-      name: PM 10.0 Standard Atmospher Concentration
+      name: PM 10.0 Standard Atmospheric Concentration
     pm_0_3um:
       name: Particulate Count >0.3um
     pm_0_5um: