Merge branch 'dev' into sha256_ota

2025-10-30 14:43:51 +00:00 · 2025-09-21 15:37:11 -06:00
parent 0d67d2de60 30bb640c89
commit 67e847773d
30 changed files with 1799 additions and 386 deletions
--- a/esphome/main.py
+++ b/esphome/main.py
@@ -772,7 +772,7 @@ def command_update_all(args: ArgsProtocol) -> int | None:
        safe_print(f"{half_line}{middle_text}{half_line}")

    for f in files:
-        safe_print(f"Updating {color(AnsiFore.CYAN, f)}")
+        safe_print(f"Updating {color(AnsiFore.CYAN, str(f))}")
        safe_print("-" * twidth)
        safe_print()
        if CORE.dashboard:
@@ -784,10 +784,10 @@ def command_update_all(args: ArgsProtocol) -> int | None:
                "esphome", "run", f, "--no-logs", "--device", "OTA"
            )
        if rc == 0:
-            print_bar(f"[{color(AnsiFore.BOLD_GREEN, 'SUCCESS')}] {f}")
+            print_bar(f"[{color(AnsiFore.BOLD_GREEN, 'SUCCESS')}] {str(f)}")
            success[f] = True
        else:
-            print_bar(f"[{color(AnsiFore.BOLD_RED, 'ERROR')}] {f}")
+            print_bar(f"[{color(AnsiFore.BOLD_RED, 'ERROR')}] {str(f)}")
            success[f] = False

        safe_print()
@@ -798,9 +798,9 @@ def command_update_all(args: ArgsProtocol) -> int | None:
    failed = 0
    for f in files:
        if success[f]:
-            safe_print(f"  - {f}: {color(AnsiFore.GREEN, 'SUCCESS')}")
+            safe_print(f"  - {str(f)}: {color(AnsiFore.GREEN, 'SUCCESS')}")
        else:
-            safe_print(f"  - {f}: {color(AnsiFore.BOLD_RED, 'FAILED')}")
+            safe_print(f"  - {str(f)}: {color(AnsiFore.BOLD_RED, 'FAILED')}")
            failed += 1
    return failed

@@ -1273,7 +1273,12 @@ def run_esphome(argv):
        CORE.config_path = conf_path
        CORE.dashboard = args.dashboard

-        config = read_config(dict(args.substitution) if args.substitution else {})
+        # For logs command, skip updating external components
+        skip_external = args.command == "logs"
+        config = read_config(
+            dict(args.substitution) if args.substitution else {},
+            skip_external_update=skip_external,
+        )
        if config is None:
            return 2
        CORE.config = config
--- a/esphome/components/esp32_improv/esp32_improv_component.cpp
+++ b/esphome/components/esp32_improv/esp32_improv_component.cpp
@@ -31,6 +31,9 @@ void ESP32ImprovComponent::setup() {
 #endif
  global_ble_server->on(BLEServerEvt::EmptyEvt::ON_DISCONNECT,
                        [this](uint16_t conn_id) { this->set_error_(improv::ERROR_NONE); });
+
+  // Start with loop disabled - will be enabled by start() when needed
+  this->disable_loop();
 }

 void ESP32ImprovComponent::setup_characteristics() {
--- a/esphome/components/external_components/init.py
+++ b/esphome/components/external_components/init.py
@@ -39,11 +39,13 @@ async def to_code(config):
    pass


-def _process_git_config(config: dict, refresh) -> str:
+def _process_git_config(config: dict, refresh, skip_update: bool = False) -> str:
+    # When skip_update is True, use NEVER_REFRESH to prevent updates
+    actual_refresh = git.NEVER_REFRESH if skip_update else refresh
    repo_dir, _ = git.clone_or_update(
        url=config[CONF_URL],
        ref=config.get(CONF_REF),
-        refresh=refresh,
+        refresh=actual_refresh,
        domain=DOMAIN,
        username=config.get(CONF_USERNAME),
        password=config.get(CONF_PASSWORD),
@@ -70,12 +72,12 @@ def _process_git_config(config: dict, refresh) -> str:
    return components_dir


-def _process_single_config(config: dict):
+def _process_single_config(config: dict, skip_update: bool = False):
    conf = config[CONF_SOURCE]
    if conf[CONF_TYPE] == TYPE_GIT:
        with cv.prepend_path([CONF_SOURCE]):
            components_dir = _process_git_config(
-                config[CONF_SOURCE], config[CONF_REFRESH]
+                config[CONF_SOURCE], config[CONF_REFRESH], skip_update
            )
    elif conf[CONF_TYPE] == TYPE_LOCAL:
        components_dir = Path(CORE.relative_config_path(conf[CONF_PATH]))
@@ -105,7 +107,7 @@ def _process_single_config(config: dict):
    loader.install_meta_finder(components_dir, allowed_components=allowed_components)


-def do_external_components_pass(config: dict) -> None:
+def do_external_components_pass(config: dict, skip_update: bool = False) -> None:
    conf = config.get(DOMAIN)
    if conf is None:
        return
@@ -113,4 +115,4 @@ def do_external_components_pass(config: dict) -> None:
        conf = CONFIG_SCHEMA(conf)
        for i, c in enumerate(conf):
            with cv.prepend_path(i):
-                _process_single_config(c)
+                _process_single_config(c, skip_update)
--- a/esphome/components/json/json_util.cpp
+++ b/esphome/components/json/json_util.cpp
@@ -8,52 +8,12 @@ namespace json {

 static const char *const TAG = "json";

-#ifdef USE_PSRAM
-// Build an allocator for the JSON Library using the RAMAllocator class
-// This is only compiled when PSRAM is enabled
-struct SpiRamAllocator : ArduinoJson::Allocator {
-  void *allocate(size_t size) override { return this->allocator_.allocate(size); }
-
-  void deallocate(void *pointer) override {
-    // ArduinoJson's Allocator interface doesn't provide the size parameter in deallocate.
-    // RAMAllocator::deallocate() requires the size, which we don't have access to here.
-    // RAMAllocator::deallocate implementation just calls free() regardless of whether
-    // the memory was allocated with heap_caps_malloc or malloc.
-    // This is safe because ESP-IDF's heap implementation internally tracks the memory region
-    // and routes free() to the appropriate heap.
-    free(pointer);  // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
-  }
-
-  void *reallocate(void *ptr, size_t new_size) override {
-    return this->allocator_.reallocate(static_cast<uint8_t *>(ptr), new_size);
-  }
-
- protected:
-  RAMAllocator<uint8_t> allocator_{RAMAllocator<uint8_t>(RAMAllocator<uint8_t>::NONE)};
-};
-#endif
-
 std::string build_json(const json_build_t &f) {
  // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-#ifdef USE_PSRAM
-  auto doc_allocator = SpiRamAllocator();
-  JsonDocument json_document(&doc_allocator);
-#else
-  JsonDocument json_document;
-#endif
-  if (json_document.overflowed()) {
-    ESP_LOGE(TAG, "Could not allocate memory for JSON document!");
-    return "{}";
-  }
-  JsonObject root = json_document.to<JsonObject>();
+  JsonBuilder builder;
+  JsonObject root = builder.root();
  f(root);
-  if (json_document.overflowed()) {
-    ESP_LOGE(TAG, "Could not allocate memory for JSON document!");
-    return "{}";
-  }
-  std::string output;
-  serializeJson(json_document, output);
-  return output;
+  return builder.serialize();
  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }

@@ -84,5 +44,15 @@ bool parse_json(const std::string &data, const json_parse_t &f) {
  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }

+std::string JsonBuilder::serialize() {
+  if (doc_.overflowed()) {
+    ESP_LOGE(TAG, "JSON document overflow");
+    return "{}";
+  }
+  std::string output;
+  serializeJson(doc_, output);
+  return output;
+}
+
 }  // namespace json
 }  // namespace esphome
--- a/esphome/components/json/json_util.h
+++ b/esphome/components/json/json_util.h
@@ -13,6 +13,31 @@
 namespace esphome {
 namespace json {

+#ifdef USE_PSRAM
+// Build an allocator for the JSON Library using the RAMAllocator class
+// This is only compiled when PSRAM is enabled
+struct SpiRamAllocator : ArduinoJson::Allocator {
+  void *allocate(size_t size) override { return allocator_.allocate(size); }
+
+  void deallocate(void *ptr) override {
+    // ArduinoJson's Allocator interface doesn't provide the size parameter in deallocate.
+    // RAMAllocator::deallocate() requires the size, which we don't have access to here.
+    // RAMAllocator::deallocate implementation just calls free() regardless of whether
+    // the memory was allocated with heap_caps_malloc or malloc.
+    // This is safe because ESP-IDF's heap implementation internally tracks the memory region
+    // and routes free() to the appropriate heap.
+    free(ptr);  // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
+  }
+
+  void *reallocate(void *ptr, size_t new_size) override {
+    return allocator_.reallocate(static_cast<uint8_t *>(ptr), new_size);
+  }
+
+ protected:
+  RAMAllocator<uint8_t> allocator_{RAMAllocator<uint8_t>::NONE};
+};
+#endif
+
 /// Callback function typedef for parsing JsonObjects.
 using json_parse_t = std::function<bool(JsonObject)>;

@@ -25,5 +50,29 @@ std::string build_json(const json_build_t &f);
 /// Parse a JSON string and run the provided json parse function if it's valid.
 bool parse_json(const std::string &data, const json_parse_t &f);

+/// Builder class for creating JSON documents without lambdas
+class JsonBuilder {
+ public:
+  JsonObject root() {
+    if (!root_created_) {
+      root_ = doc_.to<JsonObject>();
+      root_created_ = true;
+    }
+    return root_;
+  }
+
+  std::string serialize();
+
+ private:
+#ifdef USE_PSRAM
+  SpiRamAllocator allocator_;
+  JsonDocument doc_{&allocator_};
+#else
+  JsonDocument doc_;
+#endif
+  JsonObject root_;
+  bool root_created_{false};
+};
+
 }  // namespace json
 }  // namespace esphome
--- a/esphome/components/number/init.py
+++ b/esphome/components/number/init.py
@@ -51,6 +51,7 @@ from esphome.const import (
    DEVICE_CLASS_OZONE,
    DEVICE_CLASS_PH,
    DEVICE_CLASS_PM1,
+    DEVICE_CLASS_PM4,
    DEVICE_CLASS_PM10,
    DEVICE_CLASS_PM25,
    DEVICE_CLASS_POWER,
@@ -116,6 +117,7 @@ DEVICE_CLASSES = [
    DEVICE_CLASS_PM1,
    DEVICE_CLASS_PM10,
    DEVICE_CLASS_PM25,
+    DEVICE_CLASS_PM4,
    DEVICE_CLASS_POWER,
    DEVICE_CLASS_POWER_FACTOR,
    DEVICE_CLASS_PRECIPITATION,
--- a/esphome/components/packages/init.py
+++ b/esphome/components/packages/init.py
@@ -106,11 +106,13 @@ CONFIG_SCHEMA = cv.Any(
 )


-def _process_base_package(config: dict) -> dict:
+def _process_base_package(config: dict, skip_update: bool = False) -> dict:
+    # When skip_update is True, use NEVER_REFRESH to prevent updates
+    actual_refresh = git.NEVER_REFRESH if skip_update else config[CONF_REFRESH]
    repo_dir, revert = git.clone_or_update(
        url=config[CONF_URL],
        ref=config.get(CONF_REF),
-        refresh=config[CONF_REFRESH],
+        refresh=actual_refresh,
        domain=DOMAIN,
        username=config.get(CONF_USERNAME),
        password=config.get(CONF_PASSWORD),
@@ -180,16 +182,16 @@ def _process_base_package(config: dict) -> dict:
    return {"packages": packages}


-def _process_package(package_config, config):
+def _process_package(package_config, config, skip_update: bool = False):
    recursive_package = package_config
    if CONF_URL in package_config:
-        package_config = _process_base_package(package_config)
+        package_config = _process_base_package(package_config, skip_update)
    if isinstance(package_config, dict):
-        recursive_package = do_packages_pass(package_config)
+        recursive_package = do_packages_pass(package_config, skip_update)
    return merge_config(recursive_package, config)


-def do_packages_pass(config: dict):
+def do_packages_pass(config: dict, skip_update: bool = False):
    if CONF_PACKAGES not in config:
        return config
    packages = config[CONF_PACKAGES]
@@ -198,10 +200,10 @@ def do_packages_pass(config: dict):
        if isinstance(packages, dict):
            for package_name, package_config in reversed(packages.items()):
                with cv.prepend_path(package_name):
-                    config = _process_package(package_config, config)
+                    config = _process_package(package_config, config, skip_update)
        elif isinstance(packages, list):
            for package_config in reversed(packages):
-                config = _process_package(package_config, config)
+                config = _process_package(package_config, config, skip_update)
        else:
            raise cv.Invalid(
                f"Packages must be a key to value mapping or list, got {type(packages)} instead"
--- a/esphome/components/sensirion_common/i2c_sensirion.cpp
+++ b/esphome/components/sensirion_common/i2c_sensirion.cpp
@@ -76,7 +76,8 @@ bool SensirionI2CDevice::write_command_(uint16_t command, CommandLen command_len
    temp[raw_idx++] = data[i] >> 8;
 #endif
    // Use MSB first since Sensirion devices use CRC-8 with MSB first
-    temp[raw_idx++] = crc8(&temp[raw_idx - 2], 2, 0xFF, CRC_POLYNOMIAL, true);
+    uint8_t crc = crc8(&temp[raw_idx - 2], 2, 0xFF, CRC_POLYNOMIAL, true);
+    temp[raw_idx++] = crc;
  }
  this->last_error_ = this->write(temp, raw_idx);
  return this->last_error_ == i2c::ERROR_OK;
--- a/esphome/components/sensor/init.py
+++ b/esphome/components/sensor/init.py
@@ -74,6 +74,7 @@ from esphome.const import (
    DEVICE_CLASS_OZONE,
    DEVICE_CLASS_PH,
    DEVICE_CLASS_PM1,
+    DEVICE_CLASS_PM4,
    DEVICE_CLASS_PM10,
    DEVICE_CLASS_PM25,
    DEVICE_CLASS_POWER,
@@ -143,6 +144,7 @@ DEVICE_CLASSES = [
    DEVICE_CLASS_PM1,
    DEVICE_CLASS_PM10,
    DEVICE_CLASS_PM25,
+    DEVICE_CLASS_PM4,
    DEVICE_CLASS_POWER,
    DEVICE_CLASS_POWER_FACTOR,
    DEVICE_CLASS_PRECIPITATION,
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -228,10 +228,11 @@ void DeferredUpdateEventSourceList::on_client_connect_(WebServer *ws, DeferredUp

 #ifdef USE_WEBSERVER_SORTING
  for (auto &group : ws->sorting_groups_) {
-    message = json::build_json([group](JsonObject root) {
-      root["name"] = group.second.name;
-      root["sorting_weight"] = group.second.weight;
-    });
+    json::JsonBuilder builder;
+    JsonObject root = builder.root();
+    root["name"] = group.second.name;
+    root["sorting_weight"] = group.second.weight;
+    message = builder.serialize();

    // up to 31 groups should be able to be queued initially without defer
    source->try_send_nodefer(message.c_str(), "sorting_group");
@@ -265,17 +266,20 @@ void WebServer::set_js_include(const char *js_include) { this->js_include_ = js_
 #endif

 std::string WebServer::get_config_json() {
-  return json::build_json([this](JsonObject root) {
-    root["title"] = App.get_friendly_name().empty() ? App.get_name() : App.get_friendly_name();
-    root["comment"] = App.get_comment();
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  root["title"] = App.get_friendly_name().empty() ? App.get_name() : App.get_friendly_name();
+  root["comment"] = App.get_comment();
 #if defined(USE_WEBSERVER_OTA_DISABLED) || !defined(USE_WEBSERVER_OTA)
-    root["ota"] = false;  // Note: USE_WEBSERVER_OTA_DISABLED only affects web_server, not captive_portal
+  root["ota"] = false;  // Note: USE_WEBSERVER_OTA_DISABLED only affects web_server, not captive_portal
 #else
-    root["ota"] = true;
+  root["ota"] = true;
 #endif
-    root["log"] = this->expose_log_;
-    root["lang"] = "en";
-  });
+  root["log"] = this->expose_log_;
+  root["lang"] = "en";
+
+  return builder.serialize();
 }

 void WebServer::setup() {
@@ -435,22 +439,26 @@ std::string WebServer::sensor_all_json_generator(WebServer *web_server, void *so
  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) {
-  return json::build_json([this, obj, value, start_config](JsonObject root) {
-    std::string state;
-    if (std::isnan(value)) {
-      state = "NA";
-    } else {
-      state = value_accuracy_to_string(value, obj->get_accuracy_decimals());
-      if (!obj->get_unit_of_measurement().empty())
-        state += " " + obj->get_unit_of_measurement();
-    }
-    set_json_icon_state_value(root, obj, "sensor-" + obj->get_object_id(), state, value, start_config);
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-      if (!obj->get_unit_of_measurement().empty())
-        root["uom"] = obj->get_unit_of_measurement();
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  // Build JSON directly inline
+  std::string state;
+  if (std::isnan(value)) {
+    state = "NA";
+  } else {
+    state = value_accuracy_to_string(value, obj->get_accuracy_decimals());
+    if (!obj->get_unit_of_measurement().empty())
+      state += " " + obj->get_unit_of_measurement();
+  }
+  set_json_icon_state_value(root, obj, "sensor-" + obj->get_object_id(), state, value, start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+    if (!obj->get_unit_of_measurement().empty())
+      root["uom"] = obj->get_unit_of_measurement();
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -483,12 +491,15 @@ std::string WebServer::text_sensor_all_json_generator(WebServer *web_server, voi
 }
 std::string WebServer::text_sensor_json(text_sensor::TextSensor *obj, const std::string &value,
                                        JsonDetail start_config) {
-  return json::build_json([this, obj, value, start_config](JsonObject root) {
-    set_json_icon_state_value(root, obj, "text_sensor-" + obj->get_object_id(), value, value, start_config);
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_icon_state_value(root, obj, "text_sensor-" + obj->get_object_id(), value, value, start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -553,13 +564,16 @@ std::string WebServer::switch_all_json_generator(WebServer *web_server, void *so
  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) {
-  return json::build_json([this, obj, value, start_config](JsonObject root) {
-    set_json_icon_state_value(root, obj, "switch-" + obj->get_object_id(), value ? "ON" : "OFF", value, start_config);
-    if (start_config == DETAIL_ALL) {
-      root["assumed_state"] = obj->assumed_state();
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_icon_state_value(root, obj, "switch-" + obj->get_object_id(), value ? "ON" : "OFF", value, start_config);
+  if (start_config == DETAIL_ALL) {
+    root["assumed_state"] = obj->assumed_state();
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -590,12 +604,15 @@ std::string WebServer::button_all_json_generator(WebServer *web_server, void *so
  return web_server->button_json((button::Button *) (source), DETAIL_ALL);
 }
 std::string WebServer::button_json(button::Button *obj, JsonDetail start_config) {
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_id(root, obj, "button-" + obj->get_object_id(), start_config);
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "button-" + obj->get_object_id(), start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -627,13 +644,16 @@ std::string WebServer::binary_sensor_all_json_generator(WebServer *web_server, v
                                        ((binary_sensor::BinarySensor *) (source))->state, DETAIL_ALL);
 }
 std::string WebServer::binary_sensor_json(binary_sensor::BinarySensor *obj, bool value, JsonDetail start_config) {
-  return json::build_json([this, obj, value, start_config](JsonObject root) {
-    set_json_icon_state_value(root, obj, "binary_sensor-" + obj->get_object_id(), value ? "ON" : "OFF", value,
-                              start_config);
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_icon_state_value(root, obj, "binary_sensor-" + obj->get_object_id(), value ? "ON" : "OFF", value,
+                            start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -694,20 +714,23 @@ std::string WebServer::fan_all_json_generator(WebServer *web_server, void *sourc
  return web_server->fan_json((fan::Fan *) (source), DETAIL_ALL);
 }
 std::string WebServer::fan_json(fan::Fan *obj, JsonDetail start_config) {
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_icon_state_value(root, obj, "fan-" + obj->get_object_id(), obj->state ? "ON" : "OFF", obj->state,
-                              start_config);
-    const auto traits = obj->get_traits();
-    if (traits.supports_speed()) {
-      root["speed_level"] = obj->speed;
-      root["speed_count"] = traits.supported_speed_count();
-    }
-    if (obj->get_traits().supports_oscillation())
-      root["oscillation"] = obj->oscillating;
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_icon_state_value(root, obj, "fan-" + obj->get_object_id(), obj->state ? "ON" : "OFF", obj->state,
+                            start_config);
+  const auto traits = obj->get_traits();
+  if (traits.supports_speed()) {
+    root["speed_level"] = obj->speed;
+    root["speed_count"] = traits.supported_speed_count();
+  }
+  if (obj->get_traits().supports_oscillation())
+    root["oscillation"] = obj->oscillating;
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -767,20 +790,23 @@ std::string WebServer::light_all_json_generator(WebServer *web_server, void *sou
  return web_server->light_json((light::LightState *) (source), DETAIL_ALL);
 }
 std::string WebServer::light_json(light::LightState *obj, JsonDetail start_config) {
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_id(root, obj, "light-" + obj->get_object_id(), start_config);
-    root["state"] = obj->remote_values.is_on() ? "ON" : "OFF";
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();

-    light::LightJSONSchema::dump_json(*obj, root);
-    if (start_config == DETAIL_ALL) {
-      JsonArray opt = root["effects"].to<JsonArray>();
-      opt.add("None");
-      for (auto const &option : obj->get_effects()) {
-        opt.add(option->get_name());
-      }
-      this->add_sorting_info_(root, obj);
+  set_json_id(root, obj, "light-" + obj->get_object_id(), start_config);
+  root["state"] = obj->remote_values.is_on() ? "ON" : "OFF";
+
+  light::LightJSONSchema::dump_json(*obj, root);
+  if (start_config == DETAIL_ALL) {
+    JsonArray opt = root["effects"].to<JsonArray>();
+    opt.add("None");
+    for (auto const &option : obj->get_effects()) {
+      opt.add(option->get_name());
    }
-  });
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -839,19 +865,22 @@ std::string WebServer::cover_all_json_generator(WebServer *web_server, void *sou
  return web_server->cover_json((cover::Cover *) (source), DETAIL_ALL);
 }
 std::string WebServer::cover_json(cover::Cover *obj, JsonDetail start_config) {
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_icon_state_value(root, obj, "cover-" + obj->get_object_id(), obj->is_fully_closed() ? "CLOSED" : "OPEN",
-                              obj->position, start_config);
-    root["current_operation"] = cover::cover_operation_to_str(obj->current_operation);
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();

-    if (obj->get_traits().get_supports_position())
-      root["position"] = obj->position;
-    if (obj->get_traits().get_supports_tilt())
-      root["tilt"] = obj->tilt;
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  set_json_icon_state_value(root, obj, "cover-" + obj->get_object_id(), obj->is_fully_closed() ? "CLOSED" : "OPEN",
+                            obj->position, start_config);
+  root["current_operation"] = cover::cover_operation_to_str(obj->current_operation);
+
+  if (obj->get_traits().get_supports_position())
+    root["position"] = obj->position;
+  if (obj->get_traits().get_supports_tilt())
+    root["tilt"] = obj->tilt;
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -894,31 +923,33 @@ std::string WebServer::number_all_json_generator(WebServer *web_server, void *so
  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) {
-  return json::build_json([this, obj, value, start_config](JsonObject root) {
-    set_json_id(root, obj, "number-" + obj->get_object_id(), start_config);
-    if (start_config == DETAIL_ALL) {
-      root["min_value"] =
-          value_accuracy_to_string(obj->traits.get_min_value(), step_to_accuracy_decimals(obj->traits.get_step()));
-      root["max_value"] =
-          value_accuracy_to_string(obj->traits.get_max_value(), step_to_accuracy_decimals(obj->traits.get_step()));
-      root["step"] =
-          value_accuracy_to_string(obj->traits.get_step(), step_to_accuracy_decimals(obj->traits.get_step()));
-      root["mode"] = (int) obj->traits.get_mode();
-      if (!obj->traits.get_unit_of_measurement().empty())
-        root["uom"] = obj->traits.get_unit_of_measurement();
-      this->add_sorting_info_(root, obj);
-    }
-    if (std::isnan(value)) {
-      root["value"] = "\"NaN\"";
-      root["state"] = "NA";
-    } else {
-      root["value"] = value_accuracy_to_string(value, step_to_accuracy_decimals(obj->traits.get_step()));
-      std::string state = value_accuracy_to_string(value, step_to_accuracy_decimals(obj->traits.get_step()));
-      if (!obj->traits.get_unit_of_measurement().empty())
-        state += " " + obj->traits.get_unit_of_measurement();
-      root["state"] = state;
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "number-" + obj->get_object_id(), start_config);
+  if (start_config == DETAIL_ALL) {
+    root["min_value"] =
+        value_accuracy_to_string(obj->traits.get_min_value(), step_to_accuracy_decimals(obj->traits.get_step()));
+    root["max_value"] =
+        value_accuracy_to_string(obj->traits.get_max_value(), step_to_accuracy_decimals(obj->traits.get_step()));
+    root["step"] = value_accuracy_to_string(obj->traits.get_step(), step_to_accuracy_decimals(obj->traits.get_step()));
+    root["mode"] = (int) obj->traits.get_mode();
+    if (!obj->traits.get_unit_of_measurement().empty())
+      root["uom"] = obj->traits.get_unit_of_measurement();
+    this->add_sorting_info_(root, obj);
+  }
+  if (std::isnan(value)) {
+    root["value"] = "\"NaN\"";
+    root["state"] = "NA";
+  } else {
+    root["value"] = value_accuracy_to_string(value, step_to_accuracy_decimals(obj->traits.get_step()));
+    std::string state = value_accuracy_to_string(value, step_to_accuracy_decimals(obj->traits.get_step()));
+    if (!obj->traits.get_unit_of_measurement().empty())
+      state += " " + obj->traits.get_unit_of_measurement();
+    root["state"] = state;
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -966,15 +997,18 @@ std::string WebServer::date_all_json_generator(WebServer *web_server, void *sour
  return web_server->date_json((datetime::DateEntity *) (source), DETAIL_ALL);
 }
 std::string WebServer::date_json(datetime::DateEntity *obj, JsonDetail start_config) {
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_id(root, obj, "date-" + obj->get_object_id(), start_config);
-    std::string value = str_sprintf("%d-%02d-%02d", obj->year, obj->month, obj->day);
-    root["value"] = value;
-    root["state"] = value;
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "date-" + obj->get_object_id(), start_config);
+  std::string value = str_sprintf("%d-%02d-%02d", obj->year, obj->month, obj->day);
+  root["value"] = value;
+  root["state"] = value;
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif  // USE_DATETIME_DATE

@@ -1021,15 +1055,18 @@ std::string WebServer::time_all_json_generator(WebServer *web_server, void *sour
  return web_server->time_json((datetime::TimeEntity *) (source), DETAIL_ALL);
 }
 std::string WebServer::time_json(datetime::TimeEntity *obj, JsonDetail start_config) {
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_id(root, obj, "time-" + obj->get_object_id(), start_config);
-    std::string value = str_sprintf("%02d:%02d:%02d", obj->hour, obj->minute, obj->second);
-    root["value"] = value;
-    root["state"] = value;
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "time-" + obj->get_object_id(), start_config);
+  std::string value = str_sprintf("%02d:%02d:%02d", obj->hour, obj->minute, obj->second);
+  root["value"] = value;
+  root["state"] = value;
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif  // USE_DATETIME_TIME

@@ -1076,16 +1113,19 @@ std::string WebServer::datetime_all_json_generator(WebServer *web_server, void *
  return web_server->datetime_json((datetime::DateTimeEntity *) (source), DETAIL_ALL);
 }
 std::string WebServer::datetime_json(datetime::DateTimeEntity *obj, JsonDetail start_config) {
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_id(root, obj, "datetime-" + obj->get_object_id(), start_config);
-    std::string value = str_sprintf("%d-%02d-%02d %02d:%02d:%02d", obj->year, obj->month, obj->day, obj->hour,
-                                    obj->minute, obj->second);
-    root["value"] = value;
-    root["state"] = value;
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "datetime-" + obj->get_object_id(), start_config);
+  std::string value =
+      str_sprintf("%d-%02d-%02d %02d:%02d:%02d", obj->year, obj->month, obj->day, obj->hour, obj->minute, obj->second);
+  root["value"] = value;
+  root["state"] = value;
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif  // USE_DATETIME_DATETIME

@@ -1128,22 +1168,25 @@ std::string WebServer::text_all_json_generator(WebServer *web_server, void *sour
  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) {
-  return json::build_json([this, obj, value, start_config](JsonObject root) {
-    set_json_id(root, obj, "text-" + obj->get_object_id(), start_config);
-    root["min_length"] = obj->traits.get_min_length();
-    root["max_length"] = obj->traits.get_max_length();
-    root["pattern"] = obj->traits.get_pattern();
-    if (obj->traits.get_mode() == text::TextMode::TEXT_MODE_PASSWORD) {
-      root["state"] = "********";
-    } else {
-      root["state"] = value;
-    }
-    root["value"] = value;
-    if (start_config == DETAIL_ALL) {
-      root["mode"] = (int) obj->traits.get_mode();
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "text-" + obj->get_object_id(), start_config);
+  root["min_length"] = obj->traits.get_min_length();
+  root["max_length"] = obj->traits.get_max_length();
+  root["pattern"] = obj->traits.get_pattern();
+  if (obj->traits.get_mode() == text::TextMode::TEXT_MODE_PASSWORD) {
+    root["state"] = "********";
+  } else {
+    root["state"] = value;
+  }
+  root["value"] = value;
+  if (start_config == DETAIL_ALL) {
+    root["mode"] = (int) obj->traits.get_mode();
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -1186,16 +1229,19 @@ std::string WebServer::select_all_json_generator(WebServer *web_server, void *so
  return web_server->select_json((select::Select *) (source), ((select::Select *) (source))->state, DETAIL_ALL);
 }
 std::string WebServer::select_json(select::Select *obj, const std::string &value, JsonDetail start_config) {
-  return json::build_json([this, obj, value, start_config](JsonObject root) {
-    set_json_icon_state_value(root, obj, "select-" + obj->get_object_id(), value, value, start_config);
-    if (start_config == DETAIL_ALL) {
-      JsonArray opt = root["option"].to<JsonArray>();
-      for (auto &option : obj->traits.get_options()) {
-        opt.add(option);
-      }
-      this->add_sorting_info_(root, obj);
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_icon_state_value(root, obj, "select-" + obj->get_object_id(), value, value, start_config);
+  if (start_config == DETAIL_ALL) {
+    JsonArray opt = root["option"].to<JsonArray>();
+    for (auto &option : obj->traits.get_options()) {
+      opt.add(option);
    }
-  });
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -1244,98 +1290,102 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
  request->send(404);
 }
 std::string WebServer::climate_state_json_generator(WebServer *web_server, void *source) {
+  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
  return web_server->climate_json((climate::Climate *) (source), DETAIL_STATE);
 }
 std::string WebServer::climate_all_json_generator(WebServer *web_server, void *source) {
+  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
  return web_server->climate_json((climate::Climate *) (source), DETAIL_ALL);
 }
 std::string WebServer::climate_json(climate::Climate *obj, JsonDetail start_config) {
  // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_id(root, obj, "climate-" + obj->get_object_id(), start_config);
-    const auto traits = obj->get_traits();
-    int8_t target_accuracy = traits.get_target_temperature_accuracy_decimals();
-    int8_t current_accuracy = traits.get_current_temperature_accuracy_decimals();
-    char buf[16];
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+  set_json_id(root, obj, "climate-" + obj->get_object_id(), start_config);
+  const auto traits = obj->get_traits();
+  int8_t target_accuracy = traits.get_target_temperature_accuracy_decimals();
+  int8_t current_accuracy = traits.get_current_temperature_accuracy_decimals();
+  char buf[16];

-    if (start_config == DETAIL_ALL) {
-      JsonArray opt = root["modes"].to<JsonArray>();
-      for (climate::ClimateMode m : traits.get_supported_modes())
-        opt.add(PSTR_LOCAL(climate::climate_mode_to_string(m)));
-      if (!traits.get_supported_custom_fan_modes().empty()) {
-        JsonArray opt = root["fan_modes"].to<JsonArray>();
-        for (climate::ClimateFanMode m : traits.get_supported_fan_modes())
-          opt.add(PSTR_LOCAL(climate::climate_fan_mode_to_string(m)));
-      }
-
-      if (!traits.get_supported_custom_fan_modes().empty()) {
-        JsonArray opt = root["custom_fan_modes"].to<JsonArray>();
-        for (auto const &custom_fan_mode : traits.get_supported_custom_fan_modes())
-          opt.add(custom_fan_mode);
-      }
-      if (traits.get_supports_swing_modes()) {
-        JsonArray opt = root["swing_modes"].to<JsonArray>();
-        for (auto swing_mode : traits.get_supported_swing_modes())
-          opt.add(PSTR_LOCAL(climate::climate_swing_mode_to_string(swing_mode)));
-      }
-      if (traits.get_supports_presets() && obj->preset.has_value()) {
-        JsonArray opt = root["presets"].to<JsonArray>();
-        for (climate::ClimatePreset m : traits.get_supported_presets())
-          opt.add(PSTR_LOCAL(climate::climate_preset_to_string(m)));
-      }
-      if (!traits.get_supported_custom_presets().empty() && obj->custom_preset.has_value()) {
-        JsonArray opt = root["custom_presets"].to<JsonArray>();
-        for (auto const &custom_preset : traits.get_supported_custom_presets())
-          opt.add(custom_preset);
-      }
-      this->add_sorting_info_(root, obj);
+  if (start_config == DETAIL_ALL) {
+    JsonArray opt = root["modes"].to<JsonArray>();
+    for (climate::ClimateMode m : traits.get_supported_modes())
+      opt.add(PSTR_LOCAL(climate::climate_mode_to_string(m)));
+    if (!traits.get_supported_custom_fan_modes().empty()) {
+      JsonArray opt = root["fan_modes"].to<JsonArray>();
+      for (climate::ClimateFanMode m : traits.get_supported_fan_modes())
+        opt.add(PSTR_LOCAL(climate::climate_fan_mode_to_string(m)));
    }

-    bool has_state = false;
-    root["mode"] = PSTR_LOCAL(climate_mode_to_string(obj->mode));
-    root["max_temp"] = value_accuracy_to_string(traits.get_visual_max_temperature(), target_accuracy);
-    root["min_temp"] = value_accuracy_to_string(traits.get_visual_min_temperature(), target_accuracy);
-    root["step"] = traits.get_visual_target_temperature_step();
-    if (traits.get_supports_action()) {
-      root["action"] = PSTR_LOCAL(climate_action_to_string(obj->action));
-      root["state"] = root["action"];
-      has_state = true;
-    }
-    if (traits.get_supports_fan_modes() && obj->fan_mode.has_value()) {
-      root["fan_mode"] = PSTR_LOCAL(climate_fan_mode_to_string(obj->fan_mode.value()));
-    }
-    if (!traits.get_supported_custom_fan_modes().empty() && obj->custom_fan_mode.has_value()) {
-      root["custom_fan_mode"] = obj->custom_fan_mode.value().c_str();
-    }
-    if (traits.get_supports_presets() && obj->preset.has_value()) {
-      root["preset"] = PSTR_LOCAL(climate_preset_to_string(obj->preset.value()));
-    }
-    if (!traits.get_supported_custom_presets().empty() && obj->custom_preset.has_value()) {
-      root["custom_preset"] = obj->custom_preset.value().c_str();
+    if (!traits.get_supported_custom_fan_modes().empty()) {
+      JsonArray opt = root["custom_fan_modes"].to<JsonArray>();
+      for (auto const &custom_fan_mode : traits.get_supported_custom_fan_modes())
+        opt.add(custom_fan_mode);
    }
    if (traits.get_supports_swing_modes()) {
-      root["swing_mode"] = PSTR_LOCAL(climate_swing_mode_to_string(obj->swing_mode));
+      JsonArray opt = root["swing_modes"].to<JsonArray>();
+      for (auto swing_mode : traits.get_supported_swing_modes())
+        opt.add(PSTR_LOCAL(climate::climate_swing_mode_to_string(swing_mode)));
    }
-    if (traits.get_supports_current_temperature()) {
-      if (!std::isnan(obj->current_temperature)) {
-        root["current_temperature"] = value_accuracy_to_string(obj->current_temperature, current_accuracy);
-      } else {
-        root["current_temperature"] = "NA";
-      }
+    if (traits.get_supports_presets() && obj->preset.has_value()) {
+      JsonArray opt = root["presets"].to<JsonArray>();
+      for (climate::ClimatePreset m : traits.get_supported_presets())
+        opt.add(PSTR_LOCAL(climate::climate_preset_to_string(m)));
    }
-    if (traits.get_supports_two_point_target_temperature()) {
-      root["target_temperature_low"] = value_accuracy_to_string(obj->target_temperature_low, target_accuracy);
-      root["target_temperature_high"] = value_accuracy_to_string(obj->target_temperature_high, target_accuracy);
-      if (!has_state) {
-        root["state"] = value_accuracy_to_string((obj->target_temperature_high + obj->target_temperature_low) / 2.0f,
-                                                 target_accuracy);
-      }
+    if (!traits.get_supported_custom_presets().empty() && obj->custom_preset.has_value()) {
+      JsonArray opt = root["custom_presets"].to<JsonArray>();
+      for (auto const &custom_preset : traits.get_supported_custom_presets())
+        opt.add(custom_preset);
+    }
+    this->add_sorting_info_(root, obj);
+  }
+
+  bool has_state = false;
+  root["mode"] = PSTR_LOCAL(climate_mode_to_string(obj->mode));
+  root["max_temp"] = value_accuracy_to_string(traits.get_visual_max_temperature(), target_accuracy);
+  root["min_temp"] = value_accuracy_to_string(traits.get_visual_min_temperature(), target_accuracy);
+  root["step"] = traits.get_visual_target_temperature_step();
+  if (traits.get_supports_action()) {
+    root["action"] = PSTR_LOCAL(climate_action_to_string(obj->action));
+    root["state"] = root["action"];
+    has_state = true;
+  }
+  if (traits.get_supports_fan_modes() && obj->fan_mode.has_value()) {
+    root["fan_mode"] = PSTR_LOCAL(climate_fan_mode_to_string(obj->fan_mode.value()));
+  }
+  if (!traits.get_supported_custom_fan_modes().empty() && obj->custom_fan_mode.has_value()) {
+    root["custom_fan_mode"] = obj->custom_fan_mode.value().c_str();
+  }
+  if (traits.get_supports_presets() && obj->preset.has_value()) {
+    root["preset"] = PSTR_LOCAL(climate_preset_to_string(obj->preset.value()));
+  }
+  if (!traits.get_supported_custom_presets().empty() && obj->custom_preset.has_value()) {
+    root["custom_preset"] = obj->custom_preset.value().c_str();
+  }
+  if (traits.get_supports_swing_modes()) {
+    root["swing_mode"] = PSTR_LOCAL(climate_swing_mode_to_string(obj->swing_mode));
+  }
+  if (traits.get_supports_current_temperature()) {
+    if (!std::isnan(obj->current_temperature)) {
+      root["current_temperature"] = value_accuracy_to_string(obj->current_temperature, current_accuracy);
    } else {
-      root["target_temperature"] = value_accuracy_to_string(obj->target_temperature, target_accuracy);
-      if (!has_state)
-        root["state"] = root["target_temperature"];
+      root["current_temperature"] = "NA";
    }
-  });
+  }
+  if (traits.get_supports_two_point_target_temperature()) {
+    root["target_temperature_low"] = value_accuracy_to_string(obj->target_temperature_low, target_accuracy);
+    root["target_temperature_high"] = value_accuracy_to_string(obj->target_temperature_high, target_accuracy);
+    if (!has_state) {
+      root["state"] = value_accuracy_to_string((obj->target_temperature_high + obj->target_temperature_low) / 2.0f,
+                                               target_accuracy);
+    }
+  } else {
+    root["target_temperature"] = value_accuracy_to_string(obj->target_temperature, target_accuracy);
+    if (!has_state)
+      root["state"] = root["target_temperature"];
+  }
+
+  return builder.serialize();
  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 #endif
@@ -1401,13 +1451,16 @@ std::string WebServer::lock_all_json_generator(WebServer *web_server, void *sour
  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) {
-  return json::build_json([this, obj, value, start_config](JsonObject root) {
-    set_json_icon_state_value(root, obj, "lock-" + obj->get_object_id(), lock::lock_state_to_string(value), value,
-                              start_config);
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_icon_state_value(root, obj, "lock-" + obj->get_object_id(), lock::lock_state_to_string(value), value,
+                            start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -1464,17 +1517,20 @@ std::string WebServer::valve_all_json_generator(WebServer *web_server, void *sou
  return web_server->valve_json((valve::Valve *) (source), DETAIL_ALL);
 }
 std::string WebServer::valve_json(valve::Valve *obj, JsonDetail start_config) {
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_icon_state_value(root, obj, "valve-" + obj->get_object_id(), obj->is_fully_closed() ? "CLOSED" : "OPEN",
-                              obj->position, start_config);
-    root["current_operation"] = valve::valve_operation_to_str(obj->current_operation);
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();

-    if (obj->get_traits().get_supports_position())
-      root["position"] = obj->position;
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  set_json_icon_state_value(root, obj, "valve-" + obj->get_object_id(), obj->is_fully_closed() ? "CLOSED" : "OPEN",
+                            obj->position, start_config);
+  root["current_operation"] = valve::valve_operation_to_str(obj->current_operation);
+
+  if (obj->get_traits().get_supports_position())
+    root["position"] = obj->position;
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -1533,14 +1589,17 @@ std::string WebServer::alarm_control_panel_all_json_generator(WebServer *web_ser
 std::string WebServer::alarm_control_panel_json(alarm_control_panel::AlarmControlPanel *obj,
                                                alarm_control_panel::AlarmControlPanelState value,
                                                JsonDetail start_config) {
-  return json::build_json([this, obj, value, start_config](JsonObject root) {
-    char buf[16];
-    set_json_icon_state_value(root, obj, "alarm-control-panel-" + obj->get_object_id(),
-                              PSTR_LOCAL(alarm_control_panel_state_to_string(value)), value, start_config);
-    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  char buf[16];
+  set_json_icon_state_value(root, obj, "alarm-control-panel-" + obj->get_object_id(),
+                            PSTR_LOCAL(alarm_control_panel_state_to_string(value)), value, start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -1577,20 +1636,23 @@ std::string WebServer::event_all_json_generator(WebServer *web_server, void *sou
  return web_server->event_json(event, get_event_type(event), DETAIL_ALL);
 }
 std::string WebServer::event_json(event::Event *obj, const std::string &event_type, JsonDetail start_config) {
-  return json::build_json([this, obj, event_type, start_config](JsonObject root) {
-    set_json_id(root, obj, "event-" + obj->get_object_id(), start_config);
-    if (!event_type.empty()) {
-      root["event_type"] = event_type;
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "event-" + obj->get_object_id(), start_config);
+  if (!event_type.empty()) {
+    root["event_type"] = event_type;
+  }
+  if (start_config == DETAIL_ALL) {
+    JsonArray event_types = root["event_types"].to<JsonArray>();
+    for (auto const &event_type : obj->get_event_types()) {
+      event_types.add(event_type);
    }
-    if (start_config == DETAIL_ALL) {
-      JsonArray event_types = root["event_types"].to<JsonArray>();
-      for (auto const &event_type : obj->get_event_types()) {
-        event_types.add(event_type);
-      }
-      root["device_class"] = obj->get_device_class();
-      this->add_sorting_info_(root, obj);
-    }
-  });
+    root["device_class"] = obj->get_device_class();
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif

@@ -1637,25 +1699,30 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
  request->send(404);
 }
 std::string WebServer::update_state_json_generator(WebServer *web_server, void *source) {
+  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
  return web_server->update_json((update::UpdateEntity *) (source), DETAIL_STATE);
 }
 std::string WebServer::update_all_json_generator(WebServer *web_server, void *source) {
+  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
  return web_server->update_json((update::UpdateEntity *) (source), DETAIL_STATE);
 }
 std::string WebServer::update_json(update::UpdateEntity *obj, JsonDetail start_config) {
  // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  return json::build_json([this, obj, start_config](JsonObject root) {
-    set_json_id(root, obj, "update-" + obj->get_object_id(), start_config);
-    root["value"] = obj->update_info.latest_version;
-    root["state"] = update_state_to_string(obj->state);
-    if (start_config == DETAIL_ALL) {
-      root["current_version"] = obj->update_info.current_version;
-      root["title"] = obj->update_info.title;
-      root["summary"] = obj->update_info.summary;
-      root["release_url"] = obj->update_info.release_url;
-      this->add_sorting_info_(root, obj);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "update-" + obj->get_object_id(), start_config);
+  root["value"] = obj->update_info.latest_version;
+  root["state"] = update_state_to_string(obj->state);
+  if (start_config == DETAIL_ALL) {
+    root["current_version"] = obj->update_info.current_version;
+    root["title"] = obj->update_info.title;
+    root["summary"] = obj->update_info.summary;
+    root["release_url"] = obj->update_info.release_url;
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 #endif
--- a/esphome/components/web_server_idf/web_server_idf.cpp
+++ b/esphome/components/web_server_idf/web_server_idf.cpp
@@ -317,8 +317,8 @@ AsyncEventSource::~AsyncEventSource() {
 }

 void AsyncEventSource::handleRequest(AsyncWebServerRequest *request) {
-  auto *rsp =  // NOLINT(cppcoreguidelines-owning-memory)
-      new AsyncEventSourceResponse(request, this, this->web_server_);
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory,clang-analyzer-cplusplus.NewDeleteLeaks)
+  auto *rsp = new AsyncEventSourceResponse(request, this, this->web_server_);
  if (this->on_connect_) {
    this->on_connect_(rsp);
  }
@@ -392,10 +392,11 @@ AsyncEventSourceResponse::AsyncEventSourceResponse(const AsyncWebServerRequest *
 #ifdef USE_WEBSERVER_SORTING
  for (auto &group : ws->sorting_groups_) {
    // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-    message = json::build_json([group](JsonObject root) {
-      root["name"] = group.second.name;
-      root["sorting_weight"] = group.second.weight;
-    });
+    json::JsonBuilder builder;
+    JsonObject root = builder.root();
+    root["name"] = group.second.name;
+    root["sorting_weight"] = group.second.weight;
+    message = builder.serialize();
    // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)

    // a (very) large number of these should be able to be queued initially without defer
--- a/esphome/config.py
+++ b/esphome/config.py
@@ -846,7 +846,9 @@ class PinUseValidationCheck(ConfigValidationStep):


 def validate_config(
-    config: dict[str, Any], command_line_substitutions: dict[str, Any]
+    config: dict[str, Any],
+    command_line_substitutions: dict[str, Any],
+    skip_external_update: bool = False,
 ) -> Config:
    result = Config()

@@ -859,7 +861,7 @@ def validate_config(

        result.add_output_path([CONF_PACKAGES], CONF_PACKAGES)
        try:
-            config = do_packages_pass(config)
+            config = do_packages_pass(config, skip_update=skip_external_update)
        except vol.Invalid as err:
            result.update(config)
            result.add_error(err)
@@ -896,7 +898,7 @@ def validate_config(

        result.add_output_path([CONF_EXTERNAL_COMPONENTS], CONF_EXTERNAL_COMPONENTS)
        try:
-            do_external_components_pass(config)
+            do_external_components_pass(config, skip_update=skip_external_update)
        except vol.Invalid as err:
            result.update(config)
            result.add_error(err)
@@ -1020,7 +1022,9 @@ class InvalidYAMLError(EsphomeError):
        self.base_exc = base_exc


-def _load_config(command_line_substitutions: dict[str, Any]) -> Config:
+def _load_config(
+    command_line_substitutions: dict[str, Any], skip_external_update: bool = False
+) -> Config:
    """Load the configuration file."""
    try:
        config = yaml_util.load_yaml(CORE.config_path)
@@ -1028,7 +1032,7 @@ def _load_config(command_line_substitutions: dict[str, Any]) -> Config:
        raise InvalidYAMLError(e) from e

    try:
-        return validate_config(config, command_line_substitutions)
+        return validate_config(config, command_line_substitutions, skip_external_update)
    except EsphomeError:
        raise
    except Exception:
@@ -1036,9 +1040,11 @@ def _load_config(command_line_substitutions: dict[str, Any]) -> Config:
        raise


-def load_config(command_line_substitutions: dict[str, Any]) -> Config:
+def load_config(
+    command_line_substitutions: dict[str, Any], skip_external_update: bool = False
+) -> Config:
    try:
-        return _load_config(command_line_substitutions)
+        return _load_config(command_line_substitutions, skip_external_update)
    except vol.Invalid as err:
        raise EsphomeError(f"Error while parsing config: {err}") from err

@@ -1178,10 +1184,10 @@ def strip_default_ids(config):
    return config


-def read_config(command_line_substitutions):
+def read_config(command_line_substitutions, skip_external_update=False):
    _LOGGER.info("Reading configuration %s...", CORE.config_path)
    try:
-        res = load_config(command_line_substitutions)
+        res = load_config(command_line_substitutions, skip_external_update)
    except EsphomeError as err:
        _LOGGER.error("Error while reading config: %s", err)
        return None
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -1269,6 +1269,7 @@ DEVICE_CLASS_PLUG = "plug"
 DEVICE_CLASS_PM1 = "pm1"
 DEVICE_CLASS_PM10 = "pm10"
 DEVICE_CLASS_PM25 = "pm25"
+DEVICE_CLASS_PM4 = "pm4"
 DEVICE_CLASS_POWER = "power"
 DEVICE_CLASS_POWER_FACTOR = "power_factor"
 DEVICE_CLASS_PRECIPITATION = "precipitation"
--- a/esphome/git.py
+++ b/esphome/git.py
@@ -13,6 +13,9 @@ from esphome.core import CORE, TimePeriodSeconds

 _LOGGER = logging.getLogger(__name__)

+# Special value to indicate never refresh
+NEVER_REFRESH = TimePeriodSeconds(seconds=-1)
+

 def run_git_command(cmd, cwd=None) -> str:
    _LOGGER.debug("Running git command: %s", " ".join(cmd))
@@ -85,6 +88,11 @@ def clone_or_update(

    else:
        # Check refresh needed
+        # Skip refresh if NEVER_REFRESH is specified
+        if refresh == NEVER_REFRESH:
+            _LOGGER.debug("Skipping update for %s (refresh disabled)", key)
+            return repo_dir, None
+
        file_timestamp = Path(repo_dir / ".git" / "FETCH_HEAD")
        # On first clone, FETCH_HEAD does not exists
        if not file_timestamp.exists():
--- a/esphome/writer.py
+++ b/esphome/writer.py
@@ -301,6 +301,11 @@ def clean_cmake_cache():
 def clean_build():
    import shutil

+    # Allow skipping cache cleaning for integration tests
+    if os.environ.get("ESPHOME_SKIP_CLEAN_BUILD"):
+        _LOGGER.warning("Skipping build cleaning (ESPHOME_SKIP_CLEAN_BUILD set)")
+        return
+
    pioenvs = CORE.relative_pioenvs_path()
    if pioenvs.is_dir():
        _LOGGER.info("Deleting %s", pioenvs)