Merge branch 'memory_api' into memory_api_action_chaining_const_ref

.ai/instructions.md

@@ -51,79 +51,7 @@ This document provides essential context for AI models interacting with this pro
 
 *   **Naming Conventions:**
     *   **Python:** Follows PEP 8. Use clear, descriptive names following snake_case.
-    *   **C++:** Follows the Google C++ Style Guide with these specifics (following clang-tidy conventions):
-        - Function, method, and variable names: `lower_snake_case`
-        - Class/struct/enum names: `UpperCamelCase`
-        - Top-level constants (global/namespace scope): `UPPER_SNAKE_CASE`
-        - Function-local constants: `lower_snake_case`
-        - Protected/private fields: `lower_snake_case_with_trailing_underscore_`
-        - Favor descriptive names over abbreviations
-
-*   **C++ Field Visibility:**
-    *   **Prefer `protected`:** Use `protected` for most class fields to enable extensibility and testing. Fields should be `lower_snake_case_with_trailing_underscore_`.
-    *   **Use `private` for safety-critical cases:** Use `private` visibility when direct field access could introduce bugs or violate invariants:
-        1. **Pointer lifetime issues:** When setters validate and store pointers from known lists to prevent dangling references.
-           ```cpp
-           // Helper to find matching string in vector and return its pointer
-           inline const char *vector_find(const std::vector<const char *> &vec, const char *value) {
-             for (const char *item : vec) {
-               if (strcmp(item, value) == 0)
-                 return item;
-             }
-             return nullptr;
-           }
-
-           class ClimateDevice {
-            public:
-             void set_custom_fan_modes(std::initializer_list<const char *> modes) {
-               this->custom_fan_modes_ = modes;
-               this->active_custom_fan_mode_ = nullptr;  // Reset when modes change
-             }
-             bool set_custom_fan_mode(const char *mode) {
-               // Find mode in supported list and store that pointer (not the input pointer)
-               const char *validated_mode = vector_find(this->custom_fan_modes_, mode);
-               if (validated_mode != nullptr) {
-                 this->active_custom_fan_mode_ = validated_mode;
-                 return true;
-               }
-               return false;
-             }
-            private:
-             std::vector<const char *> custom_fan_modes_;  // Pointers to string literals in flash
-             const char *active_custom_fan_mode_{nullptr};  // Must point to entry in custom_fan_modes_
-           };
-           ```
-        2. **Invariant coupling:** When multiple fields must remain synchronized to prevent buffer overflows or data corruption.
-           ```cpp
-           class Buffer {
-            public:
-             void resize(size_t new_size) {
-               auto new_data = std::make_unique<uint8_t[]>(new_size);
-               if (this->data_) {
-                 std::memcpy(new_data.get(), this->data_.get(), std::min(this->size_, new_size));
-               }
-               this->data_ = std::move(new_data);
-               this->size_ = new_size;  // Must stay in sync with data_
-             }
-            private:
-             std::unique_ptr<uint8_t[]> data_;
-             size_t size_{0};  // Must match allocated size of data_
-           };
-           ```
-        3. **Resource management:** When setters perform cleanup or registration operations that derived classes might skip.
-    *   **Provide `protected` accessor methods:** When derived classes need controlled access to `private` members.
-
-*   **C++ Preprocessor Directives:**
-    *   **Avoid `#define` for constants:** Using `#define` for constants is discouraged and should be replaced with `const` variables or enums.
-    *   **Use `#define` only for:**
-        - Conditional compilation (`#ifdef`, `#ifndef`)
-        - Compile-time sizes calculated during Python code generation (e.g., configuring `std::array` or `StaticVector` dimensions via `cg.add_define()`)
-
-*   **C++ Additional Conventions:**
-    *   **Member access:** Prefix all class member access with `this->` (e.g., `this->value_` not `value_`)
-    *   **Indentation:** Use spaces (two per indentation level), not tabs
-    *   **Type aliases:** Prefer `using type_t = int;` over `typedef int type_t;`
-    *   **Line length:** Wrap lines at no more than 120 characters
+    *   **C++:** Follows the Google C++ Style Guide.
 
 *   **Component Structure:**
     *   **Standard Files:**
@@ -172,7 +100,8 @@ This document provides essential context for AI models interacting with this pro
 
     *   **C++ Class Pattern:**
         ```cpp
-        namespace esphome::my_component {
+        namespace esphome {
+        namespace my_component {
 
         class MyComponent : public Component {
          public:
@@ -188,7 +117,8 @@ This document provides essential context for AI models interacting with this pro
           int param_{0};
         };
 
-        }  // namespace esphome::my_component
+        }  // namespace my_component
+        }  // namespace esphome
         ```
 
     *   **Common Component Examples:**
@@ -438,45 +368,3 @@ This document provides essential context for AI models interacting with this pro
     *   **Python:** When adding a new Python dependency, add it to the appropriate `requirements*.txt` file and `pyproject.toml`.
     *   **C++ / PlatformIO:** When adding a new C++ dependency, add it to `platformio.ini` and use `cg.add_library`.
     *   **Build Flags:** Use `cg.add_build_flag(...)` to add compiler flags.
-
-## 8. Public API and Breaking Changes
-
-*   **Public C++ API:**
-    *   **Components**: Only documented features at [esphome.io](https://esphome.io) are public API. Undocumented `public` members are internal.
-    *   **Core/Base Classes** (`esphome/core/`, `Component`, `Sensor`, etc.): All `public` members are public API.
-    *   **Components with Global Accessors** (`global_api_server`, etc.): All `public` members are public API (except config setters).
-
-*   **Public Python API:**
-    *   All documented configuration options at [esphome.io](https://esphome.io) are public API.
-    *   Python code in `esphome/core/` actively used by existing core components is considered stable API.
-    *   Other Python code is internal unless explicitly documented for external component use.
-
-*   **Breaking Changes Policy:**
-    *   Aim for **6-month deprecation window** when possible
-    *   Clean breaks allowed for: signature changes, deep refactorings, resource constraints
-    *   Must document migration path in PR description (generates release notes)
-    *   Blog post required for core/base class changes or significant architectural changes
-    *   Full details: https://developers.esphome.io/contributing/code/#public-api-and-breaking-changes
-
-*   **Breaking Change Checklist:**
-    - [ ] Clear justification (RAM/flash savings, architectural improvement)
-    - [ ] Explored non-breaking alternatives
-    - [ ] Added deprecation warnings if possible (use `ESPDEPRECATED` macro for C++)
-    - [ ] Documented migration path in PR description with before/after examples
-    - [ ] Updated all internal usage and esphome-docs
-    - [ ] Tested backward compatibility during deprecation period
-
-*   **Deprecation Pattern (C++):**
-    ```cpp
-    // Remove before 2026.6.0
-    ESPDEPRECATED("Use new_method() instead. Removed in 2026.6.0", "2025.12.0")
-    void old_method() { this->new_method(); }
-    ```
-
-*   **Deprecation Pattern (Python):**
-    ```python
-    # Remove before 2026.6.0
-    if CONF_OLD_KEY in config:
-        _LOGGER.warning(f"'{CONF_OLD_KEY}' deprecated, use '{CONF_NEW_KEY}'. Removed in 2026.6.0")
-        config[CONF_NEW_KEY] = config.pop(CONF_OLD_KEY)  # Auto-migrate
-    ```

.github/workflows/codeowner-review-request.yml

@@ -21,7 +21,7 @@ permissions:
 jobs:
   request-codeowner-reviews:
     name: Run
-    if: ${{ github.repository == 'esphome/esphome' && !github.event.pull_request.draft }}
+    if: ${{ !github.event.pull_request.draft }}
     runs-on: ubuntu-latest
     steps:
       - name: Request reviews from component codeowners

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           category: "/language:${{matrix.language}}"

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.5
+    rev: v0.14.3
     hooks:
       # Run the linter.
       - id: ruff

CODEOWNERS

@@ -181,7 +181,7 @@ esphome/components/gdk101/* @Szewcson
 esphome/components/gl_r01_i2c/* @pkejval
 esphome/components/globals/* @esphome/core
 esphome/components/gp2y1010au0f/* @zry98
-esphome/components/gp8403/* @jesserockz @sebydocky
+esphome/components/gp8403/* @jesserockz
 esphome/components/gpio/* @esphome/core
 esphome/components/gpio/one_wire/* @ssieb
 esphome/components/gps/* @coogle @ximex
@@ -206,7 +206,6 @@ esphome/components/hdc2010/* @optimusprimespace @ssieb
 esphome/components/he60r/* @clydebarrow
 esphome/components/heatpumpir/* @rob-deutsch
 esphome/components/hitachi_ac424/* @sourabhjaiswal
-esphome/components/hlk_fm22x/* @OnFreund
 esphome/components/hm3301/* @freekode
 esphome/components/hmac_md5/* @dwmw2
 esphome/components/homeassistant/* @esphome/core @OttoWinter
@@ -291,7 +290,6 @@ esphome/components/mcp23x17_base/* @jesserockz
 esphome/components/mcp23xxx_base/* @jesserockz
 esphome/components/mcp2515/* @danielschramm @mvturnho
 esphome/components/mcp3204/* @rsumner
-esphome/components/mcp3221/* @philippderdiedas
 esphome/components/mcp4461/* @p1ngb4ck
 esphome/components/mcp4728/* @berfenger
 esphome/components/mcp47a1/* @jesserockz
@@ -396,7 +394,6 @@ esphome/components/rpi_dpi_rgb/* @clydebarrow
 esphome/components/rtl87xx/* @kuba2k2
 esphome/components/rtttl/* @glmnet
 esphome/components/runtime_stats/* @bdraco
-esphome/components/rx8130/* @beormund
 esphome/components/safe_mode/* @jsuanet @kbx81 @paulmonigatti
 esphome/components/scd4x/* @martgras @sjtrny
 esphome/components/script/* @esphome/core

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2025.12.0-dev
+PROJECT_NUMBER         = 2025.11.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/analyze_memory/cli.py

@@ -16,11 +16,6 @@ from . import (
 class MemoryAnalyzerCLI(MemoryAnalyzer):
     """Memory analyzer with CLI-specific report generation."""
 
-    # Symbol size threshold for detailed analysis
-    SYMBOL_SIZE_THRESHOLD: int = (
-        100  # Show symbols larger than this in detailed analysis
-    )
-
     # Column width constants
     COL_COMPONENT: int = 29
     COL_FLASH_TEXT: int = 14
@@ -197,21 +192,14 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                     f"{len(symbols):>{self.COL_CORE_COUNT}} | {percentage:>{self.COL_CORE_PERCENT - 1}.1f}%"
                 )
 
-            # All core symbols above threshold
+            # Top 15 largest core symbols
             lines.append("")
+            lines.append(f"Top 15 Largest {_COMPONENT_CORE} Symbols:")
             sorted_core_symbols = sorted(
                 self._esphome_core_symbols, key=lambda x: x[2], reverse=True
             )
-            large_core_symbols = [
-                (symbol, demangled, size)
-                for symbol, demangled, size in sorted_core_symbols
-                if size > self.SYMBOL_SIZE_THRESHOLD
-            ]
 
-            lines.append(
-                f"{_COMPONENT_CORE} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_core_symbols)} symbols):"
-            )
-            for i, (symbol, demangled, size) in enumerate(large_core_symbols):
+            for i, (symbol, demangled, size) in enumerate(sorted_core_symbols[:15]):
                 lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
             lines.append("=" * self.TABLE_WIDTH)
@@ -281,15 +269,13 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 lines.append(f"Total size: {comp_mem.flash_total:,} B")
                 lines.append("")
 
-                # Show all symbols above threshold for better visibility
+                # Show all symbols > 100 bytes for better visibility
                 large_symbols = [
-                    (sym, dem, size)
-                    for sym, dem, size in sorted_symbols
-                    if size > self.SYMBOL_SIZE_THRESHOLD
+                    (sym, dem, size) for sym, dem, size in sorted_symbols if size > 100
                 ]
 
                 lines.append(
-                    f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_symbols)} symbols):"
+                    f"{comp_name} Symbols > 100 B ({len(large_symbols)} symbols):"
                 )
                 for i, (symbol, demangled, size) in enumerate(large_symbols):
                     lines.append(f"{i + 1}. {demangled} ({size:,} B)")

esphome/components/alarm_control_panel/alarm_control_panel.cpp

@@ -1,9 +1,7 @@
-#include "alarm_control_panel.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
-
 #include <utility>
 
+#include "alarm_control_panel.h"
+
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -36,9 +34,6 @@ void AlarmControlPanel::publish_state(AlarmControlPanelState state) {
              LOG_STR_ARG(alarm_control_panel_state_to_string(prev_state)));
     this->current_state_ = state;
     this->state_callback_.call();
-#if defined(USE_ALARM_CONTROL_PANEL) && defined(USE_CONTROLLER_REGISTRY)
-    ControllerRegistry::notify_alarm_control_panel_update(this);
-#endif
     if (state == ACP_STATE_TRIGGERED) {
       this->triggered_callback_.call();
     } else if (state == ACP_STATE_ARMING) {

esphome/components/api/__init__.py

@@ -227,7 +227,6 @@ CONFIG_SCHEMA = cv.All(
                 esp32=8,  # More RAM, can buffer more
                 rp2040=5,  # Limited RAM
                 bk72xx=8,  # Moderate RAM
-                nrf52=8,  # Moderate RAM
                 rtl87xx=8,  # Moderate RAM
                 host=16,  # Abundant resources
                 ln882x=8,  # Moderate RAM
@@ -245,9 +244,6 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    # Track controller registration for StaticVector sizing
-    CORE.register_controller()
-
     cg.add(var.set_port(config[CONF_PORT]))
     if config[CONF_PASSWORD]:
         cg.add_define("USE_API_PASSWORD")

esphome/components/api/api.proto

@@ -2147,7 +2147,7 @@ message ListEntitiesEventResponse {
   EntityCategory entity_category = 7;
   string device_class = 8;
 
-  repeated string event_types = 9 [(container_pointer_no_template) = "FixedVector<const char *>"];
+  repeated string event_types = 9;
   uint32 device_id = 10 [(field_ifdef) = "USE_DEVICES"];
 }
 message EventResponse {

esphome/components/api/api_connection.cpp

@@ -476,9 +476,8 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
   auto *light = static_cast<light::LightState *>(entity);
   ListEntitiesLightResponse msg;
   auto traits = light->get_traits();
-  auto supported_modes = traits.get_supported_color_modes();
   // Pass pointer to ColorModeMask so the iterator can encode actual ColorMode enum values
-  msg.supported_color_modes = &supported_modes;
+  msg.supported_color_modes = &traits.get_supported_color_modes();
   if (traits.supports_color_capability(light::ColorCapability::COLOR_TEMPERATURE) ||
       traits.supports_color_capability(light::ColorCapability::COLD_WARM_WHITE)) {
     msg.min_mireds = traits.get_min_mireds();
@@ -1295,11 +1294,11 @@ void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRe
 #endif
 
 #ifdef USE_EVENT
-void APIConnection::send_event(event::Event *event, const char *event_type) {
-  this->send_message_smart_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
-                            EventResponse::ESTIMATED_SIZE);
+void APIConnection::send_event(event::Event *event, const std::string &event_type) {
+  this->schedule_message_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
+                          EventResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_event_response(event::Event *event, const char *event_type, APIConnection *conn,
+uint16_t APIConnection::try_send_event_response(event::Event *event, const std::string &event_type, APIConnection *conn,
                                                 uint32_t remaining_size, bool is_single) {
   EventResponse resp;
   resp.set_event_type(StringRef(event_type));
@@ -1311,7 +1310,8 @@ uint16_t APIConnection::try_send_event_info(EntityBase *entity, APIConnection *c
   auto *event = static_cast<event::Event *>(entity);
   ListEntitiesEventResponse msg;
   msg.set_device_class(event->get_device_class_ref());
-  msg.event_types = &event->get_event_types();
+  for (const auto &event_type : event->get_event_types())
+    msg.event_types.push_back(event_type);
   return fill_and_encode_entity_info(event, msg, ListEntitiesEventResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
@@ -1468,8 +1468,6 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
   static constexpr auto MANUFACTURER = StringRef::from_lit("Beken");
 #elif defined(USE_LN882X)
   static constexpr auto MANUFACTURER = StringRef::from_lit("Lightning");
-#elif defined(USE_NRF52)
-  static constexpr auto MANUFACTURER = StringRef::from_lit("Nordic Semiconductor");
 #elif defined(USE_RTL87XX)
   static constexpr auto MANUFACTURER = StringRef::from_lit("Realtek");
 #elif defined(USE_HOST)
@@ -1651,7 +1649,9 @@ void APIConnection::DeferredBatch::add_item(EntityBase *entity, MessageCreator c
   // O(n) but optimized for RAM and not performance.
   for (auto &item : items) {
     if (item.entity == entity && item.message_type == message_type) {
-      // Replace with new creator
+      // Clean up old creator before replacing
+      item.creator.cleanup(message_type);
+      // Move assign the new creator
       item.creator = std::move(creator);
       return;
     }
@@ -1821,7 +1821,7 @@ void APIConnection::process_batch_() {
 
   // Handle remaining items more efficiently
   if (items_processed < this->deferred_batch_.size()) {
-    // Remove processed items from the beginning
+    // Remove processed items from the beginning with proper cleanup
     this->deferred_batch_.remove_front(items_processed);
     // Reschedule for remaining items
     this->schedule_batch_();
@@ -1834,10 +1834,10 @@ void APIConnection::process_batch_() {
 uint16_t APIConnection::MessageCreator::operator()(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                    bool is_single, uint8_t message_type) const {
 #ifdef USE_EVENT
-  // Special case: EventResponse uses const char * pointer
+  // Special case: EventResponse uses string pointer
   if (message_type == EventResponse::MESSAGE_TYPE) {
     auto *e = static_cast<event::Event *>(entity);
-    return APIConnection::try_send_event_response(e, data_.const_char_ptr, conn, remaining_size, is_single);
+    return APIConnection::try_send_event_response(e, *data_.string_ptr, conn, remaining_size, is_single);
   }
 #endif
 

esphome/components/api/api_connection.h

@@ -177,7 +177,7 @@ class APIConnection final : public APIServerConnection {
 #endif
 
 #ifdef USE_EVENT
-  void send_event(event::Event *event, const char *event_type);
+  void send_event(event::Event *event, const std::string &event_type);
 #endif
 
 #ifdef USE_UPDATE
@@ -450,7 +450,7 @@ class APIConnection final : public APIServerConnection {
                                                     bool is_single);
 #endif
 #ifdef USE_EVENT
-  static uint16_t try_send_event_response(event::Event *event, const char *event_type, APIConnection *conn,
+  static uint16_t try_send_event_response(event::Event *event, const std::string &event_type, APIConnection *conn,
                                           uint32_t remaining_size, bool is_single);
   static uint16_t try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
@@ -508,8 +508,10 @@ class APIConnection final : public APIServerConnection {
     // Constructor for function pointer
     MessageCreator(MessageCreatorPtr ptr) { data_.function_ptr = ptr; }
 
-    // Constructor for const char * (Event types - no allocation needed)
-    explicit MessageCreator(const char *str_value) { data_.const_char_ptr = str_value; }
+    // Constructor for string state capture
+    explicit MessageCreator(const std::string &str_value) { data_.string_ptr = new std::string(str_value); }
+
+    // No destructor - cleanup must be called explicitly with message_type
 
     // Delete copy operations - MessageCreator should only be moved
     MessageCreator(const MessageCreator &other) = delete;
@@ -521,6 +523,8 @@ class APIConnection final : public APIServerConnection {
     // Move assignment
     MessageCreator &operator=(MessageCreator &&other) noexcept {
       if (this != &other) {
+        // IMPORTANT: Caller must ensure cleanup() was called if this contains a string!
+        // In our usage, this happens in add_item() deduplication and vector::erase()
         data_ = other.data_;
         other.data_.function_ptr = nullptr;
       }
@@ -531,10 +535,20 @@ class APIConnection final : public APIServerConnection {
     uint16_t operator()(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single,
                         uint8_t message_type) const;
 
+    // Manual cleanup method - must be called before destruction for string types
+    void cleanup(uint8_t message_type) {
+#ifdef USE_EVENT
+      if (message_type == EventResponse::MESSAGE_TYPE && data_.string_ptr != nullptr) {
+        delete data_.string_ptr;
+        data_.string_ptr = nullptr;
+      }
+#endif
+    }
+
    private:
     union Data {
       MessageCreatorPtr function_ptr;
-      const char *const_char_ptr;
+      std::string *string_ptr;
     } data_;  // 4 bytes on 32-bit, 8 bytes on 64-bit - same as before
   };
 
@@ -554,24 +568,42 @@ class APIConnection final : public APIServerConnection {
     std::vector<BatchItem> items;
     uint32_t batch_start_time{0};
 
+   private:
+    // Helper to cleanup items from the beginning
+    void cleanup_items_(size_t count) {
+      for (size_t i = 0; i < count; i++) {
+        items[i].creator.cleanup(items[i].message_type);
+      }
+    }
+
+   public:
     DeferredBatch() {
       // Pre-allocate capacity for typical batch sizes to avoid reallocation
       items.reserve(8);
     }
 
+    ~DeferredBatch() {
+      // Ensure cleanup of any remaining items
+      clear();
+    }
+
     // Add item to the batch
     void add_item(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size);
     // Add item to the front of the batch (for high priority messages like ping)
     void add_item_front(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size);
 
-    // Clear all items
+    // Clear all items with proper cleanup
     void clear() {
+      cleanup_items_(items.size());
       items.clear();
       batch_start_time = 0;
     }
 
-    // Remove processed items from the front
-    void remove_front(size_t count) { items.erase(items.begin(), items.begin() + count); }
+    // Remove processed items from the front with proper cleanup
+    void remove_front(size_t count) {
+      cleanup_items_(count);
+      items.erase(items.begin(), items.begin() + count);
+    }
 
     bool empty() const { return items.empty(); }
     size_t size() const { return items.size(); }
@@ -650,30 +682,21 @@ class APIConnection final : public APIServerConnection {
   }
 #endif
 
-  // Helper to check if a message type should bypass batching
-  // Returns true if:
-  // 1. It's an UpdateStateResponse (always send immediately to handle cases where
-  //    the main loop is blocked, e.g., during OTA updates)
-  // 2. It's an EventResponse (events are edge-triggered - every occurrence matters)
-  // 3. OR: User has opted into immediate sending (should_try_send_immediately = true
-  //    AND batch_delay = 0)
-  inline bool should_send_immediately_(uint8_t message_type) const {
-    return (
-#ifdef USE_UPDATE
-        message_type == UpdateStateResponse::MESSAGE_TYPE ||
-#endif
-#ifdef USE_EVENT
-        message_type == EventResponse::MESSAGE_TYPE ||
-#endif
-        (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0));
-  }
-
   // Helper method to send a message either immediately or via batching
-  // Tries immediate send if should_send_immediately_() returns true and buffer has space
-  // Falls back to batching if immediate send fails or isn't applicable
   bool send_message_smart_(EntityBase *entity, MessageCreatorPtr creator, uint8_t message_type,
                            uint8_t estimated_size) {
-    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
+    // Try to send immediately if:
+    // 1. It's an UpdateStateResponse (always send immediately to handle cases where
+    //    the main loop is blocked, e.g., during OTA updates)
+    // 2. OR: We should try to send immediately (should_try_send_immediately = true)
+    //        AND Batch delay is 0 (user has opted in to immediate sending)
+    // 3. AND: Buffer has space available
+    if ((
+#ifdef USE_UPDATE
+            message_type == UpdateStateResponse::MESSAGE_TYPE ||
+#endif
+            (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0)) &&
+        this->helper_->can_write_without_blocking()) {
       // Now actually encode and send
       if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true) &&
           this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
@@ -691,27 +714,6 @@ class APIConnection final : public APIServerConnection {
     return this->schedule_message_(entity, creator, message_type, estimated_size);
   }
 
-  // Overload for MessageCreator (used by events which need to capture event_type)
-  bool send_message_smart_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
-    // Try to send immediately if message type should bypass batching and buffer has space
-    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
-      // Now actually encode and send
-      if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true, message_type) &&
-          this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
-#ifdef HAS_PROTO_MESSAGE_DUMP
-        // Log the message in verbose mode
-        this->log_proto_message_(entity, creator, message_type);
-#endif
-        return true;
-      }
-
-      // If immediate send failed, fall through to batching
-    }
-
-    // Fall back to scheduled batching
-    return this->schedule_message_(entity, std::move(creator), message_type, estimated_size);
-  }
-
   // Helper function to schedule a deferred message with known message type
   bool schedule_message_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
     this->deferred_batch_.add_item(entity, std::move(creator), message_type, estimated_size);

esphome/components/api/api_pb2.cpp

@@ -2877,8 +2877,8 @@ void ListEntitiesEventResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_uint32(7, static_cast<uint32_t>(this->entity_category));
   buffer.encode_string(8, this->device_class_ref_);
-  for (const char *it : *this->event_types) {
-    buffer.encode_string(9, it, strlen(it), true);
+  for (auto &it : this->event_types) {
+    buffer.encode_string(9, it, true);
   }
 #ifdef USE_DEVICES
   buffer.encode_uint32(10, this->device_id);
@@ -2894,9 +2894,9 @@ void ListEntitiesEventResponse::calculate_size(ProtoSize &size) const {
   size.add_bool(1, this->disabled_by_default);
   size.add_uint32(1, static_cast<uint32_t>(this->entity_category));
   size.add_length(1, this->device_class_ref_.size());
-  if (!this->event_types->empty()) {
-    for (const char *it : *this->event_types) {
-      size.add_length_force(1, strlen(it));
+  if (!this->event_types.empty()) {
+    for (const auto &it : this->event_types) {
+      size.add_length_force(1, it.size());
     }
   }
 #ifdef USE_DEVICES

esphome/components/api/api_pb2.h

@@ -2788,7 +2788,7 @@ class ListEntitiesEventResponse final : public InfoResponseProtoMessage {
 #endif
   StringRef device_class_ref_{};
   void set_device_class(const StringRef &ref) { this->device_class_ref_ = ref; }
-  const FixedVector<const char *> *event_types{};
+  std::vector<std::string> event_types{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/api/api_pb2_dump.cpp

@@ -2053,7 +2053,7 @@ void ListEntitiesEventResponse::dump_to(std::string &out) const {
   dump_field(out, "disabled_by_default", this->disabled_by_default);
   dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
   dump_field(out, "device_class", this->device_class_ref_);
-  for (const auto &it : *this->event_types) {
+  for (const auto &it : this->event_types) {
     dump_field(out, "event_types", it, 4);
   }
 #ifdef USE_DEVICES

esphome/components/api/api_server.cpp

@@ -5,7 +5,6 @@
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
@@ -35,7 +34,7 @@ APIServer::APIServer() {
 }
 
 void APIServer::setup() {
-  ControllerRegistry::register_controller(this);
+  this->setup_controller();
 
 #ifdef USE_API_NOISE
   uint32_t hash = 88491486UL;
@@ -270,7 +269,7 @@ bool APIServer::check_password(const uint8_t *password_data, size_t password_len
 
 void APIServer::handle_disconnect(APIConnection *conn) {}
 
-// Macro for controller update dispatch
+// Macro for entities without extra parameters
 #define API_DISPATCH_UPDATE(entity_type, entity_name) \
   void APIServer::on_##entity_name##_update(entity_type *obj) { /* NOLINT(bugprone-macro-parentheses) */ \
     if (obj->is_internal()) \
@@ -279,6 +278,15 @@ void APIServer::handle_disconnect(APIConnection *conn) {}
       c->send_##entity_name##_state(obj); \
   }
 
+// Macro for entities with extra parameters (but parameters not used in send)
+#define API_DISPATCH_UPDATE_IGNORE_PARAMS(entity_type, entity_name, ...) \
+  void APIServer::on_##entity_name##_update(entity_type *obj, __VA_ARGS__) { /* NOLINT(bugprone-macro-parentheses) */ \
+    if (obj->is_internal()) \
+      return; \
+    for (auto &c : this->clients_) \
+      c->send_##entity_name##_state(obj); \
+  }
+
 #ifdef USE_BINARY_SENSOR
 API_DISPATCH_UPDATE(binary_sensor::BinarySensor, binary_sensor)
 #endif
@@ -296,15 +304,15 @@ API_DISPATCH_UPDATE(light::LightState, light)
 #endif
 
 #ifdef USE_SENSOR
-API_DISPATCH_UPDATE(sensor::Sensor, sensor)
+API_DISPATCH_UPDATE_IGNORE_PARAMS(sensor::Sensor, sensor, float state)
 #endif
 
 #ifdef USE_SWITCH
-API_DISPATCH_UPDATE(switch_::Switch, switch)
+API_DISPATCH_UPDATE_IGNORE_PARAMS(switch_::Switch, switch, bool state)
 #endif
 
 #ifdef USE_TEXT_SENSOR
-API_DISPATCH_UPDATE(text_sensor::TextSensor, text_sensor)
+API_DISPATCH_UPDATE_IGNORE_PARAMS(text_sensor::TextSensor, text_sensor, const std::string &state)
 #endif
 
 #ifdef USE_CLIMATE
@@ -312,7 +320,7 @@ API_DISPATCH_UPDATE(climate::Climate, climate)
 #endif
 
 #ifdef USE_NUMBER
-API_DISPATCH_UPDATE(number::Number, number)
+API_DISPATCH_UPDATE_IGNORE_PARAMS(number::Number, number, float state)
 #endif
 
 #ifdef USE_DATETIME_DATE
@@ -328,11 +336,11 @@ API_DISPATCH_UPDATE(datetime::DateTimeEntity, datetime)
 #endif
 
 #ifdef USE_TEXT
-API_DISPATCH_UPDATE(text::Text, text)
+API_DISPATCH_UPDATE_IGNORE_PARAMS(text::Text, text, const std::string &state)
 #endif
 
 #ifdef USE_SELECT
-API_DISPATCH_UPDATE(select::Select, select)
+API_DISPATCH_UPDATE_IGNORE_PARAMS(select::Select, select, const std::string &state, size_t index)
 #endif
 
 #ifdef USE_LOCK
@@ -348,13 +356,12 @@ API_DISPATCH_UPDATE(media_player::MediaPlayer, media_player)
 #endif
 
 #ifdef USE_EVENT
-// Event is a special case - unlike other entities with simple state fields,
-// events store their state in a member accessed via obj->get_last_event_type()
-void APIServer::on_event(event::Event *obj) {
+// Event is a special case - it's the only entity that passes extra parameters to the send method
+void APIServer::on_event(event::Event *obj, const std::string &event_type) {
   if (obj->is_internal())
     return;
   for (auto &c : this->clients_)
-    c->send_event(obj, obj->get_last_event_type());
+    c->send_event(obj, event_type);
 }
 #endif
 

esphome/components/api/api_server.h

@@ -72,19 +72,19 @@ class APIServer : public Component, public Controller {
   void on_light_update(light::LightState *obj) override;
 #endif
 #ifdef USE_SENSOR
-  void on_sensor_update(sensor::Sensor *obj) override;
+  void on_sensor_update(sensor::Sensor *obj, float state) override;
 #endif
 #ifdef USE_SWITCH
-  void on_switch_update(switch_::Switch *obj) override;
+  void on_switch_update(switch_::Switch *obj, bool state) override;
 #endif
 #ifdef USE_TEXT_SENSOR
-  void on_text_sensor_update(text_sensor::TextSensor *obj) override;
+  void on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) override;
 #endif
 #ifdef USE_CLIMATE
   void on_climate_update(climate::Climate *obj) override;
 #endif
 #ifdef USE_NUMBER
-  void on_number_update(number::Number *obj) override;
+  void on_number_update(number::Number *obj, float state) override;
 #endif
 #ifdef USE_DATETIME_DATE
   void on_date_update(datetime::DateEntity *obj) override;
@@ -96,10 +96,10 @@ class APIServer : public Component, public Controller {
   void on_datetime_update(datetime::DateTimeEntity *obj) override;
 #endif
 #ifdef USE_TEXT
-  void on_text_update(text::Text *obj) override;
+  void on_text_update(text::Text *obj, const std::string &state) override;
 #endif
 #ifdef USE_SELECT
-  void on_select_update(select::Select *obj) override;
+  void on_select_update(select::Select *obj, const std::string &state, size_t index) override;
 #endif
 #ifdef USE_LOCK
   void on_lock_update(lock::Lock *obj) override;
@@ -141,7 +141,7 @@ class APIServer : public Component, public Controller {
   void on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj) override;
 #endif
 #ifdef USE_EVENT
-  void on_event(event::Event *obj) override;
+  void on_event(event::Event *obj, const std::string &event_type) override;
 #endif
 #ifdef USE_UPDATE
   void on_update(update::UpdateEntity *obj) override;

esphome/components/api/custom_api_device.h

@@ -9,11 +9,11 @@
 namespace esphome::api {
 
 #ifdef USE_API_SERVICES
-template<typename T, typename... Ts> class CustomAPIDeviceService : public UserServiceDynamic<Ts...> {
+template<typename T, typename... Ts> class CustomAPIDeviceService : public UserServiceBase<Ts...> {
  public:
   CustomAPIDeviceService(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names, T *obj,
                          void (T::*callback)(Ts...))
-      : UserServiceDynamic<Ts...>(name, arg_names), obj_(obj), callback_(callback) {}
+      : UserServiceBase<Ts...>(name, arg_names), obj_(obj), callback_(callback) {}
 
  protected:
   void execute(Ts... x) override { (this->obj_->*this->callback_)(x...); }  // NOLINT

esphome/components/api/user_services.h

@@ -23,58 +23,11 @@ template<typename T> T get_execute_arg_value(const ExecuteServiceArgument &arg);
 
 template<typename T> enums::ServiceArgType to_service_arg_type();
 
-// Base class for YAML-defined services (most common case)
-// Stores only pointers to string literals in flash - no heap allocation
 template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
  public:
-  UserServiceBase(const char *name, const std::array<const char *, sizeof...(Ts)> &arg_names)
-      : name_(name), arg_names_(arg_names) {
-    this->key_ = fnv1_hash(name);
-  }
-
-  ListEntitiesServicesResponse encode_list_service_response() override {
-    ListEntitiesServicesResponse msg;
-    msg.set_name(StringRef(this->name_));
-    msg.key = this->key_;
-    std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
-    msg.args.init(sizeof...(Ts));
-    for (size_t i = 0; i < sizeof...(Ts); i++) {
-      auto &arg = msg.args.emplace_back();
-      arg.type = arg_types[i];
-      arg.set_name(StringRef(this->arg_names_[i]));
-    }
-    return msg;
-  }
-
-  bool execute_service(const ExecuteServiceRequest &req) override {
-    if (req.key != this->key_)
-      return false;
-    if (req.args.size() != sizeof...(Ts))
-      return false;
-    this->execute_(req.args, std::make_index_sequence<sizeof...(Ts)>{});
-    return true;
-  }
-
- protected:
-  virtual void execute(Ts... x) = 0;
-  template<typename ArgsContainer, size_t... S>
-  void execute_(const ArgsContainer &args, std::index_sequence<S...> type) {
-    this->execute((get_execute_arg_value<Ts>(args[S]))...);
-  }
-
-  // Pointers to string literals in flash - no heap allocation
-  const char *name_;
-  std::array<const char *, sizeof...(Ts)> arg_names_;
-  uint32_t key_{0};
-};
-
-// Separate class for custom_api_device services (rare case)
-// Stores copies of runtime-generated names
-template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor {
- public:
-  UserServiceDynamic(std::string name, const std::array<std::string, sizeof...(Ts)> &arg_names)
+  UserServiceBase(std::string name, const std::array<std::string, sizeof...(Ts)> &arg_names)
       : name_(std::move(name)), arg_names_(arg_names) {
-    this->key_ = fnv1_hash(this->name_.c_str());
+    this->key_ = fnv1_hash(this->name_);
   }
 
   ListEntitiesServicesResponse encode_list_service_response() override {
@@ -94,29 +47,26 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
   bool execute_service(const ExecuteServiceRequest &req) override {
     if (req.key != this->key_)
       return false;
-    if (req.args.size() != sizeof...(Ts))
+    if (req.args.size() != this->arg_names_.size())
       return false;
-    this->execute_(req.args, std::make_index_sequence<sizeof...(Ts)>{});
+    this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
     return true;
   }
 
  protected:
   virtual void execute(Ts... x) = 0;
-  template<typename ArgsContainer, size_t... S>
-  void execute_(const ArgsContainer &args, std::index_sequence<S...> type) {
+  template<typename ArgsContainer, int... S> void execute_(const ArgsContainer &args, seq<S...> type) {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 
-  // Heap-allocated strings for runtime-generated names
   std::string name_;
-  std::array<std::string, sizeof...(Ts)> arg_names_;
   uint32_t key_{0};
+  std::array<std::string, sizeof...(Ts)> arg_names_;
 };
 
 template<typename... Ts> class UserServiceTrigger : public UserServiceBase<Ts...>, public Trigger<Ts...> {
  public:
-  // Constructor for static names (YAML-defined services - used by code generator)
-  UserServiceTrigger(const char *name, const std::array<const char *, sizeof...(Ts)> &arg_names)
+  UserServiceTrigger(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names)
       : UserServiceBase<Ts...>(name, arg_names) {}
 
  protected:

esphome/components/bh1750/bh1750.cpp

@@ -1,8 +1,8 @@
 #include "bh1750.h"
 #include "esphome/core/log.h"
-#include "esphome/core/application.h"
 
-namespace esphome::bh1750 {
+namespace esphome {
+namespace bh1750 {
 
 static const char *const TAG = "bh1750.sensor";
 
@@ -13,31 +13,6 @@ static const uint8_t BH1750_COMMAND_ONE_TIME_L = 0b00100011;
 static const uint8_t BH1750_COMMAND_ONE_TIME_H = 0b00100000;
 static const uint8_t BH1750_COMMAND_ONE_TIME_H2 = 0b00100001;
 
-static constexpr uint32_t MEASUREMENT_TIMEOUT_MS = 2000;
-static constexpr float HIGH_LIGHT_THRESHOLD_LX = 7000.0f;
-
-// Measurement time constants (datasheet values)
-static constexpr uint16_t MTREG_DEFAULT = 69;
-static constexpr uint16_t MTREG_MIN = 31;
-static constexpr uint16_t MTREG_MAX = 254;
-static constexpr uint16_t MEAS_TIME_L_MS = 24;   // L-resolution max measurement time @ mtreg=69
-static constexpr uint16_t MEAS_TIME_H_MS = 180;  // H/H2-resolution max measurement time @ mtreg=69
-
-// Conversion constants (datasheet formulas)
-static constexpr float RESOLUTION_DIVISOR = 1.2f;  // counts to lux conversion divisor
-static constexpr float MODE_H2_DIVISOR = 2.0f;     // H2 mode has 2x higher resolution
-
-// MTreg calculation constants
-static constexpr int COUNTS_TARGET = 50000;  // Target counts for optimal range (avoid saturation)
-static constexpr int COUNTS_NUMERATOR = 10;
-static constexpr int COUNTS_DENOMINATOR = 12;
-
-// MTreg register bit manipulation constants
-static constexpr uint8_t MTREG_HI_SHIFT = 5;       // High 3 bits start at bit 5
-static constexpr uint8_t MTREG_HI_MASK = 0b111;    // 3-bit mask for high bits
-static constexpr uint8_t MTREG_LO_SHIFT = 0;       // Low 5 bits start at bit 0
-static constexpr uint8_t MTREG_LO_MASK = 0b11111;  // 5-bit mask for low bits
-
 /*
 bh1750 properties:
 
@@ -68,7 +43,74 @@ void BH1750Sensor::setup() {
     this->mark_failed();
     return;
   }
-  this->state_ = IDLE;
+}
+
+void BH1750Sensor::read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f) {
+  // turn on (after one-shot sensor automatically powers down)
+  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
+  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Power on failed");
+    f(NAN);
+    return;
+  }
+
+  if (active_mtreg_ != mtreg) {
+    // set mtreg
+    uint8_t mtreg_hi = BH1750_COMMAND_MT_REG_HI | ((mtreg >> 5) & 0b111);
+    uint8_t mtreg_lo = BH1750_COMMAND_MT_REG_LO | ((mtreg >> 0) & 0b11111);
+    if (this->write(&mtreg_hi, 1) != i2c::ERROR_OK || this->write(&mtreg_lo, 1) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Set measurement time failed");
+      active_mtreg_ = 0;
+      f(NAN);
+      return;
+    }
+    active_mtreg_ = mtreg;
+  }
+
+  uint8_t cmd;
+  uint16_t meas_time;
+  switch (mode) {
+    case BH1750_MODE_L:
+      cmd = BH1750_COMMAND_ONE_TIME_L;
+      meas_time = 24 * mtreg / 69;
+      break;
+    case BH1750_MODE_H:
+      cmd = BH1750_COMMAND_ONE_TIME_H;
+      meas_time = 180 * mtreg / 69;
+      break;
+    case BH1750_MODE_H2:
+      cmd = BH1750_COMMAND_ONE_TIME_H2;
+      meas_time = 180 * mtreg / 69;
+      break;
+    default:
+      f(NAN);
+      return;
+  }
+  if (this->write(&cmd, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Start measurement failed");
+    f(NAN);
+    return;
+  }
+
+  // probably not needed, but adjust for rounding
+  meas_time++;
+
+  this->set_timeout("read", meas_time, [this, mode, mtreg, f]() {
+    uint16_t raw_value;
+    if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Read data failed");
+      f(NAN);
+      return;
+    }
+    raw_value = i2c::i2ctohs(raw_value);
+
+    float lx = float(raw_value) / 1.2f;
+    lx *= 69.0f / mtreg;
+    if (mode == BH1750_MODE_H2)
+      lx /= 2.0f;
+
+    f(lx);
+  });
 }
 
 void BH1750Sensor::dump_config() {
@@ -82,188 +124,45 @@ void BH1750Sensor::dump_config() {
 }
 
 void BH1750Sensor::update() {
-  const uint32_t now = millis();
-
-  // Start coarse measurement to determine optimal mode/mtreg
-  if (this->state_ != IDLE) {
-    // Safety timeout: reset if stuck
-    if (now - this->measurement_start_time_ > MEASUREMENT_TIMEOUT_MS) {
-      ESP_LOGW(TAG, "Measurement timeout, resetting state");
-      this->state_ = IDLE;
-    } else {
-      ESP_LOGW(TAG, "Previous measurement not complete, skipping update");
+  // first do a quick measurement in L-mode with full range
+  // to find right range
+  this->read_lx_(BH1750_MODE_L, 31, [this](float val) {
+    if (std::isnan(val)) {
+      this->status_set_warning();
+      this->publish_state(NAN);
       return;
     }
-  }
 
-  if (!this->start_measurement_(BH1750_MODE_L, MTREG_MIN, now)) {
-    this->status_set_warning();
-    this->publish_state(NAN);
-    return;
-  }
-
-  this->state_ = WAITING_COARSE_MEASUREMENT;
-  this->enable_loop();  // Enable loop while measurement in progress
-}
-
-void BH1750Sensor::loop() {
-  const uint32_t now = App.get_loop_component_start_time();
-
-  switch (this->state_) {
-    case IDLE:
-      // Disable loop when idle to save cycles
-      this->disable_loop();
-      break;
-
-    case WAITING_COARSE_MEASUREMENT:
-      if (now - this->measurement_start_time_ >= this->measurement_duration_) {
-        this->state_ = READING_COARSE_RESULT;
-      }
-      break;
-
-    case READING_COARSE_RESULT: {
-      float lx;
-      if (!this->read_measurement_(lx)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      this->process_coarse_result_(lx);
-
-      // Start fine measurement with optimal settings
-      if (!this->start_measurement_(this->fine_mode_, this->fine_mtreg_, now)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      this->state_ = WAITING_FINE_MEASUREMENT;
-      break;
+    BH1750Mode use_mode;
+    uint8_t use_mtreg;
+    if (val <= 7000) {
+      use_mode = BH1750_MODE_H2;
+      use_mtreg = 254;
+    } else {
+      use_mode = BH1750_MODE_H;
+      // lx = counts / 1.2 * (69 / mtreg)
+      // -> mtreg = counts / 1.2 * (69 / lx)
+      // calculate for counts=50000 (allow some range to not saturate, but maximize mtreg)
+      // -> mtreg = 50000*(10/12)*(69/lx)
+      int ideal_mtreg = 50000 * 10 * 69 / (12 * (int) val);
+      use_mtreg = std::min(254, std::max(31, ideal_mtreg));
     }
+    ESP_LOGV(TAG, "L result: %f -> Calculated mode=%d, mtreg=%d", val, (int) use_mode, use_mtreg);
 
-    case WAITING_FINE_MEASUREMENT:
-      if (now - this->measurement_start_time_ >= this->measurement_duration_) {
-        this->state_ = READING_FINE_RESULT;
+    this->read_lx_(use_mode, use_mtreg, [this](float val) {
+      if (std::isnan(val)) {
+        this->status_set_warning();
+        this->publish_state(NAN);
+        return;
       }
-      break;
-
-    case READING_FINE_RESULT: {
-      float lx;
-      if (!this->read_measurement_(lx)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
+      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), val);
       this->status_clear_warning();
-      this->publish_state(lx);
-      this->state_ = IDLE;
-      break;
-    }
-  }
-}
-
-bool BH1750Sensor::start_measurement_(BH1750Mode mode, uint8_t mtreg, uint32_t now) {
-  // Power on
-  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
-  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Power on failed");
-    return false;
-  }
-
-  // Set MTreg if changed
-  if (this->active_mtreg_ != mtreg) {
-    uint8_t mtreg_hi = BH1750_COMMAND_MT_REG_HI | ((mtreg >> MTREG_HI_SHIFT) & MTREG_HI_MASK);
-    uint8_t mtreg_lo = BH1750_COMMAND_MT_REG_LO | ((mtreg >> MTREG_LO_SHIFT) & MTREG_LO_MASK);
-    if (this->write(&mtreg_hi, 1) != i2c::ERROR_OK || this->write(&mtreg_lo, 1) != i2c::ERROR_OK) {
-      ESP_LOGW(TAG, "Set measurement time failed");
-      this->active_mtreg_ = 0;
-      return false;
-    }
-    this->active_mtreg_ = mtreg;
-  }
-
-  // Start measurement
-  uint8_t cmd;
-  uint16_t meas_time;
-  switch (mode) {
-    case BH1750_MODE_L:
-      cmd = BH1750_COMMAND_ONE_TIME_L;
-      meas_time = MEAS_TIME_L_MS * mtreg / MTREG_DEFAULT;
-      break;
-    case BH1750_MODE_H:
-      cmd = BH1750_COMMAND_ONE_TIME_H;
-      meas_time = MEAS_TIME_H_MS * mtreg / MTREG_DEFAULT;
-      break;
-    case BH1750_MODE_H2:
-      cmd = BH1750_COMMAND_ONE_TIME_H2;
-      meas_time = MEAS_TIME_H_MS * mtreg / MTREG_DEFAULT;
-      break;
-    default:
-      return false;
-  }
-
-  if (this->write(&cmd, 1) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Start measurement failed");
-    return false;
-  }
-
-  // Store current measurement parameters
-  this->current_mode_ = mode;
-  this->current_mtreg_ = mtreg;
-  this->measurement_start_time_ = now;
-  this->measurement_duration_ = meas_time + 1;  // Add 1ms for safety
-
-  return true;
-}
-
-bool BH1750Sensor::read_measurement_(float &lx_out) {
-  uint16_t raw_value;
-  if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Read data failed");
-    return false;
-  }
-  raw_value = i2c::i2ctohs(raw_value);
-
-  float lx = float(raw_value) / RESOLUTION_DIVISOR;
-  lx *= float(MTREG_DEFAULT) / this->current_mtreg_;
-  if (this->current_mode_ == BH1750_MODE_H2) {
-    lx /= MODE_H2_DIVISOR;
-  }
-
-  lx_out = lx;
-  return true;
-}
-
-void BH1750Sensor::process_coarse_result_(float lx) {
-  if (std::isnan(lx)) {
-    // Use defaults if coarse measurement failed
-    this->fine_mode_ = BH1750_MODE_H2;
-    this->fine_mtreg_ = MTREG_MAX;
-    return;
-  }
-
-  if (lx <= HIGH_LIGHT_THRESHOLD_LX) {
-    this->fine_mode_ = BH1750_MODE_H2;
-    this->fine_mtreg_ = MTREG_MAX;
-  } else {
-    this->fine_mode_ = BH1750_MODE_H;
-    // lx = counts / 1.2 * (69 / mtreg)
-    // -> mtreg = counts / 1.2 * (69 / lx)
-    // calculate for counts=50000 (allow some range to not saturate, but maximize mtreg)
-    // -> mtreg = 50000*(10/12)*(69/lx)
-    int ideal_mtreg = COUNTS_TARGET * COUNTS_NUMERATOR * MTREG_DEFAULT / (COUNTS_DENOMINATOR * (int) lx);
-    this->fine_mtreg_ = std::min((int) MTREG_MAX, std::max((int) MTREG_MIN, ideal_mtreg));
-  }
-
-  ESP_LOGV(TAG, "L result: %.1f -> Calculated mode=%d, mtreg=%d", lx, (int) this->fine_mode_, this->fine_mtreg_);
-}
-
-void BH1750Sensor::fail_and_reset_() {
-  this->status_set_warning();
-  this->publish_state(NAN);
-  this->state_ = IDLE;
+      this->publish_state(val);
+    });
+  });
 }
 
 float BH1750Sensor::get_setup_priority() const { return setup_priority::DATA; }
 
-}  // namespace esphome::bh1750
+}  // namespace bh1750
+}  // namespace esphome

esphome/components/bh1750/bh1750.h

@@ -4,9 +4,10 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
 
-namespace esphome::bh1750 {
+namespace esphome {
+namespace bh1750 {
 
-enum BH1750Mode : uint8_t {
+enum BH1750Mode {
   BH1750_MODE_L,
   BH1750_MODE_H,
   BH1750_MODE_H2,
@@ -20,36 +21,13 @@ class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c:
   void setup() override;
   void dump_config() override;
   void update() override;
-  void loop() override;
   float get_setup_priority() const override;
 
  protected:
-  // State machine states
-  enum State : uint8_t {
-    IDLE,
-    WAITING_COARSE_MEASUREMENT,
-    READING_COARSE_RESULT,
-    WAITING_FINE_MEASUREMENT,
-    READING_FINE_RESULT,
-  };
+  void read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f);
 
-  // 4-byte aligned members
-  uint32_t measurement_start_time_{0};
-  uint32_t measurement_duration_{0};
-
-  // 1-byte members grouped together to minimize padding
-  State state_{IDLE};
-  BH1750Mode current_mode_{BH1750_MODE_L};
-  uint8_t current_mtreg_{31};
-  BH1750Mode fine_mode_{BH1750_MODE_H2};
-  uint8_t fine_mtreg_{254};
   uint8_t active_mtreg_{0};
-
-  // Helper methods
-  bool start_measurement_(BH1750Mode mode, uint8_t mtreg, uint32_t now);
-  bool read_measurement_(float &lx_out);
-  void process_coarse_result_(float lx);
-  void fail_and_reset_();
 };
 
-}  // namespace esphome::bh1750
+}  // namespace bh1750
+}  // namespace esphome

esphome/components/binary_sensor/automation.cpp

@@ -1,11 +1,12 @@
 #include "automation.h"
 #include "esphome/core/log.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+namespace binary_sensor {
 
 static const char *const TAG = "binary_sensor.automation";
 
-void MultiClickTrigger::on_state_(bool state) {
+void binary_sensor::MultiClickTrigger::on_state_(bool state) {
   // Handle duplicate events
   if (state == this->last_state_) {
     return;
@@ -66,7 +67,7 @@ void MultiClickTrigger::on_state_(bool state) {
 
   *this->at_index_ = *this->at_index_ + 1;
 }
-void MultiClickTrigger::schedule_cooldown_() {
+void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
   ESP_LOGV(TAG, "Multi Click: Invalid length of press, starting cooldown of %" PRIu32 " ms", this->invalid_cooldown_);
   this->is_in_cooldown_ = true;
   this->set_timeout("cooldown", this->invalid_cooldown_, [this]() {
@@ -78,7 +79,7 @@ void MultiClickTrigger::schedule_cooldown_() {
   this->cancel_timeout("is_valid");
   this->cancel_timeout("is_not_valid");
 }
-void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
+void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
   if (min_length == 0) {
     this->is_valid_ = true;
     return;
@@ -89,19 +90,19 @@ void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
     this->is_valid_ = true;
   });
 }
-void MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
+void binary_sensor::MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
   this->set_timeout("is_not_valid", max_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You waited too long to %s.", this->parent_->state ? "RELEASE" : "PRESS");
     this->is_valid_ = false;
     this->schedule_cooldown_();
   });
 }
-void MultiClickTrigger::cancel() {
+void binary_sensor::MultiClickTrigger::cancel() {
   ESP_LOGV(TAG, "Multi Click: Sequence explicitly cancelled.");
   this->is_valid_ = false;
   this->schedule_cooldown_();
 }
-void MultiClickTrigger::trigger_() {
+void binary_sensor::MultiClickTrigger::trigger_() {
   ESP_LOGV(TAG, "Multi Click: Hooray, multi click is valid. Triggering!");
   this->at_index_.reset();
   this->cancel_timeout("trigger");
@@ -117,4 +118,5 @@ bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length) {
     return length >= min_length && length <= max_length;
   }
 }
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+}  // namespace esphome

esphome/components/binary_sensor/automation.h

@@ -9,7 +9,8 @@
 #include "esphome/core/helpers.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+namespace binary_sensor {
 
 struct MultiClickTriggerEvent {
   bool state;
@@ -171,4 +172,5 @@ template<typename... Ts> class BinarySensorInvalidateAction : public Action<Ts..
   BinarySensor *sensor_;
 };
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+}  // namespace esphome

esphome/components/binary_sensor/binary_sensor.cpp

@@ -1,9 +1,9 @@
 #include "binary_sensor.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 static const char *const TAG = "binary_sensor";
 
@@ -37,9 +37,6 @@ void BinarySensor::send_state_internal(bool new_state) {
   // Note that set_state_ de-dups and will only trigger callbacks if the state has actually changed
   if (this->set_state_(new_state)) {
     ESP_LOGD(TAG, "'%s': New state is %s", this->get_name().c_str(), ONOFF(new_state));
-#if defined(USE_BINARY_SENSOR) && defined(USE_CONTROLLER_REGISTRY)
-    ControllerRegistry::notify_binary_sensor_update(this);
-#endif
   }
 }
 
@@ -61,4 +58,6 @@ void BinarySensor::add_filters(std::initializer_list<Filter *> filters) {
 }
 bool BinarySensor::is_status_binary_sensor() const { return false; }
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+
+}  // namespace esphome

esphome/components/binary_sensor/binary_sensor.h

@@ -6,7 +6,9 @@
 
 #include <initializer_list>
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 class BinarySensor;
 void log_binary_sensor(const char *tag, const char *prefix, const char *type, BinarySensor *obj);
@@ -68,4 +70,5 @@ class BinarySensorInitiallyOff : public BinarySensor {
   bool has_state() const override { return true; }
 };
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+}  // namespace esphome

esphome/components/binary_sensor/filter.cpp

@@ -2,7 +2,9 @@
 
 #include "binary_sensor.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 static const char *const TAG = "sensor.filter";
 
@@ -130,4 +132,6 @@ optional<bool> SettleFilter::new_value(bool value) {
 
 float SettleFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+
+}  // namespace esphome

esphome/components/binary_sensor/filter.h

@@ -4,7 +4,9 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 class BinarySensor;
 
@@ -137,4 +139,6 @@ class SettleFilter : public Filter, public Component {
   bool steady_{true};
 };
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+
+}  // namespace esphome

esphome/components/bl0940/number/calibration_number.cpp

@@ -9,7 +9,7 @@ static const char *const TAG = "bl0940.number";
 void CalibrationNumber::setup() {
   float value = 0.0f;
   if (this->restore_value_) {
-    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
+    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
     if (!this->pref_.load(&value)) {
       value = 0.0f;
     }

esphome/components/ble_client/__init__.py

@@ -15,7 +15,6 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_VALUE,
 )
-from esphome.core import ID
 
 AUTO_LOAD = ["esp32_ble_client"]
 CODEOWNERS = ["@buxtronix", "@clydebarrow"]
@@ -199,12 +198,7 @@ async def ble_write_to_code(config, action_id, template_arg, args):
         templ = await cg.templatable(value, args, cg.std_vector.template(cg.uint8))
         cg.add(var.set_value_template(templ))
     else:
-        # Generate static array in flash to avoid RAM copy
-        if isinstance(value, bytes):
-            value = list(value)
-        arr_id = ID(f"{action_id}_data", is_declaration=True, type=cg.uint8)
-        arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*value))
-        cg.add(var.set_value_simple(arr, len(value)))
+        cg.add(var.set_value_simple(value))
 
     if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
         cg.add(

esphome/components/ble_client/automation.h

@@ -96,8 +96,11 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   BLEClientWriteAction(BLEClient *ble_client) {
     ble_client->register_ble_node(this);
     ble_client_ = ble_client;
+    this->construct_simple_value_();
   }
 
+  ~BLEClientWriteAction() { this->destroy_simple_value_(); }
+
   void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
   void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
   void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
@@ -107,14 +110,17 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
 
   void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
-    this->value_.func = func;
-    this->len_ = -1;  // Sentinel value indicates template mode
+    this->destroy_simple_value_();
+    this->value_.template_func = func;
+    this->has_simple_value_ = false;
   }
 
-  // Store pointer to static data in flash (no RAM copy)
-  void set_value_simple(const uint8_t *data, size_t len) {
-    this->value_.data = data;
-    this->len_ = len;  // Length >= 0 indicates static mode
+  void set_value_simple(const std::vector<uint8_t> &value) {
+    if (!this->has_simple_value_) {
+      this->construct_simple_value_();
+    }
+    this->value_.simple = value;
+    this->has_simple_value_ = true;
   }
 
   void play(const Ts &...x) override {}
@@ -122,19 +128,9 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   void play_complex(const Ts &...x) override {
     this->num_running_++;
     this->var_ = std::make_tuple(x...);
-
-    bool result;
-    if (this->len_ >= 0) {
-      // Static mode: write directly from flash pointer
-      result = this->write(this->value_.data, this->len_);
-    } else {
-      // Template mode: call function and write the vector
-      std::vector<uint8_t> value = this->value_.func(x...);
-      result = this->write(value);
-    }
-
+    auto value = this->has_simple_value_ ? this->value_.simple : this->value_.template_func(x...);
     // on write failure, continue the automation chain rather than stopping so that e.g. disconnect can work.
-    if (!result)
+    if (!write(value))
       this->play_next_(x...);
   }
 
@@ -147,15 +143,15 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
    * errors.
    */
   // initiate the write. Return true if all went well, will be followed by a WRITE_CHAR event.
-  bool write(const uint8_t *data, size_t len) {
+  bool write(const std::vector<uint8_t> &value) {
     if (this->node_state != espbt::ClientState::ESTABLISHED) {
       esph_log_w(Automation::TAG, "Cannot write to BLE characteristic - not connected");
       return false;
     }
-    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", len, format_hex_pretty(data, len).c_str());
-    esp_err_t err =
-        esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_, len,
-                                 const_cast<uint8_t *>(data), this->write_type_, ESP_GATT_AUTH_REQ_NONE);
+    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", value.size(), format_hex_pretty(value).c_str());
+    esp_err_t err = esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(),
+                                             this->char_handle_, value.size(), const_cast<uint8_t *>(value.data()),
+                                             this->write_type_, ESP_GATT_AUTH_REQ_NONE);
     if (err != ESP_OK) {
       esph_log_e(Automation::TAG, "Error writing to characteristic: %s!", esp_err_to_name(err));
       return false;
@@ -163,8 +159,6 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
     return true;
   }
 
-  bool write(const std::vector<uint8_t> &value) { return this->write(value.data(), value.size()); }
-
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                            esp_ble_gattc_cb_param_t *param) override {
     switch (event) {
@@ -207,11 +201,21 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
   }
 
  private:
+  void construct_simple_value_() { new (&this->value_.simple) std::vector<uint8_t>(); }
+
+  void destroy_simple_value_() {
+    if (this->has_simple_value_) {
+      this->value_.simple.~vector();
+    }
+  }
+
   BLEClient *ble_client_;
-  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
+  bool has_simple_value_ = true;
   union Value {
-    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
-    const uint8_t *data;                  // Pointer to static data in flash
+    std::vector<uint8_t> simple;
+    std::vector<uint8_t> (*template_func)(Ts...);
+    Value() {}   // trivial constructor
+    ~Value() {}  // trivial destructor - we manage lifetime via discriminator
   } value_;
   espbt::ESPBTUUID service_uuid_;
   espbt::ESPBTUUID char_uuid_;

esphome/components/canbus/__init__.py

@@ -4,7 +4,7 @@ from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_TRIGGER_ID
-from esphome.core import CORE, ID
+from esphome.core import CORE
 
 CODEOWNERS = ["@mvturnho", "@danielschramm"]
 IS_PLATFORM_COMPONENT = True
@@ -176,8 +176,5 @@ async def canbus_action_to_code(config, action_id, template_arg, args):
     else:
         if isinstance(data, bytes):
             data = [int(x) for x in data]
-        # Generate static array in flash to avoid RAM copy
-        arr_id = ID(f"{action_id}_data", is_declaration=True, type=cg.uint8)
-        arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*data))
-        cg.add(var.set_data_static(arr, len(data)))
+        cg.add(var.set_data_static(data))
     return var

esphome/components/canbus/canbus.h

@@ -112,16 +112,13 @@ class Canbus : public Component {
 
 template<typename... Ts> class CanbusSendAction : public Action<Ts...>, public Parented<Canbus> {
  public:
-  void set_data_template(std::vector<uint8_t> (*func)(Ts...)) {
-    // Stateless lambdas (generated by ESPHome) implicitly convert to function pointers
-    this->data_.func = func;
-    this->len_ = -1;  // Sentinel value indicates template mode
+  void set_data_template(const std::function<std::vector<uint8_t>(Ts...)> func) {
+    this->data_func_ = func;
+    this->static_ = false;
   }
-
-  // Store pointer to static data in flash (no RAM copy)
-  void set_data_static(const uint8_t *data, size_t len) {
-    this->data_.data = data;
-    this->len_ = len;  // Length >= 0 indicates static mode
+  void set_data_static(const std::vector<uint8_t> &data) {
+    this->data_static_ = data;
+    this->static_ = true;
   }
 
   void set_can_id(uint32_t can_id) { this->can_id_ = can_id; }
@@ -136,26 +133,21 @@ template<typename... Ts> class CanbusSendAction : public Action<Ts...>, public P
     auto can_id = this->can_id_.has_value() ? *this->can_id_ : this->parent_->can_id_;
     auto use_extended_id =
         this->use_extended_id_.has_value() ? *this->use_extended_id_ : this->parent_->use_extended_id_;
-    std::vector<uint8_t> data;
-    if (this->len_ >= 0) {
-      // Static mode: copy from flash to vector
-      data.assign(this->data_.data, this->data_.data + this->len_);
+    if (this->static_) {
+      this->parent_->send_data(can_id, use_extended_id, this->remote_transmission_request_, this->data_static_);
     } else {
-      // Template mode: call function
-      data = this->data_.func(x...);
+      auto val = this->data_func_(x...);
+      this->parent_->send_data(can_id, use_extended_id, this->remote_transmission_request_, val);
     }
-    this->parent_->send_data(can_id, use_extended_id, this->remote_transmission_request_, data);
   }
 
  protected:
   optional<uint32_t> can_id_{};
   optional<bool> use_extended_id_{};
   bool remote_transmission_request_{false};
-  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
-  union Data {
-    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
-    const uint8_t *data;                  // Pointer to static data in flash
-  } data_;
+  bool static_{false};
+  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
+  std::vector<uint8_t> data_static_{};
 };
 
 class CanbusTrigger : public Trigger<std::vector<uint8_t>, uint32_t, bool>, public Component {

esphome/components/captive_portal/__init__.py

@@ -1,12 +1,9 @@
-import logging
-
 import esphome.codegen as cg
 from esphome.components import web_server_base
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_AP,
     CONF_ID,
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
@@ -17,10 +14,6 @@ from esphome.const import (
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-_LOGGER = logging.getLogger(__name__)
 
 
 def AUTO_LOAD() -> list[str]:
@@ -57,27 +50,6 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def _final_validate(config: ConfigType) -> ConfigType:
-    full_config = fv.full_config.get()
-    wifi_conf = full_config.get("wifi")
-
-    if wifi_conf is None:
-        # This shouldn't happen due to DEPENDENCIES = ["wifi"], but check anyway
-        raise cv.Invalid("Captive portal requires the wifi component to be configured")
-
-    if CONF_AP not in wifi_conf:
-        _LOGGER.warning(
-            "Captive portal is enabled but no WiFi AP is configured. "
-            "The captive portal will not be accessible. "
-            "Add 'ap:' to your WiFi configuration to enable the captive portal."
-        )
-
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 @coroutine_with_priority(CoroPriority.CAPTIVE_PORTAL)
 async def to_code(config):
     paren = await cg.get_variable(config[CONF_WEB_SERVER_BASE_ID])

esphome/components/climate/climate.cpp

@@ -1,6 +1,4 @@
 #include "climate.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
 #include "esphome/core/macros.h"
 
 namespace esphome {
@@ -465,9 +463,6 @@ void Climate::publish_state() {
 
   // Send state to frontend
   this->state_callback_.call(*this);
-#if defined(USE_CLIMATE) && defined(USE_CONTROLLER_REGISTRY)
-  ControllerRegistry::notify_climate_update(this);
-#endif
   // Save state
   this->save_state_();
 }

esphome/components/const/__init__.py

@@ -8,8 +8,6 @@ BYTE_ORDER_BIG = "big_endian"
 
 CONF_COLOR_DEPTH = "color_depth"
 CONF_DRAW_ROUNDING = "draw_rounding"
-CONF_ENABLED = "enabled"
-CONF_IGNORE_NOT_FOUND = "ignore_not_found"
 CONF_ON_RECEIVE = "on_receive"
 CONF_ON_STATE_CHANGE = "on_state_change"
 CONF_REQUEST_HEADERS = "request_headers"

esphome/components/cover/automation.h

@@ -4,7 +4,8 @@
 #include "esphome/core/automation.h"
 #include "cover.h"
 
-namespace esphome::cover {
+namespace esphome {
+namespace cover {
 
 template<typename... Ts> class OpenAction : public Action<Ts...> {
  public:
@@ -130,4 +131,5 @@ class CoverClosedTrigger : public Trigger<> {
   }
 };
 
-}  // namespace esphome::cover
+}  // namespace cover
+}  // namespace esphome

esphome/components/cover/cover.cpp

@@ -1,12 +1,9 @@
 #include "cover.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
-
 #include <strings.h>
-
 #include "esphome/core/log.h"
 
-namespace esphome::cover {
+namespace esphome {
+namespace cover {
 
 static const char *const TAG = "cover";
 
@@ -172,9 +169,6 @@ void Cover::publish_state(bool save) {
   ESP_LOGD(TAG, "  Current Operation: %s", cover_operation_to_str(this->current_operation));
 
   this->state_callback_.call();
-#if defined(USE_COVER) && defined(USE_CONTROLLER_REGISTRY)
-  ControllerRegistry::notify_cover_update(this);
-#endif
 
   if (save) {
     CoverRestoreState restore{};
@@ -211,4 +205,5 @@ void CoverRestoreState::apply(Cover *cover) {
   cover->publish_state();
 }
 
-}  // namespace esphome::cover
+}  // namespace cover
+}  // namespace esphome

esphome/components/cover/cover.h

@@ -7,7 +7,8 @@
 
 #include "cover_traits.h"
 
-namespace esphome::cover {
+namespace esphome {
+namespace cover {
 
 const extern float COVER_OPEN;
 const extern float COVER_CLOSED;
@@ -156,4 +157,5 @@ class Cover : public EntityBase, public EntityBase_DeviceClass {
   ESPPreferenceObject rtc_;
 };
 
-}  // namespace esphome::cover
+}  // namespace cover
+}  // namespace esphome

esphome/components/cover/cover_traits.h

@@ -1,6 +1,7 @@
 #pragma once
 
-namespace esphome::cover {
+namespace esphome {
+namespace cover {
 
 class CoverTraits {
  public:
@@ -25,4 +26,5 @@ class CoverTraits {
   bool supports_stop_{false};
 };
 
-}  // namespace esphome::cover
+}  // namespace cover
+}  // namespace esphome

esphome/components/dashboard_import/dashboard_import.cpp

@@ -3,10 +3,10 @@
 namespace esphome {
 namespace dashboard_import {
 
-static const char *g_package_import_url = "";  // NOLINT
+static std::string g_package_import_url;  // NOLINT
 
-const char *get_package_import_url() { return g_package_import_url; }
-void set_package_import_url(const char *url) { g_package_import_url = url; }
+const std::string &get_package_import_url() { return g_package_import_url; }
+void set_package_import_url(std::string url) { g_package_import_url = std::move(url); }
 
 }  // namespace dashboard_import
 }  // namespace esphome

esphome/components/dashboard_import/dashboard_import.h

@@ -1,10 +1,12 @@
 #pragma once
 
+#include <string>
+
 namespace esphome {
 namespace dashboard_import {
 
-const char *get_package_import_url();
-void set_package_import_url(const char *url);
+const std::string &get_package_import_url();
+void set_package_import_url(std::string url);
 
 }  // namespace dashboard_import
 }  // namespace esphome

esphome/components/datetime/date_entity.cpp

@@ -1,6 +1,5 @@
 #include "date_entity.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
+
 #ifdef USE_DATETIME_DATE
 
 #include "esphome/core/log.h"
@@ -33,9 +32,6 @@ void DateEntity::publish_state() {
   this->set_has_state(true);
   ESP_LOGD(TAG, "'%s': Sending date %d-%d-%d", this->get_name().c_str(), this->year_, this->month_, this->day_);
   this->state_callback_.call();
-#if defined(USE_DATETIME_DATE) && defined(USE_CONTROLLER_REGISTRY)
-  ControllerRegistry::notify_date_update(this);
-#endif
 }
 
 DateCall DateEntity::make_call() { return DateCall(this); }

esphome/components/datetime/datetime_entity.cpp

@@ -1,6 +1,5 @@
 #include "datetime_entity.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
+
 #ifdef USE_DATETIME_DATETIME
 
 #include "esphome/core/log.h"
@@ -49,9 +48,6 @@ void DateTimeEntity::publish_state() {
   ESP_LOGD(TAG, "'%s': Sending datetime %04u-%02u-%02u %02d:%02d:%02d", this->get_name().c_str(), this->year_,
            this->month_, this->day_, this->hour_, this->minute_, this->second_);
   this->state_callback_.call();
-#if defined(USE_DATETIME_DATETIME) && defined(USE_CONTROLLER_REGISTRY)
-  ControllerRegistry::notify_datetime_update(this);
-#endif
 }
 
 DateTimeCall DateTimeEntity::make_call() { return DateTimeCall(this); }

esphome/components/datetime/time_entity.cpp

@@ -1,6 +1,5 @@
 #include "time_entity.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
+
 #ifdef USE_DATETIME_TIME
 
 #include "esphome/core/log.h"
@@ -30,9 +29,6 @@ void TimeEntity::publish_state() {
   ESP_LOGD(TAG, "'%s': Sending time %02d:%02d:%02d", this->get_name().c_str(), this->hour_, this->minute_,
            this->second_);
   this->state_callback_.call();
-#if defined(USE_DATETIME_TIME) && defined(USE_CONTROLLER_REGISTRY)
-  ControllerRegistry::notify_time_update(this);
-#endif
 }
 
 TimeCall TimeEntity::make_call() { return TimeCall(this); }

esphome/components/debug/__init__.py

@@ -59,7 +59,6 @@ async def to_code(config):
         zephyr_add_prj_conf("SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL", True)
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
-    cg.add_define("USE_DEBUG")
 
 
 FILTER_SOURCE_FILES = filter_source_files_from_platform(

esphome/components/debug/debug_component.cpp

@@ -49,9 +49,9 @@ void DebugComponent::dump_config() {
   }
 #endif  // USE_TEXT_SENSOR
 
-#if defined(USE_ESP32) || defined(USE_ZEPHYR)
-  this->log_partition_info_();  // Log partition information
-#endif
+#ifdef USE_ESP32
+  this->log_partition_info_();  // Log partition information for ESP32
+#endif                          // USE_ESP32
 }
 
 void DebugComponent::loop() {

esphome/components/debug/debug_component.h

@@ -62,19 +62,19 @@ class DebugComponent : public PollingComponent {
   sensor::Sensor *cpu_frequency_sensor_{nullptr};
 #endif  // USE_SENSOR
 
-#if defined(USE_ESP32) || defined(USE_ZEPHYR)
+#ifdef USE_ESP32
   /**
    * @brief Logs information about the device's partition table.
    *
-   * This function iterates through the partition table and logs details
+   * This function iterates through the ESP32's partition table and logs details
    * about each partition, including its name, type, subtype, starting address,
    * and size. The information is useful for diagnosing issues related to flash
    * memory or verifying the partition configuration dynamically at runtime.
    *
-   * Only available when compiled for ESP32 and ZEPHYR platforms.
+   * Only available when compiled for ESP32 platforms.
    */
   void log_partition_info_();
-#endif
+#endif  // USE_ESP32
 
 #ifdef USE_TEXT_SENSOR
   text_sensor::TextSensor *device_info_{nullptr};

esphome/components/debug/debug_zephyr.cpp

@@ -5,7 +5,6 @@
 #include <zephyr/drivers/hwinfo.h>
 #include <hal/nrf_power.h>
 #include <cstdint>
-#include <zephyr/storage/flash_map.h>
 
 #define BOOTLOADER_VERSION_REGISTER NRF_TIMER2->CC[0]
 
@@ -87,37 +86,6 @@ std::string DebugComponent::get_reset_reason_() {
 
 uint32_t DebugComponent::get_free_heap_() { return INT_MAX; }
 
-static void fa_cb(const struct flash_area *fa, void *user_data) {
-#if CONFIG_FLASH_MAP_LABELS
-  const char *fa_label = flash_area_label(fa);
-
-  if (fa_label == nullptr) {
-    fa_label = "-";
-  }
-  ESP_LOGCONFIG(TAG, "%2d   0x%0*" PRIxPTR "   %-26s  %-24.24s  0x%-10x 0x%-12x", (int) fa->fa_id,
-                sizeof(uintptr_t) * 2, (uintptr_t) fa->fa_dev, fa->fa_dev->name, fa_label, (uint32_t) fa->fa_off,
-                fa->fa_size);
-#else
-  ESP_LOGCONFIG(TAG, "%2d   0x%0*" PRIxPTR "   %-26s  0x%-10x 0x%-12x", (int) fa->fa_id, sizeof(uintptr_t) * 2,
-                (uintptr_t) fa->fa_dev, fa->fa_dev->name, (uint32_t) fa->fa_off, fa->fa_size);
-#endif
-}
-
-void DebugComponent::log_partition_info_() {
-#if CONFIG_FLASH_MAP_LABELS
-  ESP_LOGCONFIG(TAG, "ID | Device     | Device Name               "
-                     "| Label                   | Offset     | Size");
-  ESP_LOGCONFIG(TAG, "--------------------------------------------"
-                     "-----------------------------------------------");
-#else
-  ESP_LOGCONFIG(TAG, "ID | Device     | Device Name               "
-                     "| Offset     | Size");
-  ESP_LOGCONFIG(TAG, "-----------------------------------------"
-                     "------------------------------");
-#endif
-  flash_area_foreach(fa_cb, nullptr);
-}
-
 void DebugComponent::get_device_info_(std::string &device_info) {
   std::string supply = "Main supply status: ";
   if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_NORMAL) {

esphome/components/demo/demo_select.h

@@ -8,7 +8,7 @@ namespace demo {
 
 class DemoSelect : public select::Select, public Component {
  protected:
-  void control(size_t index) override { this->publish_state(index); }
+  void control(const std::string &value) override { this->publish_state(value); }
 };
 
 }  // namespace demo

esphome/components/display/display.h

@@ -176,117 +176,7 @@ class Display;
 class DisplayPage;
 class DisplayOnPageChangeTrigger;
 
-/** Optimized display writer that uses function pointers for stateless lambdas.
- *
- * Similar to TemplatableValue but specialized for display writer callbacks.
- * Saves ~8 bytes per stateless lambda on 32-bit platforms (16 bytes std::function → ~8 bytes discriminator+pointer).
- *
- * Supports both:
- * - Stateless lambdas (from YAML) → function pointer (4 bytes)
- * - Stateful lambdas/std::function (from C++ code) → std::function* (heap allocated)
- *
- * @tparam T The display type (e.g., Display, Nextion, GPIOLCDDisplay)
- */
-template<typename T> class DisplayWriter {
- public:
-  DisplayWriter() : type_(NONE) {}
-
-  // For stateless lambdas (convertible to function pointer): use function pointer (4 bytes)
-  template<typename F>
-  DisplayWriter(F f) requires std::invocable<F, T &> && std::convertible_to<F, void (*)(T &)>
-      : type_(STATELESS_LAMBDA) {
-    this->stateless_f_ = f;  // Implicit conversion to function pointer
-  }
-
-  // For stateful lambdas and std::function (not convertible to function pointer): use std::function* (heap allocated)
-  // This handles backwards compatibility with external components
-  template<typename F>
-  DisplayWriter(F f) requires std::invocable<F, T &> &&(!std::convertible_to<F, void (*)(T &)>) : type_(LAMBDA) {
-    this->f_ = new std::function<void(T &)>(std::move(f));
-  }
-
-  // Copy constructor
-  DisplayWriter(const DisplayWriter &other) : type_(other.type_) {
-    if (type_ == LAMBDA) {
-      this->f_ = new std::function<void(T &)>(*other.f_);
-    } else if (type_ == STATELESS_LAMBDA) {
-      this->stateless_f_ = other.stateless_f_;
-    }
-  }
-
-  // Move constructor
-  DisplayWriter(DisplayWriter &&other) noexcept : type_(other.type_) {
-    if (type_ == LAMBDA) {
-      this->f_ = other.f_;
-      other.f_ = nullptr;
-    } else if (type_ == STATELESS_LAMBDA) {
-      this->stateless_f_ = other.stateless_f_;
-    }
-    other.type_ = NONE;
-  }
-
-  // Assignment operators
-  DisplayWriter &operator=(const DisplayWriter &other) {
-    if (this != &other) {
-      this->~DisplayWriter();
-      new (this) DisplayWriter(other);
-    }
-    return *this;
-  }
-
-  DisplayWriter &operator=(DisplayWriter &&other) noexcept {
-    if (this != &other) {
-      this->~DisplayWriter();
-      new (this) DisplayWriter(std::move(other));
-    }
-    return *this;
-  }
-
-  ~DisplayWriter() {
-    if (type_ == LAMBDA) {
-      delete this->f_;
-    }
-    // STATELESS_LAMBDA/NONE: no cleanup needed (function pointer or empty)
-  }
-
-  bool has_value() const { return this->type_ != NONE; }
-
-  void call(T &display) const {
-    switch (this->type_) {
-      case STATELESS_LAMBDA:
-        this->stateless_f_(display);  // Direct function pointer call
-        break;
-      case LAMBDA:
-        (*this->f_)(display);  // std::function call
-        break;
-      case NONE:
-      default:
-        break;
-    }
-  }
-
-  // Operator() for convenience
-  void operator()(T &display) const { this->call(display); }
-
-  // Operator* for backwards compatibility with (*writer_)(*this) pattern
-  DisplayWriter &operator*() { return *this; }
-  const DisplayWriter &operator*() const { return *this; }
-
- protected:
-  enum : uint8_t {
-    NONE,
-    LAMBDA,
-    STATELESS_LAMBDA,
-  } type_;
-
-  union {
-    std::function<void(T &)> *f_;
-    void (*stateless_f_)(T &);
-  };
-};
-
-// Type alias for Display writer - uses optimized DisplayWriter instead of std::function
-using display_writer_t = DisplayWriter<Display>;
+using display_writer_t = std::function<void(Display &)>;
 
 #define LOG_DISPLAY(prefix, type, obj) \
   if ((obj) != nullptr) { \
@@ -788,7 +678,7 @@ class Display : public PollingComponent {
   void sort_triangle_points_by_y_(int *x1, int *y1, int *x2, int *y2, int *x3, int *y3);
 
   DisplayRotation rotation_{DISPLAY_ROTATION_0_DEGREES};
-  display_writer_t writer_{};
+  optional<display_writer_t> writer_{};
   DisplayPage *page_{nullptr};
   DisplayPage *previous_page_{nullptr};
   std::vector<DisplayOnPageChangeTrigger *> on_page_change_triggers_;

esphome/components/ds1307/ds1307.cpp

@@ -23,7 +23,7 @@ void DS1307Component::dump_config() {
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
-  RealTimeClock::dump_config();
+  ESP_LOGCONFIG(TAG, "  Timezone: '%s'", this->timezone_.c_str());
 }
 
 float DS1307Component::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/es8388/select/adc_input_mic_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace es8388 {
 
-void ADCInputMicSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_adc_input_mic(static_cast<AdcInputMicLine>(index));
+void ADCInputMicSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_adc_input_mic(static_cast<AdcInputMicLine>(this->index_of(value).value()));
 }
 
 }  // namespace es8388

esphome/components/es8388/select/adc_input_mic_select.h

@@ -8,7 +8,7 @@ namespace es8388 {
 
 class ADCInputMicSelect : public select::Select, public Parented<ES8388> {
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace es8388

esphome/components/es8388/select/dac_output_select.cpp

@@ -3,9 +3,9 @@
 namespace esphome {
 namespace es8388 {
 
-void DacOutputSelect::control(size_t index) {
-  this->publish_state(index);
-  this->parent_->set_dac_output(static_cast<DacOutputLine>(index));
+void DacOutputSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_dac_output(static_cast<DacOutputLine>(this->index_of(value).value()));
 }
 
 }  // namespace es8388

esphome/components/es8388/select/dac_output_select.h

@@ -8,7 +8,7 @@ namespace es8388 {
 
 class DacOutputSelect : public select::Select, public Parented<ES8388> {
  protected:
-  void control(size_t index) override;
+  void control(const std::string &value) override;
 };
 
 }  // namespace es8388

esphome/components/esp32/__init__.py

@@ -334,14 +334,12 @@ def _is_framework_url(source: str) -> str:
 #  - https://github.com/espressif/arduino-esp32/releases
 ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
     "recommended": cv.Version(3, 3, 2),
-    "latest": cv.Version(3, 3, 4),
-    "dev": cv.Version(3, 3, 4),
+    "latest": cv.Version(3, 3, 2),
+    "dev": cv.Version(3, 3, 2),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(3, 3, 4): cv.Version(55, 3, 31, "2"),
-    cv.Version(3, 3, 3): cv.Version(55, 3, 31, "2"),
-    cv.Version(3, 3, 2): cv.Version(55, 3, 31, "2"),
-    cv.Version(3, 3, 1): cv.Version(55, 3, 31, "2"),
+    cv.Version(3, 3, 2): cv.Version(55, 3, 31, "1"),
+    cv.Version(3, 3, 1): cv.Version(55, 3, 31, "1"),
     cv.Version(3, 3, 0): cv.Version(55, 3, 30, "2"),
     cv.Version(3, 2, 1): cv.Version(54, 3, 21, "2"),
     cv.Version(3, 2, 0): cv.Version(54, 3, 20),
@@ -359,8 +357,8 @@ ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
     "dev": cv.Version(5, 5, 1),
 }
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(5, 5, 1): cv.Version(55, 3, 31, "2"),
-    cv.Version(5, 5, 0): cv.Version(55, 3, 31, "2"),
+    cv.Version(5, 5, 1): cv.Version(55, 3, 31, "1"),
+    cv.Version(5, 5, 0): cv.Version(55, 3, 31, "1"),
     cv.Version(5, 4, 3): cv.Version(55, 3, 32),
     cv.Version(5, 4, 2): cv.Version(54, 3, 21, "2"),
     cv.Version(5, 4, 1): cv.Version(54, 3, 21, "2"),
@@ -375,15 +373,14 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 # The platform-espressif32 version
 #  - https://github.com/pioarduino/platform-espressif32/releases
 PLATFORM_VERSION_LOOKUP = {
-    "recommended": cv.Version(55, 3, 31, "2"),
-    "latest": cv.Version(55, 3, 31, "2"),
-    "dev": cv.Version(55, 3, 31, "2"),
+    "recommended": cv.Version(55, 3, 31, "1"),
+    "latest": cv.Version(55, 3, 31, "1"),
+    "dev": cv.Version(55, 3, 31, "1"),
 }
 
 
-def _check_versions(config):
-    config = config.copy()
-    value = config[CONF_FRAMEWORK]
+def _check_versions(value):
+    value = value.copy()
 
     if value[CONF_VERSION] in PLATFORM_VERSION_LOOKUP:
         if CONF_SOURCE in value or CONF_PLATFORM_VERSION in value:
@@ -448,7 +445,7 @@ def _check_versions(config):
             "If there are connectivity or build issues please remove the manual version."
         )
 
-    return config
+    return value
 
 
 def _parse_platform_version(value):
@@ -498,8 +495,6 @@ def final_validate(config):
     from esphome.components.psram import DOMAIN as PSRAM_DOMAIN
 
     errs = []
-    conf_fw = config[CONF_FRAMEWORK]
-    advanced = conf_fw[CONF_ADVANCED]
     full_config = fv.full_config.get()
     if pio_options := full_config[CONF_ESPHOME].get(CONF_PLATFORMIO_OPTIONS):
         pio_flash_size_key = "board_upload.flash_size"
@@ -516,14 +511,22 @@ def final_validate(config):
                     f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
                 )
             )
-    if config[CONF_VARIANT] != VARIANT_ESP32 and advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
+    if (
+        config[CONF_VARIANT] != VARIANT_ESP32
+        and CONF_ADVANCED in (conf_fw := config[CONF_FRAMEWORK])
+        and CONF_IGNORE_EFUSE_MAC_CRC in conf_fw[CONF_ADVANCED]
+    ):
         errs.append(
             cv.Invalid(
                 f"'{CONF_IGNORE_EFUSE_MAC_CRC}' is not supported on {config[CONF_VARIANT]}",
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_IGNORE_EFUSE_MAC_CRC],
             )
         )
-    if advanced[CONF_EXECUTE_FROM_PSRAM]:
+    if (
+        config.get(CONF_FRAMEWORK, {})
+        .get(CONF_ADVANCED, {})
+        .get(CONF_EXECUTE_FROM_PSRAM)
+    ):
         if config[CONF_VARIANT] != VARIANT_ESP32S3:
             errs.append(
                 cv.Invalid(
@@ -539,17 +542,6 @@ def final_validate(config):
                 )
             )
 
-    if (
-        config[CONF_FLASH_SIZE] == "32MB"
-        and "ota" in full_config
-        and not advanced[CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES]
-    ):
-        errs.append(
-            cv.Invalid(
-                f"OTA with 32MB flash requires '{CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES}' to be set in the '{CONF_ADVANCED}' section of the esp32 configuration",
-                path=[CONF_FLASH_SIZE],
-            )
-        )
     if errs:
         raise cv.MultipleInvalid(errs)
 
@@ -604,74 +596,89 @@ def _validate_idf_component(config: ConfigType) -> ConfigType:
 
 FRAMEWORK_ESP_IDF = "esp-idf"
 FRAMEWORK_ARDUINO = "arduino"
-FRAMEWORK_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_TYPE): cv.one_of(FRAMEWORK_ESP_IDF, FRAMEWORK_ARDUINO),
-        cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
-        cv.Optional(CONF_RELEASE): cv.string_strict,
-        cv.Optional(CONF_SOURCE): cv.string_strict,
-        cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
-        cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
-            cv.string_strict: cv.string_strict
-        },
-        cv.Optional(CONF_LOG_LEVEL, default="ERROR"): cv.one_of(
-            *LOG_LEVELS_IDF, upper=True
-        ),
-        cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
-            {
-                cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
-                    *ASSERTION_LEVELS, upper=True
-                ),
-                cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
-                    *COMPILER_OPTIMIZATIONS, upper=True
-                ),
-                cv.Optional(
-                    CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES, default=False
-                ): cv.boolean,
-                cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
-                cv.Optional(CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False): cv.boolean,
-                cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False): cv.boolean,
-                # DHCP server is needed for WiFi AP mode. When WiFi component is used,
-                # it will handle disabling DHCP server when AP is not configured.
-                # Default to false (disabled) when WiFi is not used.
-                cv.OnlyWithout(
-                    CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
-                ): cv.boolean,
-                cv.Optional(CONF_ENABLE_LWIP_MDNS_QUERIES, default=True): cv.boolean,
-                cv.Optional(
-                    CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
-                ): cv.boolean,
-                cv.Optional(
-                    CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, default=True
-                ): cv.boolean,
-                cv.Optional(
-                    CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
-                ): cv.boolean,
-                cv.Optional(CONF_DISABLE_LIBC_LOCKS_IN_IRAM, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_VFS_SUPPORT_TERMIOS, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_VFS_SUPPORT_SELECT, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_VFS_SUPPORT_DIR, default=True): cv.boolean,
-                cv.Optional(CONF_EXECUTE_FROM_PSRAM, default=False): cv.boolean,
-                cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
-                    min=8192, max=32768
-                ),
-            }
-        ),
-        cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
-            cv.All(
-                cv.Schema(
-                    {
-                        cv.Required(CONF_NAME): cv.string_strict,
-                        cv.Optional(CONF_SOURCE): cv.git_ref,
-                        cv.Optional(CONF_REF): cv.string,
-                        cv.Optional(CONF_PATH): cv.string,
-                        cv.Optional(CONF_REFRESH): cv.All(cv.string, cv.source_refresh),
-                    }
-                ),
-                _validate_idf_component,
-            )
-        ),
-    }
+FRAMEWORK_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Optional(CONF_TYPE, default=FRAMEWORK_ARDUINO): cv.one_of(
+                FRAMEWORK_ESP_IDF, FRAMEWORK_ARDUINO
+            ),
+            cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
+            cv.Optional(CONF_RELEASE): cv.string_strict,
+            cv.Optional(CONF_SOURCE): cv.string_strict,
+            cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
+            cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
+                cv.string_strict: cv.string_strict
+            },
+            cv.Optional(CONF_LOG_LEVEL, default="ERROR"): cv.one_of(
+                *LOG_LEVELS_IDF, upper=True
+            ),
+            cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
+                {
+                    cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
+                        *ASSERTION_LEVELS, upper=True
+                    ),
+                    cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
+                        *COMPILER_OPTIMIZATIONS, upper=True
+                    ),
+                    cv.Optional(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES): cv.boolean,
+                    cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
+                    cv.Optional(
+                        CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False
+                    ): cv.boolean,
+                    cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC): cv.boolean,
+                    # DHCP server is needed for WiFi AP mode. When WiFi component is used,
+                    # it will handle disabling DHCP server when AP is not configured.
+                    # Default to false (disabled) when WiFi is not used.
+                    cv.OnlyWithout(
+                        CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_MDNS_QUERIES, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_DISABLE_LIBC_LOCKS_IN_IRAM, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_DISABLE_VFS_SUPPORT_TERMIOS, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_DISABLE_VFS_SUPPORT_SELECT, default=True
+                    ): cv.boolean,
+                    cv.Optional(CONF_DISABLE_VFS_SUPPORT_DIR, default=True): cv.boolean,
+                    cv.Optional(CONF_EXECUTE_FROM_PSRAM): cv.boolean,
+                    cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
+                        min=8192, max=32768
+                    ),
+                }
+            ),
+            cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
+                cv.All(
+                    cv.Schema(
+                        {
+                            cv.Required(CONF_NAME): cv.string_strict,
+                            cv.Optional(CONF_SOURCE): cv.git_ref,
+                            cv.Optional(CONF_REF): cv.string,
+                            cv.Optional(CONF_PATH): cv.string,
+                            cv.Optional(CONF_REFRESH): cv.All(
+                                cv.string, cv.source_refresh
+                            ),
+                        }
+                    ),
+                    _validate_idf_component,
+                )
+            ),
+        }
+    ),
+    _check_versions,
 )
 
 
@@ -734,11 +741,11 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
 
 
 def _set_default_framework(config):
-    config = config.copy()
     if CONF_FRAMEWORK not in config:
-        config[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
-    if CONF_TYPE not in config[CONF_FRAMEWORK]:
+        config = config.copy()
+
         variant = config[CONF_VARIANT]
+        config[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
         if variant in ARDUINO_ALLOWED_VARIANTS:
             config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ARDUINO
             _show_framework_migration_message(
@@ -778,7 +785,6 @@ CONFIG_SCHEMA = cv.All(
     ),
     _detect_variant,
     _set_default_framework,
-    _check_versions,
     set_core_data,
     cv.has_at_least_one_key(CONF_BOARD, CONF_VARIANT),
 )
@@ -797,7 +803,9 @@ def _configure_lwip_max_sockets(conf: dict) -> None:
     from esphome.components.socket import KEY_SOCKET_CONSUMERS
 
     # Check if user manually specified CONFIG_LWIP_MAX_SOCKETS
-    user_max_sockets = conf[CONF_SDKCONFIG_OPTIONS].get("CONFIG_LWIP_MAX_SOCKETS")
+    user_max_sockets = conf.get(CONF_SDKCONFIG_OPTIONS, {}).get(
+        "CONFIG_LWIP_MAX_SOCKETS"
+    )
 
     socket_consumers: dict[str, int] = CORE.data.get(KEY_SOCKET_CONSUMERS, {})
     total_sockets = sum(socket_consumers.values())
@@ -967,18 +975,23 @@ async def to_code(config):
     # WiFi component handles its own optimization when AP mode is not used
     # When using Arduino with Ethernet, DHCP server functions must be available
     # for the Network library to compile, even if not actively used
-    if advanced.get(CONF_ENABLE_LWIP_DHCP_SERVER) is False and not (
-        conf[CONF_TYPE] == FRAMEWORK_ARDUINO and "ethernet" in CORE.loaded_integrations
+    if (
+        CONF_ENABLE_LWIP_DHCP_SERVER in advanced
+        and not advanced[CONF_ENABLE_LWIP_DHCP_SERVER]
+        and not (
+            conf[CONF_TYPE] == FRAMEWORK_ARDUINO
+            and "ethernet" in CORE.loaded_integrations
+        )
     ):
         add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
-    if not advanced[CONF_ENABLE_LWIP_MDNS_QUERIES]:
+    if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, True):
         add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
-    if not advanced[CONF_ENABLE_LWIP_BRIDGE_INTERFACE]:
+    if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
         add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
 
     _configure_lwip_max_sockets(conf)
 
-    if advanced[CONF_EXECUTE_FROM_PSRAM]:
+    if advanced.get(CONF_EXECUTE_FROM_PSRAM, False):
         add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True)
         add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True)
 
@@ -989,22 +1002,23 @@ async def to_code(config):
     # - select() on 4 sockets: ~190μs (Arduino/core locking) vs ~235μs (ESP-IDF default)
     # - Up to 200% slower under load when all operations queue through tcpip_thread
     # Enabling this makes ESP-IDF socket performance match Arduino framework.
-    if advanced[CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING]:
+    if advanced.get(CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, True):
         add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_CORE_LOCKING", True)
-    if advanced[CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY]:
+    if advanced.get(CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, True):
         add_idf_sdkconfig_option("CONFIG_LWIP_CHECK_THREAD_SAFETY", True)
 
     # Disable placing libc locks in IRAM to save RAM
     # This is safe for ESPHome since no IRAM ISRs (interrupts that run while cache is disabled)
     # use libc lock APIs. Saves approximately 1.3KB (1,356 bytes) of IRAM.
-    if advanced[CONF_DISABLE_LIBC_LOCKS_IN_IRAM]:
+    if advanced.get(CONF_DISABLE_LIBC_LOCKS_IN_IRAM, True):
         add_idf_sdkconfig_option("CONFIG_LIBC_LOCKS_PLACE_IN_IRAM", False)
 
     # Disable VFS support for termios (terminal I/O functions)
     # ESPHome doesn't use termios functions on ESP32 (only used in host UART driver).
     # Saves approximately 1.8KB of flash when disabled (default).
     add_idf_sdkconfig_option(
-        "CONFIG_VFS_SUPPORT_TERMIOS", not advanced[CONF_DISABLE_VFS_SUPPORT_TERMIOS]
+        "CONFIG_VFS_SUPPORT_TERMIOS",
+        not advanced.get(CONF_DISABLE_VFS_SUPPORT_TERMIOS, True),
     )
 
     # Disable VFS support for select() with file descriptors
@@ -1018,7 +1032,8 @@ async def to_code(config):
     else:
         # No component needs it - allow user to control (default: disabled)
         add_idf_sdkconfig_option(
-            "CONFIG_VFS_SUPPORT_SELECT", not advanced[CONF_DISABLE_VFS_SUPPORT_SELECT]
+            "CONFIG_VFS_SUPPORT_SELECT",
+            not advanced.get(CONF_DISABLE_VFS_SUPPORT_SELECT, True),
         )
 
     # Disable VFS support for directory functions (opendir, readdir, mkdir, etc.)
@@ -1031,7 +1046,8 @@ async def to_code(config):
     else:
         # No component needs it - allow user to control (default: disabled)
         add_idf_sdkconfig_option(
-            "CONFIG_VFS_SUPPORT_DIR", not advanced[CONF_DISABLE_VFS_SUPPORT_DIR]
+            "CONFIG_VFS_SUPPORT_DIR",
+            not advanced.get(CONF_DISABLE_VFS_SUPPORT_DIR, True),
         )
 
     cg.add_platformio_option("board_build.partitions", "partitions.csv")
@@ -1045,7 +1061,7 @@ async def to_code(config):
             add_idf_sdkconfig_option(flag, assertion_level == key)
 
     add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
-    compiler_optimization = advanced[CONF_COMPILER_OPTIMIZATION]
+    compiler_optimization = advanced.get(CONF_COMPILER_OPTIMIZATION)
     for key, flag in COMPILER_OPTIMIZATIONS.items():
         add_idf_sdkconfig_option(flag, compiler_optimization == key)
 
@@ -1054,20 +1070,18 @@ async def to_code(config):
         conf[CONF_ADVANCED][CONF_ENABLE_LWIP_ASSERT],
     )
 
-    if advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
+    if advanced.get(CONF_IGNORE_EFUSE_MAC_CRC):
         add_idf_sdkconfig_option("CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR", True)
         add_idf_sdkconfig_option("CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE", False)
-    if advanced[CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES]:
+    if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
         _LOGGER.warning(
             "Using experimental features in ESP-IDF may result in unexpected failures."
         )
         add_idf_sdkconfig_option("CONFIG_IDF_EXPERIMENTAL_FEATURES", True)
-        if config[CONF_FLASH_SIZE] == "32MB":
-            add_idf_sdkconfig_option(
-                "CONFIG_BOOTLOADER_CACHE_32BIT_ADDR_QUAD_FLASH", True
-            )
 
-    cg.add_define("ESPHOME_LOOP_TASK_STACK_SIZE", advanced[CONF_LOOP_TASK_STACK_SIZE])
+    cg.add_define(
+        "ESPHOME_LOOP_TASK_STACK_SIZE", advanced.get(CONF_LOOP_TASK_STACK_SIZE)
+    )
 
     cg.add_define(
         "USE_ESP_IDF_VERSION_CODE",

esphome/components/esp32_ble/ble.cpp

@@ -638,13 +638,11 @@ void ESP32BLE::dump_config() {
         io_capability_s = "invalid";
         break;
     }
-    char mac_s[18];
-    format_mac_addr_upper(mac_address, mac_s);
     ESP_LOGCONFIG(TAG,
                   "BLE:\n"
                   "  MAC address: %s\n"
                   "  IO Capability: %s",
-                  mac_s, io_capability_s);
+                  format_mac_address_pretty(mac_address).c_str(), io_capability_s);
   } else {
     ESP_LOGCONFIG(TAG, "Bluetooth stack is not enabled");
   }

esphome/components/esp32_ble_tracker/automation.h

@@ -10,7 +10,7 @@ namespace esphome::esp32_ble_tracker {
 class ESPBTAdvertiseTrigger : public Trigger<const ESPBTDevice &>, public ESPBTDeviceListener {
  public:
   explicit ESPBTAdvertiseTrigger(ESP32BLETracker *parent) { parent->register_listener(this); }
-  void set_addresses(std::initializer_list<uint64_t> addresses) { this->address_vec_ = addresses; }
+  void set_addresses(const std::vector<uint64_t> &addresses) { this->address_vec_ = addresses; }
 
   bool parse_device(const ESPBTDevice &device) override {
     uint64_t u64_addr = device.address_uint64();

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -336,7 +336,7 @@ void ESP32ImprovComponent::process_incoming_data_() {
         this->connecting_sta_ = sta;
 
         wifi::global_wifi_component->set_sta(sta);
-        wifi::global_wifi_component->start_connecting(sta);
+        wifi::global_wifi_component->start_connecting(sta, false);
         this->set_state_(improv::STATE_PROVISIONING);
         ESP_LOGD(TAG, "Received Improv Wi-Fi settings ssid=%s, password=" LOG_SECRET("%s"), command.ssid.c_str(),
                  command.password.c_str());

esphome/components/ethernet/__init__.py

@@ -383,7 +383,6 @@ async def to_code(config):
     cg.add(var.set_use_address(config[CONF_USE_ADDRESS]))
 
     if CONF_MANUAL_IP in config:
-        cg.add_define("USE_ETHERNET_MANUAL_IP")
         cg.add(var.set_manual_ip(manual_ip(config[CONF_MANUAL_IP])))
 
     # Add compile-time define for PHY types with specific code

esphome/components/ethernet/ethernet_component.cpp

@@ -381,10 +381,7 @@ void EthernetComponent::dump_config() {
       break;
   }
 
-  ESP_LOGCONFIG(TAG,
-                "Ethernet:\n"
-                "  Connected: %s",
-                YESNO(this->is_connected()));
+  ESP_LOGCONFIG(TAG, "Ethernet:");
   this->dump_connect_params_();
 #ifdef USE_ETHERNET_SPI
   ESP_LOGCONFIG(TAG,
@@ -421,6 +418,8 @@ void EthernetComponent::dump_config() {
 
 float EthernetComponent::get_setup_priority() const { return setup_priority::WIFI; }
 
+bool EthernetComponent::can_proceed() { return this->is_connected(); }
+
 network::IPAddresses EthernetComponent::get_ip_addresses() {
   network::IPAddresses addresses;
   esp_netif_ip_info_t ip;
@@ -553,14 +552,11 @@ void EthernetComponent::start_connect_() {
   }
 
   esp_netif_ip_info_t info;
-#ifdef USE_ETHERNET_MANUAL_IP
   if (this->manual_ip_.has_value()) {
     info.ip = this->manual_ip_->static_ip;
     info.gw = this->manual_ip_->gateway;
     info.netmask = this->manual_ip_->subnet;
-  } else
-#endif
-  {
+  } else {
     info.ip.addr = 0;
     info.gw.addr = 0;
     info.netmask.addr = 0;
@@ -581,7 +577,6 @@ void EthernetComponent::start_connect_() {
   err = esp_netif_set_ip_info(this->eth_netif_, &info);
   ESPHL_ERROR_CHECK(err, "DHCPC set IP info error");
 
-#ifdef USE_ETHERNET_MANUAL_IP
   if (this->manual_ip_.has_value()) {
     LwIPLock lock;
     if (this->manual_ip_->dns1.is_set()) {
@@ -594,9 +589,7 @@ void EthernetComponent::start_connect_() {
       d = this->manual_ip_->dns2;
       dns_setserver(1, &d);
     }
-  } else
-#endif
-  {
+  } else {
     err = esp_netif_dhcpc_start(this->eth_netif_);
     if (err != ESP_ERR_ESP_NETIF_DHCP_ALREADY_STARTED) {
       ESPHL_ERROR_CHECK(err, "DHCPC start error");
@@ -694,9 +687,7 @@ void EthernetComponent::set_clk_mode(emac_rmii_clock_mode_t clk_mode) { this->cl
 void EthernetComponent::add_phy_register(PHYRegister register_value) { this->phy_registers_.push_back(register_value); }
 #endif
 void EthernetComponent::set_type(EthernetType type) { this->type_ = type; }
-#ifdef USE_ETHERNET_MANUAL_IP
 void EthernetComponent::set_manual_ip(const ManualIP &manual_ip) { this->manual_ip_ = manual_ip; }
-#endif
 
 // set_use_address() is guaranteed to be called during component setup by Python code generation,
 // so use_address_ will always be valid when get_use_address() is called - no fallback needed.

esphome/components/ethernet/ethernet_component.h

@@ -58,6 +58,7 @@ class EthernetComponent : public Component {
   void loop() override;
   void dump_config() override;
   float get_setup_priority() const override;
+  bool can_proceed() override;
   void on_powerdown() override { powerdown(); }
   bool is_connected();
 
@@ -82,9 +83,7 @@ class EthernetComponent : public Component {
   void add_phy_register(PHYRegister register_value);
 #endif
   void set_type(EthernetType type);
-#ifdef USE_ETHERNET_MANUAL_IP
   void set_manual_ip(const ManualIP &manual_ip);
-#endif
   void set_fixed_mac(const std::array<uint8_t, 6> &mac) { this->fixed_mac_ = mac; }
 
   network::IPAddresses get_ip_addresses();
@@ -139,9 +138,7 @@ class EthernetComponent : public Component {
   uint8_t mdc_pin_{23};
   uint8_t mdio_pin_{18};
 #endif
-#ifdef USE_ETHERNET_MANUAL_IP
   optional<ManualIP> manual_ip_{};
-#endif
   uint32_t connect_begin_;
 
   // Group all uint8_t types together (enums and bools)

esphome/components/event/event.cpp

@@ -1,6 +1,5 @@
 #include "event.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
+
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -9,11 +8,11 @@ namespace event {
 static const char *const TAG = "event";
 
 void Event::trigger(const std::string &event_type) {
-  // Linear search with strcmp - faster than std::set for small datasets (1-5 items typical)
-  const char *found = nullptr;
-  for (const char *type : this->types_) {
-    if (strcmp(type, event_type.c_str()) == 0) {
-      found = type;
+  // Linear search - faster than std::set for small datasets (1-5 items typical)
+  const std::string *found = nullptr;
+  for (const auto &type : this->types_) {
+    if (type == event_type) {
+      found = &type;
       break;
     }
   }
@@ -21,28 +20,9 @@ void Event::trigger(const std::string &event_type) {
     ESP_LOGE(TAG, "'%s': invalid event type for trigger(): %s", this->get_name().c_str(), event_type.c_str());
     return;
   }
-  this->last_event_type_ = found;
-  ESP_LOGD(TAG, "'%s' Triggered event '%s'", this->get_name().c_str(), this->last_event_type_);
+  last_event_type = found;
+  ESP_LOGD(TAG, "'%s' Triggered event '%s'", this->get_name().c_str(), last_event_type->c_str());
   this->event_callback_.call(event_type);
-#if defined(USE_EVENT) && defined(USE_CONTROLLER_REGISTRY)
-  ControllerRegistry::notify_event(this);
-#endif
-}
-
-void Event::set_event_types(const FixedVector<const char *> &event_types) {
-  this->types_.init(event_types.size());
-  for (const char *type : event_types) {
-    this->types_.push_back(type);
-  }
-  this->last_event_type_ = nullptr;  // Reset when types change
-}
-
-void Event::set_event_types(const std::vector<const char *> &event_types) {
-  this->types_.init(event_types.size());
-  for (const char *type : event_types) {
-    this->types_.push_back(type);
-  }
-  this->last_event_type_ = nullptr;  // Reset when types change
 }
 
 void Event::add_on_event_callback(std::function<void(const std::string &event_type)> &&callback) {

esphome/components/event/event.h

@@ -1,8 +1,6 @@
 #pragma once
 
-#include <cstring>
 #include <string>
-#include <vector>
 
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
@@ -24,39 +22,16 @@ namespace event {
 
 class Event : public EntityBase, public EntityBase_DeviceClass {
  public:
+  const std::string *last_event_type;
+
   void trigger(const std::string &event_type);
-
-  /// Set the event types supported by this event (from initializer list).
-  void set_event_types(std::initializer_list<const char *> event_types) {
-    this->types_ = event_types;
-    this->last_event_type_ = nullptr;  // Reset when types change
-  }
-  /// Set the event types supported by this event (from FixedVector).
-  void set_event_types(const FixedVector<const char *> &event_types);
-  /// Set the event types supported by this event (from vector).
-  void set_event_types(const std::vector<const char *> &event_types);
-
-  // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
-  void set_event_types(std::initializer_list<std::string> event_types) = delete;
-  void set_event_types(const FixedVector<std::string> &event_types) = delete;
-  void set_event_types(const std::vector<std::string> &event_types) = delete;
-
-  /// Return the event types supported by this event.
-  const FixedVector<const char *> &get_event_types() const { return this->types_; }
-
-  /// Return the last triggered event type (pointer to string in types_), or nullptr if no event triggered yet.
-  const char *get_last_event_type() const { return this->last_event_type_; }
-
+  void set_event_types(const std::initializer_list<std::string> &event_types) { this->types_ = event_types; }
+  const FixedVector<std::string> &get_event_types() const { return this->types_; }
   void add_on_event_callback(std::function<void(const std::string &event_type)> &&callback);
 
  protected:
   CallbackManager<void(const std::string &event_type)> event_callback_;
-  FixedVector<const char *> types_;
-
- private:
-  /// Last triggered event type - must point to entry in types_ to ensure valid lifetime.
-  /// Set by trigger() after validation, reset to nullptr when types_ changes.
-  const char *last_event_type_{nullptr};
+  FixedVector<std::string> types_;
 };
 
 }  // namespace event

esphome/components/fan/fan.cpp

@@ -1,6 +1,4 @@
 #include "fan.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -183,9 +181,6 @@ void Fan::publish_state() {
     ESP_LOGD(TAG, "  Preset Mode: %s", preset);
   }
   this->state_callback_.call();
-#if defined(USE_FAN) && defined(USE_CONTROLLER_REGISTRY)
-  ControllerRegistry::notify_fan_update(this);
-#endif
   this->save_state_();
 }
 
@@ -236,7 +231,7 @@ void Fan::save_state_() {
   state.direction = this->direction;
 
   const char *preset = this->get_preset_mode();
-  if (preset != nullptr) {
+  if (traits.supports_preset_modes() && preset != nullptr) {
     const auto &preset_modes = traits.supported_preset_modes();
     // Find index of current preset mode (pointer comparison is safe since preset is from traits)
     for (size_t i = 0; i < preset_modes.size(); i++) {

esphome/components/font/__init__.py

@@ -36,6 +36,7 @@ from esphome.const import (
     CONF_WEIGHT,
 )
 from esphome.core import CORE, HexInt
+from esphome.helpers import cpp_string_escape
 from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
@@ -49,6 +50,7 @@ font_ns = cg.esphome_ns.namespace("font")
 
 Font = font_ns.class_("Font")
 Glyph = font_ns.class_("Glyph")
+GlyphData = font_ns.struct("GlyphData")
 
 CONF_BPP = "bpp"
 CONF_EXTRAS = "extras"
@@ -461,7 +463,7 @@ FONT_SCHEMA = cv.Schema(
             )
         ),
         cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
-        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(Glyph),
+        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(GlyphData),
     },
 )
 
@@ -486,8 +488,6 @@ class GlyphInfo:
 
 
 def glyph_to_glyphinfo(glyph, font, size, bpp):
-    # Convert to 32 bit unicode codepoint
-    glyph = ord(glyph)
     scale = 256 // (1 << bpp)
     if not font.is_scalable:
         sizes = [pt_to_px(x.size) for x in font.available_sizes]
@@ -583,15 +583,22 @@ async def to_code(config):
 
     # Create the glyph table that points to data in the above array.
     glyph_initializer = [
-        [
-            x.glyph,
-            prog_arr + (y - len(x.bitmap_data)),
-            x.advance,
-            x.offset_x,
-            x.offset_y,
-            x.width,
-            x.height,
-        ]
+        cg.StructInitializer(
+            GlyphData,
+            (
+                "a_char",
+                cg.RawExpression(f"(const uint8_t *){cpp_string_escape(x.glyph)}"),
+            ),
+            (
+                "data",
+                cg.RawExpression(f"{str(prog_arr)} + {str(y - len(x.bitmap_data))}"),
+            ),
+            ("advance", x.advance),
+            ("offset_x", x.offset_x),
+            ("offset_y", x.offset_y),
+            ("width", x.width),
+            ("height", x.height),
+        )
         for (x, y) in zip(
             glyph_args, list(accumulate([len(x.bitmap_data) for x in glyph_args]))
         )

esphome/components/font/font.cpp

@@ -6,245 +6,133 @@
 
 namespace esphome {
 namespace font {
+
 static const char *const TAG = "font";
 
-#ifdef USE_LVGL_FONT
-const uint8_t *Font::get_glyph_bitmap(const lv_font_t *font, uint32_t unicode_letter) {
-  auto *fe = (Font *) font->dsc;
-  const auto *gd = fe->get_glyph_data_(unicode_letter);
-  if (gd == nullptr) {
-    return nullptr;
+const uint8_t *Glyph::get_char() const { return this->glyph_data_->a_char; }
+// Compare the char at the string position with this char.
+// Return true if this char is less than or equal the other.
+bool Glyph::compare_to(const uint8_t *str) const {
+  // 1 -> this->char_
+  // 2 -> str
+  for (uint32_t i = 0;; i++) {
+    if (this->glyph_data_->a_char[i] == '\0')
+      return true;
+    if (str[i] == '\0')
+      return false;
+    if (this->glyph_data_->a_char[i] > str[i])
+      return false;
+    if (this->glyph_data_->a_char[i] < str[i])
+      return true;
   }
-  return gd->data;
+  // this should not happen
+  return false;
+}
+int Glyph::match_length(const uint8_t *str) const {
+  for (uint32_t i = 0;; i++) {
+    if (this->glyph_data_->a_char[i] == '\0')
+      return i;
+    if (str[i] != this->glyph_data_->a_char[i])
+      return 0;
+  }
+  // this should not happen
+  return 0;
+}
+void Glyph::scan_area(int *x1, int *y1, int *width, int *height) const {
+  *x1 = this->glyph_data_->offset_x;
+  *y1 = this->glyph_data_->offset_y;
+  *width = this->glyph_data_->width;
+  *height = this->glyph_data_->height;
 }
 
-bool Font::get_glyph_dsc_cb(const lv_font_t *font, lv_font_glyph_dsc_t *dsc, uint32_t unicode_letter, uint32_t next) {
-  auto *fe = (Font *) font->dsc;
-  const auto *gd = fe->get_glyph_data_(unicode_letter);
-  if (gd == nullptr) {
-    return false;
-  }
-  dsc->adv_w = gd->advance;
-  dsc->ofs_x = gd->offset_x;
-  dsc->ofs_y = fe->height_ - gd->height - gd->offset_y - fe->lv_font_.base_line;
-  dsc->box_w = gd->width;
-  dsc->box_h = gd->height;
-  dsc->is_placeholder = 0;
-  dsc->bpp = fe->get_bpp();
-  return true;
-}
-
-const Glyph *Font::get_glyph_data_(uint32_t unicode_letter) {
-  if (unicode_letter == this->last_letter_ && this->last_letter_ != 0)
-    return this->last_data_;
-  auto *glyph = this->find_glyph(unicode_letter);
-  if (glyph == nullptr) {
-    return nullptr;
-  }
-  this->last_data_ = glyph;
-  this->last_letter_ = unicode_letter;
-  return glyph;
-}
-#endif
-
-/**
- *  Attempt to extract a 32 bit Unicode codepoint from a UTF-8 string.
- *  If successful, return the codepoint and set the length to the number of bytes read.
- *  If the end of the string has been reached and a valid codepoint has not been found, return 0 and set the length to
- * 0.
- *
- * @param utf8_str The input string
- * @param length Pointer to length storage
- * @return The extracted code point
- */
-static uint32_t extract_unicode_codepoint(const char *utf8_str, size_t *length) {
-  // Safely cast to uint8_t* for correct bitwise operations on bytes
-  const uint8_t *current = reinterpret_cast<const uint8_t *>(utf8_str);
-  uint32_t code_point = 0;
-  uint8_t c1 = *current++;
-
-  // check for end of string
-  if (c1 == 0) {
-    *length = 0;
-    return 0;
-  }
-
-  // --- 1-Byte Sequence: 0xxxxxxx (ASCII) ---
-  if (c1 < 0x80) {
-    // Valid ASCII byte.
-    code_point = c1;
-    // Optimization: No need to check for continuation bytes.
-  }
-  // --- 2-Byte Sequence: 110xxxxx 10xxxxxx ---
-  else if ((c1 & 0xE0) == 0xC0) {
-    uint8_t c2 = *current++;
-
-    // Error Check 1: Check if c2 is a valid continuation byte (10xxxxxx)
-    if ((c2 & 0xC0) != 0x80) {
-      *length = 0;
-      return 0;
-    }
-
-    code_point = (c1 & 0x1F) << 6;
-    code_point |= (c2 & 0x3F);
-
-    // Error Check 2: Overlong check (2-byte must be > 0x7F)
-    if (code_point <= 0x7F) {
-      *length = 0;
-      return 0;
-    }
-  }
-  // --- 3-Byte Sequence: 1110xxxx 10xxxxxx 10xxxxxx ---
-  else if ((c1 & 0xF0) == 0xE0) {
-    uint8_t c2 = *current++;
-    uint8_t c3 = *current++;
-
-    // Error Check 1: Check continuation bytes
-    if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80)) {
-      *length = 0;
-      return 0;
-    }
-
-    code_point = (c1 & 0x0F) << 12;
-    code_point |= (c2 & 0x3F) << 6;
-    code_point |= (c3 & 0x3F);
-
-    // Error Check 2: Overlong check (3-byte must be > 0x7FF)
-    // Also check for surrogates (0xD800-0xDFFF)
-    if (code_point <= 0x7FF || (code_point >= 0xD800 && code_point <= 0xDFFF)) {
-      *length = 0;
-      return 0;
-    }
-  }
-  // --- 4-Byte Sequence: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx ---
-  else if ((c1 & 0xF8) == 0xF0) {
-    uint8_t c2 = *current++;
-    uint8_t c3 = *current++;
-    uint8_t c4 = *current++;
-
-    // Error Check 1: Check continuation bytes
-    if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80) || ((c4 & 0xC0) != 0x80)) {
-      *length = 0;
-      return 0;
-    }
-
-    code_point = (c1 & 0x07) << 18;
-    code_point |= (c2 & 0x3F) << 12;
-    code_point |= (c3 & 0x3F) << 6;
-    code_point |= (c4 & 0x3F);
-
-    // Error Check 2: Overlong check (4-byte must be > 0xFFFF)
-    // Also check for valid Unicode range (must be <= 0x10FFFF)
-    if (code_point <= 0xFFFF || code_point > 0x10FFFF) {
-      *length = 0;
-      return 0;
-    }
-  }
-  // --- Invalid leading byte (e.g., 10xxxxxx or 11111xxx) ---
-  else {
-    *length = 0;
-    return 0;
-  }
-  *length = current - reinterpret_cast<const uint8_t *>(utf8_str);
-  return code_point;
-}
-
-Font::Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+Font::Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
            uint8_t bpp)
-    : glyphs_(ConstVector(data, data_nr)),
-      baseline_(baseline),
+    : baseline_(baseline),
       height_(height),
       descender_(descender),
       linegap_(height - baseline - descender),
       xheight_(xheight),
       capheight_(capheight),
       bpp_(bpp) {
-#ifdef USE_LVGL_FONT
-  this->lv_font_.dsc = this;
-  this->lv_font_.line_height = this->get_height();
-  this->lv_font_.base_line = this->lv_font_.line_height - this->get_baseline();
-  this->lv_font_.get_glyph_dsc = get_glyph_dsc_cb;
-  this->lv_font_.get_glyph_bitmap = get_glyph_bitmap;
-  this->lv_font_.subpx = LV_FONT_SUBPX_NONE;
-  this->lv_font_.underline_position = -1;
-  this->lv_font_.underline_thickness = 1;
-#endif
+  glyphs_.reserve(data_nr);
+  for (int i = 0; i < data_nr; ++i)
+    glyphs_.emplace_back(&data[i]);
 }
-
-const Glyph *Font::find_glyph(uint32_t codepoint) const {
+int Font::match_next_glyph(const uint8_t *str, int *match_length) {
   int lo = 0;
   int hi = this->glyphs_.size() - 1;
   while (lo != hi) {
     int mid = (lo + hi + 1) / 2;
-    if (this->glyphs_[mid].is_less_or_equal(codepoint)) {
+    if (this->glyphs_[mid].compare_to(str)) {
       lo = mid;
     } else {
       hi = mid - 1;
     }
   }
-  auto *result = &this->glyphs_[lo];
-  if (result->code_point == codepoint)
-    return result;
-  return nullptr;
+  *match_length = this->glyphs_[lo].match_length(str);
+  if (*match_length <= 0)
+    return -1;
+  return lo;
 }
-
 #ifdef USE_DISPLAY
 void Font::measure(const char *str, int *width, int *x_offset, int *baseline, int *height) {
   *baseline = this->baseline_;
   *height = this->height_;
+  int i = 0;
   int min_x = 0;
   bool has_char = false;
   int x = 0;
-  for (;;) {
-    size_t length;
-    auto code_point = extract_unicode_codepoint(str, &length);
-    if (length == 0)
-      break;
-    str += length;
-    auto *glyph = this->find_glyph(code_point);
-    if (glyph == nullptr) {
+  while (str[i] != '\0') {
+    int match_length;
+    int glyph_n = this->match_next_glyph((const uint8_t *) str + i, &match_length);
+    if (glyph_n < 0) {
       // Unknown char, skip
-      if (!this->glyphs_.empty())
-        x += this->glyphs_[0].advance;
+      if (!this->get_glyphs().empty())
+        x += this->get_glyphs()[0].glyph_data_->advance;
+      i++;
       continue;
     }
 
+    const Glyph &glyph = this->glyphs_[glyph_n];
     if (!has_char) {
-      min_x = glyph->offset_x;
+      min_x = glyph.glyph_data_->offset_x;
     } else {
-      min_x = std::min(min_x, x + glyph->offset_x);
+      min_x = std::min(min_x, x + glyph.glyph_data_->offset_x);
     }
-    x += glyph->advance;
+    x += glyph.glyph_data_->advance;
 
+    i += match_length;
     has_char = true;
   }
   *x_offset = min_x;
   *width = x - min_x;
 }
-
 void Font::print(int x_start, int y_start, display::Display *display, Color color, const char *text, Color background) {
+  int i = 0;
   int x_at = x_start;
-  for (;;) {
-    size_t length;
-    auto code_point = extract_unicode_codepoint(text, &length);
-    if (length == 0)
-      break;
-    text += length;
-    auto *glyph = this->find_glyph(code_point);
-    if (glyph == nullptr) {
+  int scan_x1, scan_y1, scan_width, scan_height;
+  while (text[i] != '\0') {
+    int match_length;
+    int glyph_n = this->match_next_glyph((const uint8_t *) text + i, &match_length);
+    if (glyph_n < 0) {
       // Unknown char, skip
-      ESP_LOGW(TAG, "Codepoint 0x%08" PRIx32 " not found in font", code_point);
-      if (!this->glyphs_.empty()) {
-        uint8_t glyph_width = this->glyphs_[0].advance;
-        display->rectangle(x_at, y_start, glyph_width, this->height_, color);
+      ESP_LOGW(TAG, "Encountered character without representation in font: '%c'", text[i]);
+      if (!this->get_glyphs().empty()) {
+        uint8_t glyph_width = this->get_glyphs()[0].glyph_data_->advance;
+        display->filled_rectangle(x_at, y_start, glyph_width, this->height_, color);
         x_at += glyph_width;
       }
+
+      i++;
       continue;
     }
 
-    const uint8_t *data = glyph->data;
-    const int max_x = x_at + glyph->offset_x + glyph->width;
-    const int max_y = y_start + glyph->offset_y + glyph->height;
+    const Glyph &glyph = this->get_glyphs()[glyph_n];
+    glyph.scan_area(&scan_x1, &scan_y1, &scan_width, &scan_height);
+
+    const uint8_t *data = glyph.glyph_data_->data;
+    const int max_x = x_at + scan_x1 + scan_width;
+    const int max_y = y_start + scan_y1 + scan_height;
 
     uint8_t bitmask = 0;
     uint8_t pixel_data = 0;
@@ -257,10 +145,10 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
     auto b_g = (float) background.g;
     auto b_b = (float) background.b;
     auto b_w = (float) background.w;
-    for (int glyph_y = y_start + glyph->offset_y; glyph_y != max_y; glyph_y++) {
-      for (int glyph_x = x_at + glyph->offset_x; glyph_x != max_x; glyph_x++) {
+    for (int glyph_y = y_start + scan_y1; glyph_y != max_y; glyph_y++) {
+      for (int glyph_x = x_at + scan_x1; glyph_x != max_x; glyph_x++) {
         uint8_t pixel = 0;
-        for (uint8_t bit_num = 0; bit_num != this->bpp_; bit_num++) {
+        for (int bit_num = 0; bit_num != this->bpp_; bit_num++) {
           if (bitmask == 0) {
             pixel_data = progmem_read_byte(data++);
             bitmask = 0x80;
@@ -280,9 +168,12 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
         }
       }
     }
-    x_at += glyph->advance;
+    x_at += glyph.glyph_data_->advance;
+
+    i += match_length;
   }
 }
 #endif
+
 }  // namespace font
 }  // namespace esphome

esphome/components/font/font.h

@@ -6,30 +6,14 @@
 #ifdef USE_DISPLAY
 #include "esphome/components/display/display.h"
 #endif
-#ifdef USE_LVGL_FONT
-#include <lvgl.h>
-#endif
 
 namespace esphome {
 namespace font {
 
 class Font;
 
-class Glyph {
- public:
-  constexpr Glyph(uint32_t code_point, const uint8_t *data, int advance, int offset_x, int offset_y, int width,
-                  int height)
-      : code_point(code_point),
-        data(data),
-        advance(advance),
-        offset_x(offset_x),
-        offset_y(offset_y),
-        width(width),
-        height(height) {}
-
-  bool is_less_or_equal(uint32_t other) const { return this->code_point <= other; }
-
-  const uint32_t code_point;
+struct GlyphData {
+  const uint8_t *a_char;
   const uint8_t *data;
   int advance;
   int offset_x;
@@ -38,6 +22,26 @@ class Glyph {
   int height;
 };
 
+class Glyph {
+ public:
+  Glyph(const GlyphData *data) : glyph_data_(data) {}
+
+  const uint8_t *get_char() const;
+
+  bool compare_to(const uint8_t *str) const;
+
+  int match_length(const uint8_t *str) const;
+
+  void scan_area(int *x1, int *y1, int *width, int *height) const;
+
+  const GlyphData *get_glyph_data() const { return this->glyph_data_; }
+
+ protected:
+  friend Font;
+
+  const GlyphData *glyph_data_;
+};
+
 class Font
 #ifdef USE_DISPLAY
     : public display::BaseFont
@@ -46,8 +50,8 @@ class Font
  public:
   /** Construct the font with the given glyphs.
    *
-   * @param data A list of glyphs, must be sorted lexicographically.
-   * @param data_nr The number of glyphs
+   * @param data A vector of glyphs, must be sorted lexicographically.
+   * @param data_nr The number of glyphs in data.
    * @param baseline The y-offset from the top of the text to the baseline.
    * @param height The y-offset from the top of the text to the bottom.
    * @param descender The y-offset from the baseline to the lowest stroke in the font (e.g. from letters like g or p).
@@ -55,10 +59,10 @@ class Font
    * @param capheight The height of capital letters, usually measured at the "X" glyph.
    * @param bpp The bits per pixel used for this font. Used to read data out of the glyph bitmaps.
    */
-  Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+  Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
        uint8_t bpp = 1);
 
-  const Glyph *find_glyph(uint32_t codepoint) const;
+  int match_next_glyph(const uint8_t *str, int *match_length);
 
 #ifdef USE_DISPLAY
   void print(int x_start, int y_start, display::Display *display, Color color, const char *text,
@@ -73,14 +77,11 @@ class Font
   inline int get_xheight() { return this->xheight_; }
   inline int get_capheight() { return this->capheight_; }
   inline int get_bpp() { return this->bpp_; }
-#ifdef USE_LVGL_FONT
-  const lv_font_t *get_lv_font() const { return &this->lv_font_; }
-#endif
 
-  const ConstVector<Glyph> &get_glyphs() const { return glyphs_; }
+  const std::vector<Glyph, RAMAllocator<Glyph>> &get_glyphs() const { return glyphs_; }
 
  protected:
-  ConstVector<Glyph> glyphs_;
+  std::vector<Glyph, RAMAllocator<Glyph>> glyphs_;
   int baseline_;
   int height_;
   int descender_;
@@ -88,14 +89,6 @@ class Font
   int xheight_;
   int capheight_;
   uint8_t bpp_;  // bits per pixel
-#ifdef USE_LVGL_FONT
-  lv_font_t lv_font_{};
-  static const uint8_t *get_glyph_bitmap(const lv_font_t *font, uint32_t unicode_letter);
-  static bool get_glyph_dsc_cb(const lv_font_t *font, lv_font_glyph_dsc_t *dsc, uint32_t unicode_letter, uint32_t next);
-  const Glyph *get_glyph_data_(uint32_t unicode_letter);
-  uint32_t last_letter_{};
-  const Glyph *last_data_{};
-#endif
 };
 
 }  // namespace font

esphome/components/gdk101/gdk101.cpp

@@ -62,6 +62,7 @@ void GDK101Component::dump_config() {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 #ifdef USE_SENSOR
+  LOG_SENSOR("  ", "Firmware Version", this->fw_version_sensor_);
   LOG_SENSOR("  ", "Average Radaition Dose per 1 minute", this->rad_1m_sensor_);
   LOG_SENSOR("  ", "Average Radaition Dose per 10 minutes", this->rad_10m_sensor_);
   LOG_SENSOR("  ", "Status", this->status_sensor_);
@@ -71,10 +72,6 @@ void GDK101Component::dump_config() {
 #ifdef USE_BINARY_SENSOR
   LOG_BINARY_SENSOR("  ", "Vibration Status", this->vibration_binary_sensor_);
 #endif  // USE_BINARY_SENSOR
-
-#ifdef USE_TEXT_SENSOR
-  LOG_TEXT_SENSOR("  ", "Firmware Version", this->fw_version_text_sensor_);
-#endif  // USE_TEXT_SENSOR
 }
 
 float GDK101Component::get_setup_priority() const { return setup_priority::DATA; }
@@ -156,18 +153,18 @@ bool GDK101Component::read_status_(uint8_t *data) {
 }
 
 bool GDK101Component::read_fw_version_(uint8_t *data) {
-#ifdef USE_TEXT_SENSOR
-  if (this->fw_version_text_sensor_ != nullptr) {
+#ifdef USE_SENSOR
+  if (this->fw_version_sensor_ != nullptr) {
     if (!this->read_bytes(GDK101_REG_READ_FIRMWARE, data, 2)) {
       ESP_LOGE(TAG, "Updating GDK101 failed!");
       return false;
     }
 
-    const std::string fw_version_str = str_sprintf("%d.%d", data[0], data[1]);
+    const float fw_version = data[0] + (data[1] / 10.0f);
 
-    this->fw_version_text_sensor_->publish_state(fw_version_str);
+    this->fw_version_sensor_->publish_state(fw_version);
   }
-#endif  // USE_TEXT_SENSOR
+#endif  // USE_SENSOR
   return true;
 }
 

esphome/components/gdk101/gdk101.h

@@ -8,9 +8,6 @@
 #ifdef USE_BINARY_SENSOR
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #endif  // USE_BINARY_SENSOR
-#ifdef USE_TEXT_SENSOR
-#include "esphome/components/text_sensor/text_sensor.h"
-#endif  // USE_TEXT_SENSOR
 #include "esphome/components/i2c/i2c.h"
 
 namespace esphome {
@@ -28,14 +25,12 @@ class GDK101Component : public PollingComponent, public i2c::I2CDevice {
   SUB_SENSOR(rad_1m)
   SUB_SENSOR(rad_10m)
   SUB_SENSOR(status)
+  SUB_SENSOR(fw_version)
   SUB_SENSOR(measurement_duration)
 #endif  // USE_SENSOR
 #ifdef USE_BINARY_SENSOR
   SUB_BINARY_SENSOR(vibration)
 #endif  // USE_BINARY_SENSOR
-#ifdef USE_TEXT_SENSOR
-  SUB_TEXT_SENSOR(fw_version)
-#endif  // USE_TEXT_SENSOR
 
  public:
   void setup() override;

esphome/components/gdk101/sensor.py

@@ -40,8 +40,9 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_EMPTY,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
-        cv.Optional(CONF_VERSION): cv.invalid(
-            "The 'version' option has been moved to the `text_sensor` component."
+        cv.Optional(CONF_VERSION): sensor.sensor_schema(
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            accuracy_decimals=1,
         ),
         cv.Optional(CONF_STATUS): sensor.sensor_schema(
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
@@ -70,6 +71,10 @@ async def to_code(config):
         sens = await sensor.new_sensor(radiation_dose_per_10m)
         cg.add(hub.set_rad_10m_sensor(sens))
 
+    if version_config := config.get(CONF_VERSION):
+        sens = await sensor.new_sensor(version_config)
+        cg.add(hub.set_fw_version_sensor(sens))
+
     if status_config := config.get(CONF_STATUS):
         sens = await sensor.new_sensor(status_config)
         cg.add(hub.set_status_sensor(sens))

esphome/components/gdk101/text_sensor.py

@@ -1,23 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import text_sensor
-import esphome.config_validation as cv
-from esphome.const import CONF_VERSION, ENTITY_CATEGORY_DIAGNOSTIC, ICON_CHIP
-
-from . import CONF_GDK101_ID, GDK101Component
-
-DEPENDENCIES = ["gdk101"]
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_GDK101_ID): cv.use_id(GDK101Component),
-        cv.Required(CONF_VERSION): text_sensor.text_sensor_schema(
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_CHIP
-        ),
-    }
-)
-
-
-async def to_code(config):
-    hub = await cg.get_variable(config[CONF_GDK101_ID])
-    var = await text_sensor.new_text_sensor(config[CONF_VERSION])
-    cg.add(hub.set_fw_version_text_sensor(var))

esphome/components/gp8403/__init__.py

@@ -1,25 +1,19 @@
 import esphome.codegen as cg
 from esphome.components import i2c
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_MODEL, CONF_VOLTAGE
+from esphome.const import CONF_ID, CONF_VOLTAGE
 
-CODEOWNERS = ["@jesserockz", "@sebydocky"]
+CODEOWNERS = ["@jesserockz"]
 DEPENDENCIES = ["i2c"]
 MULTI_CONF = True
 
 gp8403_ns = cg.esphome_ns.namespace("gp8403")
-GP8403Component = gp8403_ns.class_("GP8403Component", cg.Component, i2c.I2CDevice)
+GP8403 = gp8403_ns.class_("GP8403", cg.Component, i2c.I2CDevice)
 
 GP8403Voltage = gp8403_ns.enum("GP8403Voltage")
-GP8403Model = gp8403_ns.enum("GP8403Model")
 
 CONF_GP8403_ID = "gp8403_id"
 
-MODELS = {
-    "GP8403": GP8403Model.GP8403,
-    "GP8413": GP8403Model.GP8413,
-}
-
 VOLTAGES = {
     "5V": GP8403Voltage.GP8403_VOLTAGE_5V,
     "10V": GP8403Voltage.GP8403_VOLTAGE_10V,
@@ -28,8 +22,7 @@ VOLTAGES = {
 CONFIG_SCHEMA = (
     cv.Schema(
         {
-            cv.GenerateID(): cv.declare_id(GP8403Component),
-            cv.Optional(CONF_MODEL, default="GP8403"): cv.enum(MODELS, upper=True),
+            cv.GenerateID(): cv.declare_id(GP8403),
             cv.Required(CONF_VOLTAGE): cv.enum(VOLTAGES, upper=True),
         }
     )
@@ -42,5 +35,5 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
-    cg.add(var.set_model(config[CONF_MODEL]))
+
     cg.add(var.set_voltage(config[CONF_VOLTAGE]))

esphome/components/gp8403/gp8403.cpp

@@ -8,48 +8,16 @@ namespace gp8403 {
 static const char *const TAG = "gp8403";
 
 static const uint8_t RANGE_REGISTER = 0x01;
-static const uint8_t OUTPUT_REGISTER = 0x02;
 
-const LogString *model_to_string(GP8403Model model) {
-  switch (model) {
-    case GP8403Model::GP8403:
-      return LOG_STR("GP8403");
-    case GP8403Model::GP8413:
-      return LOG_STR("GP8413");
-  }
-  return LOG_STR("Unknown");
-};
+void GP8403::setup() { this->write_register(RANGE_REGISTER, (uint8_t *) (&this->voltage_), 1); }
 
-void GP8403Component::setup() { this->write_register(RANGE_REGISTER, (uint8_t *) (&this->voltage_), 1); }
-
-void GP8403Component::dump_config() {
+void GP8403::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "GP8403:\n"
-                "  Voltage: %dV\n"
-                "  Model: %s",
-                this->voltage_ == GP8403_VOLTAGE_5V ? 5 : 10, LOG_STR_ARG(model_to_string(this->model_)));
+                "  Voltage: %dV",
+                this->voltage_ == GP8403_VOLTAGE_5V ? 5 : 10);
   LOG_I2C_DEVICE(this);
 }
 
-void GP8403Component::write_state(float state, uint8_t channel) {
-  uint16_t val = 0;
-  switch (this->model_) {
-    case GP8403Model::GP8403:
-      val = ((uint16_t) (4095 * state)) << 4;
-      break;
-    case GP8403Model::GP8413:
-      val = ((uint16_t) (32767 * state)) << 1;
-      break;
-    default:
-      ESP_LOGE(TAG, "Unknown model %s", LOG_STR_ARG(model_to_string(this->model_)));
-      return;
-  }
-  ESP_LOGV(TAG, "Calculated DAC value: %" PRIu16, val);
-  i2c::ErrorCode err = this->write_register(OUTPUT_REGISTER + (2 * channel), (uint8_t *) &val, 2);
-  if (err != i2c::ERROR_OK) {
-    ESP_LOGE(TAG, "Error writing to %s, code %d", LOG_STR_ARG(model_to_string(this->model_)), err);
-  }
-}
-
 }  // namespace gp8403
 }  // namespace esphome

esphome/components/gp8403/gp8403.h

@@ -11,24 +11,15 @@ enum GP8403Voltage {
   GP8403_VOLTAGE_10V = 0x11,
 };
 
-enum GP8403Model {
-  GP8403,
-  GP8413,
-};
-
-class GP8403Component : public Component, public i2c::I2CDevice {
+class GP8403 : public Component, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
-  void set_model(GP8403Model model) { this->model_ = model; }
-  void set_voltage(gp8403::GP8403Voltage voltage) { this->voltage_ = voltage; }
 
-  void write_state(float state, uint8_t channel);
+  void set_voltage(gp8403::GP8403Voltage voltage) { this->voltage_ = voltage; }
 
  protected:
   GP8403Voltage voltage_;
-  GP8403Model model_{GP8403Model::GP8403};
 };
 
 }  // namespace gp8403

esphome/components/gp8403/output/__init__.py

@@ -3,7 +3,7 @@ from esphome.components import i2c, output
 import esphome.config_validation as cv
 from esphome.const import CONF_CHANNEL, CONF_ID
 
-from .. import CONF_GP8403_ID, GP8403Component, gp8403_ns
+from .. import CONF_GP8403_ID, GP8403, gp8403_ns
 
 DEPENDENCIES = ["gp8403"]
 
@@ -14,7 +14,7 @@ GP8403Output = gp8403_ns.class_(
 CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
     {
         cv.GenerateID(): cv.declare_id(GP8403Output),
-        cv.GenerateID(CONF_GP8403_ID): cv.use_id(GP8403Component),
+        cv.GenerateID(CONF_GP8403_ID): cv.use_id(GP8403),
         cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=1),
     }
 ).extend(cv.COMPONENT_SCHEMA)

esphome/components/gp8403/output/gp8403_output.cpp

@@ -7,6 +7,8 @@ namespace gp8403 {
 
 static const char *const TAG = "gp8403.output";
 
+static const uint8_t OUTPUT_REGISTER = 0x02;
+
 void GP8403Output::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "GP8403 Output:\n"
@@ -14,7 +16,13 @@ void GP8403Output::dump_config() {
                 this->channel_);
 }
 
-void GP8403Output::write_state(float state) { this->parent_->write_state(state, this->channel_); }
+void GP8403Output::write_state(float state) {
+  uint16_t value = ((uint16_t) (state * 4095)) << 4;
+  i2c::ErrorCode err = this->parent_->write_register(OUTPUT_REGISTER + (2 * this->channel_), (uint8_t *) &value, 2);
+  if (err != i2c::ERROR_OK) {
+    ESP_LOGE(TAG, "Error writing to GP8403, code %d", err);
+  }
+}
 
 }  // namespace gp8403
 }  // namespace esphome

esphome/components/gp8403/output/gp8403_output.h

@@ -8,11 +8,13 @@
 namespace esphome {
 namespace gp8403 {
 
-class GP8403Output : public Component, public output::FloatOutput, public Parented<GP8403Component> {
+class GP8403Output : public Component, public output::FloatOutput, public Parented<GP8403> {
  public:
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::DATA - 1; }
+
   void set_channel(uint8_t channel) { this->channel_ = channel; }
+
   void write_state(float state) override;
 
  protected:

esphome/components/graph/graph.cpp

@@ -235,7 +235,7 @@ void GraphLegend::init(Graph *g) {
       std::string valstr =
           value_accuracy_to_string(trace->sensor_->get_state(), trace->sensor_->get_accuracy_decimals());
       if (this->units_) {
-        valstr += trace->sensor_->get_unit_of_measurement_ref();
+        valstr += trace->sensor_->get_unit_of_measurement();
       }
       this->font_value_->measure(valstr.c_str(), &fw, &fos, &fbl, &fh);
       if (fw > valw)
@@ -371,7 +371,7 @@ void Graph::draw_legend(display::Display *buff, uint16_t x_offset, uint16_t y_of
       std::string valstr =
           value_accuracy_to_string(trace->sensor_->get_state(), trace->sensor_->get_accuracy_decimals());
       if (legend_->units_) {
-        valstr += trace->sensor_->get_unit_of_measurement_ref();
+        valstr += trace->sensor_->get_unit_of_measurement();
       }
       buff->printf(xv, yv, legend_->font_value_, trace->get_line_color(), TextAlign::TOP_CENTER, "%s", valstr.c_str());
       ESP_LOGV(TAG, "    value: %s", valstr.c_str());

esphome/components/gt911/touchscreen/gt911_touchscreen.cpp

@@ -34,8 +34,8 @@ void GT911Touchscreen::setup() {
       this->interrupt_pin_->digital_write(false);
     }
     delay(2);
-    this->reset_pin_->digital_write(true);  // wait at least T3+T4 ms as per the datasheet
-    this->set_timeout(5 + 50 + 1, [this] { this->setup_internal_(); });
+    this->reset_pin_->digital_write(true);  // wait 50ms after reset
+    this->set_timeout(50, [this] { this->setup_internal_(); });
     return;
   }
   this->setup_internal_();

esphome/components/hlk_fm22x/__init__.py

@@ -1,247 +0,0 @@
-from esphome import automation
-import esphome.codegen as cg
-from esphome.components import uart
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_DIRECTION,
-    CONF_ID,
-    CONF_NAME,
-    CONF_ON_ENROLLMENT_DONE,
-    CONF_ON_ENROLLMENT_FAILED,
-    CONF_TRIGGER_ID,
-)
-
-CODEOWNERS = ["@OnFreund"]
-DEPENDENCIES = ["uart"]
-AUTO_LOAD = ["binary_sensor", "sensor", "text_sensor"]
-MULTI_CONF = True
-
-CONF_HLK_FM22X_ID = "hlk_fm22x_id"
-CONF_FACE_ID = "face_id"
-CONF_ON_FACE_SCAN_MATCHED = "on_face_scan_matched"
-CONF_ON_FACE_SCAN_UNMATCHED = "on_face_scan_unmatched"
-CONF_ON_FACE_SCAN_INVALID = "on_face_scan_invalid"
-CONF_ON_FACE_INFO = "on_face_info"
-
-hlk_fm22x_ns = cg.esphome_ns.namespace("hlk_fm22x")
-HlkFm22xComponent = hlk_fm22x_ns.class_(
-    "HlkFm22xComponent", cg.PollingComponent, uart.UARTDevice
-)
-
-FaceScanMatchedTrigger = hlk_fm22x_ns.class_(
-    "FaceScanMatchedTrigger", automation.Trigger.template(cg.int16, cg.std_string)
-)
-
-FaceScanUnmatchedTrigger = hlk_fm22x_ns.class_(
-    "FaceScanUnmatchedTrigger", automation.Trigger.template()
-)
-
-FaceScanInvalidTrigger = hlk_fm22x_ns.class_(
-    "FaceScanInvalidTrigger", automation.Trigger.template(cg.uint8)
-)
-
-FaceInfoTrigger = hlk_fm22x_ns.class_(
-    "FaceInfoTrigger",
-    automation.Trigger.template(
-        cg.int16, cg.int16, cg.int16, cg.int16, cg.int16, cg.int16, cg.int16, cg.int16
-    ),
-)
-
-EnrollmentDoneTrigger = hlk_fm22x_ns.class_(
-    "EnrollmentDoneTrigger", automation.Trigger.template(cg.int16, cg.uint8)
-)
-
-EnrollmentFailedTrigger = hlk_fm22x_ns.class_(
-    "EnrollmentFailedTrigger", automation.Trigger.template(cg.uint8)
-)
-
-EnrollmentAction = hlk_fm22x_ns.class_("EnrollmentAction", automation.Action)
-DeleteAction = hlk_fm22x_ns.class_("DeleteAction", automation.Action)
-DeleteAllAction = hlk_fm22x_ns.class_("DeleteAllAction", automation.Action)
-ScanAction = hlk_fm22x_ns.class_("ScanAction", automation.Action)
-ResetAction = hlk_fm22x_ns.class_("ResetAction", automation.Action)
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(HlkFm22xComponent),
-            cv.Optional(CONF_ON_FACE_SCAN_MATCHED): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        FaceScanMatchedTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_FACE_SCAN_UNMATCHED): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        FaceScanUnmatchedTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_FACE_SCAN_INVALID): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        FaceScanInvalidTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_FACE_INFO): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(FaceInfoTrigger),
-                }
-            ),
-            cv.Optional(CONF_ON_ENROLLMENT_DONE): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        EnrollmentDoneTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_ENROLLMENT_FAILED): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        EnrollmentFailedTrigger
-                    ),
-                }
-            ),
-        }
-    )
-    .extend(cv.polling_component_schema("50ms"))
-    .extend(uart.UART_DEVICE_SCHEMA),
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await uart.register_uart_device(var, config)
-
-    for conf in config.get(CONF_ON_FACE_SCAN_MATCHED, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(
-            trigger, [(cg.int16, "face_id"), (cg.std_string, "name")], conf
-        )
-
-    for conf in config.get(CONF_ON_FACE_SCAN_UNMATCHED, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [], conf)
-
-    for conf in config.get(CONF_ON_FACE_SCAN_INVALID, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [(cg.uint8, "error")], conf)
-
-    for conf in config.get(CONF_ON_FACE_INFO, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(
-            trigger,
-            [
-                (cg.int16, "status"),
-                (cg.int16, "left"),
-                (cg.int16, "top"),
-                (cg.int16, "right"),
-                (cg.int16, "bottom"),
-                (cg.int16, "yaw"),
-                (cg.int16, "pitch"),
-                (cg.int16, "roll"),
-            ],
-            conf,
-        )
-
-    for conf in config.get(CONF_ON_ENROLLMENT_DONE, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(
-            trigger, [(cg.int16, "face_id"), (cg.uint8, "direction")], conf
-        )
-
-    for conf in config.get(CONF_ON_ENROLLMENT_FAILED, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [(cg.uint8, "error")], conf)
-
-
-@automation.register_action(
-    "hlk_fm22x.enroll",
-    EnrollmentAction,
-    cv.maybe_simple_value(
-        {
-            cv.GenerateID(): cv.use_id(HlkFm22xComponent),
-            cv.Required(CONF_NAME): cv.templatable(cv.string),
-            cv.Required(CONF_DIRECTION): cv.templatable(cv.uint8_t),
-        },
-        key=CONF_NAME,
-    ),
-)
-async def hlk_fm22x_enroll_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-
-    template_ = await cg.templatable(config[CONF_NAME], args, cg.std_string)
-    cg.add(var.set_name(template_))
-    template_ = await cg.templatable(config[CONF_DIRECTION], args, cg.uint8)
-    cg.add(var.set_direction(template_))
-    return var
-
-
-@automation.register_action(
-    "hlk_fm22x.delete",
-    DeleteAction,
-    cv.maybe_simple_value(
-        {
-            cv.GenerateID(): cv.use_id(HlkFm22xComponent),
-            cv.Required(CONF_FACE_ID): cv.templatable(cv.uint16_t),
-        },
-        key=CONF_FACE_ID,
-    ),
-)
-async def hlk_fm22x_delete_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-
-    template_ = await cg.templatable(config[CONF_FACE_ID], args, cg.int16)
-    cg.add(var.set_face_id(template_))
-    return var
-
-
-@automation.register_action(
-    "hlk_fm22x.delete_all",
-    DeleteAllAction,
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(HlkFm22xComponent),
-        }
-    ),
-)
-async def hlk_fm22x_delete_all_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-@automation.register_action(
-    "hlk_fm22x.scan",
-    ScanAction,
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(HlkFm22xComponent),
-        }
-    ),
-)
-async def hlk_fm22x_scan_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-@automation.register_action(
-    "hlk_fm22x.reset",
-    ResetAction,
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(HlkFm22xComponent),
-        }
-    ),
-)
-async def hlk_fm22x_reset_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var

esphome/components/hlk_fm22x/binary_sensor.py

@@ -1,21 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import binary_sensor
-import esphome.config_validation as cv
-from esphome.const import CONF_ICON, ICON_KEY_PLUS
-
-from . import CONF_HLK_FM22X_ID, HlkFm22xComponent
-
-DEPENDENCIES = ["hlk_fm22x"]
-
-CONFIG_SCHEMA = binary_sensor.binary_sensor_schema().extend(
-    {
-        cv.GenerateID(CONF_HLK_FM22X_ID): cv.use_id(HlkFm22xComponent),
-        cv.Optional(CONF_ICON, default=ICON_KEY_PLUS): cv.icon,
-    }
-)
-
-
-async def to_code(config):
-    hub = await cg.get_variable(config[CONF_HLK_FM22X_ID])
-    var = await binary_sensor.new_binary_sensor(config)
-    cg.add(hub.set_enrolling_binary_sensor(var))

esphome/components/hlk_fm22x/hlk_fm22x.cpp

@@ -1,325 +0,0 @@
-#include "hlk_fm22x.h"
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
-#include <array>
-#include <cinttypes>
-
-namespace esphome::hlk_fm22x {
-
-static const char *const TAG = "hlk_fm22x";
-
-void HlkFm22xComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up HLK-FM22X...");
-  this->set_enrolling_(false);
-  while (this->available()) {
-    this->read();
-  }
-  this->defer([this]() { this->send_command_(HlkFm22xCommand::GET_STATUS); });
-}
-
-void HlkFm22xComponent::update() {
-  if (this->active_command_ != HlkFm22xCommand::NONE) {
-    if (this->wait_cycles_ > 600) {
-      ESP_LOGE(TAG, "Command 0x%.2X timed out", this->active_command_);
-      if (HlkFm22xCommand::RESET == this->active_command_) {
-        this->mark_failed();
-      } else {
-        this->reset();
-      }
-    }
-  }
-  this->recv_command_();
-}
-
-void HlkFm22xComponent::enroll_face(const std::string &name, HlkFm22xFaceDirection direction) {
-  if (name.length() > 31) {
-    ESP_LOGE(TAG, "enroll_face(): name too long '%s'", name.c_str());
-    return;
-  }
-  ESP_LOGI(TAG, "Starting enrollment for %s", name.c_str());
-  std::array<uint8_t, 35> data{};
-  data[0] = 0;  // admin
-  std::copy(name.begin(), name.end(), data.begin() + 1);
-  // Remaining bytes are already zero-initialized
-  data[33] = (uint8_t) direction;
-  data[34] = 10;  // timeout
-  this->send_command_(HlkFm22xCommand::ENROLL, data.data(), data.size());
-  this->set_enrolling_(true);
-}
-
-void HlkFm22xComponent::scan_face() {
-  ESP_LOGI(TAG, "Verify face");
-  static const uint8_t DATA[] = {0, 0};
-  this->send_command_(HlkFm22xCommand::VERIFY, DATA, sizeof(DATA));
-}
-
-void HlkFm22xComponent::delete_face(int16_t face_id) {
-  ESP_LOGI(TAG, "Deleting face in slot %d", face_id);
-  const uint8_t data[] = {(uint8_t) (face_id >> 8), (uint8_t) (face_id & 0xFF)};
-  this->send_command_(HlkFm22xCommand::DELETE_FACE, data, sizeof(data));
-}
-
-void HlkFm22xComponent::delete_all_faces() {
-  ESP_LOGI(TAG, "Deleting all stored faces");
-  this->send_command_(HlkFm22xCommand::DELETE_ALL_FACES);
-}
-
-void HlkFm22xComponent::get_face_count_() {
-  ESP_LOGD(TAG, "Getting face count");
-  this->send_command_(HlkFm22xCommand::GET_ALL_FACE_IDS);
-}
-
-void HlkFm22xComponent::reset() {
-  ESP_LOGI(TAG, "Resetting module");
-  this->active_command_ = HlkFm22xCommand::NONE;
-  this->wait_cycles_ = 0;
-  this->set_enrolling_(false);
-  this->send_command_(HlkFm22xCommand::RESET);
-}
-
-void HlkFm22xComponent::send_command_(HlkFm22xCommand command, const uint8_t *data, size_t size) {
-  ESP_LOGV(TAG, "Send command: 0x%.2X", command);
-  if (this->active_command_ != HlkFm22xCommand::NONE) {
-    ESP_LOGW(TAG, "Command 0x%.2X already active", this->active_command_);
-    return;
-  }
-  this->wait_cycles_ = 0;
-  this->active_command_ = command;
-  while (this->available())
-    this->read();
-  this->write((uint8_t) (START_CODE >> 8));
-  this->write((uint8_t) (START_CODE & 0xFF));
-  this->write((uint8_t) command);
-  uint16_t data_size = size;
-  this->write((uint8_t) (data_size >> 8));
-  this->write((uint8_t) (data_size & 0xFF));
-
-  uint8_t checksum = 0;
-  checksum ^= (uint8_t) command;
-  checksum ^= (data_size >> 8);
-  checksum ^= (data_size & 0xFF);
-  for (size_t i = 0; i < size; i++) {
-    this->write(data[i]);
-    checksum ^= data[i];
-  }
-
-  this->write(checksum);
-  this->active_command_ = command;
-  this->wait_cycles_ = 0;
-}
-
-void HlkFm22xComponent::recv_command_() {
-  uint8_t byte, checksum = 0;
-  uint16_t length = 0;
-
-  if (this->available() < 7) {
-    ++this->wait_cycles_;
-    return;
-  }
-  this->wait_cycles_ = 0;
-
-  if ((this->read() != (uint8_t) (START_CODE >> 8)) || (this->read() != (uint8_t) (START_CODE & 0xFF))) {
-    ESP_LOGE(TAG, "Invalid start code");
-    return;
-  }
-
-  byte = this->read();
-  checksum ^= byte;
-  HlkFm22xResponseType response_type = (HlkFm22xResponseType) byte;
-
-  byte = this->read();
-  checksum ^= byte;
-  length = byte << 8;
-  byte = this->read();
-  checksum ^= byte;
-  length |= byte;
-
-  std::vector<uint8_t> data;
-  data.reserve(length);
-  for (uint16_t idx = 0; idx < length; ++idx) {
-    byte = this->read();
-    checksum ^= byte;
-    data.push_back(byte);
-  }
-
-  ESP_LOGV(TAG, "Recv type: 0x%.2X, data: %s", response_type, format_hex_pretty(data).c_str());
-
-  byte = this->read();
-  if (byte != checksum) {
-    ESP_LOGE(TAG, "Invalid checksum for data. Calculated: 0x%.2X, Received: 0x%.2X", checksum, byte);
-    return;
-  }
-  switch (response_type) {
-    case HlkFm22xResponseType::NOTE:
-      this->handle_note_(data);
-      break;
-    case HlkFm22xResponseType::REPLY:
-      this->handle_reply_(data);
-      break;
-    default:
-      ESP_LOGW(TAG, "Unexpected response type: 0x%.2X", response_type);
-      break;
-  }
-}
-
-void HlkFm22xComponent::handle_note_(const std::vector<uint8_t> &data) {
-  switch (data[0]) {
-    case HlkFm22xNoteType::FACE_STATE:
-      if (data.size() < 17) {
-        ESP_LOGE(TAG, "Invalid face note data size: %u", data.size());
-        break;
-      }
-      {
-        int16_t info[8];
-        uint8_t offset = 1;
-        for (int16_t &i : info) {
-          i = ((int16_t) data[offset + 1] << 8) | data[offset];
-          offset += 2;
-        }
-        ESP_LOGV(TAG, "Face state: status: %d, left: %d, top: %d, right: %d, bottom: %d, yaw: %d, pitch: %d, roll: %d",
-                 info[0], info[1], info[2], info[3], info[4], info[5], info[6], info[7]);
-        this->face_info_callback_.call(info[0], info[1], info[2], info[3], info[4], info[5], info[6], info[7]);
-      }
-      break;
-    case HlkFm22xNoteType::READY:
-      ESP_LOGE(TAG, "Command 0x%.2X timed out", this->active_command_);
-      switch (this->active_command_) {
-        case HlkFm22xCommand::ENROLL:
-          this->set_enrolling_(false);
-          this->enrollment_failed_callback_.call(HlkFm22xResult::FAILED4_TIMEOUT);
-          break;
-        case HlkFm22xCommand::VERIFY:
-          this->face_scan_invalid_callback_.call(HlkFm22xResult::FAILED4_TIMEOUT);
-          break;
-        default:
-          break;
-      }
-      this->active_command_ = HlkFm22xCommand::NONE;
-      this->wait_cycles_ = 0;
-      break;
-    default:
-      ESP_LOGW(TAG, "Unhandled note: 0x%.2X", data[0]);
-      break;
-  }
-}
-
-void HlkFm22xComponent::handle_reply_(const std::vector<uint8_t> &data) {
-  auto expected = this->active_command_;
-  this->active_command_ = HlkFm22xCommand::NONE;
-  if (data[0] != (uint8_t) expected) {
-    ESP_LOGE(TAG, "Unexpected response command. Expected: 0x%.2X, Received: 0x%.2X", expected, data[0]);
-    return;
-  }
-
-  if (data[1] != HlkFm22xResult::SUCCESS) {
-    ESP_LOGE(TAG, "Command <0x%.2X> failed. Error: 0x%.2X", data[0], data[1]);
-    switch (expected) {
-      case HlkFm22xCommand::ENROLL:
-        this->set_enrolling_(false);
-        this->enrollment_failed_callback_.call(data[1]);
-        break;
-      case HlkFm22xCommand::VERIFY:
-        if (data[1] == HlkFm22xResult::REJECTED) {
-          this->face_scan_unmatched_callback_.call();
-        } else {
-          this->face_scan_invalid_callback_.call(data[1]);
-        }
-        break;
-      default:
-        break;
-    }
-    return;
-  }
-  switch (expected) {
-    case HlkFm22xCommand::VERIFY: {
-      int16_t face_id = ((int16_t) data[2] << 8) | data[3];
-      std::string name(data.begin() + 4, data.begin() + 36);
-      ESP_LOGD(TAG, "Face verified. ID: %d, name: %s", face_id, name.c_str());
-      if (this->last_face_id_sensor_ != nullptr) {
-        this->last_face_id_sensor_->publish_state(face_id);
-      }
-      if (this->last_face_name_text_sensor_ != nullptr) {
-        this->last_face_name_text_sensor_->publish_state(name);
-      }
-      this->face_scan_matched_callback_.call(face_id, name);
-      break;
-    }
-    case HlkFm22xCommand::ENROLL: {
-      int16_t face_id = ((int16_t) data[2] << 8) | data[3];
-      HlkFm22xFaceDirection direction = (HlkFm22xFaceDirection) data[4];
-      ESP_LOGI(TAG, "Face enrolled. ID: %d, Direction: 0x%.2X", face_id, direction);
-      this->enrollment_done_callback_.call(face_id, (uint8_t) direction);
-      this->set_enrolling_(false);
-      this->defer([this]() { this->get_face_count_(); });
-      break;
-    }
-    case HlkFm22xCommand::GET_STATUS:
-      if (this->status_sensor_ != nullptr) {
-        this->status_sensor_->publish_state(data[2]);
-      }
-      this->defer([this]() { this->send_command_(HlkFm22xCommand::GET_VERSION); });
-      break;
-    case HlkFm22xCommand::GET_VERSION:
-      if (this->version_text_sensor_ != nullptr) {
-        std::string version(data.begin() + 2, data.end());
-        this->version_text_sensor_->publish_state(version);
-      }
-      this->defer([this]() { this->get_face_count_(); });
-      break;
-    case HlkFm22xCommand::GET_ALL_FACE_IDS:
-      if (this->face_count_sensor_ != nullptr) {
-        this->face_count_sensor_->publish_state(data[2]);
-      }
-      break;
-    case HlkFm22xCommand::DELETE_FACE:
-      ESP_LOGI(TAG, "Deleted face");
-      break;
-    case HlkFm22xCommand::DELETE_ALL_FACES:
-      ESP_LOGI(TAG, "Deleted all faces");
-      break;
-    case HlkFm22xCommand::RESET:
-      ESP_LOGI(TAG, "Module reset");
-      this->defer([this]() { this->send_command_(HlkFm22xCommand::GET_STATUS); });
-      break;
-    default:
-      ESP_LOGW(TAG, "Unhandled command: 0x%.2X", this->active_command_);
-      break;
-  }
-}
-
-void HlkFm22xComponent::set_enrolling_(bool enrolling) {
-  if (this->enrolling_binary_sensor_ != nullptr) {
-    this->enrolling_binary_sensor_->publish_state(enrolling);
-  }
-}
-
-void HlkFm22xComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "HLK_FM22X:");
-  LOG_UPDATE_INTERVAL(this);
-  if (this->version_text_sensor_) {
-    LOG_TEXT_SENSOR("  ", "Version", this->version_text_sensor_);
-    ESP_LOGCONFIG(TAG, "    Current Value: %s", this->version_text_sensor_->get_state().c_str());
-  }
-  if (this->enrolling_binary_sensor_) {
-    LOG_BINARY_SENSOR("  ", "Enrolling", this->enrolling_binary_sensor_);
-    ESP_LOGCONFIG(TAG, "    Current Value: %s", this->enrolling_binary_sensor_->state ? "ON" : "OFF");
-  }
-  if (this->face_count_sensor_) {
-    LOG_SENSOR("  ", "Face Count", this->face_count_sensor_);
-    ESP_LOGCONFIG(TAG, "    Current Value: %u", (uint16_t) this->face_count_sensor_->get_state());
-  }
-  if (this->status_sensor_) {
-    LOG_SENSOR("  ", "Status", this->status_sensor_);
-    ESP_LOGCONFIG(TAG, "    Current Value: %u", (uint8_t) this->status_sensor_->get_state());
-  }
-  if (this->last_face_id_sensor_) {
-    LOG_SENSOR("  ", "Last Face ID", this->last_face_id_sensor_);
-    ESP_LOGCONFIG(TAG, "    Current Value: %u", (int16_t) this->last_face_id_sensor_->get_state());
-  }
-  if (this->last_face_name_text_sensor_) {
-    LOG_TEXT_SENSOR("  ", "Last Face Name", this->last_face_name_text_sensor_);
-    ESP_LOGCONFIG(TAG, "    Current Value: %s", this->last_face_name_text_sensor_->get_state().c_str());
-  }
-}
-
-}  // namespace esphome::hlk_fm22x

esphome/components/hlk_fm22x/hlk_fm22x.h

@@ -1,224 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/core/automation.h"
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/binary_sensor/binary_sensor.h"
-#include "esphome/components/text_sensor/text_sensor.h"
-#include "esphome/components/uart/uart.h"
-
-#include <utility>
-#include <vector>
-
-namespace esphome::hlk_fm22x {
-
-static const uint16_t START_CODE = 0xEFAA;
-enum HlkFm22xCommand {
-  NONE = 0x00,
-  RESET = 0x10,
-  GET_STATUS = 0x11,
-  VERIFY = 0x12,
-  ENROLL = 0x13,
-  DELETE_FACE = 0x20,
-  DELETE_ALL_FACES = 0x21,
-  GET_ALL_FACE_IDS = 0x24,
-  GET_VERSION = 0x30,
-  GET_SERIAL_NUMBER = 0x93,
-};
-
-enum HlkFm22xResponseType {
-  REPLY = 0x00,
-  NOTE = 0x01,
-  IMAGE = 0x02,
-};
-
-enum HlkFm22xNoteType {
-  READY = 0x00,
-  FACE_STATE = 0x01,
-};
-
-enum HlkFm22xResult {
-  SUCCESS = 0x00,
-  REJECTED = 0x01,
-  ABORTED = 0x02,
-  FAILED4_CAMERA = 0x04,
-  FAILED4_UNKNOWNREASON = 0x05,
-  FAILED4_INVALIDPARAM = 0x06,
-  FAILED4_NOMEMORY = 0x07,
-  FAILED4_UNKNOWNUSER = 0x08,
-  FAILED4_MAXUSER = 0x09,
-  FAILED4_FACEENROLLED = 0x0A,
-  FAILED4_LIVENESSCHECK = 0x0C,
-  FAILED4_TIMEOUT = 0x0D,
-  FAILED4_AUTHORIZATION = 0x0E,
-  FAILED4_READ_FILE = 0x13,
-  FAILED4_WRITE_FILE = 0x14,
-  FAILED4_NO_ENCRYPT = 0x15,
-  FAILED4_NO_RGBIMAGE = 0x17,
-  FAILED4_JPGPHOTO_LARGE = 0x18,
-  FAILED4_JPGPHOTO_SMALL = 0x19,
-};
-
-enum HlkFm22xFaceDirection {
-  FACE_DIRECTION_UNDEFINED = 0x00,
-  FACE_DIRECTION_MIDDLE = 0x01,
-  FACE_DIRECTION_RIGHT = 0x02,
-  FACE_DIRECTION_LEFT = 0x04,
-  FACE_DIRECTION_DOWN = 0x08,
-  FACE_DIRECTION_UP = 0x10,
-};
-
-class HlkFm22xComponent : public PollingComponent, public uart::UARTDevice {
- public:
-  void setup() override;
-  void update() override;
-  void dump_config() override;
-
-  void set_face_count_sensor(sensor::Sensor *face_count_sensor) { this->face_count_sensor_ = face_count_sensor; }
-  void set_status_sensor(sensor::Sensor *status_sensor) { this->status_sensor_ = status_sensor; }
-  void set_last_face_id_sensor(sensor::Sensor *last_face_id_sensor) {
-    this->last_face_id_sensor_ = last_face_id_sensor;
-  }
-  void set_last_face_name_text_sensor(text_sensor::TextSensor *last_face_name_text_sensor) {
-    this->last_face_name_text_sensor_ = last_face_name_text_sensor;
-  }
-  void set_enrolling_binary_sensor(binary_sensor::BinarySensor *enrolling_binary_sensor) {
-    this->enrolling_binary_sensor_ = enrolling_binary_sensor;
-  }
-  void set_version_text_sensor(text_sensor::TextSensor *version_text_sensor) {
-    this->version_text_sensor_ = version_text_sensor;
-  }
-  void add_on_face_scan_matched_callback(std::function<void(int16_t, std::string)> callback) {
-    this->face_scan_matched_callback_.add(std::move(callback));
-  }
-  void add_on_face_scan_unmatched_callback(std::function<void()> callback) {
-    this->face_scan_unmatched_callback_.add(std::move(callback));
-  }
-  void add_on_face_scan_invalid_callback(std::function<void(uint8_t)> callback) {
-    this->face_scan_invalid_callback_.add(std::move(callback));
-  }
-  void add_on_face_info_callback(
-      std::function<void(int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t)> callback) {
-    this->face_info_callback_.add(std::move(callback));
-  }
-  void add_on_enrollment_done_callback(std::function<void(int16_t, uint8_t)> callback) {
-    this->enrollment_done_callback_.add(std::move(callback));
-  }
-  void add_on_enrollment_failed_callback(std::function<void(uint8_t)> callback) {
-    this->enrollment_failed_callback_.add(std::move(callback));
-  }
-
-  void enroll_face(const std::string &name, HlkFm22xFaceDirection direction);
-  void scan_face();
-  void delete_face(int16_t face_id);
-  void delete_all_faces();
-  void reset();
-
- protected:
-  void get_face_count_();
-  void send_command_(HlkFm22xCommand command, const uint8_t *data = nullptr, size_t size = 0);
-  void recv_command_();
-  void handle_note_(const std::vector<uint8_t> &data);
-  void handle_reply_(const std::vector<uint8_t> &data);
-  void set_enrolling_(bool enrolling);
-
-  HlkFm22xCommand active_command_ = HlkFm22xCommand::NONE;
-  uint16_t wait_cycles_ = 0;
-  sensor::Sensor *face_count_sensor_{nullptr};
-  sensor::Sensor *status_sensor_{nullptr};
-  sensor::Sensor *last_face_id_sensor_{nullptr};
-  binary_sensor::BinarySensor *enrolling_binary_sensor_{nullptr};
-  text_sensor::TextSensor *last_face_name_text_sensor_{nullptr};
-  text_sensor::TextSensor *version_text_sensor_{nullptr};
-  CallbackManager<void(uint8_t)> face_scan_invalid_callback_;
-  CallbackManager<void(int16_t, std::string)> face_scan_matched_callback_;
-  CallbackManager<void()> face_scan_unmatched_callback_;
-  CallbackManager<void(int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t)> face_info_callback_;
-  CallbackManager<void(int16_t, uint8_t)> enrollment_done_callback_;
-  CallbackManager<void(uint8_t)> enrollment_failed_callback_;
-};
-
-class FaceScanMatchedTrigger : public Trigger<int16_t, std::string> {
- public:
-  explicit FaceScanMatchedTrigger(HlkFm22xComponent *parent) {
-    parent->add_on_face_scan_matched_callback(
-        [this](int16_t face_id, const std::string &name) { this->trigger(face_id, name); });
-  }
-};
-
-class FaceScanUnmatchedTrigger : public Trigger<> {
- public:
-  explicit FaceScanUnmatchedTrigger(HlkFm22xComponent *parent) {
-    parent->add_on_face_scan_unmatched_callback([this]() { this->trigger(); });
-  }
-};
-
-class FaceScanInvalidTrigger : public Trigger<uint8_t> {
- public:
-  explicit FaceScanInvalidTrigger(HlkFm22xComponent *parent) {
-    parent->add_on_face_scan_invalid_callback([this](uint8_t error) { this->trigger(error); });
-  }
-};
-
-class FaceInfoTrigger : public Trigger<int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t> {
- public:
-  explicit FaceInfoTrigger(HlkFm22xComponent *parent) {
-    parent->add_on_face_info_callback(
-        [this](int16_t status, int16_t left, int16_t top, int16_t right, int16_t bottom, int16_t yaw, int16_t pitch,
-               int16_t roll) { this->trigger(status, left, top, right, bottom, yaw, pitch, roll); });
-  }
-};
-
-class EnrollmentDoneTrigger : public Trigger<int16_t, uint8_t> {
- public:
-  explicit EnrollmentDoneTrigger(HlkFm22xComponent *parent) {
-    parent->add_on_enrollment_done_callback(
-        [this](int16_t face_id, uint8_t direction) { this->trigger(face_id, direction); });
-  }
-};
-
-class EnrollmentFailedTrigger : public Trigger<uint8_t> {
- public:
-  explicit EnrollmentFailedTrigger(HlkFm22xComponent *parent) {
-    parent->add_on_enrollment_failed_callback([this](uint8_t error) { this->trigger(error); });
-  }
-};
-
-template<typename... Ts> class EnrollmentAction : public Action<Ts...>, public Parented<HlkFm22xComponent> {
- public:
-  TEMPLATABLE_VALUE(std::string, name)
-  TEMPLATABLE_VALUE(uint8_t, direction)
-
-  void play(Ts... x) override {
-    auto name = this->name_.value(x...);
-    auto direction = (HlkFm22xFaceDirection) this->direction_.value(x...);
-    this->parent_->enroll_face(name, direction);
-  }
-};
-
-template<typename... Ts> class DeleteAction : public Action<Ts...>, public Parented<HlkFm22xComponent> {
- public:
-  TEMPLATABLE_VALUE(int16_t, face_id)
-
-  void play(Ts... x) override {
-    auto face_id = this->face_id_.value(x...);
-    this->parent_->delete_face(face_id);
-  }
-};
-
-template<typename... Ts> class DeleteAllAction : public Action<Ts...>, public Parented<HlkFm22xComponent> {
- public:
-  void play(Ts... x) override { this->parent_->delete_all_faces(); }
-};
-
-template<typename... Ts> class ScanAction : public Action<Ts...>, public Parented<HlkFm22xComponent> {
- public:
-  void play(Ts... x) override { this->parent_->scan_face(); }
-};
-
-template<typename... Ts> class ResetAction : public Action<Ts...>, public Parented<HlkFm22xComponent> {
- public:
-  void play(Ts... x) override { this->parent_->reset(); }
-};
-
-}  // namespace esphome::hlk_fm22x

esphome/components/hlk_fm22x/sensor.py

@@ -1,47 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import sensor
-import esphome.config_validation as cv
-from esphome.const import CONF_STATUS, ENTITY_CATEGORY_DIAGNOSTIC, ICON_ACCOUNT
-
-from . import CONF_HLK_FM22X_ID, HlkFm22xComponent
-
-DEPENDENCIES = ["hlk_fm22x"]
-
-CONF_FACE_COUNT = "face_count"
-CONF_LAST_FACE_ID = "last_face_id"
-ICON_FACE = "mdi:face-recognition"
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_HLK_FM22X_ID): cv.use_id(HlkFm22xComponent),
-        cv.Optional(CONF_FACE_COUNT): sensor.sensor_schema(
-            icon=ICON_FACE,
-            accuracy_decimals=0,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
-        cv.Optional(CONF_STATUS): sensor.sensor_schema(
-            accuracy_decimals=0,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
-        cv.Optional(CONF_LAST_FACE_ID): sensor.sensor_schema(
-            icon=ICON_ACCOUNT,
-            accuracy_decimals=0,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
-    }
-)
-
-
-async def to_code(config):
-    hub = await cg.get_variable(config[CONF_HLK_FM22X_ID])
-
-    for key in [
-        CONF_FACE_COUNT,
-        CONF_STATUS,
-        CONF_LAST_FACE_ID,
-    ]:
-        if key not in config:
-            continue
-        conf = config[key]
-        sens = await sensor.new_sensor(conf)
-        cg.add(getattr(hub, f"set_{key}_sensor")(sens))

esphome/components/hlk_fm22x/text_sensor.py

@@ -1,42 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import text_sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_VERSION,
-    ENTITY_CATEGORY_DIAGNOSTIC,
-    ICON_ACCOUNT,
-    ICON_RESTART,
-)
-
-from . import CONF_HLK_FM22X_ID, HlkFm22xComponent
-
-DEPENDENCIES = ["hlk_fm22x"]
-
-CONF_LAST_FACE_NAME = "last_face_name"
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_HLK_FM22X_ID): cv.use_id(HlkFm22xComponent),
-        cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
-            icon=ICON_RESTART,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
-        cv.Optional(CONF_LAST_FACE_NAME): text_sensor.text_sensor_schema(
-            icon=ICON_ACCOUNT,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
-    }
-)
-
-
-async def to_code(config):
-    hub = await cg.get_variable(config[CONF_HLK_FM22X_ID])
-    for key in [
-        CONF_VERSION,
-        CONF_LAST_FACE_NAME,
-    ]:
-        if key not in config:
-            continue
-        conf = config[key]
-        sens = await text_sensor.new_text_sensor(conf)
-        cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))

esphome/components/hm3301/aqi_calculator.h

@@ -1,7 +1,7 @@
 #pragma once
-#include <climits>
+
 #include "abstract_aqi_calculator.h"
-// https://document.airnow.gov/technical-assistance-document-for-the-reporting-of-daily-air-quailty.pdf
+// https://www.airnow.gov/sites/default/files/2020-05/aqi-technical-assistance-document-sept2018.pdf
 
 namespace esphome {
 namespace hm3301 {
@@ -16,15 +16,16 @@ class AQICalculator : public AbstractAQICalculator {
   }
 
  protected:
-  static const int AMOUNT_OF_LEVELS = 6;
+  static const int AMOUNT_OF_LEVELS = 7;
 
-  int index_grid_[AMOUNT_OF_LEVELS][2] = {{0, 50}, {51, 100}, {101, 150}, {151, 200}, {201, 300}, {301, 500}};
+  int index_grid_[AMOUNT_OF_LEVELS][2] = {{0, 50},    {51, 100},  {101, 150}, {151, 200},
+                                          {201, 300}, {301, 400}, {401, 500}};
 
-  int pm2_5_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 9},    {10, 35},   {36, 55},
-                                                      {56, 125}, {126, 225}, {226, INT_MAX}};
+  int pm2_5_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 12},    {13, 35},   {36, 55},  {56, 150},
+                                                      {151, 250}, {251, 350}, {351, 500}};
 
-  int pm10_0_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 54},    {55, 154},  {155, 254},
-                                                       {255, 354}, {355, 424}, {425, INT_MAX}};
+  int pm10_0_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 54},    {55, 154},  {155, 254}, {255, 354},
+                                                       {355, 424}, {425, 504}, {505, 604}};
 
   int calculate_index_(uint16_t value, int array[AMOUNT_OF_LEVELS][2]) {
     int grid_index = get_grid_index_(value, array);

esphome/components/homeassistant/time/homeassistant_time.cpp

@@ -7,8 +7,10 @@ namespace homeassistant {
 static const char *const TAG = "homeassistant.time";
 
 void HomeassistantTime::dump_config() {
-  ESP_LOGCONFIG(TAG, "Home Assistant Time");
-  RealTimeClock::dump_config();
+  ESP_LOGCONFIG(TAG,
+                "Home Assistant Time:\n"
+                "  Timezone: '%s'",
+                this->timezone_.c_str());
 }
 
 float HomeassistantTime::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/improv_serial/improv_serial_component.cpp

@@ -231,7 +231,7 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
       this->connecting_sta_ = sta;
 
       wifi::global_wifi_component->set_sta(sta);
-      wifi::global_wifi_component->start_connecting(sta);
+      wifi::global_wifi_component->start_connecting(sta, false);
       this->set_state_(improv::STATE_PROVISIONING);
       ESP_LOGD(TAG, "Received settings: SSID=%s, password=" LOG_SECRET("%s"), command.ssid.c_str(),
                command.password.c_str());

esphome/components/lcd_gpio/gpio_lcd_display.h

@@ -2,18 +2,13 @@
 
 #include "esphome/core/hal.h"
 #include "esphome/components/lcd_base/lcd_display.h"
-#include "esphome/components/display/display.h"
 
 namespace esphome {
 namespace lcd_gpio {
 
-class GPIOLCDDisplay;
-
-using gpio_lcd_writer_t = display::DisplayWriter<GPIOLCDDisplay>;
-
 class GPIOLCDDisplay : public lcd_base::LCDDisplay {
  public:
-  void set_writer(gpio_lcd_writer_t &&writer) { this->writer_ = std::move(writer); }
+  void set_writer(std::function<void(GPIOLCDDisplay &)> &&writer) { this->writer_ = std::move(writer); }
   void setup() override;
   void set_data_pins(GPIOPin *d0, GPIOPin *d1, GPIOPin *d2, GPIOPin *d3) {
     this->data_pins_[0] = d0;
@@ -48,7 +43,7 @@ class GPIOLCDDisplay : public lcd_base::LCDDisplay {
   GPIOPin *rw_pin_{nullptr};
   GPIOPin *enable_pin_{nullptr};
   GPIOPin *data_pins_[8]{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
-  gpio_lcd_writer_t writer_;
+  std::function<void(GPIOLCDDisplay &)> writer_;
 };
 
 }  // namespace lcd_gpio

esphome/components/lcd_pcf8574/pcf8574_display.h

@@ -3,18 +3,13 @@
 #include "esphome/core/component.h"
 #include "esphome/components/lcd_base/lcd_display.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/components/display/display.h"
 
 namespace esphome {
 namespace lcd_pcf8574 {
 
-class PCF8574LCDDisplay;
-
-using pcf8574_lcd_writer_t = display::DisplayWriter<PCF8574LCDDisplay>;
-
 class PCF8574LCDDisplay : public lcd_base::LCDDisplay, public i2c::I2CDevice {
  public:
-  void set_writer(pcf8574_lcd_writer_t &&writer) { this->writer_ = std::move(writer); }
+  void set_writer(std::function<void(PCF8574LCDDisplay &)> &&writer) { this->writer_ = std::move(writer); }
   void setup() override;
   void dump_config() override;
   void backlight();
@@ -29,7 +24,7 @@ class PCF8574LCDDisplay : public lcd_base::LCDDisplay, public i2c::I2CDevice {
 
   // Stores the current state of the backlight.
   uint8_t backlight_value_;
-  pcf8574_lcd_writer_t writer_;
+  std::function<void(PCF8574LCDDisplay &)> writer_;
 };
 
 }  // namespace lcd_pcf8574

esphome/components/ld2410/sensor.py

@@ -31,83 +31,35 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_LIGHTBULB,
         ),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
@@ -121,13 +73,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -135,13 +81,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/ld2412/sensor.py

@@ -31,84 +31,36 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_LIGHTBULB,
             unit_of_measurement=UNIT_EMPTY,  # No standard unit for this light sensor
         ),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
@@ -122,13 +74,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -136,13 +82,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/ld2420/ld2420.cpp

@@ -174,7 +174,7 @@ static uint8_t calc_checksum(void *data, size_t size) {
 static int get_firmware_int(const char *version_string) {
   std::string version_str = version_string;
   if (version_str[0] == 'v') {
-    version_str.erase(0, 1);
+    version_str = version_str.substr(1);
   }
   version_str.erase(remove(version_str.begin(), version_str.end(), '.'), version_str.end());
   int version_integer = stoi(version_str);

esphome/components/light/light_call.cpp

@@ -52,10 +52,8 @@ static void log_invalid_parameter(const char *name, const LogString *message) {
   }
 
 static const LogString *color_mode_to_human(ColorMode color_mode) {
-  if (color_mode == ColorMode::ON_OFF)
-    return LOG_STR("On/Off");
-  if (color_mode == ColorMode::BRIGHTNESS)
-    return LOG_STR("Brightness");
+  if (color_mode == ColorMode::UNKNOWN)
+    return LOG_STR("Unknown");
   if (color_mode == ColorMode::WHITE)
     return LOG_STR("White");
   if (color_mode == ColorMode::COLOR_TEMPERATURE)
@@ -70,7 +68,7 @@ static const LogString *color_mode_to_human(ColorMode color_mode) {
     return LOG_STR("RGB + cold/warm white");
   if (color_mode == ColorMode::RGB_COLOR_TEMPERATURE)
     return LOG_STR("RGB + color temperature");
-  return LOG_STR("Unknown");
+  return LOG_STR("");
 }
 
 // Helper to log percentage values
@@ -408,7 +406,7 @@ void LightCall::transform_parameters_() {
   }
 }
 ColorMode LightCall::compute_color_mode_() {
-  auto supported_modes = this->parent_->get_traits().get_supported_color_modes();
+  const auto &supported_modes = this->parent_->get_traits().get_supported_color_modes();
   int supported_count = supported_modes.size();
 
   // Some lights don't support any color modes (e.g. monochromatic light), leave it at unknown.

esphome/components/light/light_state.cpp

@@ -1,8 +1,7 @@
-#include "light_state.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
+
 #include "light_output.h"
+#include "light_state.h"
 #include "transformers.h"
 
 namespace esphome {
@@ -24,9 +23,6 @@ void LightState::setup() {
     effect->init_internal(this);
   }
 
-  // Start with loop disabled if idle - respects any effects/transitions set up during initialization
-  this->disable_loop_if_idle_();
-
   // When supported color temperature range is known, initialize color temperature setting within bounds.
   auto traits = this->get_traits();
   float min_mireds = traits.get_min_mireds();
@@ -129,9 +125,6 @@ void LightState::loop() {
       this->is_transformer_active_ = false;
       this->transformer_ = nullptr;
       this->target_state_reached_callback_.call();
-
-      // Disable loop if idle (no transformer and no effect)
-      this->disable_loop_if_idle_();
     }
   }
 
@@ -139,19 +132,12 @@ void LightState::loop() {
   if (this->next_write_) {
     this->next_write_ = false;
     this->output_->write_state(this);
-    // Disable loop if idle (no transformer and no effect)
-    this->disable_loop_if_idle_();
   }
 }
 
 float LightState::get_setup_priority() const { return setup_priority::HARDWARE - 1.0f; }
 
-void LightState::publish_state() {
-  this->remote_values_callback_.call();
-#if defined(USE_LIGHT) && defined(USE_CONTROLLER_REGISTRY)
-  ControllerRegistry::notify_light_update(this);
-#endif
-}
+void LightState::publish_state() { this->remote_values_callback_.call(); }
 
 LightOutput *LightState::get_output() const { return this->output_; }
 
@@ -236,8 +222,6 @@ void LightState::start_effect_(uint32_t effect_index) {
   this->active_effect_index_ = effect_index;
   auto *effect = this->get_active_effect_();
   effect->start_internal();
-  // Enable loop while effect is active
-  this->enable_loop();
 }
 LightEffect *LightState::get_active_effect_() {
   if (this->active_effect_index_ == 0) {
@@ -252,8 +236,6 @@ void LightState::stop_effect_() {
     effect->stop();
   }
   this->active_effect_index_ = 0;
-  // Disable loop if idle (no effect and no transformer)
-  this->disable_loop_if_idle_();
 }
 
 void LightState::start_transition_(const LightColorValues &target, uint32_t length, bool set_remote_values) {
@@ -263,8 +245,6 @@ void LightState::start_transition_(const LightColorValues &target, uint32_t leng
   if (set_remote_values) {
     this->remote_values = target;
   }
-  // Enable loop while transition is active
-  this->enable_loop();
 }
 
 void LightState::start_flash_(const LightColorValues &target, uint32_t length, bool set_remote_values) {
@@ -280,8 +260,6 @@ void LightState::start_flash_(const LightColorValues &target, uint32_t length, b
   if (set_remote_values) {
     this->remote_values = target;
   };
-  // Enable loop while flash is active
-  this->enable_loop();
 }
 
 void LightState::set_immediately_(const LightColorValues &target, bool set_remote_values) {
@@ -293,14 +271,6 @@ void LightState::set_immediately_(const LightColorValues &target, bool set_remot
   }
   this->output_->update_state(this);
   this->next_write_ = true;
-  this->enable_loop();
-}
-
-void LightState::disable_loop_if_idle_() {
-  // Only disable loop if both transformer and effect are inactive, and no pending writes
-  if (this->transformer_ == nullptr && this->get_active_effect_() == nullptr && !this->next_write_) {
-    this->disable_loop();
-  }
 }
 
 void LightState::save_remote_values_() {

esphome/components/light/light_state.h

@@ -256,9 +256,6 @@ class LightState : public EntityBase, public Component {
   /// Internal method to save the current remote_values to the preferences
   void save_remote_values_();
 
-  /// Disable loop if neither transformer nor effect is active
-  void disable_loop_if_idle_();
-
   /// Store the output to allow effects to have more access.
   LightOutput *output_;
   /// The currently active transformer for this light (transition/flash).

esphome/components/light/light_traits.h

@@ -18,8 +18,7 @@ class LightTraits {
  public:
   LightTraits() = default;
 
-  // Return by value to avoid dangling reference when get_traits() returns a temporary
-  ColorModeMask get_supported_color_modes() const { return this->supported_color_modes_; }
+  const ColorModeMask &get_supported_color_modes() const { return this->supported_color_modes_; }
   void set_supported_color_modes(ColorModeMask supported_color_modes) {
     this->supported_color_modes_ = supported_color_modes;
   }

esphome/components/lock/lock.cpp

@@ -1,6 +1,4 @@
 #include "lock.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -55,9 +53,6 @@ void Lock::publish_state(LockState state) {
   this->rtc_.save(&this->state);
   ESP_LOGD(TAG, "'%s': Sending state %s", this->name_.c_str(), lock_state_to_string(state));
   this->state_callback_.call();
-#if defined(USE_LOCK) && defined(USE_CONTROLLER_REGISTRY)
-  ControllerRegistry::notify_lock_update(this);
-#endif
 }
 
 void Lock::add_on_state_callback(std::function<void()> &&callback) { this->state_callback_.add(std::move(callback)); }

esphome/components/logger/__init__.py

@@ -365,10 +365,8 @@ async def to_code(config):
     if CORE.is_esp32:
         if config[CONF_HARDWARE_UART] == USB_CDC:
             add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_CDC", True)
-            cg.add_define("USE_LOGGER_UART_SELECTION_USB_CDC")
         elif config[CONF_HARDWARE_UART] == USB_SERIAL_JTAG:
             add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG", True)
-            cg.add_define("USE_LOGGER_UART_SELECTION_USB_SERIAL_JTAG")
     try:
         uart_selection(USB_SERIAL_JTAG)
         cg.add_define("USE_LOGGER_USB_SERIAL_JTAG")