[logger] RP2040: Use write() with known length instead of println()

.ai/instructions.md

@@ -293,12 +293,6 @@ This document provides essential context for AI models interacting with this pro
     *   **Configuration Design:** Aim for simplicity with sensible defaults, while allowing for advanced customization.
     *   **Embedded Systems Optimization:** ESPHome targets resource-constrained microcontrollers. Be mindful of flash size and RAM usage.
 
-        **Why Heap Allocation Matters:**
-
-        ESP devices run for months with small heaps shared between Wi-Fi, BLE, LWIP, and application code. Over time, repeated allocations of different sizes fragment the heap. Failures happen when the largest contiguous block shrinks, even if total free heap is still large. We have seen field crashes caused by this.
-
-        **Heap allocation after `setup()` should be avoided unless absolutely unavoidable.** Every allocation/deallocation cycle contributes to fragmentation. ESPHome treats runtime heap allocation as a long-term reliability bug, not a performance issue. Helpers that hide allocation (`std::string`, `std::to_string`, string-returning helpers) are being deprecated and replaced with buffer and view based APIs.
-
         **STL Container Guidelines:**
 
         ESPHome runs on embedded systems with limited resources. Choose containers carefully:
@@ -328,15 +322,15 @@ This document provides essential context for AI models interacting with this pro
            std::array<uint8_t, 256> buffer;
            ```
 
-        2. **Compile-time-known fixed sizes with vector-like API:** Use `StaticVector` from `esphome/core/helpers.h` for compile-time fixed size with `push_back()` interface (no dynamic allocation).
+        2. **Compile-time-known fixed sizes with vector-like API:** Use `StaticVector` from `esphome/core/helpers.h` for fixed-size stack allocation with `push_back()` interface.
            ```cpp
            // Bad - generates STL realloc code (_M_realloc_insert)
            std::vector<ServiceRecord> services;
            services.reserve(5);  // Still includes reallocation machinery
 
-           // Good - compile-time fixed size, no dynamic allocation
-           StaticVector<ServiceRecord, MAX_SERVICES> services;
-           services.push_back(record1);
+           // Good - compile-time fixed size, stack allocated, no reallocation machinery
+           StaticVector<ServiceRecord, MAX_SERVICES> services;  // Allocates all MAX_SERVICES on stack
+           services.push_back(record1);  // Tracks count but all slots allocated
            ```
            Use `cg.add_define("MAX_SERVICES", count)` to set the size from Python configuration.
            Like `std::array` but with vector-like API (`push_back()`, `size()`) and no STL reallocation code.
@@ -378,21 +372,22 @@ This document provides essential context for AI models interacting with this pro
            ```
            Linear search on small datasets (1-16 elements) is often faster than hashing/tree overhead, but this depends on lookup frequency and access patterns. For frequent lookups in hot code paths, the O(1) vs O(n) complexity difference may still matter even for small datasets. `std::vector` with simple structs is usually fine—it's the heavy containers (`map`, `set`, `unordered_map`) that should be avoided for small datasets unless profiling shows otherwise.
 
-        5. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices.
-
-        6. **Detection:** Look for these patterns in compiler output:
+        5. **Detection:** Look for these patterns in compiler output:
            - Large code sections with STL symbols (vector, map, set)
            - `alloc`, `realloc`, `dealloc` in symbol names
            - `_M_realloc_insert`, `_M_default_append` (vector reallocation)
            - Red-black tree code (`rb_tree`, `_Rb_tree`)
            - Hash table infrastructure (`unordered_map`, `hash`)
 
-        **Prioritize optimization effort for:**
+        **When to optimize:**
         - Core components (API, network, logger)
         - Widely-used components (mdns, wifi, ble)
         - Components causing flash size complaints
 
-        Note: Avoiding heap allocation after `setup()` is always required regardless of component type. The prioritization above is about the effort spent on container optimization (e.g., migrating from `std::vector` to `StaticVector`).
+        **When not to optimize:**
+        - Single-use niche components
+        - Code where readability matters more than bytes
+        - Already using appropriate containers
 
     *   **State Management:** Use `CORE.data` for component state that needs to persist during configuration generation. Avoid module-level mutable globals.
 

.clang-tidy.hash

@@ -1 +1 @@
-d272a88e8ca28ae9340a9a03295a566432a52cb696501908f57764475bf7ca65
+4268ab0b5150f79ab1c317e8f3834c8bb0b4c8122da4f6b1fd67c49d0f2098c9

.github/PULL_REQUEST_TEMPLATE.md

@@ -27,7 +27,6 @@
 - [ ] RP2040
 - [ ] BK72xx
 - [ ] RTL87xx
-- [ ] LN882x
 - [ ] nRF52840
 
 ## Example entry for `config.yaml`:

.github/workflows/codeql.yml

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

.pre-commit-config.yaml

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

CODEOWNERS

@@ -91,7 +91,6 @@ esphome/components/bmp3xx_spi/* @latonita
 esphome/components/bmp581/* @kahrendt
 esphome/components/bp1658cj/* @Cossid
 esphome/components/bp5758d/* @Cossid
-esphome/components/bthome_mithermometer/* @nagyrobi
 esphome/components/button/* @esphome/core
 esphome/components/bytebuffer/* @clydebarrow
 esphome/components/camera/* @bdraco @DT-art1
@@ -135,7 +134,7 @@ esphome/components/display_menu_base/* @numo68
 esphome/components/dps310/* @kbx81
 esphome/components/ds1307/* @badbadc0ffee
 esphome/components/ds2484/* @mrk-its
-esphome/components/dsmr/* @glmnet @PolarGoose @zuidwijk
+esphome/components/dsmr/* @glmnet @zuidwijk
 esphome/components/duty_time/* @dudanov
 esphome/components/ee895/* @Stock-M
 esphome/components/ektf2232/touchscreen/* @jesserockz
@@ -249,13 +248,11 @@ esphome/components/ina260/* @mreditor97
 esphome/components/ina2xx_base/* @latonita
 esphome/components/ina2xx_i2c/* @latonita
 esphome/components/ina2xx_spi/* @latonita
-esphome/components/infrared/* @kbx81
 esphome/components/inkbird_ibsth1_mini/* @fkirill
 esphome/components/inkplate/* @jesserockz @JosipKuci
 esphome/components/integration/* @OttoWinter
 esphome/components/internal_temperature/* @Mat931
 esphome/components/interval/* @esphome/core
-esphome/components/ir_rf_proxy/* @kbx81
 esphome/components/jsn_sr04t/* @Mafus1
 esphome/components/json/* @esphome/core
 esphome/components/kamstrup_kmp/* @cfeenstra1024
@@ -397,7 +394,6 @@ esphome/components/radon_eye_rd200/* @jeffeb3
 esphome/components/rc522/* @glmnet
 esphome/components/rc522_i2c/* @glmnet
 esphome/components/rc522_spi/* @glmnet
-esphome/components/rd03d/* @jasstrong
 esphome/components/resampler/speaker/* @kahrendt
 esphome/components/restart/* @esphome/core
 esphome/components/rf_bridge/* @jesserockz
@@ -523,7 +519,6 @@ 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
@@ -578,6 +573,5 @@ esphome/components/xpt2046/touchscreen/* @nielsnl68 @numo68
 esphome/components/xxtea/* @clydebarrow
 esphome/components/zephyr/* @tomaszduda23
 esphome/components/zhlt01/* @cfeenstra1024
-esphome/components/zigbee/* @tomaszduda23
 esphome/components/zio_ultrasonic/* @kahrendt
 esphome/components/zwave_proxy/* @kbx81

MANIFEST.in

@@ -1,7 +1,6 @@
 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,16 +11,6 @@ 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

@@ -62,9 +62,6 @@ from esphome.util import (
 
 _LOGGER = logging.getLogger(__name__)
 
-# Maximum buffer size for serial log reading to prevent unbounded memory growth
-SERIAL_BUFFER_MAX_SIZE = 65536
-
 # Special non-component keys that appear in configs
 _NON_COMPONENT_KEYS = frozenset(
     {
@@ -434,37 +431,25 @@ 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:
-                        # Read all available data and timestamp it
-                        chunk = ser.read(ser.in_waiting or 1)
-                        if not chunk:
-                            continue
-                        time_ = datetime.now()
-                        milliseconds = time_.microsecond // 1000
-                        time_str = f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}.{milliseconds:03}]"
-
-                        # Add to buffer and process complete lines
-                        # Limit buffer size to prevent unbounded memory growth
-                        # if device sends data without newlines
-                        buffer += chunk
-                        if len(buffer) > SERIAL_BUFFER_MAX_SIZE:
-                            buffer = buffer[-SERIAL_BUFFER_MAX_SIZE:]
-                        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
-                            )
+                        raw = ser.readline()
                     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)
@@ -804,13 +789,7 @@ def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
     exit_code = compile_program(args, config)
     if exit_code != 0:
         return exit_code
-    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.")
+    _LOGGER.info("Successfully compiled program.")
     return 0
 
 
@@ -860,8 +839,10 @@ def command_run(args: ArgsProtocol, config: ConfigType) -> int | None:
     if CORE.is_host:
         from esphome.platformio_api import get_idedata
 
-        program_path = str(get_idedata(config).firmware_elf_path)
-        _LOGGER.info("Running program from path '%s'", program_path)
+        idedata = get_idedata(config)
+        if idedata is None:
+            return 1
+        program_path = idedata.raw["prog_path"]
         return run_external_process(program_path)
 
     # Get devices, resolving special identifiers like OTA
@@ -1032,7 +1013,6 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:
         idedata.objdump_path,
         idedata.readelf_path,
         external_components,
-        idedata=idedata,
     )
     analyzer.analyze()
 

esphome/analyze_memory/__init__.py

@@ -22,7 +22,6 @@ from .helpers import (
     map_section_name,
     parse_symbol_line,
 )
-from .toolchain import find_tool, run_tool
 
 if TYPE_CHECKING:
     from esphome.platformio_api import IDEData
@@ -54,9 +53,6 @@ _NAMESPACE_STD = "std::"
 # Type alias for symbol information: (symbol_name, size, component)
 SymbolInfoType = tuple[str, int, str]
 
-# RAM sections - symbols in these sections consume RAM
-RAM_SECTIONS = frozenset([".data", ".bss"])
-
 
 @dataclass
 class MemorySection:
@@ -64,20 +60,7 @@ class MemorySection:
 
     name: str
     symbols: list[SymbolInfoType] = field(default_factory=list)
-    total_size: int = 0  # Actual section size from ELF headers
-    symbol_size: int = 0  # Sum of symbol sizes (may be less than total_size)
-
-
-@dataclass
-class SDKSymbol:
-    """Represents a symbol from an SDK library that's not in the ELF symbol table."""
-
-    name: str
-    size: int
-    library: str  # Name of the .a file (e.g., "libpp.a")
-    section: str  # ".bss" or ".data"
-    is_local: bool  # True if static/local symbol (lowercase in nm output)
-    demangled: str = ""  # Demangled name (populated after analysis)
+    total_size: int = 0
 
 
 @dataclass
@@ -135,10 +118,6 @@ class MemoryAnalyzer:
         self.objdump_path = objdump_path or "objdump"
         self.readelf_path = readelf_path or "readelf"
         self.external_components = external_components or set()
-        self._idedata = idedata
-
-        # Derive nm path from objdump path using shared toolchain utility
-        self.nm_path = find_tool("nm", self.objdump_path)
 
         self.sections: dict[str, MemorySection] = {}
         self.components: dict[str, ComponentMemory] = defaultdict(
@@ -149,25 +128,15 @@ class MemoryAnalyzer:
         self._esphome_core_symbols: list[
             tuple[str, str, int]
         ] = []  # Track core symbols
-        # Track symbols for all components: (symbol_name, demangled, size, section)
-        self._component_symbols: dict[str, list[tuple[str, str, int, str]]] = (
-            defaultdict(list)
-        )
-        # Track RAM symbols separately for detailed analysis: (symbol_name, demangled, size, section)
-        self._ram_symbols: dict[str, list[tuple[str, str, int, str]]] = defaultdict(
+        self._component_symbols: dict[str, list[tuple[str, str, int]]] = defaultdict(
             list
-        )
-        # Track ELF symbol names for SDK cross-reference
-        self._elf_symbol_names: set[str] = set()
-        # SDK symbols not in ELF (static/local symbols from closed-source libs)
-        self._sdk_symbols: list[SDKSymbol] = []
+        )  # Track symbols for all components
 
     def analyze(self) -> dict[str, ComponentMemory]:
         """Analyze the ELF file and return component memory usage."""
         self._parse_sections()
         self._parse_symbols()
         self._categorize_symbols()
-        self._analyze_sdk_libraries()
         return dict(self.components)
 
     def _parse_sections(self) -> None:
@@ -221,8 +190,6 @@ class MemoryAnalyzer:
                 continue
 
             self.sections[section].symbols.append((name, size, ""))
-            self.sections[section].symbol_size += size
-            self._elf_symbol_names.add(name)
             seen_addresses.add(address)
 
     def _categorize_symbols(self) -> None:
@@ -266,13 +233,8 @@ class MemoryAnalyzer:
                 if size > 0:
                     demangled = self._demangle_symbol(symbol_name)
                     self._component_symbols[component].append(
-                        (symbol_name, demangled, size, section_name)
+                        (symbol_name, demangled, size)
                     )
-                    # Track RAM symbols separately for detailed RAM analysis
-                    if section_name in RAM_SECTIONS:
-                        self._ram_symbols[component].append(
-                            (symbol_name, demangled, size, section_name)
-                        )
 
     def _identify_component(self, symbol_name: str) -> str:
         """Identify which component a symbol belongs to."""
@@ -366,247 +328,6 @@ class MemoryAnalyzer:
 
         return "Other Core"
 
-    def get_unattributed_ram(self) -> tuple[int, int, int]:
-        """Get unattributed RAM sizes (SDK/framework overhead).
-
-        Returns:
-            Tuple of (unattributed_bss, unattributed_data, total_unattributed)
-            These are bytes in RAM sections that have no corresponding symbols.
-        """
-        bss_section = self.sections.get(".bss")
-        data_section = self.sections.get(".data")
-
-        unattributed_bss = 0
-        unattributed_data = 0
-
-        if bss_section:
-            unattributed_bss = max(0, bss_section.total_size - bss_section.symbol_size)
-        if data_section:
-            unattributed_data = max(
-                0, data_section.total_size - data_section.symbol_size
-            )
-
-        return unattributed_bss, unattributed_data, unattributed_bss + unattributed_data
-
-    def _find_sdk_library_dirs(self) -> list[Path]:
-        """Find SDK library directories based on platform.
-
-        Returns:
-            List of paths to SDK library directories containing .a files.
-        """
-        sdk_dirs: list[Path] = []
-
-        if self._idedata is None:
-            return sdk_dirs
-
-        # Get the CC path to determine the framework location
-        cc_path = getattr(self._idedata, "cc_path", None)
-        if not cc_path:
-            return sdk_dirs
-
-        cc_path = Path(cc_path)
-
-        # For ESP8266 Arduino framework
-        # CC is like: ~/.platformio/packages/toolchain-xtensa/bin/xtensa-lx106-elf-gcc
-        # SDK libs are in: ~/.platformio/packages/framework-arduinoespressif8266/tools/sdk/lib/
-        if "xtensa-lx106" in str(cc_path):
-            platformio_dir = cc_path.parent.parent.parent
-            esp8266_sdk = (
-                platformio_dir
-                / "framework-arduinoespressif8266"
-                / "tools"
-                / "sdk"
-                / "lib"
-            )
-            if esp8266_sdk.exists():
-                sdk_dirs.append(esp8266_sdk)
-                # Also check for NONOSDK subdirectories (closed-source libs)
-                sdk_dirs.extend(
-                    subdir
-                    for subdir in esp8266_sdk.iterdir()
-                    if subdir.is_dir() and subdir.name.startswith("NONOSDK")
-                )
-
-        # For ESP32 IDF framework
-        # CC is like: ~/.platformio/packages/toolchain-xtensa-esp-elf/bin/xtensa-esp32-elf-gcc
-        # or: ~/.platformio/packages/toolchain-riscv32-esp/bin/riscv32-esp-elf-gcc
-        elif "xtensa-esp" in str(cc_path) or "riscv32-esp" in str(cc_path):
-            # Detect ESP32 variant from CC path or defines
-            variant = self._detect_esp32_variant()
-            if variant:
-                platformio_dir = cc_path.parent.parent.parent
-                espidf_dir = platformio_dir / "framework-espidf" / "components"
-                if espidf_dir.exists():
-                    # Find all directories named after the variant that contain .a files
-                    # This handles various ESP-IDF library layouts:
-                    # - components/*/lib/<variant>/
-                    # - components/*/<variant>/
-                    # - components/*/lib/lib/<variant>/
-                    # - components/*/*/lib_*/<variant>/
-                    sdk_dirs.extend(
-                        variant_dir
-                        for variant_dir in espidf_dir.rglob(variant)
-                        if variant_dir.is_dir() and any(variant_dir.glob("*.a"))
-                    )
-
-        return sdk_dirs
-
-    def _detect_esp32_variant(self) -> str | None:
-        """Detect ESP32 variant from idedata defines.
-
-        Returns:
-            Variant string like 'esp32', 'esp32s2', 'esp32c3', etc. or None.
-        """
-        if self._idedata is None:
-            return None
-
-        defines = getattr(self._idedata, "defines", [])
-        if not defines:
-            return None
-
-        # ESPHome always adds USE_ESP32_VARIANT_xxx defines
-        variant_prefix = "USE_ESP32_VARIANT_"
-        for define in defines:
-            if define.startswith(variant_prefix):
-                # Extract variant name and convert to lowercase
-                # USE_ESP32_VARIANT_ESP32 -> esp32
-                # USE_ESP32_VARIANT_ESP32S3 -> esp32s3
-                return define[len(variant_prefix) :].lower()
-
-        return None
-
-    def _parse_sdk_library(
-        self, lib_path: Path
-    ) -> tuple[list[tuple[str, int, str, bool]], set[str]]:
-        """Parse a single SDK library for symbols.
-
-        Args:
-            lib_path: Path to the .a library file
-
-        Returns:
-            Tuple of:
-            - List of BSS/DATA symbols: (symbol_name, size, section, is_local)
-            - Set of global BSS/DATA symbol names (for checking if RAM is linked)
-        """
-        ram_symbols: list[tuple[str, int, str, bool]] = []
-        global_ram_symbols: set[str] = set()
-
-        result = run_tool([self.nm_path, "--size-sort", str(lib_path)], timeout=10)
-        if result is None:
-            return ram_symbols, global_ram_symbols
-
-        for line in result.stdout.splitlines():
-            parts = line.split()
-            if len(parts) < 3:
-                continue
-
-            try:
-                size = int(parts[0], 16)
-                sym_type = parts[1]
-                name = parts[2]
-
-                # Only collect BSS (b/B) and DATA (d/D) for RAM analysis
-                if sym_type in ("b", "B"):
-                    section = ".bss"
-                    is_local = sym_type == "b"
-                    ram_symbols.append((name, size, section, is_local))
-                    # Track global RAM symbols (B/D) for linking check
-                    if sym_type == "B":
-                        global_ram_symbols.add(name)
-                elif sym_type in ("d", "D"):
-                    section = ".data"
-                    is_local = sym_type == "d"
-                    ram_symbols.append((name, size, section, is_local))
-                    if sym_type == "D":
-                        global_ram_symbols.add(name)
-            except (ValueError, IndexError):
-                continue
-
-        return ram_symbols, global_ram_symbols
-
-    def _analyze_sdk_libraries(self) -> None:
-        """Analyze SDK libraries to find symbols not in the ELF.
-
-        This finds static/local symbols from closed-source SDK libraries
-        that consume RAM but don't appear in the final ELF symbol table.
-        Only includes symbols from libraries that have RAM actually linked
-        (at least one global BSS/DATA symbol in the ELF).
-        """
-        sdk_dirs = self._find_sdk_library_dirs()
-        if not sdk_dirs:
-            _LOGGER.debug("No SDK library directories found")
-            return
-
-        _LOGGER.debug("Analyzing SDK libraries in %d directories", len(sdk_dirs))
-
-        # Track seen symbols to avoid duplicates from multiple SDK versions
-        seen_symbols: set[str] = set()
-
-        for sdk_dir in sdk_dirs:
-            for lib_path in sorted(sdk_dir.glob("*.a")):
-                lib_name = lib_path.name
-                ram_symbols, global_ram_symbols = self._parse_sdk_library(lib_path)
-
-                # Check if this library's RAM is actually linked by seeing if any
-                # of its global BSS/DATA symbols appear in the ELF
-                if not global_ram_symbols & self._elf_symbol_names:
-                    # No RAM from this library is in the ELF - skip it
-                    continue
-
-                for name, size, section, is_local in ram_symbols:
-                    # Skip if already in ELF or already seen from another lib
-                    if name in self._elf_symbol_names or name in seen_symbols:
-                        continue
-
-                    # Only track symbols with non-zero size
-                    if size > 0:
-                        self._sdk_symbols.append(
-                            SDKSymbol(
-                                name=name,
-                                size=size,
-                                library=lib_name,
-                                section=section,
-                                is_local=is_local,
-                            )
-                        )
-                        seen_symbols.add(name)
-
-        # Demangle SDK symbols for better readability
-        if self._sdk_symbols:
-            sdk_names = [sym.name for sym in self._sdk_symbols]
-            demangled_map = batch_demangle(sdk_names, objdump_path=self.objdump_path)
-            for sym in self._sdk_symbols:
-                sym.demangled = demangled_map.get(sym.name, sym.name)
-
-        # Sort by size descending for reporting
-        self._sdk_symbols.sort(key=lambda s: s.size, reverse=True)
-
-        total_sdk_ram = sum(s.size for s in self._sdk_symbols)
-        _LOGGER.debug(
-            "Found %d SDK symbols not in ELF, totaling %d bytes",
-            len(self._sdk_symbols),
-            total_sdk_ram,
-        )
-
-    def get_sdk_ram_symbols(self) -> list[SDKSymbol]:
-        """Get SDK symbols that consume RAM but aren't in the ELF symbol table.
-
-        Returns:
-            List of SDKSymbol objects sorted by size descending.
-        """
-        return self._sdk_symbols
-
-    def get_sdk_ram_by_library(self) -> dict[str, list[SDKSymbol]]:
-        """Get SDK RAM symbols grouped by library.
-
-        Returns:
-            Dictionary mapping library name to list of symbols.
-        """
-        by_lib: dict[str, list[SDKSymbol]] = defaultdict(list)
-        for sym in self._sdk_symbols:
-            by_lib[sym.library].append(sym)
-        return dict(by_lib)
-
 
 if __name__ == "__main__":
     from .cli import main

esphome/analyze_memory/cli.py

@@ -1,24 +1,16 @@
 """CLI interface for memory analysis with report generation."""
 
-from __future__ import annotations
-
 from collections import defaultdict
-from collections.abc import Callable
 import sys
-from typing import TYPE_CHECKING
 
 from . import (
     _COMPONENT_API,
     _COMPONENT_CORE,
     _COMPONENT_PREFIX_ESPHOME,
     _COMPONENT_PREFIX_EXTERNAL,
-    RAM_SECTIONS,
     MemoryAnalyzer,
 )
 
-if TYPE_CHECKING:
-    from . import ComponentMemory
-
 
 class MemoryAnalyzerCLI(MemoryAnalyzer):
     """Memory analyzer with CLI-specific report generation."""
@@ -27,8 +19,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
     SYMBOL_SIZE_THRESHOLD: int = (
         100  # Show symbols larger than this in detailed analysis
     )
-    # Lower threshold for RAM symbols (RAM is more constrained)
-    RAM_SYMBOL_SIZE_THRESHOLD: int = 24
 
     # Column width constants
     COL_COMPONENT: int = 29
@@ -93,60 +83,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
         COL_CORE_PERCENT,
     )
 
-    def _add_section_header(self, lines: list[str], title: str) -> None:
-        """Add a section header with title centered between separator lines."""
-        lines.append("")
-        lines.append("=" * self.TABLE_WIDTH)
-        lines.append(title.center(self.TABLE_WIDTH))
-        lines.append("=" * self.TABLE_WIDTH)
-        lines.append("")
-
-    def _add_top_consumers(
-        self,
-        lines: list[str],
-        title: str,
-        components: list[tuple[str, ComponentMemory]],
-        get_size: Callable[[ComponentMemory], int],
-        total: int,
-        memory_type: str,
-        limit: int = 25,
-    ) -> None:
-        """Add a formatted list of top memory consumers to the report.
-
-        Args:
-            lines: List of report lines to append the output to.
-            title: Section title to print before the list.
-            components: Sequence of (name, ComponentMemory) tuples to analyze.
-            get_size: Callable that takes a ComponentMemory and returns the
-                size in bytes to use for ranking and display.
-            total: Total size in bytes for computing percentage usage.
-            memory_type: Label for the memory region (e.g., "flash" or "RAM").
-            limit: Maximum number of components to include in the list.
-        """
-        lines.append("")
-        lines.append(f"{title}:")
-        for i, (name, mem) in enumerate(components[:limit]):
-            size = get_size(mem)
-            if size > 0:
-                percentage = (size / total * 100) if total > 0 else 0
-                lines.append(
-                    f"{i + 1}. {name} ({size:,} B) - {percentage:.1f}% of analyzed {memory_type}"
-                )
-
-    def _format_symbol_with_section(
-        self, demangled: str, size: int, section: str | None = None
-    ) -> str:
-        """Format a symbol entry, optionally adding a RAM section label.
-
-        If section is one of the RAM sections (.data or .bss), a label like
-        " [data]" or " [bss]" is appended. For non-RAM sections or when
-        section is None, no section label is added.
-        """
-        section_label = ""
-        if section in RAM_SECTIONS:
-            section_label = f" [{section[1:]}]"  # .data -> [data], .bss -> [bss]
-        return f"{demangled} ({size:,} B){section_label}"
-
     def generate_report(self, detailed: bool = False) -> str:
         """Generate a formatted memory report."""
         components = sorted(
@@ -187,70 +123,43 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
             f"{total_flash:>{self.COL_TOTAL_FLASH - 2},} B | {total_ram:>{self.COL_TOTAL_RAM - 2},} B"
         )
 
-        # Show unattributed RAM (SDK/framework overhead)
-        unattributed_bss, unattributed_data, unattributed_total = (
-            self.get_unattributed_ram()
-        )
-        if unattributed_total > 0:
-            lines.append("")
-            lines.append(
-                f"Unattributed RAM: {unattributed_total:,} B (SDK/framework overhead)"
-            )
-            if unattributed_bss > 0 and unattributed_data > 0:
+        # Top consumers
+        lines.append("")
+        lines.append("Top Flash Consumers:")
+        for i, (name, mem) in enumerate(components[:25]):
+            if mem.flash_total > 0:
+                percentage = (
+                    (mem.flash_total / total_flash * 100) if total_flash > 0 else 0
+                )
                 lines.append(
-                    f"  .bss: {unattributed_bss:,} B | .data: {unattributed_data:,} B"
+                    f"{i + 1}. {name} ({mem.flash_total:,} B) - {percentage:.1f}% of analyzed flash"
                 )
 
-            # Show SDK symbol breakdown if available
-            sdk_by_lib = self.get_sdk_ram_by_library()
-            if sdk_by_lib:
-                lines.append("")
-                lines.append("SDK library breakdown (static symbols not in ELF):")
-                # Sort libraries by total size
-                lib_totals = [
-                    (lib, sum(s.size for s in syms), syms)
-                    for lib, syms in sdk_by_lib.items()
-                ]
-                lib_totals.sort(key=lambda x: x[1], reverse=True)
-
-                for lib_name, lib_total, syms in lib_totals:
-                    if lib_total == 0:
-                        continue
-                    lines.append(f"  {lib_name}: {lib_total:,} B")
-                    # Show top symbols from this library
-                    for sym in sorted(syms, key=lambda s: s.size, reverse=True)[:3]:
-                        section_label = sym.section.lstrip(".")
-                        # Use demangled name (falls back to original if not demangled)
-                        display_name = sym.demangled or sym.name
-                        if len(display_name) > 50:
-                            display_name = f"{display_name[:47]}..."
-                        lines.append(
-                            f"    {sym.size:>6,} B [{section_label}] {display_name}"
-                        )
-
-        # Top consumers
-        self._add_top_consumers(
-            lines,
-            "Top Flash Consumers",
-            components,
-            lambda m: m.flash_total,
-            total_flash,
-            "flash",
-        )
-
+        lines.append("")
+        lines.append("Top RAM Consumers:")
         ram_components = sorted(components, key=lambda x: x[1].ram_total, reverse=True)
-        self._add_top_consumers(
-            lines,
-            "Top RAM Consumers",
-            ram_components,
-            lambda m: m.ram_total,
-            total_ram,
-            "RAM",
+        for i, (name, mem) in enumerate(ram_components[:25]):
+            if mem.ram_total > 0:
+                percentage = (mem.ram_total / total_ram * 100) if total_ram > 0 else 0
+                lines.append(
+                    f"{i + 1}. {name} ({mem.ram_total:,} B) - {percentage:.1f}% of analyzed RAM"
+                )
+
+        lines.append("")
+        lines.append(
+            "Note: This analysis covers symbols in the ELF file. Some runtime allocations may not be included."
         )
+        lines.append("=" * self.TABLE_WIDTH)
 
         # Add ESPHome core detailed analysis if there are core symbols
         if self._esphome_core_symbols:
-            self._add_section_header(lines, f"{_COMPONENT_CORE} Detailed Analysis")
+            lines.append("")
+            lines.append("=" * self.TABLE_WIDTH)
+            lines.append(
+                f"{_COMPONENT_CORE} Detailed Analysis".center(self.TABLE_WIDTH)
+            )
+            lines.append("=" * self.TABLE_WIDTH)
+            lines.append("")
 
             # Group core symbols by subcategory
             core_subcategories: dict[str, list[tuple[str, str, int]]] = defaultdict(
@@ -302,11 +211,7 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 f"{_COMPONENT_CORE} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_core_symbols)} symbols):"
             )
             for i, (symbol, demangled, size) in enumerate(large_core_symbols):
-                # Core symbols only track (symbol, demangled, size) without section info,
-                # so we don't show section labels here
-                lines.append(
-                    f"{i + 1}. {self._format_symbol_with_section(demangled, size)}"
-                )
+                lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
             lines.append("=" * self.TABLE_WIDTH)
 
@@ -362,7 +267,11 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
             for comp_name, comp_mem in components_to_analyze:
                 if not (comp_symbols := self._component_symbols.get(comp_name, [])):
                     continue
-                self._add_section_header(lines, f"{comp_name} Detailed Analysis")
+                lines.append("")
+                lines.append("=" * self.TABLE_WIDTH)
+                lines.append(f"{comp_name} Detailed Analysis".center(self.TABLE_WIDTH))
+                lines.append("=" * self.TABLE_WIDTH)
+                lines.append("")
 
                 # Sort symbols by size
                 sorted_symbols = sorted(comp_symbols, key=lambda x: x[2], reverse=True)
@@ -373,69 +282,19 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
                 # Show all symbols above threshold for better visibility
                 large_symbols = [
-                    (sym, dem, size, sec)
-                    for sym, dem, size, sec in sorted_symbols
+                    (sym, dem, size)
+                    for sym, dem, size in sorted_symbols
                     if size > self.SYMBOL_SIZE_THRESHOLD
                 ]
 
                 lines.append(
                     f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_symbols)} symbols):"
                 )
-                for i, (symbol, demangled, size, section) in enumerate(large_symbols):
-                    lines.append(
-                        f"{i + 1}. {self._format_symbol_with_section(demangled, size, section)}"
-                    )
+                for i, (symbol, demangled, size) in enumerate(large_symbols):
+                    lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
                 lines.append("=" * self.TABLE_WIDTH)
 
-        # Detailed RAM analysis by component (at end, before RAM strings analysis)
-        self._add_section_header(lines, "RAM Symbol Analysis by Component")
-
-        # Show top 15 RAM consumers with their large symbols
-        for name, mem in ram_components[:15]:
-            if mem.ram_total == 0:
-                continue
-            ram_syms = self._ram_symbols.get(name, [])
-            if not ram_syms:
-                continue
-
-            # Sort by size descending
-            sorted_ram_syms = sorted(ram_syms, key=lambda x: x[2], reverse=True)
-            large_ram_syms = [
-                s for s in sorted_ram_syms if s[2] > self.RAM_SYMBOL_SIZE_THRESHOLD
-            ]
-
-            lines.append(f"{name} ({mem.ram_total:,} B total RAM):")
-
-            # Show breakdown by section type
-            data_size = sum(s[2] for s in ram_syms if s[3] == ".data")
-            bss_size = sum(s[2] for s in ram_syms if s[3] == ".bss")
-            lines.append(f"  .data (initialized): {data_size:,} B")
-            lines.append(f"  .bss (uninitialized): {bss_size:,} B")
-
-            if large_ram_syms:
-                lines.append(
-                    f"  Symbols > {self.RAM_SYMBOL_SIZE_THRESHOLD} B ({len(large_ram_syms)}):"
-                )
-                for symbol, demangled, size, section in large_ram_syms[:10]:
-                    # Format section label consistently by stripping leading dot
-                    section_label = section.lstrip(".") if section else ""
-                    # Add ellipsis if name is truncated
-                    demangled_display = (
-                        f"{demangled[:70]}..." if len(demangled) > 70 else demangled
-                    )
-                    lines.append(
-                        f"    {size:>6,} B [{section_label}] {demangled_display}"
-                    )
-                if len(large_ram_syms) > 10:
-                    lines.append(f"    ... and {len(large_ram_syms) - 10} more")
-            lines.append("")
-
-        lines.append(
-            "Note: This analysis covers symbols in the ELF file. Some runtime allocations may not be included."
-        )
-        lines.append("=" * self.TABLE_WIDTH)
-
         return "\n".join(lines)
 
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:

esphome/analyze_memory/const.py

@@ -7,13 +7,11 @@ ESPHOME_COMPONENT_PATTERN = re.compile(r"esphome::([a-zA-Z0-9_]+)::")
 
 # Section mapping for ELF file sections
 # Maps standard section names to their various platform-specific variants
-# Note: Order matters! More specific patterns (.bss) must come before general ones (.dram)
-# because ESP-IDF uses names like ".dram0.bss" which would match ".dram" otherwise
 SECTION_MAPPING = {
     ".text": frozenset([".text", ".iram"]),
     ".rodata": frozenset([".rodata"]),
-    ".bss": frozenset([".bss"]),  # Must be before .data to catch ".dram0.bss"
     ".data": frozenset([".data", ".dram"]),
+    ".bss": frozenset([".bss"]),
 }
 
 # Section to ComponentMemory attribute mapping
@@ -90,77 +88,6 @@ SYMBOL_PATTERNS = {
         "sys_mbox_new",
         "sys_arch_mbox_tryfetch",
     ],
-    # LibreTiny/Beken BK7231 radio calibration
-    "bk_radio_cal": [
-        "bk7011_",
-        "calibration_main",
-        "gcali_",
-        "rwnx_cal",
-    ],
-    # LibreTiny/Beken WiFi MAC layer
-    "bk_wifi_mac": [
-        "rxu_",  # RX upper layer
-        "txu_",  # TX upper layer
-        "txl_",  # TX lower layer
-        "rxl_",  # RX lower layer
-        "scanu_",  # Scan unit
-        "mm_hw_",  # MAC management hardware
-        "mm_bcn",  # MAC management beacon
-        "mm_tim",  # MAC management TIM
-        "mm_check",  # MAC management checks
-        "sm_connect",  # Station management
-        "me_beacon",  # Management entity beacon
-        "me_build",  # Management entity build
-        "hapd_",  # Host AP daemon
-        "chan_pre_",  # Channel management
-        "handle_probe_",  # Probe handling
-    ],
-    # LibreTiny/Beken system control
-    "bk_system": [
-        "sctrl_",  # System control
-        "icu_ctrl",  # Interrupt control unit
-        "gdma_ctrl",  # DMA control
-        "mpb_ctrl",  # MPB control
-        "uf2_",  # UF2 OTA
-        "bkreg_",  # Beken registers
-    ],
-    # LibreTiny/Beken BLE stack
-    "bk_ble": [
-        "gapc_",  # GAP client
-        "gattc_",  # GATT client
-        "attc_",  # ATT client
-        "attmdb_",  # ATT database
-        "atts_",  # ATT server
-        "l2cc_",  # L2CAP
-        "prf_env",  # Profile environment
-    ],
-    # LibreTiny/Beken scheduler
-    "bk_scheduler": [
-        "sch_plan_",  # Scheduler plan
-        "sch_prog_",  # Scheduler program
-        "sch_arb_",  # Scheduler arbiter
-    ],
-    # LibreTiny/Beken DMA descriptors
-    "bk_dma": [
-        "rx_payload_desc",
-        "rx_dma_hdrdesc",
-        "tx_hw_desc",
-        "host_event_data",
-        "host_cmd_data",
-    ],
-    # ARM EABI compiler runtime (LibreTiny uses ARM Cortex-M)
-    "arm_runtime": [
-        "__aeabi_",
-        "__adddf3",
-        "__subdf3",
-        "__muldf3",
-        "__divdf3",
-        "__addsf3",
-        "__subsf3",
-        "__mulsf3",
-        "__divsf3",
-        "__gnu_unwind",
-    ],
     "xtensa": ["xt_", "_xt_", "xPortEnterCriticalTimeout"],
     "heap": ["heap_", "multi_heap"],
     "spi_flash": ["spi_flash"],
@@ -855,22 +782,7 @@ SYMBOL_PATTERNS = {
     "math_internal": ["__mdiff", "__lshift", "__mprec_tens", "quorem"],
     "character_class": ["__chclass"],
     "camellia": ["camellia_", "camellia_feistel"],
-    "crypto_tables": [
-        "FSb",
-        "FSb2",
-        "FSb3",
-        "FSb4",
-        "Te0",  # AES encryption table
-        "Td0",  # AES decryption table
-        "crc32_table",  # CRC32 lookup table
-        "crc_tab",  # CRC lookup table
-    ],
-    "crypto_hash": [
-        "SHA1Transform",  # SHA1 hash function
-        "MD5Transform",  # MD5 hash function
-        "SHA256",
-        "SHA512",
-    ],
+    "crypto_tables": ["FSb", "FSb2", "FSb3", "FSb4"],
     "event_buffer": ["g_eb_list_desc", "eb_space"],
     "base_node": ["base_node_", "base_node_add_handler"],
     "file_descriptor": ["s_fd_table"],

esphome/analyze_memory/toolchain.py

@@ -5,10 +5,6 @@ from __future__ import annotations
 import logging
 from pathlib import Path
 import subprocess
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from collections.abc import Sequence
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -59,35 +55,3 @@ def find_tool(
 
     _LOGGER.warning("Could not find %s tool", tool_name)
     return None
-
-
-def run_tool(
-    cmd: Sequence[str],
-    timeout: int = 30,
-) -> subprocess.CompletedProcess[str] | None:
-    """Run a toolchain command and return the result.
-
-    Args:
-        cmd: Command and arguments to run
-        timeout: Timeout in seconds
-
-    Returns:
-        CompletedProcess on success, None on failure
-    """
-    try:
-        return subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-            check=False,
-        )
-    except subprocess.TimeoutExpired:
-        _LOGGER.warning("Command timed out: %s", " ".join(cmd))
-        return None
-    except FileNotFoundError:
-        _LOGGER.warning("Command not found: %s", cmd[0])
-        return None
-    except OSError as e:
-        _LOGGER.warning("Failed to run command %s: %s", cmd[0], e)
-        return None

esphome/components/a01nyub/a01nyub.cpp

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

esphome/components/a02yyuw/a02yyuw.cpp

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

esphome/components/absolute_humidity/absolute_humidity.cpp

@@ -90,16 +90,13 @@ void AbsoluteHumidityComponent::loop() {
       this->status_set_error(LOG_STR("Invalid saturation vapor pressure equation selection!"));
       return;
   }
+  ESP_LOGD(TAG, "Saturation vapor pressure %f kPa", es);
 
   // Calculate absolute humidity
   const float absolute_humidity = vapor_density(es, hr, temperature_k);
 
-  ESP_LOGD(TAG,
-           "Saturation vapor pressure %f kPa\n"
-           "Publishing absolute humidity %f g/m³",
-           es, absolute_humidity);
-
   // Publish absolute humidity
+  ESP_LOGD(TAG, "Publishing absolute humidity %f g/m³", absolute_humidity);
   this->status_clear_warning();
   this->publish_state(absolute_humidity);
 }

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -1,3 +1,5 @@
+#ifdef USE_ARDUINO
+
 #include "ac_dimmer.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -7,12 +9,12 @@
 #ifdef USE_ESP8266
 #include <core_esp8266_waveform.h>
 #endif
-
-#ifdef USE_ESP32
-#include "hw_timer_esp_idf.h"
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+#include <esp32-hal-timer.h>
 #endif
 
-namespace esphome::ac_dimmer {
+namespace esphome {
+namespace ac_dimmer {
 
 static const char *const TAG = "ac_dimmer";
 
@@ -25,14 +27,7 @@ static AcDimmerDataStore *all_dimmers[32];  // NOLINT(cppcoreguidelines-avoid-no
 /// However other factors like gate driver propagation time
 /// are also considered and a really low value is not important
 /// See also: https://github.com/esphome/issues/issues/1632
-static constexpr uint32_t GATE_ENABLE_TIME = 50;
-
-#ifdef USE_ESP32
-/// Timer frequency in Hz (1 MHz = 1µs resolution)
-static constexpr uint32_t TIMER_FREQUENCY_HZ = 1000000;
-/// Timer interrupt interval in microseconds
-static constexpr uint64_t TIMER_INTERVAL_US = 50;
-#endif
+static const uint32_t GATE_ENABLE_TIME = 50;
 
 /// Function called from timer interrupt
 /// Input is current time in microseconds (micros())
@@ -159,7 +154,7 @@ void IRAM_ATTR HOT AcDimmerDataStore::s_gpio_intr(AcDimmerDataStore *store) {
 #ifdef USE_ESP32
 // ESP32 implementation, uses basically the same code but needs to wrap
 // timer_interrupt() function to auto-reschedule
-static HWTimer *dimmer_timer = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static hw_timer_t *dimmer_timer = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 void IRAM_ATTR HOT AcDimmerDataStore::s_timer_intr() { timer_interrupt(); }
 #endif
 
@@ -199,15 +194,15 @@ void AcDimmer::setup() {
   setTimer1Callback(&timer_interrupt);
 #endif
 #ifdef USE_ESP32
-  dimmer_timer = timer_begin(TIMER_FREQUENCY_HZ);
-  timer_attach_interrupt(dimmer_timer, &AcDimmerDataStore::s_timer_intr);
+  // timer frequency of 1mhz
+  dimmer_timer = timerBegin(1000000);
+  timerAttachInterrupt(dimmer_timer, &AcDimmerDataStore::s_timer_intr);
   // For ESP32, we can't use dynamic interval calculation because the timerX functions
   // are not callable from ISR (placed in flash storage).
   // Here we just use an interrupt firing every 50 µs.
-  timer_alarm(dimmer_timer, TIMER_INTERVAL_US, true, 0);
+  timerAlarm(dimmer_timer, 50, true, 0);
 #endif
 }
-
 void AcDimmer::write_state(float state) {
   state = std::acos(1 - (2 * state)) / std::numbers::pi;  // RMS power compensation
   auto new_value = static_cast<uint16_t>(roundf(state * 65535));
@@ -215,15 +210,14 @@ void AcDimmer::write_state(float state) {
     this->store_.init_cycle = this->init_with_half_cycle_;
   this->store_.value = new_value;
 }
-
 void AcDimmer::dump_config() {
+  ESP_LOGCONFIG(TAG, "AcDimmer:");
+  LOG_PIN("  Output Pin: ", this->gate_pin_);
+  LOG_PIN("  Zero-Cross Pin: ", this->zero_cross_pin_);
   ESP_LOGCONFIG(TAG,
-                "AcDimmer:\n"
                 "   Min Power: %.1f%%\n"
                 "   Init with half cycle: %s",
                 this->store_.min_power / 10.0f, YESNO(this->init_with_half_cycle_));
-  LOG_PIN("  Output Pin: ", this->gate_pin_);
-  LOG_PIN("  Zero-Cross Pin: ", this->zero_cross_pin_);
   if (method_ == DIM_METHOD_LEADING_PULSE) {
     ESP_LOGCONFIG(TAG, "   Method: leading pulse");
   } else if (method_ == DIM_METHOD_LEADING) {
@@ -236,4 +230,7 @@ void AcDimmer::dump_config() {
   ESP_LOGV(TAG, "  Estimated Frequency: %.3fHz", 1e6f / this->store_.cycle_time_us / 2);
 }
 
-}  // namespace esphome::ac_dimmer
+}  // namespace ac_dimmer
+}  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/ac_dimmer/ac_dimmer.h

@@ -1,10 +1,13 @@
 #pragma once
 
+#ifdef USE_ARDUINO
+
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/components/output/float_output.h"
 
-namespace esphome::ac_dimmer {
+namespace esphome {
+namespace ac_dimmer {
 
 enum DimMethod { DIM_METHOD_LEADING_PULSE = 0, DIM_METHOD_LEADING, DIM_METHOD_TRAILING };
 
@@ -61,4 +64,7 @@ class AcDimmer : public output::FloatOutput, public Component {
   DimMethod method_;
 };
 
-}  // namespace esphome::ac_dimmer
+}  // namespace ac_dimmer
+}  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/ac_dimmer/hw_timer_esp_idf.cpp

@@ -1,152 +0,0 @@
-#ifdef USE_ESP32
-
-#include "hw_timer_esp_idf.h"
-
-#include "freertos/FreeRTOS.h"
-#include "esphome/core/log.h"
-
-#include "driver/gptimer.h"
-#include "esp_clk_tree.h"
-#include "soc/clk_tree_defs.h"
-
-static const char *const TAG = "hw_timer_esp_idf";
-
-namespace esphome::ac_dimmer {
-
-// GPTimer divider constraints from ESP-IDF documentation
-static constexpr uint32_t GPTIMER_DIVIDER_MIN = 2;
-static constexpr uint32_t GPTIMER_DIVIDER_MAX = 65536;
-
-using voidFuncPtr = void (*)();
-using voidFuncPtrArg = void (*)(void *);
-
-struct InterruptConfigT {
-  voidFuncPtr fn{nullptr};
-  void *arg{nullptr};
-};
-
-struct HWTimer {
-  gptimer_handle_t timer_handle{nullptr};
-  InterruptConfigT interrupt_handle{};
-  bool timer_started{false};
-};
-
-HWTimer *timer_begin(uint32_t frequency) {
-  esp_err_t err = ESP_OK;
-  uint32_t counter_src_hz = 0;
-  uint32_t divider = 0;
-  soc_module_clk_t clk;
-  for (auto clk_candidate : SOC_GPTIMER_CLKS) {
-    clk = clk_candidate;
-    esp_clk_tree_src_get_freq_hz(clk, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &counter_src_hz);
-    divider = counter_src_hz / frequency;
-    if ((divider >= GPTIMER_DIVIDER_MIN) && (divider <= GPTIMER_DIVIDER_MAX)) {
-      break;
-    } else {
-      divider = 0;
-    }
-  }
-
-  if (divider == 0) {
-    ESP_LOGE(TAG, "Resolution not possible; aborting");
-    return nullptr;
-  }
-
-  gptimer_config_t config = {
-      .clk_src = static_cast<gptimer_clock_source_t>(clk),
-      .direction = GPTIMER_COUNT_UP,
-      .resolution_hz = frequency,
-      .flags = {.intr_shared = true},
-  };
-
-  HWTimer *timer = new HWTimer();
-
-  err = gptimer_new_timer(&config, &timer->timer_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "GPTimer creation failed; error %d", err);
-    delete timer;
-    return nullptr;
-  }
-
-  err = gptimer_enable(timer->timer_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "GPTimer enable failed; error %d", err);
-    gptimer_del_timer(timer->timer_handle);
-    delete timer;
-    return nullptr;
-  }
-
-  err = gptimer_start(timer->timer_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "GPTimer start failed; error %d", err);
-    gptimer_disable(timer->timer_handle);
-    gptimer_del_timer(timer->timer_handle);
-    delete timer;
-    return nullptr;
-  }
-
-  timer->timer_started = true;
-  return timer;
-}
-
-bool IRAM_ATTR timer_fn_wrapper(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *args) {
-  auto *isr = static_cast<InterruptConfigT *>(args);
-  if (isr->fn) {
-    if (isr->arg) {
-      reinterpret_cast<voidFuncPtrArg>(isr->fn)(isr->arg);
-    } else {
-      isr->fn();
-    }
-  }
-  // Return false to indicate that no higher-priority task was woken and no context switch is requested.
-  return false;
-}
-
-static void timer_attach_interrupt_functional_arg(HWTimer *timer, void (*user_func)(void *), void *arg) {
-  if (timer == nullptr) {
-    ESP_LOGE(TAG, "Timer handle is nullptr");
-    return;
-  }
-  gptimer_event_callbacks_t cbs = {
-      .on_alarm = timer_fn_wrapper,
-  };
-
-  timer->interrupt_handle.fn = reinterpret_cast<voidFuncPtr>(user_func);
-  timer->interrupt_handle.arg = arg;
-
-  if (timer->timer_started) {
-    gptimer_stop(timer->timer_handle);
-  }
-  gptimer_disable(timer->timer_handle);
-  esp_err_t err = gptimer_register_event_callbacks(timer->timer_handle, &cbs, &timer->interrupt_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Timer Attach Interrupt failed; error %d", err);
-  }
-  gptimer_enable(timer->timer_handle);
-  if (timer->timer_started) {
-    gptimer_start(timer->timer_handle);
-  }
-}
-
-void timer_attach_interrupt(HWTimer *timer, voidFuncPtr user_func) {
-  timer_attach_interrupt_functional_arg(timer, reinterpret_cast<voidFuncPtrArg>(user_func), nullptr);
-}
-
-void timer_alarm(HWTimer *timer, uint64_t alarm_value, bool autoreload, uint64_t reload_count) {
-  if (timer == nullptr) {
-    ESP_LOGE(TAG, "Timer handle is nullptr");
-    return;
-  }
-  gptimer_alarm_config_t alarm_cfg = {
-      .alarm_count = alarm_value,
-      .reload_count = reload_count,
-      .flags = {.auto_reload_on_alarm = autoreload},
-  };
-  esp_err_t err = gptimer_set_alarm_action(timer->timer_handle, &alarm_cfg);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Timer Alarm Write failed; error %d", err);
-  }
-}
-
-}  // namespace esphome::ac_dimmer
-#endif

esphome/components/ac_dimmer/hw_timer_esp_idf.h

@@ -1,17 +0,0 @@
-#pragma once
-#ifdef USE_ESP32
-
-#include "driver/gptimer_types.h"
-
-namespace esphome::ac_dimmer {
-
-struct HWTimer;
-
-HWTimer *timer_begin(uint32_t frequency);
-
-void timer_attach_interrupt(HWTimer *timer, void (*user_func)());
-void timer_alarm(HWTimer *timer, uint64_t alarm_value, bool autoreload, uint64_t reload_count);
-
-}  // namespace esphome::ac_dimmer
-
-#endif

esphome/components/ac_dimmer/output.py

@@ -3,7 +3,6 @@ import esphome.codegen as cg
 from esphome.components import output
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_METHOD, CONF_MIN_POWER
-from esphome.core import CORE
 
 CODEOWNERS = ["@glmnet"]
 
@@ -32,16 +31,11 @@ CONFIG_SCHEMA = cv.All(
             ),
         }
     ).extend(cv.COMPONENT_SCHEMA),
+    cv.only_with_arduino,
 )
 
 
 async def to_code(config):
-    if CORE.is_esp8266:
-        # ac_dimmer uses setTimer1Callback which requires the waveform generator
-        from esphome.components.esp8266.const import require_waveform
-
-        require_waveform()
-
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 

esphome/components/adc/adc_sensor_esp32.cpp

@@ -121,21 +121,23 @@ void ADCSensor::setup() {
 void ADCSensor::dump_config() {
   LOG_SENSOR("", "ADC Sensor", this);
   LOG_PIN("  Pin: ", this->pin_);
+  ESP_LOGCONFIG(TAG,
+                "  Channel:       %d\n"
+                "  Unit:          %s\n"
+                "  Attenuation:   %s\n"
+                "  Samples:       %i\n"
+                "  Sampling mode: %s",
+                this->channel_, LOG_STR_ARG(adc_unit_to_str(this->adc_unit_)),
+                this->autorange_ ? "Auto" : LOG_STR_ARG(attenuation_to_str(this->attenuation_)), this->sample_count_,
+                LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+
   ESP_LOGCONFIG(
       TAG,
-      "  Channel:       %d\n"
-      "  Unit:          %s\n"
-      "  Attenuation:   %s\n"
-      "  Samples:       %i\n"
-      "  Sampling mode: %s\n"
       "  Setup Status:\n"
       "    Handle Init:  %s\n"
       "    Config:       %s\n"
       "    Calibration:  %s\n"
       "    Overall Init: %s",
-      this->channel_, LOG_STR_ARG(adc_unit_to_str(this->adc_unit_)),
-      this->autorange_ ? "Auto" : LOG_STR_ARG(attenuation_to_str(this->attenuation_)), this->sample_count_,
-      LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)),
       this->setup_flags_.handle_init_complete ? "OK" : "FAILED", this->setup_flags_.config_complete ? "OK" : "FAILED",
       this->setup_flags_.calibration_complete ? "OK" : "FAILED", this->setup_flags_.init_complete ? "OK" : "FAILED");
 

esphome/components/addressable_light/addressable_light_display.h

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

esphome/components/ade7880/ade7880.cpp

@@ -162,13 +162,11 @@ void ADE7880::update() {
 }
 
 void ADE7880::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "ADE7880:\n"
-                "  Frequency: %.0f Hz",
-                this->frequency_);
+  ESP_LOGCONFIG(TAG, "ADE7880:");
   LOG_PIN("  IRQ0  Pin: ", this->irq0_pin_);
   LOG_PIN("  IRQ1  Pin: ", this->irq1_pin_);
   LOG_PIN("  RESET Pin: ", this->reset_pin_);
+  ESP_LOGCONFIG(TAG, "  Frequency: %.0f Hz", this->frequency_);
 
   if (this->channel_a_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  Phase A:");

esphome/components/ads1115/sensor/ads1115_sensor.cpp

@@ -21,12 +21,10 @@ void ADS1115Sensor::update() {
 
 void ADS1115Sensor::dump_config() {
   LOG_SENSOR("  ", "ADS1115 Sensor", this);
-  ESP_LOGCONFIG(TAG,
-                "    Multiplexer: %u\n"
-                "    Gain: %u\n"
-                "    Resolution: %u\n"
-                "    Sample rate: %u",
-                this->multiplexer_, this->gain_, this->resolution_, this->samplerate_);
+  ESP_LOGCONFIG(TAG, "    Multiplexer: %u", this->multiplexer_);
+  ESP_LOGCONFIG(TAG, "    Gain: %u", this->gain_);
+  ESP_LOGCONFIG(TAG, "    Resolution: %u", this->resolution_);
+  ESP_LOGCONFIG(TAG, "    Sample rate: %u", this->samplerate_);
 }
 
 }  // namespace ads1115

esphome/components/ads1118/sensor/ads1118_sensor.cpp

@@ -9,10 +9,8 @@ static const char *const TAG = "ads1118.sensor";
 
 void ADS1118Sensor::dump_config() {
   LOG_SENSOR("  ", "ADS1118 Sensor", this);
-  ESP_LOGCONFIG(TAG,
-                "    Multiplexer: %u\n"
-                "    Gain: %u",
-                this->multiplexer_, this->gain_);
+  ESP_LOGCONFIG(TAG, "    Multiplexer: %u", this->multiplexer_);
+  ESP_LOGCONFIG(TAG, "    Gain: %u", this->gain_);
 }
 
 float ADS1118Sensor::sample() {

esphome/components/airthings_ble/airthings_listener.cpp

@@ -20,8 +20,7 @@ bool AirthingsListener::parse_device(const esp32_ble_tracker::ESPBTDevice &devic
       sn |= ((uint32_t) it.data[2] << 16);
       sn |= ((uint32_t) it.data[3] << 24);
 
-      char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-      ESP_LOGD(TAG, "Found AirThings device Serial:%" PRIu32 " (MAC: %s)", sn, device.address_str_to(addr_buf));
+      ESP_LOGD(TAG, "Found AirThings device Serial:%" PRIu32 " (MAC: %s)", sn, device.address_str().c_str());
       return true;
     }
   }

esphome/components/airthings_wave_base/airthings_wave_base.cpp

@@ -1,5 +1,4 @@
 #include "airthings_wave_base.h"
-#include "esphome/components/esp32_ble/ble_uuid.h"
 
 // All information related to reading battery information came from the sensors.airthings_wave
 // project by Sverre Hamre (https://github.com/sverrham/sensor.airthings_wave)
@@ -94,10 +93,8 @@ void AirthingsWaveBase::update() {
 bool AirthingsWaveBase::request_read_values_() {
   auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->sensors_data_characteristic_uuid_);
   if (chr == nullptr) {
-    char service_buf[esp32_ble::UUID_STR_LEN];
-    char char_buf[esp32_ble::UUID_STR_LEN];
-    ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_str(service_buf),
-             this->sensors_data_characteristic_uuid_.to_str(char_buf));
+    ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_string().c_str(),
+             this->sensors_data_characteristic_uuid_.to_string().c_str());
     return false;
   }
 
@@ -120,20 +117,17 @@ bool AirthingsWaveBase::request_battery_() {
 
   auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->access_control_point_characteristic_uuid_);
   if (chr == nullptr) {
-    char service_buf[esp32_ble::UUID_STR_LEN];
-    char char_buf[esp32_ble::UUID_STR_LEN];
     ESP_LOGW(TAG, "No access control point characteristic found at service %s char %s",
-             this->service_uuid_.to_str(service_buf), this->access_control_point_characteristic_uuid_.to_str(char_buf));
+             this->service_uuid_.to_string().c_str(),
+             this->access_control_point_characteristic_uuid_.to_string().c_str());
     return false;
   }
 
   auto *descr = this->parent()->get_descriptor(this->service_uuid_, this->access_control_point_characteristic_uuid_,
                                                CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR_UUID);
   if (descr == nullptr) {
-    char service_buf[esp32_ble::UUID_STR_LEN];
-    char char_buf[esp32_ble::UUID_STR_LEN];
-    ESP_LOGW(TAG, "No CCC descriptor found at service %s char %s", this->service_uuid_.to_str(service_buf),
-             this->access_control_point_characteristic_uuid_.to_str(char_buf));
+    ESP_LOGW(TAG, "No CCC descriptor found at service %s char %s", this->service_uuid_.to_string().c_str(),
+             this->access_control_point_characteristic_uuid_.to_string().c_str());
     return false;
   }
 

esphome/components/alarm_control_panel/alarm_control_panel.cpp

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

esphome/components/alarm_control_panel/alarm_control_panel.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <map>
+
 #include "alarm_control_panel_call.h"
 #include "alarm_control_panel_state.h"
 
@@ -7,7 +9,8 @@
 #include "esphome/core/entity_base.h"
 #include "esphome/core/log.h"
 
-namespace esphome::alarm_control_panel {
+namespace esphome {
+namespace alarm_control_panel {
 
 enum AlarmControlPanelFeature : uint8_t {
   // Matches Home Assistant values
@@ -138,4 +141,5 @@ class AlarmControlPanel : public EntityBase {
   LazyCallbackManager<void()> ready_callback_{};
 };
 
-}  // namespace esphome::alarm_control_panel
+}  // namespace alarm_control_panel
+}  // namespace esphome

esphome/components/alarm_control_panel/alarm_control_panel_call.cpp

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

esphome/components/alarm_control_panel/alarm_control_panel_call.h

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

esphome/components/alarm_control_panel/alarm_control_panel_state.cpp

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

esphome/components/alarm_control_panel/alarm_control_panel_state.h

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

esphome/components/alarm_control_panel/automation.h

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

esphome/components/alpha3/alpha3.h

@@ -15,8 +15,10 @@ namespace alpha3 {
 namespace espbt = esphome::esp32_ble_tracker;
 
 static const espbt::ESPBTUUID ALPHA3_GENI_SERVICE_UUID = espbt::ESPBTUUID::from_uint16(0xfe5d);
-static const espbt::ESPBTUUID ALPHA3_GENI_CHARACTERISTIC_UUID = espbt::ESPBTUUID::from_raw(
-    {0xa9, 0x7b, 0xb8, 0x85, 0x00, 0x1a, 0x28, 0xaa, 0x2a, 0x43, 0x6e, 0x03, 0xd1, 0xff, 0x9c, 0x85});
+static const espbt::ESPBTUUID ALPHA3_GENI_CHARACTERISTIC_UUID =
+    espbt::ESPBTUUID::from_raw({static_cast<char>(0xa9), 0x7b, static_cast<char>(0xb8), static_cast<char>(0x85), 0x0,
+                                0x1a, 0x28, static_cast<char>(0xaa), 0x2a, 0x43, 0x6e, 0x3, static_cast<char>(0xd1),
+                                static_cast<char>(0xff), static_cast<char>(0x9c), static_cast<char>(0x85)});
 static const int16_t GENI_RESPONSE_HEADER_LENGTH = 13;
 static const size_t GENI_RESPONSE_TYPE_LENGTH = 8;
 

esphome/components/anova/anova.cpp

@@ -67,10 +67,8 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
     case ESP_GATTC_SEARCH_CMPL_EVT: {
       auto *chr = this->parent_->get_characteristic(ANOVA_SERVICE_UUID, ANOVA_CHARACTERISTIC_UUID);
       if (chr == nullptr) {
-        ESP_LOGW(TAG,
-                 "[%s] No control service found at device, not an Anova..?\n"
-                 "[%s] Note, this component does not currently support Anova Nano.",
-                 this->get_name().c_str(), this->get_name().c_str());
+        ESP_LOGW(TAG, "[%s] No control service found at device, not an Anova..?", this->get_name().c_str());
+        ESP_LOGW(TAG, "[%s] Note, this component does not currently support Anova Nano.", this->get_name().c_str());
         break;
       }
       this->char_handle_ = chr->handle;

esphome/components/api/__init__.py

@@ -4,7 +4,6 @@ import logging
 from esphome import automation
 from esphome.automation import Condition
 import esphome.codegen as cg
-from esphome.components.logger import request_log_listener
 from esphome.config_helpers import get_logger_level
 import esphome.config_validation as cv
 from esphome.const import (
@@ -227,6 +226,32 @@ def _encryption_schema(config):
     return ENCRYPTION_SCHEMA(config)
 
 
+def _validate_api_config(config: ConfigType) -> ConfigType:
+    """Validate API configuration with mutual exclusivity check and deprecation warning."""
+    # Check if both password and encryption are configured
+    has_password = CONF_PASSWORD in config and config[CONF_PASSWORD]
+    has_encryption = CONF_ENCRYPTION in config
+
+    if has_password and has_encryption:
+        raise cv.Invalid(
+            "The 'password' and 'encryption' options are mutually exclusive. "
+            "The API client only supports one authentication method at a time. "
+            "Please remove one of them. "
+            "Note: 'password' authentication is deprecated and will be removed in version 2026.1.0. "
+            "We strongly recommend using 'encryption' instead for better security."
+        )
+
+    # Warn about password deprecation
+    if has_password:
+        _LOGGER.warning(
+            "API 'password' authentication has been deprecated since May 2022 and will be removed in version 2026.1.0. "
+            "Please migrate to the 'encryption' configuration. "
+            "See https://esphome.io/components/api/#configuration-variables"
+        )
+
+    return config
+
+
 def _consume_api_sockets(config: ConfigType) -> ConfigType:
     """Register socket needs for API component."""
     from esphome.components import socket
@@ -243,17 +268,7 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(): cv.declare_id(APIServer),
             cv.Optional(CONF_PORT, default=6053): cv.port,
-            # Removed in 2026.1.0 - kept to provide helpful error message
-            cv.Optional(CONF_PASSWORD): cv.invalid(
-                "The 'password' option has been removed in ESPHome 2026.1.0.\n"
-                "Password authentication was deprecated in May 2022.\n"
-                "Please migrate to encryption for secure API communication:\n\n"
-                "api:\n"
-                "  encryption:\n"
-                "    key: !secret api_encryption_key\n\n"
-                "Generate a key with: openssl rand -base64 32\n"
-                "Or visit https://esphome.io/components/api/#configuration-variables"
-            ),
+            cv.Optional(CONF_PASSWORD, default=""): cv.string_strict,
             cv.Optional(
                 CONF_REBOOT_TIMEOUT, default="15min"
             ): cv.positive_time_period_milliseconds,
@@ -315,6 +330,7 @@ CONFIG_SCHEMA = cv.All(
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.rename_key(CONF_SERVICES, CONF_ACTIONS),
+    _validate_api_config,
     _consume_api_sockets,
 )
 
@@ -327,10 +343,10 @@ async def to_code(config: ConfigType) -> None:
     # Track controller registration for StaticVector sizing
     CORE.register_controller()
 
-    # Request a log listener slot for API log streaming
-    request_log_listener()
-
     cg.add(var.set_port(config[CONF_PORT]))
+    if config[CONF_PASSWORD]:
+        cg.add_define("USE_API_PASSWORD")
+        cg.add(var.set_password(config[CONF_PASSWORD]))
     cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
     cg.add(var.set_batch_delay(config[CONF_BATCH_DELAY]))
     if CONF_LISTEN_BACKLOG in config:

esphome/components/api/api.proto

@@ -7,7 +7,10 @@ service APIConnection {
     option (needs_setup_connection) = false;
     option (needs_authentication) = false;
   }
-  // REMOVED in ESPHome 2026.1.0: rpc authenticate (AuthenticationRequest) returns (AuthenticationResponse)
+  rpc authenticate (AuthenticationRequest) returns (AuthenticationResponse) {
+    option (needs_setup_connection) = false;
+    option (needs_authentication) = false;
+  }
   rpc disconnect (DisconnectRequest) returns (DisconnectResponse) {
     option (needs_setup_connection) = false;
     option (needs_authentication) = false;
@@ -66,8 +69,6 @@ service APIConnection {
 
   rpc zwave_proxy_frame(ZWaveProxyFrame) returns (void) {}
   rpc zwave_proxy_request(ZWaveProxyRequest) returns (void) {}
-
-  rpc infrared_rf_transmit_raw_timings(InfraredRFTransmitRawTimingsRequest) returns (void) {}
 }
 
 
@@ -81,13 +82,14 @@ service APIConnection {
 //  * VarInt denoting the type of message.
 //  * The message object encoded as a ProtoBuf message
 
-// The connection is established in 2 steps:
+// The connection is established in 4 steps:
 //  * First, the client connects to the server and sends a "Hello Request" identifying itself
-//  * The server responds with a "Hello Response" and the connection is authenticated
+//  * The server responds with a "Hello Response" and selects the protocol version
+//  * After receiving this message, the client attempts to authenticate itself using
+//    the password and a "Connect Request"
+//  * The server responds with a "Connect Response" and notifies of invalid password.
 // If anything in this initial process fails, the connection must immediately closed
 // by both sides and _no_ disconnection message is to be sent.
-// Note: Password authentication via AuthenticationRequest/AuthenticationResponse (message IDs 3, 4)
-// was removed in ESPHome 2026.1.0. Those message IDs are reserved and should not be reused.
 
 // Message sent at the beginning of each connection
 // Can only be sent by the client and only at the beginning of the connection
@@ -100,7 +102,7 @@ message HelloRequest {
   // For example "Home Assistant"
   // Not strictly necessary to send but nice for debugging
   // purposes.
-  string client_info = 1;
+  string client_info = 1 [(pointer_to_buffer) = true];
   uint32 api_version_major = 2;
   uint32 api_version_minor = 3;
 }
@@ -128,23 +130,25 @@ message HelloResponse {
   string name = 4;
 }
 
-// DEPRECATED in ESPHome 2026.1.0 - Password authentication is no longer supported.
-// These messages are kept for protocol documentation but are not processed by the server.
-// Use noise encryption instead: https://esphome.io/components/api/#configuration-variables
+// Message sent at the beginning of each connection to authenticate the client
+// Can only be sent by the client and only at the beginning of the connection
 message AuthenticationRequest {
   option (id) = 3;
   option (source) = SOURCE_CLIENT;
   option (no_delay) = true;
-  option deprecated = true;
+  option (ifdef) = "USE_API_PASSWORD";
 
-  string password = 1;
+  // The password to log in with
+  string password = 1 [(pointer_to_buffer) = true];
 }
 
+// Confirmation of successful connection. After this the connection is available for all traffic.
+// Can only be sent by the server and only at the beginning of the connection
 message AuthenticationResponse {
   option (id) = 4;
   option (source) = SOURCE_SERVER;
   option (no_delay) = true;
-  option deprecated = true;
+  option (ifdef) = "USE_API_PASSWORD";
 
   bool invalid_password = 1;
 }
@@ -201,9 +205,7 @@ message DeviceInfoResponse {
   option (id) = 10;
   option (source) = SOURCE_SERVER;
 
-  // Deprecated in ESPHome 2026.1.0, but kept for backward compatibility
-  // with older ESPHome versions that still send this field.
-  bool uses_password = 1 [deprecated = true];
+  bool uses_password = 1 [(field_ifdef) = "USE_API_PASSWORD"];
 
   // The name of the node, given by "App.set_name()"
   string name = 2;
@@ -475,7 +477,7 @@ message FanCommandRequest {
   bool has_speed_level = 10;
   int32 speed_level = 11;
   bool has_preset_mode = 12;
-  string preset_mode = 13;
+  string preset_mode = 13 [(pointer_to_buffer) = true];
   uint32 device_id = 14 [(field_ifdef) = "USE_DEVICES"];
 }
 
@@ -577,7 +579,7 @@ message LightCommandRequest {
   bool has_flash_length = 16;
   uint32 flash_length = 17;
   bool has_effect = 18;
-  string effect = 19;
+  string effect = 19 [(pointer_to_buffer) = true];
   uint32 device_id = 28 [(field_ifdef) = "USE_DEVICES"];
 }
 
@@ -745,7 +747,7 @@ message NoiseEncryptionSetKeyRequest {
   option (source) = SOURCE_CLIENT;
   option (ifdef) = "USE_API_NOISE";
 
-  bytes key = 1;
+  bytes key = 1 [(pointer_to_buffer) = true];
 }
 
 message NoiseEncryptionSetKeyResponse {
@@ -765,7 +767,7 @@ message SubscribeHomeassistantServicesRequest {
 
 message HomeassistantServiceMap {
   string key = 1;
-  string value = 2;
+  string value = 2 [(no_zero_copy) = true];
 }
 
 message HomeassistantActionRequest {
@@ -781,7 +783,7 @@ message HomeassistantActionRequest {
   bool is_event = 5;
   uint32 call_id = 6 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES"];
   bool wants_response = 7 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
-  string response_template = 8 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
+  string response_template = 8 [(no_zero_copy) = true, (field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
 }
 
 // Message sent by Home Assistant to ESPHome with service call response data
@@ -794,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 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
+  bytes response_data = 4 [(pointer_to_buffer) = true, (field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
 }
 
 // ==================== IMPORT HOME ASSISTANT STATES ====================
@@ -822,9 +824,9 @@ message HomeAssistantStateResponse {
   option (no_delay) = true;
   option (ifdef) = "USE_API_HOMEASSISTANT_STATES";
 
-  string entity_id = 1;
-  string state = 2;
-  string attribute = 3;
+  string entity_id = 1 [(pointer_to_buffer) = true];
+  string state = 2 [(pointer_to_buffer) = true];
+  string attribute = 3 [(pointer_to_buffer) = true];
 }
 
 // ==================== IMPORT TIME ====================
@@ -839,7 +841,7 @@ message GetTimeResponse {
   option (no_delay) = true;
 
   fixed32 epoch_seconds = 1;
-  string timezone = 2;
+  string timezone = 2 [(pointer_to_buffer) = true];
 }
 
 // ==================== USER-DEFINES SERVICES ====================
@@ -1089,11 +1091,11 @@ message ClimateCommandRequest {
   bool has_swing_mode = 14;
   ClimateSwingMode swing_mode = 15;
   bool has_custom_fan_mode = 16;
-  string custom_fan_mode = 17;
+  string custom_fan_mode = 17 [(pointer_to_buffer) = true];
   bool has_preset = 18;
   ClimatePreset preset = 19;
   bool has_custom_preset = 20;
-  string custom_preset = 21;
+  string custom_preset = 21 [(pointer_to_buffer) = true];
   bool has_target_humidity = 22;
   float target_humidity = 23;
   uint32 device_id = 24 [(field_ifdef) = "USE_DEVICES"];
@@ -1272,7 +1274,7 @@ message SelectCommandRequest {
   option (base_class) = "CommandProtoMessage";
 
   fixed32 key = 1;
-  string state = 2;
+  string state = 2 [(pointer_to_buffer) = true];
   uint32 device_id = 3 [(field_ifdef) = "USE_DEVICES"];
 }
 
@@ -1290,7 +1292,7 @@ message ListEntitiesSirenResponse {
 
   string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
   bool disabled_by_default = 6;
-  repeated string tones = 7 [(container_pointer_no_template) = "FixedVector<const char *>"];
+  repeated string tones = 7;
   bool supports_duration = 8;
   bool supports_volume = 9;
   EntityCategory entity_category = 10;
@@ -1690,7 +1692,7 @@ message BluetoothGATTWriteRequest {
   uint32 handle = 2;
   bool response = 3;
 
-  bytes data = 4;
+  bytes data = 4 [(pointer_to_buffer) = true];
 }
 
 message BluetoothGATTReadDescriptorRequest {
@@ -1710,7 +1712,7 @@ message BluetoothGATTWriteDescriptorRequest {
   uint64 address = 1;
   uint32 handle = 2;
 
-  bytes data = 3;
+  bytes data = 3 [(pointer_to_buffer) = true];
 }
 
 message BluetoothGATTNotifyRequest {
@@ -1935,7 +1937,7 @@ message VoiceAssistantAudio {
   option (source) = SOURCE_BOTH;
   option (ifdef) = "USE_VOICE_ASSISTANT";
 
-  bytes data = 1 [(pointer_to_buffer) = true];
+  bytes data = 1;
   bool end = 2;
 }
 
@@ -2423,7 +2425,7 @@ message ZWaveProxyFrame {
   option (ifdef) = "USE_ZWAVE_PROXY";
   option (no_delay) = true;
 
-  bytes data = 1;
+  bytes data = 1 [(pointer_to_buffer) = true];
 }
 
 enum ZWaveProxyRequestType {
@@ -2437,51 +2439,5 @@ message ZWaveProxyRequest {
   option (ifdef) = "USE_ZWAVE_PROXY";
 
   ZWaveProxyRequestType type = 1;
-  bytes data = 2;
-}
-
-// ==================== INFRARED ====================
-// Note: Feature and capability flag enums are defined in
-// esphome/components/infrared/infrared.h
-
-// Listing of infrared instances
-message ListEntitiesInfraredResponse {
-  option (id) = 135;
-  option (base_class) = "InfoResponseProtoMessage";
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_INFRARED";
-
-  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"];
-  uint32 capabilities = 8;  // Bitfield of InfraredCapabilityFlags
-}
-
-// Command to transmit infrared/RF data using raw timings
-message InfraredRFTransmitRawTimingsRequest {
-  option (id) = 136;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_IR_RF";
-
-  uint32 device_id = 1 [(field_ifdef) = "USE_DEVICES"];
-  fixed32 key = 2;                                       // Key identifying the transmitter instance
-  uint32 carrier_frequency = 3;                          // Carrier frequency in Hz
-  uint32 repeat_count = 4;                               // Number of times to transmit (1 = once, 2 = twice, etc.)
-  repeated sint32 timings = 5 [packed = true, (packed_buffer) = true];  // Raw timings in microseconds (zigzag-encoded): positive = mark (LED/TX on), negative = space (LED/TX off)
-}
-
-// Event message for received infrared/RF data
-message InfraredRFReceiveEvent {
-  option (id) = 137;
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_IR_RF";
-  option (no_delay) = true;
-
-  uint32 device_id = 1 [(field_ifdef) = "USE_DEVICES"];
-  fixed32 key = 2;                                    // Key identifying the receiver instance
-  repeated sint32 timings = 3 [packed = true, (container_pointer_no_template) = "std::vector<int32_t>"];  // Raw timings in microseconds (zigzag-encoded): alternating mark/space periods
+  bytes data = 2 [(pointer_to_buffer) = true];
 }

esphome/components/api/api_connection.h

@@ -9,24 +9,32 @@
 #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 <limits>
 #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
-// 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)
-// Verify MAX_MESSAGES_PER_BATCH (defined in api_frame_helper.h) can hold the initial batch
-static_assert(MAX_MESSAGES_PER_BATCH >= MAX_INITIAL_PER_BATCH,
-              "MAX_MESSAGES_PER_BATCH must be >= MAX_INITIAL_PER_BATCH");
+// 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;
+// 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
+#if defined(USE_ESP32) || defined(USE_HOST)
+static constexpr size_t MAX_PACKETS_PER_BATCH = 64;  // ESP32 has 8KB+ stack, HOST has plenty
+#else
+static constexpr size_t MAX_PACKETS_PER_BATCH = 32;  // ESP8266/RP2040/etc have smaller stacks
+#endif
 
 class APIConnection final : public APIServerConnection {
  public:
@@ -39,8 +47,8 @@ class APIConnection final : public APIServerConnection {
   void loop();
 
   bool send_list_info_done() {
-    return this->schedule_message_(nullptr, ListEntitiesDoneResponse::MESSAGE_TYPE,
-                                   ListEntitiesDoneResponse::ESTIMATED_SIZE);
+    return this->schedule_message_(nullptr, &APIConnection::try_send_list_info_done,
+                                   ListEntitiesDoneResponse::MESSAGE_TYPE, ListEntitiesDoneResponse::ESTIMATED_SIZE);
   }
 #ifdef USE_BINARY_SENSOR
   bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor);
@@ -173,13 +181,8 @@ class APIConnection final : public APIServerConnection {
   void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
 #endif
 
-#ifdef USE_IR_RF
-  void infrared_rf_transmit_raw_timings(const InfraredRFTransmitRawTimingsRequest &msg) override;
-  void send_infrared_rf_receive_event(const InfraredRFReceiveEvent &msg);
-#endif
-
 #ifdef USE_EVENT
-  void send_event(event::Event *event);
+  void send_event(event::Event *event, const char *event_type);
 #endif
 
 #ifdef USE_UPDATE
@@ -199,17 +202,16 @@ class APIConnection final : public APIServerConnection {
   void on_get_time_response(const GetTimeResponse &value) override;
 #endif
   bool send_hello_response(const HelloRequest &msg) override;
+#ifdef USE_API_PASSWORD
+  bool send_authenticate_response(const AuthenticationRequest &msg) override;
+#endif
   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->begin_iterator_(ActiveIterator::LIST_ENTITIES); }
+  void list_entities(const ListEntitiesRequest &msg) override { this->list_entities_iterator_.begin(); }
   void subscribe_states(const SubscribeStatesRequest &msg) override {
     this->flags_.state_subscription = true;
-    // 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);
-    }
+    this->initial_state_iterator_.begin();
   }
   void subscribe_logs(const SubscribeLogsRequest &msg) override {
     this->flags_.log_subscription = msg.level;
@@ -227,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, StringRef error_message);
+  void send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  void send_execute_service_response(uint32_t call_id, bool success, StringRef error_message,
+  void send_execute_service_response(uint32_t call_id, bool success, const std::string &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
@@ -254,6 +256,9 @@ class APIConnection final : public APIServerConnection {
   }
 
   void on_fatal_error() override;
+#ifdef USE_API_PASSWORD
+  void on_unauthenticated_access() override;
+#endif
   void on_no_setup_connection() override;
   ProtoWriteBuffer create_buffer(uint32_t reserve_size) override {
     // FIXME: ensure no recursive writes can happen
@@ -280,18 +285,13 @@ 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 char *get_name() const { return this->helper_->get_client_name(); }
-  /// Get peer name (IP address) - cached at connection init time
-  const char *get_peername() const { return this->helper_->get_client_peername(); }
+  const std::string &get_name() const { return this->client_info_.name; }
+  const std::string &get_peername() const { return this->client_info_.peername; }
 
  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
@@ -315,24 +315,25 @@ 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();
-
-    // 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.object_id = entity->get_object_id_to(object_id_buf);
+    // 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));
     }
 
     if (entity->has_own_name()) {
-      msg.name = entity->get_name();
+      msg.set_name(entity->get_name());
     }
 
     // Set common EntityBase properties
 #ifdef USE_ENTITY_ICON
-    msg.icon = entity->get_icon_ref();
+    msg.set_icon(entity->get_icon_ref());
 #endif
     msg.disabled_by_default = entity->is_disabled_by_default();
     msg.entity_category = static_cast<enums::EntityCategory>(entity->get_entity_category());
@@ -347,24 +348,16 @@ 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();
-    size_t max_batch = this->get_max_batch_size_();
-    while (!iterator.completed() && (this->deferred_batch_.size() - initial_size) < max_batch) {
+    while (!iterator.completed() && (this->deferred_batch_.size() - initial_size) < MAX_INITIAL_PER_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_batch) {
+    if (this->deferred_batch_.size() >= MAX_INITIAL_PER_BATCH) {
       this->process_batch_();
     }
   }
@@ -474,12 +467,8 @@ class APIConnection final : public APIServerConnection {
   static uint16_t try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single);
 #endif
-#ifdef USE_INFRARED
-  static uint16_t try_send_infrared_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, StringRef event_type, APIConnection *conn,
+  static uint16_t try_send_event_response(event::Event *event, const char *event_type, APIConnection *conn,
                                           uint32_t remaining_size, bool is_single);
   static uint16_t try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
@@ -512,27 +501,18 @@ class APIConnection final : public APIServerConnection {
   std::unique_ptr<APIFrameHelper> helper_;
   APIServer *parent_;
 
-  // 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);
+  // 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_;
 #ifdef USE_CAMERA
   std::unique_ptr<camera::CameraImageReader> image_reader_;
 #endif
 
-  // Group 3: 4-byte types
+  // Group 3: Client info struct (24 bytes on 32-bit: 2 strings × 12 bytes each)
+  ClientInfo client_info_;
+
+  // Group 4: 4-byte types
   uint32_t last_traffic_;
 #ifdef USE_API_HOMEASSISTANT_STATES
   int state_subs_at_ = -1;
@@ -541,17 +521,33 @@ class APIConnection final : public APIServerConnection {
   // Function pointer type for message encoding
   using MessageCreatorPtr = uint16_t (*)(EntityBase *, APIConnection *, uint32_t remaining_size, bool is_single);
 
+  class MessageCreator {
+   public:
+    MessageCreator(MessageCreatorPtr ptr) { data_.function_ptr = ptr; }
+    explicit MessageCreator(const char *str_value) { data_.const_char_ptr = str_value; }
+
+    // Call operator - uses message_type to determine union type
+    uint16_t operator()(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single,
+                        uint8_t message_type) const;
+
+   private:
+    union Data {
+      MessageCreatorPtr function_ptr;
+      const char *const_char_ptr;
+    } data_;  // 4 bytes on 32-bit, 8 bytes on 64-bit
+  };
+
   // Generic batching mechanism for both state updates and entity info
   struct DeferredBatch {
-    // Sentinel value for unused aux_data_index
-    static constexpr uint8_t AUX_DATA_UNUSED = std::numeric_limits<uint8_t>::max();
-
     struct BatchItem {
-      EntityBase *entity;                       // 4 bytes - Entity pointer
-      uint8_t message_type;                     // 1 byte - Message type for protocol and dispatch
-      uint8_t estimated_size;                   // 1 byte - Estimated message size (max 255 bytes)
-      uint8_t aux_data_index{AUX_DATA_UNUSED};  // 1 byte - For events: index into entity's event_types
-      // 1 byte padding
+      EntityBase *entity;      // Entity pointer
+      MessageCreator creator;  // Function that creates the message when needed
+      uint8_t message_type;    // Message type for overhead calculation (max 255)
+      uint8_t estimated_size;  // Estimated message size (max 255 bytes)
+
+      // Constructor for creating BatchItem
+      BatchItem(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size)
+          : entity(entity), creator(creator), message_type(message_type), estimated_size(estimated_size) {}
     };
 
     std::vector<BatchItem> items;
@@ -560,11 +556,10 @@ class APIConnection final : public APIServerConnection {
     // No pre-allocation - log connections never use batching, and for
     // connections that do, buffers are released after initial sync anyway
 
-    // Add item to the batch (with deduplication)
-    void add_item(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
-                  uint8_t aux_data_index = AUX_DATA_UNUSED);
+    // Add item to the batch
+    void add_item(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size);
     // Add item to the front of the batch (for high priority messages like ping)
-    void add_item_front(EntityBase *entity, uint8_t message_type, uint8_t estimated_size);
+    void add_item_front(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size);
 
     // Clear all items
     void clear() {
@@ -578,7 +573,6 @@ class APIConnection final : public APIServerConnection {
     bool empty() const { return items.empty(); }
     size_t size() const { return items.size(); }
     const BatchItem &operator[](size_t index) const { return items[index]; }
-
     // Release excess capacity - only releases if items already empty
     void release_buffer() {
       // Safe to call: batch is processed before release_buffer is called,
@@ -625,9 +619,7 @@ 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};
-  // 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
+  // Total: 2 (flags) + 2 + 2 = 6 bytes, then 2 bytes 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
@@ -650,16 +642,18 @@ class APIConnection final : public APIServerConnection {
     this->flags_.batch_scheduled = false;
   }
 
-  // Dispatch message encoding based on message_type - replaces function pointer storage
-  // Switch assigns pointer, single call site for smaller code size
-  uint16_t dispatch_message_(const DeferredBatch::BatchItem &item, uint32_t remaining_size, bool is_single);
-
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  void log_batch_item_(const DeferredBatch::BatchItem &item) {
+  // Helper to log a proto message from a MessageCreator object
+  void log_proto_message_(EntityBase *entity, const MessageCreator &creator, uint8_t message_type) {
     this->flags_.log_only_mode = true;
-    this->dispatch_message_(item, MAX_BATCH_PACKET_SIZE, true);
+    creator(entity, this, MAX_BATCH_PACKET_SIZE, true, message_type);
     this->flags_.log_only_mode = false;
   }
+
+  void log_batch_item_(const DeferredBatch::BatchItem &item) {
+    // Use the helper to log the message
+    this->log_proto_message_(item.entity, item.creator, item.message_type);
+  }
 #endif
 
   // Helper to check if a message type should bypass batching
@@ -683,36 +677,66 @@ class APIConnection final : public APIServerConnection {
   // Helper method to send a message either immediately or via batching
   // Tries immediate send if should_send_immediately_() returns true and buffer has space
   // Falls back to batching if immediate send fails or isn't applicable
-  bool send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
-                           uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED) {
+  bool send_message_smart_(EntityBase *entity, MessageCreatorPtr creator, uint8_t message_type,
+                           uint8_t estimated_size) {
     if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
-      DeferredBatch::BatchItem item{entity, message_type, estimated_size, aux_data_index};
-      if (this->dispatch_message_(item, MAX_BATCH_PACKET_SIZE, true) &&
+      // Now actually encode and send
+      if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true) &&
           this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
-        this->log_batch_item_(item);
+        // Log the message in verbose mode
+        this->log_proto_message_(entity, MessageCreator(creator), message_type);
 #endif
         return true;
       }
+
+      // If immediate send failed, fall through to batching
     }
-    return this->schedule_message_(entity, message_type, estimated_size, aux_data_index);
+
+    // Fall back to scheduled batching
+    return this->schedule_message_(entity, creator, message_type, estimated_size);
+  }
+
+  // Overload for MessageCreator (used by events which need to capture event_type)
+  bool send_message_smart_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
+    // Try to send immediately if message type should bypass batching and buffer has space
+    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
+      // Now actually encode and send
+      if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true, message_type) &&
+          this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+        // Log the message in verbose mode
+        this->log_proto_message_(entity, creator, message_type);
+#endif
+        return true;
+      }
+
+      // If immediate send failed, fall through to batching
+    }
+
+    // Fall back to scheduled batching
+    return this->schedule_message_(entity, creator, message_type, estimated_size);
   }
 
   // Helper function to schedule a deferred message with known message type
-  bool schedule_message_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
-                         uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED) {
-    this->deferred_batch_.add_item(entity, message_type, estimated_size, aux_data_index);
+  bool schedule_message_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
+    this->deferred_batch_.add_item(entity, creator, message_type, estimated_size);
     return this->schedule_batch_();
   }
 
+  // Overload for function pointers (for info messages and current state reads)
+  bool schedule_message_(EntityBase *entity, MessageCreatorPtr function_ptr, uint8_t message_type,
+                         uint8_t estimated_size) {
+    return schedule_message_(entity, MessageCreator(function_ptr), message_type, estimated_size);
+  }
+
   // Helper function to schedule a high priority message at the front of the batch
-  bool schedule_message_front_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size) {
-    this->deferred_batch_.add_item_front(entity, message_type, estimated_size);
+  bool schedule_message_front_(EntityBase *entity, MessageCreatorPtr function_ptr, uint8_t message_type,
+                               uint8_t estimated_size) {
+    this->deferred_batch_.add_item_front(entity, MessageCreator(function_ptr), message_type, estimated_size);
     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,5 +1,6 @@
 #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"
@@ -12,29 +13,12 @@ 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_name_, this->client_peername_, ##__VA_ARGS__)
-#else
-#define HELPER_LOG(msg, ...) ((void) 0)
-#endif
+#define HELPER_LOG(msg, ...) \
+  ESP_LOGVV(TAG, "%s (%s): " msg, this->client_info_->name.c_str(), this->client_info_->peername.c_str(), ##__VA_ARGS__)
 
 #ifdef HELPER_LOG_PACKETS
-#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)
+#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())
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
 #define LOG_PACKET_SENDING(data, len) ((void) 0)
@@ -245,8 +229,6 @@ APIError APIFrameHelper::init_common_() {
     HELPER_LOG("Bad state for init %d", (int) state_);
     return APIError::BAD_STATE;
   }
-  // Cache peername now while socket is valid - needed for error logging after socket failure
-  this->socket_->getpeername_to(this->client_peername_);
   int err = this->socket_->setblocking(false);
   if (err != 0) {
     state_ = State::FAILED;

esphome/components/api/api_frame_helper.h

@@ -29,28 +29,24 @@ 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
 
-// Maximum number of messages to batch in a single write operation
-// Must be >= MAX_INITIAL_PER_BATCH in api_connection.h (enforced by static_assert there)
-static constexpr size_t MAX_MESSAGES_PER_BATCH = 34;
+// 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;
   uint16_t type;
 };
 
-// Packed message info structure to minimize memory usage
-struct MessageInfo {
+// Packed packet info structure to minimize memory usage
+struct PacketInfo {
   uint16_t offset;        // Offset in buffer where message starts
   uint16_t payload_size;  // Size of the message payload
   uint8_t message_type;   // Message type (0-255)
 
-  MessageInfo(uint8_t type, uint16_t off, uint16_t size) : offset(off), payload_size(size), message_type(type) {}
+  PacketInfo(uint8_t type, uint16_t off, uint16_t size) : offset(off), payload_size(size), message_type(type) {}
 };
 
 enum class APIError : uint16_t {
@@ -86,23 +82,14 @@ const LogString *api_error_to_logstr(APIError err);
 class APIFrameHelper {
  public:
   APIFrameHelper() = default;
-  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_; }
-  // Get client peername/IP (null-terminated, cached at init time for availability after socket failure)
-  const char *get_client_peername() const { return this->client_peername_; }
-  // 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';
-  }
+  explicit APIFrameHelper(std::unique_ptr<socket::Socket> socket, const ClientInfo *client_info)
+      : socket_(std::move(socket)), client_info_(client_info) {}
   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); }
   APIError close() {
     state_ = State::CLOSED;
@@ -120,32 +107,11 @@ class APIFrameHelper {
     }
     return APIError::OK;
   }
-  /// Toggle TCP_NODELAY socket option to control Nagle's algorithm.
-  ///
-  /// This is used to allow log messages to coalesce (Nagle enabled) while keeping
-  /// state updates low-latency (NODELAY enabled). Without this, many small log
-  /// packets fill the TCP send buffer, crowding out important state updates.
-  ///
-  /// State is tracked to minimize setsockopt() overhead - on lwip_raw (ESP8266/RP2040)
-  /// this is just a boolean assignment; on other platforms it's a lightweight syscall.
-  ///
-  /// @param enable true to enable NODELAY (disable Nagle), false to enable Nagle
-  /// @return true if successful or already in desired state
-  bool set_nodelay(bool enable) {
-    if (this->nodelay_enabled_ == enable)
-      return true;
-    int val = enable ? 1 : 0;
-    int err = this->socket_->setsockopt(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
-    if (err == 0) {
-      this->nodelay_enabled_ = enable;
-    }
-    return err == 0;
-  }
   virtual APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) = 0;
-  // Write multiple protobuf messages in a single operation
-  // messages contains (message_type, offset, length) for each message in the buffer
+  // Write multiple protobuf packets in a single operation
+  // packets contains (message_type, offset, length) for each message in the buffer
   // The buffer contains all messages with appropriate padding before each
-  virtual APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) = 0;
+  virtual APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) = 0;
   // Get the frame header padding required by this protocol
   uint8_t frame_header_padding() const { return frame_header_padding_; }
   // Get the frame footer size required by this protocol
@@ -161,6 +127,12 @@ class APIFrameHelper {
       // Use swap trick since shrink_to_fit() is non-binding and may be ignored
       std::vector<uint8_t>().swap(this->rx_buf_);
     }
+    // reusable_iovs_: Safe to release unconditionally.
+    // Only used within write_protobuf_packets() calls - cleared at start,
+    // populated with pointers, used for writev(), then function returns.
+    // The iovecs contain stale pointers after the call (data was either sent
+    // or copied to tx_buf_), and are cleared on next write_protobuf_packets().
+    std::vector<struct iovec>().swap(this->reusable_iovs_);
   }
 
  protected:
@@ -214,12 +186,12 @@ class APIFrameHelper {
 
   // Containers (size varies, but typically 12+ bytes on 32-bit)
   std::array<std::unique_ptr<SendBuffer>, API_MAX_SEND_QUEUE> tx_buf_;
+  std::vector<struct iovec> reusable_iovs_;
   std::vector<uint8_t> rx_buf_;
 
-  // Client name buffer - stores name from Hello message or initial peername
-  char client_name_[CLIENT_INFO_NAME_MAX_LEN]{};
-  // Cached peername/IP address - captured at init time for availability after socket failure
-  char client_peername_[socket::SOCKADDR_STR_LEN]{};
+  // 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};
 
   // Group smaller types together
   uint16_t rx_buf_len_ = 0;
@@ -229,10 +201,7 @@ class APIFrameHelper {
   uint8_t tx_buf_head_{0};
   uint8_t tx_buf_tail_{0};
   uint8_t tx_buf_count_{0};
-  // Tracks TCP_NODELAY state to minimize setsockopt() calls. Initialized to true
-  // since init_common_() enables NODELAY. Used by set_nodelay() to allow log
-  // messages to coalesce while keeping state updates low-latency.
-  bool nodelay_enabled_{true};
+  // 8 bytes total, 0 bytes padding
 
   // Common initialization for both plaintext and noise protocols
   APIError init_common_();

esphome/components/api/api_frame_helper_noise.cpp

@@ -24,29 +24,12 @@ 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_name_, this->client_peername_, ##__VA_ARGS__)
-#else
-#define HELPER_LOG(msg, ...) ((void) 0)
-#endif
+#define HELPER_LOG(msg, ...) \
+  ESP_LOGVV(TAG, "%s (%s): " msg, this->client_info_->name.c_str(), this->client_info_->peername.c_str(), ##__VA_ARGS__)
 
 #ifdef HELPER_LOG_PACKETS
-#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)
+#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())
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
 #define LOG_PACKET_SENDING(data, len) ((void) 0)
@@ -432,12 +415,12 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
 APIError APINoiseFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
   // Resize to include MAC space (required for Noise encryption)
   buffer.get_buffer()->resize(buffer.get_buffer()->size() + frame_footer_size_);
-  MessageInfo msg{type, 0,
-                  static_cast<uint16_t>(buffer.get_buffer()->size() - frame_header_padding_ - frame_footer_size_)};
-  return write_protobuf_messages(buffer, std::span<const MessageInfo>(&msg, 1));
+  PacketInfo packet{type, 0,
+                    static_cast<uint16_t>(buffer.get_buffer()->size() - frame_header_padding_ - frame_footer_size_)};
+  return write_protobuf_packets(buffer, std::span<const PacketInfo>(&packet, 1));
 }
 
-APIError APINoiseFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) {
+APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) {
   APIError aerr = state_action_();
   if (aerr != APIError::OK) {
     return aerr;
@@ -447,20 +430,20 @@ APIError APINoiseFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer, s
     return APIError::WOULD_BLOCK;
   }
 
-  if (messages.empty()) {
+  if (packets.empty()) {
     return APIError::OK;
   }
 
   uint8_t *buffer_data = buffer.get_buffer()->data();
 
-  // Stack-allocated iovec array - no heap allocation
-  StaticVector<struct iovec, MAX_MESSAGES_PER_BATCH> iovs;
+  this->reusable_iovs_.clear();
+  this->reusable_iovs_.reserve(packets.size());
   uint16_t total_write_len = 0;
 
-  // We need to encrypt each message in place
-  for (const auto &msg : messages) {
+  // We need to encrypt each packet in place
+  for (const auto &packet : packets) {
     // The buffer already has padding at offset
-    uint8_t *buf_start = buffer_data + msg.offset;
+    uint8_t *buf_start = buffer_data + packet.offset;
 
     // Write noise header
     buf_start[0] = 0x01;  // indicator
@@ -468,10 +451,10 @@ APIError APINoiseFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer, s
 
     // Write message header (to be encrypted)
     const uint8_t msg_offset = 3;
-    buf_start[msg_offset] = static_cast<uint8_t>(msg.message_type >> 8);      // type high byte
-    buf_start[msg_offset + 1] = static_cast<uint8_t>(msg.message_type);       // type low byte
-    buf_start[msg_offset + 2] = static_cast<uint8_t>(msg.payload_size >> 8);  // data_len high byte
-    buf_start[msg_offset + 3] = static_cast<uint8_t>(msg.payload_size);       // data_len low byte
+    buf_start[msg_offset] = static_cast<uint8_t>(packet.message_type >> 8);      // type high byte
+    buf_start[msg_offset + 1] = static_cast<uint8_t>(packet.message_type);       // type low byte
+    buf_start[msg_offset + 2] = static_cast<uint8_t>(packet.payload_size >> 8);  // data_len high byte
+    buf_start[msg_offset + 3] = static_cast<uint8_t>(packet.payload_size);       // data_len low byte
     // payload data is already in the buffer starting at offset + 7
 
     // Make sure we have space for MAC
@@ -480,8 +463,8 @@ APIError APINoiseFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer, s
     // Encrypt the message in place
     NoiseBuffer mbuf;
     noise_buffer_init(mbuf);
-    noise_buffer_set_inout(mbuf, buf_start + msg_offset, 4 + msg.payload_size,
-                           4 + msg.payload_size + frame_footer_size_);
+    noise_buffer_set_inout(mbuf, buf_start + msg_offset, 4 + packet.payload_size,
+                           4 + packet.payload_size + frame_footer_size_);
 
     int err = noise_cipherstate_encrypt(send_cipher_, &mbuf);
     APIError aerr =
@@ -493,14 +476,14 @@ APIError APINoiseFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer, s
     buf_start[1] = static_cast<uint8_t>(mbuf.size >> 8);
     buf_start[2] = static_cast<uint8_t>(mbuf.size);
 
-    // Add iovec for this encrypted message
-    size_t msg_len = static_cast<size_t>(3 + mbuf.size);  // indicator + size + encrypted data
-    iovs.push_back({buf_start, msg_len});
-    total_write_len += msg_len;
+    // Add iovec for this encrypted packet
+    size_t packet_len = static_cast<size_t>(3 + mbuf.size);  // indicator + size + encrypted data
+    this->reusable_iovs_.push_back({buf_start, packet_len});
+    total_write_len += packet_len;
   }
 
-  // Send all encrypted messages in one writev call
-  return this->write_raw_(iovs.data(), iovs.size(), total_write_len);
+  // Send all encrypted packets in one writev call
+  return this->write_raw_(this->reusable_iovs_.data(), this->reusable_iovs_.size(), total_write_len);
 }
 
 APIError APINoiseFrameHelper::write_frame_(const uint8_t *data, uint16_t len) {

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)
-      : APIFrameHelper(std::move(socket)), ctx_(ctx) {
+  APINoiseFrameHelper(std::unique_ptr<socket::Socket> socket, APINoiseContext &ctx, const ClientInfo *client_info)
+      : APIFrameHelper(std::move(socket), client_info), ctx_(ctx) {
     // Noise header structure:
     // Pos 0: indicator (0x01)
     // Pos 1-2: encrypted payload size (16-bit big-endian)
@@ -23,7 +23,7 @@ class APINoiseFrameHelper final : public APIFrameHelper {
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
   APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
-  APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) override;
+  APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) override;
 
  protected:
   APIError state_action_();

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -1,6 +1,7 @@
 #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"
@@ -17,29 +18,12 @@ 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_name_, this->client_peername_, ##__VA_ARGS__)
-#else
-#define HELPER_LOG(msg, ...) ((void) 0)
-#endif
+#define HELPER_LOG(msg, ...) \
+  ESP_LOGVV(TAG, "%s (%s): " msg, this->client_info_->name.c_str(), this->client_info_->peername.c_str(), ##__VA_ARGS__)
 
 #ifdef HELPER_LOG_PACKETS
-#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)
+#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())
 #else
 #define LOG_PACKET_RECEIVED(buffer) ((void) 0)
 #define LOG_PACKET_SENDING(data, len) ((void) 0)
@@ -232,30 +216,29 @@ APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   return APIError::OK;
 }
 APIError APIPlaintextFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
-  MessageInfo msg{type, 0, static_cast<uint16_t>(buffer.get_buffer()->size() - frame_header_padding_)};
-  return write_protobuf_messages(buffer, std::span<const MessageInfo>(&msg, 1));
+  PacketInfo packet{type, 0, static_cast<uint16_t>(buffer.get_buffer()->size() - frame_header_padding_)};
+  return write_protobuf_packets(buffer, std::span<const PacketInfo>(&packet, 1));
 }
 
-APIError APIPlaintextFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffer,
-                                                          std::span<const MessageInfo> messages) {
+APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) {
   if (state_ != State::DATA) {
     return APIError::BAD_STATE;
   }
 
-  if (messages.empty()) {
+  if (packets.empty()) {
     return APIError::OK;
   }
 
   uint8_t *buffer_data = buffer.get_buffer()->data();
 
-  // Stack-allocated iovec array - no heap allocation
-  StaticVector<struct iovec, MAX_MESSAGES_PER_BATCH> iovs;
+  this->reusable_iovs_.clear();
+  this->reusable_iovs_.reserve(packets.size());
   uint16_t total_write_len = 0;
 
-  for (const auto &msg : messages) {
+  for (const auto &packet : packets) {
     // Calculate varint sizes for header layout
-    uint8_t size_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(msg.payload_size));
-    uint8_t type_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(msg.message_type));
+    uint8_t size_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(packet.payload_size));
+    uint8_t type_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(packet.message_type));
     uint8_t total_header_len = 1 + size_varint_len + type_varint_len;
 
     // Calculate where to start writing the header
@@ -283,25 +266,25 @@ APIError APIPlaintextFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffe
     //
     // The message starts at offset + frame_header_padding_
     // So we write the header starting at offset + frame_header_padding_ - total_header_len
-    uint8_t *buf_start = buffer_data + msg.offset;
+    uint8_t *buf_start = buffer_data + packet.offset;
     uint32_t header_offset = frame_header_padding_ - total_header_len;
 
     // Write the plaintext header
     buf_start[header_offset] = 0x00;  // indicator
 
     // Encode varints directly into buffer
-    ProtoVarInt(msg.payload_size).encode_to_buffer_unchecked(buf_start + header_offset + 1, size_varint_len);
-    ProtoVarInt(msg.message_type)
+    ProtoVarInt(packet.payload_size).encode_to_buffer_unchecked(buf_start + header_offset + 1, size_varint_len);
+    ProtoVarInt(packet.message_type)
         .encode_to_buffer_unchecked(buf_start + header_offset + 1 + size_varint_len, type_varint_len);
 
-    // Add iovec for this message (header + payload)
-    size_t msg_len = static_cast<size_t>(total_header_len + msg.payload_size);
-    iovs.push_back({buf_start + header_offset, msg_len});
-    total_write_len += msg_len;
+    // Add iovec for this packet (header + payload)
+    size_t packet_len = static_cast<size_t>(total_header_len + packet.payload_size);
+    this->reusable_iovs_.push_back({buf_start + header_offset, packet_len});
+    total_write_len += packet_len;
   }
 
-  // Send all messages in one writev call
-  return write_raw_(iovs.data(), iovs.size(), total_write_len);
+  // Send all packets in one writev call
+  return write_raw_(this->reusable_iovs_.data(), this->reusable_iovs_.size(), total_write_len);
 }
 
 }  // namespace esphome::api

esphome/components/api/api_frame_helper_plaintext.h

@@ -7,7 +7,8 @@ namespace esphome::api {
 
 class APIPlaintextFrameHelper final : public APIFrameHelper {
  public:
-  explicit APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket) : APIFrameHelper(std::move(socket)) {
+  APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket, const ClientInfo *client_info)
+      : APIFrameHelper(std::move(socket), client_info) {
     // Plaintext header structure (worst case):
     // Pos 0: indicator (0x00)
     // Pos 1-3: payload size varint (up to 3 bytes)
@@ -20,7 +21,7 @@ class APIPlaintextFrameHelper final : public APIFrameHelper {
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
   APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
-  APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) override;
+  APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) override;
 
  protected:
   APIError try_read_frame_();

esphome/components/api/api_options.proto

@@ -27,6 +27,7 @@ extend google.protobuf.MessageOptions {
 extend google.protobuf.FieldOptions {
     optional string field_ifdef = 1042;
     optional uint32 fixed_array_size = 50007;
+    optional bool no_zero_copy = 50008 [default=false];
     optional bool fixed_array_skip_zero = 50009 [default=false];
     optional string fixed_array_size_define = 50010;
     optional string fixed_array_with_length_define = 50011;
@@ -79,15 +80,4 @@ extend google.protobuf.FieldOptions {
     // Example: [(container_pointer_no_template) = "light::ColorModeMask"]
     //   generates: const light::ColorModeMask *supported_color_modes{};
     optional string container_pointer_no_template = 50014;
-
-    // packed_buffer: Expose raw packed buffer instead of decoding into container
-    // When set on a packed repeated field, the generated code stores a pointer
-    // to the raw protobuf buffer instead of decoding values. This enables
-    // zero-copy passthrough when the consumer can decode on-demand.
-    // The field must be a packed repeated field (packed=true).
-    // Generates three fields:
-    //   - const uint8_t *<field>_data_{nullptr};
-    //   - uint16_t <field>_length_{0};
-    //   - uint16_t <field>_count_{0};
-    optional bool packed_buffer = 50015 [default=false];
 }

esphome/components/api/api_pb2_service.cpp

@@ -8,12 +8,8 @@ namespace esphome::api {
 static const char *const TAG = "api.service";
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
-void APIServerConnectionBase::log_send_message_(const char *name, const char *dump) {
-  ESP_LOGVV(TAG, "send_message %s: %s", name, dump);
-}
-void APIServerConnectionBase::log_receive_message_(const LogString *name, const ProtoMessage &msg) {
-  DumpBuffer dump_buf;
-  ESP_LOGVV(TAG, "%s: %s", LOG_STR_ARG(name), msg.dump_to(dump_buf));
+void APIServerConnectionBase::log_send_message_(const char *name, const std::string &dump) {
+  ESP_LOGVV(TAG, "send_message %s: %s", name, dump.c_str());
 }
 #endif
 
@@ -23,16 +19,27 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       HelloRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_hello_request"), msg);
+      ESP_LOGVV(TAG, "on_hello_request: %s", msg.dump().c_str());
 #endif
       this->on_hello_request(msg);
       break;
     }
+#ifdef USE_API_PASSWORD
+    case AuthenticationRequest::MESSAGE_TYPE: {
+      AuthenticationRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_authentication_request: %s", msg.dump().c_str());
+#endif
+      this->on_authentication_request(msg);
+      break;
+    }
+#endif
     case DisconnectRequest::MESSAGE_TYPE: {
       DisconnectRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_disconnect_request"), msg);
+      ESP_LOGVV(TAG, "on_disconnect_request: %s", msg.dump().c_str());
 #endif
       this->on_disconnect_request(msg);
       break;
@@ -41,7 +48,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       DisconnectResponse msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_disconnect_response"), msg);
+      ESP_LOGVV(TAG, "on_disconnect_response: %s", msg.dump().c_str());
 #endif
       this->on_disconnect_response(msg);
       break;
@@ -50,7 +57,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       PingRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_ping_request"), msg);
+      ESP_LOGVV(TAG, "on_ping_request: %s", msg.dump().c_str());
 #endif
       this->on_ping_request(msg);
       break;
@@ -59,7 +66,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       PingResponse msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_ping_response"), msg);
+      ESP_LOGVV(TAG, "on_ping_response: %s", msg.dump().c_str());
 #endif
       this->on_ping_response(msg);
       break;
@@ -68,7 +75,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       DeviceInfoRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_device_info_request"), msg);
+      ESP_LOGVV(TAG, "on_device_info_request: %s", msg.dump().c_str());
 #endif
       this->on_device_info_request(msg);
       break;
@@ -77,7 +84,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ListEntitiesRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_list_entities_request"), msg);
+      ESP_LOGVV(TAG, "on_list_entities_request: %s", msg.dump().c_str());
 #endif
       this->on_list_entities_request(msg);
       break;
@@ -86,7 +93,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeStatesRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_states_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_states_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_states_request(msg);
       break;
@@ -95,7 +102,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeLogsRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_logs_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_logs_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_logs_request(msg);
       break;
@@ -105,7 +112,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       CoverCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_cover_command_request"), msg);
+      ESP_LOGVV(TAG, "on_cover_command_request: %s", msg.dump().c_str());
 #endif
       this->on_cover_command_request(msg);
       break;
@@ -116,7 +123,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       FanCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_fan_command_request"), msg);
+      ESP_LOGVV(TAG, "on_fan_command_request: %s", msg.dump().c_str());
 #endif
       this->on_fan_command_request(msg);
       break;
@@ -127,7 +134,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       LightCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_light_command_request"), msg);
+      ESP_LOGVV(TAG, "on_light_command_request: %s", msg.dump().c_str());
 #endif
       this->on_light_command_request(msg);
       break;
@@ -138,7 +145,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SwitchCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_switch_command_request"), msg);
+      ESP_LOGVV(TAG, "on_switch_command_request: %s", msg.dump().c_str());
 #endif
       this->on_switch_command_request(msg);
       break;
@@ -149,7 +156,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeHomeassistantServicesRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_homeassistant_services_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_homeassistant_services_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_homeassistant_services_request(msg);
       break;
@@ -159,7 +166,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       GetTimeResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_get_time_response"), msg);
+      ESP_LOGVV(TAG, "on_get_time_response: %s", msg.dump().c_str());
 #endif
       this->on_get_time_response(msg);
       break;
@@ -169,7 +176,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeHomeAssistantStatesRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_home_assistant_states_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_home_assistant_states_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_home_assistant_states_request(msg);
       break;
@@ -180,7 +187,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       HomeAssistantStateResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_home_assistant_state_response"), msg);
+      ESP_LOGVV(TAG, "on_home_assistant_state_response: %s", msg.dump().c_str());
 #endif
       this->on_home_assistant_state_response(msg);
       break;
@@ -191,7 +198,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ExecuteServiceRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_execute_service_request"), msg);
+      ESP_LOGVV(TAG, "on_execute_service_request: %s", msg.dump().c_str());
 #endif
       this->on_execute_service_request(msg);
       break;
@@ -202,7 +209,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       CameraImageRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_camera_image_request"), msg);
+      ESP_LOGVV(TAG, "on_camera_image_request: %s", msg.dump().c_str());
 #endif
       this->on_camera_image_request(msg);
       break;
@@ -213,7 +220,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ClimateCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_climate_command_request"), msg);
+      ESP_LOGVV(TAG, "on_climate_command_request: %s", msg.dump().c_str());
 #endif
       this->on_climate_command_request(msg);
       break;
@@ -224,7 +231,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       NumberCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_number_command_request"), msg);
+      ESP_LOGVV(TAG, "on_number_command_request: %s", msg.dump().c_str());
 #endif
       this->on_number_command_request(msg);
       break;
@@ -235,7 +242,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SelectCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_select_command_request"), msg);
+      ESP_LOGVV(TAG, "on_select_command_request: %s", msg.dump().c_str());
 #endif
       this->on_select_command_request(msg);
       break;
@@ -246,7 +253,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SirenCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_siren_command_request"), msg);
+      ESP_LOGVV(TAG, "on_siren_command_request: %s", msg.dump().c_str());
 #endif
       this->on_siren_command_request(msg);
       break;
@@ -257,7 +264,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       LockCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_lock_command_request"), msg);
+      ESP_LOGVV(TAG, "on_lock_command_request: %s", msg.dump().c_str());
 #endif
       this->on_lock_command_request(msg);
       break;
@@ -268,7 +275,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ButtonCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_button_command_request"), msg);
+      ESP_LOGVV(TAG, "on_button_command_request: %s", msg.dump().c_str());
 #endif
       this->on_button_command_request(msg);
       break;
@@ -279,7 +286,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       MediaPlayerCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_media_player_command_request"), msg);
+      ESP_LOGVV(TAG, "on_media_player_command_request: %s", msg.dump().c_str());
 #endif
       this->on_media_player_command_request(msg);
       break;
@@ -290,7 +297,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeBluetoothLEAdvertisementsRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_bluetooth_le_advertisements_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_bluetooth_le_advertisements_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_bluetooth_le_advertisements_request(msg);
       break;
@@ -301,7 +308,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothDeviceRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_device_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_device_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_device_request(msg);
       break;
@@ -312,7 +319,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTGetServicesRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_get_services_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_get_services_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_get_services_request(msg);
       break;
@@ -323,7 +330,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTReadRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_read_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_read_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_read_request(msg);
       break;
@@ -334,7 +341,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTWriteRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_write_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_write_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_write_request(msg);
       break;
@@ -345,7 +352,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTReadDescriptorRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_read_descriptor_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_read_descriptor_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_read_descriptor_request(msg);
       break;
@@ -356,7 +363,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTWriteDescriptorRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_write_descriptor_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_write_descriptor_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_write_descriptor_request(msg);
       break;
@@ -367,7 +374,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTNotifyRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_notify_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_notify_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_notify_request(msg);
       break;
@@ -378,7 +385,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeBluetoothConnectionsFreeRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_bluetooth_connections_free_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_bluetooth_connections_free_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_bluetooth_connections_free_request(msg);
       break;
@@ -389,7 +396,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       UnsubscribeBluetoothLEAdvertisementsRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_unsubscribe_bluetooth_le_advertisements_request"), msg);
+      ESP_LOGVV(TAG, "on_unsubscribe_bluetooth_le_advertisements_request: %s", msg.dump().c_str());
 #endif
       this->on_unsubscribe_bluetooth_le_advertisements_request(msg);
       break;
@@ -400,7 +407,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeVoiceAssistantRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_voice_assistant_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_voice_assistant_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_voice_assistant_request(msg);
       break;
@@ -411,7 +418,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_response"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_response: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_response(msg);
       break;
@@ -422,7 +429,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantEventResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_event_response"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_event_response: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_event_response(msg);
       break;
@@ -433,7 +440,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       AlarmControlPanelCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_alarm_control_panel_command_request"), msg);
+      ESP_LOGVV(TAG, "on_alarm_control_panel_command_request: %s", msg.dump().c_str());
 #endif
       this->on_alarm_control_panel_command_request(msg);
       break;
@@ -444,7 +451,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       TextCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_text_command_request"), msg);
+      ESP_LOGVV(TAG, "on_text_command_request: %s", msg.dump().c_str());
 #endif
       this->on_text_command_request(msg);
       break;
@@ -455,7 +462,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       DateCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_date_command_request"), msg);
+      ESP_LOGVV(TAG, "on_date_command_request: %s", msg.dump().c_str());
 #endif
       this->on_date_command_request(msg);
       break;
@@ -466,7 +473,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       TimeCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_time_command_request"), msg);
+      ESP_LOGVV(TAG, "on_time_command_request: %s", msg.dump().c_str());
 #endif
       this->on_time_command_request(msg);
       break;
@@ -477,7 +484,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantAudio msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_audio"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_audio: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_audio(msg);
       break;
@@ -488,7 +495,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ValveCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_valve_command_request"), msg);
+      ESP_LOGVV(TAG, "on_valve_command_request: %s", msg.dump().c_str());
 #endif
       this->on_valve_command_request(msg);
       break;
@@ -499,7 +506,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       DateTimeCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_date_time_command_request"), msg);
+      ESP_LOGVV(TAG, "on_date_time_command_request: %s", msg.dump().c_str());
 #endif
       this->on_date_time_command_request(msg);
       break;
@@ -510,7 +517,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantTimerEventResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_timer_event_response"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_timer_event_response: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_timer_event_response(msg);
       break;
@@ -521,7 +528,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       UpdateCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_update_command_request"), msg);
+      ESP_LOGVV(TAG, "on_update_command_request: %s", msg.dump().c_str());
 #endif
       this->on_update_command_request(msg);
       break;
@@ -532,7 +539,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantAnnounceRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_announce_request"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_announce_request: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_announce_request(msg);
       break;
@@ -543,7 +550,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantConfigurationRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_configuration_request"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_configuration_request: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_configuration_request(msg);
       break;
@@ -554,7 +561,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantSetConfiguration msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_set_configuration"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_set_configuration: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_set_configuration(msg);
       break;
@@ -565,7 +572,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       NoiseEncryptionSetKeyRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_noise_encryption_set_key_request"), msg);
+      ESP_LOGVV(TAG, "on_noise_encryption_set_key_request: %s", msg.dump().c_str());
 #endif
       this->on_noise_encryption_set_key_request(msg);
       break;
@@ -576,7 +583,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothScannerSetModeRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_scanner_set_mode_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_scanner_set_mode_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_scanner_set_mode_request(msg);
       break;
@@ -587,7 +594,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ZWaveProxyFrame msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_z_wave_proxy_frame"), msg);
+      ESP_LOGVV(TAG, "on_z_wave_proxy_frame: %s", msg.dump().c_str());
 #endif
       this->on_z_wave_proxy_frame(msg);
       break;
@@ -598,7 +605,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ZWaveProxyRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_z_wave_proxy_request"), msg);
+      ESP_LOGVV(TAG, "on_z_wave_proxy_request: %s", msg.dump().c_str());
 #endif
       this->on_z_wave_proxy_request(msg);
       break;
@@ -609,7 +616,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       HomeassistantActionResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_homeassistant_action_response"), msg);
+      ESP_LOGVV(TAG, "on_homeassistant_action_response: %s", msg.dump().c_str());
 #endif
       this->on_homeassistant_action_response(msg);
       break;
@@ -620,22 +627,11 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       WaterHeaterCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_water_heater_command_request"), msg);
+      ESP_LOGVV(TAG, "on_water_heater_command_request: %s", msg.dump().c_str());
 #endif
       this->on_water_heater_command_request(msg);
       break;
     }
-#endif
-#ifdef USE_IR_RF
-    case InfraredRFTransmitRawTimingsRequest::MESSAGE_TYPE: {
-      InfraredRFTransmitRawTimingsRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_infrared_rf_transmit_raw_timings_request"), msg);
-#endif
-      this->on_infrared_rf_transmit_raw_timings_request(msg);
-      break;
-    }
 #endif
     default:
       break;
@@ -647,6 +643,13 @@ void APIServerConnection::on_hello_request(const HelloRequest &msg) {
     this->on_fatal_error();
   }
 }
+#ifdef USE_API_PASSWORD
+void APIServerConnection::on_authentication_request(const AuthenticationRequest &msg) {
+  if (!this->send_authenticate_response(msg)) {
+    this->on_fatal_error();
+  }
+}
+#endif
 void APIServerConnection::on_disconnect_request(const DisconnectRequest &msg) {
   if (!this->send_disconnect_response(msg)) {
     this->on_fatal_error();
@@ -834,16 +837,14 @@ void APIServerConnection::on_z_wave_proxy_frame(const ZWaveProxyFrame &msg) { th
 #ifdef USE_ZWAVE_PROXY
 void APIServerConnection::on_z_wave_proxy_request(const ZWaveProxyRequest &msg) { this->zwave_proxy_request(msg); }
 #endif
-#ifdef USE_IR_RF
-void APIServerConnection::on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg) {
-  this->infrared_rf_transmit_raw_timings(msg);
-}
-#endif
 
 void APIServerConnection::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {
   // Check authentication/connection requirements for messages
   switch (msg_type) {
-    case HelloRequest::MESSAGE_TYPE:       // No setup required
+    case HelloRequest::MESSAGE_TYPE:  // No setup required
+#ifdef USE_API_PASSWORD
+    case AuthenticationRequest::MESSAGE_TYPE:  // No setup required
+#endif
     case DisconnectRequest::MESSAGE_TYPE:  // No setup required
     case PingRequest::MESSAGE_TYPE:        // No setup required
       break;                               // Skip all checks for these messages

esphome/components/api/api_pb2_service.h

@@ -12,22 +12,24 @@ class APIServerConnectionBase : public ProtoService {
  public:
 #ifdef HAS_PROTO_MESSAGE_DUMP
  protected:
-  void log_send_message_(const char *name, const char *dump);
-  void log_receive_message_(const LogString *name, const ProtoMessage &msg);
+  void log_send_message_(const char *name, const std::string &dump);
 
  public:
 #endif
 
   bool send_message(const ProtoMessage &msg, uint8_t message_type) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
-    DumpBuffer dump_buf;
-    this->log_send_message_(msg.message_name(), msg.dump_to(dump_buf));
+    this->log_send_message_(msg.message_name(), msg.dump());
 #endif
     return this->send_message_(msg, message_type);
   }
 
   virtual void on_hello_request(const HelloRequest &value){};
 
+#ifdef USE_API_PASSWORD
+  virtual void on_authentication_request(const AuthenticationRequest &value){};
+#endif
+
   virtual void on_disconnect_request(const DisconnectRequest &value){};
   virtual void on_disconnect_response(const DisconnectResponse &value){};
   virtual void on_ping_request(const PingRequest &value){};
@@ -219,11 +221,6 @@ class APIServerConnectionBase : public ProtoService {
 #ifdef USE_ZWAVE_PROXY
   virtual void on_z_wave_proxy_request(const ZWaveProxyRequest &value){};
 #endif
-
-#ifdef USE_IR_RF
-  virtual void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &value){};
-#endif
-
  protected:
   void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
 };
@@ -231,6 +228,9 @@ class APIServerConnectionBase : public ProtoService {
 class APIServerConnection : public APIServerConnectionBase {
  public:
   virtual bool send_hello_response(const HelloRequest &msg) = 0;
+#ifdef USE_API_PASSWORD
+  virtual bool send_authenticate_response(const AuthenticationRequest &msg) = 0;
+#endif
   virtual bool send_disconnect_response(const DisconnectRequest &msg) = 0;
   virtual bool send_ping_response(const PingRequest &msg) = 0;
   virtual bool send_device_info_response(const DeviceInfoRequest &msg) = 0;
@@ -354,12 +354,12 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_ZWAVE_PROXY
   virtual void zwave_proxy_request(const ZWaveProxyRequest &msg) = 0;
-#endif
-#ifdef USE_IR_RF
-  virtual void infrared_rf_transmit_raw_timings(const InfraredRFTransmitRawTimingsRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
+#ifdef USE_API_PASSWORD
+  void on_authentication_request(const AuthenticationRequest &msg) override;
+#endif
   void on_disconnect_request(const DisconnectRequest &msg) override;
   void on_ping_request(const PingRequest &msg) override;
   void on_device_info_request(const DeviceInfoRequest &msg) override;
@@ -483,9 +483,6 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_ZWAVE_PROXY
   void on_z_wave_proxy_request(const ZWaveProxyRequest &msg) override;
-#endif
-#ifdef USE_IR_RF
-  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg) override;
 #endif
   void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
 };

esphome/components/api/api_server.cpp

@@ -125,18 +125,15 @@ void APIServer::loop() {
       if (!sock)
         break;
 
-      char peername[socket::SOCKADDR_STR_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_, peername);
+        ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, sock->getpeername().c_str());
         // Immediately close - socket destructor will handle cleanup
         sock.reset();
         continue;
       }
 
-      ESP_LOGD(TAG, "Accept %s", peername);
+      ESP_LOGD(TAG, "Accept %s", sock->getpeername().c_str());
 
       auto *conn = new APIConnection(std::move(sock), this);
       this->clients_.emplace_back(conn);
@@ -169,7 +166,8 @@ void APIServer::loop() {
     // Network is down - disconnect all clients
     for (auto &client : this->clients_) {
       client->on_fatal_error();
-      client->log_client_(ESPHOME_LOG_LEVEL_WARN, LOG_STR("Network down; disconnect"));
+      ESP_LOGW(TAG, "%s (%s): Network down; disconnect", client->client_info_.name.c_str(),
+               client->client_info_.peername.c_str());
     }
     // Continue to process and clean up the clients below
   }
@@ -186,16 +184,13 @@ 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);
+#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->get_name());
-
-#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    // Save client info before removal for the trigger
-    std::string client_name(client->get_name());
-    std::string client_peername(client->get_peername());
-#endif
+    ESP_LOGV(TAG, "Remove connection %s", client->client_info_.name.c_str());
 
     // Swap with the last element and pop (avoids expensive vector shifts)
     if (client_index < this->clients_.size() - 1) {
@@ -208,11 +203,6 @@ void APIServer::loop() {
       this->status_set_warning();
       this->last_connected_ = App.get_loop_component_start_time();
     }
-
-#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    // Fire trigger after client is removed so api.connected reflects the true state
-    this->client_disconnected_trigger_->trigger(client_name, client_peername);
-#endif
     // Don't increment client_index since we need to process the swapped element
   }
 }
@@ -234,6 +224,38 @@ void APIServer::dump_config() {
 #endif
 }
 
+#ifdef USE_API_PASSWORD
+bool APIServer::check_password(const uint8_t *password_data, size_t password_len) const {
+  // depend only on input password length
+  const char *a = this->password_.c_str();
+  uint32_t len_a = this->password_.length();
+  const char *b = reinterpret_cast<const char *>(password_data);
+  uint32_t len_b = password_len;
+
+  // disable optimization with volatile
+  volatile uint32_t length = len_b;
+  volatile const char *left = nullptr;
+  volatile const char *right = b;
+  uint8_t result = 0;
+
+  if (len_a == length) {
+    left = *((volatile const char **) &a);
+    result = 0;
+  }
+  if (len_a != length) {
+    left = b;
+    result = 1;
+  }
+
+  for (size_t i = 0; i < length; i++) {
+    result |= *left++ ^ *right++;  // NOLINT
+  }
+
+  return result == 0;
+}
+
+#endif
+
 void APIServer::handle_disconnect(APIConnection *conn) {}
 
 // Macro for controller update dispatch
@@ -318,11 +340,13 @@ 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()
 void APIServer::on_event(event::Event *obj) {
   if (obj->is_internal())
     return;
   for (auto &c : this->clients_)
-    c->send_event(obj);
+    c->send_event(obj, obj->get_last_event_type());
 }
 #endif
 
@@ -345,21 +369,6 @@ void APIServer::on_zwave_proxy_request(const esphome::api::ProtoMessage &msg) {
 }
 #endif
 
-#ifdef USE_IR_RF
-void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_id, uint32_t key,
-                                               const std::vector<int32_t> *timings) {
-  InfraredRFReceiveEvent resp{};
-#ifdef USE_DEVICES
-  resp.device_id = device_id;
-#endif
-  resp.key = key;
-  resp.timings = timings;
-
-  for (auto &c : this->clients_)
-    c->send_infrared_rf_receive_event(resp);
-}
-#endif
-
 #ifdef USE_ALARM_CONTROL_PANEL
 API_DISPATCH_UPDATE(alarm_control_panel::AlarmControlPanel, alarm_control_panel)
 #endif
@@ -368,6 +377,10 @@ float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI;
 
 void APIServer::set_port(uint16_t port) { this->port_ = port; }
 
+#ifdef USE_API_PASSWORD
+void APIServer::set_password(const std::string &password) { this->password_ = password; }
+#endif
+
 void APIServer::set_batch_delay(uint16_t batch_delay) { this->batch_delay_ = batch_delay; }
 
 #ifdef USE_API_HOMEASSISTANT_SERVICES
@@ -381,7 +394,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, StringRef error_message) {
+void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &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);
@@ -393,7 +406,7 @@ void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef
   }
 }
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef error_message,
+void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &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) {
@@ -411,8 +424,8 @@ void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef
 
 #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(StringRef)> f,
-                                        bool once) {
+void APIServer::add_state_subscription_(const char *entity_id, const char *attribute,
+                                        std::function<void(std::string)> 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)
@@ -421,7 +434,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(StringRef)> f, bool once) {
+                                        std::function<void(std::string)> 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));
@@ -441,43 +454,23 @@ 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(StringRef)> f) {
+                                               std::function<void(std::string)> 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(StringRef)> f) {
+                                         std::function<void(std::string)> f) {
   this->add_state_subscription_(entity_id, attribute, std::move(f), true);
 }
 
-// std::string overload with StringRef callback (zero-allocation callback)
+// Existing std::string overload (for custom_api_device.h - heap allocation)
 void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                               std::function<void(StringRef)> f) {
+                                               std::function<void(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(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) {
+                                         std::function<void(std::string)> f) {
   this->add_state_subscription_(std::move(entity_id), std::move(attribute), std::move(f), true);
 }
 
@@ -613,7 +606,8 @@ void APIServer::on_shutdown() {
     if (!c->send_message(req, DisconnectRequest::MESSAGE_TYPE)) {
       // If we can't send the disconnect request directly (tx_buffer full),
       // schedule it at the front of the batch so it will be sent with priority
-      c->schedule_message_front_(nullptr, DisconnectRequest::MESSAGE_TYPE, DisconnectRequest::ESTIMATED_SIZE);
+      c->schedule_message_front_(nullptr, &APIConnection::try_send_disconnect_request, DisconnectRequest::MESSAGE_TYPE,
+                                 DisconnectRequest::ESTIMATED_SIZE);
     }
   }
 }
@@ -684,7 +678,7 @@ void APIServer::unregister_active_action_calls_for_connection(APIConnection *con
   }
 }
 
-void APIServer::send_action_response(uint32_t action_call_id, bool success, StringRef error_message) {
+void APIServer::send_action_response(uint32_t action_call_id, bool success, const std::string &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);
@@ -694,7 +688,7 @@ void APIServer::send_action_response(uint32_t action_call_id, bool success, Stri
   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, StringRef error_message,
+void APIServer::send_action_response(uint32_t action_call_id, bool success, const std::string &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,7 +10,6 @@
 #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
@@ -60,6 +59,10 @@ class APIServer : public Component,
 #endif
 #ifdef USE_CAMERA
   void on_camera_image(const std::shared_ptr<camera::CameraImage> &image) override;
+#endif
+#ifdef USE_API_PASSWORD
+  bool check_password(const uint8_t *password_data, size_t password_len) const;
+  void set_password(const std::string &password);
 #endif
   void set_port(uint16_t port);
   void set_reboot_timeout(uint32_t reboot_timeout);
@@ -140,10 +143,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, StringRef error_message);
+  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message);
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  void handle_action_response(uint32_t call_id, bool success, StringRef error_message, const uint8_t *response_data,
-                              size_t response_data_len);
+  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);
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #endif  // USE_API_HOMEASSISTANT_SERVICES
@@ -162,9 +165,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, StringRef error_message);
+  void send_action_response(uint32_t action_call_id, bool success, const std::string &error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  void send_action_response(uint32_t action_call_id, bool success, StringRef error_message,
+  void send_action_response(uint32_t action_call_id, bool success, const std::string &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
@@ -185,9 +188,6 @@ class APIServer : public Component,
 #ifdef USE_ZWAVE_PROXY
   void on_zwave_proxy_request(const esphome::api::ProtoMessage &msg);
 #endif
-#ifdef USE_IR_RF
-  void send_infrared_rf_receive_event(uint32_t device_id, uint32_t key, const std::vector<int32_t> *timings);
-#endif
 
   bool is_connected(bool state_subscription_only = false) const;
 
@@ -195,7 +195,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(StringRef)> callback;
+    std::function<void(std::string)> callback;
     bool once;
 
     // Dynamic storage for external components using std::string API (custom_api_device.h)
@@ -205,20 +205,14 @@ 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(StringRef)> f);
-  void get_home_assistant_state(const char *entity_id, const char *attribute, std::function<void(StringRef)> f);
+  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);
 
-  // std::string overload with StringRef callback (for custom_api_device.h with zero-allocation callback)
+  // Existing std::string overload (for custom_api_device.h - heap allocation)
   void subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                      std::function<void(StringRef)> f);
+                                      std::function<void(std::string)> f);
   void get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
-                                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);
+                                std::function<void(std::string)> f);
 
   const std::vector<HomeAssistantStateSubscription> &get_state_subs() const;
 #endif
@@ -242,13 +236,10 @@ 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(StringRef)> f,
+  void add_state_subscription_(const char *entity_id, const char *attribute, std::function<void(std::string)> 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(const std::string &)> f, bool once);
+                               std::function<void(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;
@@ -265,6 +256,9 @@ class APIServer : public Component,
 
   // Vectors and strings (12 bytes each on 32-bit)
   std::vector<std::unique_ptr<APIConnection>> clients_;
+#ifdef USE_API_PASSWORD
+  std::string password_;
+#endif
   std::vector<uint8_t> shared_write_buffer_;  // Shared proto write buffer for all connections
 #ifdef USE_API_HOMEASSISTANT_STATES
   std::vector<HomeAssistantStateSubscription> state_subs_;

esphome/components/api/client.py

@@ -16,7 +16,7 @@ with warnings.catch_warnings():
 
 import contextlib
 
-from esphome.const import CONF_KEY, CONF_PORT, __version__
+from esphome.const import CONF_KEY, CONF_PASSWORD, CONF_PORT, __version__
 from esphome.core import CORE
 
 from . import CONF_ENCRYPTION
@@ -35,6 +35,7 @@ async def async_run_logs(config: dict[str, Any], addresses: list[str]) -> None:
     conf = config["api"]
     name = config["esphome"]["name"]
     port: int = int(conf[CONF_PORT])
+    password: str = conf[CONF_PASSWORD]
     noise_psk: str | None = None
     if (encryption := conf.get(CONF_ENCRYPTION)) and (key := encryption.get(CONF_KEY)):
         noise_psk = key
@@ -49,7 +50,7 @@ async def async_run_logs(config: dict[str, Any], addresses: list[str]) -> None:
     cli = APIClient(
         addresses[0],  # Primary address for compatibility
         port,
-        "",  # Password auth removed in 2026.1.0
+        password,
         client_info=f"ESPHome Logs {__version__}",
         noise_psk=noise_psk,
         addresses=addresses,  # Pass all addresses for automatic retry

esphome/components/api/custom_api_device.h

@@ -122,36 +122,21 @@ class CustomAPIDevice {
    *   subscribe_homeassistant_state(&CustomNativeAPI::on_state_changed, "climate.kitchen", "current_temperature");
    * }
    *
-   * 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
+   * void on_state_changed(std::string state) {
+   *   // State of sensor.weather_forecast 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 (zero-allocation).
+   * @param callback The member function to call when the entity state changes.
    * @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);
-    // 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));
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
   }
 
   /** Subscribe to the state (or attribute state) of an entity from Home Assistant.
@@ -163,45 +148,23 @@ class CustomAPIDevice {
    *   subscribe_homeassistant_state(&CustomNativeAPI::on_state_changed, "sensor.weather_forecast");
    * }
    *
-   * void on_state_changed(const std::string &entity_id, StringRef state) {
+   * void on_state_changed(std::string entity_id, std::string 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 (zero-allocation for state).
+   * @param callback The member function to call when the entity state changes.
    * @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);
-    // 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));
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), 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 = "") {
@@ -210,14 +173,6 @@ 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 = "") {
@@ -240,7 +195,7 @@ class CustomAPIDevice {
    */
   void call_homeassistant_service(const std::string &service_name) {
     HomeassistantActionRequest resp;
-    resp.service = StringRef(service_name);
+    resp.set_service(StringRef(service_name));
     global_api_server->send_homeassistant_action(resp);
   }
 
@@ -260,12 +215,12 @@ class CustomAPIDevice {
    */
   void call_homeassistant_service(const std::string &service_name, const std::map<std::string, std::string> &data) {
     HomeassistantActionRequest resp;
-    resp.service = StringRef(service_name);
+    resp.set_service(StringRef(service_name));
     resp.data.init(data.size());
     for (auto &it : data) {
       auto &kv = resp.data.emplace_back();
-      kv.key = StringRef(it.first);
-      kv.value = StringRef(it.second);  // data map lives until send completes
+      kv.set_key(StringRef(it.first));
+      kv.value = it.second;
     }
     global_api_server->send_homeassistant_action(resp);
   }
@@ -282,7 +237,7 @@ class CustomAPIDevice {
    */
   void fire_homeassistant_event(const std::string &event_name) {
     HomeassistantActionRequest resp;
-    resp.service = StringRef(event_name);
+    resp.set_service(StringRef(event_name));
     resp.is_event = true;
     global_api_server->send_homeassistant_action(resp);
   }
@@ -302,13 +257,13 @@ class CustomAPIDevice {
    */
   void fire_homeassistant_event(const std::string &service_name, const std::map<std::string, std::string> &data) {
     HomeassistantActionRequest resp;
-    resp.service = StringRef(service_name);
+    resp.set_service(StringRef(service_name));
     resp.is_event = true;
     resp.data.init(data.size());
     for (auto &it : data) {
       auto &kv = resp.data.emplace_back();
-      kv.key = StringRef(it.first);
-      kv.value = StringRef(it.second);  // data map lives until send completes
+      kv.set_key(StringRef(it.first));
+      kv.value = it.second;
     }
     global_api_server->send_homeassistant_action(resp);
   }

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, StringRef error_message) : success_(success), error_message_(error_message) {}
+  ActionResponse(bool success, const std::string &error_message) : success_(success), error_message_(error_message) {}
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  ActionResponse(bool success, StringRef error_message, const uint8_t *data, size_t data_len)
+  ActionResponse(bool success, const std::string &error_message, const uint8_t *data, size_t data_len)
       : success_(success), error_message_(error_message) {
     if (data == nullptr || data_len == 0)
       return;
@@ -147,23 +147,13 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
   void play(const Ts &...x) override {
     HomeassistantActionRequest resp;
     std::string service_value = this->service_.value(x...);
-    resp.service = StringRef(service_value);
+    resp.set_service(StringRef(service_value));
     resp.is_event = this->flags_.is_event;
-
-    // Local storage for lambda-evaluated strings - lives until after send
-    FixedVector<std::string> data_storage;
-    FixedVector<std::string> data_template_storage;
-    FixedVector<std::string> variables_storage;
-
-    this->populate_service_map(resp.data, this->data_, data_storage, x...);
-    this->populate_service_map(resp.data_template, this->data_template_, data_template_storage, x...);
-    this->populate_service_map(resp.variables, this->variables_, variables_storage, x...);
+    this->populate_service_map(resp.data, this->data_, x...);
+    this->populate_service_map(resp.data_template, this->data_template_, x...);
+    this->populate_service_map(resp.variables, this->variables_, x...);
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-    // IMPORTANT: Declare at outer scope so it lives until send_homeassistant_action returns.
-    std::string response_template_value;
-#endif
     if (this->flags_.wants_status) {
       // Generate a unique call ID for this service call
       static uint32_t call_id_counter = 1;
@@ -174,8 +164,8 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
         resp.wants_response = true;
         // Set response template if provided
         if (this->flags_.has_response_template) {
-          response_template_value = this->response_template_.value(x...);
-          resp.response_template = StringRef(response_template_value);
+          std::string response_template_value = this->response_template_.value(x...);
+          resp.response_template = response_template_value;
         }
       }
 #endif
@@ -215,31 +205,12 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
   }
 
   template<typename VectorType, typename SourceType>
-  static void populate_service_map(VectorType &dest, SourceType &source, FixedVector<std::string> &value_storage,
-                                   Ts... x) {
+  static void populate_service_map(VectorType &dest, SourceType &source, Ts... x) {
     dest.init(source.size());
-
-    // Count non-static strings to allocate exact storage needed
-    size_t lambda_count = 0;
-    for (const auto &it : source) {
-      if (!it.value.is_static_string()) {
-        lambda_count++;
-      }
-    }
-    value_storage.init(lambda_count);
-
     for (auto &it : source) {
       auto &kv = dest.emplace_back();
-      kv.key = StringRef(it.key);
-
-      if (it.value.is_static_string()) {
-        // Static string from YAML - zero allocation
-        kv.value = StringRef(it.value.get_static_string());
-      } else {
-        // Lambda evaluation - store result, reference it
-        value_storage.push_back(it.value.value(x...));
-        kv.value = StringRef(value_storage.back());
-      }
+      kv.set_key(StringRef(it.key));
+      kv.value = it.value.value(x...);
     }
   }
 

esphome/components/api/list_entities.cpp

@@ -76,9 +76,6 @@ LIST_ENTITIES_HANDLER(alarm_control_panel, alarm_control_panel::AlarmControlPane
 #ifdef USE_WATER_HEATER
 LIST_ENTITIES_HANDLER(water_heater, water_heater::WaterHeater, ListEntitiesWaterHeaterResponse)
 #endif
-#ifdef USE_INFRARED
-LIST_ENTITIES_HANDLER(infrared, infrared::Infrared, ListEntitiesInfraredResponse)
-#endif
 #ifdef USE_EVENT
 LIST_ENTITIES_HANDLER(event, event::Event, ListEntitiesEventResponse)
 #endif

esphome/components/api/list_entities.h

@@ -9,10 +9,11 @@ namespace esphome::api {
 class APIConnection;
 
 // Macro for generating ListEntitiesIterator handlers
-// Calls schedule_message_ which dispatches to try_send_*_info
+// Calls schedule_message_ with try_send_*_info
 #define LIST_ENTITIES_HANDLER(entity_type, EntityClass, ResponseType) \
   bool ListEntitiesIterator::on_##entity_type(EntityClass *entity) { /* NOLINT(bugprone-macro-parentheses) */ \
-    return this->client_->schedule_message_(entity, ResponseType::MESSAGE_TYPE, ResponseType::ESTIMATED_SIZE); \
+    return this->client_->schedule_message_(entity, &APIConnection::try_send_##entity_type##_info, \
+                                            ResponseType::MESSAGE_TYPE, ResponseType::ESTIMATED_SIZE); \
   }
 
 class ListEntitiesIterator : public ComponentIterator {
@@ -84,9 +85,6 @@ class ListEntitiesIterator : public ComponentIterator {
 #ifdef USE_WATER_HEATER
   bool on_water_heater(water_heater::WaterHeater *entity) override;
 #endif
-#ifdef USE_INFRARED
-  bool on_infrared(infrared::Infrared *entity) override;
-#endif
 #ifdef USE_EVENT
   bool on_event(event::Event *entity) override;
 #endif

esphome/components/api/proto.cpp

@@ -139,4 +139,12 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
   }
 }
 
+#ifdef HAS_PROTO_MESSAGE_DUMP
+std::string ProtoMessage::dump() const {
+  std::string out;
+  this->dump_to(out);
+  return out;
+}
+#endif
+
 }  // namespace esphome::api

esphome/components/api/proto.h

@@ -39,24 +39,6 @@ inline constexpr int64_t decode_zigzag64(uint64_t value) {
   return (value & 1) ? static_cast<int64_t>(~(value >> 1)) : static_cast<int64_t>(value >> 1);
 }
 
-/// Count number of varints in a packed buffer
-inline uint16_t count_packed_varints(const uint8_t *data, size_t len) {
-  uint16_t count = 0;
-  while (len > 0) {
-    // Skip varint bytes until we find one without continuation bit
-    while (len > 0 && (*data & 0x80)) {
-      data++;
-      len--;
-    }
-    if (len > 0) {
-      data++;
-      len--;
-      count++;
-    }
-  }
-  return count;
-}
-
 /*
  * StringRef Ownership Model for API Protocol Messages
  * ===================================================
@@ -72,16 +54,16 @@ inline uint16_t count_packed_varints(const uint8_t *data, size_t len) {
  * 3. Global/static strings: StringRef(GLOBAL_CONSTANT) - Always safe
  * 4. Local variables: Safe ONLY if encoding happens before function returns:
  *    std::string temp = compute_value();
- *    msg.field = StringRef(temp);
+ *    msg.set_field(StringRef(temp));
  *    return this->send_message(msg);  // temp is valid during encoding
  *
  * Unsafe Patterns (WILL cause crashes/corruption):
- * 1. Temporaries: msg.field = StringRef(obj.get_string()) // get_string() returns by value
- * 2. Concatenation: msg.field = StringRef(str1 + str2) // Result is temporary
+ * 1. Temporaries: msg.set_field(StringRef(obj.get_string())) // get_string() returns by value
+ * 2. Concatenation: msg.set_field(StringRef(str1 + str2)) // Result is temporary
  *
  * For unsafe patterns, store in a local variable first:
  *    std::string temp = get_string();  // or str1 + str2
- *    msg.field = StringRef(temp);
+ *    msg.set_field(StringRef(temp));
  *
  * The send_*_response pattern ensures proper lifetime management by encoding
  * within the same function scope where temporaries are created.
@@ -198,10 +180,9 @@ class ProtoVarInt {
   uint64_t value_;
 };
 
-// Forward declarations for decode_to_message, encode_message and encode_packed_sint32
-class ProtoDecodableMessage;
+// Forward declaration for decode_to_message and encode_to_writer
 class ProtoMessage;
-class ProtoSize;
+class ProtoDecodableMessage;
 
 class ProtoLengthDelimited {
  public:
@@ -353,8 +334,6 @@ class ProtoWriteBuffer {
   void encode_sint64(uint32_t field_id, int64_t value, bool force = false) {
     this->encode_uint64(field_id, encode_zigzag64(value), force);
   }
-  /// Encode a packed repeated sint32 field (zero-copy from vector)
-  void encode_packed_sint32(uint32_t field_id, const std::vector<int32_t> &values);
   void encode_message(uint32_t field_id, const ProtoMessage &value);
   std::vector<uint8_t> *get_buffer() const { return buffer_; }
 
@@ -362,62 +341,8 @@ class ProtoWriteBuffer {
   std::vector<uint8_t> *buffer_;
 };
 
-#ifdef HAS_PROTO_MESSAGE_DUMP
-/**
- * Fixed-size buffer for message dumps - avoids heap allocation.
- * Sized to match the logger's default tx_buffer_size (512 bytes)
- * since anything larger gets truncated anyway.
- */
-class DumpBuffer {
- public:
-  // Matches default tx_buffer_size in logger component
-  static constexpr size_t CAPACITY = 512;
-
-  DumpBuffer() : pos_(0) { buf_[0] = '\0'; }
-
-  DumpBuffer &append(const char *str) {
-    if (str) {
-      append_impl_(str, strlen(str));
-    }
-    return *this;
-  }
-
-  DumpBuffer &append(const char *str, size_t len) {
-    append_impl_(str, len);
-    return *this;
-  }
-
-  DumpBuffer &append(size_t n, char c) {
-    size_t space = CAPACITY - 1 - pos_;
-    if (n > space)
-      n = space;
-    if (n > 0) {
-      memset(buf_ + pos_, c, n);
-      pos_ += n;
-      buf_[pos_] = '\0';
-    }
-    return *this;
-  }
-
-  const char *c_str() const { return buf_; }
-  size_t size() const { return pos_; }
-
- private:
-  void append_impl_(const char *str, size_t len) {
-    size_t space = CAPACITY - 1 - pos_;
-    if (len > space)
-      len = space;
-    if (len > 0) {
-      memcpy(buf_ + pos_, str, len);
-      pos_ += len;
-      buf_[pos_] = '\0';
-    }
-  }
-
-  char buf_[CAPACITY];
-  size_t pos_;
-};
-#endif
+// Forward declaration
+class ProtoSize;
 
 class ProtoMessage {
  public:
@@ -427,7 +352,8 @@ class ProtoMessage {
   // Default implementation for messages with no fields
   virtual void calculate_size(ProtoSize &size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  virtual const char *dump_to(DumpBuffer &out) const = 0;
+  std::string dump() const;
+  virtual void dump_to(std::string &out) const = 0;
   virtual const char *message_name() const { return "unknown"; }
 #endif
 };
@@ -866,43 +792,8 @@ class ProtoSize {
       }
     }
   }
-
-  /**
-   * @brief Calculate size of a packed repeated sint32 field
-   */
-  inline void add_packed_sint32(uint32_t field_id_size, const std::vector<int32_t> &values) {
-    if (values.empty())
-      return;
-
-    size_t packed_size = 0;
-    for (int value : values) {
-      packed_size += varint(encode_zigzag32(value));
-    }
-
-    // field_id + length varint + packed data
-    total_size_ += field_id_size + varint(static_cast<uint32_t>(packed_size)) + static_cast<uint32_t>(packed_size);
-  }
 };
 
-// Implementation of encode_packed_sint32 - must be after ProtoSize is defined
-inline void ProtoWriteBuffer::encode_packed_sint32(uint32_t field_id, const std::vector<int32_t> &values) {
-  if (values.empty())
-    return;
-
-  // Calculate packed size
-  size_t packed_size = 0;
-  for (int value : values) {
-    packed_size += ProtoSize::varint(encode_zigzag32(value));
-  }
-
-  // Write tag (LENGTH_DELIMITED) + length + all zigzag-encoded values
-  this->encode_field_raw(field_id, WIRE_TYPE_LENGTH_DELIMITED);
-  this->encode_varint_raw(packed_size);
-  for (int value : values) {
-    this->encode_varint_raw(encode_zigzag32(value));
-  }
-}
-
 // Implementation of encode_message - must be after ProtoMessage is defined
 inline void ProtoWriteBuffer::encode_message(uint32_t field_id, const ProtoMessage &value) {
   this->encode_field_raw(field_id, 2);  // type 2: Length-delimited message
@@ -942,6 +833,9 @@ class ProtoService {
   virtual bool is_authenticated() = 0;
   virtual bool is_connection_setup() = 0;
   virtual void on_fatal_error() = 0;
+#ifdef USE_API_PASSWORD
+  virtual void on_unauthenticated_access() = 0;
+#endif
   virtual void on_no_setup_connection() = 0;
   /**
    * Create a buffer with a reserved size.
@@ -979,7 +873,20 @@ class ProtoService {
     return true;
   }
 
-  inline bool check_authenticated_() { return this->check_connection_setup_(); }
+  inline bool check_authenticated_() {
+#ifdef USE_API_PASSWORD
+    if (!this->check_connection_setup_()) {
+      return false;
+    }
+    if (!this->is_authenticated()) {
+      this->on_unauthenticated_access();
+      return false;
+    }
+    return true;
+#else
+    return this->check_connection_setup_();
+#endif
+  }
 };
 
 }  // namespace esphome::api

esphome/components/api/subscribe_state.h

@@ -79,9 +79,6 @@ class InitialStateIterator : public ComponentIterator {
 #ifdef USE_WATER_HEATER
   bool on_water_heater(water_heater::WaterHeater *entity) override;
 #endif
-#ifdef USE_INFRARED
-  bool on_infrared(infrared::Infrared *infrared) override { return true; };
-#endif
 #ifdef USE_EVENT
   bool on_event(event::Event *event) override { return true; };
 #endif

esphome/components/api/user_services.h

@@ -46,7 +46,7 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
 
   ListEntitiesServicesResponse encode_list_service_response() override {
     ListEntitiesServicesResponse msg;
-    msg.name = StringRef(this->name_);
+    msg.set_name(StringRef(this->name_));
     msg.key = this->key_;
     msg.supports_response = this->supports_response_;
     std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
@@ -54,7 +54,7 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
     for (size_t i = 0; i < sizeof...(Ts); i++) {
       auto &arg = msg.args.emplace_back();
       arg.type = arg_types[i];
-      arg.name = StringRef(this->arg_names_[i]);
+      arg.set_name(StringRef(this->arg_names_[i]));
     }
     return msg;
   }
@@ -108,7 +108,7 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
 
   ListEntitiesServicesResponse encode_list_service_response() override {
     ListEntitiesServicesResponse msg;
-    msg.name = StringRef(this->name_);
+    msg.set_name(StringRef(this->name_));
     msg.key = this->key_;
     msg.supports_response = enums::SUPPORTS_RESPONSE_NONE;  // Dynamic services don't support responses yet
     std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
@@ -116,7 +116,7 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
     for (size_t i = 0; i < sizeof...(Ts); i++) {
       auto &arg = msg.args.emplace_back();
       arg.type = arg_types[i];
-      arg.name = StringRef(this->arg_names_[i]);
+      arg.set_name(StringRef(this->arg_names_[i]));
     }
     return msg;
   }
@@ -255,7 +255,7 @@ template<typename... Ts> class APIRespondAction : public Action<Ts...> {
             bool return_response = std::get<1>(args);
             if (!return_response) {
               // Client doesn't want response data, just send success/error
-              this->parent_->send_action_response(call_id, success, StringRef(error_message));
+              this->parent_->send_action_response(call_id, success, error_message);
               return;
             }
           }
@@ -265,12 +265,12 @@ template<typename... Ts> class APIRespondAction : public Action<Ts...> {
       json::JsonBuilder builder;
       this->json_builder_(x..., builder.root());
       std::string json_str = builder.serialize();
-      this->parent_->send_action_response(call_id, success, StringRef(error_message),
+      this->parent_->send_action_response(call_id, success, error_message,
                                           reinterpret_cast<const uint8_t *>(json_str.data()), json_str.size());
       return;
     }
 #endif
-    this->parent_->send_action_response(call_id, success, StringRef(error_message));
+    this->parent_->send_action_response(call_id, success, error_message);
   }
 
  protected:

esphome/components/aqi/abstract_aqi_calculator.h

@@ -6,7 +6,7 @@ namespace esphome::aqi {
 
 class AbstractAQICalculator {
  public:
-  virtual uint16_t get_aqi(float pm2_5_value, float pm10_0_value) = 0;
+  virtual uint16_t get_aqi(uint16_t pm2_5_value, uint16_t pm10_0_value) = 0;
 };
 
 }  // namespace esphome::aqi

esphome/components/aqi/aqi_calculator.h

@@ -1,7 +1,6 @@
 #pragma once
 
-#include <cmath>
-#include <limits>
+#include <climits>
 #include "abstract_aqi_calculator.h"
 
 // https://document.airnow.gov/technical-assistance-document-for-the-reporting-of-daily-air-quailty.pdf
@@ -10,41 +9,39 @@ namespace esphome::aqi {
 
 class AQICalculator : public AbstractAQICalculator {
  public:
-  uint16_t get_aqi(float pm2_5_value, float pm10_0_value) override {
-    float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
-    float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
+  uint16_t get_aqi(uint16_t pm2_5_value, uint16_t pm10_0_value) override {
+    int pm2_5_index = calculate_index_(pm2_5_value, pm2_5_calculation_grid_);
+    int pm10_0_index = calculate_index_(pm10_0_value, pm10_0_calculation_grid_);
 
-    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
+    return (pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index;
   }
 
  protected:
-  static constexpr int NUM_LEVELS = 6;
+  static const int AMOUNT_OF_LEVELS = 6;
 
-  static constexpr int INDEX_GRID[NUM_LEVELS][2] = {{0, 50}, {51, 100}, {101, 150}, {151, 200}, {201, 300}, {301, 500}};
+  int index_grid_[AMOUNT_OF_LEVELS][2] = {{0, 50}, {51, 100}, {101, 150}, {151, 200}, {201, 300}, {301, 500}};
 
-  static constexpr float PM2_5_GRID[NUM_LEVELS][2] = {{0.0f, 9.0f},     {9.1f, 35.4f},
-                                                      {35.5f, 55.4f},   {55.5f, 125.4f},
-                                                      {125.5f, 225.4f}, {225.5f, std::numeric_limits<float>::max()}};
+  int pm2_5_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 9},    {10, 35},   {36, 55},
+                                                      {56, 125}, {126, 225}, {226, INT_MAX}};
 
-  static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {{0.0f, 54.0f},    {55.0f, 154.0f},
-                                                       {155.0f, 254.0f}, {255.0f, 354.0f},
-                                                       {355.0f, 424.0f}, {425.0f, std::numeric_limits<float>::max()}};
+  int pm10_0_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 54},    {55, 154},  {155, 254},
+                                                       {255, 354}, {355, 424}, {425, INT_MAX}};
 
-  static float calculate_index(float value, const float array[NUM_LEVELS][2]) {
-    int grid_index = get_grid_index(value, array);
+  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.0f;
+      return -1;
     }
-    float aqi_lo = INDEX_GRID[grid_index][0];
-    float aqi_hi = INDEX_GRID[grid_index][1];
-    float conc_lo = array[grid_index][0];
-    float conc_hi = array[grid_index][1];
+    int aqi_lo = index_grid_[grid_index][0];
+    int aqi_hi = index_grid_[grid_index][1];
+    int conc_lo = array[grid_index][0];
+    int conc_hi = array[grid_index][1];
 
     return (value - conc_lo) * (aqi_hi - aqi_lo) / (conc_hi - conc_lo) + aqi_lo;
   }
 
-  static int get_grid_index(float value, const float array[NUM_LEVELS][2]) {
-    for (int i = 0; i < NUM_LEVELS; i++) {
+  int get_grid_index_(uint16_t value, int array[AMOUNT_OF_LEVELS][2]) {
+    for (int i = 0; i < AMOUNT_OF_LEVELS; i++) {
       if (value >= array[i][0] && value <= array[i][1]) {
         return i;
       }

esphome/components/aqi/aqi_sensor.cpp

@@ -1,51 +0,0 @@
-#include "aqi_sensor.h"
-#include "esphome/core/log.h"
-
-namespace esphome::aqi {
-
-static const char *const TAG = "aqi";
-
-void AQISensor::setup() {
-  if (this->pm_2_5_sensor_ != nullptr) {
-    this->pm_2_5_sensor_->add_on_state_callback([this](float value) {
-      this->pm_2_5_value_ = value;
-      // Defer calculation to avoid double-publishing if both sensors update in the same loop
-      this->defer("update", [this]() { this->calculate_aqi_(); });
-    });
-  }
-  if (this->pm_10_0_sensor_ != nullptr) {
-    this->pm_10_0_sensor_->add_on_state_callback([this](float value) {
-      this->pm_10_0_value_ = value;
-      this->defer("update", [this]() { this->calculate_aqi_(); });
-    });
-  }
-}
-
-void AQISensor::dump_config() {
-  ESP_LOGCONFIG(TAG, "AQI Sensor:");
-  ESP_LOGCONFIG(TAG, "  Calculation Type: %s", this->aqi_calc_type_ == AQI_TYPE ? "AQI" : "CAQI");
-  if (this->pm_2_5_sensor_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  PM2.5 Sensor: '%s'", this->pm_2_5_sensor_->get_name().c_str());
-  }
-  if (this->pm_10_0_sensor_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  PM10 Sensor: '%s'", this->pm_10_0_sensor_->get_name().c_str());
-  }
-  LOG_SENSOR("  ", "AQI", this);
-}
-
-void AQISensor::calculate_aqi_() {
-  if (std::isnan(this->pm_2_5_value_) || std::isnan(this->pm_10_0_value_)) {
-    return;
-  }
-
-  AbstractAQICalculator *calculator = this->aqi_calculator_factory_.get_calculator(this->aqi_calc_type_);
-  if (calculator == nullptr) {
-    ESP_LOGW(TAG, "Unknown AQI calculator type");
-    return;
-  }
-
-  uint16_t aqi = calculator->get_aqi(this->pm_2_5_value_, this->pm_10_0_value_);
-  this->publish_state(aqi);
-}
-
-}  // namespace esphome::aqi

esphome/components/aqi/aqi_sensor.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
-#include "aqi_calculator_factory.h"
-
-namespace esphome::aqi {
-
-class AQISensor : public sensor::Sensor, public Component {
- public:
-  void setup() override;
-  void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
-  void set_pm_2_5_sensor(sensor::Sensor *sensor) { this->pm_2_5_sensor_ = sensor; }
-  void set_pm_10_0_sensor(sensor::Sensor *sensor) { this->pm_10_0_sensor_ = sensor; }
-  void set_aqi_calculation_type(AQICalculatorType type) { this->aqi_calc_type_ = type; }
-
- protected:
-  void calculate_aqi_();
-
-  sensor::Sensor *pm_2_5_sensor_{nullptr};
-  sensor::Sensor *pm_10_0_sensor_{nullptr};
-  AQICalculatorType aqi_calc_type_{AQI_TYPE};
-  AQICalculatorFactory aqi_calculator_factory_;
-
-  float pm_2_5_value_{NAN};
-  float pm_10_0_value_{NAN};
-};
-
-}  // namespace esphome::aqi

esphome/components/aqi/caqi_calculator.h

@@ -1,47 +1,44 @@
 #pragma once
 
-#include <cmath>
-#include <limits>
+#include "esphome/core/log.h"
 #include "abstract_aqi_calculator.h"
 
 namespace esphome::aqi {
 
 class CAQICalculator : public AbstractAQICalculator {
  public:
-  uint16_t get_aqi(float pm2_5_value, float pm10_0_value) override {
-    float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
-    float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
+  uint16_t get_aqi(uint16_t pm2_5_value, uint16_t pm10_0_value) override {
+    int pm2_5_index = calculate_index_(pm2_5_value, pm2_5_calculation_grid_);
+    int pm10_0_index = calculate_index_(pm10_0_value, pm10_0_calculation_grid_);
 
-    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
+    return (pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index;
   }
 
  protected:
-  static constexpr int NUM_LEVELS = 5;
+  static const int AMOUNT_OF_LEVELS = 5;
 
-  static constexpr int INDEX_GRID[NUM_LEVELS][2] = {{0, 25}, {26, 50}, {51, 75}, {76, 100}, {101, 400}};
+  int index_grid_[AMOUNT_OF_LEVELS][2] = {{0, 25}, {26, 50}, {51, 75}, {76, 100}, {101, 400}};
 
-  static constexpr float PM2_5_GRID[NUM_LEVELS][2] = {
-      {0.0f, 15.0f}, {15.1f, 30.0f}, {30.1f, 55.0f}, {55.1f, 110.0f}, {110.1f, std::numeric_limits<float>::max()}};
+  int pm2_5_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 15}, {16, 30}, {31, 55}, {56, 110}, {111, 400}};
 
-  static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {
-      {0.0f, 25.0f}, {25.1f, 50.0f}, {50.1f, 90.0f}, {90.1f, 180.0f}, {180.1f, std::numeric_limits<float>::max()}};
+  int pm10_0_calculation_grid_[AMOUNT_OF_LEVELS][2] = {{0, 25}, {26, 50}, {51, 90}, {91, 180}, {181, 400}};
 
-  static float calculate_index(float value, const float array[NUM_LEVELS][2]) {
-    int grid_index = get_grid_index(value, array);
+  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.0f;
+      return -1;
     }
 
-    float aqi_lo = INDEX_GRID[grid_index][0];
-    float aqi_hi = INDEX_GRID[grid_index][1];
-    float conc_lo = array[grid_index][0];
-    float conc_hi = array[grid_index][1];
+    int aqi_lo = index_grid_[grid_index][0];
+    int aqi_hi = index_grid_[grid_index][1];
+    int conc_lo = array[grid_index][0];
+    int conc_hi = array[grid_index][1];
 
     return (value - conc_lo) * (aqi_hi - aqi_lo) / (conc_hi - conc_lo) + aqi_lo;
   }
 
-  static int get_grid_index(float value, const float array[NUM_LEVELS][2]) {
-    for (int i = 0; i < NUM_LEVELS; i++) {
+  int get_grid_index_(uint16_t value, int array[AMOUNT_OF_LEVELS][2]) {
+    for (int i = 0; i < AMOUNT_OF_LEVELS; i++) {
       if (value >= array[i][0] && value <= array[i][1]) {
         return i;
       }

esphome/components/aqi/sensor.py

@@ -1,51 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_PM_2_5,
-    CONF_PM_10_0,
-    DEVICE_CLASS_AQI,
-    STATE_CLASS_MEASUREMENT,
-)
-
-from . import AQI_CALCULATION_TYPE, CONF_CALCULATION_TYPE, aqi_ns
-
-CODEOWNERS = ["@jasstrong"]
-DEPENDENCIES = ["sensor"]
-
-UNIT_INDEX = "index"
-
-AQISensor = aqi_ns.class_("AQISensor", sensor.Sensor, cg.Component)
-
-CONFIG_SCHEMA = (
-    sensor.sensor_schema(
-        AQISensor,
-        unit_of_measurement=UNIT_INDEX,
-        accuracy_decimals=0,
-        device_class=DEVICE_CLASS_AQI,
-        state_class=STATE_CLASS_MEASUREMENT,
-    )
-    .extend(
-        {
-            cv.Required(CONF_PM_2_5): cv.use_id(sensor.Sensor),
-            cv.Required(CONF_PM_10_0): cv.use_id(sensor.Sensor),
-            cv.Required(CONF_CALCULATION_TYPE): cv.enum(
-                AQI_CALCULATION_TYPE, upper=True
-            ),
-        }
-    )
-    .extend(cv.COMPONENT_SCHEMA)
-)
-
-
-async def to_code(config):
-    var = await sensor.new_sensor(config)
-    await cg.register_component(var, config)
-
-    pm_2_5_sensor = await cg.get_variable(config[CONF_PM_2_5])
-    cg.add(var.set_pm_2_5_sensor(pm_2_5_sensor))
-
-    pm_10_0_sensor = await cg.get_variable(config[CONF_PM_10_0])
-    cg.add(var.set_pm_10_0_sensor(pm_10_0_sensor))
-
-    cg.add(var.set_aqi_calculation_type(config[CONF_CALCULATION_TYPE]))

esphome/components/as3935/as3935.cpp

@@ -305,14 +305,12 @@ bool AS3935Component::calibrate_oscillator() {
 }
 
 void AS3935Component::tune_antenna() {
+  ESP_LOGI(TAG, "Starting antenna tuning");
   uint8_t div_ratio = this->read_div_ratio();
   uint8_t tune_val = this->read_capacitance();
-  ESP_LOGI(TAG,
-           "Starting antenna tuning\n"
-           "Division Ratio is set to: %d\n"
-           "Internal Capacitor is set to: %d\n"
-           "Displaying oscillator on INT pin. Measure its frequency - multiply value by Division Ratio",
-           div_ratio, tune_val);
+  ESP_LOGI(TAG, "Division Ratio is set to: %d", div_ratio);
+  ESP_LOGI(TAG, "Internal Capacitor is set to: %d", tune_val);
+  ESP_LOGI(TAG, "Displaying oscillator on INT pin. Measure its frequency - multiply value by Division Ratio");
   this->display_oscillator(true, ANTFREQ);
 }
 

esphome/components/async_tcp/__init__.py

@@ -1,50 +1,37 @@
-# Async TCP client support for all platforms
+# Dummy integration to allow relying on AsyncTCP
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome.const import (
+    PLATFORM_BK72XX,
+    PLATFORM_ESP32,
+    PLATFORM_ESP8266,
+    PLATFORM_LN882X,
+    PLATFORM_RTL87XX,
+)
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
-DEPENDENCIES = ["network"]
 
-
-def AUTO_LOAD() -> list[str]:
-    # Socket component needed for platforms using socket-based implementation
-    # ESP32, ESP8266, RP2040, and LibreTiny use AsyncTCP libraries, others use sockets
-    if (
-        not CORE.is_esp32
-        and not CORE.is_esp8266
-        and not CORE.is_rp2040
-        and not CORE.is_libretiny
-    ):
-        return ["socket"]
-    return []
-
-
-# Support all platforms - Arduino/ESP-IDF get libraries, other platforms use socket implementation
-CONFIG_SCHEMA = cv.Schema({})
+CONFIG_SCHEMA = cv.All(
+    cv.Schema({}),
+    cv.only_with_arduino,
+    cv.only_on(
+        [
+            PLATFORM_ESP32,
+            PLATFORM_ESP8266,
+            PLATFORM_BK72XX,
+            PLATFORM_LN882X,
+            PLATFORM_RTL87XX,
+        ]
+    ),
+)
 
 
 @coroutine_with_priority(CoroPriority.NETWORK_TRANSPORT)
 async def to_code(config):
-    if CORE.is_esp32:
-        # https://github.com/ESP32Async/AsyncTCP
-        from esphome.components.esp32 import add_idf_component
-
-        add_idf_component(name="esp32async/asynctcp", ref="3.4.91")
-    elif CORE.is_libretiny:
+    if CORE.is_esp32 or CORE.is_libretiny:
         # https://github.com/ESP32Async/AsyncTCP
         cg.add_library("ESP32Async/AsyncTCP", "3.4.5")
     elif CORE.is_esp8266:
         # https://github.com/ESP32Async/ESPAsyncTCP
         cg.add_library("ESP32Async/ESPAsyncTCP", "2.0.0")
-    elif CORE.is_rp2040:
-        # https://github.com/khoih-prog/AsyncTCP_RP2040W
-        cg.add_library("khoih-prog/AsyncTCP_RP2040W", "1.2.0")
-    # Other platforms (host, etc) use socket-based implementation
-
-
-def FILTER_SOURCE_FILES() -> list[str]:
-    # Exclude socket implementation for platforms that use AsyncTCP libraries
-    if CORE.is_esp32 or CORE.is_esp8266 or CORE.is_rp2040 or CORE.is_libretiny:
-        return ["async_tcp_socket.cpp"]
-    return []

esphome/components/async_tcp/async_tcp.h

@@ -1,16 +0,0 @@
-#pragma once
-#include "esphome/core/defines.h"
-
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-// Use AsyncTCP library for ESP32 (Arduino or ESP-IDF) and LibreTiny
-#include <AsyncTCP.h>
-#elif defined(USE_ESP8266)
-// Use ESPAsyncTCP library for ESP8266 (always Arduino)
-#include <ESPAsyncTCP.h>
-#elif defined(USE_RP2040)
-// Use AsyncTCP_RP2040W library for RP2040
-#include <AsyncTCP_RP2040W.h>
-#else
-// Use socket-based implementation for other platforms
-#include "async_tcp_socket.h"
-#endif

esphome/components/async_tcp/async_tcp_socket.cpp

@@ -1,162 +0,0 @@
-#include "async_tcp_socket.h"
-
-#if !defined(USE_ESP32) && !defined(USE_ESP8266) && !defined(USE_RP2040) && !defined(USE_LIBRETINY) && \
-    (defined(USE_SOCKET_IMPL_LWIP_SOCKETS) || defined(USE_SOCKET_IMPL_BSD_SOCKETS))
-
-#include "esphome/components/network/util.h"
-#include "esphome/core/log.h"
-#include <cerrno>
-#include <sys/select.h>
-
-namespace esphome::async_tcp {
-
-static const char *const TAG = "async_tcp";
-
-// Read buffer size matches TCP MSS (1500 MTU - 40 bytes IP/TCP headers).
-// This implementation only runs on ESP-IDF and host which have ample stack.
-static constexpr size_t READ_BUFFER_SIZE = 1460;
-
-bool AsyncClient::connect(const char *host, uint16_t port) {
-  if (connected_ || connecting_) {
-    ESP_LOGW(TAG, "Already connected/connecting");
-    return false;
-  }
-
-  // Resolve address
-  struct sockaddr_storage addr;
-  socklen_t addrlen = esphome::socket::set_sockaddr((struct sockaddr *) &addr, sizeof(addr), host, port);
-  if (addrlen == 0) {
-    ESP_LOGE(TAG, "Invalid address: %s", host);
-    if (error_cb_)
-      error_cb_(error_arg_, this, -1);
-    return false;
-  }
-
-  // Create socket with loop monitoring
-  int family = ((struct sockaddr *) &addr)->sa_family;
-  socket_ = esphome::socket::socket_loop_monitored(family, SOCK_STREAM, IPPROTO_TCP);
-  if (!socket_) {
-    ESP_LOGE(TAG, "Failed to create socket");
-    if (error_cb_)
-      error_cb_(error_arg_, this, -1);
-    return false;
-  }
-
-  socket_->setblocking(false);
-
-  int err = socket_->connect((struct sockaddr *) &addr, addrlen);
-  if (err == 0) {
-    // Connection succeeded immediately (rare, but possible for localhost)
-    connected_ = true;
-    if (connect_cb_)
-      connect_cb_(connect_arg_, this);
-    return true;
-  }
-  if (errno != EINPROGRESS) {
-    ESP_LOGE(TAG, "Connect failed: %d", errno);
-    close();
-    if (error_cb_)
-      error_cb_(error_arg_, this, errno);
-    return false;
-  }
-
-  connecting_ = true;
-  return true;
-}
-
-void AsyncClient::close() {
-  socket_.reset();
-  bool was_connected = connected_;
-  connected_ = false;
-  connecting_ = false;
-  if (was_connected && disconnect_cb_)
-    disconnect_cb_(disconnect_arg_, this);
-}
-
-size_t AsyncClient::write(const char *data, size_t len) {
-  if (!socket_ || !connected_)
-    return 0;
-
-  ssize_t sent = socket_->write(data, len);
-  if (sent < 0) {
-    if (errno != EAGAIN && errno != EWOULDBLOCK) {
-      ESP_LOGE(TAG, "Write error: %d", errno);
-      close();
-      if (error_cb_)
-        error_cb_(error_arg_, this, errno);
-    }
-    return 0;
-  }
-  return sent;
-}
-
-void AsyncClient::loop() {
-  if (!socket_)
-    return;
-
-  if (connecting_) {
-    // For connecting, we need to check writability, not readability
-    // The Application's select() only monitors read FDs, so we do our own check here
-    // For ESP platforms lwip_select() might be faster, but this code isn't used
-    // on those platforms anyway. If it was, we'd fix the Application select()
-    // to report writability instead of doing it this way.
-    int fd = socket_->get_fd();
-    if (fd < 0) {
-      ESP_LOGW(TAG, "Invalid socket fd");
-      close();
-      return;
-    }
-
-    fd_set writefds;
-    FD_ZERO(&writefds);
-    FD_SET(fd, &writefds);
-
-    struct timeval tv = {0, 0};
-    int ret = select(fd + 1, nullptr, &writefds, nullptr, &tv);
-
-    if (ret > 0 && FD_ISSET(fd, &writefds)) {
-      int error = 0;
-      socklen_t len = sizeof(error);
-      if (socket_->getsockopt(SOL_SOCKET, SO_ERROR, &error, &len) == 0 && error == 0) {
-        connecting_ = false;
-        connected_ = true;
-        if (connect_cb_)
-          connect_cb_(connect_arg_, this);
-      } else {
-        ESP_LOGW(TAG, "Connection failed: %d", error);
-        close();
-        if (error_cb_)
-          error_cb_(error_arg_, this, error);
-      }
-    } else if (ret < 0) {
-      ESP_LOGE(TAG, "Select error: %d", errno);
-      close();
-      if (error_cb_)
-        error_cb_(error_arg_, this, errno);
-    }
-  } else if (connected_) {
-    // For connected sockets, use the Application's select() results
-    if (!socket_->ready())
-      return;
-
-    uint8_t buf[READ_BUFFER_SIZE];
-    ssize_t len = socket_->read(buf, READ_BUFFER_SIZE);
-
-    if (len == 0) {
-      ESP_LOGI(TAG, "Connection closed by peer");
-      close();
-    } else if (len > 0) {
-      if (data_cb_)
-        data_cb_(data_arg_, this, buf, len);
-    } else if (errno != EAGAIN && errno != EWOULDBLOCK) {
-      ESP_LOGW(TAG, "Read error: %d", errno);
-      close();
-      if (error_cb_)
-        error_cb_(error_arg_, this, errno);
-    }
-  }
-}
-
-}  // namespace esphome::async_tcp
-
-#endif

esphome/components/async_tcp/async_tcp_socket.h

@@ -1,73 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#if !defined(USE_ESP32) && !defined(USE_ESP8266) && !defined(USE_RP2040) && !defined(USE_LIBRETINY) && \
-    (defined(USE_SOCKET_IMPL_LWIP_SOCKETS) || defined(USE_SOCKET_IMPL_BSD_SOCKETS))
-
-#include "esphome/components/socket/socket.h"
-#include <functional>
-#include <memory>
-#include <string>
-#include <utility>
-
-namespace esphome::async_tcp {
-
-/// AsyncClient API for platforms using sockets (ESP-IDF, host, etc.)
-/// NOTE: This class is NOT thread-safe. All methods must be called from the main loop.
-class AsyncClient {
- public:
-  using AcConnectHandler = std::function<void(void *, AsyncClient *)>;
-  using AcDataHandler = std::function<void(void *, AsyncClient *, void *data, size_t len)>;
-  using AcErrorHandler = std::function<void(void *, AsyncClient *, int8_t error)>;
-
-  AsyncClient() = default;
-  ~AsyncClient() = default;
-
-  [[nodiscard]] bool connect(const char *host, uint16_t port);
-  void close();
-  [[nodiscard]] bool connected() const { return connected_; }
-  size_t write(const char *data, size_t len);
-
-  void onConnect(AcConnectHandler cb, void *arg = nullptr) {  // NOLINT(readability-identifier-naming)
-    connect_cb_ = std::move(cb);
-    connect_arg_ = arg;
-  }
-  void onDisconnect(AcConnectHandler cb, void *arg = nullptr) {  // NOLINT(readability-identifier-naming)
-    disconnect_cb_ = std::move(cb);
-    disconnect_arg_ = arg;
-  }
-  /// Set data callback. NOTE: data pointer is only valid during callback execution.
-  void onData(AcDataHandler cb, void *arg = nullptr) {  // NOLINT(readability-identifier-naming)
-    data_cb_ = std::move(cb);
-    data_arg_ = arg;
-  }
-  void onError(AcErrorHandler cb, void *arg = nullptr) {  // NOLINT(readability-identifier-naming)
-    error_cb_ = std::move(cb);
-    error_arg_ = arg;
-  }
-
-  // Must be called from loop()
-  void loop();
-
- private:
-  std::unique_ptr<esphome::socket::Socket> socket_;
-
-  AcConnectHandler connect_cb_{nullptr};
-  void *connect_arg_{nullptr};
-  AcConnectHandler disconnect_cb_{nullptr};
-  void *disconnect_arg_{nullptr};
-  AcDataHandler data_cb_{nullptr};
-  void *data_arg_{nullptr};
-  AcErrorHandler error_cb_{nullptr};
-  void *error_arg_{nullptr};
-
-  bool connected_{false};
-  bool connecting_{false};
-};
-
-}  // namespace esphome::async_tcp
-
-// Expose AsyncClient in global namespace to match library behavior
-using esphome::async_tcp::AsyncClient;  // NOLINT(google-global-names-in-headers)
-#endif

esphome/components/atc_mithermometer/atc_mithermometer.cpp

@@ -21,9 +21,7 @@ bool ATCMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &device
     ESP_LOGVV(TAG, "parse_device(): unknown MAC address.");
     return false;
   }
-  char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  const char *addr_str = device.address_str_to(addr_buf);
-  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", addr_str);
+  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str().c_str());
 
   bool success = false;
   for (auto &service_data : device.get_service_datas()) {
@@ -34,7 +32,7 @@ bool ATCMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &device
     if (!(parse_message_(service_data.data, *res))) {
       continue;
     }
-    if (!(report_results_(res, addr_str))) {
+    if (!(report_results_(res, device.address_str()))) {
       continue;
     }
     if (res->temperature.has_value() && this->temperature_ != nullptr)
@@ -105,13 +103,13 @@ bool ATCMiThermometer::parse_message_(const std::vector<uint8_t> &message, Parse
   return true;
 }
 
-bool ATCMiThermometer::report_results_(const optional<ParseResult> &result, const char *address) {
+bool ATCMiThermometer::report_results_(const optional<ParseResult> &result, const std::string &address) {
   if (!result.has_value()) {
     ESP_LOGVV(TAG, "report_results(): no results available.");
     return false;
   }
 
-  ESP_LOGD(TAG, "Got ATC MiThermometer (%s):", address);
+  ESP_LOGD(TAG, "Got ATC MiThermometer (%s):", address.c_str());
 
   if (result->temperature.has_value()) {
     ESP_LOGD(TAG, "  Temperature: %.1f °C", *result->temperature);

esphome/components/atc_mithermometer/atc_mithermometer.h

@@ -41,7 +41,7 @@ class ATCMiThermometer : public Component, public esp32_ble_tracker::ESPBTDevice
 
   optional<ParseResult> parse_header_(const esp32_ble_tracker::ServiceData &service_data);
   bool parse_message_(const std::vector<uint8_t> &message, ParseResult &result);
-  bool report_results_(const optional<ParseResult> &result, const char *address);
+  bool report_results_(const optional<ParseResult> &result, const std::string &address);
 };
 
 }  // namespace atc_mithermometer

esphome/components/audio/audio_reader.cpp

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

esphome/components/audio/audio_reader.h

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

esphome/components/b_parasite/b_parasite.cpp

@@ -22,8 +22,7 @@ bool BParasite::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
     ESP_LOGVV(TAG, "parse_device(): unknown MAC address.");
     return false;
   }
-  char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str_to(addr_buf));
+  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str().c_str());
   const auto &service_datas = device.get_service_datas();
   if (service_datas.size() != 1) {
     ESP_LOGE(TAG, "Unexpected service_datas size (%d)", service_datas.size());

esphome/components/bedjet/bedjet_hub.cpp

@@ -193,9 +193,8 @@ bool BedJetHub::discover_characteristics_() {
       result = false;
     } else if (descr->uuid.get_uuid().len != ESP_UUID_LEN_16 ||
                descr->uuid.get_uuid().uuid.uuid16 != ESP_GATT_UUID_CHAR_CLIENT_CONFIG) {
-      char uuid_buf[espbt::UUID_STR_LEN];
       ESP_LOGW(TAG, "Config descriptor 0x%x (uuid %s) is not a client config char uuid", this->char_handle_status_,
-               descr->uuid.to_str(uuid_buf));
+               descr->uuid.to_string().c_str());
       result = false;
     } else {
       this->config_descr_status_ = descr->handle;
@@ -217,14 +216,11 @@ bool BedJetHub::discover_characteristics_() {
     }
   }
 
-  ESP_LOGI(TAG,
-           "[%s] Discovered service characteristics:\n"
-           "     - Command char: 0x%x\n"
-           "     - Status char: 0x%x\n"
-           "       - config descriptor: 0x%x\n"
-           "     - Name char: 0x%x",
-           this->get_name().c_str(), this->char_handle_cmd_, this->char_handle_status_, this->config_descr_status_,
-           this->char_handle_name_);
+  ESP_LOGI(TAG, "[%s] Discovered service characteristics: ", this->get_name().c_str());
+  ESP_LOGI(TAG, "     - Command char: 0x%x", this->char_handle_cmd_);
+  ESP_LOGI(TAG, "     - Status char: 0x%x", this->char_handle_status_);
+  ESP_LOGI(TAG, "       - config descriptor: 0x%x", this->config_descr_status_);
+  ESP_LOGI(TAG, "     - Name char: 0x%x", this->char_handle_name_);
 
   return result;
 }

esphome/components/bedjet/climate/__init__.py

@@ -1,7 +1,12 @@
 import esphome.codegen as cg
-from esphome.components import climate
+from esphome.components import ble_client, climate
 import esphome.config_validation as cv
-from esphome.const import CONF_HEAT_MODE, CONF_TEMPERATURE_SOURCE
+from esphome.const import (
+    CONF_HEAT_MODE,
+    CONF_RECEIVE_TIMEOUT,
+    CONF_TEMPERATURE_SOURCE,
+    CONF_TIME_ID,
+)
 
 from .. import BEDJET_CLIENT_SCHEMA, bedjet_ns, register_bedjet_child
 
@@ -33,6 +38,22 @@ 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/bedjet/climate/bedjet_climate.cpp

@@ -164,21 +164,21 @@ void BedJetClimate::control(const ClimateCall &call) {
       return;
     }
   } else if (call.has_custom_preset()) {
-    auto preset = call.get_custom_preset();
+    const char *preset = call.get_custom_preset();
     bool result;
 
-    if (preset == "M1") {
+    if (strcmp(preset, "M1") == 0) {
       result = this->parent_->button_memory1();
-    } else if (preset == "M2") {
+    } else if (strcmp(preset, "M2") == 0) {
       result = this->parent_->button_memory2();
-    } else if (preset == "M3") {
+    } else if (strcmp(preset, "M3") == 0) {
       result = this->parent_->button_memory3();
-    } else if (preset == "LTD HT") {
+    } else if (strcmp(preset, "LTD HT") == 0) {
       result = this->parent_->button_heat();
-    } else if (preset == "EXT HT") {
+    } else if (strcmp(preset, "EXT HT") == 0) {
       result = this->parent_->button_ext_heat();
     } else {
-      ESP_LOGW(TAG, "Unsupported preset: %.*s", (int) preset.size(), preset.c_str());
+      ESP_LOGW(TAG, "Unsupported preset: %s", preset);
       return;
     }
 
@@ -208,11 +208,10 @@ void BedJetClimate::control(const ClimateCall &call) {
       this->set_fan_mode_(fan_mode);
     }
   } else if (call.has_custom_fan_mode()) {
-    auto fan_mode = call.get_custom_fan_mode();
-    auto fan_index = bedjet_fan_speed_to_step(fan_mode.c_str());
+    const char *fan_mode = call.get_custom_fan_mode();
+    auto fan_index = bedjet_fan_speed_to_step(fan_mode);
     if (fan_index <= 19) {
-      ESP_LOGV(TAG, "[%s] Converted fan mode %.*s to bedjet fan step %d", this->get_name().c_str(),
-               (int) fan_mode.size(), fan_mode.c_str(), fan_index);
+      ESP_LOGV(TAG, "[%s] Converted fan mode %s to bedjet fan step %d", this->get_name().c_str(), fan_mode, fan_index);
       bool result = this->parent_->set_fan_index(fan_index);
       if (result) {
         this->set_custom_fan_mode_(fan_mode);

esphome/components/bh1750/bh1750.cpp

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

esphome/components/bh1750/bh1750.h

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

esphome/components/bh1750/sensor.py

@@ -20,6 +20,16 @@ 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/binary_sensor/__init__.py

@@ -3,7 +3,7 @@ from logging import getLogger
 from esphome import automation, core
 from esphome.automation import Condition, maybe_simple_id
 import esphome.codegen as cg
-from esphome.components import mqtt, web_server, zigbee
+from esphome.components import mqtt, web_server
 from esphome.components.const import CONF_ON_STATE_CHANGE
 import esphome.config_validation as cv
 from esphome.const import (
@@ -439,7 +439,6 @@ def validate_publish_initial_state(value):
 _BINARY_SENSOR_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMPONENT_SCHEMA)
-    .extend(zigbee.BINARY_SENSOR_SCHEMA)
     .extend(
         {
             cv.GenerateID(): cv.declare_id(BinarySensor),
@@ -521,7 +520,6 @@ _BINARY_SENSOR_SCHEMA = (
 
 
 _BINARY_SENSOR_SCHEMA.add_extra(entity_duplicate_validator("binary_sensor"))
-_BINARY_SENSOR_SCHEMA.add_extra(zigbee.validate_binary_sensor)
 
 
 def binary_sensor_schema(
@@ -623,8 +621,6 @@ async def setup_binary_sensor_core_(var, config):
     if web_server_config := config.get(CONF_WEB_SERVER):
         await web_server.add_entity_config(var, web_server_config)
 
-    await zigbee.setup_binary_sensor(var, config)
-
 
 async def register_binary_sensor(var, config):
     if not CORE.has_id(config[CONF_ID]):

esphome/components/binary_sensor/automation.cpp

@@ -21,10 +21,8 @@ void MultiClickTrigger::on_state_(bool state) {
     // Start matching
     MultiClickTriggerEvent evt = this->timing_[0];
     if (evt.state == state) {
-      ESP_LOGV(TAG,
-               "START min=%" PRIu32 " max=%" PRIu32 "\n"
-               "Multi Click: Starting multi click action!",
-               evt.min_length, evt.max_length);
+      ESP_LOGV(TAG, "START min=%" PRIu32 " max=%" PRIu32, evt.min_length, evt.max_length);
+      ESP_LOGV(TAG, "Multi Click: Starting multi click action!");
       this->at_index_ = 1;
       if (this->timing_.size() == 1 && evt.max_length == 4294967294UL) {
         this->set_timeout("trigger", evt.min_length, [this]() { this->trigger_(); });

esphome/components/bk72xx/__init__.py

@@ -1,23 +1,9 @@
-"""
-██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗
-██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝
-██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗
-██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║
-╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝
- ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝
-
-         AUTO-GENERATED FILE - DO NOT EDIT!
-
-This file was auto-generated by libretiny/generate_components.py.
-Any manual changes WILL BE LOST on regeneration.
-
-To customize this component:
-  - Pin validators: Create gpio.py with validate_pin() or validate_usage()
-  - Schema extensions: Create schema.py with COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
-
-Platform-specific code should be added to the main libretiny component
-(__init__.py in esphome/components/libretiny/) rather than here.
-"""
+# This file was auto-generated by libretiny/generate_components.py
+# Do not modify its contents.
+# For custom pin validators, put validate_pin() or validate_usage()
+# in gpio.py file in this directory.
+# For changing schema/pin schema, put COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
+# in schema.py file in this directory.
 
 from esphome import pins
 from esphome.components import libretiny
@@ -41,7 +27,6 @@ COMPONENT_DATA = LibreTinyComponent(
     board_pins=BK72XX_BOARD_PINS,
     pin_validation=None,
     usage_validation=None,
-    supports_atomics=False,
 )
 
 

esphome/components/ble_client/automation.h

@@ -7,12 +7,8 @@
 
 #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 .
@@ -155,10 +151,7 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
       esph_log_w(Automation::TAG, "Cannot write to BLE characteristic - not connected");
       return false;
     }
-#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
+    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", len, format_hex_pretty(data, len).c_str());
     esp_err_t err =
         esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_, len,
                                  const_cast<uint8_t *>(data), this->write_type_, ESP_GATT_AUTH_REQ_NONE);
@@ -186,10 +179,8 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
       case ESP_GATTC_SEARCH_CMPL_EVT: {
         auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
         if (chr == nullptr) {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          char service_buf[esp32_ble::UUID_STR_LEN];
           esph_log_w("ble_write_action", "Characteristic %s was not found in service %s",
-                     this->char_uuid_.to_str(char_buf), this->service_uuid_.to_str(service_buf));
+                     this->char_uuid_.to_string().c_str(), this->service_uuid_.to_string().c_str());
           break;
         }
         this->char_handle_ = chr->handle;
@@ -201,13 +192,11 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
           this->write_type_ = ESP_GATT_WRITE_TYPE_NO_RSP;
           esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_NO_RSP");
         } else {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          esph_log_e(Automation::TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
+          esph_log_e(Automation::TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_string().c_str());
           break;
         }
         this->node_state = espbt::ClientState::ESTABLISHED;
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
+        esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_string().c_str(),
                    ble_client_->address_str());
         break;
       }

esphome/components/ble_client/output/ble_binary_output.cpp

@@ -9,15 +9,12 @@ static const char *const TAG = "ble_binary_output";
 
 void BLEBinaryOutput::dump_config() {
   ESP_LOGCONFIG(TAG, "BLE Binary Output:");
-  char service_buf[esp32_ble::UUID_STR_LEN];
-  char char_buf[esp32_ble::UUID_STR_LEN];
-  this->service_uuid_.to_str(service_buf);
-  this->char_uuid_.to_str(char_buf);
   ESP_LOGCONFIG(TAG,
                 "  MAC address        : %s\n"
                 "  Service UUID       : %s\n"
                 "  Characteristic UUID: %s",
-                this->parent_->address_str(), service_buf, char_buf);
+                this->parent_->address_str(), this->service_uuid_.to_string().c_str(),
+                this->char_uuid_.to_string().c_str());
   LOG_BINARY_OUTPUT(this);
 }
 
@@ -27,10 +24,8 @@ void BLEBinaryOutput::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
     case ESP_GATTC_SEARCH_CMPL_EVT: {
       auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
       if (chr == nullptr) {
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        char service_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGW(TAG, "Characteristic %s was not found in service %s", this->char_uuid_.to_str(char_buf),
-                 this->service_uuid_.to_str(service_buf));
+        ESP_LOGW(TAG, "Characteristic %s was not found in service %s", this->char_uuid_.to_string().c_str(),
+                 this->service_uuid_.to_string().c_str());
         break;
       }
       this->char_handle_ = chr->handle;
@@ -42,24 +37,20 @@ void BLEBinaryOutput::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
         this->write_type_ = ESP_GATT_WRITE_TYPE_NO_RSP;
         ESP_LOGD(TAG, "Write type: ESP_GATT_WRITE_TYPE_NO_RSP");
       } else {
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGE(TAG, "Characteristic %s does not allow writing with%s response", this->char_uuid_.to_str(char_buf),
+        ESP_LOGE(TAG, "Characteristic %s does not allow writing with%s response", this->char_uuid_.to_string().c_str(),
                  this->require_response_ ? "" : "out");
         break;
       }
       this->node_state = espbt::ClientState::ESTABLISHED;
-      char char_buf[esp32_ble::UUID_STR_LEN];
-      ESP_LOGD(TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
+      ESP_LOGD(TAG, "Found characteristic %s on device %s", this->char_uuid_.to_string().c_str(),
                this->parent()->address_str());
       this->node_state = espbt::ClientState::ESTABLISHED;
       break;
     }
     case ESP_GATTC_WRITE_CHAR_EVT: {
       if (param->write.handle == this->char_handle_) {
-        if (param->write.status != 0) {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          ESP_LOGW(TAG, "[%s] Write error, status=%d", this->char_uuid_.to_str(char_buf), param->write.status);
-        }
+        if (param->write.status != 0)
+          ESP_LOGW(TAG, "[%s] Write error, status=%d", this->char_uuid_.to_string().c_str(), param->write.status);
       }
       break;
     }
@@ -69,19 +60,18 @@ void BLEBinaryOutput::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
 }
 
 void BLEBinaryOutput::write_state(bool state) {
-  char char_buf[esp32_ble::UUID_STR_LEN];
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
     ESP_LOGW(TAG, "[%s] Not connected to BLE client.  State update can not be written.",
-             this->char_uuid_.to_str(char_buf));
+             this->char_uuid_.to_string().c_str());
     return;
   }
   uint8_t state_as_uint = (uint8_t) state;
-  ESP_LOGV(TAG, "[%s] Write State: %d", this->char_uuid_.to_str(char_buf), state_as_uint);
+  ESP_LOGV(TAG, "[%s] Write State: %d", this->char_uuid_.to_string().c_str(), state_as_uint);
   esp_err_t err =
       esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_,
                                sizeof(state_as_uint), &state_as_uint, this->write_type_, ESP_GATT_AUTH_REQ_NONE);
   if (err != ESP_GATT_OK)
-    ESP_LOGW(TAG, "[%s] Write error, err=%d", this->char_uuid_.to_str(char_buf), err);
+    ESP_LOGW(TAG, "[%s] Write error, err=%d", this->char_uuid_.to_string().c_str(), err);
 }
 
 }  // namespace esphome::ble_client

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -18,17 +18,14 @@ void BLESensor::loop() {
 
 void BLESensor::dump_config() {
   LOG_SENSOR("", "BLE Sensor", this);
-  char service_buf[esp32_ble::UUID_STR_LEN];
-  char char_buf[esp32_ble::UUID_STR_LEN];
-  char descr_buf[esp32_ble::UUID_STR_LEN];
   ESP_LOGCONFIG(TAG,
                 "  MAC address        : %s\n"
                 "  Service UUID       : %s\n"
                 "  Characteristic UUID: %s\n"
                 "  Descriptor UUID    : %s\n"
                 "  Notifications      : %s",
-                this->parent()->address_str(), this->service_uuid_.to_str(service_buf),
-                this->char_uuid_.to_str(char_buf), this->descr_uuid_.to_str(descr_buf), YESNO(this->notify_));
+                this->parent()->address_str(), this->service_uuid_.to_string().c_str(),
+                this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
 
@@ -54,10 +51,8 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
       if (chr == nullptr) {
         this->status_set_warning();
         this->publish_state(NAN);
-        char service_buf[esp32_ble::UUID_STR_LEN];
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_str(service_buf),
-                 this->char_uuid_.to_str(char_buf));
+        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_string().c_str(),
+                 this->char_uuid_.to_string().c_str());
         break;
       }
       this->handle = chr->handle;
@@ -66,12 +61,9 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
         if (descr == nullptr) {
           this->status_set_warning();
           this->publish_state(NAN);
-          char service_buf[esp32_ble::UUID_STR_LEN];
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          char descr_buf[esp32_ble::UUID_STR_LEN];
           ESP_LOGW(TAG, "No sensor descriptor found at service %s char %s descr %s",
-                   this->service_uuid_.to_str(service_buf), this->char_uuid_.to_str(char_buf),
-                   this->descr_uuid_.to_str(descr_buf));
+                   this->service_uuid_.to_string().c_str(), this->char_uuid_.to_string().c_str(),
+                   this->descr_uuid_.to_string().c_str());
           break;
         }
         this->handle = descr->handle;
@@ -117,8 +109,7 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
           break;
         }
         this->node_state = espbt::ClientState::ESTABLISHED;
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGD(TAG, "Register for notify on %s complete", this->char_uuid_.to_str(char_buf));
+        ESP_LOGD(TAG, "Register for notify on %s complete", this->char_uuid_.to_string().c_str());
       }
       break;
     }

esphome/components/ble_client/text_sensor/automation.h

@@ -21,7 +21,7 @@ class BLETextSensorNotifyTrigger : public Trigger<std::string>, public BLETextSe
         if (param->notify.conn_id != this->sensor_->parent()->get_conn_id() ||
             param->notify.handle != this->sensor_->handle)
           break;
-        this->trigger(std::string(reinterpret_cast<const char *>(param->notify.value), param->notify.value_len));
+        this->trigger(this->sensor_->parse_data(param->notify.value, param->notify.value_len));
       }
       default:
         break;

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -11,6 +11,8 @@ namespace esphome::ble_client {
 
 static const char *const TAG = "ble_text_sensor";
 
+static const std::string EMPTY = "";
+
 void BLETextSensor::loop() {
   // Parent BLEClientNode has a loop() method, but this component uses
   // polling via update() and BLE callbacks so loop isn't needed
@@ -19,17 +21,14 @@ void BLETextSensor::loop() {
 
 void BLETextSensor::dump_config() {
   LOG_TEXT_SENSOR("", "BLE Text Sensor", this);
-  char service_buf[esp32_ble::UUID_STR_LEN];
-  char char_buf[esp32_ble::UUID_STR_LEN];
-  char descr_buf[esp32_ble::UUID_STR_LEN];
   ESP_LOGCONFIG(TAG,
                 "  MAC address        : %s\n"
                 "  Service UUID       : %s\n"
                 "  Characteristic UUID: %s\n"
                 "  Descriptor UUID    : %s\n"
                 "  Notifications      : %s",
-                this->parent()->address_str(), this->service_uuid_.to_str(service_buf),
-                this->char_uuid_.to_str(char_buf), this->descr_uuid_.to_str(descr_buf), YESNO(this->notify_));
+                this->parent()->address_str(), this->service_uuid_.to_string().c_str(),
+                this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
 
@@ -45,7 +44,7 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
     }
     case ESP_GATTC_CLOSE_EVT: {
       this->status_set_warning();
-      this->publish_state("");
+      this->publish_state(EMPTY);
       break;
     }
     case ESP_GATTC_SEARCH_CMPL_EVT: {
@@ -53,11 +52,9 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
       if (chr == nullptr) {
         this->status_set_warning();
-        this->publish_state("");
-        char service_buf[esp32_ble::UUID_STR_LEN];
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_str(service_buf),
-                 this->char_uuid_.to_str(char_buf));
+        this->publish_state(EMPTY);
+        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_string().c_str(),
+                 this->char_uuid_.to_string().c_str());
         break;
       }
       this->handle = chr->handle;
@@ -65,13 +62,10 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         auto *descr = chr->get_descriptor(this->descr_uuid_);
         if (descr == nullptr) {
           this->status_set_warning();
-          this->publish_state("");
-          char service_buf[esp32_ble::UUID_STR_LEN];
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          char descr_buf[esp32_ble::UUID_STR_LEN];
+          this->publish_state(EMPTY);
           ESP_LOGW(TAG, "No sensor descriptor found at service %s char %s descr %s",
-                   this->service_uuid_.to_str(service_buf), this->char_uuid_.to_str(char_buf),
-                   this->descr_uuid_.to_str(descr_buf));
+                   this->service_uuid_.to_string().c_str(), this->char_uuid_.to_string().c_str(),
+                   this->descr_uuid_.to_string().c_str());
           break;
         }
         this->handle = descr->handle;
@@ -97,7 +91,7 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
           break;
         }
         this->status_clear_warning();
-        this->publish_state(reinterpret_cast<const char *>(param->read.value), param->read.value_len);
+        this->publish_state(this->parse_data(param->read.value, param->read.value_len));
       }
       break;
     }
@@ -106,7 +100,7 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         break;
       ESP_LOGV(TAG, "[%s] ESP_GATTC_NOTIFY_EVT: handle=0x%x, value=0x%x", this->get_name().c_str(),
                param->notify.handle, param->notify.value[0]);
-      this->publish_state(reinterpret_cast<const char *>(param->notify.value), param->notify.value_len);
+      this->publish_state(this->parse_data(param->notify.value, param->notify.value_len));
       break;
     }
     case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
@@ -119,6 +113,11 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
   }
 }
 
+std::string BLETextSensor::parse_data(uint8_t *value, uint16_t value_len) {
+  std::string text(value, value + value_len);
+  return text;
+}
+
 void BLETextSensor::update() {
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
     ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->get_name().c_str());
@@ -133,7 +132,7 @@ void BLETextSensor::update() {
                                         ESP_GATT_AUTH_REQ_NONE);
   if (status) {
     this->status_set_warning();
-    this->publish_state("");
+    this->publish_state(EMPTY);
     ESP_LOGW(TAG, "[%s] Error sending read request for sensor, status=%d", this->get_name().c_str(), status);
   }
 }

esphome/components/ble_client/text_sensor/ble_text_sensor.h

@@ -29,6 +29,7 @@ class BLETextSensor : public text_sensor::TextSensor, public PollingComponent, p
   void set_descr_uuid32(uint32_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
   void set_descr_uuid128(uint8_t *uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
   void set_enable_notify(bool notify) { this->notify_ = notify; }
+  std::string parse_data(uint8_t *value, uint16_t value_len);
   uint16_t handle;
 
  protected:

esphome/components/ble_nus/__init__.py

@@ -1,5 +1,4 @@
 import esphome.codegen as cg
-from esphome.components.logger import request_log_listener
 from esphome.components.zephyr import zephyr_add_prj_conf
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_LOGS, CONF_TYPE
@@ -26,8 +25,5 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     zephyr_add_prj_conf("BT_NUS", True)
-    expose_log = config[CONF_TYPE] == CONF_LOGS
-    cg.add(var.set_expose_log(expose_log))
-    if expose_log:
-        request_log_listener()  # Request a log listener slot for BLE NUS log streaming
+    cg.add(var.set_expose_log(config[CONF_TYPE] == CONF_LOGS))
     await cg.register_component(var, config)

esphome/components/ble_nus/ble_nus.cpp

@@ -103,10 +103,8 @@ void BLENUS::on_log(uint8_t level, const char *tag, const char *message, size_t
 #endif
 
 void BLENUS::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "ble nus:\n"
-                "  log: %s",
-                YESNO(this->expose_log_));
+  ESP_LOGCONFIG(TAG, "ble nus:");
+  ESP_LOGCONFIG(TAG, "  log: %s", YESNO(this->expose_log_));
   uint32_t mtu = 0;
   bt_conn *conn = this->conn_.load();
   if (conn) {

esphome/components/ble_scanner/ble_scanner.h

@@ -1,8 +1,7 @@
 #pragma once
 
-#include <cinttypes>
-#include <cstdio>
 #include <ctime>
+#include <string>
 
 #include "esphome/core/component.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
@@ -16,13 +15,17 @@ namespace ble_scanner {
 class BLEScanner : public text_sensor::TextSensor, public esp32_ble_tracker::ESPBTDeviceListener, public Component {
  public:
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override {
-    // Format JSON using stack buffer to avoid heap allocations from string concatenation
-    char buf[128];
-    char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-    snprintf(buf, sizeof(buf), "{\"timestamp\":%" PRId64 ",\"address\":\"%s\",\"rssi\":%d,\"name\":\"%s\"}",
-             static_cast<int64_t>(::time(nullptr)), device.address_str_to(addr_buf), device.get_rssi(),
-             device.get_name().c_str());
-    this->publish_state(buf);
+    this->publish_state("{\"timestamp\":" + to_string(::time(nullptr)) +
+                        ","
+                        "\"address\":\"" +
+                        device.address_str() +
+                        "\","
+                        "\"rssi\":" +
+                        to_string(device.get_rssi()) +
+                        ","
+                        "\"name\":\"" +
+                        device.get_name() + "\"}");
+
     return true;
   }
   void dump_config() override;

esphome/components/bme68x_bsec2/sensor.py

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