esphome 2025.9.3__py3-none-any.whl → 2025.10.0b2__py3-none-any.whl

esphome/components/web_server/web_server.cpp

@@ -8,7 +8,7 @@
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
-#ifdef USE_ARDUINO
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
 #include "StreamString.h"
 #endif
 
@@ -103,19 +103,19 @@ static UrlMatch match_url(const char *url_ptr, size_t url_len, bool only_domain)
   return match;
 }
 
-#ifdef USE_ARDUINO
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
 // helper for allowing only unique entries in the queue
 void DeferredUpdateEventSource::deq_push_back_with_dedup_(void *source, message_generator_t *message_generator) {
   DeferredEvent item(source, message_generator);
 
-  auto iter = std::find_if(this->deferred_queue_.begin(), this->deferred_queue_.end(),
-                           [&item](const DeferredEvent &test) -> bool { return test == item; });
-
-  if (iter != this->deferred_queue_.end()) {
-    (*iter) = item;
-  } else {
-    this->deferred_queue_.push_back(item);
+  // Use range-based for loop instead of std::find_if to reduce template instantiation overhead and binary size
+  for (auto &event : this->deferred_queue_) {
+    if (event == item) {
+      event = item;
+      return;
+    }
   }
+  this->deferred_queue_.push_back(item);
 }
 
 void DeferredUpdateEventSource::process_deferred_queue_() {
@@ -127,6 +127,10 @@ void DeferredUpdateEventSource::process_deferred_queue_() {
       deferred_queue_.erase(deferred_queue_.begin());
       this->consecutive_send_failures_ = 0;  // Reset failure count on successful send
     } else {
+      // NOTE: Similar logic exists in web_server_idf/web_server_idf.cpp in AsyncEventSourceResponse::process_buffer_()
+      // The implementations differ due to platform-specific APIs (DISCARDED vs HTTPD_SOCK_ERR_TIMEOUT, close() vs
+      // fd_.store(0)), but the failure counting and timeout logic should be kept in sync. If you change this logic,
+      // also update the ESP-IDF implementation.
       this->consecutive_send_failures_++;
       if (this->consecutive_send_failures_ >= MAX_CONSECUTIVE_SEND_FAILURES) {
         // Too many failures, connection is likely dead
@@ -228,10 +232,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 +270,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() {
@@ -293,7 +301,7 @@ void WebServer::setup() {
   }
 #endif
 
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
   this->base_->add_handler(&this->events_);
 #endif
   this->base_->add_handler(this);
@@ -377,11 +385,14 @@ void WebServer::handle_js_request(AsyncWebServerRequest *request) {
 #endif
 
 // Helper functions to reduce code size by avoiding macro expansion
-static void set_json_id(JsonObject &root, EntityBase *obj, const std::string &id, JsonDetail start_config) {
-  root["id"] = id;
+static void set_json_id(JsonObject &root, EntityBase *obj, const char *prefix, JsonDetail start_config) {
+  char id_buf[160];  // object_id can be up to 128 chars + prefix + dash + null
+  const auto &object_id = obj->get_object_id();
+  snprintf(id_buf, sizeof(id_buf), "%s-%s", prefix, object_id.c_str());
+  root["id"] = id_buf;
   if (start_config == DETAIL_ALL) {
     root["name"] = obj->get_name();
-    root["icon"] = obj->get_icon();
+    root["icon"] = obj->get_icon_ref();
     root["entity_category"] = obj->get_entity_category();
     bool is_disabled = obj->is_disabled_by_default();
     if (is_disabled)
@@ -389,17 +400,19 @@ static void set_json_id(JsonObject &root, EntityBase *obj, const std::string &id
   }
 }
 
+// Keep as separate function even though only used once: reduces code size by ~48 bytes
+// by allowing compiler to share code between template instantiations (bool, float, etc.)
 template<typename T>
-static void set_json_value(JsonObject &root, EntityBase *obj, const std::string &id, const T &value,
+static void set_json_value(JsonObject &root, EntityBase *obj, const char *prefix, const T &value,
                            JsonDetail start_config) {
-  set_json_id(root, obj, id, start_config);
+  set_json_id(root, obj, prefix, start_config);
   root["value"] = value;
 }
 
 template<typename T>
-static void set_json_icon_state_value(JsonObject &root, EntityBase *obj, const std::string &id,
-                                      const std::string &state, const T &value, JsonDetail start_config) {
-  set_json_value(root, obj, id, value, start_config);
+static void set_json_icon_state_value(JsonObject &root, EntityBase *obj, const char *prefix, const std::string &state,
+                                      const T &value, JsonDetail start_config) {
+  set_json_value(root, obj, prefix, value, start_config);
   root["state"] = state;
 }
 
@@ -435,22 +448,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();
+
+  const auto uom_ref = obj->get_unit_of_measurement_ref();
+
+  // Build JSON directly inline
+  std::string state;
+  if (std::isnan(value)) {
+    state = "NA";
+  } else {
+    state = value_accuracy_with_uom_to_string(value, obj->get_accuracy_decimals(), uom_ref);
+  }
+  set_json_icon_state_value(root, obj, "sensor", state, value, start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+    if (!uom_ref.empty())
+      root["uom"] = uom_ref;
+  }
+
+  return builder.serialize();
 }
 #endif
 
@@ -483,12 +500,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", value, value, start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif
 
@@ -553,13 +573,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", 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 +613,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", start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif
 
@@ -627,13 +653,15 @@ 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", value ? "ON" : "OFF", value, start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif
 
@@ -694,20 +722,22 @@ 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->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 +797,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";
-
-    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);
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "light", 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
 
@@ -803,15 +836,28 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
     }
 
     auto call = obj->make_call();
-    if (match.method_equals("open")) {
-      call.set_command_open();
-    } else if (match.method_equals("close")) {
-      call.set_command_close();
-    } else if (match.method_equals("stop")) {
-      call.set_command_stop();
-    } else if (match.method_equals("toggle")) {
-      call.set_command_toggle();
-    } else if (!match.method_equals("set")) {
+
+    // Lookup table for cover methods
+    static const struct {
+      const char *name;
+      cover::CoverCall &(cover::CoverCall::*action)();
+    } METHODS[] = {
+        {"open", &cover::CoverCall::set_command_open},
+        {"close", &cover::CoverCall::set_command_close},
+        {"stop", &cover::CoverCall::set_command_stop},
+        {"toggle", &cover::CoverCall::set_command_toggle},
+    };
+
+    bool found = false;
+    for (const auto &method : METHODS) {
+      if (match.method_equals(method.name)) {
+        (call.*method.action)();
+        found = true;
+        break;
+      }
+    }
+
+    if (!found && !match.method_equals("set")) {
       request->send(404);
       return;
     }
@@ -839,19 +885,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);
-
-    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);
-    }
-  });
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_icon_state_value(root, obj, "cover", 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 +943,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();
+
+  const auto uom_ref = obj->traits.get_unit_of_measurement_ref();
+
+  set_json_id(root, obj, "number", 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 (!uom_ref.empty())
+      root["uom"] = uom_ref;
+    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()));
+    root["state"] =
+        value_accuracy_with_uom_to_string(value, step_to_accuracy_decimals(obj->traits.get_step()), uom_ref);
+  }
+
+  return builder.serialize();
 }
 #endif
 
@@ -966,15 +1017,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", 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 +1075,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", 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 +1133,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", 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 +1188,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", 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,21 +1249,24 @@ 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", 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
 
 // Longest: HORIZONTAL
-#define PSTR_LOCAL(mode_s) strncpy_P(buf, (PGM_P) ((mode_s)), 15)
+#define PSTR_LOCAL(mode_s) ESPHOME_strncpy_P(buf, (ESPHOME_PGM_P) ((mode_s)), 15)
 
 #ifdef USE_CLIMATE
 void WebServer::on_climate_update(climate::Climate *obj) {
@@ -1244,98 +1310,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];
-
-    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)));
-      }
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+  set_json_id(root, obj, "climate", 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 (!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_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_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_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()) {
-      root["preset"] = PSTR_LOCAL(climate_preset_to_string(obj->preset.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()) {
-      root["custom_preset"] = obj->custom_preset.value().c_str();
+      JsonArray opt = root["custom_presets"].to<JsonArray>();
+      for (auto const &custom_preset : traits.get_supported_custom_presets())
+        opt.add(custom_preset);
     }
-    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["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);
-      }
+    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 +1471,15 @@ 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", lock::lock_state_to_string(value), value, start_config);
+  if (start_config == DETAIL_ALL) {
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif
 
@@ -1430,15 +1502,28 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
     }
 
     auto call = obj->make_call();
-    if (match.method_equals("open")) {
-      call.set_command_open();
-    } else if (match.method_equals("close")) {
-      call.set_command_close();
-    } else if (match.method_equals("stop")) {
-      call.set_command_stop();
-    } else if (match.method_equals("toggle")) {
-      call.set_command_toggle();
-    } else if (!match.method_equals("set")) {
+
+    // Lookup table for valve methods
+    static const struct {
+      const char *name;
+      valve::ValveCall &(valve::ValveCall::*action)();
+    } METHODS[] = {
+        {"open", &valve::ValveCall::set_command_open},
+        {"close", &valve::ValveCall::set_command_close},
+        {"stop", &valve::ValveCall::set_command_stop},
+        {"toggle", &valve::ValveCall::set_command_toggle},
+    };
+
+    bool found = false;
+    for (const auto &method : METHODS) {
+      if (match.method_equals(method.name)) {
+        (call.*method.action)();
+        found = true;
+        break;
+      }
+    }
+
+    if (!found && !match.method_equals("set")) {
       request->send(404);
       return;
     }
@@ -1464,17 +1549,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);
-
-    if (obj->get_traits().get_supports_position())
-      root["position"] = obj->position;
-    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, "valve", 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
 
@@ -1499,17 +1587,28 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
     auto call = obj->make_call();
     parse_string_param_(request, "code", call, &decltype(call)::set_code);
 
-    if (match.method_equals("disarm")) {
-      call.disarm();
-    } else if (match.method_equals("arm_away")) {
-      call.arm_away();
-    } else if (match.method_equals("arm_home")) {
-      call.arm_home();
-    } else if (match.method_equals("arm_night")) {
-      call.arm_night();
-    } else if (match.method_equals("arm_vacation")) {
-      call.arm_vacation();
-    } else {
+    // Lookup table for alarm control panel methods
+    static const struct {
+      const char *name;
+      alarm_control_panel::AlarmControlPanelCall &(alarm_control_panel::AlarmControlPanelCall::*action)();
+    } METHODS[] = {
+        {"disarm", &alarm_control_panel::AlarmControlPanelCall::disarm},
+        {"arm_away", &alarm_control_panel::AlarmControlPanelCall::arm_away},
+        {"arm_home", &alarm_control_panel::AlarmControlPanelCall::arm_home},
+        {"arm_night", &alarm_control_panel::AlarmControlPanelCall::arm_night},
+        {"arm_vacation", &alarm_control_panel::AlarmControlPanelCall::arm_vacation},
+    };
+
+    bool found = false;
+    for (const auto &method : METHODS) {
+      if (match.method_equals(method.name)) {
+        (call.*method.action)();
+        found = true;
+        break;
+      }
+    }
+
+    if (!found) {
       request->send(404);
       return;
     }
@@ -1533,14 +1632,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", 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 +1679,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;
-    }
-    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);
+  json::JsonBuilder builder;
+  JsonObject root = builder.root();
+
+  set_json_id(root, obj, "event", 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);
     }
-  });
+    root["device_class"] = obj->get_device_class_ref();
+    this->add_sorting_info_(root, obj);
+  }
+
+  return builder.serialize();
 }
 #endif
 
@@ -1637,25 +1742,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", 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
@@ -1664,24 +1774,24 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   const auto &url = request->url();
   const auto method = request->method();
 
-  // Simple URL checks
-  if (url == "/")
-    return true;
-
-#ifdef USE_ARDUINO
-  if (url == "/events")
-    return true;
+  // Static URL checks
+  static const char *const STATIC_URLS[] = {
+    "/",
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
+    "/events",
 #endif
-
 #ifdef USE_WEBSERVER_CSS_INCLUDE
-  if (url == "/0.css")
-    return true;
+    "/0.css",
 #endif
-
 #ifdef USE_WEBSERVER_JS_INCLUDE
-  if (url == "/0.js")
-    return true;
+    "/0.js",
 #endif
+  };
+
+  for (const auto &static_url : STATIC_URLS) {
+    if (url == static_url)
+      return true;
+  }
 
 #ifdef USE_WEBSERVER_PRIVATE_NETWORK_ACCESS
   if (method == HTTP_OPTIONS && request->hasHeader(HEADER_CORS_REQ_PNA))
@@ -1701,92 +1811,87 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   if (!is_get_or_post)
     return false;
 
-  // GET-only components
-  if (is_get) {
+  // Use lookup tables for domain checks
+  static const char *const GET_ONLY_DOMAINS[] = {
 #ifdef USE_SENSOR
-    if (match.domain_equals("sensor"))
-      return true;
+      "sensor",
 #endif
 #ifdef USE_BINARY_SENSOR
-    if (match.domain_equals("binary_sensor"))
-      return true;
+      "binary_sensor",
 #endif
 #ifdef USE_TEXT_SENSOR
-    if (match.domain_equals("text_sensor"))
-      return true;
+      "text_sensor",
 #endif
 #ifdef USE_EVENT
-    if (match.domain_equals("event"))
-      return true;
+      "event",
 #endif
-  }
+  };
 
-  // GET+POST components
-  if (is_get_or_post) {
+  static const char *const GET_POST_DOMAINS[] = {
 #ifdef USE_SWITCH
-    if (match.domain_equals("switch"))
-      return true;
+      "switch",
 #endif
 #ifdef USE_BUTTON
-    if (match.domain_equals("button"))
-      return true;
+      "button",
 #endif
 #ifdef USE_FAN
-    if (match.domain_equals("fan"))
-      return true;
+      "fan",
 #endif
 #ifdef USE_LIGHT
-    if (match.domain_equals("light"))
-      return true;
+      "light",
 #endif
 #ifdef USE_COVER
-    if (match.domain_equals("cover"))
-      return true;
+      "cover",
 #endif
 #ifdef USE_NUMBER
-    if (match.domain_equals("number"))
-      return true;
+      "number",
 #endif
 #ifdef USE_DATETIME_DATE
-    if (match.domain_equals("date"))
-      return true;
+      "date",
 #endif
 #ifdef USE_DATETIME_TIME
-    if (match.domain_equals("time"))
-      return true;
+      "time",
 #endif
 #ifdef USE_DATETIME_DATETIME
-    if (match.domain_equals("datetime"))
-      return true;
+      "datetime",
 #endif
 #ifdef USE_TEXT
-    if (match.domain_equals("text"))
-      return true;
+      "text",
 #endif
 #ifdef USE_SELECT
-    if (match.domain_equals("select"))
-      return true;
+      "select",
 #endif
 #ifdef USE_CLIMATE
-    if (match.domain_equals("climate"))
-      return true;
+      "climate",
 #endif
 #ifdef USE_LOCK
-    if (match.domain_equals("lock"))
-      return true;
+      "lock",
 #endif
 #ifdef USE_VALVE
-    if (match.domain_equals("valve"))
-      return true;
+      "valve",
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
-    if (match.domain_equals("alarm_control_panel"))
-      return true;
+      "alarm_control_panel",
 #endif
 #ifdef USE_UPDATE
-    if (match.domain_equals("update"))
-      return true;
+      "update",
 #endif
+  };
+
+  // Check GET-only domains
+  if (is_get) {
+    for (const auto &domain : GET_ONLY_DOMAINS) {
+      if (match.domain_equals(domain))
+        return true;
+    }
+  }
+
+  // Check GET+POST domains
+  if (is_get_or_post) {
+    for (const auto &domain : GET_POST_DOMAINS) {
+      if (match.domain_equals(domain))
+        return true;
+    }
   }
 
   return false;
@@ -1800,7 +1905,7 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
     return;
   }
 
-#ifdef USE_ARDUINO
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
   if (url == "/events") {
     this->events_.add_new_client(this, request);
     return;