[vbus] Use stack-based hex formatting in verbose logging

2025.12.4

.clang-tidy.hash

@@ -1 +1 @@
-766420905c06eeb6c5f360f68fd965e5ddd9c4a5db6b823263d3ad3accb64a07
+94557f94be073390342833aff12ef8676a8b597db5fa770a5a1232e9425cb48f

.github/workflows/ci-docker.yml

@@ -49,7 +49,7 @@ jobs:
         with:
           python-version: "3.11"
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
 
       - name: Set TAG
         run: |

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@1b168cd39490f61582a9beae412bb7057a6b2c4e # v4.31.8
+        uses: github/codeql-action/init@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
         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@1b168cd39490f61582a9beae412bb7057a6b2c4e # v4.31.8
+        uses: github/codeql-action/analyze@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/release.yml

@@ -99,7 +99,7 @@ jobs:
           python-version: "3.11"
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
 
       - name: Log in to docker hub
         uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
@@ -178,7 +178,7 @@ jobs:
           merge-multiple: true
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
 
       - name: Log in to docker hub
         if: matrix.registry == 'dockerhub'

.gitignore

@@ -91,6 +91,10 @@ venv-*/
 # mypy
 .mypy_cache/
 
+# nix
+/default.nix
+/shell.nix
+
 .pioenvs
 .piolibdeps
 .pio

.pre-commit-config.yaml

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

CODEOWNERS

@@ -42,6 +42,7 @@ esphome/components/animation/* @syndlex
 esphome/components/anova/* @buxtronix
 esphome/components/apds9306/* @aodrenah
 esphome/components/api/* @esphome/core
+esphome/components/aqi/* @freekode @jasstrong @ximex
 esphome/components/as5600/* @ammmze
 esphome/components/as5600/sensor/* @ammmze
 esphome/components/as7341/* @mrgnr
@@ -215,6 +216,7 @@ esphome/components/hlk_fm22x/* @OnFreund
 esphome/components/hlw8032/* @rici4kubicek
 esphome/components/hm3301/* @freekode
 esphome/components/hmac_md5/* @dwmw2
+esphome/components/hmac_sha256/* @dwmw2
 esphome/components/homeassistant/* @esphome/core @OttoWinter
 esphome/components/homeassistant/number/* @landonr
 esphome/components/homeassistant/switch/* @Links2004
@@ -517,6 +519,7 @@ esphome/components/tuya/switch/* @jesserockz
 esphome/components/tuya/text_sensor/* @dentra
 esphome/components/uart/* @esphome/core
 esphome/components/uart/button/* @ssieb
+esphome/components/uart/event/* @eoasmxd
 esphome/components/uart/packet_transport/* @clydebarrow
 esphome/components/udp/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
@@ -535,6 +538,7 @@ esphome/components/version/* @esphome/core
 esphome/components/voice_assistant/* @jesserockz @kahrendt
 esphome/components/wake_on_lan/* @clydebarrow @willwill2will54
 esphome/components/watchdog/* @oarcher
+esphome/components/water_heater/* @dhoeben
 esphome/components/waveshare_epaper/* @clydebarrow
 esphome/components/web_server/ota/* @esphome/core
 esphome/components/web_server_base/* @esphome/core

MANIFEST.in

@@ -1,6 +1,7 @@
 include LICENSE
 include README.md
 include requirements.txt
+recursive-include esphome *.yaml
 recursive-include esphome *.cpp *.h *.tcc *.c
 recursive-include esphome *.py.script
 recursive-include esphome LICENSE.txt

docker/Dockerfile

@@ -11,6 +11,16 @@ FROM base-source-${BUILD_TYPE} AS base
 
 RUN git config --system --add safe.directory "*"
 
+# Install build tools for Python packages that require compilation
+# (e.g., ruamel.yaml.clibz used by ESP-IDF's idf-component-manager)
+RUN if command -v apk > /dev/null; then \
+        apk add --no-cache build-base; \
+    else \
+        apt-get update \
+        && apt-get install -y --no-install-recommends build-essential \
+        && rm -rf /var/lib/apt/lists/*; \
+    fi
+
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1
 
 RUN pip install --no-cache-dir -U pip uv==0.6.14

esphome/__main__.py

@@ -431,25 +431,33 @@ def run_miniterm(config: ConfigType, port: str, args) -> int:
     while tries < 5:
         try:
             with ser:
+                buffer = b""
+                ser.timeout = 0.1  # 100ms timeout for non-blocking reads
                 while True:
                     try:
-                        raw = ser.readline()
+                        # Read all available data and timestamp it
+                        chunk = ser.read(ser.in_waiting or 1)
+                        if not chunk:
+                            continue
+                        time_ = datetime.now()
+                        nanoseconds = time_.microsecond // 1000
+                        time_str = f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}.{nanoseconds:03}]"
+
+                        # Add to buffer and process complete lines
+                        buffer += chunk
+                        while b"\n" in buffer:
+                            raw_line, buffer = buffer.split(b"\n", 1)
+                            line = raw_line.replace(b"\r", b"").decode(
+                                "utf8", "backslashreplace"
+                            )
+                            safe_print(parser.parse_line(line, time_str))
+
+                            backtrace_state = platformio_api.process_stacktrace(
+                                config, line, backtrace_state=backtrace_state
+                            )
                     except serial.SerialException:
                         _LOGGER.error("Serial port closed!")
                         return 0
-                    line = (
-                        raw.replace(b"\r", b"")
-                        .replace(b"\n", b"")
-                        .decode("utf8", "backslashreplace")
-                    )
-                    time_ = datetime.now()
-                    nanoseconds = time_.microsecond // 1000
-                    time_str = f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}.{nanoseconds:03}]"
-                    safe_print(parser.parse_line(line, time_str))
-
-                    backtrace_state = platformio_api.process_stacktrace(
-                        config, line, backtrace_state=backtrace_state
-                    )
         except serial.SerialException:
             tries += 1
             time.sleep(1)
@@ -518,10 +526,49 @@ def compile_program(args: ArgsProtocol, config: ConfigType) -> int:
     rc = platformio_api.run_compile(config, CORE.verbose)
     if rc != 0:
         return rc
+
+    # Check if firmware was rebuilt and emit build_info + create manifest
+    _check_and_emit_build_info()
+
     idedata = platformio_api.get_idedata(config)
     return 0 if idedata is not None else 1
 
 
+def _check_and_emit_build_info() -> None:
+    """Check if firmware was rebuilt and emit build_info."""
+    import json
+
+    firmware_path = CORE.firmware_bin
+    build_info_json_path = CORE.relative_build_path("build_info.json")
+
+    # Check if both files exist
+    if not firmware_path.exists() or not build_info_json_path.exists():
+        return
+
+    # Check if firmware is newer than build_info (indicating a relink occurred)
+    if firmware_path.stat().st_mtime <= build_info_json_path.stat().st_mtime:
+        return
+
+    # Read build_info from JSON
+    try:
+        with open(build_info_json_path, encoding="utf-8") as f:
+            build_info = json.load(f)
+    except (OSError, json.JSONDecodeError) as e:
+        _LOGGER.debug("Failed to read build_info: %s", e)
+        return
+
+    config_hash = build_info.get("config_hash")
+    build_time_str = build_info.get("build_time_str")
+
+    if config_hash is None or build_time_str is None:
+        return
+
+    # Emit build_info with human-readable time
+    _LOGGER.info(
+        "Build Info: config_hash=0x%08x build_time_str=%s", config_hash, build_time_str
+    )
+
+
 def upload_using_esptool(
     config: ConfigType, port: str, file: str, speed: int
 ) -> str | int:
@@ -757,7 +804,13 @@ def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
     exit_code = compile_program(args, config)
     if exit_code != 0:
         return exit_code
-    _LOGGER.info("Successfully compiled program.")
+    if CORE.is_host:
+        from esphome.platformio_api import get_idedata
+
+        program_path = str(get_idedata(config).firmware_elf_path)
+        _LOGGER.info("Successfully compiled program to path '%s'", program_path)
+    else:
+        _LOGGER.info("Successfully compiled program.")
     return 0
 
 
@@ -807,10 +860,8 @@ def command_run(args: ArgsProtocol, config: ConfigType) -> int | None:
     if CORE.is_host:
         from esphome.platformio_api import get_idedata
 
-        idedata = get_idedata(config)
-        if idedata is None:
-            return 1
-        program_path = idedata.raw["prog_path"]
+        program_path = str(get_idedata(config).firmware_elf_path)
+        _LOGGER.info("Running program from path '%s'", program_path)
         return run_external_process(program_path)
 
     # Get devices, resolving special identifiers like OTA

esphome/components/a01nyub/a01nyub.cpp

@@ -30,7 +30,9 @@ void A01nyubComponent::check_buffer_() {
       ESP_LOGV(TAG, "Distance from sensor: %f mm, %f m", distance, meters);
       this->publish_state(meters);
     } else {
-      ESP_LOGW(TAG, "Invalid data read from sensor: %s", format_hex_pretty(this->buffer_).c_str());
+      char hex_buf[format_hex_pretty_size(4)];
+      ESP_LOGW(TAG, "Invalid data read from sensor: %s",
+               format_hex_pretty_to(hex_buf, this->buffer_.data(), this->buffer_.size()));
     }
   } else {
     ESP_LOGW(TAG, "checksum failed: %02x != %02x", checksum, this->buffer_[3]);

esphome/components/a02yyuw/a02yyuw.cpp

@@ -29,7 +29,9 @@ void A02yyuwComponent::check_buffer_() {
       ESP_LOGV(TAG, "Distance from sensor: %f mm", distance);
       this->publish_state(distance);
     } else {
-      ESP_LOGW(TAG, "Invalid data read from sensor: %s", format_hex_pretty(this->buffer_).c_str());
+      char hex_buf[format_hex_pretty_size(4)];
+      ESP_LOGW(TAG, "Invalid data read from sensor: %s",
+               format_hex_pretty_to(hex_buf, this->buffer_.data(), this->buffer_.size()));
     }
   } else {
     ESP_LOGW(TAG, "checksum failed: %02x != %02x", checksum, this->buffer_[3]);

esphome/components/addressable_light/addressable_light_display.h

@@ -25,11 +25,13 @@ class AddressableLightDisplay : public display::DisplayBuffer {
       if (enabled_ && !enabled) {  // enabled -> disabled
         // - Tell the parent light to refresh, effectively wiping the display. Also
         //   restores the previous effect (if any).
-        light_state_->make_call().set_effect(this->last_effect_).perform();
+        if (this->last_effect_index_.has_value()) {
+          light_state_->make_call().set_effect(*this->last_effect_index_).perform();
+        }
 
       } else if (!enabled_ && enabled) {  // disabled -> enabled
-        // - Save the current effect.
-        this->last_effect_ = light_state_->get_effect_name();
+        // - Save the current effect index.
+        this->last_effect_index_ = light_state_->get_current_effect_index();
         // - Disable any current effect.
         light_state_->make_call().set_effect(0).perform();
       }
@@ -56,7 +58,7 @@ class AddressableLightDisplay : public display::DisplayBuffer {
   int32_t width_;
   int32_t height_;
   std::vector<Color> addressable_light_buffer_;
-  optional<std::string> last_effect_;
+  optional<uint32_t> last_effect_index_;
   optional<std::function<int(int, int)>> pixel_mapper_f_;
 };
 }  // namespace addressable_light

esphome/components/ade7880/sensor.py

@@ -227,7 +227,7 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(): cv.declare_id(ADE7880),
             cv.Optional(CONF_FREQUENCY, default="50Hz"): cv.All(
-                cv.frequency, cv.Range(min=45.0, max=66.0)
+                cv.frequency, cv.float_range(min=45.0, max=66.0)
             ),
             cv.Optional(CONF_IRQ0_PIN): pins.internal_gpio_input_pin_schema,
             cv.Required(CONF_IRQ1_PIN): pins.internal_gpio_input_pin_schema,

esphome/components/alarm_control_panel/alarm_control_panel.cpp

@@ -8,8 +8,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 static const char *const TAG = "alarm_control_panel";
 
@@ -115,5 +114,4 @@ void AlarmControlPanel::disarm(optional<std::string> code) {
   call.perform();
 }
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <map>
-
 #include "alarm_control_panel_call.h"
 #include "alarm_control_panel_state.h"
 
@@ -9,8 +7,7 @@
 #include "esphome/core/entity_base.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 enum AlarmControlPanelFeature : uint8_t {
   // Matches Home Assistant values
@@ -132,14 +129,13 @@ class AlarmControlPanel : public EntityBase {
   // the call control function
   virtual void control(const AlarmControlPanelCall &call) = 0;
   // state callback - triggers check get_state() for specific state
-  CallbackManager<void()> state_callback_{};
+  LazyCallbackManager<void()> state_callback_{};
   // clear callback - fires when leaving TRIGGERED state
-  CallbackManager<void()> cleared_callback_{};
+  LazyCallbackManager<void()> cleared_callback_{};
   // chime callback
-  CallbackManager<void()> chime_callback_{};
+  LazyCallbackManager<void()> chime_callback_{};
   // ready callback
-  CallbackManager<void()> ready_callback_{};
+  LazyCallbackManager<void()> ready_callback_{};
 };
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel_call.cpp

@@ -4,8 +4,7 @@
 
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 static const char *const TAG = "alarm_control_panel";
 
@@ -99,5 +98,4 @@ void AlarmControlPanelCall::perform() {
   }
 }
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel_call.h

@@ -6,8 +6,7 @@
 
 #include "esphome/core/helpers.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 class AlarmControlPanel;
 
@@ -36,5 +35,4 @@ class AlarmControlPanelCall {
   void validate_();
 };
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel_state.cpp

@@ -1,7 +1,6 @@
 #include "alarm_control_panel_state.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 const LogString *alarm_control_panel_state_to_string(AlarmControlPanelState state) {
   switch (state) {
@@ -30,5 +29,4 @@ const LogString *alarm_control_panel_state_to_string(AlarmControlPanelState stat
   }
 }
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel_state.h

@@ -3,8 +3,7 @@
 #include <cstdint>
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 enum AlarmControlPanelState : uint8_t {
   ACP_STATE_DISARMED = 0,
@@ -25,5 +24,4 @@ enum AlarmControlPanelState : uint8_t {
  */
 const LogString *alarm_control_panel_state_to_string(AlarmControlPanelState state);
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/automation.h

@@ -3,8 +3,7 @@
 #include "esphome/core/automation.h"
 #include "alarm_control_panel.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 /// Trigger on any state change
 class StateTrigger : public Trigger<> {
@@ -165,5 +164,4 @@ template<typename... Ts> class AlarmControlPanelCondition : public Condition<Ts.
   AlarmControlPanel *parent_;
 };
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/api/api.proto

@@ -102,7 +102,7 @@ message HelloRequest {
   // For example "Home Assistant"
   // Not strictly necessary to send but nice for debugging
   // purposes.
-  string client_info = 1 [(pointer_to_buffer) = true];
+  string client_info = 1;
   uint32 api_version_major = 2;
   uint32 api_version_minor = 3;
 }
@@ -139,7 +139,7 @@ message AuthenticationRequest {
   option (ifdef) = "USE_API_PASSWORD";
 
   // The password to log in with
-  string password = 1 [(pointer_to_buffer) = true];
+  string password = 1;
 }
 
 // Confirmation of successful connection. After this the connection is available for all traffic.
@@ -579,7 +579,7 @@ message LightCommandRequest {
   bool has_flash_length = 16;
   uint32 flash_length = 17;
   bool has_effect = 18;
-  string effect = 19 [(pointer_to_buffer) = true];
+  string effect = 19;
   uint32 device_id = 28 [(field_ifdef) = "USE_DEVICES"];
 }
 
@@ -796,7 +796,7 @@ message HomeassistantActionResponse {
   uint32 call_id = 1; // Matches the call_id from HomeassistantActionRequest
   bool success = 2; // Whether the service call succeeded
   string error_message = 3; // Error message if success = false
-  bytes response_data = 4 [(pointer_to_buffer) = true, (field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
+  bytes response_data = 4 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
 }
 
 // ==================== IMPORT HOME ASSISTANT STATES ====================
@@ -841,7 +841,7 @@ message GetTimeResponse {
   option (no_delay) = true;
 
   fixed32 epoch_seconds = 1;
-  string timezone = 2 [(pointer_to_buffer) = true];
+  string timezone = 2;
 }
 
 // ==================== USER-DEFINES SERVICES ====================
@@ -1101,6 +1101,85 @@ message ClimateCommandRequest {
   uint32 device_id = 24 [(field_ifdef) = "USE_DEVICES"];
 }
 
+// ==================== WATER_HEATER ====================
+enum WaterHeaterMode {
+  WATER_HEATER_MODE_OFF = 0;
+  WATER_HEATER_MODE_ECO = 1;
+  WATER_HEATER_MODE_ELECTRIC = 2;
+  WATER_HEATER_MODE_PERFORMANCE = 3;
+  WATER_HEATER_MODE_HIGH_DEMAND = 4;
+  WATER_HEATER_MODE_HEAT_PUMP = 5;
+  WATER_HEATER_MODE_GAS = 6;
+}
+
+message ListEntitiesWaterHeaterResponse {
+  option (id) = 132;
+  option (base_class) = "InfoResponseProtoMessage";
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_WATER_HEATER";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON"];
+  bool disabled_by_default = 5;
+  EntityCategory entity_category = 6;
+  uint32 device_id = 7 [(field_ifdef) = "USE_DEVICES"];
+  float min_temperature = 8;
+  float max_temperature = 9;
+  float target_temperature_step = 10;
+  repeated WaterHeaterMode supported_modes = 11 [(container_pointer_no_template) = "water_heater::WaterHeaterModeMask"];
+  // Bitmask of WaterHeaterFeature flags
+  uint32 supported_features = 12;
+}
+
+message WaterHeaterStateResponse {
+  option (id) = 133;
+  option (base_class) = "StateResponseProtoMessage";
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_WATER_HEATER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  float current_temperature = 2;
+  float target_temperature = 3;
+  WaterHeaterMode mode = 4;
+  uint32 device_id = 5 [(field_ifdef) = "USE_DEVICES"];
+  // Bitmask of current state flags (bit 0 = away, bit 1 = on)
+  uint32 state = 6;
+  float target_temperature_low = 7;
+  float target_temperature_high = 8;
+}
+
+// Bitmask for WaterHeaterCommandRequest.has_fields
+enum WaterHeaterCommandHasField {
+  WATER_HEATER_COMMAND_HAS_NONE = 0;
+  WATER_HEATER_COMMAND_HAS_MODE = 1;
+  WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE = 2;
+  WATER_HEATER_COMMAND_HAS_STATE = 4;
+  WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW = 8;
+  WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH = 16;
+}
+
+message WaterHeaterCommandRequest {
+  option (id) = 134;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_WATER_HEATER";
+  option (no_delay) = true;
+  option (base_class) = "CommandProtoMessage";
+
+  fixed32 key = 1;
+  // Bitmask of which fields are set (see WaterHeaterCommandHasField)
+  uint32 has_fields = 2;
+  WaterHeaterMode mode = 3;
+  float target_temperature = 4;
+  uint32 device_id = 5 [(field_ifdef) = "USE_DEVICES"];
+  // State flags bitmask (bit 0 = away, bit 1 = on)
+  uint32 state = 6;
+  float target_temperature_low = 7;
+  float target_temperature_high = 8;
+}
+
 // ==================== NUMBER ====================
 enum NumberMode {
   NUMBER_MODE_AUTO = 0;
@@ -1195,7 +1274,7 @@ message SelectCommandRequest {
   option (base_class) = "CommandProtoMessage";
 
   fixed32 key = 1;
-  string state = 2 [(pointer_to_buffer) = true];
+  string state = 2;
   uint32 device_id = 3 [(field_ifdef) = "USE_DEVICES"];
 }
 
@@ -1213,7 +1292,7 @@ message ListEntitiesSirenResponse {
 
   string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
   bool disabled_by_default = 6;
-  repeated string tones = 7;
+  repeated string tones = 7 [(container_pointer_no_template) = "FixedVector<const char *>"];
   bool supports_duration = 8;
   bool supports_volume = 9;
   EntityCategory entity_category = 10;
@@ -1613,7 +1692,7 @@ message BluetoothGATTWriteRequest {
   uint32 handle = 2;
   bool response = 3;
 
-  bytes data = 4 [(pointer_to_buffer) = true];
+  bytes data = 4;
 }
 
 message BluetoothGATTReadDescriptorRequest {
@@ -1633,7 +1712,7 @@ message BluetoothGATTWriteDescriptorRequest {
   uint64 address = 1;
   uint32 handle = 2;
 
-  bytes data = 3 [(pointer_to_buffer) = true];
+  bytes data = 3;
 }
 
 message BluetoothGATTNotifyRequest {
@@ -1858,7 +1937,7 @@ message VoiceAssistantAudio {
   option (source) = SOURCE_BOTH;
   option (ifdef) = "USE_VOICE_ASSISTANT";
 
-  bytes data = 1;
+  bytes data = 1 [(pointer_to_buffer) = true];
   bool end = 2;
 }
 

esphome/components/api/api_connection.cpp

@@ -13,6 +13,7 @@
 #include <cinttypes>
 #include <functional>
 #include <limits>
+#include <new>
 #include <utility>
 #ifdef USE_ESP8266
 #include <pgmspace.h>
@@ -42,6 +43,9 @@
 #ifdef USE_ZWAVE_PROXY
 #include "esphome/components/zwave_proxy/zwave_proxy.h"
 #endif
+#ifdef USE_WATER_HEATER
+#include "esphome/components/water_heater/water_heater.h"
+#endif
 
 namespace esphome::api {
 
@@ -93,21 +97,18 @@ static const int CAMERA_STOP_STREAM = 5000;
     return;
 #endif  // USE_DEVICES
 
-APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *parent)
-    : parent_(parent), initial_state_iterator_(this), list_entities_iterator_(this) {
+APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *parent) : parent_(parent) {
 #if defined(USE_API_PLAINTEXT) && defined(USE_API_NOISE)
   auto &noise_ctx = parent->get_noise_ctx();
   if (noise_ctx.has_psk()) {
-    this->helper_ =
-        std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), noise_ctx, &this->client_info_)};
+    this->helper_ = std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), noise_ctx)};
   } else {
-    this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock), &this->client_info_)};
+    this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
   }
 #elif defined(USE_API_PLAINTEXT)
-  this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock), &this->client_info_)};
+  this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
 #elif defined(USE_API_NOISE)
-  this->helper_ = std::unique_ptr<APIFrameHelper>{
-      new APINoiseFrameHelper(std::move(sock), parent->get_noise_ctx(), &this->client_info_)};
+  this->helper_ = std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), parent->get_noise_ctx())};
 #else
 #error "No frame helper defined"
 #endif
@@ -128,11 +129,14 @@ void APIConnection::start() {
     this->fatal_error_with_log_(LOG_STR("Helper init failed"), err);
     return;
   }
-  this->client_info_.peername = helper_->getpeername();
-  this->client_info_.name = this->client_info_.peername;
+  // Initialize client name with peername (IP address) until Hello message provides actual name
+  char peername[socket::PEERNAME_MAX_LEN];
+  size_t len = this->helper_->getpeername_to(peername);
+  this->helper_->set_client_name(peername, len);
 }
 
 APIConnection::~APIConnection() {
+  this->destroy_active_iterator_();
 #ifdef USE_BLUETOOTH_PROXY
   if (bluetooth_proxy::global_bluetooth_proxy->get_api_connection() == this) {
     bluetooth_proxy::global_bluetooth_proxy->unsubscribe_api_connection(this);
@@ -145,6 +149,32 @@ APIConnection::~APIConnection() {
 #endif
 }
 
+void APIConnection::destroy_active_iterator_() {
+  switch (this->active_iterator_) {
+    case ActiveIterator::LIST_ENTITIES:
+      this->iterator_storage_.list_entities.~ListEntitiesIterator();
+      break;
+    case ActiveIterator::INITIAL_STATE:
+      this->iterator_storage_.initial_state.~InitialStateIterator();
+      break;
+    case ActiveIterator::NONE:
+      break;
+  }
+  this->active_iterator_ = ActiveIterator::NONE;
+}
+
+void APIConnection::begin_iterator_(ActiveIterator type) {
+  this->destroy_active_iterator_();
+  this->active_iterator_ = type;
+  if (type == ActiveIterator::LIST_ENTITIES) {
+    new (&this->iterator_storage_.list_entities) ListEntitiesIterator(this);
+    this->iterator_storage_.list_entities.begin();
+  } else {
+    new (&this->iterator_storage_.initial_state) InitialStateIterator(this);
+    this->iterator_storage_.initial_state.begin();
+  }
+}
+
 void APIConnection::loop() {
   if (this->flags_.next_close) {
     // requested a disconnect
@@ -187,31 +217,42 @@ void APIConnection::loop() {
     this->process_batch_();
   }
 
-  if (!this->list_entities_iterator_.completed()) {
-    this->process_iterator_batch_(this->list_entities_iterator_);
-  } else if (!this->initial_state_iterator_.completed()) {
-    this->process_iterator_batch_(this->initial_state_iterator_);
-
-    // If we've completed initial states, process any remaining and clear the flag
-    if (this->initial_state_iterator_.completed()) {
-      // Process any remaining batched messages immediately
-      if (!this->deferred_batch_.empty()) {
-        this->process_batch_();
+  switch (this->active_iterator_) {
+    case ActiveIterator::LIST_ENTITIES:
+      if (this->iterator_storage_.list_entities.completed()) {
+        this->destroy_active_iterator_();
+        if (this->flags_.state_subscription) {
+          this->begin_iterator_(ActiveIterator::INITIAL_STATE);
+        }
+      } else {
+        this->process_iterator_batch_(this->iterator_storage_.list_entities);
       }
-      // Now that everything is sent, enable immediate sending for future state changes
-      this->flags_.should_try_send_immediately = true;
-      // Release excess memory from buffers that grew during initial sync
-      this->deferred_batch_.release_buffer();
-      this->helper_->release_buffers();
-    }
+      break;
+    case ActiveIterator::INITIAL_STATE:
+      if (this->iterator_storage_.initial_state.completed()) {
+        this->destroy_active_iterator_();
+        // Process any remaining batched messages immediately
+        if (!this->deferred_batch_.empty()) {
+          this->process_batch_();
+        }
+        // Now that everything is sent, enable immediate sending for future state changes
+        this->flags_.should_try_send_immediately = true;
+        // Release excess memory from buffers that grew during initial sync
+        this->deferred_batch_.release_buffer();
+        this->helper_->release_buffers();
+      } else {
+        this->process_iterator_batch_(this->iterator_storage_.initial_state);
+      }
+      break;
+    case ActiveIterator::NONE:
+      break;
   }
 
   if (this->flags_.sent_ping) {
     // Disconnect if not responded within 2.5*keepalive
     if (now - this->last_traffic_ > KEEPALIVE_DISCONNECT_TIMEOUT) {
       on_fatal_error();
-      ESP_LOGW(TAG, "%s (%s) is unresponsive; disconnecting", this->client_info_.name.c_str(),
-               this->client_info_.peername.c_str());
+      this->log_client_(ESPHOME_LOG_LEVEL_WARN, LOG_STR("is unresponsive; disconnecting"));
     }
   } else if (now - this->last_traffic_ > KEEPALIVE_TIMEOUT_MS && !this->flags_.remove) {
     // Only send ping if we're not disconnecting
@@ -228,40 +269,24 @@ void APIConnection::loop() {
     }
   }
 
-#ifdef USE_CAMERA
-  if (this->image_reader_ && this->image_reader_->available() && this->helper_->can_write_without_blocking()) {
-    uint32_t to_send = std::min((size_t) MAX_BATCH_PACKET_SIZE, this->image_reader_->available());
-    bool done = this->image_reader_->available() == to_send;
-
-    CameraImageResponse msg;
-    msg.key = camera::Camera::instance()->get_object_id_hash();
-    msg.set_data(this->image_reader_->peek_data_buffer(), to_send);
-    msg.done = done;
-#ifdef USE_DEVICES
-    msg.device_id = camera::Camera::instance()->get_device_id();
-#endif
-
-    if (this->send_message_(msg, CameraImageResponse::MESSAGE_TYPE)) {
-      this->image_reader_->consume_data(to_send);
-      if (done) {
-        this->image_reader_->return_image();
-      }
-    }
-  }
-#endif
-
 #ifdef USE_API_HOMEASSISTANT_STATES
   if (state_subs_at_ >= 0) {
     this->process_state_subscriptions_();
   }
 #endif
+
+#ifdef USE_CAMERA
+  // Process camera last - state updates are higher priority
+  // (missing a frame is fine, missing a state update is not)
+  this->try_send_camera_image_();
+#endif
 }
 
 bool APIConnection::send_disconnect_response(const DisconnectRequest &msg) {
   // remote initiated disconnect_client
   // don't close yet, we still need to send the disconnect response
   // close will happen on next loop
-  ESP_LOGD(TAG, "%s (%s) disconnected", this->client_info_.name.c_str(), this->client_info_.peername.c_str());
+  this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("disconnected"));
   this->flags_.next_close = true;
   DisconnectResponse resp;
   return this->send_message(resp, DisconnectResponse::MESSAGE_TYPE);
@@ -447,7 +472,7 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
   if (msg.has_direction)
     call.set_direction(static_cast<fan::FanDirection>(msg.direction));
   if (msg.has_preset_mode)
-    call.set_preset_mode(msg.preset_mode);
+    call.set_preset_mode(msg.preset_mode.c_str(), msg.preset_mode.size());
   call.perform();
 }
 #endif
@@ -533,7 +558,7 @@ void APIConnection::light_command(const LightCommandRequest &msg) {
   if (msg.has_flash_length)
     call.set_flash_length(msg.flash_length);
   if (msg.has_effect)
-    call.set_effect(reinterpret_cast<const char *>(msg.effect), msg.effect_len);
+    call.set_effect(msg.effect.c_str(), msg.effect.size());
   call.perform();
 }
 #endif
@@ -712,11 +737,11 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
   if (msg.has_fan_mode)
     call.set_fan_mode(static_cast<climate::ClimateFanMode>(msg.fan_mode));
   if (msg.has_custom_fan_mode)
-    call.set_fan_mode(msg.custom_fan_mode);
+    call.set_fan_mode(msg.custom_fan_mode.c_str(), msg.custom_fan_mode.size());
   if (msg.has_preset)
     call.set_preset(static_cast<climate::ClimatePreset>(msg.preset));
   if (msg.has_custom_preset)
-    call.set_preset(msg.custom_preset);
+    call.set_preset(msg.custom_preset.c_str(), msg.custom_preset.size());
   if (msg.has_swing_mode)
     call.set_swing_mode(static_cast<climate::ClimateSwingMode>(msg.swing_mode));
   call.perform();
@@ -905,7 +930,7 @@ uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *
 }
 void APIConnection::select_command(const SelectCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(select::Select, select, select)
-  call.set_option(reinterpret_cast<const char *>(msg.state), msg.state_len);
+  call.set_option(msg.state.c_str(), msg.state.size());
   call.perform();
 }
 #endif
@@ -1057,6 +1082,36 @@ void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {
 #endif
 
 #ifdef USE_CAMERA
+void APIConnection::try_send_camera_image_() {
+  if (!this->image_reader_)
+    return;
+
+  // Send as many chunks as possible without blocking
+  while (this->image_reader_->available()) {
+    if (!this->helper_->can_write_without_blocking())
+      return;
+
+    uint32_t to_send = std::min((size_t) MAX_BATCH_PACKET_SIZE, this->image_reader_->available());
+    bool done = this->image_reader_->available() == to_send;
+
+    CameraImageResponse msg;
+    msg.key = camera::Camera::instance()->get_object_id_hash();
+    msg.set_data(this->image_reader_->peek_data_buffer(), to_send);
+    msg.done = done;
+#ifdef USE_DEVICES
+    msg.device_id = camera::Camera::instance()->get_device_id();
+#endif
+
+    if (!this->send_message_(msg, CameraImageResponse::MESSAGE_TYPE)) {
+      return;  // Send failed, try again later
+    }
+    this->image_reader_->consume_data(to_send);
+    if (done) {
+      this->image_reader_->return_image();
+      return;
+    }
+  }
+}
 void APIConnection::set_camera_state(std::shared_ptr<camera::CameraImage> image) {
   if (!this->flags_.state_subscription)
     return;
@@ -1064,8 +1119,11 @@ void APIConnection::set_camera_state(std::shared_ptr<camera::CameraImage> image)
     return;
   if (this->image_reader_->available())
     return;
-  if (image->was_requested_by(esphome::camera::API_REQUESTER) || image->was_requested_by(esphome::camera::IDLE))
+  if (image->was_requested_by(esphome::camera::API_REQUESTER) || image->was_requested_by(esphome::camera::IDLE)) {
     this->image_reader_->set_image(std::move(image));
+    // Try to send immediately to reduce latency
+    this->try_send_camera_image_();
+  }
 }
 uint16_t APIConnection::try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
@@ -1094,9 +1152,8 @@ void APIConnection::on_get_time_response(const GetTimeResponse &value) {
   if (homeassistant::global_homeassistant_time != nullptr) {
     homeassistant::global_homeassistant_time->set_epoch_time(value.epoch_seconds);
 #ifdef USE_TIME_TIMEZONE
-    if (value.timezone_len > 0) {
-      homeassistant::global_homeassistant_time->set_timezone(reinterpret_cast<const char *>(value.timezone),
-                                                             value.timezone_len);
+    if (!value.timezone.empty()) {
+      homeassistant::global_homeassistant_time->set_timezone(value.timezone.c_str(), value.timezone.size());
     }
 #endif
   }
@@ -1306,6 +1363,57 @@ void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRe
 }
 #endif
 
+#ifdef USE_WATER_HEATER
+bool APIConnection::send_water_heater_state(water_heater::WaterHeater *water_heater) {
+  return this->send_message_smart_(water_heater, &APIConnection::try_send_water_heater_state,
+                                   WaterHeaterStateResponse::MESSAGE_TYPE, WaterHeaterStateResponse::ESTIMATED_SIZE);
+}
+uint16_t APIConnection::try_send_water_heater_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                                    bool is_single) {
+  auto *wh = static_cast<water_heater::WaterHeater *>(entity);
+  WaterHeaterStateResponse resp;
+  resp.mode = static_cast<enums::WaterHeaterMode>(wh->get_mode());
+  resp.current_temperature = wh->get_current_temperature();
+  resp.target_temperature = wh->get_target_temperature();
+  resp.target_temperature_low = wh->get_target_temperature_low();
+  resp.target_temperature_high = wh->get_target_temperature_high();
+  resp.state = wh->get_state();
+  resp.key = wh->get_object_id_hash();
+
+  return encode_message_to_buffer(resp, WaterHeaterStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
+uint16_t APIConnection::try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                                   bool is_single) {
+  auto *wh = static_cast<water_heater::WaterHeater *>(entity);
+  ListEntitiesWaterHeaterResponse msg;
+  auto traits = wh->get_traits();
+  msg.min_temperature = traits.get_min_temperature();
+  msg.max_temperature = traits.get_max_temperature();
+  msg.target_temperature_step = traits.get_target_temperature_step();
+  msg.supported_modes = &traits.get_supported_modes();
+  msg.supported_features = traits.get_feature_flags();
+  return fill_and_encode_entity_info(wh, msg, ListEntitiesWaterHeaterResponse::MESSAGE_TYPE, conn, remaining_size,
+                                     is_single);
+}
+
+void APIConnection::on_water_heater_command_request(const WaterHeaterCommandRequest &msg) {
+  ENTITY_COMMAND_MAKE_CALL(water_heater::WaterHeater, water_heater, water_heater)
+  if (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_MODE)
+    call.set_mode(static_cast<water_heater::WaterHeaterMode>(msg.mode));
+  if (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE)
+    call.set_target_temperature(msg.target_temperature);
+  if (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW)
+    call.set_target_temperature_low(msg.target_temperature_low);
+  if (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH)
+    call.set_target_temperature_high(msg.target_temperature_high);
+  if (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_STATE) {
+    call.set_away((msg.state & water_heater::WATER_HEATER_STATE_AWAY) != 0);
+    call.set_on((msg.state & water_heater::WATER_HEATER_STATE_ON) != 0);
+  }
+  call.perform();
+}
+#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,
@@ -1395,9 +1503,12 @@ void APIConnection::complete_authentication_() {
   }
 
   this->flags_.connection_state = static_cast<uint8_t>(ConnectionState::AUTHENTICATED);
-  ESP_LOGD(TAG, "%s (%s) connected", this->client_info_.name.c_str(), this->client_info_.peername.c_str());
+  this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("connected"));
 #ifdef USE_API_CLIENT_CONNECTED_TRIGGER
-  this->parent_->get_client_connected_trigger()->trigger(this->client_info_.name, this->client_info_.peername);
+  char peername_buf[socket::PEERNAME_MAX_LEN];
+  this->helper_->getpeername_to(peername_buf);
+  this->parent_->get_client_connected_trigger()->trigger(std::string(this->helper_->get_client_name()),
+                                                         std::string(peername_buf));
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
   if (homeassistant::global_homeassistant_time != nullptr) {
@@ -1412,16 +1523,18 @@ void APIConnection::complete_authentication_() {
 }
 
 bool APIConnection::send_hello_response(const HelloRequest &msg) {
-  this->client_info_.name.assign(reinterpret_cast<const char *>(msg.client_info), msg.client_info_len);
-  this->client_info_.peername = this->helper_->getpeername();
+  // Copy client name with truncation if needed (set_client_name handles truncation)
+  this->helper_->set_client_name(msg.client_info.c_str(), msg.client_info.size());
   this->client_api_version_major_ = msg.api_version_major;
   this->client_api_version_minor_ = msg.api_version_minor;
-  ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %" PRIu32 ".%" PRIu32, this->client_info_.name.c_str(),
-           this->client_info_.peername.c_str(), this->client_api_version_major_, this->client_api_version_minor_);
+  char peername[socket::PEERNAME_MAX_LEN];
+  this->helper_->getpeername_to(peername);
+  ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %" PRIu32 ".%" PRIu32, this->helper_->get_client_name(),
+           peername, this->client_api_version_major_, this->client_api_version_minor_);
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 13;
+  resp.api_version_minor = 14;
   // Send only the version string - the client only logs this for debugging and doesn't use it otherwise
   resp.set_server_info(ESPHOME_VERSION_REF);
   resp.set_name(StringRef(App.get_name()));
@@ -1440,7 +1553,7 @@ bool APIConnection::send_hello_response(const HelloRequest &msg) {
 bool APIConnection::send_authenticate_response(const AuthenticationRequest &msg) {
   AuthenticationResponse resp;
   // bool invalid_password = 1;
-  resp.invalid_password = !this->parent_->check_password(msg.password, msg.password_len);
+  resp.invalid_password = !this->parent_->check_password(msg.password.byte(), msg.password.size());
   if (!resp.invalid_password) {
     this->complete_authentication_();
   }
@@ -1472,7 +1585,10 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
 
   resp.set_esphome_version(ESPHOME_VERSION_REF);
 
-  resp.set_compilation_time(App.get_compilation_time_ref());
+  // Stack buffer for build time string
+  char build_time_str[Application::BUILD_TIME_STR_SIZE];
+  App.get_build_time_string(build_time_str);
+  resp.set_compilation_time(StringRef(build_time_str));
 
   // Manufacturer string - define once, handle ESP8266 PROGMEM separately
 #if defined(USE_ESP8266) || defined(USE_ESP32)
@@ -1579,15 +1695,38 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
 
 #ifdef USE_API_HOMEASSISTANT_STATES
 void APIConnection::on_home_assistant_state_response(const HomeAssistantStateResponse &msg) {
-  for (auto &it : this->parent_->get_state_subs()) {
-    // Compare entity_id and attribute with message fields
-    bool entity_match = (strcmp(it.entity_id, msg.entity_id.c_str()) == 0);
-    bool attribute_match = (it.attribute != nullptr && strcmp(it.attribute, msg.attribute.c_str()) == 0) ||
-                           (it.attribute == nullptr && msg.attribute.empty());
+  // Skip if entity_id is empty (invalid message)
+  if (msg.entity_id.empty()) {
+    return;
+  }
 
-    if (entity_match && attribute_match) {
-      it.callback(msg.state);
+  for (auto &it : this->parent_->get_state_subs()) {
+    // Compare entity_id: check length matches and content matches
+    size_t entity_id_len = strlen(it.entity_id);
+    if (entity_id_len != msg.entity_id.size() ||
+        memcmp(it.entity_id, msg.entity_id.c_str(), msg.entity_id.size()) != 0) {
+      continue;
     }
+
+    // Compare attribute: either both have matching attribute, or both have none
+    size_t sub_attr_len = it.attribute != nullptr ? strlen(it.attribute) : 0;
+    if (sub_attr_len != msg.attribute.size() ||
+        (sub_attr_len > 0 && memcmp(it.attribute, msg.attribute.c_str(), sub_attr_len) != 0)) {
+      continue;
+    }
+
+    // Create null-terminated state for callback (parse_number needs null-termination)
+    // HA state max length is 255, so 256 byte buffer covers all cases
+    char state_buf[256];
+    size_t copy_len = msg.state_len;
+    if (copy_len >= sizeof(state_buf)) {
+      copy_len = sizeof(state_buf) - 1;  // Truncate to leave space for null terminator
+    }
+    if (copy_len > 0) {
+      memcpy(state_buf, msg.state, copy_len);
+    }
+    state_buf[copy_len] = '\0';
+    it.callback(StringRef(state_buf, copy_len));
   }
 }
 #endif
@@ -1622,20 +1761,20 @@ void APIConnection::execute_service(const ExecuteServiceRequest &msg) {
   // the action list. This ensures async actions (delays, waits) complete first.
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-void APIConnection::send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message) {
+void APIConnection::send_execute_service_response(uint32_t call_id, bool success, StringRef error_message) {
   ExecuteServiceResponse resp;
   resp.call_id = call_id;
   resp.success = success;
-  resp.set_error_message(StringRef(error_message));
+  resp.set_error_message(error_message);
   this->send_message(resp, ExecuteServiceResponse::MESSAGE_TYPE);
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-void APIConnection::send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message,
+void APIConnection::send_execute_service_response(uint32_t call_id, bool success, StringRef error_message,
                                                   const uint8_t *response_data, size_t response_data_len) {
   ExecuteServiceResponse resp;
   resp.call_id = call_id;
   resp.success = success;
-  resp.set_error_message(StringRef(error_message));
+  resp.set_error_message(error_message);
   resp.response_data = response_data;
   resp.response_data_len = response_data_len;
   this->send_message(resp, ExecuteServiceResponse::MESSAGE_TYPE);
@@ -1663,13 +1802,13 @@ bool APIConnection::send_noise_encryption_set_key_response(const NoiseEncryption
   resp.success = false;
 
   psk_t psk{};
-  if (msg.key.empty()) {
+  if (msg.key_len == 0) {
     if (this->parent_->clear_noise_psk(true)) {
       resp.success = true;
     } else {
       ESP_LOGW(TAG, "Failed to clear encryption key");
     }
-  } else if (base64_decode(msg.key, psk.data(), psk.size()) != psk.size()) {
+  } else if (base64_decode(msg.key, msg.key_len, psk.data(), psk.size()) != psk.size()) {
     ESP_LOGW(TAG, "Invalid encryption key length");
   } else if (!this->parent_->save_noise_psk(psk, true)) {
     ESP_LOGW(TAG, "Failed to save encryption key");
@@ -1721,12 +1860,12 @@ bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
 #ifdef USE_API_PASSWORD
 void APIConnection::on_unauthenticated_access() {
   this->on_fatal_error();
-  ESP_LOGD(TAG, "%s (%s) no authentication", this->client_info_.name.c_str(), this->client_info_.peername.c_str());
+  this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no authentication"));
 }
 #endif
 void APIConnection::on_no_setup_connection() {
   this->on_fatal_error();
-  ESP_LOGD(TAG, "%s (%s) no connection setup", this->client_info_.name.c_str(), this->client_info_.peername.c_str());
+  this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no connection setup"));
 }
 void APIConnection::on_fatal_error() {
   this->helper_->close();
@@ -1974,9 +2113,18 @@ void APIConnection::process_state_subscriptions_() {
 }
 #endif  // USE_API_HOMEASSISTANT_STATES
 
+void APIConnection::log_client_(int level, const LogString *message) {
+  char peername[socket::PEERNAME_MAX_LEN];
+  this->helper_->getpeername_to(peername);
+  esp_log_printf_(level, TAG, __LINE__, ESPHOME_LOG_FORMAT("%s (%s): %s"), this->helper_->get_client_name(), peername,
+                  LOG_STR_ARG(message));
+}
+
 void APIConnection::log_warning_(const LogString *message, APIError err) {
-  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->client_info_.name.c_str(), this->client_info_.peername.c_str(),
-           LOG_STR_ARG(message), LOG_STR_ARG(api_error_to_logstr(err)), errno);
+  char peername[socket::PEERNAME_MAX_LEN];
+  this->helper_->getpeername_to(peername);
+  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->helper_->get_client_name(), peername, LOG_STR_ARG(message),
+           LOG_STR_ARG(api_error_to_logstr(err)), errno);
 }
 
 }  // namespace esphome::api

esphome/components/api/api_connection.h

@@ -9,24 +9,20 @@
 #include "esphome/core/application.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
+#include "esphome/core/string_ref.h"
 
 #include <functional>
 #include <vector>
 
 namespace esphome::api {
 
-// Client information structure
-struct ClientInfo {
-  std::string name;      // Client name from Hello message
-  std::string peername;  // IP:port from socket
-};
-
 // Keepalive timeout in milliseconds
 static constexpr uint32_t KEEPALIVE_TIMEOUT_MS = 60000;
 // Maximum number of entities to process in a single batch during initial state/info sending
-// This was increased from 20 to 24 after removing the unique_id field from entity info messages,
-// which reduced message sizes allowing more entities per batch without exceeding packet limits
-static constexpr size_t MAX_INITIAL_PER_BATCH = 24;
+// API 1.14+ clients compute object_id client-side, so messages are smaller and we can fit more per batch
+// TODO: Remove MAX_INITIAL_PER_BATCH_LEGACY before 2026.7.0 - all clients should support API 1.14 by then
+static constexpr size_t MAX_INITIAL_PER_BATCH_LEGACY = 24;  // For clients < API 1.14 (includes object_id)
+static constexpr size_t MAX_INITIAL_PER_BATCH = 34;         // For clients >= API 1.14 (no object_id)
 // Maximum number of packets to process in a single batch (platform-dependent)
 // This limit exists to prevent stack overflow from the PacketInfo array in process_batch_
 // Each PacketInfo is 8 bytes, so 64 * 8 = 512 bytes, 32 * 8 = 256 bytes
@@ -176,6 +172,11 @@ class APIConnection final : public APIServerConnection {
   void alarm_control_panel_command(const AlarmControlPanelCommandRequest &msg) override;
 #endif
 
+#ifdef USE_WATER_HEATER
+  bool send_water_heater_state(water_heater::WaterHeater *water_heater);
+  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
+#endif
+
 #ifdef USE_EVENT
   void send_event(event::Event *event, const char *event_type);
 #endif
@@ -203,10 +204,14 @@ class APIConnection final : public APIServerConnection {
   bool send_disconnect_response(const DisconnectRequest &msg) override;
   bool send_ping_response(const PingRequest &msg) override;
   bool send_device_info_response(const DeviceInfoRequest &msg) override;
-  void list_entities(const ListEntitiesRequest &msg) override { this->list_entities_iterator_.begin(); }
+  void list_entities(const ListEntitiesRequest &msg) override { this->begin_iterator_(ActiveIterator::LIST_ENTITIES); }
   void subscribe_states(const SubscribeStatesRequest &msg) override {
     this->flags_.state_subscription = true;
-    this->initial_state_iterator_.begin();
+    // Start initial state iterator only if no iterator is active
+    // If list_entities is running, we'll start initial_state when it completes
+    if (this->active_iterator_ == ActiveIterator::NONE) {
+      this->begin_iterator_(ActiveIterator::INITIAL_STATE);
+    }
   }
   void subscribe_logs(const SubscribeLogsRequest &msg) override {
     this->flags_.log_subscription = msg.level;
@@ -224,9 +229,9 @@ class APIConnection final : public APIServerConnection {
 #ifdef USE_API_USER_DEFINED_ACTIONS
   void execute_service(const ExecuteServiceRequest &msg) override;
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-  void send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message);
+  void send_execute_service_response(uint32_t call_id, bool success, StringRef error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  void send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message,
+  void send_execute_service_response(uint32_t call_id, bool success, StringRef error_message,
                                      const uint8_t *response_data, size_t response_data_len);
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -280,13 +285,20 @@ class APIConnection final : public APIServerConnection {
   bool try_to_clear_buffer(bool log_out_of_space);
   bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) override;
 
-  const std::string &get_name() const { return this->client_info_.name; }
-  const std::string &get_peername() const { return this->client_info_.peername; }
+  const char *get_name() const { return this->helper_->get_client_name(); }
+  /// Get peer name (IP address) into a stack buffer - avoids heap allocation
+  size_t get_peername_to(std::span<char, socket::PEERNAME_MAX_LEN> buf) const {
+    return this->helper_->getpeername_to(buf);
+  }
 
  protected:
   // Helper function to handle authentication completion
   void complete_authentication_();
 
+#ifdef USE_CAMERA
+  void try_send_camera_image_();
+#endif
+
 #ifdef USE_API_HOMEASSISTANT_STATES
   void process_state_subscriptions_();
 #endif
@@ -310,16 +322,15 @@ class APIConnection final : public APIServerConnection {
                                               APIConnection *conn, uint32_t remaining_size, bool is_single) {
     // Set common fields that are shared by all entity types
     msg.key = entity->get_object_id_hash();
-    // Try to use static reference first to avoid allocation
-    StringRef static_ref = entity->get_object_id_ref_for_api_();
-    // Store dynamic string outside the if-else to maintain lifetime
-    std::string object_id;
-    if (!static_ref.empty()) {
-      msg.set_object_id(static_ref);
-    } else {
-      // Dynamic case - need to allocate
-      object_id = entity->get_object_id();
-      msg.set_object_id(StringRef(object_id));
+
+    // API 1.14+ clients compute object_id client-side from the entity name
+    // For older clients, we must send object_id for backward compatibility
+    // See: https://github.com/esphome/backlog/issues/76
+    // TODO: Remove this backward compat code before 2026.7.0 - all clients should support API 1.14 by then
+    // Buffer must remain in scope until encode_message_to_buffer is called
+    char object_id_buf[OBJECT_ID_MAX_LEN];
+    if (!conn->client_supports_api_version(1, 14)) {
+      msg.set_object_id(entity->get_object_id_to(object_id_buf));
     }
 
     if (entity->has_own_name()) {
@@ -343,16 +354,24 @@ class APIConnection final : public APIServerConnection {
   inline bool check_voice_assistant_api_connection_() const;
 #endif
 
+  // Get the max batch size based on client API version
+  // API 1.14+ clients don't receive object_id, so messages are smaller and more fit per batch
+  // TODO: Remove this method before 2026.7.0 and use MAX_INITIAL_PER_BATCH directly
+  size_t get_max_batch_size_() const {
+    return this->client_supports_api_version(1, 14) ? MAX_INITIAL_PER_BATCH : MAX_INITIAL_PER_BATCH_LEGACY;
+  }
+
   // Helper method to process multiple entities from an iterator in a batch
   template<typename Iterator> void process_iterator_batch_(Iterator &iterator) {
     size_t initial_size = this->deferred_batch_.size();
-    while (!iterator.completed() && (this->deferred_batch_.size() - initial_size) < MAX_INITIAL_PER_BATCH) {
+    size_t max_batch = this->get_max_batch_size_();
+    while (!iterator.completed() && (this->deferred_batch_.size() - initial_size) < max_batch) {
       iterator.advance();
     }
 
     // If the batch is full, process it immediately
     // Note: iterator.advance() already calls schedule_batch_() via schedule_message_()
-    if (this->deferred_batch_.size() >= MAX_INITIAL_PER_BATCH) {
+    if (this->deferred_batch_.size() >= max_batch) {
       this->process_batch_();
     }
   }
@@ -456,6 +475,12 @@ class APIConnection final : public APIServerConnection {
   static uint16_t try_send_alarm_control_panel_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                     bool is_single);
 #endif
+#ifdef USE_WATER_HEATER
+  static uint16_t try_send_water_heater_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                              bool is_single);
+  static uint16_t try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                             bool is_single);
+#endif
 #ifdef USE_EVENT
   static uint16_t try_send_event_response(event::Event *event, const char *event_type, APIConnection *conn,
                                           uint32_t remaining_size, bool is_single);
@@ -490,18 +515,27 @@ class APIConnection final : public APIServerConnection {
   std::unique_ptr<APIFrameHelper> helper_;
   APIServer *parent_;
 
-  // Group 2: Larger objects (must be 4-byte aligned)
-  // These contain vectors/pointers internally, so putting them early ensures good alignment
-  InitialStateIterator initial_state_iterator_;
-  ListEntitiesIterator list_entities_iterator_;
+  // Group 2: Iterator union (saves ~16 bytes vs separate iterators)
+  // These iterators are never active simultaneously - list_entities runs to completion
+  // before initial_state begins, so we use a union with explicit construction/destruction.
+  enum class ActiveIterator : uint8_t { NONE, LIST_ENTITIES, INITIAL_STATE };
+
+  union IteratorUnion {
+    ListEntitiesIterator list_entities;
+    InitialStateIterator initial_state;
+    // Constructor/destructor do nothing - use placement new/explicit destructor
+    IteratorUnion() {}
+    ~IteratorUnion() {}
+  } iterator_storage_;
+
+  // Helper methods for iterator lifecycle management
+  void destroy_active_iterator_();
+  void begin_iterator_(ActiveIterator type);
 #ifdef USE_CAMERA
   std::unique_ptr<camera::CameraImageReader> image_reader_;
 #endif
 
-  // Group 3: Client info struct (24 bytes on 32-bit: 2 strings × 12 bytes each)
-  ClientInfo client_info_;
-
-  // Group 4: 4-byte types
+  // Group 3: 4-byte types
   uint32_t last_traffic_;
 #ifdef USE_API_HOMEASSISTANT_STATES
   int state_subs_at_ = -1;
@@ -608,7 +642,9 @@ class APIConnection final : public APIServerConnection {
   // 2-byte types immediately after flags_ (no padding between them)
   uint16_t client_api_version_major_{0};
   uint16_t client_api_version_minor_{0};
-  // Total: 2 (flags) + 2 + 2 = 6 bytes, then 2 bytes padding to next 4-byte boundary
+  // 1-byte type to fill padding
+  ActiveIterator active_iterator_{ActiveIterator::NONE};
+  // Total: 2 (flags) + 2 + 2 + 1 = 7 bytes, then 1 byte padding to next 4-byte boundary
 
   uint32_t get_batch_delay_ms_() const;
   // Message will use 8 more bytes than the minimum size, and typical
@@ -726,6 +762,8 @@ class APIConnection final : public APIServerConnection {
     return this->schedule_batch_();
   }
 
+  // Helper function to log client messages with name and peername
+  void log_client_(int level, const LogString *message);
   // Helper function to log API errors with errno
   void log_warning_(const LogString *message, APIError err);
   // Helper to handle fatal errors with logging

esphome/components/api/api_frame_helper.cpp

@@ -1,6 +1,5 @@
 #include "api_frame_helper.h"
 #ifdef USE_API
-#include "api_connection.h"  // For ClientInfo struct
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
@@ -13,12 +12,34 @@ namespace esphome::api {
 
 static const char *const TAG = "api.frame_helper";
 
+// Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
+static constexpr size_t API_MAX_LOG_BYTES = 168;
+
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
 #define HELPER_LOG(msg, ...) \
-  ESP_LOGVV(TAG, "%s (%s): " msg, this->client_info_->name.c_str(), this->client_info_->peername.c_str(), ##__VA_ARGS__)
+  do { \
+    char peername__[socket::PEERNAME_MAX_LEN]; \
+    this->socket_->getpeername_to(peername__); \
+    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername__, ##__VA_ARGS__); \
+  } while (0)
+#else
+#define HELPER_LOG(msg, ...) ((void) 0)
+#endif
 
 #ifdef HELPER_LOG_PACKETS
-#define LOG_PACKET_RECEIVED(buffer) ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(buffer).c_str())
-#define LOG_PACKET_SENDING(data, len) ESP_LOGVV(TAG, "Sending raw: %s", format_hex_pretty(data, len).c_str())
+#define LOG_PACKET_RECEIVED(buffer) \
+  do { \
+    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
+    ESP_LOGVV(TAG, "Received frame: %s", \
+              format_hex_pretty_to(hex_buf_, (buffer).data(), \
+                                   (buffer).size() < API_MAX_LOG_BYTES ? (buffer).size() : API_MAX_LOG_BYTES)); \
+  } while (0)
+#define LOG_PACKET_SENDING(data, len) \
+  do { \
+    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
+    ESP_LOGVV(TAG, "Sending raw: %s", \
+              format_hex_pretty_to(hex_buf_, data, (len) < API_MAX_LOG_BYTES ? (len) : API_MAX_LOG_BYTES)); \
+  } while (0)
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
 #define LOG_PACKET_SENDING(data, len) ((void) 0)

esphome/components/api/api_frame_helper.h

@@ -29,11 +29,11 @@ static constexpr uint16_t MAX_MESSAGE_SIZE = 8192;  // 8 KiB for ESP8266
 static constexpr uint16_t MAX_MESSAGE_SIZE = 32768;  // 32 KiB for ESP32 and other platforms
 #endif
 
-// Forward declaration
-struct ClientInfo;
-
 class ProtoWriteBuffer;
 
+// Max client name length (e.g., "Home Assistant 2026.1.0.dev0" = 28 chars)
+static constexpr size_t CLIENT_INFO_NAME_MAX_LEN = 32;
+
 struct ReadPacketBuffer {
   const uint8_t *data;  // Points directly into frame helper's rx_buf_ (valid until next read_packet call)
   uint16_t data_len;
@@ -82,15 +82,23 @@ const LogString *api_error_to_logstr(APIError err);
 class APIFrameHelper {
  public:
   APIFrameHelper() = default;
-  explicit APIFrameHelper(std::unique_ptr<socket::Socket> socket, const ClientInfo *client_info)
-      : socket_(std::move(socket)), client_info_(client_info) {}
+  explicit APIFrameHelper(std::unique_ptr<socket::Socket> socket) : socket_(std::move(socket)) {}
+
+  // Get client name (null-terminated)
+  const char *get_client_name() const { return this->client_name_; }
+  // Set client name from buffer with length (truncates if needed)
+  void set_client_name(const char *name, size_t len) {
+    size_t copy_len = std::min(len, sizeof(this->client_name_) - 1);
+    memcpy(this->client_name_, name, copy_len);
+    this->client_name_[copy_len] = '\0';
+  }
   virtual ~APIFrameHelper() = default;
   virtual APIError init() = 0;
   virtual APIError loop();
   virtual APIError read_packet(ReadPacketBuffer *buffer) = 0;
   bool can_write_without_blocking() { return this->state_ == State::DATA && this->tx_buf_count_ == 0; }
-  std::string getpeername() { return socket_->getpeername(); }
   int getpeername(struct sockaddr *addr, socklen_t *addrlen) { return socket_->getpeername(addr, addrlen); }
+  size_t getpeername_to(std::span<char, socket::PEERNAME_MAX_LEN> buf) { return socket_->getpeername_to(buf); }
   APIError close() {
     state_ = State::CLOSED;
     int err = this->socket_->close();
@@ -189,9 +197,8 @@ class APIFrameHelper {
   std::vector<struct iovec> reusable_iovs_;
   std::vector<uint8_t> rx_buf_;
 
-  // Pointer to client info (4 bytes on 32-bit)
-  // Note: The pointed-to ClientInfo object must outlive this APIFrameHelper instance.
-  const ClientInfo *client_info_{nullptr};
+  // Client name buffer - stores name from Hello message or initial peername
+  char client_name_[CLIENT_INFO_NAME_MAX_LEN]{};
 
   // Group smaller types together
   uint16_t rx_buf_len_ = 0;

esphome/components/api/api_frame_helper_noise.cpp

@@ -24,12 +24,34 @@ static const char *const PROLOGUE_INIT = "NoiseAPIInit";
 #endif
 static constexpr size_t PROLOGUE_INIT_LEN = 12;  // strlen("NoiseAPIInit")
 
+// Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
+static constexpr size_t API_MAX_LOG_BYTES = 168;
+
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
 #define HELPER_LOG(msg, ...) \
-  ESP_LOGVV(TAG, "%s (%s): " msg, this->client_info_->name.c_str(), this->client_info_->peername.c_str(), ##__VA_ARGS__)
+  do { \
+    char peername__[socket::PEERNAME_MAX_LEN]; \
+    this->socket_->getpeername_to(peername__); \
+    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername__, ##__VA_ARGS__); \
+  } while (0)
+#else
+#define HELPER_LOG(msg, ...) ((void) 0)
+#endif
 
 #ifdef HELPER_LOG_PACKETS
-#define LOG_PACKET_RECEIVED(buffer) ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(buffer).c_str())
-#define LOG_PACKET_SENDING(data, len) ESP_LOGVV(TAG, "Sending raw: %s", format_hex_pretty(data, len).c_str())
+#define LOG_PACKET_RECEIVED(buffer) \
+  do { \
+    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
+    ESP_LOGVV(TAG, "Received frame: %s", \
+              format_hex_pretty_to(hex_buf_, (buffer).data(), \
+                                   (buffer).size() < API_MAX_LOG_BYTES ? (buffer).size() : API_MAX_LOG_BYTES)); \
+  } while (0)
+#define LOG_PACKET_SENDING(data, len) \
+  do { \
+    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
+    ESP_LOGVV(TAG, "Sending raw: %s", \
+              format_hex_pretty_to(hex_buf_, data, (len) < API_MAX_LOG_BYTES ? (len) : API_MAX_LOG_BYTES)); \
+  } while (0)
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
 #define LOG_PACKET_SENDING(data, len) ((void) 0)

esphome/components/api/api_frame_helper_noise.h

@@ -9,8 +9,8 @@ namespace esphome::api {
 
 class APINoiseFrameHelper final : public APIFrameHelper {
  public:
-  APINoiseFrameHelper(std::unique_ptr<socket::Socket> socket, APINoiseContext &ctx, const ClientInfo *client_info)
-      : APIFrameHelper(std::move(socket), client_info), ctx_(ctx) {
+  APINoiseFrameHelper(std::unique_ptr<socket::Socket> socket, APINoiseContext &ctx)
+      : APIFrameHelper(std::move(socket)), ctx_(ctx) {
     // Noise header structure:
     // Pos 0: indicator (0x01)
     // Pos 1-2: encrypted payload size (16-bit big-endian)

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -1,7 +1,6 @@
 #include "api_frame_helper_plaintext.h"
 #ifdef USE_API
 #ifdef USE_API_PLAINTEXT
-#include "api_connection.h"  // For ClientInfo struct
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
@@ -18,12 +17,34 @@ namespace esphome::api {
 
 static const char *const TAG = "api.plaintext";
 
+// Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
+static constexpr size_t API_MAX_LOG_BYTES = 168;
+
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
 #define HELPER_LOG(msg, ...) \
-  ESP_LOGVV(TAG, "%s (%s): " msg, this->client_info_->name.c_str(), this->client_info_->peername.c_str(), ##__VA_ARGS__)
+  do { \
+    char peername__[socket::PEERNAME_MAX_LEN]; \
+    this->socket_->getpeername_to(peername__); \
+    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername__, ##__VA_ARGS__); \
+  } while (0)
+#else
+#define HELPER_LOG(msg, ...) ((void) 0)
+#endif
 
 #ifdef HELPER_LOG_PACKETS
-#define LOG_PACKET_RECEIVED(buffer) ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(buffer).c_str())
-#define LOG_PACKET_SENDING(data, len) ESP_LOGVV(TAG, "Sending raw: %s", format_hex_pretty(data, len).c_str())
+#define LOG_PACKET_RECEIVED(buffer) \
+  do { \
+    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
+    ESP_LOGVV(TAG, "Received frame: %s", \
+              format_hex_pretty_to(hex_buf_, (buffer).data(), \
+                                   (buffer).size() < API_MAX_LOG_BYTES ? (buffer).size() : API_MAX_LOG_BYTES)); \
+  } while (0)
+#define LOG_PACKET_SENDING(data, len) \
+  do { \
+    char hex_buf_[format_hex_pretty_size(API_MAX_LOG_BYTES)]; \
+    ESP_LOGVV(TAG, "Sending raw: %s", \
+              format_hex_pretty_to(hex_buf_, data, (len) < API_MAX_LOG_BYTES ? (len) : API_MAX_LOG_BYTES)); \
+  } while (0)
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
 #define LOG_PACKET_SENDING(data, len) ((void) 0)

esphome/components/api/api_frame_helper_plaintext.h

@@ -7,8 +7,7 @@ namespace esphome::api {
 
 class APIPlaintextFrameHelper final : public APIFrameHelper {
  public:
-  APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket, const ClientInfo *client_info)
-      : APIFrameHelper(std::move(socket), client_info) {
+  explicit APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket) : APIFrameHelper(std::move(socket)) {
     // Plaintext header structure (worst case):
     // Pos 0: indicator (0x00)
     // Pos 1-3: payload size varint (up to 3 bytes)

esphome/components/api/api_pb2.cpp

@@ -23,9 +23,7 @@ bool HelloRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-      // Use raw data directly to avoid allocation
-      this->client_info = value.data();
-      this->client_info_len = value.size();
+      this->client_info = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -49,9 +47,7 @@ void HelloResponse::calculate_size(ProtoSize &size) const {
 bool AuthenticationRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-      // Use raw data directly to avoid allocation
-      this->password = value.data();
-      this->password_len = value.size();
+      this->password = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -124,12 +120,12 @@ void DeviceInfoResponse::encode(ProtoWriteBuffer buffer) const {
 #endif
 #ifdef USE_DEVICES
   for (const auto &it : this->devices) {
-    buffer.encode_message(20, it, true);
+    buffer.encode_message(20, it);
   }
 #endif
 #ifdef USE_AREAS
   for (const auto &it : this->areas) {
-    buffer.encode_message(21, it, true);
+    buffer.encode_message(21, it);
   }
 #endif
 #ifdef USE_AREAS
@@ -447,9 +443,10 @@ bool FanCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool FanCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 13:
-      this->preset_mode = value.as_string();
+    case 13: {
+      this->preset_mode = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -612,9 +609,7 @@ bool LightCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 bool LightCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 19: {
-      // Use raw data directly to avoid allocation
-      this->effect = value.data();
-      this->effect_len = value.size();
+      this->effect = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -855,9 +850,11 @@ void SubscribeLogsResponse::calculate_size(ProtoSize &size) const {
 #ifdef USE_API_NOISE
 bool NoiseEncryptionSetKeyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->key = value.as_string();
+    case 1: {
+      this->key = value.data();
+      this->key_len = value.size();
       break;
+    }
     default:
       return false;
   }
@@ -878,13 +875,13 @@ void HomeassistantServiceMap::calculate_size(ProtoSize &size) const {
 void HomeassistantActionRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->service_ref_);
   for (auto &it : this->data) {
-    buffer.encode_message(2, it, true);
+    buffer.encode_message(2, it);
   }
   for (auto &it : this->data_template) {
-    buffer.encode_message(3, it, true);
+    buffer.encode_message(3, it);
   }
   for (auto &it : this->variables) {
-    buffer.encode_message(4, it, true);
+    buffer.encode_message(4, it);
   }
   buffer.encode_bool(5, this->is_event);
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
@@ -930,12 +927,12 @@ bool HomeassistantActionResponse::decode_varint(uint32_t field_id, ProtoVarInt v
 }
 bool HomeassistantActionResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 3:
-      this->error_message = value.as_string();
+    case 3: {
+      this->error_message = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
     case 4: {
-      // Use raw data directly to avoid allocation
       this->response_data = value.data();
       this->response_data_len = value.size();
       break;
@@ -960,15 +957,18 @@ void SubscribeHomeAssistantStateResponse::calculate_size(ProtoSize &size) const
 }
 bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->entity_id = value.as_string();
+    case 1: {
+      this->entity_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 2:
-      this->state = value.as_string();
+    }
+    case 2: {
+      this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 3:
-      this->attribute = value.as_string();
+    }
+    case 3: {
+      this->attribute = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -978,9 +978,7 @@ bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDel
 bool GetTimeResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-      // Use raw data directly to avoid allocation
-      this->timezone = value.data();
-      this->timezone_len = value.size();
+      this->timezone = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -1011,7 +1009,7 @@ void ListEntitiesServicesResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->name_ref_);
   buffer.encode_fixed32(2, this->key);
   for (auto &it : this->args) {
-    buffer.encode_message(3, it, true);
+    buffer.encode_message(3, it);
   }
   buffer.encode_uint32(4, static_cast<uint32_t>(this->supports_response));
 }
@@ -1045,9 +1043,10 @@ bool ExecuteServiceArgument::decode_varint(uint32_t field_id, ProtoVarInt value)
 }
 bool ExecuteServiceArgument::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 4:
-      this->string_ = value.as_string();
+    case 4: {
+      this->string_ = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     case 9:
       this->string_array.push_back(value.as_string());
       break;
@@ -1138,7 +1137,7 @@ void ExecuteServiceResponse::calculate_size(ProtoSize &size) const {
   size.add_bool(1, this->success);
   size.add_length(1, this->error_message_ref_.size());
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  size.add_length(4, this->response_data_len);
+  size.add_length(1, this->response_data_len);
 #endif
 }
 #endif
@@ -1392,12 +1391,14 @@ bool ClimateCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value)
 }
 bool ClimateCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 17:
-      this->custom_fan_mode = value.as_string();
+    case 17: {
+      this->custom_fan_mode = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 21:
-      this->custom_preset = value.as_string();
+    }
+    case 21: {
+      this->custom_preset = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -1426,6 +1427,114 @@ bool ClimateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   return true;
 }
 #endif
+#ifdef USE_WATER_HEATER
+void ListEntitiesWaterHeaterResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->object_id_ref_);
+  buffer.encode_fixed32(2, this->key);
+  buffer.encode_string(3, this->name_ref_);
+#ifdef USE_ENTITY_ICON
+  buffer.encode_string(4, this->icon_ref_);
+#endif
+  buffer.encode_bool(5, this->disabled_by_default);
+  buffer.encode_uint32(6, static_cast<uint32_t>(this->entity_category));
+#ifdef USE_DEVICES
+  buffer.encode_uint32(7, this->device_id);
+#endif
+  buffer.encode_float(8, this->min_temperature);
+  buffer.encode_float(9, this->max_temperature);
+  buffer.encode_float(10, this->target_temperature_step);
+  for (const auto &it : *this->supported_modes) {
+    buffer.encode_uint32(11, static_cast<uint32_t>(it), true);
+  }
+  buffer.encode_uint32(12, this->supported_features);
+}
+void ListEntitiesWaterHeaterResponse::calculate_size(ProtoSize &size) const {
+  size.add_length(1, this->object_id_ref_.size());
+  size.add_fixed32(1, this->key);
+  size.add_length(1, this->name_ref_.size());
+#ifdef USE_ENTITY_ICON
+  size.add_length(1, this->icon_ref_.size());
+#endif
+  size.add_bool(1, this->disabled_by_default);
+  size.add_uint32(1, static_cast<uint32_t>(this->entity_category));
+#ifdef USE_DEVICES
+  size.add_uint32(1, this->device_id);
+#endif
+  size.add_float(1, this->min_temperature);
+  size.add_float(1, this->max_temperature);
+  size.add_float(1, this->target_temperature_step);
+  if (!this->supported_modes->empty()) {
+    for (const auto &it : *this->supported_modes) {
+      size.add_uint32_force(1, static_cast<uint32_t>(it));
+    }
+  }
+  size.add_uint32(1, this->supported_features);
+}
+void WaterHeaterStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_float(2, this->current_temperature);
+  buffer.encode_float(3, this->target_temperature);
+  buffer.encode_uint32(4, static_cast<uint32_t>(this->mode));
+#ifdef USE_DEVICES
+  buffer.encode_uint32(5, this->device_id);
+#endif
+  buffer.encode_uint32(6, this->state);
+  buffer.encode_float(7, this->target_temperature_low);
+  buffer.encode_float(8, this->target_temperature_high);
+}
+void WaterHeaterStateResponse::calculate_size(ProtoSize &size) const {
+  size.add_fixed32(1, this->key);
+  size.add_float(1, this->current_temperature);
+  size.add_float(1, this->target_temperature);
+  size.add_uint32(1, static_cast<uint32_t>(this->mode));
+#ifdef USE_DEVICES
+  size.add_uint32(1, this->device_id);
+#endif
+  size.add_uint32(1, this->state);
+  size.add_float(1, this->target_temperature_low);
+  size.add_float(1, this->target_temperature_high);
+}
+bool WaterHeaterCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2:
+      this->has_fields = value.as_uint32();
+      break;
+    case 3:
+      this->mode = static_cast<enums::WaterHeaterMode>(value.as_uint32());
+      break;
+#ifdef USE_DEVICES
+    case 5:
+      this->device_id = value.as_uint32();
+      break;
+#endif
+    case 6:
+      this->state = value.as_uint32();
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+bool WaterHeaterCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 4:
+      this->target_temperature = value.as_float();
+      break;
+    case 7:
+      this->target_temperature_low = value.as_float();
+      break;
+    case 8:
+      this->target_temperature_high = value.as_float();
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+#endif
 #ifdef USE_NUMBER
 void ListEntitiesNumberResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id_ref_);
@@ -1573,9 +1682,7 @@ bool SelectCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 bool SelectCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-      // Use raw data directly to avoid allocation
-      this->state = value.data();
-      this->state_len = value.size();
+      this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -1603,8 +1710,8 @@ void ListEntitiesSirenResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(5, this->icon_ref_);
 #endif
   buffer.encode_bool(6, this->disabled_by_default);
-  for (auto &it : this->tones) {
-    buffer.encode_string(7, it, true);
+  for (const char *it : *this->tones) {
+    buffer.encode_string(7, it, strlen(it), true);
   }
   buffer.encode_bool(8, this->supports_duration);
   buffer.encode_bool(9, this->supports_volume);
@@ -1621,9 +1728,9 @@ void ListEntitiesSirenResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->icon_ref_.size());
 #endif
   size.add_bool(1, this->disabled_by_default);
-  if (!this->tones.empty()) {
-    for (const auto &it : this->tones) {
-      size.add_length_force(1, it.size());
+  if (!this->tones->empty()) {
+    for (const char *it : *this->tones) {
+      size.add_length_force(1, strlen(it));
     }
   }
   size.add_bool(1, this->supports_duration);
@@ -1679,9 +1786,10 @@ bool SirenCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool SirenCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 5:
-      this->tone = value.as_string();
+    case 5: {
+      this->tone = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -1770,9 +1878,10 @@ bool LockCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool LockCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 4:
-      this->code = value.as_string();
+    case 4: {
+      this->code = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -1867,7 +1976,7 @@ void ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(7, static_cast<uint32_t>(this->entity_category));
   buffer.encode_bool(8, this->supports_pause);
   for (auto &it : this->supported_formats) {
-    buffer.encode_message(9, it, true);
+    buffer.encode_message(9, it);
   }
 #ifdef USE_DEVICES
   buffer.encode_uint32(10, this->device_id);
@@ -1940,9 +2049,10 @@ bool MediaPlayerCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt val
 }
 bool MediaPlayerCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 7:
-      this->media_url = value.as_string();
+    case 7: {
+      this->media_url = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -1987,7 +2097,7 @@ void BluetoothLERawAdvertisement::calculate_size(ProtoSize &size) const {
 }
 void BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer buffer) const {
   for (uint16_t i = 0; i < this->advertisements_len; i++) {
-    buffer.encode_message(1, this->advertisements[i], true);
+    buffer.encode_message(1, this->advertisements[i]);
   }
 }
 void BluetoothLERawAdvertisementsResponse::calculate_size(ProtoSize &size) const {
@@ -2060,7 +2170,7 @@ void BluetoothGATTCharacteristic::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->handle);
   buffer.encode_uint32(3, this->properties);
   for (auto &it : this->descriptors) {
-    buffer.encode_message(4, it, true);
+    buffer.encode_message(4, it);
   }
   buffer.encode_uint32(5, this->short_uuid);
 }
@@ -2081,7 +2191,7 @@ void BluetoothGATTService::encode(ProtoWriteBuffer buffer) const {
   }
   buffer.encode_uint32(2, this->handle);
   for (auto &it : this->characteristics) {
-    buffer.encode_message(3, it, true);
+    buffer.encode_message(3, it);
   }
   buffer.encode_uint32(4, this->short_uuid);
 }
@@ -2097,7 +2207,7 @@ void BluetoothGATTService::calculate_size(ProtoSize &size) const {
 void BluetoothGATTGetServicesResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   for (auto &it : this->services) {
-    buffer.encode_message(2, it, true);
+    buffer.encode_message(2, it);
   }
 }
 void BluetoothGATTGetServicesResponse::calculate_size(ProtoSize &size) const {
@@ -2150,7 +2260,6 @@ bool BluetoothGATTWriteRequest::decode_varint(uint32_t field_id, ProtoVarInt val
 bool BluetoothGATTWriteRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 4: {
-      // Use raw data directly to avoid allocation
       this->data = value.data();
       this->data_len = value.size();
       break;
@@ -2189,7 +2298,6 @@ bool BluetoothGATTWriteDescriptorRequest::decode_varint(uint32_t field_id, Proto
 bool BluetoothGATTWriteDescriptorRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 3: {
-      // Use raw data directly to avoid allocation
       this->data = value.data();
       this->data_len = value.size();
       break;
@@ -2373,12 +2481,14 @@ bool VoiceAssistantResponse::decode_varint(uint32_t field_id, ProtoVarInt value)
 }
 bool VoiceAssistantEventData::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->name = value.as_string();
+    case 1: {
+      this->name = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 2:
-      this->value = value.as_string();
+    }
+    case 2: {
+      this->value = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2417,20 +2527,22 @@ bool VoiceAssistantAudio::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool VoiceAssistantAudio::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->data = value.as_string();
+    case 1: {
+      this->data = value.data();
+      this->data_len = value.size();
       break;
+    }
     default:
       return false;
   }
   return true;
 }
 void VoiceAssistantAudio::encode(ProtoWriteBuffer buffer) const {
-  buffer.encode_bytes(1, this->data_ptr_, this->data_len_);
+  buffer.encode_bytes(1, this->data, this->data_len);
   buffer.encode_bool(2, this->end);
 }
 void VoiceAssistantAudio::calculate_size(ProtoSize &size) const {
-  size.add_length(1, this->data_len_);
+  size.add_length(1, this->data_len);
   size.add_bool(1, this->end);
 }
 bool VoiceAssistantTimerEventResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
@@ -2454,12 +2566,14 @@ bool VoiceAssistantTimerEventResponse::decode_varint(uint32_t field_id, ProtoVar
 }
 bool VoiceAssistantTimerEventResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 2:
-      this->timer_id = value.as_string();
+    case 2: {
+      this->timer_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 3:
-      this->name = value.as_string();
+    }
+    case 3: {
+      this->name = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2477,15 +2591,18 @@ bool VoiceAssistantAnnounceRequest::decode_varint(uint32_t field_id, ProtoVarInt
 }
 bool VoiceAssistantAnnounceRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->media_id = value.as_string();
+    case 1: {
+      this->media_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 2:
-      this->text = value.as_string();
+    }
+    case 2: {
+      this->text = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 3:
-      this->preannounce_media_id = value.as_string();
+    }
+    case 3: {
+      this->preannounce_media_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2521,24 +2638,29 @@ bool VoiceAssistantExternalWakeWord::decode_varint(uint32_t field_id, ProtoVarIn
 }
 bool VoiceAssistantExternalWakeWord::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->id = value.as_string();
+    case 1: {
+      this->id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 2:
-      this->wake_word = value.as_string();
+    }
+    case 2: {
+      this->wake_word = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     case 3:
       this->trained_languages.push_back(value.as_string());
       break;
-    case 4:
-      this->model_type = value.as_string();
+    case 4: {
+      this->model_type = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 6:
-      this->model_hash = value.as_string();
+    }
+    case 6: {
+      this->model_hash = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 7:
-      this->url = value.as_string();
+    }
+    case 7: {
+      this->url = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2557,7 +2679,7 @@ bool VoiceAssistantConfigurationRequest::decode_length(uint32_t field_id, ProtoL
 }
 void VoiceAssistantConfigurationResponse::encode(ProtoWriteBuffer buffer) const {
   for (auto &it : this->available_wake_words) {
-    buffer.encode_message(1, it, true);
+    buffer.encode_message(1, it);
   }
   for (const auto &it : *this->active_wake_words) {
     buffer.encode_string(2, it, true);
@@ -2648,9 +2770,10 @@ bool AlarmControlPanelCommandRequest::decode_varint(uint32_t field_id, ProtoVarI
 }
 bool AlarmControlPanelCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 3:
-      this->code = value.as_string();
+    case 3: {
+      this->code = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2732,9 +2855,10 @@ bool TextCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool TextCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 2:
-      this->state = value.as_string();
+    case 2: {
+      this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -3202,7 +3326,6 @@ bool UpdateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 bool ZWaveProxyFrame::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-      // Use raw data directly to avoid allocation
       this->data = value.data();
       this->data_len = value.size();
       break;
@@ -3227,7 +3350,6 @@ bool ZWaveProxyRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 bool ZWaveProxyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-      // Use raw data directly to avoid allocation
       this->data = value.data();
       this->data_len = value.size();
       break;
@@ -3243,7 +3365,7 @@ void ZWaveProxyRequest::encode(ProtoWriteBuffer buffer) const {
 }
 void ZWaveProxyRequest::calculate_size(ProtoSize &size) const {
   size.add_uint32(1, static_cast<uint32_t>(this->type));
-  size.add_length(2, this->data_len);
+  size.add_length(1, this->data_len);
 }
 #endif
 

esphome/components/api/api_pb2.h

@@ -129,6 +129,25 @@ enum ClimatePreset : uint32_t {
   CLIMATE_PRESET_ACTIVITY = 7,
 };
 #endif
+#ifdef USE_WATER_HEATER
+enum WaterHeaterMode : uint32_t {
+  WATER_HEATER_MODE_OFF = 0,
+  WATER_HEATER_MODE_ECO = 1,
+  WATER_HEATER_MODE_ELECTRIC = 2,
+  WATER_HEATER_MODE_PERFORMANCE = 3,
+  WATER_HEATER_MODE_HIGH_DEMAND = 4,
+  WATER_HEATER_MODE_HEAT_PUMP = 5,
+  WATER_HEATER_MODE_GAS = 6,
+};
+#endif
+enum WaterHeaterCommandHasField : uint32_t {
+  WATER_HEATER_COMMAND_HAS_NONE = 0,
+  WATER_HEATER_COMMAND_HAS_MODE = 1,
+  WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE = 2,
+  WATER_HEATER_COMMAND_HAS_STATE = 4,
+  WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW = 8,
+  WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH = 16,
+};
 #ifdef USE_NUMBER
 enum NumberMode : uint32_t {
   NUMBER_MODE_AUTO = 0,
@@ -338,12 +357,11 @@ class CommandProtoMessage : public ProtoDecodableMessage {
 class HelloRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 1;
-  static constexpr uint8_t ESTIMATED_SIZE = 27;
+  static constexpr uint8_t ESTIMATED_SIZE = 17;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "hello_request"; }
 #endif
-  const uint8_t *client_info{nullptr};
-  uint16_t client_info_len{0};
+  StringRef client_info{};
   uint32_t api_version_major{0};
   uint32_t api_version_minor{0};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -379,12 +397,11 @@ class HelloResponse final : public ProtoMessage {
 class AuthenticationRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 3;
-  static constexpr uint8_t ESTIMATED_SIZE = 19;
+  static constexpr uint8_t ESTIMATED_SIZE = 9;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "authentication_request"; }
 #endif
-  const uint8_t *password{nullptr};
-  uint16_t password_len{0};
+  StringRef password{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -778,7 +795,7 @@ class FanCommandRequest final : public CommandProtoMessage {
   bool has_speed_level{false};
   int32_t speed_level{0};
   bool has_preset_mode{false};
-  std::string preset_mode{};
+  StringRef preset_mode{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -840,7 +857,7 @@ class LightStateResponse final : public StateResponseProtoMessage {
 class LightCommandRequest final : public CommandProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 32;
-  static constexpr uint8_t ESTIMATED_SIZE = 122;
+  static constexpr uint8_t ESTIMATED_SIZE = 112;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "light_command_request"; }
 #endif
@@ -869,8 +886,7 @@ class LightCommandRequest final : public CommandProtoMessage {
   bool has_flash_length{false};
   uint32_t flash_length{0};
   bool has_effect{false};
-  const uint8_t *effect{nullptr};
-  uint16_t effect_len{0};
+  StringRef effect{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1057,7 +1073,8 @@ class NoiseEncryptionSetKeyRequest final : public ProtoDecodableMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "noise_encryption_set_key_request"; }
 #endif
-  std::string key{};
+  const uint8_t *key{nullptr};
+  uint16_t key_len{0};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1144,13 +1161,13 @@ class HomeassistantActionRequest final : public ProtoMessage {
 class HomeassistantActionResponse final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 130;
-  static constexpr uint8_t ESTIMATED_SIZE = 34;
+  static constexpr uint8_t ESTIMATED_SIZE = 24;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "homeassistant_action_response"; }
 #endif
   uint32_t call_id{0};
   bool success{false};
-  std::string error_message{};
+  StringRef error_message{};
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
   const uint8_t *response_data{nullptr};
   uint16_t response_data_len{0};
@@ -1205,9 +1222,9 @@ class HomeAssistantStateResponse final : public ProtoDecodableMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "home_assistant_state_response"; }
 #endif
-  std::string entity_id{};
-  std::string state{};
-  std::string attribute{};
+  StringRef entity_id{};
+  StringRef state{};
+  StringRef attribute{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1232,13 +1249,12 @@ class GetTimeRequest final : public ProtoMessage {
 class GetTimeResponse final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 37;
-  static constexpr uint8_t ESTIMATED_SIZE = 24;
+  static constexpr uint8_t ESTIMATED_SIZE = 14;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "get_time_response"; }
 #endif
   uint32_t epoch_seconds{0};
-  const uint8_t *timezone{nullptr};
-  uint16_t timezone_len{0};
+  StringRef timezone{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1286,7 +1302,7 @@ class ExecuteServiceArgument final : public ProtoDecodableMessage {
   bool bool_{false};
   int32_t legacy_int{0};
   float float_{0.0f};
-  std::string string_{};
+  StringRef string_{};
   int32_t int_{0};
   FixedVector<bool> bool_array{};
   FixedVector<int32_t> int_array{};
@@ -1492,11 +1508,11 @@ class ClimateCommandRequest final : public CommandProtoMessage {
   bool has_swing_mode{false};
   enums::ClimateSwingMode swing_mode{};
   bool has_custom_fan_mode{false};
-  std::string custom_fan_mode{};
+  StringRef custom_fan_mode{};
   bool has_preset{false};
   enums::ClimatePreset preset{};
   bool has_custom_preset{false};
-  std::string custom_preset{};
+  StringRef custom_preset{};
   bool has_target_humidity{false};
   float target_humidity{0.0f};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1509,6 +1525,70 @@ class ClimateCommandRequest final : public CommandProtoMessage {
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
 #endif
+#ifdef USE_WATER_HEATER
+class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 132;
+  static constexpr uint8_t ESTIMATED_SIZE = 63;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "list_entities_water_heater_response"; }
+#endif
+  float min_temperature{0.0f};
+  float max_temperature{0.0f};
+  float target_temperature_step{0.0f};
+  const water_heater::WaterHeaterModeMask *supported_modes{};
+  uint32_t supported_features{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void calculate_size(ProtoSize &size) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+};
+class WaterHeaterStateResponse final : public StateResponseProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 133;
+  static constexpr uint8_t ESTIMATED_SIZE = 35;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "water_heater_state_response"; }
+#endif
+  float current_temperature{0.0f};
+  float target_temperature{0.0f};
+  enums::WaterHeaterMode mode{};
+  uint32_t state{0};
+  float target_temperature_low{0.0f};
+  float target_temperature_high{0.0f};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void calculate_size(ProtoSize &size) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+};
+class WaterHeaterCommandRequest final : public CommandProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 134;
+  static constexpr uint8_t ESTIMATED_SIZE = 34;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "water_heater_command_request"; }
+#endif
+  uint32_t has_fields{0};
+  enums::WaterHeaterMode mode{};
+  float target_temperature{0.0f};
+  uint32_t state{0};
+  float target_temperature_low{0.0f};
+  float target_temperature_high{0.0f};
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+#endif
 #ifdef USE_NUMBER
 class ListEntitiesNumberResponse final : public InfoResponseProtoMessage {
  public:
@@ -1605,12 +1685,11 @@ class SelectStateResponse final : public StateResponseProtoMessage {
 class SelectCommandRequest final : public CommandProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 54;
-  static constexpr uint8_t ESTIMATED_SIZE = 28;
+  static constexpr uint8_t ESTIMATED_SIZE = 18;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "select_command_request"; }
 #endif
-  const uint8_t *state{nullptr};
-  uint16_t state_len{0};
+  StringRef state{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1629,7 +1708,7 @@ class ListEntitiesSirenResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_siren_response"; }
 #endif
-  std::vector<std::string> tones{};
+  const FixedVector<const char *> *tones{};
   bool supports_duration{false};
   bool supports_volume{false};
   void encode(ProtoWriteBuffer buffer) const override;
@@ -1666,7 +1745,7 @@ class SirenCommandRequest final : public CommandProtoMessage {
   bool has_state{false};
   bool state{false};
   bool has_tone{false};
-  std::string tone{};
+  StringRef tone{};
   bool has_duration{false};
   uint32_t duration{0};
   bool has_volume{false};
@@ -1727,7 +1806,7 @@ class LockCommandRequest final : public CommandProtoMessage {
 #endif
   enums::LockCommand command{};
   bool has_code{false};
-  std::string code{};
+  StringRef code{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1837,7 +1916,7 @@ class MediaPlayerCommandRequest final : public CommandProtoMessage {
   bool has_volume{false};
   float volume{0.0f};
   bool has_media_url{false};
-  std::string media_url{};
+  StringRef media_url{};
   bool has_announcement{false};
   bool announcement{false};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2067,7 +2146,7 @@ class BluetoothGATTReadResponse final : public ProtoMessage {
 class BluetoothGATTWriteRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 75;
-  static constexpr uint8_t ESTIMATED_SIZE = 29;
+  static constexpr uint8_t ESTIMATED_SIZE = 19;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_gatt_write_request"; }
 #endif
@@ -2103,7 +2182,7 @@ class BluetoothGATTReadDescriptorRequest final : public ProtoDecodableMessage {
 class BluetoothGATTWriteDescriptorRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 77;
-  static constexpr uint8_t ESTIMATED_SIZE = 27;
+  static constexpr uint8_t ESTIMATED_SIZE = 17;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_gatt_write_descriptor_request"; }
 #endif
@@ -2413,8 +2492,8 @@ class VoiceAssistantResponse final : public ProtoDecodableMessage {
 };
 class VoiceAssistantEventData final : public ProtoDecodableMessage {
  public:
-  std::string name{};
-  std::string value{};
+  StringRef name{};
+  StringRef value{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -2442,17 +2521,12 @@ class VoiceAssistantEventResponse final : public ProtoDecodableMessage {
 class VoiceAssistantAudio final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 106;
-  static constexpr uint8_t ESTIMATED_SIZE = 11;
+  static constexpr uint8_t ESTIMATED_SIZE = 21;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "voice_assistant_audio"; }
 #endif
-  std::string data{};
-  const uint8_t *data_ptr_{nullptr};
-  size_t data_len_{0};
-  void set_data(const uint8_t *data, size_t len) {
-    this->data_ptr_ = data;
-    this->data_len_ = len;
-  }
+  const uint8_t *data{nullptr};
+  uint16_t data_len{0};
   bool end{false};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -2472,8 +2546,8 @@ class VoiceAssistantTimerEventResponse final : public ProtoDecodableMessage {
   const char *message_name() const override { return "voice_assistant_timer_event_response"; }
 #endif
   enums::VoiceAssistantTimerEvent event_type{};
-  std::string timer_id{};
-  std::string name{};
+  StringRef timer_id{};
+  StringRef name{};
   uint32_t total_seconds{0};
   uint32_t seconds_left{0};
   bool is_active{false};
@@ -2492,9 +2566,9 @@ class VoiceAssistantAnnounceRequest final : public ProtoDecodableMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "voice_assistant_announce_request"; }
 #endif
-  std::string media_id{};
-  std::string text{};
-  std::string preannounce_media_id{};
+  StringRef media_id{};
+  StringRef text{};
+  StringRef preannounce_media_id{};
   bool start_conversation{false};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -2537,13 +2611,13 @@ class VoiceAssistantWakeWord final : public ProtoMessage {
 };
 class VoiceAssistantExternalWakeWord final : public ProtoDecodableMessage {
  public:
-  std::string id{};
-  std::string wake_word{};
+  StringRef id{};
+  StringRef wake_word{};
   std::vector<std::string> trained_languages{};
-  std::string model_type{};
+  StringRef model_type{};
   uint32_t model_size{0};
-  std::string model_hash{};
-  std::string url{};
+  StringRef model_hash{};
+  StringRef url{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -2644,7 +2718,7 @@ class AlarmControlPanelCommandRequest final : public CommandProtoMessage {
   const char *message_name() const override { return "alarm_control_panel_command_request"; }
 #endif
   enums::AlarmControlPanelStateCommand command{};
-  std::string code{};
+  StringRef code{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -2701,7 +2775,7 @@ class TextCommandRequest final : public CommandProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "text_command_request"; }
 #endif
-  std::string state{};
+  StringRef state{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif

esphome/components/api/api_pb2_dump.cpp

@@ -348,6 +348,47 @@ template<> const char *proto_enum_to_string<enums::ClimatePreset>(enums::Climate
   }
 }
 #endif
+#ifdef USE_WATER_HEATER
+template<> const char *proto_enum_to_string<enums::WaterHeaterMode>(enums::WaterHeaterMode value) {
+  switch (value) {
+    case enums::WATER_HEATER_MODE_OFF:
+      return "WATER_HEATER_MODE_OFF";
+    case enums::WATER_HEATER_MODE_ECO:
+      return "WATER_HEATER_MODE_ECO";
+    case enums::WATER_HEATER_MODE_ELECTRIC:
+      return "WATER_HEATER_MODE_ELECTRIC";
+    case enums::WATER_HEATER_MODE_PERFORMANCE:
+      return "WATER_HEATER_MODE_PERFORMANCE";
+    case enums::WATER_HEATER_MODE_HIGH_DEMAND:
+      return "WATER_HEATER_MODE_HIGH_DEMAND";
+    case enums::WATER_HEATER_MODE_HEAT_PUMP:
+      return "WATER_HEATER_MODE_HEAT_PUMP";
+    case enums::WATER_HEATER_MODE_GAS:
+      return "WATER_HEATER_MODE_GAS";
+    default:
+      return "UNKNOWN";
+  }
+}
+#endif
+template<>
+const char *proto_enum_to_string<enums::WaterHeaterCommandHasField>(enums::WaterHeaterCommandHasField value) {
+  switch (value) {
+    case enums::WATER_HEATER_COMMAND_HAS_NONE:
+      return "WATER_HEATER_COMMAND_HAS_NONE";
+    case enums::WATER_HEATER_COMMAND_HAS_MODE:
+      return "WATER_HEATER_COMMAND_HAS_MODE";
+    case enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE:
+      return "WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE";
+    case enums::WATER_HEATER_COMMAND_HAS_STATE:
+      return "WATER_HEATER_COMMAND_HAS_STATE";
+    case enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW:
+      return "WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW";
+    case enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH:
+      return "WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH";
+    default:
+      return "UNKNOWN";
+  }
+}
 #ifdef USE_NUMBER
 template<> const char *proto_enum_to_string<enums::NumberMode>(enums::NumberMode value) {
   switch (value) {
@@ -695,7 +736,7 @@ template<> const char *proto_enum_to_string<enums::ZWaveProxyRequestType>(enums:
 void HelloRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "HelloRequest");
   out.append("  client_info: ");
-  out.append(format_hex_pretty(this->client_info, this->client_info_len));
+  out.append("'").append(this->client_info.c_str(), this->client_info.size()).append("'");
   out.append("\n");
   dump_field(out, "api_version_major", this->api_version_major);
   dump_field(out, "api_version_minor", this->api_version_minor);
@@ -711,7 +752,7 @@ void HelloResponse::dump_to(std::string &out) const {
 void AuthenticationRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "AuthenticationRequest");
   out.append("  password: ");
-  out.append(format_hex_pretty(this->password, this->password_len));
+  out.append("'").append(this->password.c_str(), this->password.size()).append("'");
   out.append("\n");
 }
 void AuthenticationResponse::dump_to(std::string &out) const {
@@ -923,7 +964,9 @@ void FanCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "has_speed_level", this->has_speed_level);
   dump_field(out, "speed_level", this->speed_level);
   dump_field(out, "has_preset_mode", this->has_preset_mode);
-  dump_field(out, "preset_mode", this->preset_mode);
+  out.append("  preset_mode: ");
+  out.append("'").append(this->preset_mode.c_str(), this->preset_mode.size()).append("'");
+  out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
 #endif
@@ -1000,7 +1043,7 @@ void LightCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "flash_length", this->flash_length);
   dump_field(out, "has_effect", this->has_effect);
   out.append("  effect: ");
-  out.append(format_hex_pretty(this->effect, this->effect_len));
+  out.append("'").append(this->effect.c_str(), this->effect.size()).append("'");
   out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
@@ -1113,7 +1156,7 @@ void SubscribeLogsResponse::dump_to(std::string &out) const {
 void NoiseEncryptionSetKeyRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "NoiseEncryptionSetKeyRequest");
   out.append("  key: ");
-  out.append(format_hex_pretty(reinterpret_cast<const uint8_t *>(this->key.data()), this->key.size()));
+  out.append(format_hex_pretty(this->key, this->key_len));
   out.append("\n");
 }
 void NoiseEncryptionSetKeyResponse::dump_to(std::string &out) const { dump_field(out, "success", this->success); }
@@ -1162,7 +1205,9 @@ void HomeassistantActionResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "HomeassistantActionResponse");
   dump_field(out, "call_id", this->call_id);
   dump_field(out, "success", this->success);
-  dump_field(out, "error_message", this->error_message);
+  out.append("  error_message: ");
+  out.append("'").append(this->error_message.c_str(), this->error_message.size()).append("'");
+  out.append("\n");
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
   out.append("  response_data: ");
   out.append(format_hex_pretty(this->response_data, this->response_data_len));
@@ -1182,9 +1227,15 @@ void SubscribeHomeAssistantStateResponse::dump_to(std::string &out) const {
 }
 void HomeAssistantStateResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "HomeAssistantStateResponse");
-  dump_field(out, "entity_id", this->entity_id);
-  dump_field(out, "state", this->state);
-  dump_field(out, "attribute", this->attribute);
+  out.append("  entity_id: ");
+  out.append("'").append(this->entity_id.c_str(), this->entity_id.size()).append("'");
+  out.append("\n");
+  out.append("  state: ");
+  out.append("'").append(this->state.c_str(), this->state.size()).append("'");
+  out.append("\n");
+  out.append("  attribute: ");
+  out.append("'").append(this->attribute.c_str(), this->attribute.size()).append("'");
+  out.append("\n");
 }
 #endif
 void GetTimeRequest::dump_to(std::string &out) const { out.append("GetTimeRequest {}"); }
@@ -1192,7 +1243,7 @@ void GetTimeResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "GetTimeResponse");
   dump_field(out, "epoch_seconds", this->epoch_seconds);
   out.append("  timezone: ");
-  out.append(format_hex_pretty(this->timezone, this->timezone_len));
+  out.append("'").append(this->timezone.c_str(), this->timezone.size()).append("'");
   out.append("\n");
 }
 #ifdef USE_API_USER_DEFINED_ACTIONS
@@ -1217,7 +1268,9 @@ void ExecuteServiceArgument::dump_to(std::string &out) const {
   dump_field(out, "bool_", this->bool_);
   dump_field(out, "legacy_int", this->legacy_int);
   dump_field(out, "float_", this->float_);
-  dump_field(out, "string_", this->string_);
+  out.append("  string_: ");
+  out.append("'").append(this->string_.c_str(), this->string_.size()).append("'");
+  out.append("\n");
   dump_field(out, "int_", this->int_);
   for (const auto it : this->bool_array) {
     dump_field(out, "bool_array", static_cast<bool>(it), 4);
@@ -1374,11 +1427,15 @@ void ClimateCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "has_swing_mode", this->has_swing_mode);
   dump_field(out, "swing_mode", static_cast<enums::ClimateSwingMode>(this->swing_mode));
   dump_field(out, "has_custom_fan_mode", this->has_custom_fan_mode);
-  dump_field(out, "custom_fan_mode", this->custom_fan_mode);
+  out.append("  custom_fan_mode: ");
+  out.append("'").append(this->custom_fan_mode.c_str(), this->custom_fan_mode.size()).append("'");
+  out.append("\n");
   dump_field(out, "has_preset", this->has_preset);
   dump_field(out, "preset", static_cast<enums::ClimatePreset>(this->preset));
   dump_field(out, "has_custom_preset", this->has_custom_preset);
-  dump_field(out, "custom_preset", this->custom_preset);
+  out.append("  custom_preset: ");
+  out.append("'").append(this->custom_preset.c_str(), this->custom_preset.size()).append("'");
+  out.append("\n");
   dump_field(out, "has_target_humidity", this->has_target_humidity);
   dump_field(out, "target_humidity", this->target_humidity);
 #ifdef USE_DEVICES
@@ -1386,6 +1443,55 @@ void ClimateCommandRequest::dump_to(std::string &out) const {
 #endif
 }
 #endif
+#ifdef USE_WATER_HEATER
+void ListEntitiesWaterHeaterResponse::dump_to(std::string &out) const {
+  MessageDumpHelper helper(out, "ListEntitiesWaterHeaterResponse");
+  dump_field(out, "object_id", this->object_id_ref_);
+  dump_field(out, "key", this->key);
+  dump_field(out, "name", this->name_ref_);
+#ifdef USE_ENTITY_ICON
+  dump_field(out, "icon", this->icon_ref_);
+#endif
+  dump_field(out, "disabled_by_default", this->disabled_by_default);
+  dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
+#ifdef USE_DEVICES
+  dump_field(out, "device_id", this->device_id);
+#endif
+  dump_field(out, "min_temperature", this->min_temperature);
+  dump_field(out, "max_temperature", this->max_temperature);
+  dump_field(out, "target_temperature_step", this->target_temperature_step);
+  for (const auto &it : *this->supported_modes) {
+    dump_field(out, "supported_modes", static_cast<enums::WaterHeaterMode>(it), 4);
+  }
+  dump_field(out, "supported_features", this->supported_features);
+}
+void WaterHeaterStateResponse::dump_to(std::string &out) const {
+  MessageDumpHelper helper(out, "WaterHeaterStateResponse");
+  dump_field(out, "key", this->key);
+  dump_field(out, "current_temperature", this->current_temperature);
+  dump_field(out, "target_temperature", this->target_temperature);
+  dump_field(out, "mode", static_cast<enums::WaterHeaterMode>(this->mode));
+#ifdef USE_DEVICES
+  dump_field(out, "device_id", this->device_id);
+#endif
+  dump_field(out, "state", this->state);
+  dump_field(out, "target_temperature_low", this->target_temperature_low);
+  dump_field(out, "target_temperature_high", this->target_temperature_high);
+}
+void WaterHeaterCommandRequest::dump_to(std::string &out) const {
+  MessageDumpHelper helper(out, "WaterHeaterCommandRequest");
+  dump_field(out, "key", this->key);
+  dump_field(out, "has_fields", this->has_fields);
+  dump_field(out, "mode", static_cast<enums::WaterHeaterMode>(this->mode));
+  dump_field(out, "target_temperature", this->target_temperature);
+#ifdef USE_DEVICES
+  dump_field(out, "device_id", this->device_id);
+#endif
+  dump_field(out, "state", this->state);
+  dump_field(out, "target_temperature_low", this->target_temperature_low);
+  dump_field(out, "target_temperature_high", this->target_temperature_high);
+}
+#endif
 #ifdef USE_NUMBER
 void ListEntitiesNumberResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "ListEntitiesNumberResponse");
@@ -1456,7 +1562,7 @@ void SelectCommandRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "SelectCommandRequest");
   dump_field(out, "key", this->key);
   out.append("  state: ");
-  out.append(format_hex_pretty(this->state, this->state_len));
+  out.append("'").append(this->state.c_str(), this->state.size()).append("'");
   out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
@@ -1473,7 +1579,7 @@ void ListEntitiesSirenResponse::dump_to(std::string &out) const {
   dump_field(out, "icon", this->icon_ref_);
 #endif
   dump_field(out, "disabled_by_default", this->disabled_by_default);
-  for (const auto &it : this->tones) {
+  for (const auto &it : *this->tones) {
     dump_field(out, "tones", it, 4);
   }
   dump_field(out, "supports_duration", this->supports_duration);
@@ -1497,7 +1603,9 @@ void SirenCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "has_state", this->has_state);
   dump_field(out, "state", this->state);
   dump_field(out, "has_tone", this->has_tone);
-  dump_field(out, "tone", this->tone);
+  out.append("  tone: ");
+  out.append("'").append(this->tone.c_str(), this->tone.size()).append("'");
+  out.append("\n");
   dump_field(out, "has_duration", this->has_duration);
   dump_field(out, "duration", this->duration);
   dump_field(out, "has_volume", this->has_volume);
@@ -1539,7 +1647,9 @@ void LockCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "key", this->key);
   dump_field(out, "command", static_cast<enums::LockCommand>(this->command));
   dump_field(out, "has_code", this->has_code);
-  dump_field(out, "code", this->code);
+  out.append("  code: ");
+  out.append("'").append(this->code.c_str(), this->code.size()).append("'");
+  out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
 #endif
@@ -1617,7 +1727,9 @@ void MediaPlayerCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "has_volume", this->has_volume);
   dump_field(out, "volume", this->volume);
   dump_field(out, "has_media_url", this->has_media_url);
-  dump_field(out, "media_url", this->media_url);
+  out.append("  media_url: ");
+  out.append("'").append(this->media_url.c_str(), this->media_url.size()).append("'");
+  out.append("\n");
   dump_field(out, "has_announcement", this->has_announcement);
   dump_field(out, "announcement", this->announcement);
 #ifdef USE_DEVICES
@@ -1847,8 +1959,12 @@ void VoiceAssistantResponse::dump_to(std::string &out) const {
 }
 void VoiceAssistantEventData::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantEventData");
-  dump_field(out, "name", this->name);
-  dump_field(out, "value", this->value);
+  out.append("  name: ");
+  out.append("'").append(this->name.c_str(), this->name.size()).append("'");
+  out.append("\n");
+  out.append("  value: ");
+  out.append("'").append(this->value.c_str(), this->value.size()).append("'");
+  out.append("\n");
 }
 void VoiceAssistantEventResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantEventResponse");
@@ -1862,28 +1978,34 @@ void VoiceAssistantEventResponse::dump_to(std::string &out) const {
 void VoiceAssistantAudio::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantAudio");
   out.append("  data: ");
-  if (this->data_ptr_ != nullptr) {
-    out.append(format_hex_pretty(this->data_ptr_, this->data_len_));
-  } else {
-    out.append(format_hex_pretty(reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size()));
-  }
+  out.append(format_hex_pretty(this->data, this->data_len));
   out.append("\n");
   dump_field(out, "end", this->end);
 }
 void VoiceAssistantTimerEventResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantTimerEventResponse");
   dump_field(out, "event_type", static_cast<enums::VoiceAssistantTimerEvent>(this->event_type));
-  dump_field(out, "timer_id", this->timer_id);
-  dump_field(out, "name", this->name);
+  out.append("  timer_id: ");
+  out.append("'").append(this->timer_id.c_str(), this->timer_id.size()).append("'");
+  out.append("\n");
+  out.append("  name: ");
+  out.append("'").append(this->name.c_str(), this->name.size()).append("'");
+  out.append("\n");
   dump_field(out, "total_seconds", this->total_seconds);
   dump_field(out, "seconds_left", this->seconds_left);
   dump_field(out, "is_active", this->is_active);
 }
 void VoiceAssistantAnnounceRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantAnnounceRequest");
-  dump_field(out, "media_id", this->media_id);
-  dump_field(out, "text", this->text);
-  dump_field(out, "preannounce_media_id", this->preannounce_media_id);
+  out.append("  media_id: ");
+  out.append("'").append(this->media_id.c_str(), this->media_id.size()).append("'");
+  out.append("\n");
+  out.append("  text: ");
+  out.append("'").append(this->text.c_str(), this->text.size()).append("'");
+  out.append("\n");
+  out.append("  preannounce_media_id: ");
+  out.append("'").append(this->preannounce_media_id.c_str(), this->preannounce_media_id.size()).append("'");
+  out.append("\n");
   dump_field(out, "start_conversation", this->start_conversation);
 }
 void VoiceAssistantAnnounceFinished::dump_to(std::string &out) const { dump_field(out, "success", this->success); }
@@ -1897,15 +2019,25 @@ void VoiceAssistantWakeWord::dump_to(std::string &out) const {
 }
 void VoiceAssistantExternalWakeWord::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantExternalWakeWord");
-  dump_field(out, "id", this->id);
-  dump_field(out, "wake_word", this->wake_word);
+  out.append("  id: ");
+  out.append("'").append(this->id.c_str(), this->id.size()).append("'");
+  out.append("\n");
+  out.append("  wake_word: ");
+  out.append("'").append(this->wake_word.c_str(), this->wake_word.size()).append("'");
+  out.append("\n");
   for (const auto &it : this->trained_languages) {
     dump_field(out, "trained_languages", it, 4);
   }
-  dump_field(out, "model_type", this->model_type);
+  out.append("  model_type: ");
+  out.append("'").append(this->model_type.c_str(), this->model_type.size()).append("'");
+  out.append("\n");
   dump_field(out, "model_size", this->model_size);
-  dump_field(out, "model_hash", this->model_hash);
-  dump_field(out, "url", this->url);
+  out.append("  model_hash: ");
+  out.append("'").append(this->model_hash.c_str(), this->model_hash.size()).append("'");
+  out.append("\n");
+  out.append("  url: ");
+  out.append("'").append(this->url.c_str(), this->url.size()).append("'");
+  out.append("\n");
 }
 void VoiceAssistantConfigurationRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantConfigurationRequest");
@@ -1964,7 +2096,9 @@ void AlarmControlPanelCommandRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "AlarmControlPanelCommandRequest");
   dump_field(out, "key", this->key);
   dump_field(out, "command", static_cast<enums::AlarmControlPanelStateCommand>(this->command));
-  dump_field(out, "code", this->code);
+  out.append("  code: ");
+  out.append("'").append(this->code.c_str(), this->code.size()).append("'");
+  out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
 #endif
@@ -2001,7 +2135,9 @@ void TextStateResponse::dump_to(std::string &out) const {
 void TextCommandRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "TextCommandRequest");
   dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
+  out.append("  state: ");
+  out.append("'").append(this->state.c_str(), this->state.size()).append("'");
+  out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
 #endif

esphome/components/api/api_pb2_includes.h

@@ -10,6 +10,10 @@
 #include "esphome/components/climate/climate_traits.h"
 #endif
 
+#ifdef USE_WATER_HEATER
+#include "esphome/components/water_heater/water_heater.h"
+#endif
+
 #ifdef USE_LIGHT
 #include "esphome/components/light/light_traits.h"
 #endif

esphome/components/api/api_pb2_service.cpp

@@ -621,6 +621,17 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_homeassistant_action_response(msg);
       break;
     }
+#endif
+#ifdef USE_WATER_HEATER
+    case WaterHeaterCommandRequest::MESSAGE_TYPE: {
+      WaterHeaterCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_water_heater_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_water_heater_command_request(msg);
+      break;
+    }
 #endif
     default:
       break;

esphome/components/api/api_pb2_service.h

@@ -91,6 +91,10 @@ class APIServerConnectionBase : public ProtoService {
   virtual void on_climate_command_request(const ClimateCommandRequest &value){};
 #endif
 
+#ifdef USE_WATER_HEATER
+  virtual void on_water_heater_command_request(const WaterHeaterCommandRequest &value){};
+#endif
+
 #ifdef USE_NUMBER
   virtual void on_number_command_request(const NumberCommandRequest &value){};
 #endif

esphome/components/api/api_server.cpp

@@ -125,15 +125,18 @@ void APIServer::loop() {
       if (!sock)
         break;
 
+      char peername[socket::PEERNAME_MAX_LEN];
+      sock->getpeername_to(peername);
+
       // Check if we're at the connection limit
       if (this->clients_.size() >= this->max_connections_) {
-        ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, sock->getpeername().c_str());
+        ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
         // Immediately close - socket destructor will handle cleanup
         sock.reset();
         continue;
       }
 
-      ESP_LOGD(TAG, "Accept %s", sock->getpeername().c_str());
+      ESP_LOGD(TAG, "Accept %s", peername);
 
       auto *conn = new APIConnection(std::move(sock), this);
       this->clients_.emplace_back(conn);
@@ -166,8 +169,7 @@ void APIServer::loop() {
     // Network is down - disconnect all clients
     for (auto &client : this->clients_) {
       client->on_fatal_error();
-      ESP_LOGW(TAG, "%s (%s): Network down; disconnect", client->client_info_.name.c_str(),
-               client->client_info_.peername.c_str());
+      client->log_client_(ESPHOME_LOG_LEVEL_WARN, LOG_STR("Network down; disconnect"));
     }
     // Continue to process and clean up the clients below
   }
@@ -185,12 +187,14 @@ void APIServer::loop() {
 
     // Rare case: handle disconnection
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    this->client_disconnected_trigger_->trigger(client->client_info_.name, client->client_info_.peername);
+    char peername_buf[socket::PEERNAME_MAX_LEN];
+    client->get_peername_to(peername_buf);
+    this->client_disconnected_trigger_->trigger(std::string(client->get_name()), std::string(peername_buf));
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
     this->unregister_active_action_calls_for_connection(client.get());
 #endif
-    ESP_LOGV(TAG, "Remove connection %s", client->client_info_.name.c_str());
+    ESP_LOGV(TAG, "Remove connection %s", client->get_name());
 
     // Swap with the last element and pop (avoids expensive vector shifts)
     if (client_index < this->clients_.size() - 1) {
@@ -335,6 +339,10 @@ API_DISPATCH_UPDATE(valve::Valve, valve)
 API_DISPATCH_UPDATE(media_player::MediaPlayer, media_player)
 #endif
 
+#ifdef USE_WATER_HEATER
+API_DISPATCH_UPDATE(water_heater::WaterHeater, water_heater)
+#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()
@@ -390,7 +398,7 @@ void APIServer::register_action_response_callback(uint32_t call_id, ActionRespon
   this->action_response_callbacks_.push_back({call_id, std::move(callback)});
 }
 
-void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &error_message) {
+void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef error_message) {
   for (auto it = this->action_response_callbacks_.begin(); it != this->action_response_callbacks_.end(); ++it) {
     if (it->call_id == call_id) {
       auto callback = std::move(it->callback);
@@ -402,7 +410,7 @@ void APIServer::handle_action_response(uint32_t call_id, bool success, const std
   }
 }
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &error_message,
+void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef error_message,
                                        const uint8_t *response_data, size_t response_data_len) {
   for (auto it = this->action_response_callbacks_.begin(); it != this->action_response_callbacks_.end(); ++it) {
     if (it->call_id == call_id) {
@@ -420,8 +428,8 @@ void APIServer::handle_action_response(uint32_t call_id, bool success, const std
 
 #ifdef USE_API_HOMEASSISTANT_STATES
 // Helper to add subscription (reduces duplication)
-void APIServer::add_state_subscription_(const char *entity_id, const char *attribute,
-                                        std::function<void(std::string)> f, bool once) {
+void APIServer::add_state_subscription_(const char *entity_id, const char *attribute, std::function<void(StringRef)> f,
+                                        bool once) {
   this->state_subs_.push_back(HomeAssistantStateSubscription{
       .entity_id = entity_id, .attribute = attribute, .callback = std::move(f), .once = once,
       // entity_id_dynamic_storage and attribute_dynamic_storage remain nullptr (no heap allocation)
@@ -430,7 +438,7 @@ void APIServer::add_state_subscription_(const char *entity_id, const char *attri
 
 // Helper to add subscription with heap-allocated strings (reduces duplication)
 void APIServer::add_state_subscription_(std::string entity_id, optional<std::string> attribute,
-                                        std::function<void(std::string)> f, bool once) {
+                                        std::function<void(StringRef)> f, bool once) {
   HomeAssistantStateSubscription sub;
   // Allocate heap storage for the strings
   sub.entity_id_dynamic_storage = std::make_unique<std::string>(std::move(entity_id));
@@ -450,23 +458,43 @@ void APIServer::add_state_subscription_(std::string entity_id, optional<std::str
 
 // New const char* overload (for internal components - zero allocation)
 void APIServer::subscribe_home_assistant_state(const char *entity_id, const char *attribute,
-                                               std::function<void(std::string)> f) {
+                                               std::function<void(StringRef)> f) {
   this->add_state_subscription_(entity_id, attribute, std::move(f), false);
 }
 
 void APIServer::get_home_assistant_state(const char *entity_id, const char *attribute,
-                                         std::function<void(std::string)> f) {
+                                         std::function<void(StringRef)> f) {
   this->add_state_subscription_(entity_id, attribute, std::move(f), true);
 }
 
-// Existing std::string overload (for custom_api_device.h - heap allocation)
+// std::string overload with StringRef callback (zero-allocation callback)
 void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                               std::function<void(std::string)> f) {
+                                               std::function<void(StringRef)> f) {
   this->add_state_subscription_(std::move(entity_id), std::move(attribute), std::move(f), false);
 }
 
 void APIServer::get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                         std::function<void(std::string)> f) {
+                                         std::function<void(StringRef)> f) {
+  this->add_state_subscription_(std::move(entity_id), std::move(attribute), std::move(f), true);
+}
+
+// Legacy helper: wraps std::string callback and delegates to StringRef version
+void APIServer::add_state_subscription_(std::string entity_id, optional<std::string> attribute,
+                                        std::function<void(const std::string &)> f, bool once) {
+  // Wrap callback to convert StringRef -> std::string, then delegate
+  this->add_state_subscription_(std::move(entity_id), std::move(attribute),
+                                std::function<void(StringRef)>([f = std::move(f)](StringRef state) { f(state.str()); }),
+                                once);
+}
+
+// Legacy std::string overload (for custom_api_device.h - converts StringRef to std::string)
+void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
+                                               std::function<void(const std::string &)> f) {
+  this->add_state_subscription_(std::move(entity_id), std::move(attribute), std::move(f), false);
+}
+
+void APIServer::get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
+                                         std::function<void(const std::string &)> f) {
   this->add_state_subscription_(std::move(entity_id), std::move(attribute), std::move(f), true);
 }
 
@@ -674,7 +702,7 @@ void APIServer::unregister_active_action_calls_for_connection(APIConnection *con
   }
 }
 
-void APIServer::send_action_response(uint32_t action_call_id, bool success, const std::string &error_message) {
+void APIServer::send_action_response(uint32_t action_call_id, bool success, StringRef error_message) {
   for (auto &call : this->active_action_calls_) {
     if (call.action_call_id == action_call_id) {
       call.connection->send_execute_service_response(call.client_call_id, success, error_message);
@@ -684,7 +712,7 @@ void APIServer::send_action_response(uint32_t action_call_id, bool success, cons
   ESP_LOGW(TAG, "Cannot send response: no active call found for action_call_id %u", action_call_id);
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-void APIServer::send_action_response(uint32_t action_call_id, bool success, const std::string &error_message,
+void APIServer::send_action_response(uint32_t action_call_id, bool success, StringRef error_message,
                                      const uint8_t *response_data, size_t response_data_len) {
   for (auto &call : this->active_action_calls_) {
     if (call.action_call_id == action_call_id) {

esphome/components/api/api_server.h

@@ -10,6 +10,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/controller.h"
 #include "esphome/core/log.h"
+#include "esphome/core/string_ref.h"
 #include "list_entities.h"
 #include "subscribe_state.h"
 #ifdef USE_LOGGER
@@ -133,6 +134,9 @@ class APIServer : public Component,
 #ifdef USE_MEDIA_PLAYER
   void on_media_player_update(media_player::MediaPlayer *obj) override;
 #endif
+#ifdef USE_WATER_HEATER
+  void on_water_heater_update(water_heater::WaterHeater *obj) override;
+#endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
   void send_homeassistant_action(const HomeassistantActionRequest &call);
 
@@ -140,10 +144,10 @@ class APIServer : public Component,
   // Action response handling
   using ActionResponseCallback = std::function<void(const class ActionResponse &)>;
   void register_action_response_callback(uint32_t call_id, ActionResponseCallback callback);
-  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message);
+  void handle_action_response(uint32_t call_id, bool success, StringRef error_message);
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message,
-                              const uint8_t *response_data, size_t response_data_len);
+  void handle_action_response(uint32_t call_id, bool success, StringRef error_message, const uint8_t *response_data,
+                              size_t response_data_len);
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #endif  // USE_API_HOMEASSISTANT_SERVICES
@@ -162,9 +166,9 @@ class APIServer : public Component,
   void unregister_active_action_call(uint32_t action_call_id);
   void unregister_active_action_calls_for_connection(APIConnection *conn);
   // Send response for a specific action call (uses action_call_id, sends client_call_id in response)
-  void send_action_response(uint32_t action_call_id, bool success, const std::string &error_message);
+  void send_action_response(uint32_t action_call_id, bool success, StringRef error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  void send_action_response(uint32_t action_call_id, bool success, const std::string &error_message,
+  void send_action_response(uint32_t action_call_id, bool success, StringRef error_message,
                             const uint8_t *response_data, size_t response_data_len);
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -192,7 +196,7 @@ class APIServer : public Component,
   struct HomeAssistantStateSubscription {
     const char *entity_id;  // Pointer to flash (internal) or heap (external)
     const char *attribute;  // Pointer to flash or nullptr (nullptr means no attribute)
-    std::function<void(std::string)> callback;
+    std::function<void(StringRef)> callback;
     bool once;
 
     // Dynamic storage for external components using std::string API (custom_api_device.h)
@@ -202,14 +206,20 @@ class APIServer : public Component,
   };
 
   // New const char* overload (for internal components - zero allocation)
-  void subscribe_home_assistant_state(const char *entity_id, const char *attribute, std::function<void(std::string)> f);
-  void get_home_assistant_state(const char *entity_id, const char *attribute, std::function<void(std::string)> f);
+  void subscribe_home_assistant_state(const char *entity_id, const char *attribute, std::function<void(StringRef)> f);
+  void get_home_assistant_state(const char *entity_id, const char *attribute, std::function<void(StringRef)> f);
 
-  // Existing std::string overload (for custom_api_device.h - heap allocation)
+  // std::string overload with StringRef callback (for custom_api_device.h with zero-allocation callback)
   void subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                      std::function<void(std::string)> f);
+                                      std::function<void(StringRef)> f);
   void get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                std::function<void(std::string)> f);
+                                std::function<void(StringRef)> f);
+
+  // Legacy std::string overload (for custom_api_device.h - converts StringRef to std::string for callback)
+  void subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
+                                      std::function<void(const std::string &)> f);
+  void get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
+                                std::function<void(const std::string &)> f);
 
   const std::vector<HomeAssistantStateSubscription> &get_state_subs() const;
 #endif
@@ -233,10 +243,13 @@ class APIServer : public Component,
 #endif  // USE_API_NOISE
 #ifdef USE_API_HOMEASSISTANT_STATES
   // Helper methods to reduce code duplication
-  void add_state_subscription_(const char *entity_id, const char *attribute, std::function<void(std::string)> f,
+  void add_state_subscription_(const char *entity_id, const char *attribute, std::function<void(StringRef)> f,
                                bool once);
+  void add_state_subscription_(std::string entity_id, optional<std::string> attribute, std::function<void(StringRef)> f,
+                               bool once);
+  // Legacy helper: wraps std::string callback and delegates to StringRef version
   void add_state_subscription_(std::string entity_id, optional<std::string> attribute,
-                               std::function<void(std::string)> f, bool once);
+                               std::function<void(const std::string &)> f, bool once);
 #endif  // USE_API_HOMEASSISTANT_STATES
   // Pointers and pointer-like types first (4 bytes each)
   std::unique_ptr<socket::Socket> socket_ = nullptr;

esphome/components/api/custom_api_device.h

@@ -122,21 +122,36 @@ class CustomAPIDevice {
    *   subscribe_homeassistant_state(&CustomNativeAPI::on_state_changed, "climate.kitchen", "current_temperature");
    * }
    *
-   * void on_state_changed(std::string state) {
-   *   // State of sensor.weather_forecast is `state`
+   * void on_state_changed(StringRef state) {
+   *   // State of climate.kitchen current_temperature is `state`
+   *   // Use state.c_str() for C string, state.str() for std::string
    * }
    * ```
    *
    * @tparam T The class type creating the service, automatically deduced from the function pointer.
-   * @param callback The member function to call when the entity state changes.
+   * @param callback The member function to call when the entity state changes (zero-allocation).
    * @param entity_id The entity_id to track.
    * @param attribute The entity state attribute to track.
    */
   template<typename T>
+  void subscribe_homeassistant_state(void (T::*callback)(StringRef), const std::string &entity_id,
+                                     const std::string &attribute = "") {
+    auto f = std::bind(callback, (T *) this, std::placeholders::_1);
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), std::move(f));
+  }
+
+  /** Subscribe to the state (or attribute state) of an entity from Home Assistant (legacy std::string version).
+   *
+   * @deprecated Use the StringRef overload for zero-allocation callbacks. Will be removed in 2027.1.0.
+   */
+  template<typename T>
+  ESPDEPRECATED("Use void callback(StringRef) instead. Will be removed in 2027.1.0.", "2026.1.0")
   void subscribe_homeassistant_state(void (T::*callback)(std::string), const std::string &entity_id,
                                      const std::string &attribute = "") {
     auto f = std::bind(callback, (T *) this, std::placeholders::_1);
-    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
+    // Explicit type to disambiguate overload resolution
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute),
+                                                      std::function<void(const std::string &)>(f));
   }
 
   /** Subscribe to the state (or attribute state) of an entity from Home Assistant.
@@ -148,23 +163,45 @@ class CustomAPIDevice {
    *   subscribe_homeassistant_state(&CustomNativeAPI::on_state_changed, "sensor.weather_forecast");
    * }
    *
-   * void on_state_changed(std::string entity_id, std::string state) {
+   * void on_state_changed(const std::string &entity_id, StringRef state) {
    *   // State of `entity_id` is `state`
    * }
    * ```
    *
    * @tparam T The class type creating the service, automatically deduced from the function pointer.
-   * @param callback The member function to call when the entity state changes.
+   * @param callback The member function to call when the entity state changes (zero-allocation for state).
    * @param entity_id The entity_id to track.
    * @param attribute The entity state attribute to track.
    */
   template<typename T>
+  void subscribe_homeassistant_state(void (T::*callback)(const std::string &, StringRef), const std::string &entity_id,
+                                     const std::string &attribute = "") {
+    auto f = std::bind(callback, (T *) this, entity_id, std::placeholders::_1);
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), std::move(f));
+  }
+
+  /** Subscribe to the state (or attribute state) of an entity from Home Assistant (legacy std::string version).
+   *
+   * @deprecated Use the StringRef overload for zero-allocation callbacks. Will be removed in 2027.1.0.
+   */
+  template<typename T>
+  ESPDEPRECATED("Use void callback(const std::string &, StringRef) instead. Will be removed in 2027.1.0.", "2026.1.0")
   void subscribe_homeassistant_state(void (T::*callback)(std::string, std::string), const std::string &entity_id,
                                      const std::string &attribute = "") {
     auto f = std::bind(callback, (T *) this, entity_id, std::placeholders::_1);
-    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
+    // Explicit type to disambiguate overload resolution
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute),
+                                                      std::function<void(const std::string &)>(f));
   }
 #else
+  template<typename T>
+  void subscribe_homeassistant_state(void (T::*callback)(StringRef), const std::string &entity_id,
+                                     const std::string &attribute = "") {
+    static_assert(sizeof(T) == 0,
+                  "subscribe_homeassistant_state() requires 'homeassistant_states: true' in the 'api:' section "
+                  "of your YAML configuration");
+  }
+
   template<typename T>
   void subscribe_homeassistant_state(void (T::*callback)(std::string), const std::string &entity_id,
                                      const std::string &attribute = "") {
@@ -173,6 +210,14 @@ class CustomAPIDevice {
                   "of your YAML configuration");
   }
 
+  template<typename T>
+  void subscribe_homeassistant_state(void (T::*callback)(const std::string &, StringRef), const std::string &entity_id,
+                                     const std::string &attribute = "") {
+    static_assert(sizeof(T) == 0,
+                  "subscribe_homeassistant_state() requires 'homeassistant_states: true' in the 'api:' section "
+                  "of your YAML configuration");
+  }
+
   template<typename T>
   void subscribe_homeassistant_state(void (T::*callback)(std::string, std::string), const std::string &entity_id,
                                      const std::string &attribute = "") {

esphome/components/api/homeassistant_service.h

@@ -67,10 +67,10 @@ template<typename... Ts> class TemplatableKeyValuePair {
 // the callback is invoked synchronously while the message is on the stack).
 class ActionResponse {
  public:
-  ActionResponse(bool success, const std::string &error_message) : success_(success), error_message_(error_message) {}
+  ActionResponse(bool success, StringRef error_message) : success_(success), error_message_(error_message) {}
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  ActionResponse(bool success, const std::string &error_message, const uint8_t *data, size_t data_len)
+  ActionResponse(bool success, StringRef error_message, const uint8_t *data, size_t data_len)
       : success_(success), error_message_(error_message) {
     if (data == nullptr || data_len == 0)
       return;

esphome/components/api/list_entities.cpp

@@ -73,6 +73,9 @@ LIST_ENTITIES_HANDLER(media_player, media_player::MediaPlayer, ListEntitiesMedia
 LIST_ENTITIES_HANDLER(alarm_control_panel, alarm_control_panel::AlarmControlPanel,
                       ListEntitiesAlarmControlPanelResponse)
 #endif
+#ifdef USE_WATER_HEATER
+LIST_ENTITIES_HANDLER(water_heater, water_heater::WaterHeater, ListEntitiesWaterHeaterResponse)
+#endif
 #ifdef USE_EVENT
 LIST_ENTITIES_HANDLER(event, event::Event, ListEntitiesEventResponse)
 #endif

esphome/components/api/list_entities.h

@@ -82,6 +82,9 @@ class ListEntitiesIterator : public ComponentIterator {
 #ifdef USE_ALARM_CONTROL_PANEL
   bool on_alarm_control_panel(alarm_control_panel::AlarmControlPanel *entity) override;
 #endif
+#ifdef USE_WATER_HEATER
+  bool on_water_heater(water_heater::WaterHeater *entity) override;
+#endif
 #ifdef USE_EVENT
   bool on_event(event::Event *entity) override;
 #endif

esphome/components/api/proto.h

@@ -334,7 +334,7 @@ class ProtoWriteBuffer {
   void encode_sint64(uint32_t field_id, int64_t value, bool force = false) {
     this->encode_uint64(field_id, encode_zigzag64(value), force);
   }
-  void encode_message(uint32_t field_id, const ProtoMessage &value, bool force = false);
+  void encode_message(uint32_t field_id, const ProtoMessage &value);
   std::vector<uint8_t> *get_buffer() const { return buffer_; }
 
  protected:
@@ -795,7 +795,7 @@ class ProtoSize {
 };
 
 // Implementation of encode_message - must be after ProtoMessage is defined
-inline void ProtoWriteBuffer::encode_message(uint32_t field_id, const ProtoMessage &value, bool force) {
+inline void ProtoWriteBuffer::encode_message(uint32_t field_id, const ProtoMessage &value) {
   this->encode_field_raw(field_id, 2);  // type 2: Length-delimited message
 
   // Calculate the message size first

esphome/components/api/subscribe_state.cpp

@@ -60,6 +60,9 @@ INITIAL_STATE_HANDLER(media_player, media_player::MediaPlayer)
 #ifdef USE_ALARM_CONTROL_PANEL
 INITIAL_STATE_HANDLER(alarm_control_panel, alarm_control_panel::AlarmControlPanel)
 #endif
+#ifdef USE_WATER_HEATER
+INITIAL_STATE_HANDLER(water_heater, water_heater::WaterHeater)
+#endif
 #ifdef USE_UPDATE
 INITIAL_STATE_HANDLER(update, update::UpdateEntity)
 #endif

esphome/components/api/subscribe_state.h

@@ -76,6 +76,9 @@ class InitialStateIterator : public ComponentIterator {
 #ifdef USE_ALARM_CONTROL_PANEL
   bool on_alarm_control_panel(alarm_control_panel::AlarmControlPanel *entity) override;
 #endif
+#ifdef USE_WATER_HEATER
+  bool on_water_heater(water_heater::WaterHeater *entity) override;
+#endif
 #ifdef USE_EVENT
   bool on_event(event::Event *event) override { return true; };
 #endif

esphome/components/aqi/__init__.py

@@ -0,0 +1,14 @@
+import esphome.codegen as cg
+
+CODEOWNERS = ["@jasstrong", "@ximex", "@freekode"]
+
+aqi_ns = cg.esphome_ns.namespace("aqi")
+AQICalculatorType = aqi_ns.enum("AQICalculatorType")
+
+CONF_AQI = "aqi"
+CONF_CALCULATION_TYPE = "calculation_type"
+
+AQI_CALCULATION_TYPE = {
+    "CAQI": AQICalculatorType.CAQI_TYPE,
+    "AQI": AQICalculatorType.AQI_TYPE,
+}

esphome/components/aqi/abstract_aqi_calculator.h

@@ -2,13 +2,11 @@
 
 #include <cstdint>
 
-namespace esphome {
-namespace hm3301 {
+namespace esphome::aqi {
 
 class AbstractAQICalculator {
  public:
   virtual uint16_t get_aqi(uint16_t pm2_5_value, uint16_t pm10_0_value) = 0;
 };
 
-}  // namespace hm3301
-}  // namespace esphome
+}  // namespace esphome::aqi

esphome/components/aqi/aqi_calculator.h

@@ -1,10 +1,11 @@
 #pragma once
+
 #include <climits>
 #include "abstract_aqi_calculator.h"
+
 // https://document.airnow.gov/technical-assistance-document-for-the-reporting-of-daily-air-quailty.pdf
 
-namespace esphome {
-namespace hm3301 {
+namespace esphome::aqi {
 
 class AQICalculator : public AbstractAQICalculator {
  public:
@@ -28,6 +29,9 @@ class AQICalculator : public AbstractAQICalculator {
 
   int calculate_index_(uint16_t value, int array[AMOUNT_OF_LEVELS][2]) {
     int grid_index = get_grid_index_(value, array);
+    if (grid_index == -1) {
+      return -1;
+    }
     int aqi_lo = index_grid_[grid_index][0];
     int aqi_hi = index_grid_[grid_index][1];
     int conc_lo = array[grid_index][0];
@@ -46,5 +50,4 @@ class AQICalculator : public AbstractAQICalculator {
   }
 };
 
-}  // namespace hm3301
-}  // namespace esphome
+}  // namespace esphome::aqi

esphome/components/aqi/aqi_calculator_factory.h

@@ -3,8 +3,7 @@
 #include "caqi_calculator.h"
 #include "aqi_calculator.h"
 
-namespace esphome {
-namespace hm3301 {
+namespace esphome::aqi {
 
 enum AQICalculatorType { CAQI_TYPE = 0, AQI_TYPE = 1 };
 
@@ -12,18 +11,17 @@ class AQICalculatorFactory {
  public:
   AbstractAQICalculator *get_calculator(AQICalculatorType type) {
     if (type == 0) {
-      return caqi_calculator_;
+      return &this->caqi_calculator_;
     } else if (type == 1) {
-      return aqi_calculator_;
+      return &this->aqi_calculator_;
     }
 
     return nullptr;
   }
 
  protected:
-  CAQICalculator *caqi_calculator_ = new CAQICalculator();
-  AQICalculator *aqi_calculator_ = new AQICalculator();
+  CAQICalculator caqi_calculator_;
+  AQICalculator aqi_calculator_;
 };
 
-}  // namespace hm3301
-}  // namespace esphome
+}  // namespace esphome::aqi

esphome/components/aqi/caqi_calculator.h

@@ -3,8 +3,7 @@
 #include "esphome/core/log.h"
 #include "abstract_aqi_calculator.h"
 
-namespace esphome {
-namespace hm3301 {
+namespace esphome::aqi {
 
 class CAQICalculator : public AbstractAQICalculator {
  public:
@@ -48,5 +47,4 @@ class CAQICalculator : public AbstractAQICalculator {
   }
 };
 
-}  // namespace hm3301
-}  // namespace esphome
+}  // namespace esphome::aqi

esphome/components/audio/audio_reader.cpp

@@ -1,6 +1,6 @@
 #include "audio_reader.h"
 
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"

esphome/components/audio/audio_reader.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 
 #include "audio.h"
 #include "audio_transfer_buffer.h"

esphome/components/bedjet/climate/__init__.py

@@ -1,12 +1,7 @@
 import esphome.codegen as cg
-from esphome.components import ble_client, climate
+from esphome.components import climate
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_HEAT_MODE,
-    CONF_RECEIVE_TIMEOUT,
-    CONF_TEMPERATURE_SOURCE,
-    CONF_TIME_ID,
-)
+from esphome.const import CONF_HEAT_MODE, CONF_TEMPERATURE_SOURCE
 
 from .. import BEDJET_CLIENT_SCHEMA, bedjet_ns, register_bedjet_child
 
@@ -38,22 +33,6 @@ CONFIG_SCHEMA = (
         }
     )
     .extend(cv.polling_component_schema("60s"))
-    .extend(
-        # TODO: remove compat layer.
-        {
-            cv.Optional(ble_client.CONF_BLE_CLIENT_ID): cv.invalid(
-                "The 'ble_client_id' option has been removed. Please migrate "
-                "to the new `bedjet_id` option in the `bedjet` component.\n"
-                "See https://esphome.io/components/climate/bedjet/"
-            ),
-            cv.Optional(CONF_TIME_ID): cv.invalid(
-                "The 'time_id' option has been moved to the `bedjet` component."
-            ),
-            cv.Optional(CONF_RECEIVE_TIMEOUT): cv.invalid(
-                "The 'receive_timeout' option has been moved to the `bedjet` component."
-            ),
-        }
-    )
     .extend(BEDJET_CLIENT_SCHEMA)
 )
 

esphome/components/bh1750/sensor.py

@@ -20,16 +20,6 @@ CONFIG_SCHEMA = (
         device_class=DEVICE_CLASS_ILLUMINANCE,
         state_class=STATE_CLASS_MEASUREMENT,
     )
-    .extend(
-        {
-            cv.Optional("resolution"): cv.invalid(
-                "The 'resolution' option has been removed. The optimal value is now dynamically calculated."
-            ),
-            cv.Optional("measurement_duration"): cv.invalid(
-                "The 'measurement_duration' option has been removed. The optimal value is now dynamically calculated."
-            ),
-        }
-    )
     .extend(cv.polling_component_schema("60s"))
     .extend(i2c.i2c_device_schema(0x23))
 )

esphome/components/ble_client/automation.h

@@ -7,8 +7,12 @@
 
 #include "esphome/core/automation.h"
 #include "esphome/components/ble_client/ble_client.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
+// Maximum bytes to log in hex format for BLE writes (many logging buffers are 256 chars)
+static constexpr size_t BLE_WRITE_MAX_LOG_BYTES = 64;
+
 namespace esphome::ble_client {
 
 // placeholder class for static TAG .
@@ -151,7 +155,10 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
       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());
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
+    char hex_buf[format_hex_pretty_size(BLE_WRITE_MAX_LOG_BYTES)];
+    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
+#endif
     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);

esphome/components/bme68x_bsec2/sensor.py

@@ -50,6 +50,7 @@ TYPES = [
 
 CONFIG_SCHEMA = cv.Schema(
     {
+        cv.GenerateID(): cv.declare_id(cg.Component),
         cv.GenerateID(CONF_BME68X_BSEC2_ID): cv.use_id(BME68xBSEC2Component),
         cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
             unit_of_measurement=UNIT_CELSIUS,

esphome/components/bme68x_bsec2_i2c/__init__.py

@@ -11,6 +11,7 @@ CODEOWNERS = ["@neffs", "@kbx81"]
 
 AUTO_LOAD = ["bme68x_bsec2"]
 DEPENDENCIES = ["i2c"]
+MULTI_CONF = True
 
 bme68x_bsec2_i2c_ns = cg.esphome_ns.namespace("bme68x_bsec2_i2c")
 BME68xBSEC2I2CComponent = bme68x_bsec2_i2c_ns.class_(

esphome/components/button/button.h

@@ -41,7 +41,7 @@ class Button : public EntityBase, public EntityBase_DeviceClass {
    */
   virtual void press_action() = 0;
 
-  CallbackManager<void()> press_callback_{};
+  LazyCallbackManager<void()> press_callback_{};
 };
 
 }  // namespace esphome::button

esphome/components/captive_portal/__init__.py

@@ -25,7 +25,7 @@ _LOGGER = logging.getLogger(__name__)
 
 def AUTO_LOAD() -> list[str]:
     auto_load = ["web_server_base", "ota.web_server"]
-    if CORE.using_esp_idf:
+    if CORE.is_esp32:
         auto_load.append("socket")
     return auto_load
 
@@ -97,10 +97,6 @@ async def to_code(config):
     cg.add_define("USE_CAPTIVE_PORTAL")
 
     if CORE.using_arduino:
-        if CORE.is_esp32:
-            cg.add_library("ESP32 Async UDP", None)
-            cg.add_library("DNSServer", None)
-            cg.add_library("WiFi", None)
         if CORE.is_esp8266:
             cg.add_library("DNSServer", None)
         if CORE.is_libretiny:
@@ -110,6 +106,9 @@ async def to_code(config):
 # Only compile the ESP-IDF DNS server when using ESP-IDF framework
 FILTER_SOURCE_FILES = filter_source_files_from_platform(
     {
-        "dns_server_esp32_idf.cpp": {PlatformFramework.ESP32_IDF},
+        "dns_server_esp32_idf.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
     }
 )

esphome/components/captive_portal/captive_portal.cpp

@@ -65,22 +65,15 @@ void CaptivePortal::start() {
   this->base_->init();
   if (!this->initialized_) {
     this->base_->add_handler(this);
-#ifdef USE_ESP32
-    // Enable LRU socket purging to handle captive portal detection probe bursts
-    // OS captive portal detection makes many simultaneous HTTP requests which can
-    // exhaust sockets. LRU purging automatically closes oldest idle connections.
-    this->base_->get_server()->set_lru_purge_enable(true);
-#endif
   }
 
   network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
 
-#ifdef USE_ESP_IDF
+#if defined(USE_ESP32)
   // Create DNS server instance for ESP-IDF
   this->dns_server_ = make_unique<DNSServer>();
   this->dns_server_->start(ip);
-#endif
-#ifdef USE_ARDUINO
+#elif defined(USE_ARDUINO)
   this->dns_server_ = make_unique<DNSServer>();
   this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
   this->dns_server_->start(53, ESPHOME_F("*"), ip);

esphome/components/captive_portal/captive_portal.h

@@ -2,11 +2,10 @@
 #include "esphome/core/defines.h"
 #ifdef USE_CAPTIVE_PORTAL
 #include <memory>
-#ifdef USE_ARDUINO
-#include <DNSServer.h>
-#endif
-#ifdef USE_ESP_IDF
+#if defined(USE_ESP32)
 #include "dns_server_esp32_idf.h"
+#elif defined(USE_ARDUINO)
+#include <DNSServer.h>
 #endif
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
@@ -23,15 +22,14 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   void setup() override;
   void dump_config() override;
   void loop() override {
-#ifdef USE_ARDUINO
-    if (this->dns_server_ != nullptr) {
-      this->dns_server_->processNextRequest();
-    }
-#endif
-#ifdef USE_ESP_IDF
+#if defined(USE_ESP32)
     if (this->dns_server_ != nullptr) {
       this->dns_server_->process_next_request();
     }
+#elif defined(USE_ARDUINO)
+    if (this->dns_server_ != nullptr) {
+      this->dns_server_->processNextRequest();
+    }
 #endif
   }
   float get_setup_priority() const override;
@@ -40,10 +38,6 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   void end() {
     this->active_ = false;
     this->disable_loop();  // Stop processing DNS requests
-#ifdef USE_ESP32
-    // Disable LRU socket purging now that captive portal is done
-    this->base_->get_server()->set_lru_purge_enable(false);
-#endif
     this->base_->deinit();
     if (this->dns_server_ != nullptr) {
       this->dns_server_->stop();
@@ -68,7 +62,7 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   web_server_base::WebServerBase *base_;
   bool initialized_{false};
   bool active_{false};
-#if defined(USE_ARDUINO) || defined(USE_ESP_IDF)
+#if defined(USE_ARDUINO) || defined(USE_ESP32)
   std::unique_ptr<DNSServer> dns_server_{nullptr};
 #endif
 };

esphome/components/captive_portal/dns_server_esp32_idf.cpp

@@ -1,5 +1,5 @@
 #include "dns_server_esp32_idf.h"
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
@@ -47,7 +47,10 @@ struct DNSAnswer {
 
 void DNSServer::start(const network::IPAddress &ip) {
   this->server_ip_ = ip;
-  ESP_LOGV(TAG, "Starting DNS server on %s", ip.str().c_str());
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
+  ESP_LOGV(TAG, "Starting DNS server on %s", ip.str_to(ip_buf));
+#endif
 
   // Create loop-monitored UDP socket
   this->socket_ = socket::socket_ip_loop_monitored(SOCK_DGRAM, IPPROTO_UDP);
@@ -202,4 +205,4 @@ void DNSServer::process_next_request() {
 
 }  // namespace esphome::captive_portal
 
-#endif  // USE_ESP_IDF
+#endif  // USE_ESP32

esphome/components/captive_portal/dns_server_esp32_idf.h

@@ -1,5 +1,5 @@
 #pragma once
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 
 #include <memory>
 #include "esphome/core/helpers.h"
@@ -24,4 +24,4 @@ class DNSServer {
 
 }  // namespace esphome::captive_portal
 
-#endif  // USE_ESP_IDF
+#endif  // USE_ESP32

esphome/components/cc1101/__init__.py

@@ -1,9 +1,17 @@
-from esphome import automation
+from esphome import automation, pins
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
 from esphome.components import spi
+from esphome.components.const import CONF_CRC_ENABLE, CONF_ON_PACKET
 import esphome.config_validation as cv
-from esphome.const import CONF_CHANNEL, CONF_FREQUENCY, CONF_ID, CONF_WAIT_TIME
+from esphome.const import (
+    CONF_CHANNEL,
+    CONF_DATA,
+    CONF_FREQUENCY,
+    CONF_ID,
+    CONF_WAIT_TIME,
+)
+from esphome.core import ID
 
 CODEOWNERS = ["@lygris", "@gabest11"]
 DEPENDENCIES = ["spi"]
@@ -29,7 +37,6 @@ CONF_MANCHESTER = "manchester"
 CONF_NUM_PREAMBLE = "num_preamble"
 CONF_SYNC1 = "sync1"
 CONF_SYNC0 = "sync0"
-CONF_PKTLEN = "pktlen"
 CONF_MAGN_TARGET = "magn_target"
 CONF_MAX_LNA_GAIN = "max_lna_gain"
 CONF_MAX_DVGA_GAIN = "max_dvga_gain"
@@ -41,6 +48,12 @@ CONF_FILTER_LENGTH_ASK_OOK = "filter_length_ask_ook"
 CONF_FREEZE = "freeze"
 CONF_HYST_LEVEL = "hyst_level"
 
+# Packet mode config keys
+CONF_PACKET_MODE = "packet_mode"
+CONF_PACKET_LENGTH = "packet_length"
+CONF_WHITENING = "whitening"
+CONF_GDO0_PIN = "gdo0_pin"
+
 # Enums
 SyncMode = ns.enum("SyncMode", True)
 SYNC_MODE = {
@@ -147,45 +160,89 @@ HYST_LEVEL = {
     "High": HystLevel.HYST_LEVEL_HIGH,
 }
 
-# Config key -> Validator mapping
+# Optional settings to generate setter calls for
 CONFIG_MAP = {
-    CONF_OUTPUT_POWER: cv.float_range(min=-30.0, max=11.0),
-    CONF_RX_ATTENUATION: cv.enum(RX_ATTENUATION, upper=False),
-    CONF_DC_BLOCKING_FILTER: cv.boolean,
-    CONF_FREQUENCY: cv.All(cv.frequency, cv.float_range(min=300000000, max=928000000)),
-    CONF_IF_FREQUENCY: cv.All(cv.frequency, cv.float_range(min=25000, max=788000)),
-    CONF_FILTER_BANDWIDTH: cv.All(cv.frequency, cv.float_range(min=58000, max=812000)),
-    CONF_CHANNEL: cv.uint8_t,
-    CONF_CHANNEL_SPACING: cv.All(cv.frequency, cv.float_range(min=25000, max=405000)),
-    CONF_FSK_DEVIATION: cv.All(cv.frequency, cv.float_range(min=1500, max=381000)),
-    CONF_MSK_DEVIATION: cv.int_range(min=1, max=8),
-    CONF_SYMBOL_RATE: cv.float_range(min=600, max=500000),
-    CONF_SYNC_MODE: cv.enum(SYNC_MODE, upper=False),
-    CONF_CARRIER_SENSE_ABOVE_THRESHOLD: cv.boolean,
-    CONF_MODULATION_TYPE: cv.enum(MODULATION, upper=False),
-    CONF_MANCHESTER: cv.boolean,
-    CONF_NUM_PREAMBLE: cv.int_range(min=0, max=7),
-    CONF_SYNC1: cv.hex_uint8_t,
-    CONF_SYNC0: cv.hex_uint8_t,
-    CONF_PKTLEN: cv.uint8_t,
-    CONF_MAGN_TARGET: cv.enum(MAGN_TARGET, upper=False),
-    CONF_MAX_LNA_GAIN: cv.enum(MAX_LNA_GAIN, upper=False),
-    CONF_MAX_DVGA_GAIN: cv.enum(MAX_DVGA_GAIN, upper=False),
-    CONF_CARRIER_SENSE_ABS_THR: cv.int_range(min=-8, max=7),
-    CONF_CARRIER_SENSE_REL_THR: cv.enum(CARRIER_SENSE_REL_THR, upper=False),
-    CONF_LNA_PRIORITY: cv.boolean,
-    CONF_FILTER_LENGTH_FSK_MSK: cv.enum(FILTER_LENGTH_FSK_MSK, upper=False),
-    CONF_FILTER_LENGTH_ASK_OOK: cv.enum(FILTER_LENGTH_ASK_OOK, upper=False),
-    CONF_FREEZE: cv.enum(FREEZE, upper=False),
-    CONF_WAIT_TIME: cv.enum(WAIT_TIME, upper=False),
-    CONF_HYST_LEVEL: cv.enum(HYST_LEVEL, upper=False),
+    cv.Optional(CONF_OUTPUT_POWER, default=10): cv.float_range(min=-30.0, max=11.0),
+    cv.Optional(CONF_RX_ATTENUATION, default="0dB"): cv.enum(
+        RX_ATTENUATION, upper=False
+    ),
+    cv.Optional(CONF_DC_BLOCKING_FILTER, default=True): cv.boolean,
+    cv.Optional(CONF_FREQUENCY, default="433.92MHz"): cv.All(
+        cv.frequency, cv.float_range(min=300.0e6, max=928.0e6)
+    ),
+    cv.Optional(CONF_IF_FREQUENCY, default="153kHz"): cv.All(
+        cv.frequency, cv.float_range(min=25000, max=788000)
+    ),
+    cv.Optional(CONF_FILTER_BANDWIDTH, default="203kHz"): cv.All(
+        cv.frequency, cv.float_range(min=58000, max=812000)
+    ),
+    cv.Optional(CONF_CHANNEL, default=0): cv.uint8_t,
+    cv.Optional(CONF_CHANNEL_SPACING, default="200kHz"): cv.All(
+        cv.frequency, cv.float_range(min=25000, max=405000)
+    ),
+    cv.Optional(CONF_FSK_DEVIATION): cv.All(
+        cv.frequency, cv.float_range(min=1500, max=381000)
+    ),
+    cv.Optional(CONF_MSK_DEVIATION): cv.int_range(min=1, max=8),
+    cv.Optional(CONF_SYMBOL_RATE, default=5000): cv.float_range(min=600, max=500000),
+    cv.Optional(CONF_SYNC_MODE, default="16/16"): cv.enum(SYNC_MODE, upper=False),
+    cv.Optional(CONF_CARRIER_SENSE_ABOVE_THRESHOLD, default=False): cv.boolean,
+    cv.Optional(CONF_MODULATION_TYPE, default="ASK/OOK"): cv.enum(
+        MODULATION, upper=False
+    ),
+    cv.Optional(CONF_MANCHESTER, default=False): cv.boolean,
+    cv.Optional(CONF_NUM_PREAMBLE, default=2): cv.int_range(min=0, max=7),
+    cv.Optional(CONF_SYNC1, default=0xD3): cv.hex_uint8_t,
+    cv.Optional(CONF_SYNC0, default=0x91): cv.hex_uint8_t,
+    cv.Optional(CONF_MAGN_TARGET, default="42dB"): cv.enum(MAGN_TARGET, upper=False),
+    cv.Optional(CONF_MAX_LNA_GAIN, default="Default"): cv.enum(
+        MAX_LNA_GAIN, upper=False
+    ),
+    cv.Optional(CONF_MAX_DVGA_GAIN, default="-3"): cv.enum(MAX_DVGA_GAIN, upper=False),
+    cv.Optional(CONF_CARRIER_SENSE_ABS_THR): cv.int_range(min=-8, max=7),
+    cv.Optional(CONF_CARRIER_SENSE_REL_THR): cv.enum(
+        CARRIER_SENSE_REL_THR, upper=False
+    ),
+    cv.Optional(CONF_LNA_PRIORITY, default=False): cv.boolean,
+    cv.Optional(CONF_FILTER_LENGTH_FSK_MSK): cv.enum(
+        FILTER_LENGTH_FSK_MSK, upper=False
+    ),
+    cv.Optional(CONF_FILTER_LENGTH_ASK_OOK): cv.enum(
+        FILTER_LENGTH_ASK_OOK, upper=False
+    ),
+    cv.Optional(CONF_FREEZE): cv.enum(FREEZE, upper=False),
+    cv.Optional(CONF_WAIT_TIME, default="32"): cv.enum(WAIT_TIME, upper=False),
+    cv.Optional(CONF_HYST_LEVEL): cv.enum(HYST_LEVEL, upper=False),
+    cv.Optional(CONF_PACKET_MODE, default=False): cv.boolean,
+    cv.Optional(CONF_PACKET_LENGTH): cv.uint8_t,
+    cv.Optional(CONF_CRC_ENABLE, default=False): cv.boolean,
+    cv.Optional(CONF_WHITENING, default=False): cv.boolean,
 }
 
-CONFIG_SCHEMA = (
-    cv.Schema({cv.GenerateID(): cv.declare_id(CC1101Component)})
-    .extend({cv.Optional(key): validator for key, validator in CONFIG_MAP.items()})
+
+def _validate_packet_mode(config):
+    if config.get(CONF_PACKET_MODE, False):
+        if CONF_GDO0_PIN not in config:
+            raise cv.Invalid("gdo0_pin is required when packet_mode is enabled")
+        if CONF_PACKET_LENGTH not in config:
+            raise cv.Invalid("packet_length is required when packet_mode is enabled")
+        if config[CONF_PACKET_LENGTH] > 64:
+            raise cv.Invalid("packet_length must be <= 64 (FIFO size)")
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(CC1101Component),
+            cv.Optional(CONF_GDO0_PIN): pins.internal_gpio_input_pin_schema,
+            cv.Optional(CONF_ON_PACKET): automation.validate_automation(single=True),
+        }
+    )
+    .extend(CONFIG_MAP)
     .extend(cv.COMPONENT_SCHEMA)
-    .extend(spi.spi_device_schema(cs_pin_required=True))
+    .extend(spi.spi_device_schema(cs_pin_required=True)),
+    _validate_packet_mode,
 )
 
 
@@ -194,16 +251,34 @@ async def to_code(config):
     await cg.register_component(var, config)
     await spi.register_spi_device(var, config)
 
-    for key in CONFIG_MAP:
+    for opt in CONFIG_MAP:
+        key = opt.schema
         if key in config:
             cg.add(getattr(var, f"set_{key}")(config[key]))
 
+    if CONF_GDO0_PIN in config:
+        gdo0_pin = await cg.gpio_pin_expression(config[CONF_GDO0_PIN])
+        cg.add(var.set_gdo0_pin(gdo0_pin))
+    if CONF_ON_PACKET in config:
+        await automation.build_automation(
+            var.get_packet_trigger(),
+            [
+                (cg.std_vector.template(cg.uint8), "x"),
+                (cg.float_, "rssi"),
+                (cg.uint8, "lqi"),
+            ],
+            config[CONF_ON_PACKET],
+        )
+
 
 # Actions
 BeginTxAction = ns.class_("BeginTxAction", automation.Action)
 BeginRxAction = ns.class_("BeginRxAction", automation.Action)
 ResetAction = ns.class_("ResetAction", automation.Action)
 SetIdleAction = ns.class_("SetIdleAction", automation.Action)
+SendPacketAction = ns.class_(
+    "SendPacketAction", automation.Action, cg.Parented.template(CC1101Component)
+)
 
 CC1101_ACTION_SCHEMA = cv.Schema(
     maybe_simple_id({cv.GenerateID(CONF_ID): cv.use_id(CC1101Component)})
@@ -218,3 +293,42 @@ async def cc1101_action_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
+
+
+def validate_raw_data(value):
+    if isinstance(value, str):
+        return value.encode("utf-8")
+    if isinstance(value, list):
+        return cv.Schema([cv.hex_uint8_t])(value)
+    raise cv.Invalid(
+        "data must either be a string wrapped in quotes or a list of bytes"
+    )
+
+
+SEND_PACKET_ACTION_SCHEMA = cv.maybe_simple_value(
+    {
+        cv.GenerateID(): cv.use_id(CC1101Component),
+        cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
+    },
+    key=CONF_DATA,
+)
+
+
+@automation.register_action(
+    "cc1101.send_packet", SendPacketAction, SEND_PACKET_ACTION_SCHEMA
+)
+async def send_packet_action_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    data = config[CONF_DATA]
+    if isinstance(data, bytes):
+        data = list(data)
+    if cg.is_template(data):
+        templ = await cg.templatable(data, args, cg.std_vector.template(cg.uint8))
+        cg.add(var.set_data_template(templ))
+    else:
+        # 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)))
+    return var

esphome/components/cc1101/cc1101.cpp

@@ -98,25 +98,8 @@ CC1101Component::CC1101Component() {
   this->state_.LENGTH_CONFIG = 2;
   this->state_.FS_AUTOCAL = 1;
 
-  // Default Settings
-  this->set_frequency(433920);
-  this->set_if_frequency(153);
-  this->set_filter_bandwidth(203);
-  this->set_channel(0);
-  this->set_channel_spacing(200);
-  this->set_symbol_rate(5000);
-  this->set_sync_mode(SyncMode::SYNC_MODE_NONE);
-  this->set_carrier_sense_above_threshold(true);
-  this->set_modulation_type(Modulation::MODULATION_ASK_OOK);
-  this->set_magn_target(MagnTarget::MAGN_TARGET_42DB);
-  this->set_max_lna_gain(MaxLnaGain::MAX_LNA_GAIN_DEFAULT);
-  this->set_max_dvga_gain(MaxDvgaGain::MAX_DVGA_GAIN_MINUS_3);
-  this->set_lna_priority(false);
-  this->set_wait_time(WaitTime::WAIT_TIME_32_SAMPLES);
-
   // CRITICAL: Initialize PA Table to avoid transmitting 0 power (Silence)
   memset(this->pa_table_, 0, sizeof(this->pa_table_));
-  this->set_output_power(10.0f);
 }
 
 void CC1101Component::setup() {
@@ -143,6 +126,11 @@ void CC1101Component::setup() {
     return;
   }
 
+  // Setup GDO0 pin if configured
+  if (this->gdo0_pin_ != nullptr) {
+    this->gdo0_pin_->setup();
+  }
+
   this->initialized_ = true;
 
   for (uint8_t i = 0; i <= static_cast<uint8_t>(Register::TEST0); i++) {
@@ -151,8 +139,70 @@ void CC1101Component::setup() {
     }
     this->write_(static_cast<Register>(i));
   }
-  this->write_(Register::PATABLE, this->pa_table_, sizeof(this->pa_table_));
+  this->set_output_power(this->output_power_requested_);
   this->strobe_(Command::RX);
+
+  // Defer pin mode setup until after all components have completed setup()
+  // This handles the case where remote_transmitter runs after CC1101 and changes pin mode
+  if (this->gdo0_pin_ != nullptr) {
+    this->defer([this]() { this->gdo0_pin_->pin_mode(gpio::FLAG_INPUT); });
+  }
+}
+
+void CC1101Component::loop() {
+  if (this->state_.PKT_FORMAT != static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO) || this->gdo0_pin_ == nullptr ||
+      !this->gdo0_pin_->digital_read()) {
+    return;
+  }
+
+  // Read state
+  this->read_(Register::RXBYTES);
+  uint8_t rx_bytes = this->state_.NUM_RXBYTES;
+  bool overflow = this->state_.RXFIFO_OVERFLOW;
+  if (overflow || rx_bytes == 0) {
+    ESP_LOGW(TAG, "RX FIFO overflow, flushing");
+    this->enter_idle_();
+    this->strobe_(Command::FRX);
+    this->strobe_(Command::RX);
+    this->wait_for_state_(State::RX);
+    return;
+  }
+
+  // Read packet
+  uint8_t payload_length, expected_rx;
+  if (this->state_.LENGTH_CONFIG == static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_VARIABLE)) {
+    this->read_(Register::FIFO, &payload_length, 1);
+    expected_rx = payload_length + 1;
+  } else {
+    payload_length = this->state_.PKTLEN;
+    expected_rx = payload_length;
+  }
+  if (payload_length == 0 || payload_length > 64 || rx_bytes != expected_rx) {
+    ESP_LOGW(TAG, "Invalid packet: rx_bytes %u, payload_length %u", rx_bytes, payload_length);
+    this->enter_idle_();
+    this->strobe_(Command::FRX);
+    this->strobe_(Command::RX);
+    this->wait_for_state_(State::RX);
+    return;
+  }
+  this->packet_.resize(payload_length);
+  this->read_(Register::FIFO, this->packet_.data(), payload_length);
+
+  // Read status from registers (more reliable than FIFO status bytes due to timing issues)
+  this->read_(Register::RSSI);
+  this->read_(Register::LQI);
+  float rssi = (this->state_.RSSI * RSSI_STEP) - RSSI_OFFSET;
+  bool crc_ok = (this->state_.LQI & STATUS_CRC_OK_MASK) != 0;
+  uint8_t lqi = this->state_.LQI & STATUS_LQI_MASK;
+  if (this->state_.CRC_EN == 0 || crc_ok) {
+    this->packet_trigger_->trigger(this->packet_, rssi, lqi);
+  }
+
+  // Return to rx
+  this->enter_idle_();
+  this->strobe_(Command::FRX);
+  this->strobe_(Command::RX);
+  this->wait_for_state_(State::RX);
 }
 
 void CC1101Component::dump_config() {
@@ -177,9 +227,12 @@ void CC1101Component::dump_config() {
 }
 
 void CC1101Component::begin_tx() {
-  // Ensure Packet Format is 3 (Async Serial), use GDO0 as input during TX
+  // Ensure Packet Format is 3 (Async Serial)
   this->write_(Register::PKTCTRL0, 0x32);
   ESP_LOGV(TAG, "Beginning TX sequence");
+  if (this->gdo0_pin_ != nullptr) {
+    this->gdo0_pin_->pin_mode(gpio::FLAG_OUTPUT);
+  }
   this->strobe_(Command::TX);
   if (!this->wait_for_state_(State::TX, 50)) {
     ESP_LOGW(TAG, "Timed out waiting for TX state!");
@@ -188,6 +241,9 @@ void CC1101Component::begin_tx() {
 
 void CC1101Component::begin_rx() {
   ESP_LOGV(TAG, "Beginning RX sequence");
+  if (this->gdo0_pin_ != nullptr) {
+    this->gdo0_pin_->pin_mode(gpio::FLAG_INPUT);
+  }
   this->strobe_(Command::RX);
 }
 
@@ -201,20 +257,6 @@ void CC1101Component::set_idle() {
   this->enter_idle_();
 }
 
-void CC1101Component::set_gdo0_config(uint8_t value) {
-  this->state_.GDO0_CFG = value;
-  if (this->initialized_) {
-    this->write_(Register::IOCFG0);
-  }
-}
-
-void CC1101Component::set_gdo2_config(uint8_t value) {
-  this->state_.GDO2_CFG = value;
-  if (this->initialized_) {
-    this->write_(Register::IOCFG2);
-  }
-}
-
 bool CC1101Component::wait_for_state_(State target_state, uint32_t timeout_ms) {
   uint32_t start = millis();
   while (millis() - start < timeout_ms) {
@@ -282,6 +324,33 @@ void CC1101Component::read_(Register reg, uint8_t *buffer, size_t length) {
   this->disable();
 }
 
+CC1101Error CC1101Component::transmit_packet(const std::vector<uint8_t> &packet) {
+  if (this->state_.PKT_FORMAT != static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO)) {
+    return CC1101Error::PARAMS;
+  }
+
+  // Write packet
+  this->enter_idle_();
+  this->strobe_(Command::FTX);
+  if (this->state_.LENGTH_CONFIG == static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_VARIABLE)) {
+    this->write_(Register::FIFO, static_cast<uint8_t>(packet.size()));
+  }
+  this->write_(Register::FIFO, packet.data(), packet.size());
+  this->strobe_(Command::TX);
+  if (!this->wait_for_state_(State::IDLE, 1000)) {
+    ESP_LOGW(TAG, "TX timeout");
+    this->enter_idle_();
+    this->strobe_(Command::RX);
+    this->wait_for_state_(State::RX);
+    return CC1101Error::TIMEOUT;
+  }
+
+  // Return to rx
+  this->strobe_(Command::RX);
+  this->wait_for_state_(State::RX);
+  return CC1101Error::NONE;
+}
+
 // Setters
 void CC1101Component::set_output_power(float value) {
   this->output_power_requested_ = value;
@@ -428,6 +497,7 @@ void CC1101Component::set_modulation_type(Modulation value) {
   this->state_.PA_POWER = value == Modulation::MODULATION_ASK_OOK ? 1 : 0;
   if (this->initialized_) {
     this->enter_idle_();
+    this->set_output_power(this->output_power_requested_);
     this->write_(Register::MDMCFG2);
     this->write_(Register::FREND0);
     this->strobe_(Command::RX);
@@ -462,13 +532,6 @@ void CC1101Component::set_sync0(uint8_t value) {
   }
 }
 
-void CC1101Component::set_pktlen(uint8_t value) {
-  this->state_.PKTLEN = value;
-  if (this->initialized_) {
-    this->write_(Register::PKTLEN);
-  }
-}
-
 void CC1101Component::set_magn_target(MagnTarget value) {
   this->state_.MAGN_TARGET = static_cast<uint8_t>(value);
   if (this->initialized_) {
@@ -546,4 +609,53 @@ void CC1101Component::set_hyst_level(HystLevel value) {
   }
 }
 
+void CC1101Component::set_packet_mode(bool value) {
+  this->state_.PKT_FORMAT =
+      static_cast<uint8_t>(value ? PacketFormat::PACKET_FORMAT_FIFO : PacketFormat::PACKET_FORMAT_ASYNC_SERIAL);
+  if (value) {
+    // Configure GDO0 for FIFO status (asserts on RX FIFO threshold or end of packet)
+    this->state_.GDO0_CFG = 0x01;
+    // Set max RX FIFO threshold to ensure we only trigger on end-of-packet
+    this->state_.FIFO_THR = 15;
+    // Don't append status bytes to FIFO - we read from registers instead
+    this->state_.APPEND_STATUS = 0;
+  } else {
+    // Configure GDO0 for serial data (async serial mode)
+    this->state_.GDO0_CFG = 0x0D;
+  }
+  if (this->initialized_) {
+    this->write_(Register::PKTCTRL0);
+    this->write_(Register::PKTCTRL1);
+    this->write_(Register::IOCFG0);
+    this->write_(Register::FIFOTHR);
+  }
+}
+
+void CC1101Component::set_packet_length(uint8_t value) {
+  if (value == 0) {
+    this->state_.LENGTH_CONFIG = static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_VARIABLE);
+  } else {
+    this->state_.LENGTH_CONFIG = static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_FIXED);
+    this->state_.PKTLEN = value;
+  }
+  if (this->initialized_) {
+    this->write_(Register::PKTCTRL0);
+    this->write_(Register::PKTLEN);
+  }
+}
+
+void CC1101Component::set_crc_enable(bool value) {
+  this->state_.CRC_EN = value ? 1 : 0;
+  if (this->initialized_) {
+    this->write_(Register::PKTCTRL0);
+  }
+}
+
+void CC1101Component::set_whitening(bool value) {
+  this->state_.WHITE_DATA = value ? 1 : 0;
+  if (this->initialized_) {
+    this->write_(Register::PKTCTRL0);
+  }
+}
+
 }  // namespace esphome::cc1101

esphome/components/cc1101/cc1101.h

@@ -5,9 +5,12 @@
 #include "esphome/components/spi/spi.h"
 #include "esphome/core/automation.h"
 #include "cc1101defs.h"
+#include <vector>
 
 namespace esphome::cc1101 {
 
+enum class CC1101Error { NONE = 0, TIMEOUT, PARAMS, CRC_ERROR, FIFO_OVERFLOW };
+
 class CC1101Component : public Component,
                         public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
                                               spi::CLOCK_PHASE_LEADING, spi::DATA_RATE_1MHZ> {
@@ -15,6 +18,7 @@ class CC1101Component : public Component,
   CC1101Component();
 
   void setup() override;
+  void loop() override;
   void dump_config() override;
 
   // Actions
@@ -24,8 +28,7 @@ class CC1101Component : public Component,
   void set_idle();
 
   // GDO Pin Configuration
-  void set_gdo0_config(uint8_t value);
-  void set_gdo2_config(uint8_t value);
+  void set_gdo0_pin(InternalGPIOPin *pin) { this->gdo0_pin_ = pin; }
 
   // Configuration Setters
   void set_output_power(float value);
@@ -48,7 +51,6 @@ class CC1101Component : public Component,
   void set_num_preamble(uint8_t value);
   void set_sync1(uint8_t value);
   void set_sync0(uint8_t value);
-  void set_pktlen(uint8_t value);
 
   // AGC settings
   void set_magn_target(MagnTarget value);
@@ -63,6 +65,16 @@ class CC1101Component : public Component,
   void set_wait_time(WaitTime value);
   void set_hyst_level(HystLevel value);
 
+  // Packet mode settings
+  void set_packet_mode(bool value);
+  void set_packet_length(uint8_t value);
+  void set_crc_enable(bool value);
+  void set_whitening(bool value);
+
+  // Packet mode operations
+  CC1101Error transmit_packet(const std::vector<uint8_t> &packet);
+  Trigger<std::vector<uint8_t>, float, uint8_t> *get_packet_trigger() const { return this->packet_trigger_; }
+
  protected:
   uint16_t chip_id_{0};
   bool initialized_{false};
@@ -73,6 +85,13 @@ class CC1101Component : public Component,
 
   CC1101State state_;
 
+  // GDO pin for packet reception
+  InternalGPIOPin *gdo0_pin_{nullptr};
+
+  // Packet handling
+  Trigger<std::vector<uint8_t>, float, uint8_t> *packet_trigger_{new Trigger<std::vector<uint8_t>, float, uint8_t>()};
+  std::vector<uint8_t> packet_;
+
   // Low-level Helpers
   uint8_t strobe_(Command cmd);
   void write_(Register reg);
@@ -107,4 +126,28 @@ template<typename... Ts> class SetIdleAction : public Action<Ts...>, public Pare
   void play(const Ts &...x) override { this->parent_->set_idle(); }
 };
 
+template<typename... Ts> class SendPacketAction : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  void set_data_template(std::function<std::vector<uint8_t>(Ts...)> func) { this->data_func_ = func; }
+  void set_data_static(const uint8_t *data, size_t len) {
+    this->data_static_ = data;
+    this->data_static_len_ = len;
+  }
+
+  void play(const Ts &...x) override {
+    if (this->data_func_) {
+      auto data = this->data_func_(x...);
+      this->parent_->transmit_packet(data);
+    } else if (this->data_static_ != nullptr) {
+      std::vector<uint8_t> data(this->data_static_, this->data_static_ + this->data_static_len_);
+      this->parent_->transmit_packet(data);
+    }
+  }
+
+ protected:
+  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
+  const uint8_t *data_static_{nullptr};
+  size_t data_static_len_{0};
+};
+
 }  // namespace esphome::cc1101

esphome/components/cc1101/cc1101defs.h

@@ -6,6 +6,12 @@ namespace esphome::cc1101 {
 
 static constexpr float XTAL_FREQUENCY = 26000000;
 
+static constexpr float RSSI_OFFSET = 74.0f;
+static constexpr float RSSI_STEP = 0.5f;
+
+static constexpr uint8_t STATUS_CRC_OK_MASK = 0x80;
+static constexpr uint8_t STATUS_LQI_MASK = 0x7F;
+
 static constexpr uint8_t BUS_BURST = 0x40;
 static constexpr uint8_t BUS_READ = 0x80;
 static constexpr uint8_t BUS_WRITE = 0x00;
@@ -134,6 +140,10 @@ enum class SyncMode : uint8_t {
   SYNC_MODE_15_16,
   SYNC_MODE_16_16,
   SYNC_MODE_30_32,
+  SYNC_MODE_NONE_CS,
+  SYNC_MODE_15_16_CS,
+  SYNC_MODE_16_16_CS,
+  SYNC_MODE_30_32_CS,
 };
 
 enum class Modulation : uint8_t {
@@ -218,6 +228,19 @@ enum class HystLevel : uint8_t {
   HYST_LEVEL_HIGH,
 };
 
+enum class PacketFormat : uint8_t {
+  PACKET_FORMAT_FIFO,
+  PACKET_FORMAT_SYNC_SERIAL,
+  PACKET_FORMAT_RANDOM_TX,
+  PACKET_FORMAT_ASYNC_SERIAL,
+};
+
+enum class LengthConfig : uint8_t {
+  LENGTH_CONFIG_FIXED,
+  LENGTH_CONFIG_VARIABLE,
+  LENGTH_CONFIG_INFINITE,
+};
+
 struct __attribute__((packed)) CC1101State {
   // Byte array accessors for bulk SPI transfers
   uint8_t *regs() { return reinterpret_cast<uint8_t *>(this); }

esphome/components/ch422g/ch422g.cpp

@@ -128,7 +128,9 @@ void CH422GGPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->
 bool CH422GGPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) ^ this->inverted_; }
 
 void CH422GGPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value ^ this->inverted_); }
-std::string CH422GGPIOPin::dump_summary() const { return str_sprintf("EXIO%u via CH422G", pin_); }
+size_t CH422GGPIOPin::dump_summary(char *buffer, size_t len) const {
+  return snprintf(buffer, len, "EXIO%u via CH422G", this->pin_);
+}
 void CH422GGPIOPin::set_flags(gpio::Flags flags) {
   flags_ = flags;
   this->parent_->pin_mode(this->pin_, flags);

esphome/components/ch422g/ch422g.h

@@ -50,7 +50,7 @@ class CH422GGPIOPin : public GPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  std::string dump_summary() const override;
+  size_t dump_summary(char *buffer, size_t len) const override;
 
   void set_parent(CH422GComponent *parent) { parent_ = parent; }
   void set_pin(uint8_t pin) { pin_ = pin; }

esphome/components/climate/__init__.py

@@ -117,9 +117,7 @@ CONF_MIN_HUMIDITY = "min_humidity"
 CONF_MAX_HUMIDITY = "max_humidity"
 CONF_TARGET_HUMIDITY = "target_humidity"
 
-visual_temperature = cv.float_with_unit(
-    "visual_temperature", "(°C|° C|°|C|°K|° K|K|°F|° F|F)?"
-)
+visual_temperature = cv.float_with_unit("visual_temperature", "(°|(° ?)?[CKF])?")
 
 
 VISUAL_TEMPERATURE_STEP_SCHEMA = cv.Schema(

esphome/components/climate/climate.cpp

@@ -2,6 +2,7 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/macros.h"
+#include <strings.h>
 
 namespace esphome::climate {
 
@@ -190,24 +191,30 @@ ClimateCall &ClimateCall::set_fan_mode(ClimateFanMode fan_mode) {
 }
 
 ClimateCall &ClimateCall::set_fan_mode(const char *custom_fan_mode) {
+  return this->set_fan_mode(custom_fan_mode, strlen(custom_fan_mode));
+}
+
+ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) {
+  return this->set_fan_mode(fan_mode.data(), fan_mode.size());
+}
+
+ClimateCall &ClimateCall::set_fan_mode(const char *custom_fan_mode, size_t len) {
   // Check if it's a standard enum mode first
   for (const auto &mode_entry : CLIMATE_FAN_MODES_BY_STR) {
-    if (str_equals_case_insensitive(custom_fan_mode, mode_entry.str)) {
+    if (strncasecmp(custom_fan_mode, mode_entry.str, len) == 0 && mode_entry.str[len] == '\0') {
       return this->set_fan_mode(static_cast<ClimateFanMode>(mode_entry.value));
     }
   }
   // Find the matching pointer from parent climate device
-  if (const char *mode_ptr = this->parent_->find_custom_fan_mode_(custom_fan_mode)) {
+  if (const char *mode_ptr = this->parent_->find_custom_fan_mode_(custom_fan_mode, len)) {
     this->custom_fan_mode_ = mode_ptr;
     this->fan_mode_.reset();
     return *this;
   }
-  ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %s", this->parent_->get_name().c_str(), custom_fan_mode);
+  ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %.*s", this->parent_->get_name().c_str(), (int) len, custom_fan_mode);
   return *this;
 }
 
-ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) { return this->set_fan_mode(fan_mode.c_str()); }
-
 ClimateCall &ClimateCall::set_fan_mode(optional<std::string> fan_mode) {
   if (fan_mode.has_value()) {
     this->set_fan_mode(fan_mode.value());
@@ -222,24 +229,30 @@ ClimateCall &ClimateCall::set_preset(ClimatePreset preset) {
 }
 
 ClimateCall &ClimateCall::set_preset(const char *custom_preset) {
+  return this->set_preset(custom_preset, strlen(custom_preset));
+}
+
+ClimateCall &ClimateCall::set_preset(const std::string &preset) {
+  return this->set_preset(preset.data(), preset.size());
+}
+
+ClimateCall &ClimateCall::set_preset(const char *custom_preset, size_t len) {
   // Check if it's a standard enum preset first
   for (const auto &preset_entry : CLIMATE_PRESETS_BY_STR) {
-    if (str_equals_case_insensitive(custom_preset, preset_entry.str)) {
+    if (strncasecmp(custom_preset, preset_entry.str, len) == 0 && preset_entry.str[len] == '\0') {
       return this->set_preset(static_cast<ClimatePreset>(preset_entry.value));
     }
   }
   // Find the matching pointer from parent climate device
-  if (const char *preset_ptr = this->parent_->find_custom_preset_(custom_preset)) {
+  if (const char *preset_ptr = this->parent_->find_custom_preset_(custom_preset, len)) {
     this->custom_preset_ = preset_ptr;
     this->preset_.reset();
     return *this;
   }
-  ESP_LOGW(TAG, "'%s' - Unrecognized preset %s", this->parent_->get_name().c_str(), custom_preset);
+  ESP_LOGW(TAG, "'%s' - Unrecognized preset %.*s", this->parent_->get_name().c_str(), (int) len, custom_preset);
   return *this;
 }
 
-ClimateCall &ClimateCall::set_preset(const std::string &preset) { return this->set_preset(preset.c_str()); }
-
 ClimateCall &ClimateCall::set_preset(optional<std::string> preset) {
   if (preset.has_value()) {
     this->set_preset(preset.value());
@@ -356,7 +369,7 @@ optional<ClimateDeviceRestoreState> Climate::restore_state_() {
 }
 
 void Climate::save_state_() {
-#if (defined(USE_ESP_IDF) || (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0))) && \
+#if (defined(USE_ESP32) || (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0))) && \
     !defined(CLANG_TIDY)
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
 #define TEMP_IGNORE_MEMACCESS
@@ -688,11 +701,19 @@ bool Climate::set_custom_preset_(const char *preset) {
 void Climate::clear_custom_preset_() { this->custom_preset_ = nullptr; }
 
 const char *Climate::find_custom_fan_mode_(const char *custom_fan_mode) {
-  return this->get_traits().find_custom_fan_mode_(custom_fan_mode);
+  return this->find_custom_fan_mode_(custom_fan_mode, strlen(custom_fan_mode));
+}
+
+const char *Climate::find_custom_fan_mode_(const char *custom_fan_mode, size_t len) {
+  return this->get_traits().find_custom_fan_mode_(custom_fan_mode, len);
 }
 
 const char *Climate::find_custom_preset_(const char *custom_preset) {
-  return this->get_traits().find_custom_preset_(custom_preset);
+  return this->find_custom_preset_(custom_preset, strlen(custom_preset));
+}
+
+const char *Climate::find_custom_preset_(const char *custom_preset, size_t len) {
+  return this->get_traits().find_custom_preset_(custom_preset, len);
 }
 
 void Climate::dump_traits_(const char *tag) {

esphome/components/climate/climate.h

@@ -78,6 +78,8 @@ class ClimateCall {
   ClimateCall &set_fan_mode(optional<std::string> fan_mode);
   /// Set the custom fan mode of the climate device.
   ClimateCall &set_fan_mode(const char *custom_fan_mode);
+  /// Set the custom fan mode of the climate device (zero-copy API path).
+  ClimateCall &set_fan_mode(const char *custom_fan_mode, size_t len);
   /// Set the swing mode of the climate device.
   ClimateCall &set_swing_mode(ClimateSwingMode swing_mode);
   /// Set the swing mode of the climate device.
@@ -94,6 +96,8 @@ class ClimateCall {
   ClimateCall &set_preset(optional<std::string> preset);
   /// Set the custom preset of the climate device.
   ClimateCall &set_preset(const char *custom_preset);
+  /// Set the custom preset of the climate device (zero-copy API path).
+  ClimateCall &set_preset(const char *custom_preset, size_t len);
 
   void perform();
 
@@ -290,9 +294,11 @@ class Climate : public EntityBase {
 
   /// Find and return the matching custom fan mode pointer from traits, or nullptr if not found.
   const char *find_custom_fan_mode_(const char *custom_fan_mode);
+  const char *find_custom_fan_mode_(const char *custom_fan_mode, size_t len);
 
   /// Find and return the matching custom preset pointer from traits, or nullptr if not found.
   const char *find_custom_preset_(const char *custom_preset);
+  const char *find_custom_preset_(const char *custom_preset, size_t len);
 
   /** Get the default traits of this climate device.
    *
@@ -320,8 +326,8 @@ class Climate : public EntityBase {
 
   void dump_traits_(const char *tag);
 
-  CallbackManager<void(Climate &)> state_callback_{};
-  CallbackManager<void(ClimateCall &)> control_callback_{};
+  LazyCallbackManager<void(Climate &)> state_callback_{};
+  LazyCallbackManager<void(ClimateCall &)> control_callback_{};
   ESPPreferenceObject rtc_;
 #ifdef USE_CLIMATE_VISUAL_OVERRIDES
   float visual_min_temperature_override_{NAN};

esphome/components/climate/climate_traits.h

@@ -20,18 +20,22 @@ using ClimatePresetMask = FiniteSetMask<ClimatePreset, DefaultBitPolicy<ClimateP
 
 // Lightweight linear search for small vectors (1-20 items) of const char* pointers
 // Avoids std::find template overhead
-inline bool vector_contains(const std::vector<const char *> &vec, const char *value) {
+inline bool vector_contains(const std::vector<const char *> &vec, const char *value, size_t len) {
   for (const char *item : vec) {
-    if (strcmp(item, value) == 0)
+    if (strncmp(item, value, len) == 0 && item[len] == '\0')
       return true;
   }
   return false;
 }
 
+inline bool vector_contains(const std::vector<const char *> &vec, const char *value) {
+  return vector_contains(vec, value, strlen(value));
+}
+
 // Find and return matching pointer from vector, or nullptr if not found
-inline const char *vector_find(const std::vector<const char *> &vec, const char *value) {
+inline const char *vector_find(const std::vector<const char *> &vec, const char *value, size_t len) {
   for (const char *item : vec) {
-    if (strcmp(item, value) == 0)
+    if (strncmp(item, value, len) == 0 && item[len] == '\0')
       return item;
   }
   return nullptr;
@@ -257,13 +261,19 @@ class ClimateTraits {
   /// Find and return the matching custom fan mode pointer from supported modes, or nullptr if not found
   /// This is protected as it's an implementation detail - use Climate::find_custom_fan_mode_() instead
   const char *find_custom_fan_mode_(const char *custom_fan_mode) const {
-    return vector_find(this->supported_custom_fan_modes_, custom_fan_mode);
+    return this->find_custom_fan_mode_(custom_fan_mode, strlen(custom_fan_mode));
+  }
+  const char *find_custom_fan_mode_(const char *custom_fan_mode, size_t len) const {
+    return vector_find(this->supported_custom_fan_modes_, custom_fan_mode, len);
   }
 
   /// Find and return the matching custom preset pointer from supported presets, or nullptr if not found
   /// This is protected as it's an implementation detail - use Climate::find_custom_preset_() instead
   const char *find_custom_preset_(const char *custom_preset) const {
-    return vector_find(this->supported_custom_presets_, custom_preset);
+    return this->find_custom_preset_(custom_preset, strlen(custom_preset));
+  }
+  const char *find_custom_preset_(const char *custom_preset, size_t len) const {
+    return vector_find(this->supported_custom_presets_, custom_preset, len);
   }
 
   uint32_t feature_flags_{0};

esphome/components/const/__init__.py

@@ -7,9 +7,11 @@ BYTE_ORDER_LITTLE = "little_endian"
 BYTE_ORDER_BIG = "big_endian"
 
 CONF_COLOR_DEPTH = "color_depth"
+CONF_CRC_ENABLE = "crc_enable"
 CONF_DRAW_ROUNDING = "draw_rounding"
 CONF_ENABLED = "enabled"
 CONF_IGNORE_NOT_FOUND = "ignore_not_found"
+CONF_ON_PACKET = "on_packet"
 CONF_ON_RECEIVE = "on_receive"
 CONF_ON_STATE_CHANGE = "on_state_change"
 CONF_REQUEST_HEADERS = "request_headers"

esphome/components/copy/select/copy_select.cpp

@@ -7,7 +7,7 @@ namespace copy {
 static const char *const TAG = "copy.select";
 
 void CopySelect::setup() {
-  source_->add_on_state_callback([this](const std::string &value, size_t index) { this->publish_state(index); });
+  source_->add_on_state_callback([this](size_t index) { this->publish_state(index); });
 
   traits.set_options(source_->traits.get_options());
 

esphome/components/cover/cover.h

@@ -152,7 +152,7 @@ class Cover : public EntityBase, public EntityBase_DeviceClass {
 
   optional<CoverRestoreState> restore_state_();
 
-  CallbackManager<void()> state_callback_{};
+  LazyCallbackManager<void()> state_callback_{};
 
   ESPPreferenceObject rtc_;
 };

esphome/components/cse7766/cse7766.cpp

@@ -1,11 +1,13 @@
 #include "cse7766.h"
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace cse7766 {
 
 static const char *const TAG = "cse7766";
+static constexpr size_t CSE7766_RAW_DATA_SIZE = 24;
 
 void CSE7766Component::loop() {
   const uint32_t now = App.get_loop_component_start_time();
@@ -70,8 +72,8 @@ bool CSE7766Component::check_byte_() {
 void CSE7766Component::parse_data_() {
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   {
-    std::string s = format_hex_pretty(this->raw_data_, sizeof(this->raw_data_));
-    ESP_LOGVV(TAG, "Raw data: %s", s.c_str());
+    char hex_buf[format_hex_pretty_size(CSE7766_RAW_DATA_SIZE)];
+    ESP_LOGVV(TAG, "Raw data: %s", format_hex_pretty_to(hex_buf, this->raw_data_, sizeof(this->raw_data_)));
   }
 #endif
 

esphome/components/dallas_temp/dallas_temp.cpp

@@ -51,7 +51,7 @@ void DallasTemperatureSensor::update() {
     }
 
     float tempc = this->get_temp_c_();
-    ESP_LOGD(TAG, "'%s': Got Temperature=%.1f°C", this->get_name().c_str(), tempc);
+    ESP_LOGD(TAG, "'%s': Got Temperature=%f°C", this->get_name().c_str(), tempc);
     this->publish_state(tempc);
   });
 }

esphome/components/datetime/datetime_base.h

@@ -22,7 +22,7 @@ class DateTimeBase : public EntityBase {
 #endif
 
  protected:
-  CallbackManager<void()> state_callback_;
+  LazyCallbackManager<void()> state_callback_;
 
 #ifdef USE_TIME
   time::RealTimeClock *rtc_;

esphome/components/debug/debug_esp32.cpp

@@ -200,7 +200,7 @@ void DebugComponent::get_device_info_(std::string &device_info) {
 #ifdef USE_ARDUINO
   ESP_LOGD(TAG, "Framework: Arduino");
   device_info += "Arduino";
-#elif defined(USE_ESP_IDF)
+#elif defined(USE_ESP32)
   ESP_LOGD(TAG, "Framework: ESP-IDF");
   device_info += "ESP-IDF";
 #else

esphome/components/deep_sleep/__init__.py

@@ -1,4 +1,4 @@
-from esphome import automation, pins
+from esphome import automation, core, pins
 import esphome.codegen as cg
 from esphome.components import esp32, time
 from esphome.components.esp32 import (
@@ -23,16 +23,20 @@ from esphome.const import (
     CONF_MINUTE,
     CONF_MODE,
     CONF_NUMBER,
+    CONF_PIN,
     CONF_PINS,
     CONF_RUN_DURATION,
     CONF_SECOND,
     CONF_SLEEP_DURATION,
     CONF_TIME_ID,
     CONF_WAKEUP_PIN,
+    PLATFORM_BK72XX,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
     PlatformFramework,
 )
+from esphome.core import CORE
+from esphome.types import ConfigType
 
 WAKEUP_PINS = {
     VARIANT_ESP32: [
@@ -113,7 +117,7 @@ WAKEUP_PINS = {
 }
 
 
-def validate_pin_number(value):
+def validate_pin_number_esp32(value: ConfigType) -> ConfigType:
     valid_pins = WAKEUP_PINS.get(get_esp32_variant(), WAKEUP_PINS[VARIANT_ESP32])
     if value[CONF_NUMBER] not in valid_pins:
         raise cv.Invalid(
@@ -122,6 +126,51 @@ def validate_pin_number(value):
     return value
 
 
+def validate_pin_number(value: ConfigType) -> ConfigType:
+    if not CORE.is_esp32:
+        return value
+    return validate_pin_number_esp32(value)
+
+
+def validate_wakeup_pin(
+    value: ConfigType | list[ConfigType],
+) -> list[ConfigType]:
+    if not isinstance(value, list):
+        processed_pins: list[ConfigType] = [{CONF_PIN: value}]
+    else:
+        processed_pins = list(value)
+
+    for i, pin_config in enumerate(processed_pins):
+        # now validate each item
+        validated_pin = WAKEUP_PIN_SCHEMA(pin_config)
+        validate_pin_number(validated_pin[CONF_PIN])
+        processed_pins[i] = validated_pin
+
+    return processed_pins
+
+
+def validate_config(config: ConfigType) -> ConfigType:
+    # right now only BK72XX supports the list format for wakeup pins
+    if CORE.is_bk72xx:
+        if CONF_WAKEUP_PIN_MODE in config:
+            wakeup_pins = config.get(CONF_WAKEUP_PIN, [])
+            if len(wakeup_pins) > 1:
+                raise cv.Invalid(
+                    "You need to remove the global wakeup_pin_mode and define it per pin"
+                )
+            if wakeup_pins:
+                wakeup_pins[0][CONF_WAKEUP_PIN_MODE] = config.pop(CONF_WAKEUP_PIN_MODE)
+    elif (
+        isinstance(config.get(CONF_WAKEUP_PIN), list)
+        and len(config[CONF_WAKEUP_PIN]) > 1
+    ):
+        raise cv.Invalid(
+            "Your platform does not support providing multiple entries in wakeup_pin"
+        )
+
+    return config
+
+
 def _validate_ex1_wakeup_mode(value):
     if value == "ALL_LOW":
         esp32.only_on_variant(supported=[VARIANT_ESP32], msg_prefix="ALL_LOW")(value)
@@ -141,6 +190,15 @@ def _validate_ex1_wakeup_mode(value):
     return value
 
 
+def _validate_sleep_duration(value: core.TimePeriod) -> core.TimePeriod:
+    if not CORE.is_bk72xx:
+        return value
+    max_duration = core.TimePeriod(hours=36)
+    if value > max_duration:
+        raise cv.Invalid("sleep duration cannot be more than 36 hours on BK72XX")
+    return value
+
+
 deep_sleep_ns = cg.esphome_ns.namespace("deep_sleep")
 DeepSleepComponent = deep_sleep_ns.class_("DeepSleepComponent", cg.Component)
 EnterDeepSleepAction = deep_sleep_ns.class_("EnterDeepSleepAction", automation.Action)
@@ -186,6 +244,13 @@ WAKEUP_CAUSES_SCHEMA = cv.Schema(
     }
 )
 
+WAKEUP_PIN_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_PIN): pins.internal_gpio_input_pin_schema,
+        cv.Optional(CONF_WAKEUP_PIN_MODE): cv.enum(WAKEUP_PIN_MODES, upper=True),
+    }
+)
+
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -194,14 +259,15 @@ CONFIG_SCHEMA = cv.All(
                 cv.All(cv.only_on_esp32, WAKEUP_CAUSES_SCHEMA),
                 cv.positive_time_period_milliseconds,
             ),
-            cv.Optional(CONF_SLEEP_DURATION): cv.positive_time_period_milliseconds,
-            cv.Optional(CONF_WAKEUP_PIN): cv.All(
-                cv.only_on_esp32,
-                pins.internal_gpio_input_pin_schema,
-                validate_pin_number,
+            cv.Optional(CONF_SLEEP_DURATION): cv.All(
+                cv.positive_time_period_milliseconds,
+                _validate_sleep_duration,
             ),
+            cv.Optional(CONF_WAKEUP_PIN): validate_wakeup_pin,
             cv.Optional(CONF_WAKEUP_PIN_MODE): cv.All(
-                cv.only_on_esp32, cv.enum(WAKEUP_PIN_MODES), upper=True
+                cv.only_on([PLATFORM_ESP32, PLATFORM_BK72XX]),
+                cv.enum(WAKEUP_PIN_MODES),
+                upper=True,
             ),
             cv.Optional(CONF_ESP32_EXT1_WAKEUP): cv.All(
                 cv.only_on_esp32,
@@ -212,7 +278,8 @@ CONFIG_SCHEMA = cv.All(
                 cv.Schema(
                     {
                         cv.Required(CONF_PINS): cv.ensure_list(
-                            pins.internal_gpio_input_pin_schema, validate_pin_number
+                            pins.internal_gpio_input_pin_schema,
+                            validate_pin_number_esp32,
                         ),
                         cv.Required(CONF_MODE): cv.All(
                             cv.enum(EXT1_WAKEUP_MODES, upper=True),
@@ -238,7 +305,8 @@ CONFIG_SCHEMA = cv.All(
             ),
         }
     ).extend(cv.COMPONENT_SCHEMA),
-    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266]),
+    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_BK72XX]),
+    validate_config,
 )
 
 
@@ -249,8 +317,21 @@ async def to_code(config):
     if CONF_SLEEP_DURATION in config:
         cg.add(var.set_sleep_duration(config[CONF_SLEEP_DURATION]))
     if CONF_WAKEUP_PIN in config:
-        pin = await cg.gpio_pin_expression(config[CONF_WAKEUP_PIN])
-        cg.add(var.set_wakeup_pin(pin))
+        pins_as_list = config.get(CONF_WAKEUP_PIN, [])
+        if CORE.is_bk72xx:
+            cg.add(var.init_wakeup_pins_(len(pins_as_list)))
+            for item in pins_as_list:
+                cg.add(
+                    var.add_wakeup_pin(
+                        await cg.gpio_pin_expression(item[CONF_PIN]),
+                        item.get(
+                            CONF_WAKEUP_PIN_MODE, WakeupPinMode.WAKEUP_PIN_MODE_IGNORE
+                        ),
+                    )
+                )
+        else:
+            pin = await cg.gpio_pin_expression(pins_as_list[0][CONF_PIN])
+            cg.add(var.set_wakeup_pin(pin))
     if CONF_WAKEUP_PIN_MODE in config:
         cg.add(var.set_wakeup_pin_mode(config[CONF_WAKEUP_PIN_MODE]))
     if CONF_RUN_DURATION in config:
@@ -305,7 +386,10 @@ DEEP_SLEEP_ENTER_SCHEMA = cv.All(
             cv.Schema(
                 {
                     cv.Exclusive(CONF_SLEEP_DURATION, "time"): cv.templatable(
-                        cv.positive_time_period_milliseconds
+                        cv.All(
+                            cv.positive_time_period_milliseconds,
+                            _validate_sleep_duration,
+                        )
                     ),
                     # Only on ESP32 due to how long the RTC on ESP8266 can stay asleep
                     cv.Exclusive(CONF_UNTIL, "time"): cv.All(
@@ -363,5 +447,6 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
             PlatformFramework.ESP32_IDF,
         },
         "deep_sleep_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
+        "deep_sleep_bk72xx.cpp": {PlatformFramework.BK72XX_ARDUINO},
     }
 )

esphome/components/deep_sleep/deep_sleep_bk72xx.cpp

@@ -0,0 +1,64 @@
+#ifdef USE_BK72XX
+
+#include "deep_sleep_component.h"
+#include "esphome/core/log.h"
+
+namespace esphome::deep_sleep {
+
+static const char *const TAG = "deep_sleep.bk72xx";
+
+optional<uint32_t> DeepSleepComponent::get_run_duration_() const { return this->run_duration_; }
+
+void DeepSleepComponent::dump_config_platform_() {
+  for (const WakeUpPinItem &item : this->wakeup_pins_) {
+    LOG_PIN("  Wakeup Pin: ", item.wakeup_pin);
+  }
+}
+
+bool DeepSleepComponent::pin_prevents_sleep_(WakeUpPinItem &pinItem) const {
+  return (pinItem.wakeup_pin_mode == WAKEUP_PIN_MODE_KEEP_AWAKE && pinItem.wakeup_pin != nullptr &&
+          !this->sleep_duration_.has_value() && (pinItem.wakeup_level == get_real_pin_state_(*pinItem.wakeup_pin)));
+}
+
+bool DeepSleepComponent::prepare_to_sleep_() {
+  if (wakeup_pins_.size() > 0) {
+    for (WakeUpPinItem &item : this->wakeup_pins_) {
+      if (pin_prevents_sleep_(item)) {
+        // Defer deep sleep until inactive
+        if (!this->next_enter_deep_sleep_) {
+          this->status_set_warning();
+          ESP_LOGV(TAG, "Waiting for pin to switch state to enter deep sleep...");
+        }
+        this->next_enter_deep_sleep_ = true;
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+void DeepSleepComponent::deep_sleep_() {
+  for (WakeUpPinItem &item : this->wakeup_pins_) {
+    if (item.wakeup_pin_mode == WAKEUP_PIN_MODE_INVERT_WAKEUP) {
+      if (item.wakeup_level == get_real_pin_state_(*item.wakeup_pin)) {
+        item.wakeup_level = !item.wakeup_level;
+      }
+    }
+    ESP_LOGI(TAG, "Wake-up on P%u %s (%d)", item.wakeup_pin->get_pin(), item.wakeup_level ? "HIGH" : "LOW",
+             static_cast<int32_t>(item.wakeup_pin_mode));
+  }
+
+  if (this->sleep_duration_.has_value())
+    lt_deep_sleep_config_timer((*this->sleep_duration_ / 1000) & 0xFFFFFFFF);
+
+  for (WakeUpPinItem &item : this->wakeup_pins_) {
+    lt_deep_sleep_config_gpio(1 << item.wakeup_pin->get_pin(), item.wakeup_level);
+    lt_deep_sleep_keep_floating_gpio(1 << item.wakeup_pin->get_pin(), true);
+  }
+
+  lt_deep_sleep_enter();
+}
+
+}  // namespace esphome::deep_sleep
+
+#endif  // USE_BK72XX

esphome/components/deep_sleep/deep_sleep_component.h

@@ -19,7 +19,7 @@
 namespace esphome {
 namespace deep_sleep {
 
-#ifdef USE_ESP32
+#if defined(USE_ESP32) || defined(USE_BK72XX)
 
 /** The values of this enum define what should be done if deep sleep is set up with a wakeup pin on the ESP32
  * and the scenario occurs that the wakeup pin is already in the wakeup state.
@@ -33,7 +33,17 @@ enum WakeupPinMode {
    */
   WAKEUP_PIN_MODE_INVERT_WAKEUP,
 };
+#endif
 
+#if defined(USE_BK72XX)
+struct WakeUpPinItem {
+  InternalGPIOPin *wakeup_pin;
+  WakeupPinMode wakeup_pin_mode;
+  bool wakeup_level;
+};
+#endif  // USE_BK72XX
+
+#ifdef USE_ESP32
 #if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3)
 struct Ext1Wakeup {
   uint64_t mask;
@@ -75,6 +85,13 @@ class DeepSleepComponent : public Component {
   void set_wakeup_pin_mode(WakeupPinMode wakeup_pin_mode);
 #endif  // USE_ESP32
 
+#if defined(USE_BK72XX)
+  void init_wakeup_pins_(size_t capacity) { this->wakeup_pins_.init(capacity); }
+  void add_wakeup_pin(InternalGPIOPin *wakeup_pin, WakeupPinMode wakeup_pin_mode) {
+    this->wakeup_pins_.emplace_back(WakeUpPinItem{wakeup_pin, wakeup_pin_mode, !wakeup_pin->is_inverted()});
+  }
+#endif  // USE_BK72XX
+
 #if defined(USE_ESP32)
 #if !defined(USE_ESP32_VARIANT_ESP32C2) && !defined(USE_ESP32_VARIANT_ESP32C3)
   void set_ext1_wakeup(Ext1Wakeup ext1_wakeup);
@@ -114,7 +131,17 @@ class DeepSleepComponent : public Component {
   bool prepare_to_sleep_();
   void deep_sleep_();
 
+#ifdef USE_BK72XX
+  bool pin_prevents_sleep_(WakeUpPinItem &pinItem) const;
+  bool get_real_pin_state_(InternalGPIOPin &pin) const { return (pin.digital_read() ^ pin.is_inverted()); }
+#endif  // USE_BK72XX
+
   optional<uint64_t> sleep_duration_;
+
+#ifdef USE_BK72XX
+  FixedVector<WakeUpPinItem> wakeup_pins_;
+#endif  // USE_BK72XX
+
 #ifdef USE_ESP32
   InternalGPIOPin *wakeup_pin_;
   WakeupPinMode wakeup_pin_mode_{WAKEUP_PIN_MODE_IGNORE};
@@ -124,8 +151,10 @@ class DeepSleepComponent : public Component {
 #endif
 
   optional<bool> touch_wakeup_;
+
   optional<WakeupCauseToRunDuration> wakeup_cause_to_run_duration_;
 #endif  // USE_ESP32
+
   optional<uint32_t> run_duration_;
   bool next_enter_deep_sleep_{false};
   bool prevent_{false};

esphome/components/dht/dht.cpp

@@ -8,17 +8,20 @@ namespace dht {
 static const char *const TAG = "dht";
 
 void DHT::setup() {
-  this->pin_->digital_write(true);
-  this->pin_->setup();
-  this->pin_->digital_write(true);
+  this->t_pin_->digital_write(true);
+  this->t_pin_->setup();
+#ifdef USE_ESP32
+  this->t_pin_->pin_mode(this->t_pin_->get_flags() | gpio::FLAG_OUTPUT | gpio::FLAG_OPEN_DRAIN);
+#endif
+  this->t_pin_->digital_write(true);
 }
 
 void DHT::dump_config() {
   ESP_LOGCONFIG(TAG, "DHT:");
-  LOG_PIN("  Pin: ", this->pin_);
+  LOG_PIN("  Pin: ", this->t_pin_);
   ESP_LOGCONFIG(TAG, "  %sModel: %s", this->is_auto_detect_ ? "Auto-detected " : "",
                 this->model_ == DHT_MODEL_DHT11 ? "DHT11" : "DHT22 or equivalent");
-  ESP_LOGCONFIG(TAG, "  Internal pull-up: %s", ONOFF(this->pin_->get_flags() & gpio::FLAG_PULLUP));
+  ESP_LOGCONFIG(TAG, "  Internal pull-up: %s", ONOFF(this->t_pin_->get_flags() & gpio::FLAG_PULLUP));
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
@@ -72,21 +75,15 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
   int8_t i = 0;
   uint8_t data[5] = {0, 0, 0, 0, 0};
 
-  this->pin_->digital_write(false);
-  this->pin_->pin_mode(gpio::FLAG_OUTPUT);
-  this->pin_->digital_write(false);
+#ifndef USE_ESP32
+  this->pin_.pin_mode(gpio::FLAG_OUTPUT);
+#endif
+  this->pin_.digital_write(false);
 
   if (this->model_ == DHT_MODEL_DHT11) {
     delayMicroseconds(18000);
   } else if (this->model_ == DHT_MODEL_SI7021) {
-#ifdef USE_ESP8266
     delayMicroseconds(500);
-    this->pin_->digital_write(true);
-    delayMicroseconds(40);
-#else
-    delayMicroseconds(400);
-    this->pin_->digital_write(true);
-#endif
   } else if (this->model_ == DHT_MODEL_DHT22_TYPE2) {
     delayMicroseconds(2000);
   } else if (this->model_ == DHT_MODEL_AM2120 || this->model_ == DHT_MODEL_AM2302) {
@@ -94,7 +91,12 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
   } else {
     delayMicroseconds(800);
   }
-  this->pin_->pin_mode(this->pin_->get_flags());
+
+#ifdef USE_ESP32
+  this->pin_.digital_write(true);
+#else
+  this->pin_.pin_mode(this->t_pin_->get_flags());
+#endif
 
   {
     InterruptLock lock;
@@ -110,7 +112,7 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
       uint32_t start_time = micros();
 
       // Wait for rising edge
-      while (!this->pin_->digital_read()) {
+      while (!this->pin_.digital_read()) {
         if (micros() - start_time > 90) {
           if (i < 0) {
             error_code = 1;  // line didn't clear
@@ -127,7 +129,7 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
       uint32_t end_time = start_time;
 
       // Wait for falling edge
-      while (this->pin_->digital_read()) {
+      while (this->pin_.digital_read()) {
         end_time = micros();
         if (end_time - start_time > 90) {
           if (i < 0) {

esphome/components/dht/dht.h

@@ -38,7 +38,10 @@ class DHT : public PollingComponent {
    */
   void set_dht_model(DHTModel model);
 
-  void set_pin(InternalGPIOPin *pin) { pin_ = pin; }
+  void set_pin(InternalGPIOPin *pin) {
+    this->t_pin_ = pin;
+    this->pin_ = pin->to_isr();
+  }
   void set_model(DHTModel model) { model_ = model; }
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
   void set_humidity_sensor(sensor::Sensor *humidity_sensor) { humidity_sensor_ = humidity_sensor; }
@@ -54,7 +57,8 @@ class DHT : public PollingComponent {
  protected:
   bool read_sensor_(float *temperature, float *humidity, bool report_errors);
 
-  InternalGPIOPin *pin_;
+  InternalGPIOPin *t_pin_;
+  ISRInternalGPIOPin pin_;
   DHTModel model_{DHT_MODEL_AUTO_DETECT};
   bool is_auto_detect_{false};
   sensor::Sensor *temperature_sensor_{nullptr};

esphome/components/display/__init__.py

@@ -63,11 +63,13 @@ def validate_auto_clear(value):
     return cv.boolean(value)
 
 
-BASIC_DISPLAY_SCHEMA = cv.Schema(
-    {
-        cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
-    }
-).extend(cv.polling_component_schema("1s"))
+def basic_display_schema(default_update_interval: str = "1s") -> cv.Schema:
+    """Create a basic display schema with configurable default update interval."""
+    return cv.Schema(
+        {
+            cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
+        }
+    ).extend(cv.polling_component_schema(default_update_interval))
 
 
 def _validate_test_card(config):
@@ -81,34 +83,41 @@ def _validate_test_card(config):
     return config
 
 
-FULL_DISPLAY_SCHEMA = BASIC_DISPLAY_SCHEMA.extend(
-    {
-        cv.Optional(CONF_ROTATION): validate_rotation,
-        cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
-            cv.ensure_list(
+def full_display_schema(default_update_interval: str = "1s") -> cv.Schema:
+    """Create a full display schema with configurable default update interval."""
+    schema = basic_display_schema(default_update_interval).extend(
+        {
+            cv.Optional(CONF_ROTATION): validate_rotation,
+            cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
+                cv.ensure_list(
+                    {
+                        cv.GenerateID(): cv.declare_id(DisplayPage),
+                        cv.Required(CONF_LAMBDA): cv.lambda_,
+                    }
+                ),
+                cv.Length(min=1),
+            ),
+            cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
                 {
-                    cv.GenerateID(): cv.declare_id(DisplayPage),
-                    cv.Required(CONF_LAMBDA): cv.lambda_,
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        DisplayOnPageChangeTrigger
+                    ),
+                    cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
+                    cv.Optional(CONF_TO): cv.use_id(DisplayPage),
                 }
             ),
-            cv.Length(min=1),
-        ),
-        cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                    DisplayOnPageChangeTrigger
-                ),
-                cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
-                cv.Optional(CONF_TO): cv.use_id(DisplayPage),
-            }
-        ),
-        cv.Optional(
-            CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
-        ): validate_auto_clear,
-        cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
-    }
-)
-FULL_DISPLAY_SCHEMA.add_extra(_validate_test_card)
+            cv.Optional(
+                CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
+            ): validate_auto_clear,
+            cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
+        }
+    )
+    schema.add_extra(_validate_test_card)
+    return schema
+
+
+BASIC_DISPLAY_SCHEMA = basic_display_schema("1s")
+FULL_DISPLAY_SCHEMA = full_display_schema("1s")
 
 
 async def setup_display_core_(var, config):

esphome/components/display_menu_base/menu_item.cpp

@@ -54,6 +54,7 @@ bool MenuItemSelect::select_next() {
 
   if (this->select_var_ != nullptr) {
     this->select_var_->make_call().select_next(true).perform();
+    this->on_value_();
     changed = true;
   }
 
@@ -65,6 +66,7 @@ bool MenuItemSelect::select_prev() {
 
   if (this->select_var_ != nullptr) {
     this->select_var_->make_call().select_previous(true).perform();
+    this->on_value_();
     changed = true;
   }
 

esphome/components/ee895/ee895.cpp

@@ -7,6 +7,9 @@ namespace ee895 {
 
 static const char *const TAG = "ee895";
 
+// Serial number is 16 bytes
+static constexpr size_t EE895_SERIAL_NUMBER_SIZE = 16;
+
 static const uint16_t CRC16_ONEWIRE_START = 0xFFFF;
 static const uint8_t FUNCTION_CODE_READ = 0x03;
 static const uint16_t SERIAL_NUMBER = 0x0000;
@@ -26,7 +29,10 @@ void EE895Component::setup() {
     this->mark_failed();
     return;
   }
-  ESP_LOGV(TAG, "    Serial Number: 0x%s", format_hex(serial_number + 2, 16).c_str());
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  char serial_hex[format_hex_size(EE895_SERIAL_NUMBER_SIZE)];
+#endif
+  ESP_LOGV(TAG, "    Serial Number: 0x%s", format_hex_to(serial_hex, serial_number + 2, EE895_SERIAL_NUMBER_SIZE));
 }
 
 void EE895Component::dump_config() {

esphome/components/epaper_spi/display.py

@@ -31,6 +31,7 @@ from esphome.const import (
     CONF_TRANSFORM,
     CONF_UPDATE_INTERVAL,
     CONF_WIDTH,
+    SCHEDULER_DONT_RUN,
 )
 from esphome.cpp_generator import RawExpression
 from esphome.final_validate import full_config
@@ -72,12 +73,10 @@ TRANSFORM_OPTIONS = {CONF_MIRROR_X, CONF_MIRROR_Y, CONF_SWAP_XY}
 def model_schema(config):
     model = MODELS[config[CONF_MODEL]]
     class_name = epaper_spi_ns.class_(model.class_name, EPaperBase)
-    minimum_update_interval = update_interval(
-        model.get_default(CONF_MINIMUM_UPDATE_INTERVAL, "1s")
-    )
     cv_dimensions = cv.Optional if model.get_default(CONF_WIDTH) else cv.Required
     return (
-        display.FULL_DISPLAY_SCHEMA.extend(
+        display.full_display_schema("60s")
+        .extend(
             spi.spi_device_schema(
                 cs_pin_required=False,
                 default_mode="MODE0",
@@ -94,9 +93,6 @@ def model_schema(config):
             {
                 cv.Optional(CONF_ROTATION, default=0): validate_rotation,
                 cv.Required(CONF_MODEL): cv.one_of(model.name, upper=True),
-                cv.Optional(CONF_UPDATE_INTERVAL, default=cv.UNDEFINED): cv.All(
-                    update_interval, cv.Range(min=minimum_update_interval)
-                ),
                 cv.Optional(CONF_TRANSFORM): cv.Schema(
                     {
                         cv.Required(CONF_MIRROR_X): cv.boolean,
@@ -150,15 +146,22 @@ def _final_validate(config):
     global_config = full_config.get()
     from esphome.components.lvgl import DOMAIN as LVGL_DOMAIN
 
-    if CONF_LAMBDA not in config and CONF_PAGES not in config:
-        if LVGL_DOMAIN in global_config:
-            if CONF_UPDATE_INTERVAL not in config:
-                config[CONF_UPDATE_INTERVAL] = update_interval("never")
-        else:
-            # If no drawing methods are configured, and LVGL is not enabled, show a test card
-            config[CONF_SHOW_TEST_CARD] = True
-    elif CONF_UPDATE_INTERVAL not in config:
-        config[CONF_UPDATE_INTERVAL] = update_interval("1min")
+    # If no drawing methods are configured, and LVGL is not enabled, show a test card
+    if (
+        CONF_LAMBDA not in config
+        and CONF_PAGES not in config
+        and LVGL_DOMAIN not in global_config
+    ):
+        config[CONF_SHOW_TEST_CARD] = True
+
+    interval = config[CONF_UPDATE_INTERVAL]
+    if interval != SCHEDULER_DONT_RUN:
+        model = MODELS[config[CONF_MODEL]]
+        minimum = update_interval(model.get_default(CONF_MINIMUM_UPDATE_INTERVAL, "1s"))
+        if interval < minimum:
+            raise cv.Invalid(
+                f"update_interval must be at least {minimum} for {model.name}, got {interval}"
+            )
     return config
 
 

esphome/components/epaper_spi/epaper_spi.cpp

@@ -7,6 +7,7 @@
 namespace esphome::epaper_spi {
 
 static const char *const TAG = "epaper_spi";
+static constexpr size_t EPAPER_MAX_CMD_LOG_BYTES = 128;
 
 static constexpr const char *const EPAPER_STATE_STRINGS[] = {
     "IDLE",          "UPDATE",   "RESET",          "RESET_END", "SHOULD_WAIT", "INITIALISE",
@@ -68,8 +69,11 @@ void EPaperBase::data(uint8_t value) {
 // The command is the first byte, length is the length of data only in the second byte, followed by the data.
 // [COMMAND, LENGTH, DATA...]
 void EPaperBase::cmd_data(uint8_t command, const uint8_t *ptr, size_t length) {
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  char hex_buf[format_hex_pretty_size(EPAPER_MAX_CMD_LOG_BYTES)];
   ESP_LOGV(TAG, "Command: 0x%02X, Length: %d, Data: %s", command, length,
-           format_hex_pretty(ptr, length, '.', false).c_str());
+           format_hex_pretty_to(hex_buf, ptr, length, '.'));
+#endif
 
   this->dc_pin_->digital_write(false);
   this->enable();

esphome/components/esp32/__init__.py

@@ -4,6 +4,7 @@ import itertools
 import logging
 import os
 from pathlib import Path
+import re
 
 from esphome import yaml_util
 import esphome.codegen as cg
@@ -12,6 +13,7 @@ from esphome.const import (
     CONF_ADVANCED,
     CONF_BOARD,
     CONF_COMPONENTS,
+    CONF_DISABLED,
     CONF_ESPHOME,
     CONF_FRAMEWORK,
     CONF_IGNORE_EFUSE_CUSTOM_MAC,
@@ -23,6 +25,7 @@ from esphome.const import (
     CONF_PLATFORMIO_OPTIONS,
     CONF_REF,
     CONF_REFRESH,
+    CONF_SAFE_MODE,
     CONF_SOURCE,
     CONF_TYPE,
     CONF_VARIANT,
@@ -80,7 +83,9 @@ CONF_ASSERTION_LEVEL = "assertion_level"
 CONF_COMPILER_OPTIMIZATION = "compiler_optimization"
 CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES = "enable_idf_experimental_features"
 CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
+CONF_ENABLE_OTA_ROLLBACK = "enable_ota_rollback"
 CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
+CONF_MINIMUM_CHIP_REVISION = "minimum_chip_revision"
 CONF_RELEASE = "release"
 
 LOG_LEVELS_IDF = [
@@ -105,6 +110,21 @@ COMPILER_OPTIMIZATIONS = {
     "SIZE": "CONFIG_COMPILER_OPTIMIZATION_SIZE",
 }
 
+# ESP32 (original) chip revision options
+# Setting minimum revision to 3.0 or higher:
+# - Reduces flash size by excluding workaround code for older chip bugs
+# - For PSRAM users: disables CONFIG_SPIRAM_CACHE_WORKAROUND, which saves significant
+#   IRAM by keeping C library functions in ROM instead of recompiling them
+# See: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/chip_revision.html
+ESP32_CHIP_REVISIONS = {
+    "0.0": "CONFIG_ESP32_REV_MIN_0",
+    "1.0": "CONFIG_ESP32_REV_MIN_1",
+    "1.1": "CONFIG_ESP32_REV_MIN_1_1",
+    "2.0": "CONFIG_ESP32_REV_MIN_2",
+    "3.0": "CONFIG_ESP32_REV_MIN_3",
+    "3.1": "CONFIG_ESP32_REV_MIN_3_1",
+}
+
 # Socket limit configuration for ESP-IDF
 # ESP-IDF CONFIG_LWIP_MAX_SOCKETS has range 1-253, default 10
 DEFAULT_MAX_SOCKETS = 10  # ESP-IDF default
@@ -117,8 +137,8 @@ ARDUINO_ALLOWED_VARIANTS = [
 ]
 
 
-def get_cpu_frequencies(*frequencies):
-    return [str(x) + "MHZ" for x in frequencies]
+def get_cpu_frequencies(*frequencies: int) -> list[str]:
+    return [f"{frequency}MHZ" for frequency in frequencies]
 
 
 CPU_FREQUENCIES = {
@@ -135,7 +155,7 @@ CPU_FREQUENCIES = {
 }
 
 # Make sure not missed here if a new variant added.
-assert all(v in CPU_FREQUENCIES for v in VARIANTS)
+assert all(variant in CPU_FREQUENCIES for variant in VARIANTS)
 
 FULL_CPU_FREQUENCIES = set(itertools.chain.from_iterable(CPU_FREQUENCIES.values()))
 
@@ -249,10 +269,10 @@ def add_idf_sdkconfig_option(name: str, value: SdkconfigValueType):
 def add_idf_component(
     *,
     name: str,
-    repo: str = None,
-    ref: str = None,
-    path: str = None,
-    refresh: TimePeriod = None,
+    repo: str | None = None,
+    ref: str | None = None,
+    path: str | None = None,
+    refresh: TimePeriod | None = None,
     components: list[str] | None = None,
     submodules: list[str] | None = None,
 ):
@@ -333,7 +353,7 @@ def _format_framework_espidf_version(ver: cv.Version, release: str) -> str:
     return f"pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v{str(ver)}/esp-idf-v{str(ver)}.{ext}"
 
 
-def _is_framework_url(source: str) -> str:
+def _is_framework_url(source: str) -> bool:
     # platformio accepts many URL schemes for framework repositories and archives including http, https, git, file, and symlink
     import urllib.parse
 
@@ -353,11 +373,12 @@ def _is_framework_url(source: str) -> str:
 # The default/recommended arduino framework version
 #  - 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),
+    "recommended": cv.Version(3, 3, 5),
+    "latest": cv.Version(3, 3, 5),
+    "dev": cv.Version(3, 3, 5),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
+    cv.Version(3, 3, 5): cv.Version(55, 3, 35),
     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"),
@@ -370,15 +391,33 @@ ARDUINO_PLATFORM_VERSION_LOOKUP = {
     cv.Version(3, 1, 1): cv.Version(53, 3, 11),
     cv.Version(3, 1, 0): cv.Version(53, 3, 10),
 }
+# Maps Arduino framework versions to a compatible ESP-IDF version
+# These versions correspond to pioarduino/esp-idf releases
+# See: https://github.com/pioarduino/esp-idf/releases
+ARDUINO_IDF_VERSION_LOOKUP = {
+    cv.Version(3, 3, 5): cv.Version(5, 5, 2),
+    cv.Version(3, 3, 4): cv.Version(5, 5, 1),
+    cv.Version(3, 3, 3): cv.Version(5, 5, 1),
+    cv.Version(3, 3, 2): cv.Version(5, 5, 1),
+    cv.Version(3, 3, 1): cv.Version(5, 5, 1),
+    cv.Version(3, 3, 0): cv.Version(5, 5, 0),
+    cv.Version(3, 2, 1): cv.Version(5, 4, 2),
+    cv.Version(3, 2, 0): cv.Version(5, 4, 2),
+    cv.Version(3, 1, 3): cv.Version(5, 3, 2),
+    cv.Version(3, 1, 2): cv.Version(5, 3, 2),
+    cv.Version(3, 1, 1): cv.Version(5, 3, 1),
+    cv.Version(3, 1, 0): cv.Version(5, 3, 0),
+}
 
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
 ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
-    "recommended": cv.Version(5, 5, 1),
-    "latest": cv.Version(5, 5, 1),
-    "dev": cv.Version(5, 5, 1),
+    "recommended": cv.Version(5, 5, 2),
+    "latest": cv.Version(5, 5, 2),
+    "dev": cv.Version(5, 5, 2),
 }
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
+    cv.Version(5, 5, 2): cv.Version(55, 3, 35),
     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, 4, 3): cv.Version(55, 3, 32),
@@ -395,9 +434,9 @@ 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, 35),
+    "latest": cv.Version(55, 3, 35),
+    "dev": cv.Version(55, 3, 35),
 }
 
 
@@ -543,6 +582,16 @@ def final_validate(config):
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_IGNORE_EFUSE_MAC_CRC],
             )
         )
+    if (
+        config[CONF_VARIANT] != VARIANT_ESP32
+        and advanced.get(CONF_MINIMUM_CHIP_REVISION) is not None
+    ):
+        errs.append(
+            cv.Invalid(
+                f"'{CONF_MINIMUM_CHIP_REVISION}' is only supported on {VARIANT_ESP32}",
+                path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_MINIMUM_CHIP_REVISION],
+            )
+        )
     if advanced[CONF_EXECUTE_FROM_PSRAM]:
         if config[CONF_VARIANT] != VARIANT_ESP32S3:
             errs.append(
@@ -570,6 +619,13 @@ def final_validate(config):
                 path=[CONF_FLASH_SIZE],
             )
         )
+    if advanced[CONF_ENABLE_OTA_ROLLBACK]:
+        safe_mode_config = full_config.get(CONF_SAFE_MODE)
+        if safe_mode_config is None or safe_mode_config.get(CONF_DISABLED, False):
+            _LOGGER.warning(
+                "OTA rollback requires safe_mode, disabling rollback support"
+            )
+            advanced[CONF_ENABLE_OTA_ROLLBACK] = False
     if errs:
         raise cv.MultipleInvalid(errs)
 
@@ -630,10 +686,13 @@ def enable_ringbuf_in_iram() -> None:
 
 def _parse_idf_component(value: str) -> ConfigType:
     """Parse IDF component shorthand syntax like 'owner/component^version'"""
-    if "^" not in value:
-        raise cv.Invalid(f"Invalid IDF component shorthand '{value}'")
-    name, ref = value.split("^", 1)
-    return {CONF_NAME: name, CONF_REF: ref}
+    # Match operator followed by version-like string (digit or *)
+    if match := re.search(r"(~=|>=|<=|==|!=|>|<|\^|~)(\d|\*)", value):
+        return {CONF_NAME: value[: match.start()], CONF_REF: value[match.start() :]}
+    raise cv.Invalid(
+        f"Invalid IDF component shorthand '{value}'. "
+        f"Expected format: 'owner/component<op>version' where <op> is one of: ^, ~, ~=, ==, !=, >=, >, <=, <"
+    )
 
 
 def _validate_idf_component(config: ConfigType) -> ConfigType:
@@ -675,6 +734,9 @@ FRAMEWORK_SCHEMA = cv.Schema(
                 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,
+                cv.Optional(CONF_MINIMUM_CHIP_REVISION): cv.one_of(
+                    *ESP32_CHIP_REVISIONS
+                ),
                 # 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.
@@ -701,6 +763,7 @@ FRAMEWORK_SCHEMA = cv.Schema(
                 cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
                     min=8192, max=32768
                 ),
+                cv.Optional(CONF_ENABLE_OTA_ROLLBACK, default=True): cv.boolean,
             }
         ),
         cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -726,12 +789,14 @@ FRAMEWORK_SCHEMA = cv.Schema(
 )
 
 
+# Remove this class in 2026.7.0
 class _FrameworkMigrationWarning:
     shown = False
 
 
 def _show_framework_migration_message(name: str, variant: str) -> None:
-    """Show a friendly message about framework migration when defaulting to Arduino."""
+    """Show a message about the framework default change and how to switch back to Arduino."""
+    # Remove this function in 2026.7.0
     if _FrameworkMigrationWarning.shown:
         return
     _FrameworkMigrationWarning.shown = True
@@ -741,41 +806,27 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
     message = (
         color(
             AnsiFore.BOLD_CYAN,
-            f"💡 IMPORTANT: {name} doesn't have a framework specified!",
+            f"💡 NOTICE: {name} does not have a framework specified.",
         )
         + "\n\n"
-        + f"Currently, {variant} defaults to the Arduino framework.\n"
-        + color(AnsiFore.YELLOW, "This will change to ESP-IDF in ESPHome 2026.1.0.\n")
+        + f"Starting with ESPHome 2026.1.0, the default framework for {variant} is ESP-IDF.\n"
+        + "(We've been warning about this change since ESPHome 2025.8.0)\n"
         + "\n"
-        + "Note: Newer ESP32 variants (C6, H2, P4, etc.) already use ESP-IDF by default.\n"
-        + "\n"
-        + "Why change? ESP-IDF offers:\n"
-        + color(AnsiFore.GREEN, "  ✨ Up to 40% smaller binaries\n")
-        + color(AnsiFore.GREEN, "  🚀 Better performance and optimization\n")
+        + "Why we made this change:\n"
+        + color(AnsiFore.GREEN, "  ✨ Up to 40% smaller firmware binaries\n")
         + color(AnsiFore.GREEN, "  ⚡ 2-3x faster compile times\n")
-        + color(AnsiFore.GREEN, "  📦 Custom-built firmware for your exact needs\n")
-        + color(
-            AnsiFore.GREEN,
-            "  🔧 Active development and testing by ESPHome developers\n",
-        )
+        + color(AnsiFore.GREEN, "  🚀 Better performance and newer features\n")
+        + color(AnsiFore.GREEN, "  🔧 More actively maintained by ESPHome\n")
         + "\n"
-        + "Trade-offs:\n"
-        + color(AnsiFore.YELLOW, "  🔄 Some components need migration\n")
+        + "To continue using Arduino, add this to your YAML under 'esp32:':\n"
+        + color(AnsiFore.WHITE, "    framework:\n")
+        + color(AnsiFore.WHITE, "      type: arduino\n")
         + "\n"
-        + "What should I do?\n"
-        + color(AnsiFore.CYAN, "  Option 1")
-        + ": Migrate to ESP-IDF (recommended)\n"
-        + "    Add this to your YAML under 'esp32:':\n"
-        + color(AnsiFore.WHITE, "      framework:\n")
-        + color(AnsiFore.WHITE, "        type: esp-idf\n")
+        + "To silence this message with ESP-IDF, explicitly set:\n"
+        + color(AnsiFore.WHITE, "    framework:\n")
+        + color(AnsiFore.WHITE, "      type: esp-idf\n")
         + "\n"
-        + color(AnsiFore.CYAN, "  Option 2")
-        + ": Keep using Arduino (still supported)\n"
-        + "    Add this to your YAML under 'esp32:':\n"
-        + color(AnsiFore.WHITE, "      framework:\n")
-        + color(AnsiFore.WHITE, "        type: arduino\n")
-        + "\n"
-        + "Need help? Check out the migration guide:\n"
+        + "Migration guide: "
         + color(
             AnsiFore.BLUE,
             "https://esphome.io/guides/esp32_arduino_to_idf/",
@@ -790,13 +841,13 @@ def _set_default_framework(config):
         config[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
     if CONF_TYPE not in config[CONF_FRAMEWORK]:
         variant = config[CONF_VARIANT]
+        config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ESP_IDF
+        # Show migration message for variants that previously defaulted to Arduino
+        # Remove this message in 2026.7.0
         if variant in ARDUINO_ALLOWED_VARIANTS:
-            config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ARDUINO
             _show_framework_migration_message(
                 config.get(CONF_NAME, "This device"), variant
             )
-        else:
-            config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ESP_IDF
 
     return config
 
@@ -981,29 +1032,21 @@ async def to_code(config):
         cg.add_platformio_option("framework", "arduino, espidf")
         cg.add_build_flag("-DUSE_ARDUINO")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ARDUINO")
-        cg.add_platformio_option(
-            "board_build.embed_txtfiles",
-            [
-                "managed_components/espressif__esp_insights/server_certs/https_server.crt",
-                "managed_components/espressif__esp_rainmaker/server_certs/rmaker_mqtt_server.crt",
-                "managed_components/espressif__esp_rainmaker/server_certs/rmaker_claim_service_server.crt",
-                "managed_components/espressif__esp_rainmaker/server_certs/rmaker_ota_server.crt",
-            ],
-        )
         cg.add_define(
             "USE_ARDUINO_VERSION_CODE",
             cg.RawExpression(
                 f"VERSION_CODE({framework_ver.major}, {framework_ver.minor}, {framework_ver.patch})"
             ),
         )
-        add_idf_sdkconfig_option(
-            "CONFIG_ARDUINO_LOOP_STACK_SIZE",
-            conf[CONF_ADVANCED][CONF_LOOP_TASK_STACK_SIZE],
-        )
-        add_idf_sdkconfig_option("CONFIG_AUTOSTART_ARDUINO", True)
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_PSK_MODES", True)
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)
-        add_idf_sdkconfig_option("CONFIG_ESP_PHY_REDUCE_TX_POWER", True)
+
+        # Add IDF framework source for Arduino builds to ensure it uses the same version as
+        # the ESP-IDF framework
+        if (idf_ver := ARDUINO_IDF_VERSION_LOOKUP.get(framework_ver)) is not None:
+            cg.add_platformio_option(
+                "platform_packages", [_format_framework_espidf_version(idf_ver, None)]
+            )
 
         # ESP32-S2 Arduino: Disable USB Serial on boot to avoid TinyUSB dependency
         if get_esp32_variant() == VARIANT_ESP32S2:
@@ -1017,6 +1060,16 @@ async def to_code(config):
     add_idf_sdkconfig_option(
         f"CONFIG_ESPTOOLPY_FLASHSIZE_{config[CONF_FLASH_SIZE]}", True
     )
+
+    # Set minimum chip revision for ESP32 variant
+    # Setting this to 3.0 or higher reduces flash size by excluding workaround code,
+    # and for PSRAM users saves significant IRAM by keeping C library functions in ROM.
+    if variant == VARIANT_ESP32:
+        min_rev = conf[CONF_ADVANCED].get(CONF_MINIMUM_CHIP_REVISION)
+        if min_rev is not None:
+            for rev, flag in ESP32_CHIP_REVISIONS.items():
+                add_idf_sdkconfig_option(flag, rev == min_rev)
+            cg.add_define("USE_ESP32_MIN_CHIP_REVISION_SET")
     add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_SINGLE_APP", False)
     add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM", True)
     add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM_FILENAME", "partitions.csv")
@@ -1178,6 +1231,11 @@ async def to_code(config):
                 "CONFIG_BOOTLOADER_CACHE_32BIT_ADDR_QUAD_FLASH", True
             )
 
+    # Enable OTA rollback support
+    if advanced[CONF_ENABLE_OTA_ROLLBACK]:
+        add_idf_sdkconfig_option("CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE", True)
+        cg.add_define("USE_OTA_ROLLBACK")
+
     cg.add_define("ESPHOME_LOOP_TASK_STACK_SIZE", advanced[CONF_LOOP_TASK_STACK_SIZE])
 
     cg.add_define(
@@ -1207,7 +1265,7 @@ APP_PARTITION_SIZES = {
 }
 
 
-def get_arduino_partition_csv(flash_size):
+def get_arduino_partition_csv(flash_size: str):
     app_partition_size = APP_PARTITION_SIZES[flash_size]
     eeprom_partition_size = 0x1000  # 4 KB
     spiffs_partition_size = 0xF000  # 60 KB
@@ -1227,7 +1285,7 @@ spiffs,   data, spiffs,  0x{spiffs_partition_start:X}, 0x{spiffs_partition_size:
 """
 
 
-def get_idf_partition_csv(flash_size):
+def get_idf_partition_csv(flash_size: str):
     app_partition_size = APP_PARTITION_SIZES[flash_size]
 
     return f"""\

esphome/components/esp32/boards.py

@@ -1488,6 +1488,10 @@ BOARDS = {
         "name": "Arduino Nano ESP32",
         "variant": VARIANT_ESP32S3,
     },
+    "arduino_nesso_n1": {
+        "name": "Arduino Nesso-N1",
+        "variant": VARIANT_ESP32C6,
+    },
     "atd147_s3": {
         "name": "ArtronShop ATD1.47-S3",
         "variant": VARIANT_ESP32S3,
@@ -1656,6 +1660,10 @@ BOARDS = {
         "name": "Espressif ESP32-C6-DevKitM-1",
         "variant": VARIANT_ESP32C6,
     },
+    "esp32-c61-devkitc1-n8r2": {
+        "name": "Espressif ESP32-C61-DevKitC-1 N8R2 (8 MB Flash Quad, 2 MB PSRAM Quad)",
+        "variant": VARIANT_ESP32C61,
+    },
     "esp32-devkitlipo": {
         "name": "OLIMEX ESP32-DevKit-LiPo",
         "variant": VARIANT_ESP32,
@@ -1673,11 +1681,15 @@ BOARDS = {
         "variant": VARIANT_ESP32H2,
     },
     "esp32-p4": {
-        "name": "Espressif ESP32-P4 generic",
+        "name": "Espressif ESP32-P4 ES (pre rev.300) generic",
         "variant": VARIANT_ESP32P4,
     },
     "esp32-p4-evboard": {
-        "name": "Espressif ESP32-P4 Function EV Board",
+        "name": "Espressif ESP32-P4 Function EV Board (ES pre rev.300)",
+        "variant": VARIANT_ESP32P4,
+    },
+    "esp32-p4_r3": {
+        "name": "Espressif ESP32-P4 rev.300 generic",
         "variant": VARIANT_ESP32P4,
     },
     "esp32-pico-devkitm-2": {
@@ -2093,7 +2105,7 @@ BOARDS = {
         "variant": VARIANT_ESP32,
     },
     "m5stack-tab5-p4": {
-        "name": "M5STACK Tab5 esp32-p4 Board",
+        "name": "M5STACK Tab5 esp32-p4 Board (ES pre rev.300)",
         "variant": VARIANT_ESP32P4,
     },
     "m5stack-timer-cam": {

esphome/components/esp32/core.cpp

@@ -4,25 +4,20 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "preferences.h"
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
+#include <esp_clk_tree.h>
+#include <esp_cpu.h>
 #include <esp_idf_version.h>
 #include <esp_ota_ops.h>
 #include <esp_task_wdt.h>
 #include <esp_timer.h>
-#include <soc/rtc.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 
-#include <hal/cpu_hal.h>
+void setup();  // NOLINT(readability-redundant-declaration)
+void loop();   // NOLINT(readability-redundant-declaration)
 
-#ifdef USE_ARDUINO
-#include <Esp.h>
-#else
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
-#include <esp_clk_tree.h>
-#endif
-void setup();
-void loop();
-#endif
+// Weak stub for initArduino - overridden when the Arduino component is present
+extern "C" __attribute__((weak)) void initArduino() {}
 
 namespace esphome {
 
@@ -41,29 +36,13 @@ void arch_restart() {
 
 void arch_init() {
   // Enable the task watchdog only on the loop task (from which we're currently running)
-#if defined(USE_ESP_IDF)
   esp_task_wdt_add(nullptr);
-  // Idle task watchdog is disabled on ESP-IDF
-#elif defined(USE_ARDUINO)
-  enableLoopWDT();
-  // Disable idle task watchdog on the core we're using (Arduino pins the task to a core)
-#if defined(CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0) && CONFIG_ARDUINO_RUNNING_CORE == 0
-  disableCore0WDT();
-#endif
-#if defined(CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1) && CONFIG_ARDUINO_RUNNING_CORE == 1
-  disableCore1WDT();
-#endif
-#endif
 
-  // If the bootloader was compiled with CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE the current
-  // partition will get rolled back unless it is marked as valid.
-  esp_ota_img_states_t state;
-  const esp_partition_t *running = esp_ota_get_running_partition();
-  if (esp_ota_get_state_partition(running, &state) == ESP_OK) {
-    if (state == ESP_OTA_IMG_PENDING_VERIFY) {
-      esp_ota_mark_app_valid_cancel_rollback();
-    }
-  }
+  // Handle OTA rollback: mark partition valid immediately unless USE_OTA_ROLLBACK is enabled,
+  // in which case safe_mode will mark it valid after confirming successful boot.
+#ifndef USE_OTA_ROLLBACK
+  esp_ota_mark_app_valid_cancel_rollback();
+#endif
 }
 void IRAM_ATTR HOT arch_feed_wdt() { esp_task_wdt_reset(); }
 
@@ -71,21 +50,10 @@ uint8_t progmem_read_byte(const uint8_t *addr) { return *addr; }
 uint32_t arch_get_cpu_cycle_count() { return esp_cpu_get_cycle_count(); }
 uint32_t arch_get_cpu_freq_hz() {
   uint32_t freq = 0;
-#ifdef USE_ESP_IDF
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
   esp_clk_tree_src_get_freq_hz(SOC_MOD_CLK_CPU, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &freq);
-#else
-  rtc_cpu_freq_config_t config;
-  rtc_clk_cpu_freq_get_config(&config);
-  freq = config.freq_mhz * 1000000U;
-#endif
-#elif defined(USE_ARDUINO)
-  freq = ESP.getCpuFreqMHz() * 1000000;
-#endif
   return freq;
 }
 
-#ifdef USE_ESP_IDF
 TaskHandle_t loop_task_handle = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void loop_task(void *pv_params) {
@@ -96,6 +64,7 @@ void loop_task(void *pv_params) {
 }
 
 extern "C" void app_main() {
+  initArduino();
   esp32::setup_preferences();
 #if CONFIG_FREERTOS_UNICORE
   xTaskCreate(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, &loop_task_handle);
@@ -103,11 +72,6 @@ extern "C" void app_main() {
   xTaskCreatePinnedToCore(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, &loop_task_handle, 1);
 #endif
 }
-#endif  // USE_ESP_IDF
-
-#ifdef USE_ARDUINO
-extern "C" void init() { esp32::setup_preferences(); }
-#endif  // USE_ARDUINO
 
 }  // namespace esphome
 

esphome/components/esp32/gpio.cpp

@@ -97,10 +97,8 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
   gpio_intr_enable(this->get_pin_num());
 }
 
-std::string ESP32InternalGPIOPin::dump_summary() const {
-  char buffer[32];
-  snprintf(buffer, sizeof(buffer), "GPIO%" PRIu32, static_cast<uint32_t>(this->pin_));
-  return buffer;
+size_t ESP32InternalGPIOPin::dump_summary(char *buffer, size_t len) const {
+  return snprintf(buffer, len, "GPIO%" PRIu32, static_cast<uint32_t>(this->pin_));
 }
 
 void ESP32InternalGPIOPin::setup() {

esphome/components/esp32/gpio.h

@@ -24,7 +24,7 @@ class ESP32InternalGPIOPin : public InternalGPIOPin {
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
   void digital_write(bool value) override;
-  std::string dump_summary() const override;
+  size_t dump_summary(char *buffer, size_t len) const override;
   void detach_interrupt() const override;
   ISRInternalGPIOPin to_isr() const override;
   uint8_t get_pin() const override { return this->pin_; }

esphome/components/esp32/post_build.py.script

@@ -5,6 +5,7 @@ import json  # noqa: E402
 import os  # noqa: E402
 import pathlib  # noqa: E402
 import shutil  # noqa: E402
+from glob import glob  # noqa: E402
 
 
 def merge_factory_bin(source, target, env):
@@ -126,3 +127,14 @@ def esp32_copy_ota_bin(source, target, env):
 # Run merge first, then ota copy second
 env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", merge_factory_bin)  # noqa: F821
 env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", esp32_copy_ota_bin)  # noqa: F821
+
+# Find server certificates in managed components and generate .S files.
+# Workaround for PlatformIO not processing target_add_binary_data() from managed component CMakeLists.
+project_dir = env.subst("$PROJECT_DIR")
+managed_components = os.path.join(project_dir, "managed_components")
+if os.path.isdir(managed_components):
+    for cert_file in glob(os.path.join(managed_components, "**/server_certs/*.crt"), recursive=True):
+        try:
+            env.FileToAsm(cert_file, FILE_TYPE="TEXT")
+        except Exception as e:
+            print(f"Error processing {os.path.basename(cert_file)}: {e}")

esphome/components/esp32/preferences.cpp

@@ -4,26 +4,28 @@
 #include "esphome/core/log.h"
 #include "esphome/core/preferences.h"
 #include <nvs_flash.h>
-#include <cstring>
 #include <cinttypes>
-#include <vector>
-#include <string>
+#include <cstring>
 #include <memory>
+#include <vector>
 
 namespace esphome {
 namespace esp32 {
 
 static const char *const TAG = "esp32.preferences";
 
+// Buffer size for converting uint32_t to string: max "4294967295" (10 chars) + null terminator + 1 padding
+static constexpr size_t KEY_BUFFER_SIZE = 12;
+
 struct NVSData {
-  std::string key;
+  uint32_t key;
   std::unique_ptr<uint8_t[]> data;
   size_t len;
 
   void set_data(const uint8_t *src, size_t size) {
-    data = std::make_unique<uint8_t[]>(size);
-    memcpy(data.get(), src, size);
-    len = size;
+    this->data = std::make_unique<uint8_t[]>(size);
+    memcpy(this->data.get(), src, size);
+    this->len = size;
   }
 };
 
@@ -31,27 +33,27 @@ static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-n
 
 class ESP32PreferenceBackend : public ESPPreferenceBackend {
  public:
-  std::string key;
+  uint32_t key;
   uint32_t nvs_handle;
   bool save(const uint8_t *data, size_t len) override {
     // try find in pending saves and update that
     for (auto &obj : s_pending_save) {
-      if (obj.key == key) {
+      if (obj.key == this->key) {
         obj.set_data(data, len);
         return true;
       }
     }
     NVSData save{};
-    save.key = key;
+    save.key = this->key;
     save.set_data(data, len);
     s_pending_save.emplace_back(std::move(save));
-    ESP_LOGVV(TAG, "s_pending_save: key: %s, len: %zu", key.c_str(), len);
+    ESP_LOGVV(TAG, "s_pending_save: key: %" PRIu32 ", len: %zu", this->key, len);
     return true;
   }
   bool load(uint8_t *data, size_t len) override {
     // try find in pending saves and load from that
     for (auto &obj : s_pending_save) {
-      if (obj.key == key) {
+      if (obj.key == this->key) {
         if (obj.len != len) {
           // size mismatch
           return false;
@@ -61,22 +63,24 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
       }
     }
 
+    char key_str[KEY_BUFFER_SIZE];
+    snprintf(key_str, sizeof(key_str), "%" PRIu32, this->key);
     size_t actual_len;
-    esp_err_t err = nvs_get_blob(nvs_handle, key.c_str(), nullptr, &actual_len);
+    esp_err_t err = nvs_get_blob(this->nvs_handle, key_str, nullptr, &actual_len);
     if (err != 0) {
-      ESP_LOGV(TAG, "nvs_get_blob('%s'): %s - the key might not be set yet", key.c_str(), esp_err_to_name(err));
+      ESP_LOGV(TAG, "nvs_get_blob('%s'): %s - the key might not be set yet", key_str, esp_err_to_name(err));
       return false;
     }
     if (actual_len != len) {
       ESP_LOGVV(TAG, "NVS length does not match (%zu!=%zu)", actual_len, len);
       return false;
     }
-    err = nvs_get_blob(nvs_handle, key.c_str(), data, &len);
+    err = nvs_get_blob(this->nvs_handle, key_str, data, &len);
     if (err != 0) {
-      ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", key.c_str(), esp_err_to_name(err));
+      ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", key_str, esp_err_to_name(err));
       return false;
     } else {
-      ESP_LOGVV(TAG, "nvs_get_blob: key: %s, len: %zu", key.c_str(), len);
+      ESP_LOGVV(TAG, "nvs_get_blob: key: %s, len: %zu", key_str, len);
     }
     return true;
   }
@@ -103,14 +107,12 @@ class ESP32Preferences : public ESPPreferences {
     }
   }
   ESPPreferenceObject make_preference(size_t length, uint32_t type, bool in_flash) override {
-    return make_preference(length, type);
+    return this->make_preference(length, type);
   }
   ESPPreferenceObject make_preference(size_t length, uint32_t type) override {
     auto *pref = new ESP32PreferenceBackend();  // NOLINT(cppcoreguidelines-owning-memory)
-    pref->nvs_handle = nvs_handle;
-
-    uint32_t keyval = type;
-    pref->key = str_sprintf("%" PRIu32, keyval);
+    pref->nvs_handle = this->nvs_handle;
+    pref->key = type;
 
     return ESPPreferenceObject(pref);
   }
@@ -123,17 +125,19 @@ class ESP32Preferences : public ESPPreferences {
     // goal try write all pending saves even if one fails
     int cached = 0, written = 0, failed = 0;
     esp_err_t last_err = ESP_OK;
-    std::string last_key{};
+    uint32_t last_key = 0;
 
     // go through vector from back to front (makes erase easier/more efficient)
     for (ssize_t i = s_pending_save.size() - 1; i >= 0; i--) {
       const auto &save = s_pending_save[i];
-      ESP_LOGVV(TAG, "Checking if NVS data %s has changed", save.key.c_str());
-      if (is_changed(nvs_handle, save)) {
-        esp_err_t err = nvs_set_blob(nvs_handle, save.key.c_str(), save.data.get(), save.len);
-        ESP_LOGV(TAG, "sync: key: %s, len: %zu", save.key.c_str(), save.len);
+      char key_str[KEY_BUFFER_SIZE];
+      snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
+      ESP_LOGVV(TAG, "Checking if NVS data %s has changed", key_str);
+      if (this->is_changed_(this->nvs_handle, save, key_str)) {
+        esp_err_t err = nvs_set_blob(this->nvs_handle, key_str, save.data.get(), save.len);
+        ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.len);
         if (err != 0) {
-          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%zu) failed: %s", save.key.c_str(), save.len, esp_err_to_name(err));
+          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%zu) failed: %s", key_str, save.len, esp_err_to_name(err));
           failed++;
           last_err = err;
           last_key = save.key;
@@ -141,7 +145,7 @@ class ESP32Preferences : public ESPPreferences {
         }
         written++;
       } else {
-        ESP_LOGV(TAG, "NVS data not changed skipping %s  len=%zu", save.key.c_str(), save.len);
+        ESP_LOGV(TAG, "NVS data not changed skipping %" PRIu32 "  len=%zu", save.key, save.len);
         cached++;
       }
       s_pending_save.erase(s_pending_save.begin() + i);
@@ -149,12 +153,12 @@ class ESP32Preferences : public ESPPreferences {
     ESP_LOGD(TAG, "Writing %d items: %d cached, %d written, %d failed", cached + written + failed, cached, written,
              failed);
     if (failed > 0) {
-      ESP_LOGE(TAG, "Writing %d items failed. Last error=%s for key=%s", failed, esp_err_to_name(last_err),
-               last_key.c_str());
+      ESP_LOGE(TAG, "Writing %d items failed. Last error=%s for key=%" PRIu32, failed, esp_err_to_name(last_err),
+               last_key);
     }
 
     // note: commit on esp-idf currently is a no-op, nvs_set_blob always writes
-    esp_err_t err = nvs_commit(nvs_handle);
+    esp_err_t err = nvs_commit(this->nvs_handle);
     if (err != 0) {
       ESP_LOGV(TAG, "nvs_commit() failed: %s", esp_err_to_name(err));
       return false;
@@ -162,11 +166,13 @@ class ESP32Preferences : public ESPPreferences {
 
     return failed == 0;
   }
-  bool is_changed(const uint32_t nvs_handle, const NVSData &to_save) {
+
+ protected:
+  bool is_changed_(uint32_t nvs_handle, const NVSData &to_save, const char *key_str) {
     size_t actual_len;
-    esp_err_t err = nvs_get_blob(nvs_handle, to_save.key.c_str(), nullptr, &actual_len);
+    esp_err_t err = nvs_get_blob(nvs_handle, key_str, nullptr, &actual_len);
     if (err != 0) {
-      ESP_LOGV(TAG, "nvs_get_blob('%s'): %s - the key might not be set yet", to_save.key.c_str(), esp_err_to_name(err));
+      ESP_LOGV(TAG, "nvs_get_blob('%s'): %s - the key might not be set yet", key_str, esp_err_to_name(err));
       return true;
     }
     // Check size first before allocating memory
@@ -174,9 +180,9 @@ class ESP32Preferences : public ESPPreferences {
       return true;
     }
     auto stored_data = std::make_unique<uint8_t[]>(actual_len);
-    err = nvs_get_blob(nvs_handle, to_save.key.c_str(), stored_data.get(), &actual_len);
+    err = nvs_get_blob(nvs_handle, key_str, stored_data.get(), &actual_len);
     if (err != 0) {
-      ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", to_save.key.c_str(), esp_err_to_name(err));
+      ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", key_str, esp_err_to_name(err));
       return true;
     }
     return memcmp(to_save.data.get(), stored_data.get(), to_save.len) != 0;

esphome/components/esp32_ble/ble.cpp

@@ -24,7 +24,9 @@ extern "C" {
 #include <nvs_flash.h>
 
 #ifdef USE_ARDUINO
-#include <esp32-hal-bt.h>
+// Prevent Arduino from releasing BT memory at startup (esp32-hal-misc.c).
+// Without this, esp_bt_controller_init() fails with ESP_ERR_INVALID_STATE.
+extern "C" bool btInUse() { return true; }  // NOLINT(readability-identifier-naming)
 #endif
 
 namespace esphome::esp32_ble {
@@ -169,12 +171,6 @@ void ESP32BLE::advertising_init_() {
 bool ESP32BLE::ble_setup_() {
   esp_err_t err;
 #ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
-#ifdef USE_ARDUINO
-  if (!btStart()) {
-    ESP_LOGE(TAG, "btStart failed: %d", esp_bt_controller_get_status());
-    return false;
-  }
-#else
   if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_ENABLED) {
     // start bt controller
     if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_IDLE) {
@@ -199,7 +195,6 @@ bool ESP32BLE::ble_setup_() {
       return false;
     }
   }
-#endif
 
   esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT);
 #else
@@ -260,8 +255,11 @@ bool ESP32BLE::ble_setup_() {
   }
 #endif
 
+  // BLE device names are limited to 20 characters
+  // Buffer: 20 chars + null terminator
+  constexpr size_t ble_name_max_len = 21;
+  char name_buffer[ble_name_max_len];
   const char *device_name;
-  std::string name_with_suffix;
 
   if (this->name_ != nullptr) {
     if (App.is_name_add_mac_suffix_enabled()) {
@@ -272,23 +270,28 @@ bool ESP32BLE::ble_setup_() {
       char mac_addr[mac_address_len];
       get_mac_address_into_buffer(mac_addr);
       const char *mac_suffix_ptr = mac_addr + mac_address_suffix_len;
-      name_with_suffix =
-          make_name_with_suffix(this->name_, strlen(this->name_), '-', mac_suffix_ptr, mac_address_suffix_len);
-      device_name = name_with_suffix.c_str();
+      make_name_with_suffix_to(name_buffer, sizeof(name_buffer), this->name_, strlen(this->name_), '-', mac_suffix_ptr,
+                               mac_address_suffix_len);
+      device_name = name_buffer;
     } else {
       device_name = this->name_;
     }
   } else {
-    name_with_suffix = App.get_name();
-    if (name_with_suffix.length() > 20) {
+    const std::string &app_name = App.get_name();
+    size_t name_len = app_name.length();
+    if (name_len > 20) {
       if (App.is_name_add_mac_suffix_enabled()) {
         // Keep first 13 chars and last 7 chars (MAC suffix), remove middle
-        name_with_suffix.erase(13, name_with_suffix.length() - 20);
+        memcpy(name_buffer, app_name.c_str(), 13);
+        memcpy(name_buffer + 13, app_name.c_str() + name_len - 7, 7);
       } else {
-        name_with_suffix.resize(20);
+        memcpy(name_buffer, app_name.c_str(), 20);
       }
+      name_buffer[20] = '\0';
+    } else {
+      memcpy(name_buffer, app_name.c_str(), name_len + 1);  // Include null terminator
     }
-    device_name = name_with_suffix.c_str();
+    device_name = name_buffer;
   }
 
   err = esp_ble_gap_set_device_name(device_name);
@@ -312,22 +315,24 @@ bool ESP32BLE::ble_setup_() {
 bool ESP32BLE::ble_dismantle_() {
   esp_err_t err = esp_bluedroid_disable();
   if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_bluedroid_disable failed: %d", err);
-    return false;
+    // ESP_ERR_INVALID_STATE means Bluedroid is already disabled, which is fine
+    if (err != ESP_ERR_INVALID_STATE) {
+      ESP_LOGE(TAG, "esp_bluedroid_disable failed: %d", err);
+      return false;
+    }
+    ESP_LOGD(TAG, "Already disabled");
   }
   err = esp_bluedroid_deinit();
   if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_bluedroid_deinit failed: %d", err);
-    return false;
+    // ESP_ERR_INVALID_STATE means Bluedroid is already deinitialized, which is fine
+    if (err != ESP_ERR_INVALID_STATE) {
+      ESP_LOGE(TAG, "esp_bluedroid_deinit failed: %d", err);
+      return false;
+    }
+    ESP_LOGD(TAG, "Already deinitialized");
   }
 
 #ifndef CONFIG_ESP_HOSTED_ENABLE_BT_BLUEDROID
-#ifdef USE_ARDUINO
-  if (!btStop()) {
-    ESP_LOGE(TAG, "btStop failed: %d", esp_bt_controller_get_status());
-    return false;
-  }
-#else
   if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_IDLE) {
     // stop bt controller
     if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_ENABLED) {
@@ -351,7 +356,6 @@ bool ESP32BLE::ble_dismantle_() {
       return false;
     }
   }
-#endif
 #else
   if (esp_hosted_bt_controller_disable() != ESP_OK) {
     ESP_LOGW(TAG, "esp_hosted_bt_controller_disable failed");

esphome/components/esp32_ble/ble.h

@@ -213,17 +213,23 @@ extern ESP32BLE *global_ble;
 
 template<typename... Ts> class BLEEnabledCondition : public Condition<Ts...> {
  public:
-  bool check(const Ts &...x) override { return global_ble->is_active(); }
+  bool check(const Ts &...x) override { return global_ble != nullptr && global_ble->is_active(); }
 };
 
 template<typename... Ts> class BLEEnableAction : public Action<Ts...> {
  public:
-  void play(const Ts &...x) override { global_ble->enable(); }
+  void play(const Ts &...x) override {
+    if (global_ble != nullptr)
+      global_ble->enable();
+  }
 };
 
 template<typename... Ts> class BLEDisableAction : public Action<Ts...> {
  public:
-  void play(const Ts &...x) override { global_ble->disable(); }
+  void play(const Ts &...x) override {
+    if (global_ble != nullptr)
+      global_ble->disable();
+  }
 };
 
 }  // namespace esphome::esp32_ble

esphome/components/esp32_ble/ble_uuid.cpp

@@ -143,9 +143,8 @@ bool ESPBTUUID::operator==(const ESPBTUUID &uuid) const {
   return this->as_128bit() == uuid.as_128bit();
 }
 esp_bt_uuid_t ESPBTUUID::get_uuid() const { return this->uuid_; }
-std::string ESPBTUUID::to_string() const {
-  char buf[40];  // Enough for 128-bit UUID with dashes
-  char *pos = buf;
+void ESPBTUUID::to_str(std::span<char, UUID_STR_LEN> output) const {
+  char *pos = output.data();
 
   switch (this->uuid_.len) {
     case ESP_UUID_LEN_16:
@@ -156,7 +155,7 @@ std::string ESPBTUUID::to_string() const {
       *pos++ = format_hex_pretty_char((this->uuid_.uuid.uuid16 >> 4) & 0x0F);
       *pos++ = format_hex_pretty_char(this->uuid_.uuid.uuid16 & 0x0F);
       *pos = '\0';
-      return std::string(buf);
+      return;
 
     case ESP_UUID_LEN_32:
       *pos++ = '0';
@@ -165,7 +164,7 @@ std::string ESPBTUUID::to_string() const {
         *pos++ = format_hex_pretty_char((this->uuid_.uuid.uuid32 >> shift) & 0x0F);
       }
       *pos = '\0';
-      return std::string(buf);
+      return;
 
     default:
     case ESP_UUID_LEN_128:
@@ -179,9 +178,13 @@ std::string ESPBTUUID::to_string() const {
         }
       }
       *pos = '\0';
-      return std::string(buf);
+      return;
   }
-  return "";
+}
+std::string ESPBTUUID::to_string() const {
+  char buf[UUID_STR_LEN];
+  this->to_str(buf);
+  return std::string(buf);
 }
 
 }  // namespace esphome::esp32_ble