Merge branch 'dev' into json_web_server_stack

private implementation details
avoid misuse
2026-01-31 08:52:07 -07:00 · 2026-01-29 14:48:48 -10:00 · 2026-01-29 18:45:18 -06:00 · 2026-01-29 18:23:25 -06:00 · 2026-01-29 18:19:29 -06:00 · 2026-01-29 18:17:34 -06:00
30 changed files with 499 additions and 828 deletions
--- a/.clang-tidy.hash
+++ b/.clang-tidy.hash
@@ -1 +1 @@
-069fa9526c52f7c580a9ec17c7678d12f142221387e9b561c18f95394d4629a3
+cf3d341206b4184ec8b7fe85141aef4fe4696aa720c3f8a06d4e57930574bdab
--- a/esphome/components/api/user_services.h
+++ b/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());
-      std::string json_str = builder.serialize();
+      auto json_buf = builder.serialize();
      this->parent_->send_action_response(call_id, success, StringRef(error_message),
-                                          reinterpret_cast<const uint8_t *>(json_str.data()), json_str.size());
+                                          reinterpret_cast<const uint8_t *>(json_buf.data()), json_buf.size());
      return;
    }
 #endif
--- a/esphome/components/esp32/init.py
+++ b/esphome/components/esp32/init.py
@@ -124,14 +124,10 @@ COMPILER_OPTIMIZATIONS = {
 # - "sdmmc": driver -> esp_driver_sdmmc -> sdmmc dependency chain
 DEFAULT_EXCLUDED_IDF_COMPONENTS = (
    "cmock",  # Unit testing mock framework - ESPHome doesn't use IDF's testing
-    "driver",  # Legacy driver shim - only needed by esp32_touch, esp32_can for legacy headers
    "esp_adc",  # ADC driver - only needed by adc component
-    "esp_driver_dac",  # DAC driver - only needed by esp32_dac component
    "esp_driver_i2s",  # I2S driver - only needed by i2s_audio component
-    "esp_driver_mcpwm",  # MCPWM driver - ESPHome doesn't use motor control PWM
    "esp_driver_rmt",  # RMT driver - only needed by remote_transmitter/receiver, neopixelbus
    "esp_driver_touch_sens",  # Touch sensor driver - only needed by esp32_touch
-    "esp_driver_twai",  # TWAI/CAN driver - only needed by esp32_can component
    "esp_eth",  # Ethernet driver - only needed by ethernet component
    "esp_hid",  # HID host/device support - ESPHome doesn't implement HID functionality
    "esp_http_client",  # HTTP client - only needed by http_request component
@@ -142,11 +138,9 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
    "espcoredump",  # Core dump support - ESPHome has its own debug component
    "fatfs",  # FAT filesystem - ESPHome doesn't use filesystem storage
    "mqtt",  # ESP-IDF MQTT library - ESPHome has its own MQTT implementation
-    "openthread",  # Thread protocol - only needed by openthread component
    "perfmon",  # Xtensa performance monitor - ESPHome has its own debug component
    "protocomm",  # Protocol communication for provisioning - unused by ESPHome
    "spiffs",  # SPIFFS filesystem - ESPHome doesn't use filesystem storage (IDF only)
-    "ulp",  # ULP coprocessor - not currently used by any ESPHome component
    "unity",  # Unit testing framework - ESPHome doesn't use IDF's testing
    "wear_levelling",  # Flash wear levelling for fatfs - unused since fatfs unused
    "wifi_provisioning",  # WiFi provisioning - ESPHome uses its own improv implementation
@@ -745,10 +739,9 @@ 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_*() functions
+# Components that need VFS features can call require_vfs_select() or require_vfs_dir()
 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"
@@ -775,15 +768,6 @@ 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.

@@ -1388,18 +1372,11 @@ 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)
-    # 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().
+    # ESPHome doesn't use termios functions on ESP32 (only used in host UART driver).
    # Saves approximately 1.8KB of flash when disabled (default).
-    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]
-        )
+    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.
--- a/esphome/components/esp32_can/canbus.py
+++ b/esphome/components/esp32_can/canbus.py
@@ -15,7 +15,6 @@ from esphome.components.esp32 import (
    VARIANT_ESP32S2,
    VARIANT_ESP32S3,
    get_esp32_variant,
-    include_builtin_idf_component,
 )
 import esphome.config_validation as cv
 from esphome.const import (
@@ -122,10 +121,6 @@ def get_default_tx_enqueue_timeout(bit_rate):


 async def to_code(config):
-    # Legacy driver component provides driver/twai.h header
-    include_builtin_idf_component("driver")
-    # Also enable esp_driver_twai for future migration to new API
-    include_builtin_idf_component("esp_driver_twai")
    var = cg.new_Pvariable(config[CONF_ID])
    await canbus.register_canbus(var, config)

--- a/esphome/components/esp32_dac/output.py
+++ b/esphome/components/esp32_dac/output.py
@@ -1,12 +1,7 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import output
-from esphome.components.esp32 import (
-    VARIANT_ESP32,
-    VARIANT_ESP32S2,
-    get_esp32_variant,
-    include_builtin_idf_component,
-)
+from esphome.components.esp32 import VARIANT_ESP32, VARIANT_ESP32S2, get_esp32_variant
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_NUMBER, CONF_PIN

@@ -43,7 +38,6 @@ CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(


 async def to_code(config):
-    include_builtin_idf_component("esp_driver_dac")
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await output.register_output(var, config)
--- a/esphome/components/esp32_touch/init.py
+++ b/esphome/components/esp32_touch/init.py
@@ -269,8 +269,6 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
    # Re-enable ESP-IDF's touch sensor driver (excluded by default to save compile time)
    include_builtin_idf_component("esp_driver_touch_sens")
-    # Legacy driver component provides driver/touch_sensor.h header
-    include_builtin_idf_component("driver")

    touch = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(touch, config)
--- a/esphome/components/json/json_util.cpp
+++ b/esphome/components/json/json_util.cpp
@@ -15,7 +15,7 @@ static const char *const TAG = "json";
 static SpiRamAllocator global_json_allocator;
 #endif

-std::string build_json(const json_build_t &f) {
+SerializationBuffer<> build_json(const json_build_t &f) {
  // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
  JsonBuilder builder;
  JsonObject root = builder.root();
@@ -61,14 +61,62 @@ JsonDocument parse_json(const uint8_t *data, size_t len) {
  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }

-std::string JsonBuilder::serialize() {
+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)
+
  if (doc_.overflowed()) {
    ESP_LOGE(TAG, "JSON document overflow");
-    return "{}";
+    auto *buf = result.data_writable_();
+    buf[0] = '{';
+    buf[1] = '}';
+    buf[2] = '\0';
+    result.set_size_(2);
+    return result;
  }
-  std::string output;
-  serializeJson(doc_, output);
-  return output;
+
+  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;
 }

 }  // namespace json
--- a/esphome/components/json/json_util.h
+++ b/esphome/components/json/json_util.h
@@ -1,5 +1,7 @@
 #pragma once

+#include <cstring>
+#include <string>
 #include <vector>

 #include "esphome/core/defines.h"
@@ -14,6 +16,108 @@
 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
@@ -46,7 +150,8 @@ 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.
-std::string build_json(const json_build_t &f);
+/// Returns SerializationBuffer for stack-first allocation; implicitly converts to std::string.
+SerializationBuffer<> 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);
@@ -69,7 +174,9 @@ class JsonBuilder {
    return root_;
  }

-  std::string serialize();
+  /// 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();

 private:
 #ifdef USE_PSRAM
--- a/esphome/components/logger/init.py
+++ b/esphome/components/logger/init.py
@@ -16,8 +16,6 @@ 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 (
@@ -399,15 +397,9 @@ 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:
--- a/esphome/components/mipi_spi/mipi_spi.cpp
+++ b/esphome/components/mipi_spi/mipi_spi.cpp
@@ -1,39 +1,6 @@
 #include "mipi_spi.h"
 #include "esphome/core/log.h"

-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
+namespace esphome {
+namespace mipi_spi {}  // namespace mipi_spi
+}  // namespace esphome
--- a/esphome/components/mipi_spi/mipi_spi.h
+++ b/esphome/components/mipi_spi/mipi_spi.h
@@ -63,11 +63,6 @@ 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.
@@ -206,9 +201,37 @@ class MipiSpi : public display::Display,
  }

  void dump_config() override {
-    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);
+    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);
  }

 protected:
--- a/esphome/components/mqtt/mqtt_client.cpp
+++ b/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) {
-  std::string message = json::build_json(f);
-  return this->publish(topic, message.c_str(), message.length(), qos, retain);
+  auto message = json::build_json(f);
+  return this->publish(topic, message.c_str(), message.size(), qos, retain);
 }

 void MQTTClientComponent::enable() {
@@ -643,34 +643,10 @@ static bool topic_match(const char *message, const char *subscription) {
 }

 void MQTTClientComponent::on_message(const std::string &topic, const std::string &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
+  for (auto &subscription : this->subscriptions_) {
+    if (topic_match(topic.c_str(), subscription.topic.c_str()))
+      subscription.callback(topic, payload);
+  }
 }

 // Setters
--- a/esphome/components/openthread/init.py
+++ b/esphome/components/openthread/init.py
@@ -4,7 +4,6 @@ from esphome.components.esp32 import (
    VARIANT_ESP32C6,
    VARIANT_ESP32H2,
    add_idf_sdkconfig_option,
-    include_builtin_idf_component,
    only_on_variant,
    require_vfs_select,
 )
@@ -173,9 +172,6 @@ FINAL_VALIDATE_SCHEMA = _final_validate


 async def to_code(config):
-    # Re-enable openthread IDF component (excluded by default)
-    include_builtin_idf_component("openthread")
-
    cg.add_define("USE_OPENTHREAD")

    # OpenThread SRP needs access to mDNS services after setup
--- a/esphome/components/pmsx003/pmsx003.cpp
+++ b/esphome/components/pmsx003/pmsx003.cpp
@@ -2,20 +2,21 @@
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"

-namespace esphome::pmsx003 {
+namespace esphome {
+namespace 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 STABILISING_MS = 30000;  // time taken for the sensor to become stable after power on in ms
+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 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
+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

 void PMSX003Component::setup() {}

@@ -41,7 +42,7 @@ void PMSX003Component::dump_config() {
  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
  LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);

-  if (this->update_interval_ <= STABILISING_MS) {
+  if (this->update_interval_ <= PMS_STABILISING_MS) {
    ESP_LOGCONFIG(TAG, "  Mode: active continuous (sensor default)");
  } else {
    ESP_LOGCONFIG(TAG, "  Mode: passive with sleep/wake cycles");
@@ -54,44 +55,44 @@ void PMSX003Component::loop() {
  const uint32_t now = App.get_loop_component_start_time();

  // Initialize sensor mode on first loop
-  if (!this->initialised_) {
-    if (this->update_interval_ > STABILISING_MS) {
+  if (this->initialised_ == 0) {
+    if (this->update_interval_ > PMS_STABILISING_MS) {
      // Long update interval: use passive mode with sleep/wake cycles
-      this->send_command_(Command::MEASUREMENT_MODE, CMD_MEASUREMENT_MODE_PASSIVE);
-      this->send_command_(Command::SLEEP_MODE, CMD_SLEEP_MODE_WAKEUP);
+      this->send_command_(PMS_CMD_MEASUREMENT_MODE, PMS_CMD_MEASUREMENT_MODE_PASSIVE);
+      this->send_command_(PMS_CMD_SLEEP_MODE, PMS_CMD_SLEEP_MODE_WAKEUP);
    } else {
      // Short/zero update interval: use active continuous mode
-      this->send_command_(Command::MEASUREMENT_MODE, CMD_MEASUREMENT_MODE_ACTIVE);
+      this->send_command_(PMS_CMD_MEASUREMENT_MODE, PMS_CMD_MEASUREMENT_MODE_ACTIVE);
    }
-    this->initialised_ = true;
+    this->initialised_ = 1;
  }

  // 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_ > STABILISING_MS) {
+  if (this->update_interval_ > PMS_STABILISING_MS) {
    switch (this->state_) {
-      case State::IDLE:
+      case PMSX003_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_ - STABILISING_MS))
+        if (now - this->last_update_ < (this->update_interval_ - PMS_STABILISING_MS))
          return;

-        this->state_ = State::STABILISING;
-        this->send_command_(Command::SLEEP_MODE, CMD_SLEEP_MODE_WAKEUP);
+        this->state_ = PMSX003_STATE_STABILISING;
+        this->send_command_(PMS_CMD_SLEEP_MODE, PMS_CMD_SLEEP_MODE_WAKEUP);
        this->fan_on_time_ = now;
        return;
-      case State::STABILISING:
+      case PMSX003_STATE_STABILISING:
        // wait for the sensor to be stable
-        if (now - this->fan_on_time_ < STABILISING_MS)
+        if (now - this->fan_on_time_ < PMS_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_(Command::MANUAL_MEASUREMENT, 0);
-        this->state_ = State::WAITING;
+        this->send_command_(PMS_CMD_MANUAL_MEASUREMENT, 0);
+        this->state_ = PMSX003_STATE_WAITING;
        break;
-      case State::WAITING:
+      case PMSX003_STATE_WAITING:
        // Just go ahead and read stuff
        break;
    }
@@ -179,31 +180,27 @@ 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 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
+    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.
      return payload_length == 28 || payload_length == 20;  // 2*13+2
-    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
+    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)
  }
  return false;
 }

-void PMSX003Component::send_command_(Command cmd, uint16_t data) {
+void PMSX003Component::send_command_(PMSX0003Command cmd, uint16_t data) {
  uint8_t send_data[7] = {
      START_CHARACTER_1,            // Start Byte 1
      START_CHARACTER_2,            // Start Byte 2
-      static_cast<uint8_t>(cmd),    // Command
+      cmd,                          // Command
      uint8_t((data >> 8) & 0xFF),  // Data 1
      uint8_t((data >> 0) & 0xFF),  // Data 2
      0,                            // Verify Byte 1
@@ -268,7 +265,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_ == Type::PMS5003T) {
+  if (this->type_ == PMSX003_TYPE_5003T) {
    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",
@@ -292,7 +289,7 @@ void PMSX003Component::parse_data_() {
  }

  // Formaldehyde
-  if (this->type_ == Type::PMS5003S || this->type_ == Type::PMS5003ST) {
+  if (this->type_ == PMSX003_TYPE_5003ST || this->type_ == PMSX003_TYPE_5003S) {
    const uint16_t formaldehyde = this->get_16_bit_uint_(28);

    ESP_LOGD(TAG, "Got Formaldehyde: %u µg/m^3", formaldehyde);
@@ -302,8 +299,8 @@ void PMSX003Component::parse_data_() {
  }

  // Temperature and Humidity
-  if (this->type_ == Type::PMS5003T || this->type_ == Type::PMS5003ST) {
-    const uint8_t temperature_offset = (this->type_ == Type::PMS5003T) ? 24 : 30;
+  if (this->type_ == PMSX003_TYPE_5003ST || this->type_ == PMSX003_TYPE_5003T) {
+    const uint8_t temperature_offset = (this->type_ == PMSX003_TYPE_5003T) ? 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;
@@ -317,22 +314,22 @@ void PMSX003Component::parse_data_() {
  }

  // Firmware Version and Error Code
-  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];
+  if (this->type_ == PMSX003_TYPE_5003ST) {
+    const uint8_t firmware_version = this->data_[36];
+    const uint8_t error_code = this->data_[37];

    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_ > STABILISING_MS) {
-    this->send_command_(Command::SLEEP_MODE, CMD_SLEEP_MODE_SLEEP);
-    this->state_ = State::IDLE;
+  if (this->update_interval_ > PMS_STABILISING_MS) {
+    this->send_command_(PMS_CMD_SLEEP_MODE, PMS_CMD_SLEEP_MODE_SLEEP);
+    this->state_ = PMSX003_STATE_IDLE;
  }

  this->status_clear_warning();
 }

-}  // namespace esphome::pmsx003
+}  // namespace pmsx003
+}  // namespace esphome
--- a/esphome/components/pmsx003/pmsx003.h
+++ b/esphome/components/pmsx003/pmsx003.h
@@ -5,28 +5,27 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"

-namespace esphome::pmsx003 {
+namespace esphome {
+namespace pmsx003 {

-enum class Type : uint8_t {
-  PMS1003 = 0,
-  PMS3003,
-  PMSX003,  // PMS5003, PMS6003, PMS7003, PMSA003 (NOT PMSA003I - see `pmsa003i` component)
-  PMS5003S,
-  PMS5003T,
-  PMS5003ST,
-  PMS9003M,
+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 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 PMSX003Type {
+  PMSX003_TYPE_X003 = 0,
+  PMSX003_TYPE_5003T,
+  PMSX003_TYPE_5003ST,
+  PMSX003_TYPE_5003S,
 };

-enum class State : uint8_t {
-  IDLE = 0,
-  STABILISING,
-  WAITING,
+enum PMSX003State {
+  PMSX003_STATE_IDLE = 0,
+  PMSX003_STATE_STABILISING,
+  PMSX003_STATE_WAITING,
 };

 class PMSX003Component : public uart::UARTDevice, public Component {
@@ -38,7 +37,7 @@ class PMSX003Component : public uart::UARTDevice, public Component {

  void set_update_interval(uint32_t update_interval) { this->update_interval_ = update_interval; }

-  void set_type(Type type) { this->type_ = type; }
+  void set_type(PMSX003Type 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; }
@@ -78,20 +77,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_(Command cmd, uint16_t data);
+  void send_command_(PMSX0003Command 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};
@@ -119,4 +118,5 @@ class PMSX003Component : public uart::UARTDevice, public Component {
  sensor::Sensor *humidity_sensor_{nullptr};
 };

-}  // namespace esphome::pmsx003
+}  // namespace pmsx003
+}  // namespace esphome
--- a/esphome/components/pmsx003/sensor.py
+++ b/esphome/components/pmsx003/sensor.py
@@ -40,128 +40,34 @@ pmsx003_ns = cg.esphome_ns.namespace("pmsx003")
 PMSX003Component = pmsx003_ns.class_("PMSX003Component", uart.UARTDevice, cg.Component)
 PMSX003Sensor = pmsx003_ns.class_("PMSX003Sensor", sensor.Sensor)

-TYPE_PMS1003 = "PMS1003"
-TYPE_PMS3003 = "PMS3003"
-TYPE_PMSX003 = "PMSX003"  # PMS5003, PMS6003, PMS7003, PMSA003 (NOT PMSA003I - see `pmsa003i` component)
-TYPE_PMS5003S = "PMS5003S"
+TYPE_PMSX003 = "PMSX003"
 TYPE_PMS5003T = "PMS5003T"
 TYPE_PMS5003ST = "PMS5003ST"
-TYPE_PMS9003M = "PMS9003M"
+TYPE_PMS5003S = "PMS5003S"

-Type = pmsx003_ns.enum("Type", is_class=True)
+PMSX003Type = pmsx003_ns.enum("PMSX003Type")

 PMSX003_TYPES = {
-    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,
+    TYPE_PMSX003: PMSX003Type.PMSX003_TYPE_X003,
+    TYPE_PMS5003T: PMSX003Type.PMSX003_TYPE_5003T,
+    TYPE_PMS5003ST: PMSX003Type.PMSX003_TYPE_5003ST,
+    TYPE_PMS5003S: PMSX003Type.PMSX003_TYPE_5003S,
 }

 SENSORS_TO_TYPE = {
-    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_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_TEMPERATURE: [TYPE_PMS5003T, TYPE_PMS5003ST],
    CONF_HUMIDITY: [TYPE_PMS5003T, TYPE_PMS5003ST],
 }
--- a/esphome/components/udp/init.py
+++ b/esphome/components/udp/init.py
@@ -12,8 +12,8 @@ from esphome.components.packet_transport import (
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_PORT, CONF_TRIGGER_ID
-from esphome.core import ID
-from esphome.cpp_generator import literal
+from esphome.core import ID, Lambda
+from esphome.cpp_generator import ExpressionStatement, MockObj

 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
@@ -24,8 +24,6 @@ udp_ns = cg.esphome_ns.namespace("udp")
 UDPComponent = udp_ns.class_("UDPComponent", cg.Component)
 UDPWriteAction = udp_ns.class_("UDPWriteAction", automation.Action)
 trigger_args = cg.std_vector.template(cg.uint8)
-trigger_argname = "data"
-trigger_argtype = [(trigger_args, trigger_argname)]

 CONF_ADDRESSES = "addresses"
 CONF_LISTEN_ADDRESS = "listen_address"
@@ -113,14 +111,13 @@ async def to_code(config):
    cg.add(var.set_addresses([str(addr) for addr in config[CONF_ADDRESSES]]))
    if on_receive := config.get(CONF_ON_RECEIVE):
        on_receive = on_receive[0]
-        trigger_id = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
+        trigger = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
        trigger = await automation.build_automation(
-            trigger_id, trigger_argtype, on_receive
+            trigger, [(trigger_args, "data")], on_receive
        )
-        trigger_lambda = await cg.process_lambda(
-            trigger.trigger(literal(trigger_argname)), trigger_argtype
-        )
-        cg.add(var.add_listener(trigger_lambda))
+        trigger = Lambda(str(ExpressionStatement(trigger.trigger(MockObj("data")))))
+        trigger = await cg.process_lambda(trigger, [(trigger_args, "data")])
+        cg.add(var.add_listener(trigger))
        cg.add(var.set_should_listen())


--- a/esphome/components/web_server/web_server.cpp
+++ b/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();
-    std::string message = de.message_generator_(web_server_, de.source_);
+    auto 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 {
-    std::string message = message_generator(web_server_, source);
+    auto 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
-    std::string message = ws->get_config_json();
+    auto 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;
-      message = builder.serialize();
+      auto group_msg = builder.serialize();

      // up to 31 groups should be able to be queued initially without defer
-      source->try_send_nodefer(message.c_str(), "sorting_group");
+      source->try_send_nodefer(group_msg.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

-std::string WebServer::get_config_json() {
+json::SerializationBuffer<> 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);
-      std::string data = this->sensor_json_(obj, obj->state, detail);
+      auto data = this->sensor_json_(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
  }
  request->send(404);
 }
-std::string WebServer::sensor_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::sensor_state_json_generator(WebServer *web_server, void *source) {
  return web_server->sensor_json_((sensor::Sensor *) (source), ((sensor::Sensor *) (source))->state, DETAIL_STATE);
 }
-std::string WebServer::sensor_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::sensor_all_json_generator(WebServer *web_server, void *source) {
  return web_server->sensor_json_((sensor::Sensor *) (source), ((sensor::Sensor *) (source))->state, DETAIL_ALL);
 }
-std::string WebServer::sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config) {
+json::SerializationBuffer<> 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);
-      std::string data = this->text_sensor_json_(obj, obj->state, detail);
+      auto data = this->text_sensor_json_(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
  }
  request->send(404);
 }
-std::string WebServer::text_sensor_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::text_sensor_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value,
-                                         JsonDetail start_config) {
+json::SerializationBuffer<> 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);
-      std::string data = this->switch_json_(obj, obj->state, detail);
+      auto 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);
 }
-std::string WebServer::switch_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::switch_state_json_generator(WebServer *web_server, void *source) {
  return web_server->switch_json_((switch_::Switch *) (source), ((switch_::Switch *) (source))->state, DETAIL_STATE);
 }
-std::string WebServer::switch_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::switch_all_json_generator(WebServer *web_server, void *source) {
  return web_server->switch_json_((switch_::Switch *) (source), ((switch_::Switch *) (source))->state, DETAIL_ALL);
 }
-std::string WebServer::switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config) {
+json::SerializationBuffer<> 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);
-      std::string data = this->button_json_(obj, detail);
+      auto 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);
 }
-std::string WebServer::button_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::button_all_json_generator(WebServer *web_server, void *source) {
  return web_server->button_json_((button::Button *) (source), DETAIL_ALL);
 }
-std::string WebServer::button_json_(button::Button *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::button_json_(button::Button *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -805,22 +805,23 @@ 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);
-      std::string data = this->binary_sensor_json_(obj, obj->state, detail);
+      auto data = this->binary_sensor_json_(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
  }
  request->send(404);
 }
-std::string WebServer::binary_sensor_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::binary_sensor_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value,
+                                                           JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -847,7 +848,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);
-      std::string data = this->fan_json_(obj, detail);
+      auto 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());
@@ -888,13 +889,13 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
  }
  request->send(404);
 }
-std::string WebServer::fan_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::fan_state_json_generator(WebServer *web_server, void *source) {
  return web_server->fan_json_((fan::Fan *) (source), DETAIL_STATE);
 }
-std::string WebServer::fan_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::fan_all_json_generator(WebServer *web_server, void *source) {
  return web_server->fan_json_((fan::Fan *) (source), DETAIL_ALL);
 }
-std::string WebServer::fan_json_(fan::Fan *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::fan_json_(fan::Fan *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -928,7 +929,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);
-      std::string data = this->light_json_(obj, detail);
+      auto 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());
@@ -967,13 +968,13 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
  }
  request->send(404);
 }
-std::string WebServer::light_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::light_state_json_generator(WebServer *web_server, void *source) {
  return web_server->light_json_((light::LightState *) (source), DETAIL_STATE);
 }
-std::string WebServer::light_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::light_all_json_generator(WebServer *web_server, void *source) {
  return web_server->light_json_((light::LightState *) (source), DETAIL_ALL);
 }
-std::string WebServer::light_json_(light::LightState *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::light_json_(light::LightState *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1007,7 +1008,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);
-      std::string data = this->cover_json_(obj, detail);
+      auto data = this->cover_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1055,13 +1056,13 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
  }
  request->send(404);
 }
-std::string WebServer::cover_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::cover_state_json_generator(WebServer *web_server, void *source) {
  return web_server->cover_json_((cover::Cover *) (source), DETAIL_STATE);
 }
-std::string WebServer::cover_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::cover_all_json_generator(WebServer *web_server, void *source) {
  return web_server->cover_json_((cover::Cover *) (source), DETAIL_ALL);
 }
-std::string WebServer::cover_json_(cover::Cover *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::cover_json_(cover::Cover *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1096,7 +1097,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);
-      std::string data = this->number_json_(obj, obj->state, detail);
+      auto data = this->number_json_(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1115,13 +1116,13 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
  request->send(404);
 }

-std::string WebServer::number_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::number_state_json_generator(WebServer *web_server, void *source) {
  return web_server->number_json_((number::Number *) (source), ((number::Number *) (source))->state, DETAIL_STATE);
 }
-std::string WebServer::number_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::number_all_json_generator(WebServer *web_server, void *source) {
  return web_server->number_json_((number::Number *) (source), ((number::Number *) (source))->state, DETAIL_ALL);
 }
-std::string WebServer::number_json_(number::Number *obj, float value, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::number_json_(number::Number *obj, float value, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1163,7 +1164,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);
-      std::string data = this->date_json_(obj, detail);
+      auto data = this->date_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1188,13 +1189,13 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
  request->send(404);
 }

-std::string WebServer::date_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::date_state_json_generator(WebServer *web_server, void *source) {
  return web_server->date_json_((datetime::DateEntity *) (source), DETAIL_STATE);
 }
-std::string WebServer::date_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::date_all_json_generator(WebServer *web_server, void *source) {
  return web_server->date_json_((datetime::DateEntity *) (source), DETAIL_ALL);
 }
-std::string WebServer::date_json_(datetime::DateEntity *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::date_json_(datetime::DateEntity *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1223,7 +1224,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);
-      std::string data = this->time_json_(obj, detail);
+      auto data = this->time_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1247,13 +1248,13 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
  }
  request->send(404);
 }
-std::string WebServer::time_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::time_state_json_generator(WebServer *web_server, void *source) {
  return web_server->time_json_((datetime::TimeEntity *) (source), DETAIL_STATE);
 }
-std::string WebServer::time_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::time_all_json_generator(WebServer *web_server, void *source) {
  return web_server->time_json_((datetime::TimeEntity *) (source), DETAIL_ALL);
 }
-std::string WebServer::time_json_(datetime::TimeEntity *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::time_json_(datetime::TimeEntity *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1282,7 +1283,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);
-      std::string data = this->datetime_json_(obj, detail);
+      auto data = this->datetime_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1306,13 +1307,13 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
  }
  request->send(404);
 }
-std::string WebServer::datetime_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::datetime_state_json_generator(WebServer *web_server, void *source) {
  return web_server->datetime_json_((datetime::DateTimeEntity *) (source), DETAIL_STATE);
 }
-std::string WebServer::datetime_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::datetime_all_json_generator(WebServer *web_server, void *source) {
  return web_server->datetime_json_((datetime::DateTimeEntity *) (source), DETAIL_ALL);
 }
-std::string WebServer::datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1343,7 +1344,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);
-      std::string data = this->text_json_(obj, obj->state, detail);
+      auto data = this->text_json_(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1362,13 +1363,13 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
  request->send(404);
 }

-std::string WebServer::text_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::text_state_json_generator(WebServer *web_server, void *source) {
  return web_server->text_json_((text::Text *) (source), ((text::Text *) (source))->state, DETAIL_STATE);
 }
-std::string WebServer::text_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::text_all_json_generator(WebServer *web_server, void *source) {
  return web_server->text_json_((text::Text *) (source), ((text::Text *) (source))->state, DETAIL_ALL);
 }
-std::string WebServer::text_json_(text::Text *obj, const std::string &value, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::text_json_(text::Text *obj, const std::string &value, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1400,7 +1401,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);
-      std::string data = this->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), detail);
+      auto data = this->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1419,15 +1420,15 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
  }
  request->send(404);
 }
-std::string WebServer::select_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::select_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::select_json_(select::Select *obj, StringRef value, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::select_json_(select::Select *obj, StringRef value, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1459,7 +1460,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);
-      std::string data = this->climate_json_(obj, detail);
+      auto data = this->climate_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1488,15 +1489,15 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
  }
  request->send(404);
 }
-std::string WebServer::climate_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::climate_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::climate_json_(climate::Climate *obj, JsonDetail start_config) {
+json::SerializationBuffer<> 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();
@@ -1629,7 +1630,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);
-      std::string data = this->lock_json_(obj, obj->state, detail);
+      auto data = this->lock_json_(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1658,13 +1659,13 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
  }
  request->send(404);
 }
-std::string WebServer::lock_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::lock_state_json_generator(WebServer *web_server, void *source) {
  return web_server->lock_json_((lock::Lock *) (source), ((lock::Lock *) (source))->state, DETAIL_STATE);
 }
-std::string WebServer::lock_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::lock_all_json_generator(WebServer *web_server, void *source) {
  return web_server->lock_json_((lock::Lock *) (source), ((lock::Lock *) (source))->state, DETAIL_ALL);
 }
-std::string WebServer::lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1692,7 +1693,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);
-      std::string data = this->valve_json_(obj, detail);
+      auto data = this->valve_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1738,13 +1739,13 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
  }
  request->send(404);
 }
-std::string WebServer::valve_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::valve_state_json_generator(WebServer *web_server, void *source) {
  return web_server->valve_json_((valve::Valve *) (source), DETAIL_STATE);
 }
-std::string WebServer::valve_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::valve_all_json_generator(WebServer *web_server, void *source) {
  return web_server->valve_json_((valve::Valve *) (source), DETAIL_ALL);
 }
-std::string WebServer::valve_json_(valve::Valve *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::valve_json_(valve::Valve *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -1777,7 +1778,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);
-      std::string data = this->alarm_control_panel_json_(obj, obj->get_state(), detail);
+      auto data = this->alarm_control_panel_json_(obj, obj->get_state(), detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1817,19 +1818,19 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
  }
  request->send(404);
 }
-std::string WebServer::alarm_control_panel_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::alarm_control_panel_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
-                                                 alarm_control_panel::AlarmControlPanelState value,
-                                                 JsonDetail start_config) {
+json::SerializationBuffer<> 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();

@@ -1858,7 +1859,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);
-      std::string data = this->water_heater_json_(obj, detail);
+      auto data = this->water_heater_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -1894,14 +1895,14 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
  request->send(404);
 }

-std::string WebServer::water_heater_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::water_heater_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();
  char buf[PSTR_LOCAL_SIZE];
@@ -1964,7 +1965,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);
-      std::string data = this->infrared_json_(obj, detail);
+      auto data = this->infrared_json_(obj, detail);
      request->send(200, ESPHOME_F("application/json"), data.c_str());
      return;
    }
@@ -2035,12 +2036,12 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
  request->send(404);
 }

-std::string WebServer::infrared_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> WebServer::infrared_all_json_generator(WebServer *web_server, void *source) {
  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
  return web_server->infrared_json_(static_cast<infrared::Infrared *>(source), DETAIL_ALL);
 }

-std::string WebServer::infrared_json_(infrared::Infrared *obj, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::infrared_json_(infrared::Infrared *obj, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -2075,7 +2076,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);
-      std::string data = this->event_json_(obj, StringRef(), detail);
+      auto data = this->event_json_(obj, StringRef(), detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -2085,16 +2086,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(); }

-std::string WebServer::event_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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
-std::string WebServer::event_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config) {
+json::SerializationBuffer<> WebServer::event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config) {
  json::JsonBuilder builder;
  JsonObject root = builder.root();

@@ -2141,7 +2142,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);
-      std::string data = this->update_json_(obj, detail);
+      auto data = this->update_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
    }
@@ -2157,15 +2158,15 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
  }
  request->send(404);
 }
-std::string WebServer::update_state_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::update_all_json_generator(WebServer *web_server, void *source) {
+json::SerializationBuffer<> 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);
 }
-std::string WebServer::update_json_(update::UpdateEntity *obj, JsonDetail start_config) {
+json::SerializationBuffer<> 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();
--- a/esphome/components/web_server/web_server.h
+++ b/esphome/components/web_server/web_server.h
@@ -2,6 +2,7 @@

 #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"
@@ -104,7 +105,7 @@ enum JsonDetail { DETAIL_ALL, DETAIL_STATE };
  can be forgotten.
 */
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
-using message_generator_t = std::string(WebServer *, void *);
+using message_generator_t = json::SerializationBuffer<>(WebServer *, void *);

 class DeferredUpdateEventSourceList;
 class DeferredUpdateEventSource : public AsyncEventSource {
@@ -263,7 +264,7 @@ class WebServer : public Controller,
  void handle_index_request(AsyncWebServerRequest *request);

  /// Return the webserver configuration as JSON.
-  std::string get_config_json();
+  json::SerializationBuffer<> get_config_json();

 #ifdef USE_WEBSERVER_CSS_INCLUDE
  /// Handle included css request under '/0.css'.
@@ -285,8 +286,8 @@ class WebServer : public Controller,
  /// Handle a sensor request under '/sensor/<id>'.
  void handle_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string sensor_state_json_generator(WebServer *web_server, void *source);
-  static std::string sensor_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> sensor_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> sensor_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_SWITCH
@@ -295,8 +296,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 std::string switch_state_json_generator(WebServer *web_server, void *source);
-  static std::string switch_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> switch_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> switch_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_BUTTON
@@ -304,7 +305,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 std::string button_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> button_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_BINARY_SENSOR
@@ -313,8 +314,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 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);
+  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);
 #endif

 #ifdef USE_FAN
@@ -323,8 +324,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 std::string fan_state_json_generator(WebServer *web_server, void *source);
-  static std::string fan_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> fan_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> fan_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_LIGHT
@@ -333,8 +334,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 std::string light_state_json_generator(WebServer *web_server, void *source);
-  static std::string light_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> light_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> light_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_TEXT_SENSOR
@@ -343,8 +344,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 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);
+  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);
 #endif

 #ifdef USE_COVER
@@ -353,8 +354,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 std::string cover_state_json_generator(WebServer *web_server, void *source);
-  static std::string cover_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> cover_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> cover_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_NUMBER
@@ -362,8 +363,8 @@ class WebServer : public Controller,
  /// Handle a number request under '/number/<id>'.
  void handle_number_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string number_state_json_generator(WebServer *web_server, void *source);
-  static std::string number_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> number_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> number_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_DATETIME_DATE
@@ -371,8 +372,8 @@ class WebServer : public Controller,
  /// Handle a date request under '/date/<id>'.
  void handle_date_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string date_state_json_generator(WebServer *web_server, void *source);
-  static std::string date_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> date_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> date_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_DATETIME_TIME
@@ -380,8 +381,8 @@ class WebServer : public Controller,
  /// Handle a time request under '/time/<id>'.
  void handle_time_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string time_state_json_generator(WebServer *web_server, void *source);
-  static std::string time_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> time_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> time_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_DATETIME_DATETIME
@@ -389,8 +390,8 @@ class WebServer : public Controller,
  /// Handle a datetime request under '/datetime/<id>'.
  void handle_datetime_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string datetime_state_json_generator(WebServer *web_server, void *source);
-  static std::string datetime_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> datetime_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> datetime_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_TEXT
@@ -398,8 +399,8 @@ class WebServer : public Controller,
  /// Handle a text input request under '/text/<id>'.
  void handle_text_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string text_state_json_generator(WebServer *web_server, void *source);
-  static std::string text_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> text_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> text_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_SELECT
@@ -407,8 +408,8 @@ class WebServer : public Controller,
  /// Handle a select request under '/select/<id>'.
  void handle_select_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string select_state_json_generator(WebServer *web_server, void *source);
-  static std::string select_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> select_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> select_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_CLIMATE
@@ -416,8 +417,8 @@ class WebServer : public Controller,
  /// Handle a climate request under '/climate/<id>'.
  void handle_climate_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string climate_state_json_generator(WebServer *web_server, void *source);
-  static std::string climate_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> climate_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> climate_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_LOCK
@@ -426,8 +427,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 std::string lock_state_json_generator(WebServer *web_server, void *source);
-  static std::string lock_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> lock_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> lock_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_VALVE
@@ -436,8 +437,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 std::string valve_state_json_generator(WebServer *web_server, void *source);
-  static std::string valve_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> valve_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> valve_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_ALARM_CONTROL_PANEL
@@ -446,8 +447,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 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);
+  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);
 #endif

 #ifdef USE_WATER_HEATER
@@ -456,22 +457,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 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);
+  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);
 #endif

 #ifdef USE_INFRARED
  /// Handle an infrared request under '/infrared/<id>/transmit'.
  void handle_infrared_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string infrared_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> infrared_all_json_generator(WebServer *web_server, void *source);
 #endif

 #ifdef USE_EVENT
  void on_event(event::Event *obj) override;

-  static std::string event_state_json_generator(WebServer *web_server, void *source);
-  static std::string event_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> event_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> 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);
@@ -483,8 +484,8 @@ class WebServer : public Controller,
  /// Handle a update request under '/update/<id>'.
  void handle_update_request(AsyncWebServerRequest *request, const UrlMatch &match);

-  static std::string update_state_json_generator(WebServer *web_server, void *source);
-  static std::string update_all_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> update_state_json_generator(WebServer *web_server, void *source);
+  static json::SerializationBuffer<> update_all_json_generator(WebServer *web_server, void *source);
 #endif

  /// Override the web handler's canHandle method.
@@ -609,71 +610,74 @@ class WebServer : public Controller,

 private:
 #ifdef USE_SENSOR
-  std::string sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config);
+  json::SerializationBuffer<> sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config);
 #endif
 #ifdef USE_SWITCH
-  std::string switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config);
+  json::SerializationBuffer<> switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config);
 #endif
 #ifdef USE_BUTTON
-  std::string button_json_(button::Button *obj, JsonDetail start_config);
+  json::SerializationBuffer<> button_json_(button::Button *obj, JsonDetail start_config);
 #endif
 #ifdef USE_BINARY_SENSOR
-  std::string binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value, JsonDetail start_config);
+  json::SerializationBuffer<> binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value,
+                                                  JsonDetail start_config);
 #endif
 #ifdef USE_FAN
-  std::string fan_json_(fan::Fan *obj, JsonDetail start_config);
+  json::SerializationBuffer<> fan_json_(fan::Fan *obj, JsonDetail start_config);
 #endif
 #ifdef USE_LIGHT
-  std::string light_json_(light::LightState *obj, JsonDetail start_config);
+  json::SerializationBuffer<> light_json_(light::LightState *obj, JsonDetail start_config);
 #endif
 #ifdef USE_TEXT_SENSOR
-  std::string text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value, JsonDetail start_config);
+  json::SerializationBuffer<> text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value,
+                                                JsonDetail start_config);
 #endif
 #ifdef USE_COVER
-  std::string cover_json_(cover::Cover *obj, JsonDetail start_config);
+  json::SerializationBuffer<> cover_json_(cover::Cover *obj, JsonDetail start_config);
 #endif
 #ifdef USE_NUMBER
-  std::string number_json_(number::Number *obj, float value, JsonDetail start_config);
+  json::SerializationBuffer<> number_json_(number::Number *obj, float value, JsonDetail start_config);
 #endif
 #ifdef USE_DATETIME_DATE
-  std::string date_json_(datetime::DateEntity *obj, JsonDetail start_config);
+  json::SerializationBuffer<> date_json_(datetime::DateEntity *obj, JsonDetail start_config);
 #endif
 #ifdef USE_DATETIME_TIME
-  std::string time_json_(datetime::TimeEntity *obj, JsonDetail start_config);
+  json::SerializationBuffer<> time_json_(datetime::TimeEntity *obj, JsonDetail start_config);
 #endif
 #ifdef USE_DATETIME_DATETIME
-  std::string datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config);
+  json::SerializationBuffer<> datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config);
 #endif
 #ifdef USE_TEXT
-  std::string text_json_(text::Text *obj, const std::string &value, JsonDetail start_config);
+  json::SerializationBuffer<> text_json_(text::Text *obj, const std::string &value, JsonDetail start_config);
 #endif
 #ifdef USE_SELECT
-  std::string select_json_(select::Select *obj, StringRef value, JsonDetail start_config);
+  json::SerializationBuffer<> select_json_(select::Select *obj, StringRef value, JsonDetail start_config);
 #endif
 #ifdef USE_CLIMATE
-  std::string climate_json_(climate::Climate *obj, JsonDetail start_config);
+  json::SerializationBuffer<> climate_json_(climate::Climate *obj, JsonDetail start_config);
 #endif
 #ifdef USE_LOCK
-  std::string lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config);
+  json::SerializationBuffer<> lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config);
 #endif
 #ifdef USE_VALVE
-  std::string valve_json_(valve::Valve *obj, JsonDetail start_config);
+  json::SerializationBuffer<> valve_json_(valve::Valve *obj, JsonDetail start_config);
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
-  std::string alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
-                                        alarm_control_panel::AlarmControlPanelState value, JsonDetail start_config);
+  json::SerializationBuffer<> alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
+                                                        alarm_control_panel::AlarmControlPanelState value,
+                                                        JsonDetail start_config);
 #endif
 #ifdef USE_EVENT
-  std::string event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config);
+  json::SerializationBuffer<> event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config);
 #endif
 #ifdef USE_WATER_HEATER
-  std::string water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config);
+  json::SerializationBuffer<> water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config);
 #endif
 #ifdef USE_INFRARED
-  std::string infrared_json_(infrared::Infrared *obj, JsonDetail start_config);
+  json::SerializationBuffer<> infrared_json_(infrared::Infrared *obj, JsonDetail start_config);
 #endif
 #ifdef USE_UPDATE
-  std::string update_json_(update::UpdateEntity *obj, JsonDetail start_config);
+  json::SerializationBuffer<> update_json_(update::UpdateEntity *obj, JsonDetail start_config);
 #endif
 };

--- a/esphome/components/web_server_base/init.py
+++ b/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.6")
+        cg.add_library("ESP32Async/ESPAsyncWebServer", "3.9.5")
--- a/esphome/components/web_server_idf/web_server_idf.cpp
+++ b/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
-  std::string message = ws->get_config_json();
+  auto 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();
-    std::string message = de.message_generator_(web_server_, de.source_);
+    auto 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 {
-    std::string message = message_generator(web_server_, source);
+    auto message = message_generator(web_server_, source);
    if (!this->try_send_nodefer(message.c_str(), "state")) {
      deq_push_back_with_dedup_(source, message_generator);
    }
--- a/esphome/components/web_server_idf/web_server_idf.h
+++ b/esphome/components/web_server_idf/web_server_idf.h
@@ -16,6 +16,7 @@
 #include <vector>

 #ifdef USE_WEBSERVER
+#include "esphome/components/json/json_util.h"
 #include "esphome/components/web_server/list_entities.h"
 #endif

@@ -250,7 +251,7 @@ class AsyncWebHandler {
 class AsyncEventSource;
 class AsyncEventSourceResponse;

-using message_generator_t = std::string(esphome::web_server::WebServer *, void *);
+using message_generator_t = json::SerializationBuffer<>(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
--- a/esphome/core/init.py
+++ b/esphome/core/init.py
@@ -278,13 +278,9 @@ LAMBDA_PROG = re.compile(r"\bid\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)(\.?)")

 class Lambda:
    def __init__(self, value):
-        from esphome.cpp_generator import Expression, statement
-
        # pylint: disable=protected-access
        if isinstance(value, Lambda):
            self._value = value._value
-        elif isinstance(value, Expression):
-            self._value = str(statement(value))
        else:
            self._value = value
        self._parts = None
--- a/esphome/core/application.cpp
+++ b/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 rev%d.%d, %d core(s)", ESPHOME_VARIANT, chip_info.revision / 100,
+      ESP_LOGI(TAG, "ESP32 Chip: %s r%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
--- a/esphome/cpp_generator.py
+++ b/esphome/cpp_generator.py
@@ -462,16 +462,6 @@ def statement(expression: Expression | Statement) -> Statement:
    return ExpressionStatement(expression)


-def literal(name: str) -> "MockObj":
-    """Create a literal name that will appear in the generated code
-    not surrounded by quotes.
-
-    :param name: The name of the literal.
-    :return: The literal as a MockObj.
-    """
-    return MockObj(name, "")
-
-
 def variable(
    id_: ID, rhs: SafeExpType, type_: "MockObj" = None, register=True
 ) -> "MockObj":
@@ -675,7 +665,7 @@ async def get_variable_with_full_id(id_: ID) -> tuple[ID, "MockObj"]:


 async def process_lambda(
-    value: Lambda | Expression,
+    value: Lambda,
    parameters: TemplateArgsType,
    capture: str = "",
    return_type: SafeExpType = None,
@@ -699,14 +689,6 @@ async def process_lambda(

    if value is None:
        return None
-    # Inadvertently passing a malformed parameters value will lead to the build process mysteriously hanging at the
-    # "Generating C++ source..." stage, so check here to save the developer's hair.
-    assert isinstance(parameters, list) and all(
-        isinstance(p, tuple) and len(p) == 2 for p in parameters
-    )
-    if isinstance(value, Expression):
-        value = Lambda(value)
-
    parts = value.parts[:]
    for i, id in enumerate(value.requires_ids):
        full_id, var = await get_variable_with_full_id(id)
--- a/platformio.ini
+++ b/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.6    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.9.5    ; 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.6    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.9.5    ; 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.6    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
    droscy/esp_wireguard@0.4.2            ; wireguard
 build_flags =
    ${common:arduino.build_flags}
--- a/tests/components/json/common.yaml
+++ b/tests/components/json/common.yaml
@@ -4,15 +4,16 @@ interval:
  - interval: 60s
    then:
      - lambda: |-
-          // Test build_json
-          std::string json_str = esphome::json::build_json([](JsonObject root) {
+          // Test build_json - returns SerializationBuffer, use auto to avoid heap allocation
+          auto json_buf = esphome::json::build_json([](JsonObject root) {
            root["sensor"] = "temperature";
            root["value"] = 23.5;
            root["unit"] = "°C";
          });
-          ESP_LOGD("test", "Built JSON: %s", json_str.c_str());
+          ESP_LOGD("test", "Built JSON: %s", json_buf.c_str());

-          // Test parse_json
+          // Test parse_json - implicit conversion to std::string for backward compatibility
+          std::string json_str = json_buf;
          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"];
@@ -26,10 +27,10 @@ interval:
          });
          ESP_LOGD("test", "Parse result (JSON syntax only): %s", parse_ok ? "success" : "failed");

-          // Test JsonBuilder class
+          // Test JsonBuilder class - returns SerializationBuffer
          esphome::json::JsonBuilder builder;
          JsonObject obj = builder.root();
          obj["test"] = "direct_builder";
          obj["count"] = 42;
-          std::string result = builder.serialize();
+          auto result = builder.serialize();
          ESP_LOGD("test", "JsonBuilder result: %s", result.c_str());
--- a/tests/components/mipi_spi/test.esp8266-ard.yaml
+++ b/tests/components/mipi_spi/test.esp8266-ard.yaml
@@ -1,10 +0,0 @@
-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
--- a/tests/components/pmsx003/common.yaml
+++ b/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 Atmospheric Concentration
+      name: PM 1.0 Standard Atmospher Concentration
    pm_2_5_std:
-      name: PM 2.5 Standard Atmospheric Concentration
+      name: PM 2.5 Standard Atmospher Concentration
    pm_10_0_std:
-      name: PM 10.0 Standard Atmospheric Concentration
+      name: PM 10.0 Standard Atmospher Concentration
    pm_0_3um:
      name: Particulate Count >0.3um
    pm_0_5um:
--- a/tests/unit_tests/test_cpp_generator.py
+++ b/tests/unit_tests/test_cpp_generator.py
@@ -347,280 +347,3 @@ class TestMockObj:
        assert isinstance(actual, cg.MockObj)
        assert actual.base == "foo.eek"
        assert actual.op == "."
-
-
-class TestStatementFunction:
-    """Tests for the statement() function."""
-
-    def test_statement__expression_converted_to_statement(self):
-        """Test that expressions are converted to ExpressionStatement."""
-        expr = cg.RawExpression("foo()")
-        result = cg.statement(expr)
-
-        assert isinstance(result, cg.ExpressionStatement)
-        assert str(result) == "foo();"
-
-    def test_statement__statement_unchanged(self):
-        """Test that statements are returned unchanged."""
-        stmt = cg.RawStatement("foo()")
-        result = cg.statement(stmt)
-
-        assert result is stmt
-        assert str(result) == "foo()"
-
-    def test_statement__expression_statement_unchanged(self):
-        """Test that ExpressionStatement is returned unchanged."""
-        stmt = cg.ExpressionStatement(42)
-        result = cg.statement(stmt)
-
-        assert result is stmt
-        assert str(result) == "42;"
-
-    def test_statement__line_comment_unchanged(self):
-        """Test that LineComment is returned unchanged."""
-        stmt = cg.LineComment("This is a comment")
-        result = cg.statement(stmt)
-
-        assert result is stmt
-        assert str(result) == "// This is a comment"
-
-
-class TestLiteralFunction:
-    """Tests for the literal() function."""
-
-    def test_literal__creates_mockobj(self):
-        """Test that literal() creates a MockObj."""
-        result = cg.literal("MY_CONSTANT")
-
-        assert isinstance(result, cg.MockObj)
-        assert result.base == "MY_CONSTANT"
-        assert result.op == ""
-
-    def test_literal__string_representation(self):
-        """Test that literal names appear unquoted in generated code."""
-        result = cg.literal("nullptr")
-
-        assert str(result) == "nullptr"
-
-    def test_literal__can_be_used_in_expressions(self):
-        """Test that literals can be used as part of larger expressions."""
-        null_lit = cg.literal("nullptr")
-        expr = cg.CallExpression(cg.RawExpression("my_func"), null_lit)
-
-        assert str(expr) == "my_func(nullptr)"
-
-    def test_literal__common_cpp_literals(self):
-        """Test common C++ literal values."""
-        test_cases = [
-            ("nullptr", "nullptr"),
-            ("true", "true"),
-            ("false", "false"),
-            ("NULL", "NULL"),
-            ("NAN", "NAN"),
-        ]
-
-        for name, expected in test_cases:
-            result = cg.literal(name)
-            assert str(result) == expected
-
-
-class TestLambdaConstructor:
-    """Tests for the Lambda class constructor in core/__init__.py."""
-
-    def test_lambda__from_string(self):
-        """Test Lambda constructor with string argument."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x + 1;")
-
-        assert lambda_obj.value == "return x + 1;"
-        assert str(lambda_obj) == "return x + 1;"
-
-    def test_lambda__from_expression(self):
-        """Test Lambda constructor with Expression argument."""
-        from esphome.core import Lambda
-
-        expr = cg.RawExpression("x + 1")
-        lambda_obj = Lambda(expr)
-
-        # Expression should be converted to statement (with semicolon)
-        assert lambda_obj.value == "x + 1;"
-
-    def test_lambda__from_lambda(self):
-        """Test Lambda constructor with another Lambda argument."""
-        from esphome.core import Lambda
-
-        original = Lambda("return x + 1;")
-        copy = Lambda(original)
-
-        assert copy.value == original.value
-        assert copy.value == "return x + 1;"
-
-    def test_lambda__parts_parsing(self):
-        """Test that Lambda correctly parses parts with id() references."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return id(my_sensor).state;")
-        parts = lambda_obj.parts
-
-        # Parts should be split by LAMBDA_PROG regex: text, id, op, text
-        assert len(parts) == 4
-        assert parts[0] == "return "
-        assert parts[1] == "my_sensor"
-        assert parts[2] == "."
-        assert parts[3] == "state;"
-
-    def test_lambda__requires_ids(self):
-        """Test that Lambda correctly extracts required IDs."""
-        from esphome.core import ID, Lambda
-
-        lambda_obj = Lambda("return id(sensor1).state + id(sensor2).value;")
-        ids = lambda_obj.requires_ids
-
-        assert len(ids) == 2
-        assert all(isinstance(id_obj, ID) for id_obj in ids)
-        assert ids[0].id == "sensor1"
-        assert ids[1].id == "sensor2"
-
-    def test_lambda__no_ids(self):
-        """Test Lambda with no id() references."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return 42;")
-        ids = lambda_obj.requires_ids
-
-        assert len(ids) == 0
-
-    def test_lambda__comment_removal(self):
-        """Test that comments are removed when parsing parts."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return id(sensor).state; // Get sensor state")
-        parts = lambda_obj.parts
-
-        # Comment should be replaced with space, not affect parsing
-        assert "my_sensor" not in str(parts)
-
-    def test_lambda__multiline_string(self):
-        """Test Lambda with multiline string."""
-        from esphome.core import Lambda
-
-        code = """if (id(sensor).state > 0) {
-  return true;
-}
-return false;"""
-        lambda_obj = Lambda(code)
-
-        assert lambda_obj.value == code
-        assert "sensor" in [id_obj.id for id_obj in lambda_obj.requires_ids]
-
-
-@pytest.mark.asyncio
-class TestProcessLambda:
-    """Tests for the process_lambda() async function."""
-
-    async def test_process_lambda__none_value(self):
-        """Test that None returns None."""
-        result = await cg.process_lambda(None, [])
-
-        assert result is None
-
-    async def test_process_lambda__with_expression(self):
-        """Test process_lambda with Expression argument."""
-
-        expr = cg.RawExpression("return x + 1")
-        result = await cg.process_lambda(expr, [(int, "x")])
-
-        assert isinstance(result, cg.LambdaExpression)
-        assert "x + 1" in str(result)
-
-    async def test_process_lambda__simple_lambda_no_ids(self):
-        """Test process_lambda with simple Lambda without id() references."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x + 1;")
-        result = await cg.process_lambda(lambda_obj, [(int, "x")])
-
-        assert isinstance(result, cg.LambdaExpression)
-        # Should have parameter
-        lambda_str = str(result)
-        assert "int32_t x" in lambda_str
-        assert "return x + 1;" in lambda_str
-
-    async def test_process_lambda__with_return_type(self):
-        """Test process_lambda with return type specified."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x > 0;")
-        result = await cg.process_lambda(lambda_obj, [(int, "x")], return_type=bool)
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        assert "-> bool" in lambda_str
-
-    async def test_process_lambda__with_capture(self):
-        """Test process_lambda with capture specified."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return captured + x;")
-        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="captured")
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        assert "[captured]" in lambda_str
-
-    async def test_process_lambda__empty_capture(self):
-        """Test process_lambda with empty capture (stateless lambda)."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x + 1;")
-        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="")
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        assert "[]" in lambda_str
-
-    async def test_process_lambda__no_parameters(self):
-        """Test process_lambda with no parameters."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return 42;")
-        result = await cg.process_lambda(lambda_obj, [])
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        # Should have empty parameter list
-        assert "()" in lambda_str
-
-    async def test_process_lambda__multiple_parameters(self):
-        """Test process_lambda with multiple parameters."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x + y + z;")
-        result = await cg.process_lambda(
-            lambda_obj, [(int, "x"), (float, "y"), (bool, "z")]
-        )
-
-        assert isinstance(result, cg.LambdaExpression)
-        lambda_str = str(result)
-        assert "int32_t x" in lambda_str
-        assert "float y" in lambda_str
-        assert "bool z" in lambda_str
-
-    async def test_process_lambda__parameter_validation(self):
-        """Test that malformed parameters raise assertion error."""
-        from esphome.core import Lambda
-
-        lambda_obj = Lambda("return x;")
-
-        # Test invalid parameter format (not list of tuples)
-        with pytest.raises(AssertionError):
-            await cg.process_lambda(lambda_obj, "invalid")
-
-        # Test invalid tuple format (not 2-element tuples)
-        with pytest.raises(AssertionError):
-            await cg.process_lambda(lambda_obj, [(int, "x", "extra")])
-
-        # Test invalid tuple format (single element)
-        with pytest.raises(AssertionError):
-            await cg.process_lambda(lambda_obj, [(int,)])
Author	SHA1	Message	Date
J. Nick Koston	840ad30880	Merge branch 'dev' into json_web_server_stack	2026-01-29 14:48:48 -10:00
J. Nick Koston	cfe121b38b	private implementation details	2026-01-29 18:45:18 -06:00
J. Nick Koston	5fbd9d5b14	avoid misuse	2026-01-29 18:23:25 -06:00
J. Nick Koston	2b1783ce61	tweak	2026-01-29 18:19:29 -06:00
J. Nick Koston	904072ce79	make sure NRVO works	2026-01-29 18:17:34 -06:00
J. Nick Koston	0a4b98d74a	fix double templates	2026-01-29 17:43:26 -06:00
J. Nick Koston	b8017de724	avoid regressing performance of mqtt	2026-01-29 16:55:20 -06:00
J. Nick Koston	ca96604582	change all the cases	2026-01-29 16:49:28 -06:00
J. Nick Koston	d18d378f06	missed a few	2026-01-29 16:27:28 -06:00
J. Nick Koston	83e3752544	missed a few	2026-01-29 16:26:50 -06:00
J. Nick Koston	0490b2d450	no dummy	2026-01-29 16:24:30 -06:00
J. Nick Koston	55ff740e4e	no dummy	2026-01-29 16:23:41 -06:00
J. Nick Koston	aba8a83cba	ard as well	2026-01-29 16:02:32 -06:00
J. Nick Koston	a23809d5db	fixes	2026-01-29 15:41:29 -06:00
J. Nick Koston	32fc3ea6f5	config stack	2026-01-29 15:33:24 -06:00
J. Nick Koston	deb8ffd348	json webserver stack	2026-01-29 15:26:37 -06:00