[socket] Implement working ready() for LWIP raw TCP sockets (ESP8266/RP2040)

Previously ready() always returned true on ESP8266/RP2040, causing
every socket to be checked on every loop iteration even when no data
was available.

Override ready() in LWIPRawImpl to check rx_buf_/rx_closed_/pcb_ state,
and in LWIPRawListenImpl to check accepted_socket_count_. This uses
existing fields so no extra memory is needed per socket.

Keep ready() virtual only on the non-select path (ESP8266/RP2040) so
the select()-based path (ESP32) retains the non-virtual optimization
from the previous commit.

.clang-tidy.hash

@@ -1 +1 @@
-37ec8d5a343c8d0a485fd2118cbdabcbccd7b9bca197e4a392be75087974dced
+8dc4dae0acfa22f26c7cde87fc24e60b27f29a73300e02189b78f0315e5d0695

esphome/__main__.py

@@ -965,38 +965,6 @@ def command_clean(args: ArgsProtocol, config: ConfigType) -> int | None:
     return 0
 
 
-def command_bundle(args: ArgsProtocol, config: ConfigType) -> int | None:
-    from esphome.bundle import BUNDLE_EXTENSION, ConfigBundleCreator
-
-    creator = ConfigBundleCreator(config)
-
-    if args.list_only:
-        files = creator.discover_files()
-        for bf in sorted(files, key=lambda f: f.path):
-            safe_print(f"  {bf.path}")
-        _LOGGER.info("Found %d files", len(files))
-        return 0
-
-    result = creator.create_bundle()
-
-    if args.output:
-        output_path = Path(args.output)
-    else:
-        stem = CORE.config_path.stem
-        output_path = CORE.config_dir / f"{stem}{BUNDLE_EXTENSION}"
-
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    output_path.write_bytes(result.data)
-
-    _LOGGER.info(
-        "Bundle created: %s (%d files, %.1f KB)",
-        output_path,
-        len(result.files),
-        len(result.data) / 1024,
-    )
-    return 0
-
-
 def command_dashboard(args: ArgsProtocol) -> int | None:
     from esphome.dashboard import dashboard
 
@@ -1274,7 +1242,6 @@ POST_CONFIG_ACTIONS = {
     "rename": command_rename,
     "discover": command_discover,
     "analyze-memory": command_analyze_memory,
-    "bundle": command_bundle,
 }
 
 SIMPLE_CONFIG_ACTIONS = [
@@ -1578,24 +1545,6 @@ def parse_args(argv):
         "configuration", help="Your YAML configuration file(s).", nargs="+"
     )
 
-    parser_bundle = subparsers.add_parser(
-        "bundle",
-        help="Create a self-contained config bundle for remote compilation.",
-    )
-    parser_bundle.add_argument(
-        "configuration", help="Your YAML configuration file(s).", nargs="+"
-    )
-    parser_bundle.add_argument(
-        "-o",
-        "--output",
-        help="Output path for the bundle archive.",
-    )
-    parser_bundle.add_argument(
-        "--list-only",
-        help="List discovered files without creating the archive.",
-        action="store_true",
-    )
-
     # Keep backward compatibility with the old command line format of
     # esphome <config> <command>.
     #
@@ -1674,16 +1623,6 @@ def run_esphome(argv):
         _LOGGER.warning("Skipping secrets file %s", conf_path)
         return 0
 
-    # Bundle support: if the configuration is a .esphomebundle, extract it
-    # and rewrite conf_path to the extracted YAML config.
-    from esphome.bundle import is_bundle_path, prepare_bundle_for_compile
-
-    if is_bundle_path(conf_path):
-        _LOGGER.info("Extracting config bundle %s...", conf_path)
-        conf_path = prepare_bundle_for_compile(conf_path)
-        # Update the argument so downstream code sees the extracted path
-        args.configuration[0] = str(conf_path)
-
     CORE.config_path = conf_path
     CORE.dashboard = args.dashboard
 

esphome/bundle.py

@@ -1,699 +0,0 @@
-"""Config bundle creator and extractor for ESPHome.
-
-A bundle is a self-contained .tar.gz archive containing a YAML config
-and every local file it depends on. Bundles can be created from a config
-and compiled directly: ``esphome compile my_device.esphomebundle.tar.gz``
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from enum import StrEnum
-import io
-import json
-import logging
-from pathlib import Path
-import re
-import shutil
-import tarfile
-from typing import Any
-
-from esphome import const, yaml_util
-from esphome.const import (
-    CONF_ESPHOME,
-    CONF_EXTERNAL_COMPONENTS,
-    CONF_INCLUDES,
-    CONF_INCLUDES_C,
-    CONF_PATH,
-    CONF_SOURCE,
-    CONF_TYPE,
-)
-from esphome.core import CORE, EsphomeError
-
-_LOGGER = logging.getLogger(__name__)
-
-BUNDLE_EXTENSION = ".esphomebundle.tar.gz"
-MANIFEST_FILENAME = "manifest.json"
-CURRENT_MANIFEST_VERSION = 1
-MAX_DECOMPRESSED_SIZE = 500 * 1024 * 1024  # 500 MB
-MAX_MANIFEST_SIZE = 1024 * 1024  # 1 MB
-
-# Directories preserved across bundle extractions (build caches)
-_PRESERVE_DIRS = (".esphome", ".pioenvs", ".pio")
-_BUNDLE_STAGING_DIR = ".bundle_staging"
-
-
-class ManifestKey(StrEnum):
-    """Keys used in bundle manifest.json."""
-
-    MANIFEST_VERSION = "manifest_version"
-    ESPHOME_VERSION = "esphome_version"
-    CONFIG_FILENAME = "config_filename"
-    FILES = "files"
-    HAS_SECRETS = "has_secrets"
-
-
-# String prefixes that are never local file paths
-_NON_PATH_PREFIXES = ("http://", "https://", "ftp://", "mdi:", "<")
-
-# File extensions recognized when resolving relative path strings.
-# A relative string with one of these extensions is resolved against the
-# config directory and included if the file exists.
-_KNOWN_FILE_EXTENSIONS = frozenset(
-    {
-        # Fonts
-        ".ttf",
-        ".otf",
-        ".woff",
-        ".woff2",
-        ".pcf",
-        ".bdf",
-        # Images
-        ".png",
-        ".jpg",
-        ".jpeg",
-        ".bmp",
-        ".gif",
-        ".svg",
-        ".ico",
-        ".webp",
-        # Certificates
-        ".pem",
-        ".crt",
-        ".key",
-        ".der",
-        ".p12",
-        ".pfx",
-        # C/C++ includes
-        ".h",
-        ".hpp",
-        ".c",
-        ".cpp",
-        ".ino",
-        # Web assets
-        ".css",
-        ".js",
-        ".html",
-    }
-)
-
-
-# Matches !secret references in YAML text.  This is intentionally a simple
-# regex scan rather than a YAML parse — it may match inside comments or
-# multi-line strings, which is the conservative direction (include more
-# secrets rather than fewer).
-_SECRET_RE = re.compile(r"!secret\s+(\S+)")
-
-
-def _find_used_secret_keys(yaml_files: list[Path]) -> set[str]:
-    """Scan YAML files for ``!secret <key>`` references."""
-    keys: set[str] = set()
-    for fpath in yaml_files:
-        try:
-            text = fpath.read_text(encoding="utf-8")
-        except (OSError, UnicodeDecodeError):
-            continue
-        for match in _SECRET_RE.finditer(text):
-            keys.add(match.group(1))
-    return keys
-
-
-@dataclass
-class BundleFile:
-    """A file to include in the bundle."""
-
-    path: str  # Relative path inside the archive
-    source: Path  # Absolute path on disk
-
-
-@dataclass
-class BundleResult:
-    """Result of creating a bundle."""
-
-    data: bytes
-    manifest: dict[str, Any]
-    files: list[BundleFile]
-
-
-@dataclass
-class BundleManifest:
-    """Parsed and validated bundle manifest."""
-
-    manifest_version: int
-    esphome_version: str
-    config_filename: str
-    files: list[str]
-    has_secrets: bool
-
-
-class ConfigBundleCreator:
-    """Creates a self-contained bundle from an ESPHome config."""
-
-    def __init__(self, config: dict[str, Any]) -> None:
-        self._config = config
-        self._config_dir = CORE.config_dir
-        self._config_path = CORE.config_path
-        self._files: list[BundleFile] = []
-        self._seen_paths: set[Path] = set()
-        self._secrets_paths: set[Path] = set()
-
-    def discover_files(self) -> list[BundleFile]:
-        """Discover all files needed for the bundle."""
-        self._files = []
-        self._seen_paths = set()
-        self._secrets_paths = set()
-
-        # The main config file
-        self._add_file(self._config_path)
-
-        # Phase 1: YAML includes (tracked during config loading)
-        self._discover_yaml_includes()
-
-        # Phase 2: Component-referenced files from validated config
-        self._discover_component_files()
-
-        return list(self._files)
-
-    def create_bundle(self) -> BundleResult:
-        """Create the bundle archive."""
-        files = self.discover_files()
-
-        # Determine which secret keys are actually referenced by the
-        # bundled YAML files so we only ship those, not the entire
-        # secrets.yaml which may contain secrets for other devices.
-        yaml_sources = [
-            bf.source for bf in files if bf.source.suffix in (".yaml", ".yml")
-        ]
-        used_secret_keys = _find_used_secret_keys(yaml_sources)
-        filtered_secrets = self._build_filtered_secrets(used_secret_keys)
-
-        has_secrets = bool(filtered_secrets)
-        if has_secrets:
-            _LOGGER.warning(
-                "Bundle contains secrets (e.g. Wi-Fi passwords). "
-                "Do not share it with untrusted parties."
-            )
-
-        manifest = self._build_manifest(files, has_secrets=has_secrets)
-
-        buf = io.BytesIO()
-        with tarfile.open(fileobj=buf, mode="w:gz") as tar:
-            # Add manifest first
-            manifest_data = json.dumps(manifest, indent=2).encode("utf-8")
-            _add_bytes_to_tar(tar, MANIFEST_FILENAME, manifest_data)
-
-            # Add filtered secrets files
-            for rel_path, data in sorted(filtered_secrets.items()):
-                _add_bytes_to_tar(tar, rel_path, data)
-
-            # Add files in sorted order for determinism, skipping secrets
-            # files which were already added above with filtered content
-            for bf in sorted(files, key=lambda f: f.path):
-                if bf.source in self._secrets_paths:
-                    continue
-                self._add_to_tar(tar, bf)
-
-        return BundleResult(data=buf.getvalue(), manifest=manifest, files=files)
-
-    def _add_file(self, abs_path: Path) -> bool:
-        """Add a file to the bundle. Returns False if already added."""
-        abs_path = abs_path.resolve()
-        if abs_path in self._seen_paths:
-            return False
-        if not abs_path.is_file():
-            _LOGGER.warning("Bundle: skipping missing file %s", abs_path)
-            return False
-
-        rel_path = self._relative_to_config_dir(abs_path)
-        if rel_path is None:
-            _LOGGER.warning(
-                "Bundle: skipping file outside config directory: %s", abs_path
-            )
-            return False
-
-        self._seen_paths.add(abs_path)
-        self._files.append(BundleFile(path=rel_path, source=abs_path))
-        return True
-
-    def _add_directory(self, abs_path: Path) -> None:
-        """Recursively add all files in a directory."""
-        abs_path = abs_path.resolve()
-        if not abs_path.is_dir():
-            _LOGGER.warning("Bundle: skipping missing directory %s", abs_path)
-            return
-        for child in sorted(abs_path.rglob("*")):
-            if child.is_file() and "__pycache__" not in child.parts:
-                self._add_file(child)
-
-    def _relative_to_config_dir(self, abs_path: Path) -> str | None:
-        """Get a path relative to the config directory. Returns None if outside.
-
-        Always uses forward slashes for consistency in tar archives.
-        """
-        try:
-            return abs_path.relative_to(self._config_dir).as_posix()
-        except ValueError:
-            return None
-
-    def _discover_yaml_includes(self) -> None:
-        """Discover YAML files loaded during config parsing.
-
-        We track files by wrapping _load_yaml_internal. The config has already
-        been loaded at this point (bundle is a POST_CONFIG_ACTION), so we
-        re-load just to discover the file list.
-
-        Secrets files are tracked separately so we can filter them to
-        only include the keys this config actually references.
-        """
-        with yaml_util.track_yaml_loads() as loaded_files:
-            try:
-                yaml_util.load_yaml(self._config_path)
-            except EsphomeError:
-                _LOGGER.debug(
-                    "Bundle: re-loading YAML for include discovery failed, "
-                    "proceeding with partial file list"
-                )
-
-        for fpath in loaded_files:
-            if fpath == self._config_path.resolve():
-                continue  # Already added as config
-            if fpath.name in const.SECRETS_FILES:
-                self._secrets_paths.add(fpath)
-            self._add_file(fpath)
-
-    def _discover_component_files(self) -> None:
-        """Walk the validated config for file references.
-
-        Uses a generic recursive walk to find file paths instead of
-        hardcoding per-component knowledge about config dict formats.
-        After validation, components typically resolve paths to absolute
-        using CORE.relative_config_path() or cv.file_(). Relative paths
-        with known file extensions are also resolved and checked.
-
-        Core ESPHome concepts that use relative paths or directories
-        are handled explicitly.
-        """
-        config = self._config
-
-        # Generic walk: find all file paths in the validated config
-        self._walk_config_for_files(config)
-
-        # --- Core ESPHome concepts needing explicit handling ---
-
-        # esphome.includes / includes_c - can be relative paths and directories
-        esphome_conf = config.get(CONF_ESPHOME, {})
-        for include_path in esphome_conf.get(CONF_INCLUDES, []):
-            resolved = _resolve_include_path(include_path)
-            if resolved is None:
-                continue
-            if resolved.is_dir():
-                self._add_directory(resolved)
-            else:
-                self._add_file(resolved)
-        for include_path in esphome_conf.get(CONF_INCLUDES_C, []):
-            resolved = _resolve_include_path(include_path)
-            if resolved is not None:
-                self._add_file(resolved)
-
-        # external_components with source: local - directories
-        for ext_conf in config.get(CONF_EXTERNAL_COMPONENTS, []):
-            source = ext_conf.get(CONF_SOURCE, {})
-            if not isinstance(source, dict):
-                continue
-            if source.get(CONF_TYPE) != "local":
-                continue
-            path = source.get(CONF_PATH)
-            if not path:
-                continue
-            p = Path(path)
-            if not p.is_absolute():
-                p = CORE.relative_config_path(p)
-            self._add_directory(p)
-
-    def _walk_config_for_files(self, obj: Any) -> None:
-        """Recursively walk the config dict looking for file path references."""
-        if isinstance(obj, dict):
-            for value in obj.values():
-                self._walk_config_for_files(value)
-        elif isinstance(obj, (list, tuple)):
-            for item in obj:
-                self._walk_config_for_files(item)
-        elif isinstance(obj, Path):
-            if obj.is_absolute() and obj.is_file():
-                self._add_file(obj)
-        elif isinstance(obj, str):
-            self._check_string_path(obj)
-
-    def _check_string_path(self, value: str) -> None:
-        """Check if a string value is a local file reference."""
-        # Fast exits for strings that cannot be file paths
-        if len(value) < 2 or "\n" in value:
-            return
-        if value.startswith(_NON_PATH_PREFIXES):
-            return
-        # File paths must contain a path separator or a dot (for extension)
-        if "/" not in value and "\\" not in value and "." not in value:
-            return
-
-        p = Path(value)
-
-        # Absolute path - check if it points to an existing file
-        if p.is_absolute():
-            if p.is_file():
-                self._add_file(p)
-            return
-
-        # Relative path with a known file extension - likely a component
-        # validator that forgot to resolve to absolute via cv.file_() or
-        # CORE.relative_config_path(). Warn and try to resolve.
-        if p.suffix.lower() in _KNOWN_FILE_EXTENSIONS:
-            _LOGGER.warning(
-                "Bundle: non-absolute path in validated config: %s "
-                "(component validator should return absolute paths)",
-                value,
-            )
-            resolved = CORE.relative_config_path(p)
-            if resolved.is_file():
-                self._add_file(resolved)
-
-    def _build_filtered_secrets(self, used_keys: set[str]) -> dict[str, bytes]:
-        """Build filtered secrets files containing only the referenced keys.
-
-        Returns a dict mapping relative archive path to YAML bytes.
-        """
-        if not used_keys or not self._secrets_paths:
-            return {}
-
-        result: dict[str, bytes] = {}
-        for secrets_path in self._secrets_paths:
-            rel_path = self._relative_to_config_dir(secrets_path)
-            if rel_path is None:
-                continue
-            try:
-                all_secrets = yaml_util.load_yaml(secrets_path, clear_secrets=False)
-            except EsphomeError:
-                _LOGGER.warning("Bundle: failed to load secrets file %s", secrets_path)
-                continue
-            if not isinstance(all_secrets, dict):
-                continue
-            filtered = {k: v for k, v in all_secrets.items() if k in used_keys}
-            if filtered:
-                data = yaml_util.dump(filtered, show_secrets=True).encode("utf-8")
-                result[rel_path] = data
-        return result
-
-    def _build_manifest(
-        self, files: list[BundleFile], *, has_secrets: bool
-    ) -> dict[str, Any]:
-        """Build the manifest.json content."""
-        return {
-            ManifestKey.MANIFEST_VERSION: CURRENT_MANIFEST_VERSION,
-            ManifestKey.ESPHOME_VERSION: const.__version__,
-            ManifestKey.CONFIG_FILENAME: self._config_path.name,
-            ManifestKey.FILES: [f.path for f in files],
-            ManifestKey.HAS_SECRETS: has_secrets,
-        }
-
-    @staticmethod
-    def _add_to_tar(tar: tarfile.TarFile, bf: BundleFile) -> None:
-        """Add a BundleFile to the tar archive with deterministic metadata."""
-        with open(bf.source, "rb") as f:
-            _add_bytes_to_tar(tar, bf.path, f.read())
-
-
-def extract_bundle(
-    bundle_path: Path,
-    target_dir: Path | None = None,
-) -> Path:
-    """Extract a bundle archive and return the path to the config YAML.
-
-    Sanity checks reject path traversal, symlinks, absolute paths, and
-    oversized archives to prevent accidental file overwrites or extraction
-    outside the target directory.  These are **not** a security boundary —
-    bundles are assumed to come from the user's own machine or a trusted
-    build pipeline.
-
-    Args:
-        bundle_path: Path to the .tar.gz bundle file.
-        target_dir: Directory to extract into. If None, extracts next to
-                     the bundle file in a directory named after it.
-
-    Returns:
-        Absolute path to the extracted config YAML file.
-
-    Raises:
-        EsphomeError: If the bundle is invalid or extraction fails.
-    """
-
-    bundle_path = bundle_path.resolve()
-    if not bundle_path.is_file():
-        raise EsphomeError(f"Bundle file not found: {bundle_path}")
-
-    if target_dir is None:
-        target_dir = _default_target_dir(bundle_path)
-
-    target_dir = target_dir.resolve()
-    target_dir.mkdir(parents=True, exist_ok=True)
-
-    # Read and validate the archive
-    try:
-        with tarfile.open(bundle_path, "r:gz") as tar:
-            manifest = _read_manifest_from_tar(tar)
-            _validate_tar_members(tar, target_dir)
-            tar.extractall(path=target_dir, filter="data")
-    except tarfile.TarError as err:
-        raise EsphomeError(f"Failed to extract bundle: {err}") from err
-
-    config_filename = manifest[ManifestKey.CONFIG_FILENAME]
-    config_path = target_dir / config_filename
-    if not config_path.is_file():
-        raise EsphomeError(
-            f"Bundle manifest references config '{config_filename}' "
-            f"but it was not found in the archive"
-        )
-
-    return config_path
-
-
-def read_bundle_manifest(bundle_path: Path) -> BundleManifest:
-    """Read and validate the manifest from a bundle without full extraction.
-
-    Args:
-        bundle_path: Path to the .tar.gz bundle file.
-
-    Returns:
-        Parsed BundleManifest.
-
-    Raises:
-        EsphomeError: If the manifest is missing, invalid, or version unsupported.
-    """
-
-    try:
-        with tarfile.open(bundle_path, "r:gz") as tar:
-            manifest = _read_manifest_from_tar(tar)
-    except tarfile.TarError as err:
-        raise EsphomeError(f"Failed to read bundle: {err}") from err
-
-    return BundleManifest(
-        manifest_version=manifest[ManifestKey.MANIFEST_VERSION],
-        esphome_version=manifest.get(ManifestKey.ESPHOME_VERSION, "unknown"),
-        config_filename=manifest[ManifestKey.CONFIG_FILENAME],
-        files=manifest.get(ManifestKey.FILES, []),
-        has_secrets=manifest.get(ManifestKey.HAS_SECRETS, False),
-    )
-
-
-def _read_manifest_from_tar(tar: tarfile.TarFile) -> dict[str, Any]:
-    """Read and validate manifest.json from an open tar archive."""
-
-    try:
-        member = tar.getmember(MANIFEST_FILENAME)
-    except KeyError:
-        raise EsphomeError("Invalid bundle: missing manifest.json") from None
-
-    f = tar.extractfile(member)
-    if f is None:
-        raise EsphomeError("Invalid bundle: manifest.json is not a regular file")
-
-    if member.size > MAX_MANIFEST_SIZE:
-        raise EsphomeError(
-            f"Invalid bundle: manifest.json too large "
-            f"({member.size} bytes, max {MAX_MANIFEST_SIZE})"
-        )
-
-    try:
-        manifest = json.loads(f.read())
-    except (json.JSONDecodeError, UnicodeDecodeError) as err:
-        raise EsphomeError(f"Invalid bundle: malformed manifest.json: {err}") from err
-
-    # Version check
-    version = manifest.get(ManifestKey.MANIFEST_VERSION)
-    if version is None:
-        raise EsphomeError("Invalid bundle: manifest.json missing 'manifest_version'")
-    if not isinstance(version, int) or version < 1:
-        raise EsphomeError(
-            f"Invalid bundle: manifest_version must be a positive integer, got {version!r}"
-        )
-    if version > CURRENT_MANIFEST_VERSION:
-        raise EsphomeError(
-            f"Bundle manifest version {version} is newer than this ESPHome "
-            f"version supports (max {CURRENT_MANIFEST_VERSION}). "
-            f"Please upgrade ESPHome to compile this bundle."
-        )
-
-    # Required fields
-    if ManifestKey.CONFIG_FILENAME not in manifest:
-        raise EsphomeError("Invalid bundle: manifest.json missing 'config_filename'")
-
-    return manifest
-
-
-def _validate_tar_members(tar: tarfile.TarFile, target_dir: Path) -> None:
-    """Sanity-check tar members to prevent mistakes and accidental overwrites.
-
-    This is not a security boundary — bundles are created locally or come
-    from a trusted build pipeline.  The checks catch malformed archives
-    and common mistakes (stray absolute paths, ``..`` components) that
-    could silently overwrite unrelated files.
-    """
-
-    total_size = 0
-    for member in tar.getmembers():
-        # Reject absolute paths (Unix and Windows)
-        if member.name.startswith(("/", "\\")):
-            raise EsphomeError(
-                f"Invalid bundle: absolute path in archive: {member.name}"
-            )
-
-        # Reject path traversal (split on both / and \ for cross-platform)
-        parts = re.split(r"[/\\]", member.name)
-        if ".." in parts:
-            raise EsphomeError(
-                f"Invalid bundle: path traversal in archive: {member.name}"
-            )
-
-        # Reject symlinks
-        if member.issym() or member.islnk():
-            raise EsphomeError(f"Invalid bundle: symlink in archive: {member.name}")
-
-        # Ensure extraction stays within target_dir
-        target_path = (target_dir / member.name).resolve()
-        if not target_path.is_relative_to(target_dir):
-            raise EsphomeError(
-                f"Invalid bundle: file would extract outside target: {member.name}"
-            )
-
-        # Track total decompressed size
-        total_size += member.size
-        if total_size > MAX_DECOMPRESSED_SIZE:
-            raise EsphomeError(
-                f"Invalid bundle: decompressed size exceeds "
-                f"{MAX_DECOMPRESSED_SIZE // (1024 * 1024)}MB limit"
-            )
-
-
-def is_bundle_path(path: Path) -> bool:
-    """Check if a path looks like a bundle file."""
-    return path.name.lower().endswith(BUNDLE_EXTENSION)
-
-
-def _add_bytes_to_tar(tar: tarfile.TarFile, name: str, data: bytes) -> None:
-    """Add in-memory bytes to a tar archive with deterministic metadata."""
-    info = tarfile.TarInfo(name=name)
-    info.size = len(data)
-    info.mtime = 0
-    info.uid = 0
-    info.gid = 0
-    info.mode = 0o644
-    tar.addfile(info, io.BytesIO(data))
-
-
-def _resolve_include_path(include_path: Any) -> Path | None:
-    """Resolve an include path to absolute, skipping system includes."""
-    if isinstance(include_path, str) and include_path.startswith("<"):
-        return None  # System include, not a local file
-    p = Path(include_path)
-    if not p.is_absolute():
-        p = CORE.relative_config_path(p)
-    return p
-
-
-def _default_target_dir(bundle_path: Path) -> Path:
-    """Compute the default extraction directory for a bundle."""
-    name = bundle_path.name
-    if name.lower().endswith(BUNDLE_EXTENSION):
-        name = name[: -len(BUNDLE_EXTENSION)]
-    return bundle_path.parent / name
-
-
-def _restore_preserved_dirs(preserved: dict[str, Path], target_dir: Path) -> None:
-    """Move preserved build cache directories back into target_dir.
-
-    If the bundle contained entries under a preserved directory name,
-    the extracted copy is removed so the original cache always wins.
-    """
-    for dirname, src in preserved.items():
-        dst = target_dir / dirname
-        if dst.exists():
-            shutil.rmtree(dst)
-        shutil.move(str(src), str(dst))
-
-
-def prepare_bundle_for_compile(
-    bundle_path: Path,
-    target_dir: Path | None = None,
-) -> Path:
-    """Extract a bundle for compilation, preserving build caches.
-
-    Unlike extract_bundle(), this preserves .esphome/ and .pioenvs/
-    directories in the target if they already exist (for incremental builds).
-
-    Args:
-        bundle_path: Path to the .tar.gz bundle file.
-        target_dir: Directory to extract into. Must be specified for
-                     build server use.
-
-    Returns:
-        Absolute path to the extracted config YAML file.
-    """
-
-    bundle_path = bundle_path.resolve()
-    if not bundle_path.is_file():
-        raise EsphomeError(f"Bundle file not found: {bundle_path}")
-
-    if target_dir is None:
-        target_dir = _default_target_dir(bundle_path)
-
-    target_dir = target_dir.resolve()
-    target_dir.mkdir(parents=True, exist_ok=True)
-
-    preserved: dict[str, Path] = {}
-
-    # Temporarily move preserved dirs out of the way
-    staging = target_dir / _BUNDLE_STAGING_DIR
-    for dirname in _PRESERVE_DIRS:
-        src = target_dir / dirname
-        if src.is_dir():
-            dst = staging / dirname
-            dst.parent.mkdir(parents=True, exist_ok=True)
-            shutil.move(str(src), str(dst))
-            preserved[dirname] = dst
-
-    try:
-        # Clean non-preserved content and extract fresh
-        for item in target_dir.iterdir():
-            if item.name == _BUNDLE_STAGING_DIR:
-                continue
-            if item.is_dir():
-                shutil.rmtree(item)
-            else:
-                item.unlink()
-
-        config_path = extract_bundle(bundle_path, target_dir)
-    finally:
-        # Restore preserved dirs (idempotent) and clean staging
-        _restore_preserved_dirs(preserved, target_dir)
-        if staging.is_dir():
-            shutil.rmtree(staging)
-
-    return config_path

esphome/components/api/api.proto

@@ -1155,9 +1155,11 @@ enum WaterHeaterCommandHasField {
   WATER_HEATER_COMMAND_HAS_NONE = 0;
   WATER_HEATER_COMMAND_HAS_MODE = 1;
   WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE = 2;
-  WATER_HEATER_COMMAND_HAS_STATE = 4;
+  WATER_HEATER_COMMAND_HAS_STATE = 4 [deprecated=true];
   WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW = 8;
   WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH = 16;
+  WATER_HEATER_COMMAND_HAS_ON_STATE = 32;
+  WATER_HEATER_COMMAND_HAS_AWAY_STATE = 64;
 }
 
 message WaterHeaterCommandRequest {

esphome/components/api/api_connection.cpp

@@ -133,8 +133,8 @@ void APIConnection::start() {
     return;
   }
   // Initialize client name with peername (IP address) until Hello message provides actual name
-  const char *peername = this->helper_->get_client_peername();
-  this->helper_->set_client_name(peername, strlen(peername));
+  char peername[socket::SOCKADDR_STR_LEN];
+  this->helper_->set_client_name(this->helper_->get_peername_to(peername), strlen(peername));
 }
 
 APIConnection::~APIConnection() {
@@ -179,8 +179,8 @@ void APIConnection::begin_iterator_(ActiveIterator type) {
 
 void APIConnection::loop() {
   if (this->flags_.next_close) {
-    // requested a disconnect
-    this->helper_->close();
+    // requested a disconnect - don't close socket here, let APIServer::loop() do it
+    // so getpeername() still works for the disconnect trigger
     this->flags_.remove = true;
     return;
   }
@@ -293,7 +293,8 @@ bool APIConnection::send_disconnect_response_() {
   return this->send_message(resp, DisconnectResponse::MESSAGE_TYPE);
 }
 void APIConnection::on_disconnect_response() {
-  this->helper_->close();
+  // Don't close socket here, let APIServer::loop() do it
+  // so getpeername() still works for the disconnect trigger
   this->flags_.remove = true;
 }
 
@@ -1343,8 +1344,12 @@ void APIConnection::on_water_heater_command_request(const WaterHeaterCommandRequ
     call.set_target_temperature_low(msg.target_temperature_low);
   if (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH)
     call.set_target_temperature_high(msg.target_temperature_high);
-  if (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_STATE) {
+  if ((msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_AWAY_STATE) ||
+      (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_STATE)) {
     call.set_away((msg.state & water_heater::WATER_HEATER_STATE_AWAY) != 0);
+  }
+  if ((msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_ON_STATE) ||
+      (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_STATE)) {
     call.set_on((msg.state & water_heater::WATER_HEATER_STATE_ON) != 0);
   }
   call.perform();
@@ -1465,8 +1470,11 @@ void APIConnection::complete_authentication_() {
   this->flags_.connection_state = static_cast<uint8_t>(ConnectionState::AUTHENTICATED);
   this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("connected"));
 #ifdef USE_API_CLIENT_CONNECTED_TRIGGER
-  this->parent_->get_client_connected_trigger()->trigger(std::string(this->helper_->get_client_name()),
-                                                         std::string(this->helper_->get_client_peername()));
+  {
+    char peername[socket::SOCKADDR_STR_LEN];
+    this->parent_->get_client_connected_trigger()->trigger(std::string(this->helper_->get_client_name()),
+                                                           std::string(this->helper_->get_peername_to(peername)));
+  }
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
   if (homeassistant::global_homeassistant_time != nullptr) {
@@ -1485,8 +1493,9 @@ bool APIConnection::send_hello_response_(const HelloRequest &msg) {
   this->helper_->set_client_name(msg.client_info.c_str(), msg.client_info.size());
   this->client_api_version_major_ = msg.api_version_major;
   this->client_api_version_minor_ = msg.api_version_minor;
+  char peername[socket::SOCKADDR_STR_LEN];
   ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %" PRIu32 ".%" PRIu32, this->helper_->get_client_name(),
-           this->helper_->get_client_peername(), this->client_api_version_major_, this->client_api_version_minor_);
+           this->helper_->get_peername_to(peername), this->client_api_version_major_, this->client_api_version_minor_);
 
   HelloResponse resp;
   resp.api_version_major = 1;
@@ -1834,7 +1843,8 @@ void APIConnection::on_no_setup_connection() {
   this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no connection setup"));
 }
 void APIConnection::on_fatal_error() {
-  this->helper_->close();
+  // Don't close socket here - keep it open so getpeername() works for logging
+  // Socket will be closed when client is removed from the list in APIServer::loop()
   this->flags_.remove = true;
 }
 
@@ -2191,12 +2201,14 @@ void APIConnection::process_state_subscriptions_() {
 #endif  // USE_API_HOMEASSISTANT_STATES
 
 void APIConnection::log_client_(int level, const LogString *message) {
+  char peername[socket::SOCKADDR_STR_LEN];
   esp_log_printf_(level, TAG, __LINE__, ESPHOME_LOG_FORMAT("%s (%s): %s"), this->helper_->get_client_name(),
-                  this->helper_->get_client_peername(), LOG_STR_ARG(message));
+                  this->helper_->get_peername_to(peername), LOG_STR_ARG(message));
 }
 
 void APIConnection::log_warning_(const LogString *message, APIError err) {
-  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->helper_->get_client_name(), this->helper_->get_client_peername(),
+  char peername[socket::SOCKADDR_STR_LEN];
+  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->helper_->get_client_name(), this->helper_->get_peername_to(peername),
            LOG_STR_ARG(message), LOG_STR_ARG(api_error_to_logstr(err)), errno);
 }
 

esphome/components/api/api_connection.h

@@ -276,8 +276,10 @@ class APIConnection final : public APIServerConnectionBase {
   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(); }
+  /// Get peer name (IP address) into caller-provided buffer, returns buf for convenience
+  const char *get_peername_to(std::span<char, socket::SOCKADDR_STR_LEN> buf) const {
+    return this->helper_->get_peername_to(buf);
+  }
 
  protected:
   // Helper function to handle authentication completion

esphome/components/api/api_frame_helper.cpp

@@ -16,7 +16,12 @@ static const char *const TAG = "api.frame_helper";
 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__)
+#define HELPER_LOG(msg, ...) \
+  do { \
+    char peername_buf[socket::SOCKADDR_STR_LEN]; \
+    this->get_peername_to(peername_buf); \
+    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername_buf, ##__VA_ARGS__); \
+  } while (0)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif
@@ -240,13 +245,20 @@ APIError APIFrameHelper::try_send_tx_buf_() {
   return APIError::OK;  // All buffers sent successfully
 }
 
+const char *APIFrameHelper::get_peername_to(std::span<char, socket::SOCKADDR_STR_LEN> buf) const {
+  if (this->socket_) {
+    this->socket_->getpeername_to(buf);
+  } else {
+    buf[0] = '\0';
+  }
+  return buf.data();
+}
+
 APIError APIFrameHelper::init_common_() {
   if (state_ != State::INITIALIZE || this->socket_ == nullptr) {
     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

@@ -90,8 +90,9 @@ class APIFrameHelper {
 
   // 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_; }
+  // Get client peername/IP into caller-provided buffer (fetches on-demand from socket)
+  // Returns pointer to buf for convenience in printf-style calls
+  const char *get_peername_to(std::span<char, socket::SOCKADDR_STR_LEN> buf) const;
   // 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);
@@ -105,6 +106,8 @@ class APIFrameHelper {
   bool can_write_without_blocking() { return this->state_ == State::DATA && this->tx_buf_count_ == 0; }
   int getpeername(struct sockaddr *addr, socklen_t *addrlen) { return socket_->getpeername(addr, addrlen); }
   APIError close() {
+    if (state_ == State::CLOSED)
+      return APIError::OK;  // Already closed
     state_ = State::CLOSED;
     int err = this->socket_->close();
     if (err == -1)
@@ -231,8 +234,6 @@ class APIFrameHelper {
 
   // 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]{};
 
   // Group smaller types together
   uint16_t rx_buf_len_ = 0;

esphome/components/api/api_frame_helper_noise.cpp

@@ -29,7 +29,12 @@ static constexpr size_t PROLOGUE_INIT_LEN = 12;  // strlen("NoiseAPIInit")
 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__)
+#define HELPER_LOG(msg, ...) \
+  do { \
+    char peername_buf[socket::SOCKADDR_STR_LEN]; \
+    this->get_peername_to(peername_buf); \
+    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername_buf, ##__VA_ARGS__); \
+  } while (0)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -21,7 +21,12 @@ static const char *const TAG = "api.plaintext";
 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__)
+#define HELPER_LOG(msg, ...) \
+  do { \
+    char peername_buf[socket::SOCKADDR_STR_LEN]; \
+    this->get_peername_to(peername_buf); \
+    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername_buf, ##__VA_ARGS__); \
+  } while (0)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif

esphome/components/api/api_pb2.h

@@ -147,6 +147,8 @@ enum WaterHeaterCommandHasField : uint32_t {
   WATER_HEATER_COMMAND_HAS_STATE = 4,
   WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW = 8,
   WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH = 16,
+  WATER_HEATER_COMMAND_HAS_ON_STATE = 32,
+  WATER_HEATER_COMMAND_HAS_AWAY_STATE = 64,
 };
 #ifdef USE_NUMBER
 enum NumberMode : uint32_t {

esphome/components/api/api_pb2_dump.cpp

@@ -385,6 +385,10 @@ const char *proto_enum_to_string<enums::WaterHeaterCommandHasField>(enums::Water
       return "WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_LOW";
     case enums::WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH:
       return "WATER_HEATER_COMMAND_HAS_TARGET_TEMPERATURE_HIGH";
+    case enums::WATER_HEATER_COMMAND_HAS_ON_STATE:
+      return "WATER_HEATER_COMMAND_HAS_ON_STATE";
+    case enums::WATER_HEATER_COMMAND_HAS_AWAY_STATE:
+      return "WATER_HEATER_COMMAND_HAS_AWAY_STATE";
     default:
       return "UNKNOWN";
   }

esphome/components/api/api_server.cpp

@@ -192,11 +192,15 @@ void APIServer::loop() {
     ESP_LOGV(TAG, "Remove connection %s", client->get_name());
 
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    // Save client info before removal for the trigger
+    // Save client info before closing socket and removal for the trigger
+    char peername_buf[socket::SOCKADDR_STR_LEN];
     std::string client_name(client->get_name());
-    std::string client_peername(client->get_peername());
+    std::string client_peername(client->get_peername_to(peername_buf));
 #endif
 
+    // Close socket now (was deferred from on_fatal_error to allow getpeername)
+    client->helper_->close();
+
     // Swap with the last element and pop (avoids expensive vector shifts)
     if (client_index < this->clients_.size() - 1) {
       std::swap(this->clients_[client_index], this->clients_.back());

esphome/components/aqi/aqi_calculator.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <cmath>
 #include <limits>
 #include "abstract_aqi_calculator.h"
@@ -14,7 +15,11 @@ class AQICalculator : public AbstractAQICalculator {
     float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
     float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
 
-    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
+    float aqi = std::max(pm2_5_index, pm10_0_index);
+    if (aqi < 0.0f) {
+      aqi = 0.0f;
+    }
+    return static_cast<uint16_t>(std::lround(aqi));
   }
 
  protected:
@@ -22,13 +27,27 @@ class AQICalculator : public AbstractAQICalculator {
 
   static constexpr int INDEX_GRID[NUM_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()}};
+  static constexpr float PM2_5_GRID[NUM_LEVELS][2] = {
+      // clang-format off
+      {0.0f, 9.1f},
+      {9.1f, 35.5f},
+      {35.5f, 55.5f},
+      {55.5f, 125.5f},
+      {125.5f, 225.5f},
+      {225.5f, std::numeric_limits<float>::max()}
+      // clang-format on
+  };
 
-  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()}};
+  static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {
+      // clang-format off
+      {0.0f, 55.0f},
+      {55.0f, 155.0f},
+      {155.0f, 255.0f},
+      {255.0f, 355.0f},
+      {355.0f, 425.0f},
+      {425.0f, std::numeric_limits<float>::max()}
+      // clang-format on
+  };
 
   static float calculate_index(float value, const float array[NUM_LEVELS][2]) {
     int grid_index = get_grid_index(value, array);
@@ -45,7 +64,10 @@ class AQICalculator : public AbstractAQICalculator {
 
   static int get_grid_index(float value, const float array[NUM_LEVELS][2]) {
     for (int i = 0; i < NUM_LEVELS; i++) {
-      if (value >= array[i][0] && value <= array[i][1]) {
+      const bool in_range =
+          (value >= array[i][0]) && ((i == NUM_LEVELS - 1) ? (value <= array[i][1])   // last bucket inclusive
+                                                           : (value < array[i][1]));  // others exclusive on hi
+      if (in_range) {
         return i;
       }
     }

esphome/components/aqi/caqi_calculator.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <cmath>
 #include <limits>
 #include "abstract_aqi_calculator.h"
@@ -12,7 +13,11 @@ class CAQICalculator : public AbstractAQICalculator {
     float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
     float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
 
-    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
+    float aqi = std::max(pm2_5_index, pm10_0_index);
+    if (aqi < 0.0f) {
+      aqi = 0.0f;
+    }
+    return static_cast<uint16_t>(std::lround(aqi));
   }
 
  protected:
@@ -21,10 +26,24 @@ class CAQICalculator : public AbstractAQICalculator {
   static constexpr int INDEX_GRID[NUM_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()}};
+      // clang-format off
+      {0.0f, 15.1f},
+      {15.1f, 30.1f},
+      {30.1f, 55.1f},
+      {55.1f, 110.1f},
+      {110.1f, std::numeric_limits<float>::max()}
+      // clang-format on
+  };
 
   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()}};
+      // clang-format off
+      {0.0f, 25.1f},
+      {25.1f, 50.1f},
+      {50.1f, 90.1f},
+      {90.1f, 180.1f},
+      {180.1f, std::numeric_limits<float>::max()}
+      // clang-format on
+  };
 
   static float calculate_index(float value, const float array[NUM_LEVELS][2]) {
     int grid_index = get_grid_index(value, array);
@@ -42,7 +61,10 @@ class CAQICalculator : public AbstractAQICalculator {
 
   static int get_grid_index(float value, const float array[NUM_LEVELS][2]) {
     for (int i = 0; i < NUM_LEVELS; i++) {
-      if (value >= array[i][0] && value <= array[i][1]) {
+      const bool in_range =
+          (value >= array[i][0]) && ((i == NUM_LEVELS - 1) ? (value <= array[i][1])   // last bucket inclusive
+                                                           : (value < array[i][1]));  // others exclusive on hi
+      if (in_range) {
         return i;
       }
     }

esphome/components/bl0942/bl0942.cpp

@@ -46,16 +46,16 @@ static const uint32_t PKT_TIMEOUT_MS = 200;
 
 void BL0942::loop() {
   DataPacket buffer;
-  int avail = this->available();
+  size_t avail = this->available();
 
   if (!avail) {
     return;
   }
-  if (static_cast<size_t>(avail) < sizeof(buffer)) {
+  if (avail < sizeof(buffer)) {
     if (!this->rx_start_) {
       this->rx_start_ = millis();
     } else if (millis() > this->rx_start_ + PKT_TIMEOUT_MS) {
-      ESP_LOGW(TAG, "Junk on wire. Throwing away partial message (%d bytes)", avail);
+      ESP_LOGW(TAG, "Junk on wire. Throwing away partial message (%zu bytes)", avail);
       this->read_array((uint8_t *) &buffer, avail);
       this->rx_start_ = 0;
     }

esphome/components/cse7766/cse7766.cpp

@@ -16,8 +16,8 @@ void CSE7766Component::loop() {
   }
 
   // Early return prevents updating last_transmission_ when no data is available.
-  int avail = this->available();
-  if (avail <= 0) {
+  size_t avail = this->available();
+  if (avail == 0) {
     return;
   }
 
@@ -27,7 +27,7 @@ void CSE7766Component::loop() {
   // At 4800 baud (~480 bytes/sec) with ~122 Hz loop rate, typically ~4 bytes per call.
   uint8_t buf[CSE7766_RAW_DATA_SIZE];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/dfplayer/dfplayer.cpp

@@ -133,10 +133,10 @@ void DFPlayer::send_cmd_(uint8_t cmd, uint16_t argument) {
 
 void DFPlayer::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/dlms_meter/dlms_meter.cpp

@@ -28,15 +28,28 @@ void DlmsMeterComponent::dump_config() {
 
 void DlmsMeterComponent::loop() {
   // Read while data is available, netznoe uses two frames so allow 2x max frame length
-  while (this->available()) {
-    if (this->receive_buffer_.size() >= MBUS_MAX_FRAME_LENGTH * 2) {
+  size_t avail = this->available();
+  if (avail > 0) {
+    size_t remaining = MBUS_MAX_FRAME_LENGTH * 2 - this->receive_buffer_.size();
+    if (remaining == 0) {
       ESP_LOGW(TAG, "Receive buffer full, dropping remaining bytes");
-      break;
+    } else {
+      // Read all available bytes in batches to reduce UART call overhead.
+      // Cap reads to remaining buffer capacity.
+      if (avail > remaining) {
+        avail = remaining;
+      }
+      uint8_t buf[64];
+      while (avail > 0) {
+        size_t to_read = std::min(avail, sizeof(buf));
+        if (!this->read_array(buf, to_read)) {
+          break;
+        }
+        avail -= to_read;
+        this->receive_buffer_.insert(this->receive_buffer_.end(), buf, buf + to_read);
+        this->last_read_ = millis();
+      }
     }
-    uint8_t c;
-    this->read_byte(&c);
-    this->receive_buffer_.push_back(c);
-    this->last_read_ = millis();
   }
 
   if (!this->receive_buffer_.empty() && millis() - this->last_read_ > this->read_timeout_) {

esphome/components/dsmr/dsmr.cpp

@@ -40,9 +40,7 @@ bool Dsmr::ready_to_request_data_() {
       this->start_requesting_data_();
     }
     if (!this->requesting_data_) {
-      while (this->available()) {
-        this->read();
-      }
+      this->drain_rx_buffer_();
     }
   }
   return this->requesting_data_;
@@ -115,138 +113,169 @@ void Dsmr::stop_requesting_data_() {
     } else {
       ESP_LOGV(TAG, "Stop reading data from P1 port");
     }
-    while (this->available()) {
-      this->read();
-    }
+    this->drain_rx_buffer_();
     this->requesting_data_ = false;
   }
 }
 
+void Dsmr::drain_rx_buffer_() {
+  uint8_t buf[64];
+  size_t avail;
+  while ((avail = this->available()) > 0) {
+    if (!this->read_array(buf, std::min(avail, sizeof(buf)))) {
+      break;
+    }
+  }
+}
+
 void Dsmr::reset_telegram_() {
   this->header_found_ = false;
   this->footer_found_ = false;
   this->bytes_read_ = 0;
   this->crypt_bytes_read_ = 0;
   this->crypt_telegram_len_ = 0;
-  this->last_read_time_ = 0;
 }
 
 void Dsmr::receive_telegram_() {
   while (this->available_within_timeout_()) {
-    const char c = this->read();
+    // Read all available bytes in batches to reduce UART call overhead.
+    uint8_t buf[64];
+    size_t avail = this->available();
+    while (avail > 0) {
+      size_t to_read = std::min(avail, sizeof(buf));
+      if (!this->read_array(buf, to_read))
+        return;
+      avail -= to_read;
 
-    // Find a new telegram header, i.e. forward slash.
-    if (c == '/') {
-      ESP_LOGV(TAG, "Header of telegram found");
-      this->reset_telegram_();
-      this->header_found_ = true;
-    }
-    if (!this->header_found_)
-      continue;
+      for (size_t i = 0; i < to_read; i++) {
+        const char c = static_cast<char>(buf[i]);
 
-    // Check for buffer overflow.
-    if (this->bytes_read_ >= this->max_telegram_len_) {
-      this->reset_telegram_();
-      ESP_LOGE(TAG, "Error: telegram larger than buffer (%d bytes)", this->max_telegram_len_);
-      return;
-    }
+        // Find a new telegram header, i.e. forward slash.
+        if (c == '/') {
+          ESP_LOGV(TAG, "Header of telegram found");
+          this->reset_telegram_();
+          this->header_found_ = true;
+        }
+        if (!this->header_found_)
+          continue;
 
-    // Some v2.2 or v3 meters will send a new value which starts with '('
-    // in a new line, while the value belongs to the previous ObisId. For
-    // proper parsing, remove these new line characters.
-    if (c == '(') {
-      while (true) {
-        auto previous_char = this->telegram_[this->bytes_read_ - 1];
-        if (previous_char == '\n' || previous_char == '\r') {
-          this->bytes_read_--;
-        } else {
-          break;
+        // Check for buffer overflow.
+        if (this->bytes_read_ >= this->max_telegram_len_) {
+          this->reset_telegram_();
+          ESP_LOGE(TAG, "Error: telegram larger than buffer (%d bytes)", this->max_telegram_len_);
+          return;
+        }
+
+        // Some v2.2 or v3 meters will send a new value which starts with '('
+        // in a new line, while the value belongs to the previous ObisId. For
+        // proper parsing, remove these new line characters.
+        if (c == '(') {
+          while (true) {
+            auto previous_char = this->telegram_[this->bytes_read_ - 1];
+            if (previous_char == '\n' || previous_char == '\r') {
+              this->bytes_read_--;
+            } else {
+              break;
+            }
+          }
+        }
+
+        // Store the byte in the buffer.
+        this->telegram_[this->bytes_read_] = c;
+        this->bytes_read_++;
+
+        // Check for a footer, i.e. exclamation mark, followed by a hex checksum.
+        if (c == '!') {
+          ESP_LOGV(TAG, "Footer of telegram found");
+          this->footer_found_ = true;
+          continue;
+        }
+        // Check for the end of the hex checksum, i.e. a newline.
+        if (this->footer_found_ && c == '\n') {
+          // Parse the telegram and publish sensor values.
+          this->parse_telegram();
+          this->reset_telegram_();
+          return;
         }
       }
     }
-
-    // Store the byte in the buffer.
-    this->telegram_[this->bytes_read_] = c;
-    this->bytes_read_++;
-
-    // Check for a footer, i.e. exclamation mark, followed by a hex checksum.
-    if (c == '!') {
-      ESP_LOGV(TAG, "Footer of telegram found");
-      this->footer_found_ = true;
-      continue;
-    }
-    // Check for the end of the hex checksum, i.e. a newline.
-    if (this->footer_found_ && c == '\n') {
-      // Parse the telegram and publish sensor values.
-      this->parse_telegram();
-      this->reset_telegram_();
-      return;
-    }
   }
 }
 
 void Dsmr::receive_encrypted_telegram_() {
   while (this->available_within_timeout_()) {
-    const char c = this->read();
+    // Read all available bytes in batches to reduce UART call overhead.
+    uint8_t buf[64];
+    size_t avail = this->available();
+    while (avail > 0) {
+      size_t to_read = std::min(avail, sizeof(buf));
+      if (!this->read_array(buf, to_read))
+        return;
+      avail -= to_read;
 
-    // Find a new telegram start byte.
-    if (!this->header_found_) {
-      if ((uint8_t) c != 0xDB) {
-        continue;
+      for (size_t i = 0; i < to_read; i++) {
+        const char c = static_cast<char>(buf[i]);
+
+        // Find a new telegram start byte.
+        if (!this->header_found_) {
+          if ((uint8_t) c != 0xDB) {
+            continue;
+          }
+          ESP_LOGV(TAG, "Start byte 0xDB of encrypted telegram found");
+          this->reset_telegram_();
+          this->header_found_ = true;
+        }
+
+        // Check for buffer overflow.
+        if (this->crypt_bytes_read_ >= this->max_telegram_len_) {
+          this->reset_telegram_();
+          ESP_LOGE(TAG, "Error: encrypted telegram larger than buffer (%d bytes)", this->max_telegram_len_);
+          return;
+        }
+
+        // Store the byte in the buffer.
+        this->crypt_telegram_[this->crypt_bytes_read_] = c;
+        this->crypt_bytes_read_++;
+
+        // Read the length of the incoming encrypted telegram.
+        if (this->crypt_telegram_len_ == 0 && this->crypt_bytes_read_ > 20) {
+          // Complete header + data bytes
+          this->crypt_telegram_len_ = 13 + (this->crypt_telegram_[11] << 8 | this->crypt_telegram_[12]);
+          ESP_LOGV(TAG, "Encrypted telegram length: %d bytes", this->crypt_telegram_len_);
+        }
+
+        // Check for the end of the encrypted telegram.
+        if (this->crypt_telegram_len_ == 0 || this->crypt_bytes_read_ != this->crypt_telegram_len_) {
+          continue;
+        }
+        ESP_LOGV(TAG, "End of encrypted telegram found");
+
+        // Decrypt the encrypted telegram.
+        GCM<AES128> *gcmaes128{new GCM<AES128>()};
+        gcmaes128->setKey(this->decryption_key_.data(), gcmaes128->keySize());
+        // the iv is 8 bytes of the system title + 4 bytes frame counter
+        // system title is at byte 2 and frame counter at byte 15
+        for (int i = 10; i < 14; i++)
+          this->crypt_telegram_[i] = this->crypt_telegram_[i + 4];
+        constexpr uint16_t iv_size{12};
+        gcmaes128->setIV(&this->crypt_telegram_[2], iv_size);
+        gcmaes128->decrypt(reinterpret_cast<uint8_t *>(this->telegram_),
+                           // the ciphertext start at byte 18
+                           &this->crypt_telegram_[18],
+                           // cipher size
+                           this->crypt_bytes_read_ - 17);
+        delete gcmaes128;  // NOLINT(cppcoreguidelines-owning-memory)
+
+        this->bytes_read_ = strnlen(this->telegram_, this->max_telegram_len_);
+        ESP_LOGV(TAG, "Decrypted telegram size: %d bytes", this->bytes_read_);
+        ESP_LOGVV(TAG, "Decrypted telegram: %s", this->telegram_);
+
+        // Parse the decrypted telegram and publish sensor values.
+        this->parse_telegram();
+        this->reset_telegram_();
+        return;
       }
-      ESP_LOGV(TAG, "Start byte 0xDB of encrypted telegram found");
-      this->reset_telegram_();
-      this->header_found_ = true;
     }
-
-    // Check for buffer overflow.
-    if (this->crypt_bytes_read_ >= this->max_telegram_len_) {
-      this->reset_telegram_();
-      ESP_LOGE(TAG, "Error: encrypted telegram larger than buffer (%d bytes)", this->max_telegram_len_);
-      return;
-    }
-
-    // Store the byte in the buffer.
-    this->crypt_telegram_[this->crypt_bytes_read_] = c;
-    this->crypt_bytes_read_++;
-
-    // Read the length of the incoming encrypted telegram.
-    if (this->crypt_telegram_len_ == 0 && this->crypt_bytes_read_ > 20) {
-      // Complete header + data bytes
-      this->crypt_telegram_len_ = 13 + (this->crypt_telegram_[11] << 8 | this->crypt_telegram_[12]);
-      ESP_LOGV(TAG, "Encrypted telegram length: %d bytes", this->crypt_telegram_len_);
-    }
-
-    // Check for the end of the encrypted telegram.
-    if (this->crypt_telegram_len_ == 0 || this->crypt_bytes_read_ != this->crypt_telegram_len_) {
-      continue;
-    }
-    ESP_LOGV(TAG, "End of encrypted telegram found");
-
-    // Decrypt the encrypted telegram.
-    GCM<AES128> *gcmaes128{new GCM<AES128>()};
-    gcmaes128->setKey(this->decryption_key_.data(), gcmaes128->keySize());
-    // the iv is 8 bytes of the system title + 4 bytes frame counter
-    // system title is at byte 2 and frame counter at byte 15
-    for (int i = 10; i < 14; i++)
-      this->crypt_telegram_[i] = this->crypt_telegram_[i + 4];
-    constexpr uint16_t iv_size{12};
-    gcmaes128->setIV(&this->crypt_telegram_[2], iv_size);
-    gcmaes128->decrypt(reinterpret_cast<uint8_t *>(this->telegram_),
-                       // the ciphertext start at byte 18
-                       &this->crypt_telegram_[18],
-                       // cipher size
-                       this->crypt_bytes_read_ - 17);
-    delete gcmaes128;  // NOLINT(cppcoreguidelines-owning-memory)
-
-    this->bytes_read_ = strnlen(this->telegram_, this->max_telegram_len_);
-    ESP_LOGV(TAG, "Decrypted telegram size: %d bytes", this->bytes_read_);
-    ESP_LOGVV(TAG, "Decrypted telegram: %s", this->telegram_);
-
-    // Parse the decrypted telegram and publish sensor values.
-    this->parse_telegram();
-    this->reset_telegram_();
-    return;
   }
 }
 

esphome/components/dsmr/dsmr.h

@@ -85,6 +85,7 @@ class Dsmr : public Component, public uart::UARTDevice {
   void receive_telegram_();
   void receive_encrypted_telegram_();
   void reset_telegram_();
+  void drain_rx_buffer_();
 
   /// Wait for UART data to become available within the read timeout.
   ///

esphome/components/esp32/__init__.py

@@ -135,6 +135,7 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "esp_driver_dac",  # DAC driver - only needed by esp32_dac component
     "esp_driver_i2s",  # I2S driver - only needed by i2s_audio component
     "esp_driver_mcpwm",  # MCPWM driver - ESPHome doesn't use motor control PWM
+    "esp_driver_pcnt",  # PCNT driver - only needed by pulse_counter, hlw8012 components
     "esp_driver_rmt",  # RMT driver - only needed by remote_transmitter/receiver, neopixelbus
     "esp_driver_touch_sens",  # Touch sensor driver - only needed by esp32_touch
     "esp_driver_twai",  # TWAI/CAN driver - only needed by esp32_can component

esphome/components/esp32_hosted/__init__.py

@@ -95,9 +95,9 @@ async def to_code(config):
     framework_ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
     os.environ["ESP_IDF_VERSION"] = f"{framework_ver.major}.{framework_ver.minor}"
     if framework_ver >= cv.Version(5, 5, 0):
-        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.2.4")
+        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.3.2")
         esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.4")
-        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.9.3")
+        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.11.5")
     else:
         esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="0.13.0")
         esp32.add_idf_component(name="espressif/eppp_link", ref="0.2.0")

esphome/components/esp32_rmt_led_strip/led_strip.cpp

@@ -7,22 +7,25 @@
 #include "esphome/core/log.h"
 
 #include <esp_attr.h>
+#include <esp_clk_tree.h>
 
 namespace esphome {
 namespace esp32_rmt_led_strip {
 
 static const char *const TAG = "esp32_rmt_led_strip";
 
-#ifdef USE_ESP32_VARIANT_ESP32H2
-static const uint32_t RMT_CLK_FREQ = 32000000;
-static const uint8_t RMT_CLK_DIV = 1;
-#else
-static const uint32_t RMT_CLK_FREQ = 80000000;
-static const uint8_t RMT_CLK_DIV = 2;
-#endif
-
 static const size_t RMT_SYMBOLS_PER_BYTE = 8;
 
+// Query the RMT default clock source frequency. This varies by variant:
+// APB (80MHz) on ESP32/S2/S3/C3, PLL_F80M (80MHz) on C6/P4, XTAL (32MHz) on H2.
+// Worst-case reset time is WS2811 at 300µs = 24000 ticks at 80MHz, well within
+// the 15-bit rmt_symbol_word_t duration field max of 32767.
+static uint32_t rmt_resolution_hz() {
+  uint32_t freq;
+  esp_clk_tree_src_get_freq_hz((soc_module_clk_t) RMT_CLK_SRC_DEFAULT, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &freq);
+  return freq;
+}
+
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
 static size_t IRAM_ATTR HOT encoder_callback(const void *data, size_t size, size_t symbols_written, size_t symbols_free,
                                              rmt_symbol_word_t *symbols, bool *done, void *arg) {
@@ -92,7 +95,7 @@ void ESP32RMTLEDStripLightOutput::setup() {
   rmt_tx_channel_config_t channel;
   memset(&channel, 0, sizeof(channel));
   channel.clk_src = RMT_CLK_SRC_DEFAULT;
-  channel.resolution_hz = RMT_CLK_FREQ / RMT_CLK_DIV;
+  channel.resolution_hz = rmt_resolution_hz();
   channel.gpio_num = gpio_num_t(this->pin_);
   channel.mem_block_symbols = this->rmt_symbols_;
   channel.trans_queue_depth = 1;
@@ -137,7 +140,7 @@ void ESP32RMTLEDStripLightOutput::setup() {
 
 void ESP32RMTLEDStripLightOutput::set_led_params(uint32_t bit0_high, uint32_t bit0_low, uint32_t bit1_high,
                                                  uint32_t bit1_low, uint32_t reset_time_high, uint32_t reset_time_low) {
-  float ratio = (float) RMT_CLK_FREQ / RMT_CLK_DIV / 1e09f;
+  float ratio = (float) rmt_resolution_hz() / 1e09f;
 
   // 0-bit
   this->params_.bit0.duration0 = (uint32_t) (ratio * bit0_high);

esphome/components/hlk_fm22x/hlk_fm22x.cpp

@@ -1,20 +1,16 @@
 #include "hlk_fm22x.h"
 #include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
-#include <array>
 #include <cinttypes>
 
 namespace esphome::hlk_fm22x {
 
 static const char *const TAG = "hlk_fm22x";
 
-// Maximum response size is 36 bytes (VERIFY reply: face_id + 32-byte name)
-static constexpr size_t HLK_FM22X_MAX_RESPONSE_SIZE = 36;
-
 void HlkFm22xComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up HLK-FM22X...");
   this->set_enrolling_(false);
-  while (this->available()) {
+  while (this->available() > 0) {
     this->read();
   }
   this->defer([this]() { this->send_command_(HlkFm22xCommand::GET_STATUS); });
@@ -35,7 +31,7 @@ void HlkFm22xComponent::update() {
 }
 
 void HlkFm22xComponent::enroll_face(const std::string &name, HlkFm22xFaceDirection direction) {
-  if (name.length() > 31) {
+  if (name.length() > HLK_FM22X_NAME_SIZE - 1) {
     ESP_LOGE(TAG, "enroll_face(): name too long '%s'", name.c_str());
     return;
   }
@@ -88,7 +84,7 @@ void HlkFm22xComponent::send_command_(HlkFm22xCommand command, const uint8_t *da
   }
   this->wait_cycles_ = 0;
   this->active_command_ = command;
-  while (this->available())
+  while (this->available() > 0)
     this->read();
   this->write((uint8_t) (START_CODE >> 8));
   this->write((uint8_t) (START_CODE & 0xFF));
@@ -137,17 +133,24 @@ void HlkFm22xComponent::recv_command_() {
   checksum ^= byte;
   length |= byte;
 
-  std::vector<uint8_t> data;
-  data.reserve(length);
+  if (length > HLK_FM22X_MAX_RESPONSE_SIZE) {
+    ESP_LOGE(TAG, "Response too large: %u bytes", length);
+    // Discard exactly the remaining payload and checksum for this frame
+    for (uint16_t i = 0; i < length + 1 && this->available() > 0; ++i)
+      this->read();
+    return;
+  }
+
   for (uint16_t idx = 0; idx < length; ++idx) {
     byte = this->read();
     checksum ^= byte;
-    data.push_back(byte);
+    this->recv_buf_[idx] = byte;
   }
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   char hex_buf[format_hex_pretty_size(HLK_FM22X_MAX_RESPONSE_SIZE)];
-  ESP_LOGV(TAG, "Recv type: 0x%.2X, data: %s", response_type, format_hex_pretty_to(hex_buf, data.data(), data.size()));
+  ESP_LOGV(TAG, "Recv type: 0x%.2X, data: %s", response_type,
+           format_hex_pretty_to(hex_buf, this->recv_buf_.data(), length));
 #endif
 
   byte = this->read();
@@ -157,10 +160,10 @@ void HlkFm22xComponent::recv_command_() {
   }
   switch (response_type) {
     case HlkFm22xResponseType::NOTE:
-      this->handle_note_(data);
+      this->handle_note_(this->recv_buf_.data(), length);
       break;
     case HlkFm22xResponseType::REPLY:
-      this->handle_reply_(data);
+      this->handle_reply_(this->recv_buf_.data(), length);
       break;
     default:
       ESP_LOGW(TAG, "Unexpected response type: 0x%.2X", response_type);
@@ -168,11 +171,15 @@ void HlkFm22xComponent::recv_command_() {
   }
 }
 
-void HlkFm22xComponent::handle_note_(const std::vector<uint8_t> &data) {
+void HlkFm22xComponent::handle_note_(const uint8_t *data, size_t length) {
+  if (length < 1) {
+    ESP_LOGE(TAG, "Empty note data");
+    return;
+  }
   switch (data[0]) {
     case HlkFm22xNoteType::FACE_STATE:
-      if (data.size() < 17) {
-        ESP_LOGE(TAG, "Invalid face note data size: %u", data.size());
+      if (length < 17) {
+        ESP_LOGE(TAG, "Invalid face note data size: %zu", length);
         break;
       }
       {
@@ -209,9 +216,13 @@ void HlkFm22xComponent::handle_note_(const std::vector<uint8_t> &data) {
   }
 }
 
-void HlkFm22xComponent::handle_reply_(const std::vector<uint8_t> &data) {
+void HlkFm22xComponent::handle_reply_(const uint8_t *data, size_t length) {
   auto expected = this->active_command_;
   this->active_command_ = HlkFm22xCommand::NONE;
+  if (length < 2) {
+    ESP_LOGE(TAG, "Reply too short: %zu bytes", length);
+    return;
+  }
   if (data[0] != (uint8_t) expected) {
     ESP_LOGE(TAG, "Unexpected response command. Expected: 0x%.2X, Received: 0x%.2X", expected, data[0]);
     return;
@@ -238,16 +249,20 @@ void HlkFm22xComponent::handle_reply_(const std::vector<uint8_t> &data) {
   }
   switch (expected) {
     case HlkFm22xCommand::VERIFY: {
+      if (length < 4 + HLK_FM22X_NAME_SIZE) {
+        ESP_LOGE(TAG, "VERIFY response too short: %zu bytes", length);
+        break;
+      }
       int16_t face_id = ((int16_t) data[2] << 8) | data[3];
-      std::string name(data.begin() + 4, data.begin() + 36);
-      ESP_LOGD(TAG, "Face verified. ID: %d, name: %s", face_id, name.c_str());
+      const char *name_ptr = reinterpret_cast<const char *>(data + 4);
+      ESP_LOGD(TAG, "Face verified. ID: %d, name: %.*s", face_id, (int) HLK_FM22X_NAME_SIZE, name_ptr);
       if (this->last_face_id_sensor_ != nullptr) {
         this->last_face_id_sensor_->publish_state(face_id);
       }
       if (this->last_face_name_text_sensor_ != nullptr) {
-        this->last_face_name_text_sensor_->publish_state(name);
+        this->last_face_name_text_sensor_->publish_state(name_ptr, HLK_FM22X_NAME_SIZE);
       }
-      this->face_scan_matched_callback_.call(face_id, name);
+      this->face_scan_matched_callback_.call(face_id, std::string(name_ptr, HLK_FM22X_NAME_SIZE));
       break;
     }
     case HlkFm22xCommand::ENROLL: {
@@ -266,9 +281,8 @@ void HlkFm22xComponent::handle_reply_(const std::vector<uint8_t> &data) {
       this->defer([this]() { this->send_command_(HlkFm22xCommand::GET_VERSION); });
       break;
     case HlkFm22xCommand::GET_VERSION:
-      if (this->version_text_sensor_ != nullptr) {
-        std::string version(data.begin() + 2, data.end());
-        this->version_text_sensor_->publish_state(version);
+      if (this->version_text_sensor_ != nullptr && length > 2) {
+        this->version_text_sensor_->publish_state(reinterpret_cast<const char *>(data + 2), length - 2);
       }
       this->defer([this]() { this->get_face_count_(); });
       break;

esphome/components/hlk_fm22x/hlk_fm22x.h

@@ -7,12 +7,15 @@
 #include "esphome/components/text_sensor/text_sensor.h"
 #include "esphome/components/uart/uart.h"
 
+#include <array>
 #include <utility>
-#include <vector>
 
 namespace esphome::hlk_fm22x {
 
 static const uint16_t START_CODE = 0xEFAA;
+static constexpr size_t HLK_FM22X_NAME_SIZE = 32;
+// Maximum response payload: command(1) + result(1) + face_id(2) + name(32) = 36
+static constexpr size_t HLK_FM22X_MAX_RESPONSE_SIZE = 36;
 enum HlkFm22xCommand {
   NONE = 0x00,
   RESET = 0x10,
@@ -118,10 +121,11 @@ class HlkFm22xComponent : public PollingComponent, public uart::UARTDevice {
   void get_face_count_();
   void send_command_(HlkFm22xCommand command, const uint8_t *data = nullptr, size_t size = 0);
   void recv_command_();
-  void handle_note_(const std::vector<uint8_t> &data);
-  void handle_reply_(const std::vector<uint8_t> &data);
+  void handle_note_(const uint8_t *data, size_t length);
+  void handle_reply_(const uint8_t *data, size_t length);
   void set_enrolling_(bool enrolling);
 
+  std::array<uint8_t, HLK_FM22X_MAX_RESPONSE_SIZE> recv_buf_;
   HlkFm22xCommand active_command_ = HlkFm22xCommand::NONE;
   uint16_t wait_cycles_ = 0;
   sensor::Sensor *face_count_sensor_{nullptr};

esphome/components/hlw8012/sensor.py

@@ -94,10 +94,7 @@ CONFIG_SCHEMA = cv.Schema(
 
 async def to_code(config):
     if CORE.is_esp32:
-        # Re-enable ESP-IDF's legacy driver component (excluded by default to save compile time)
-        # HLW8012 uses pulse_counter's PCNT storage which requires driver/pcnt.h
-        # TODO: Remove this once pulse_counter migrates to new PCNT API (driver/pulse_cnt.h)
-        include_builtin_idf_component("driver")
+        include_builtin_idf_component("esp_driver_pcnt")
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/http_request/http_request.h

@@ -103,6 +103,42 @@ inline bool is_success(int const status) { return status >= HTTP_STATUS_OK && st
  *   - ESP-IDF: blocking reads, 0 only returned when all content read
  *   - Arduino: non-blocking, 0 means "no data yet" or "all content read"
  *
+ * Chunked responses that complete in a reasonable time work correctly on both
+ * platforms. The limitation below applies only to *streaming* chunked
+ * responses where data arrives slowly over a long period.
+ *
+ * Streaming chunked responses are NOT supported (all platforms):
+ *   The read helpers (http_read_loop_result, http_read_fully) block the main
+ *   event loop until all response data is received. For streaming responses
+ *   where data trickles in slowly (e.g., TTS streaming via ffmpeg proxy),
+ *   this starves the event loop on both ESP-IDF and Arduino. If data arrives
+ *   just often enough to avoid the caller's timeout, the loop runs
+ *   indefinitely. If data stops entirely, ESP-IDF fails with
+ *   -ESP_ERR_HTTP_EAGAIN (transport timeout) while Arduino spins with
+ *   delay(1) until the caller's timeout fires. Supporting streaming requires
+ *   a non-blocking incremental read pattern that yields back to the event
+ *   loop between chunks. Components that need streaming should use
+ *   esp_http_client directly on a separate FreeRTOS task with
+ *   esp_http_client_is_complete_data_received() for completion detection
+ *   (see audio_reader.cpp for an example).
+ *
+ * Chunked transfer encoding - platform differences:
+ *   - ESP-IDF HttpContainer:
+ *       HttpContainerIDF overrides is_read_complete() to call
+ *       esp_http_client_is_complete_data_received(), which is the
+ *       authoritative completion check for both chunked and non-chunked
+ *       transfers. When esp_http_client_read() returns 0 for a completed
+ *       chunked response, read() returns 0 and is_read_complete() returns
+ *       true, so callers get COMPLETE from http_read_loop_result().
+ *
+ *   - Arduino HttpContainer:
+ *       Chunked responses are decoded internally (see
+ *       HttpContainerArduino::read_chunked_()). When the final chunk arrives,
+ *       is_chunked_ is cleared and content_length is set to bytes_read_.
+ *       Completion is then detected via is_read_complete(), and a subsequent
+ *       read() returns 0 to indicate "all content read" (not
+ *       HTTP_ERROR_CONNECTION_CLOSED).
+ *
  * Use the helper functions below instead of checking return values directly:
  *   - http_read_loop_result(): for manual loops with per-chunk processing
  *   - http_read_fully(): for simple "read N bytes into buffer" operations
@@ -204,9 +240,13 @@ class HttpContainer : public Parented<HttpRequestComponent> {
 
   size_t get_bytes_read() const { return this->bytes_read_; }
 
-  /// Check if all expected content has been read
-  /// For chunked responses, returns false (completion detected via read() returning error/EOF)
-  bool is_read_complete() const {
+  /// Check if all expected content has been read.
+  /// Base implementation handles non-chunked responses and status-code-based no-body checks.
+  /// Platform implementations may override for chunked completion detection:
+  ///   - ESP-IDF: overrides to call esp_http_client_is_complete_data_received() for chunked.
+  ///   - Arduino: read_chunked_() clears is_chunked_ and sets content_length on the final
+  ///     chunk, after which the base implementation detects completion.
+  virtual bool is_read_complete() const {
     // Per RFC 9112, these responses have no body:
     // - 1xx (Informational), 204 No Content, 205 Reset Content, 304 Not Modified
     if ((this->status_code >= 100 && this->status_code < 200) || this->status_code == HTTP_STATUS_NO_CONTENT ||

esphome/components/http_request/http_request_idf.cpp

@@ -218,32 +218,50 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
   return container;
 }
 
+bool HttpContainerIDF::is_read_complete() const {
+  // Base class handles no-body status codes and non-chunked content_length completion
+  if (HttpContainer::is_read_complete()) {
+    return true;
+  }
+  // For chunked responses, use the authoritative ESP-IDF completion check
+  return this->is_chunked_ && esp_http_client_is_complete_data_received(this->client_);
+}
+
 // ESP-IDF HTTP read implementation (blocking mode)
 //
 // WARNING: Return values differ from BSD sockets! See http_request.h for full documentation.
 //
 // esp_http_client_read() in blocking mode returns:
 //   > 0: bytes read
-//   0: connection closed (end of stream)
+//   0: all chunked data received (is_chunk_complete true) or connection closed
+//   -ESP_ERR_HTTP_EAGAIN: transport timeout, no data available yet
 //   < 0: error
 //
 // We normalize to HttpContainer::read() contract:
 //   > 0: bytes read
-//   0: all content read (only returned when content_length is known and fully read)
+//   0: all content read (for both content_length-based and chunked completion)
 //   < 0: error/connection closed
 //
 // Note on chunked transfer encoding:
 //   esp_http_client_fetch_headers() returns 0 for chunked responses (no Content-Length header).
-//   We handle this by skipping the content_length check when content_length is 0,
-//   allowing esp_http_client_read() to handle chunked decoding internally and signal EOF
-//   by returning 0.
+//   When esp_http_client_read() returns 0 for a chunked response, is_read_complete() calls
+//   esp_http_client_is_complete_data_received() to distinguish successful completion from
+//   connection errors. Callers use http_read_loop_result() which checks is_read_complete()
+//   to return COMPLETE for successful chunked EOF.
+//
+// Streaming chunked responses are not supported (see http_request.h for details).
+// When data stops arriving, esp_http_client_read() returns -ESP_ERR_HTTP_EAGAIN
+// after its internal transport timeout (configured via timeout_ms) expires.
+// This is passed through as a negative return value, which callers treat as an error.
 int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
   const uint32_t start = millis();
   watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
 
-  // Check if we've already read all expected content (non-chunked only)
-  // For chunked responses (content_length == 0), esp_http_client_read() handles EOF
-  if (this->is_read_complete()) {
+  // Check if we've already read all expected content (non-chunked and no-body only).
+  // Use the base class check here, NOT the override: esp_http_client_is_complete_data_received()
+  // returns true as soon as all data arrives from the network, but data may still be in
+  // the client's internal buffer waiting to be consumed by esp_http_client_read().
+  if (HttpContainer::is_read_complete()) {
     return 0;  // All content read successfully
   }
 
@@ -258,15 +276,18 @@ int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
     return read_len_or_error;
   }
 
-  // esp_http_client_read() returns 0 in two cases:
-  // 1. Known content_length: connection closed before all data received (error)
-  // 2. Chunked encoding (content_length == 0): end of stream reached (EOF)
-  // For case 1, returning HTTP_ERROR_CONNECTION_CLOSED is correct.
-  // For case 2, 0 indicates that all chunked data has already been delivered
-  // in previous successful read() calls, so treating this as a closed
-  // connection does not cause any loss of response data.
+  // esp_http_client_read() returns 0 when:
+  // - Known content_length: connection closed before all data received (error)
+  // - Chunked encoding: all chunks received (is_chunk_complete true, genuine EOF)
+  //
+  // Return 0 in both cases. Callers use http_read_loop_result() which calls
+  // is_read_complete() to distinguish these:
+  // - Chunked complete: is_read_complete() returns true (via
+  //   esp_http_client_is_complete_data_received()), caller gets COMPLETE
+  // - Non-chunked incomplete: is_read_complete() returns false, caller
+  //   eventually gets TIMEOUT (since no more data arrives)
   if (read_len_or_error == 0) {
-    return HTTP_ERROR_CONNECTION_CLOSED;
+    return 0;
   }
 
   // Negative value - error, return the actual error code for debugging

esphome/components/http_request/http_request_idf.h

@@ -16,6 +16,7 @@ class HttpContainerIDF : public HttpContainer {
   HttpContainerIDF(esp_http_client_handle_t client) : client_(client) {}
   int read(uint8_t *buf, size_t max_len) override;
   void end() override;
+  bool is_read_complete() const override;
 
   /// @brief Feeds the watchdog timer if the executing task has one attached
   void feed_wdt();

esphome/components/ld2410/ld2410.cpp

@@ -276,10 +276,10 @@ void LD2410Component::restart_and_read_all_info() {
 
 void LD2410Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/ld2412/ld2412.cpp

@@ -311,10 +311,10 @@ void LD2412Component::restart_and_read_all_info() {
 
 void LD2412Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/ld2420/ld2420.cpp

@@ -335,9 +335,10 @@ void LD2420Component::revert_config_action() {
 
 void LD2420Component::loop() {
   // If there is a active send command do not process it here, the send command call will handle it.
-  while (!this->cmd_active_ && this->available()) {
-    this->readline_(this->read(), this->buffer_data_, MAX_LINE_LENGTH);
+  if (this->cmd_active_) {
+    return;
   }
+  this->read_batch_(this->buffer_data_);
 }
 
 void LD2420Component::update_radar_data(uint16_t const *gate_energy, uint8_t sample_number) {
@@ -539,6 +540,23 @@ void LD2420Component::handle_simple_mode_(const uint8_t *inbuf, int len) {
   }
 }
 
+void LD2420Component::read_batch_(std::span<uint8_t, MAX_LINE_LENGTH> buffer) {
+  // Read all available bytes in batches to reduce UART call overhead.
+  size_t avail = this->available();
+  uint8_t buf[MAX_LINE_LENGTH];
+  while (avail > 0) {
+    size_t to_read = std::min(avail, sizeof(buf));
+    if (!this->read_array(buf, to_read)) {
+      break;
+    }
+    avail -= to_read;
+
+    for (size_t i = 0; i < to_read; i++) {
+      this->readline_(buf[i], buffer.data(), buffer.size());
+    }
+  }
+}
+
 void LD2420Component::handle_ack_data_(uint8_t *buffer, int len) {
   this->cmd_reply_.command = buffer[CMD_FRAME_COMMAND];
   this->cmd_reply_.length = buffer[CMD_FRAME_DATA_LENGTH];

esphome/components/ld2420/ld2420.h

@@ -4,6 +4,7 @@
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/helpers.h"
+#include <span>
 #ifdef USE_TEXT_SENSOR
 #include "esphome/components/text_sensor/text_sensor.h"
 #endif
@@ -165,6 +166,7 @@ class LD2420Component : public Component, public uart::UARTDevice {
   void handle_energy_mode_(uint8_t *buffer, int len);
   void handle_ack_data_(uint8_t *buffer, int len);
   void readline_(int rx_data, uint8_t *buffer, int len);
+  void read_batch_(std::span<uint8_t, MAX_LINE_LENGTH> buffer);
   void set_calibration_(bool state) { this->calibration_ = state; };
   bool get_calibration_() { return this->calibration_; };
 

esphome/components/ld2450/__init__.py

@@ -1,7 +1,8 @@
+from esphome import automation
 import esphome.codegen as cg
 from esphome.components import uart
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_THROTTLE
+from esphome.const import CONF_ID, CONF_ON_DATA, CONF_THROTTLE, CONF_TRIGGER_ID
 
 AUTO_LOAD = ["ld24xx"]
 DEPENDENCIES = ["uart"]
@@ -11,6 +12,8 @@ MULTI_CONF = True
 ld2450_ns = cg.esphome_ns.namespace("ld2450")
 LD2450Component = ld2450_ns.class_("LD2450Component", cg.Component, uart.UARTDevice)
 
+LD2450DataTrigger = ld2450_ns.class_("LD2450DataTrigger", automation.Trigger.template())
+
 CONF_LD2450_ID = "ld2450_id"
 
 CONFIG_SCHEMA = cv.All(
@@ -20,6 +23,11 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_THROTTLE): cv.invalid(
                 f"{CONF_THROTTLE} has been removed; use per-sensor filters, instead"
             ),
+            cv.Optional(CONF_ON_DATA): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LD2450DataTrigger),
+                }
+            ),
         }
     )
     .extend(uart.UART_DEVICE_SCHEMA)
@@ -45,3 +53,6 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await uart.register_uart_device(var, config)
+    for conf in config.get(CONF_ON_DATA, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)

esphome/components/ld2450/ld2450.cpp

@@ -277,10 +277,10 @@ void LD2450Component::dump_config() {
 
 void LD2450Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }
@@ -413,6 +413,10 @@ void LD2450Component::restart_and_read_all_info() {
   this->set_timeout(1500, [this]() { this->read_all_info(); });
 }
 
+void LD2450Component::add_on_data_callback(std::function<void()> &&callback) {
+  this->data_callback_.add(std::move(callback));
+}
+
 // Send command with values to LD2450
 void LD2450Component::send_command_(uint8_t command, const uint8_t *command_value, uint8_t command_value_len) {
   ESP_LOGV(TAG, "Sending COMMAND %02X", command);
@@ -613,6 +617,8 @@ void LD2450Component::handle_periodic_data_() {
     this->still_presence_millis_ = App.get_loop_component_start_time();
   }
 #endif
+
+  this->data_callback_.call();
 }
 
 bool LD2450Component::handle_ack_data_() {

esphome/components/ld2450/ld2450.h

@@ -141,6 +141,9 @@ class LD2450Component : public Component, public uart::UARTDevice {
                       int32_t zone2_x1, int32_t zone2_y1, int32_t zone2_x2, int32_t zone2_y2, int32_t zone3_x1,
                       int32_t zone3_y1, int32_t zone3_x2, int32_t zone3_y2);
 
+  /// Add a callback that will be called after each successfully processed periodic data frame.
+  void add_on_data_callback(std::function<void()> &&callback);
+
  protected:
   void send_command_(uint8_t command_str, const uint8_t *command_value, uint8_t command_value_len);
   void set_config_mode_(bool enable);
@@ -190,6 +193,15 @@ class LD2450Component : public Component, public uart::UARTDevice {
 #ifdef USE_TEXT_SENSOR
   std::array<text_sensor::TextSensor *, 3> direction_text_sensors_{};
 #endif
+
+  LazyCallbackManager<void()> data_callback_;
+};
+
+class LD2450DataTrigger : public Trigger<> {
+ public:
+  explicit LD2450DataTrigger(LD2450Component *parent) {
+    parent->add_on_data_callback([this]() { this->trigger(); });
+  }
 };
 
 }  // namespace esphome::ld2450

esphome/components/logger/logger.cpp

@@ -36,8 +36,9 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
 #endif
 
   // Fast path: main thread, no recursion (99.9% of all logs)
+  // Pass nullptr for thread_name since we already know this is the main task
   if (is_main_task && !this->main_task_recursion_guard_) [[likely]] {
-    this->log_message_to_buffer_and_send_(this->main_task_recursion_guard_, level, tag, line, format, args);
+    this->log_message_to_buffer_and_send_(this->main_task_recursion_guard_, level, tag, line, format, args, nullptr);
     return;
   }
 
@@ -47,21 +48,23 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
   }
 
   // Non-main thread handling (~0.1% of logs)
+  // Resolve thread name once and pass it through the logging chain.
+  // ESP32/LibreTiny: use TaskHandle_t overload to avoid redundant xTaskGetCurrentTaskHandle()
+  // (we already have the handle from the main task check above).
+  // Host: pass a stack buffer for pthread_getname_np to write into.
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
-  this->log_vprintf_non_main_thread_(level, tag, line, format, args, current_task);
+  const char *thread_name = get_thread_name_(current_task);
 #else  // USE_HOST
-  this->log_vprintf_non_main_thread_(level, tag, line, format, args);
+  char thread_name_buf[THREAD_NAME_BUF_SIZE];
+  const char *thread_name = this->get_thread_name_(thread_name_buf);
 #endif
+  this->log_vprintf_non_main_thread_(level, tag, line, format, args, thread_name);
 }
 
 // Handles non-main thread logging only
 // Kept separate from hot path to improve instruction cache performance
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
 void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args,
-                                          TaskHandle_t current_task) {
-#else  // USE_HOST
-void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args) {
-#endif
+                                          const char *thread_name) {
   // Check if already in recursion for this non-main thread/task
   if (this->is_non_main_task_recursive_()) {
     return;
@@ -73,12 +76,8 @@ void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int li
   bool message_sent = false;
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   // For non-main threads/tasks, queue the message for callbacks
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
   message_sent =
-      this->log_buffer_->send_message_thread_safe(level, tag, static_cast<uint16_t>(line), current_task, format, args);
-#else  // USE_HOST
-  message_sent = this->log_buffer_->send_message_thread_safe(level, tag, static_cast<uint16_t>(line), format, args);
-#endif
+      this->log_buffer_->send_message_thread_safe(level, tag, static_cast<uint16_t>(line), thread_name, format, args);
   if (message_sent) {
     // Enable logger loop to process the buffered message
     // This is safe to call from any context including ISRs
@@ -101,19 +100,27 @@ void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int li
 #endif
     char console_buffer[MAX_CONSOLE_LOG_MSG_SIZE];  // MUST be stack allocated for thread safety
     LogBuffer buf{console_buffer, MAX_CONSOLE_LOG_MSG_SIZE};
-    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
+    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf, thread_name);
     this->write_to_console_(buf);
   }
 
   // RAII guard automatically resets on return
 }
 #else
-// Implementation for all other platforms (single-task, no threading)
+// Implementation for single-task platforms (ESP8266, RP2040, Zephyr)
+// TODO: Zephyr may have multiple threads (work queues, etc.) but uses this single-task path.
+// Logging calls are NOT thread-safe: global_recursion_guard_ is a plain bool and tx_buffer_ has no locking.
+// Not a problem in practice yet since Zephyr has no API support (logs are console-only).
 void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
-
-  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
+#ifdef USE_ZEPHYR
+  char tmp[MAX_POINTER_REPRESENTATION];
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args,
+                                        this->get_thread_name_(tmp));
+#else  // Other single-task platforms don't have thread names, so pass nullptr
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args, nullptr);
+#endif
 }
 #endif  // USE_ESP32 / USE_HOST / USE_LIBRETINY
 
@@ -129,7 +136,7 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args, nullptr);
 }
 #endif  // USE_STORE_LOG_STR_IN_FLASH
 

esphome/components/logger/logger.h

@@ -2,6 +2,7 @@
 
 #include <cstdarg>
 #include <map>
+#include <span>
 #include <type_traits>
 #if defined(USE_ESP32) || defined(USE_HOST)
 #include <pthread.h>
@@ -124,6 +125,10 @@ static constexpr uint16_t MAX_HEADER_SIZE = 128;
 // "0x" + 2 hex digits per byte + '\0'
 static constexpr size_t MAX_POINTER_REPRESENTATION = 2 + sizeof(void *) * 2 + 1;
 
+// Stack buffer size for retrieving thread/task names from the OS
+// macOS allows up to 64 bytes, Linux up to 16
+static constexpr size_t THREAD_NAME_BUF_SIZE = 64;
+
 // Buffer wrapper for log formatting functions
 struct LogBuffer {
   char *data;
@@ -408,34 +413,24 @@ class Logger : public Component {
 
 #if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY)
   // Handles non-main thread logging only (~0.1% of calls)
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-  // ESP32/LibreTiny: Pass task handle to avoid calling xTaskGetCurrentTaskHandle() twice
+  // thread_name is resolved by the caller from the task handle, avoiding redundant lookups
   void log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args,
-                                    TaskHandle_t current_task);
-#else  // USE_HOST
-  // Host: No task handle parameter needed (not used in send_message_thread_safe)
-  void log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args);
-#endif
+                                    const char *thread_name);
 #endif
   void process_messages_();
   void write_msg_(const char *msg, uint16_t len);
 
   // Format a log message with printf-style arguments and write it to a buffer with header, footer, and null terminator
+  // thread_name: name of the calling thread/task, or nullptr for main task (callers already know which task they're on)
   inline void HOT format_log_to_buffer_with_terminator_(uint8_t level, const char *tag, int line, const char *format,
-                                                        va_list args, LogBuffer &buf) {
-#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_HOST)
-    buf.write_header(level, tag, line, this->get_thread_name_());
-#elif defined(USE_ZEPHYR)
-    char tmp[MAX_POINTER_REPRESENTATION];
-    buf.write_header(level, tag, line, this->get_thread_name_(tmp));
-#else
-    buf.write_header(level, tag, line, nullptr);
-#endif
+                                                        va_list args, LogBuffer &buf, const char *thread_name) {
+    buf.write_header(level, tag, line, thread_name);
     buf.format_body(format, args);
   }
 
 #ifdef USE_STORE_LOG_STR_IN_FLASH
   // Format a log message with flash string format and write it to a buffer with header, footer, and null terminator
+  // ESP8266-only (single-task), thread_name is always nullptr
   inline void HOT format_log_to_buffer_with_terminator_P_(uint8_t level, const char *tag, int line,
                                                           const __FlashStringHelper *format, va_list args,
                                                           LogBuffer &buf) {
@@ -466,9 +461,10 @@ class Logger : public Component {
 
   // Helper to format and send a log message to both console and listeners
   // Template handles both const char* (RAM) and __FlashStringHelper* (flash) format strings
+  // thread_name: name of the calling thread/task, or nullptr for main task
   template<typename FormatType>
   inline void HOT log_message_to_buffer_and_send_(bool &recursion_guard, uint8_t level, const char *tag, int line,
-                                                  FormatType format, va_list args) {
+                                                  FormatType format, va_list args, const char *thread_name) {
     RecursionGuard guard(recursion_guard);
     LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
 #ifdef USE_STORE_LOG_STR_IN_FLASH
@@ -477,7 +473,7 @@ class Logger : public Component {
     } else
 #endif
     {
-      this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
+      this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf, thread_name);
     }
     this->notify_listeners_(level, tag, buf);
     this->write_log_buffer_to_console_(buf);
@@ -565,37 +561,57 @@ class Logger : public Component {
   bool global_recursion_guard_{false};  // Simple global recursion guard for single-task platforms
 #endif
 
-#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
-  const char *HOT get_thread_name_(
-#ifdef USE_ZEPHYR
-      char *buff
+  // --- get_thread_name_ overloads (per-platform) ---
+
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+  // Primary overload - takes a task handle directly to avoid redundant xTaskGetCurrentTaskHandle() calls
+  // when the caller already has the handle (e.g. from the main task check in log_vprintf_)
+  const char *get_thread_name_(TaskHandle_t task) {
+    if (task == this->main_task_) {
+      return nullptr;  // Main task
+    }
+#if defined(USE_ESP32)
+    return pcTaskGetName(task);
+#elif defined(USE_LIBRETINY)
+    return pcTaskGetTaskName(task);
 #endif
-  ) {
-#ifdef USE_ZEPHYR
+  }
+
+  // Convenience overload - gets the current task handle and delegates
+  const char *HOT get_thread_name_() { return this->get_thread_name_(xTaskGetCurrentTaskHandle()); }
+
+#elif defined(USE_HOST)
+  // Takes a caller-provided buffer for the thread name (stack-allocated for thread safety)
+  const char *HOT get_thread_name_(std::span<char> buff) {
+    pthread_t current_thread = pthread_self();
+    if (pthread_equal(current_thread, main_thread_)) {
+      return nullptr;  // Main thread
+    }
+    // For non-main threads, get the thread name into the caller-provided buffer
+    if (pthread_getname_np(current_thread, buff.data(), buff.size()) == 0) {
+      return buff.data();
+    }
+    return nullptr;
+  }
+
+#elif defined(USE_ZEPHYR)
+  const char *HOT get_thread_name_(std::span<char> buff) {
     k_tid_t current_task = k_current_get();
-#else
-    TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
-#endif
     if (current_task == main_task_) {
       return nullptr;  // Main task
-    } else {
-#if defined(USE_ESP32)
-      return pcTaskGetName(current_task);
-#elif defined(USE_LIBRETINY)
-      return pcTaskGetTaskName(current_task);
-#elif defined(USE_ZEPHYR)
-      const char *name = k_thread_name_get(current_task);
-      if (name) {
-        // zephyr print task names only if debug component is present
-        return name;
-      }
-      std::snprintf(buff, MAX_POINTER_REPRESENTATION, "%p", current_task);
-      return buff;
-#endif
     }
+    const char *name = k_thread_name_get(current_task);
+    if (name) {
+      // zephyr print task names only if debug component is present
+      return name;
+    }
+    std::snprintf(buff.data(), buff.size(), "%p", current_task);
+    return buff.data();
   }
 #endif
 
+  // --- Non-main task recursion guards (per-platform) ---
+
 #if defined(USE_ESP32) || defined(USE_HOST)
   // RAII guard for non-main task recursion using pthread TLS
   class NonMainTaskRecursionGuard {
@@ -635,22 +651,6 @@ class Logger : public Component {
   inline RecursionGuard make_non_main_task_guard_() { return RecursionGuard(non_main_task_recursion_guard_); }
 #endif
 
-#ifdef USE_HOST
-  const char *HOT get_thread_name_() {
-    pthread_t current_thread = pthread_self();
-    if (pthread_equal(current_thread, main_thread_)) {
-      return nullptr;  // Main thread
-    }
-    // For non-main threads, return the thread name
-    // We store it in thread-local storage to avoid allocation
-    static thread_local char thread_name_buf[32];
-    if (pthread_getname_np(current_thread, thread_name_buf, sizeof(thread_name_buf)) == 0) {
-      return thread_name_buf;
-    }
-    return nullptr;
-  }
-#endif
-
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   // Disable loop when task buffer is empty (with USB CDC check on ESP32)
   inline void disable_loop_when_buffer_empty_() {

esphome/components/logger/task_log_buffer_esp32.cpp

@@ -59,7 +59,7 @@ void TaskLogBuffer::release_message_main_loop(void *token) {
   last_processed_counter_ = message_counter_.load(std::memory_order_relaxed);
 }
 
-bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
+bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
                                              const char *format, va_list args) {
   // First, calculate the exact length needed using a null buffer (no actual writing)
   va_list args_copy;
@@ -95,7 +95,6 @@ bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uin
   // Store the thread name now instead of waiting until main loop processing
   // This avoids crashes if the task completes or is deleted between when this message
   // is enqueued and when it's processed by the main loop
-  const char *thread_name = pcTaskGetName(task_handle);
   if (thread_name != nullptr) {
     strncpy(msg->thread_name, thread_name, sizeof(msg->thread_name) - 1);
     msg->thread_name[sizeof(msg->thread_name) - 1] = '\0';  // Ensure null termination

esphome/components/logger/task_log_buffer_esp32.h

@@ -58,7 +58,7 @@ class TaskLogBuffer {
   void release_message_main_loop(void *token);
 
   // Thread-safe - send a message to the ring buffer from any thread
-  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
                                 const char *format, va_list args);
 
   // Check if there are messages ready to be processed using an atomic counter for performance

esphome/components/logger/task_log_buffer_host.cpp

@@ -70,8 +70,8 @@ void TaskLogBufferHost::commit_write_slot_(int slot_index) {
   }
 }
 
-bool TaskLogBufferHost::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *format,
-                                                 va_list args) {
+bool TaskLogBufferHost::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
+                                                 const char *format, va_list args) {
   // Acquire a slot
   int slot_index = this->acquire_write_slot_();
   if (slot_index < 0) {
@@ -85,11 +85,9 @@ bool TaskLogBufferHost::send_message_thread_safe(uint8_t level, const char *tag,
   msg.tag = tag;
   msg.line = line;
 
-  // Get thread name using pthread
-  char thread_name_buf[LogMessage::MAX_THREAD_NAME_SIZE];
-  // pthread_getname_np works the same on Linux and macOS
-  if (pthread_getname_np(pthread_self(), thread_name_buf, sizeof(thread_name_buf)) == 0) {
-    strncpy(msg.thread_name, thread_name_buf, sizeof(msg.thread_name) - 1);
+  // Store the thread name now to avoid crashes if thread exits before processing
+  if (thread_name != nullptr) {
+    strncpy(msg.thread_name, thread_name, sizeof(msg.thread_name) - 1);
     msg.thread_name[sizeof(msg.thread_name) - 1] = '\0';
   } else {
     msg.thread_name[0] = '\0';

esphome/components/logger/task_log_buffer_host.h

@@ -86,7 +86,8 @@ class TaskLogBufferHost {
 
   // Thread-safe - send a message to the buffer from any thread
   // Returns true if message was queued, false if buffer is full
-  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *format, va_list args);
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
+                                const char *format, va_list args);
 
   // Check if there are messages ready to be processed
   inline bool HOT has_messages() const {

esphome/components/logger/task_log_buffer_libretiny.cpp

@@ -101,7 +101,7 @@ void TaskLogBufferLibreTiny::release_message_main_loop() {
 }
 
 bool TaskLogBufferLibreTiny::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line,
-                                                      TaskHandle_t task_handle, const char *format, va_list args) {
+                                                      const char *thread_name, const char *format, va_list args) {
   // First, calculate the exact length needed using a null buffer (no actual writing)
   va_list args_copy;
   va_copy(args_copy, args);
@@ -162,7 +162,6 @@ bool TaskLogBufferLibreTiny::send_message_thread_safe(uint8_t level, const char
   msg->line = line;
 
   // Store the thread name now to avoid crashes if task is deleted before processing
-  const char *thread_name = pcTaskGetTaskName(task_handle);
   if (thread_name != nullptr) {
     strncpy(msg->thread_name, thread_name, sizeof(msg->thread_name) - 1);
     msg->thread_name[sizeof(msg->thread_name) - 1] = '\0';

esphome/components/logger/task_log_buffer_libretiny.h

@@ -70,7 +70,7 @@ class TaskLogBufferLibreTiny {
   void release_message_main_loop();
 
   // Thread-safe - send a message to the buffer from any thread
-  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
                                 const char *format, va_list args);
 
   // Fast check using volatile counter - no lock needed

esphome/components/mipi_dsi/models/waveshare.py

@@ -120,3 +120,101 @@ DriverChip(
         (0xB2, 0x10),
     ],
 )
+
+DriverChip(
+    "WAVESHARE-ESP32-P4-WIFI6-TOUCH-LCD-3.4C",
+    height=800,
+    width=800,
+    hsync_back_porch=20,
+    hsync_pulse_width=20,
+    hsync_front_porch=40,
+    vsync_back_porch=12,
+    vsync_pulse_width=4,
+    vsync_front_porch=24,
+    pclk_frequency="80MHz",
+    lane_bit_rate="1.5Gbps",
+    swap_xy=cv.UNDEFINED,
+    color_order="RGB",
+    initsequence=[
+        (0xE0, 0x00),  # select userpage
+        (0xE1, 0x93), (0xE2, 0x65), (0xE3, 0xF8),
+        (0x80, 0x01),  # Select number of lanes (2)
+        (0xE0, 0x01),  # select page 1
+        (0x00, 0x00), (0x01, 0x41), (0x03, 0x10), (0x04, 0x44), (0x17, 0x00), (0x18, 0xD0), (0x19, 0x00), (0x1A, 0x00),
+        (0x1B, 0xD0), (0x1C, 0x00), (0x24, 0xFE), (0x35, 0x26), (0x37, 0x09), (0x38, 0x04), (0x39, 0x08), (0x3A, 0x0A),
+        (0x3C, 0x78), (0x3D, 0xFF), (0x3E, 0xFF), (0x3F, 0xFF), (0x40, 0x00), (0x41, 0x64), (0x42, 0xC7), (0x43, 0x18),
+        (0x44, 0x0B), (0x45, 0x14), (0x55, 0x02), (0x57, 0x49), (0x59, 0x0A), (0x5A, 0x1B), (0x5B, 0x19), (0x5D, 0x7F),
+        (0x5E, 0x56), (0x5F, 0x43), (0x60, 0x37), (0x61, 0x33), (0x62, 0x25), (0x63, 0x2A), (0x64, 0x16), (0x65, 0x30),
+        (0x66, 0x2F), (0x67, 0x32), (0x68, 0x53), (0x69, 0x43), (0x6A, 0x4C), (0x6B, 0x40), (0x6C, 0x3D), (0x6D, 0x31),
+        (0x6E, 0x20), (0x6F, 0x0F), (0x70, 0x7F), (0x71, 0x56), (0x72, 0x43), (0x73, 0x37), (0x74, 0x33), (0x75, 0x25),
+        (0x76, 0x2A), (0x77, 0x16), (0x78, 0x30), (0x79, 0x2F), (0x7A, 0x32), (0x7B, 0x53), (0x7C, 0x43), (0x7D, 0x4C),
+        (0x7E, 0x40), (0x7F, 0x3D), (0x80, 0x31), (0x81, 0x20), (0x82, 0x0F),
+        (0xE0, 0x02),  # select page 2
+        (0x00, 0x5F), (0x01, 0x5F), (0x02, 0x5E), (0x03, 0x5E), (0x04, 0x50), (0x05, 0x48), (0x06, 0x48), (0x07, 0x4A),
+        (0x08, 0x4A), (0x09, 0x44), (0x0A, 0x44), (0x0B, 0x46), (0x0C, 0x46), (0x0D, 0x5F), (0x0E, 0x5F), (0x0F, 0x57),
+        (0x10, 0x57), (0x11, 0x77), (0x12, 0x77), (0x13, 0x40), (0x14, 0x42), (0x15, 0x5F), (0x16, 0x5F), (0x17, 0x5F),
+        (0x18, 0x5E), (0x19, 0x5E), (0x1A, 0x50), (0x1B, 0x49), (0x1C, 0x49), (0x1D, 0x4B), (0x1E, 0x4B), (0x1F, 0x45),
+        (0x20, 0x45), (0x21, 0x47), (0x22, 0x47), (0x23, 0x5F), (0x24, 0x5F), (0x25, 0x57), (0x26, 0x57), (0x27, 0x77),
+        (0x28, 0x77), (0x29, 0x41), (0x2A, 0x43), (0x2B, 0x5F), (0x2C, 0x1E), (0x2D, 0x1E), (0x2E, 0x1F), (0x2F, 0x1F),
+        (0x30, 0x10), (0x31, 0x07), (0x32, 0x07), (0x33, 0x05), (0x34, 0x05), (0x35, 0x0B), (0x36, 0x0B), (0x37, 0x09),
+        (0x38, 0x09), (0x39, 0x1F), (0x3A, 0x1F), (0x3B, 0x17), (0x3C, 0x17), (0x3D, 0x17), (0x3E, 0x17), (0x3F, 0x03),
+        (0x40, 0x01), (0x41, 0x1F), (0x42, 0x1E), (0x43, 0x1E), (0x44, 0x1F), (0x45, 0x1F), (0x46, 0x10), (0x47, 0x06),
+        (0x48, 0x06), (0x49, 0x04), (0x4A, 0x04), (0x4B, 0x0A), (0x4C, 0x0A), (0x4D, 0x08), (0x4E, 0x08), (0x4F, 0x1F),
+        (0x50, 0x1F), (0x51, 0x17), (0x52, 0x17), (0x53, 0x17), (0x54, 0x17), (0x55, 0x02), (0x56, 0x00), (0x57, 0x1F),
+        (0xE0, 0x02),  # select page 2
+        (0x58, 0x40), (0x59, 0x00), (0x5A, 0x00), (0x5B, 0x30), (0x5C, 0x01), (0x5D, 0x30), (0x5E, 0x01), (0x5F, 0x02),
+        (0x60, 0x30), (0x61, 0x03), (0x62, 0x04), (0x63, 0x04), (0x64, 0xA6), (0x65, 0x43), (0x66, 0x30), (0x67, 0x73),
+        (0x68, 0x05), (0x69, 0x04), (0x6A, 0x7F), (0x6B, 0x08), (0x6C, 0x00), (0x6D, 0x04), (0x6E, 0x04), (0x6F, 0x88),
+        (0x75, 0xD9), (0x76, 0x00), (0x77, 0x33), (0x78, 0x43),
+        (0xE0, 0x00),  # select userpage
+    ],
+)
+
+DriverChip(
+    "WAVESHARE-ESP32-P4-WIFI6-TOUCH-LCD-4C",
+    height=720,
+    width=720,
+    hsync_back_porch=20,
+    hsync_pulse_width=20,
+    hsync_front_porch=40,
+    vsync_back_porch=12,
+    vsync_pulse_width=4,
+    vsync_front_porch=24,
+    pclk_frequency="80MHz",
+    lane_bit_rate="1.5Gbps",
+    swap_xy=cv.UNDEFINED,
+    color_order="RGB",
+    initsequence=[
+        (0xE0, 0x00),  # select userpage
+        (0xE1, 0x93), (0xE2, 0x65), (0xE3, 0xF8),
+        (0x80, 0x01),  # Select number of lanes (2)
+        (0xE0, 0x01),  # select page 1
+        (0x00, 0x00), (0x01, 0x41), (0x03, 0x10), (0x04, 0x44), (0x17, 0x00), (0x18, 0xD0), (0x19, 0x00), (0x1A, 0x00),
+        (0x1B, 0xD0), (0x1C, 0x00), (0x24, 0xFE), (0x35, 0x26), (0x37, 0x09), (0x38, 0x04), (0x39, 0x08), (0x3A, 0x0A),
+        (0x3C, 0x78), (0x3D, 0xFF), (0x3E, 0xFF), (0x3F, 0xFF), (0x40, 0x04), (0x41, 0x64), (0x42, 0xC7), (0x43, 0x18),
+        (0x44, 0x0B), (0x45, 0x14), (0x55, 0x02), (0x57, 0x49), (0x59, 0x0A), (0x5A, 0x1B), (0x5B, 0x19), (0x5D, 0x7F),
+        (0x5E, 0x56), (0x5F, 0x43), (0x60, 0x37), (0x61, 0x33), (0x62, 0x25), (0x63, 0x2A), (0x64, 0x16), (0x65, 0x30),
+        (0x66, 0x2F), (0x67, 0x32), (0x68, 0x53), (0x69, 0x43), (0x6A, 0x4C), (0x6B, 0x40), (0x6C, 0x3D), (0x6D, 0x31),
+        (0x6E, 0x20), (0x6F, 0x0F), (0x70, 0x7F), (0x71, 0x56), (0x72, 0x43), (0x73, 0x37), (0x74, 0x33), (0x75, 0x25),
+        (0x76, 0x2A), (0x77, 0x16), (0x78, 0x30), (0x79, 0x2F), (0x7A, 0x32), (0x7B, 0x53), (0x7C, 0x43), (0x7D, 0x4C),
+        (0x7E, 0x40), (0x7F, 0x3D), (0x80, 0x31), (0x81, 0x20), (0x82, 0x0F),
+        (0xE0, 0x02),  # select page 2
+        (0x00, 0x5F), (0x01, 0x5F), (0x02, 0x5E), (0x03, 0x5E), (0x04, 0x50), (0x05, 0x48), (0x06, 0x48), (0x07, 0x4A),
+        (0x08, 0x4A), (0x09, 0x44), (0x0A, 0x44), (0x0B, 0x46), (0x0C, 0x46), (0x0D, 0x5F), (0x0E, 0x5F), (0x0F, 0x57),
+        (0x10, 0x57), (0x11, 0x77), (0x12, 0x77), (0x13, 0x40), (0x14, 0x42), (0x15, 0x5F), (0x16, 0x5F), (0x17, 0x5F),
+        (0x18, 0x5E), (0x19, 0x5E), (0x1A, 0x50), (0x1B, 0x49), (0x1C, 0x49), (0x1D, 0x4B), (0x1E, 0x4B), (0x1F, 0x45),
+        (0x20, 0x45), (0x21, 0x47), (0x22, 0x47), (0x23, 0x5F), (0x24, 0x5F), (0x25, 0x57), (0x26, 0x57), (0x27, 0x77),
+        (0x28, 0x77), (0x29, 0x41), (0x2A, 0x43), (0x2B, 0x5F), (0x2C, 0x1E), (0x2D, 0x1E), (0x2E, 0x1F), (0x2F, 0x1F),
+        (0x30, 0x10), (0x31, 0x07), (0x32, 0x07), (0x33, 0x05), (0x34, 0x05), (0x35, 0x0B), (0x36, 0x0B), (0x37, 0x09),
+        (0x38, 0x09), (0x39, 0x1F), (0x3A, 0x1F), (0x3B, 0x17), (0x3C, 0x17), (0x3D, 0x17), (0x3E, 0x17), (0x3F, 0x03),
+        (0x40, 0x01), (0x41, 0x1F), (0x42, 0x1E), (0x43, 0x1E), (0x44, 0x1F), (0x45, 0x1F), (0x46, 0x10), (0x47, 0x06),
+        (0x48, 0x06), (0x49, 0x04), (0x4A, 0x04), (0x4B, 0x0A), (0x4C, 0x0A), (0x4D, 0x08), (0x4E, 0x08), (0x4F, 0x1F),
+        (0x50, 0x1F), (0x51, 0x17), (0x52, 0x17), (0x53, 0x17), (0x54, 0x17), (0x55, 0x02), (0x56, 0x00), (0x57, 0x1F),
+        (0xE0, 0x02),  # select page 2
+        (0x58, 0x40), (0x59, 0x00), (0x5A, 0x00), (0x5B, 0x30), (0x5C, 0x01), (0x5D, 0x30), (0x5E, 0x01), (0x5F, 0x02),
+        (0x60, 0x30), (0x61, 0x03), (0x62, 0x04), (0x63, 0x04), (0x64, 0xA6), (0x65, 0x43), (0x66, 0x30), (0x67, 0x73),
+        (0x68, 0x05), (0x69, 0x04), (0x6A, 0x7F), (0x6B, 0x08), (0x6C, 0x00), (0x6D, 0x04), (0x6E, 0x04), (0x6F, 0x88),
+        (0x75, 0xD9), (0x76, 0x00), (0x77, 0x33), (0x78, 0x43),
+        (0xE0, 0x00),  # select userpage
+    ]
+)

esphome/components/mipi_rgb/display.py

@@ -11,7 +11,7 @@ from esphome.components.const import (
     CONF_DRAW_ROUNDING,
 )
 from esphome.components.display import CONF_SHOW_TEST_CARD
-from esphome.components.esp32 import VARIANT_ESP32S3, only_on_variant
+from esphome.components.esp32 import VARIANT_ESP32P4, VARIANT_ESP32S3, only_on_variant
 from esphome.components.mipi import (
     COLOR_ORDERS,
     CONF_DE_PIN,
@@ -225,7 +225,7 @@ def _config_schema(config):
     return cv.All(
         schema,
         cv.only_on_esp32,
-        only_on_variant(supported=[VARIANT_ESP32S3]),
+        only_on_variant(supported=[VARIANT_ESP32S3, VARIANT_ESP32P4]),
     )(config)
 
 

esphome/components/mipi_rgb/mipi_rgb.cpp

@@ -1,4 +1,4 @@
-#ifdef USE_ESP32_VARIANT_ESP32S3
+#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)
 #include "mipi_rgb.h"
 #include "esphome/core/gpio.h"
 #include "esphome/core/hal.h"
@@ -401,4 +401,4 @@ void MipiRgb::dump_config() {
 
 }  // namespace mipi_rgb
 }  // namespace esphome
-#endif  // USE_ESP32_VARIANT_ESP32S3
+#endif  // defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)

esphome/components/mipi_rgb/mipi_rgb.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#ifdef USE_ESP32_VARIANT_ESP32S3
+#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)
 #include "esphome/core/gpio.h"
 #include "esphome/components/display/display.h"
 #include "esp_lcd_panel_ops.h"
@@ -28,7 +28,7 @@ class MipiRgb : public display::Display {
   void setup() override;
   void loop() override;
   void update() override;
-  void fill(Color color);
+  void fill(Color color) override;
   void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
                       display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
   void write_to_display_(int x_start, int y_start, int w, int h, const uint8_t *ptr, int x_offset, int y_offset,
@@ -115,7 +115,7 @@ class MipiRgbSpi : public MipiRgb,
   void write_command_(uint8_t value);
   void write_data_(uint8_t value);
   void write_init_sequence_();
-  void dump_config();
+  void dump_config() override;
 
   GPIOPin *dc_pin_{nullptr};
   std::vector<uint8_t> init_sequence_;

esphome/components/modbus/modbus.cpp

@@ -20,10 +20,10 @@ void Modbus::loop() {
   const uint32_t now = App.get_loop_component_start_time();
 
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/nextion/nextion.cpp

@@ -398,10 +398,10 @@ bool Nextion::remove_from_q_(bool report_empty) {
 
 void Nextion::process_serial_() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/pipsolar/pipsolar.cpp

@@ -14,9 +14,9 @@ void Pipsolar::setup() {
 
 void Pipsolar::empty_uart_buffer_() {
   uint8_t buf[64];
-  int avail;
+  size_t avail;
   while ((avail = this->available()) > 0) {
-    if (!this->read_array(buf, std::min(static_cast<size_t>(avail), sizeof(buf)))) {
+    if (!this->read_array(buf, std::min(avail, sizeof(buf)))) {
       break;
     }
   }
@@ -97,10 +97,10 @@ void Pipsolar::loop() {
   }
 
   if (this->state_ == STATE_COMMAND || this->state_ == STATE_POLL) {
-    int avail = this->available();
+    size_t avail = this->available();
     while (avail > 0) {
       uint8_t buf[64];
-      size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+      size_t to_read = std::min(avail, sizeof(buf));
       if (!this->read_array(buf, to_read)) {
         break;
       }

esphome/components/pulse_counter/pulse_counter_sensor.cpp

@@ -1,6 +1,11 @@
 #include "pulse_counter_sensor.h"
 #include "esphome/core/log.h"
 
+#ifdef HAS_PCNT
+#include <esp_clk_tree.h>
+#include <hal/pcnt_ll.h>
+#endif
+
 namespace esphome {
 namespace pulse_counter {
 
@@ -56,103 +61,109 @@ pulse_counter_t BasicPulseCounterStorage::read_raw_value() {
 
 #ifdef HAS_PCNT
 bool HwPulseCounterStorage::pulse_counter_setup(InternalGPIOPin *pin) {
-  static pcnt_unit_t next_pcnt_unit = PCNT_UNIT_0;
-  static pcnt_channel_t next_pcnt_channel = PCNT_CHANNEL_0;
   this->pin = pin;
   this->pin->setup();
-  this->pcnt_unit = next_pcnt_unit;
-  this->pcnt_channel = next_pcnt_channel;
-  next_pcnt_unit = pcnt_unit_t(int(next_pcnt_unit) + 1);
-  if (int(next_pcnt_unit) >= PCNT_UNIT_0 + PCNT_UNIT_MAX) {
-    next_pcnt_unit = PCNT_UNIT_0;
-    next_pcnt_channel = pcnt_channel_t(int(next_pcnt_channel) + 1);
+
+  pcnt_unit_config_t unit_config = {
+      .low_limit = INT16_MIN,
+      .high_limit = INT16_MAX,
+      .flags = {.accum_count = true},
+  };
+  esp_err_t error = pcnt_new_unit(&unit_config, &this->pcnt_unit);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Creating PCNT unit failed: %s", esp_err_to_name(error));
+    return false;
   }
 
-  ESP_LOGCONFIG(TAG,
-                "    PCNT Unit Number: %u\n"
-                "    PCNT Channel Number: %u",
-                this->pcnt_unit, this->pcnt_channel);
+  pcnt_chan_config_t chan_config = {
+      .edge_gpio_num = this->pin->get_pin(),
+      .level_gpio_num = -1,
+  };
+  error = pcnt_new_channel(this->pcnt_unit, &chan_config, &this->pcnt_channel);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Creating PCNT channel failed: %s", esp_err_to_name(error));
+    return false;
+  }
 
-  pcnt_count_mode_t rising = PCNT_COUNT_DIS, falling = PCNT_COUNT_DIS;
+  pcnt_channel_edge_action_t rising = PCNT_CHANNEL_EDGE_ACTION_HOLD;
+  pcnt_channel_edge_action_t falling = PCNT_CHANNEL_EDGE_ACTION_HOLD;
   switch (this->rising_edge_mode) {
     case PULSE_COUNTER_DISABLE:
-      rising = PCNT_COUNT_DIS;
+      rising = PCNT_CHANNEL_EDGE_ACTION_HOLD;
       break;
     case PULSE_COUNTER_INCREMENT:
-      rising = PCNT_COUNT_INC;
+      rising = PCNT_CHANNEL_EDGE_ACTION_INCREASE;
       break;
     case PULSE_COUNTER_DECREMENT:
-      rising = PCNT_COUNT_DEC;
+      rising = PCNT_CHANNEL_EDGE_ACTION_DECREASE;
       break;
   }
   switch (this->falling_edge_mode) {
     case PULSE_COUNTER_DISABLE:
-      falling = PCNT_COUNT_DIS;
+      falling = PCNT_CHANNEL_EDGE_ACTION_HOLD;
       break;
     case PULSE_COUNTER_INCREMENT:
-      falling = PCNT_COUNT_INC;
+      falling = PCNT_CHANNEL_EDGE_ACTION_INCREASE;
       break;
     case PULSE_COUNTER_DECREMENT:
-      falling = PCNT_COUNT_DEC;
+      falling = PCNT_CHANNEL_EDGE_ACTION_DECREASE;
       break;
   }
 
-  pcnt_config_t pcnt_config = {
-      .pulse_gpio_num = this->pin->get_pin(),
-      .ctrl_gpio_num = PCNT_PIN_NOT_USED,
-      .lctrl_mode = PCNT_MODE_KEEP,
-      .hctrl_mode = PCNT_MODE_KEEP,
-      .pos_mode = rising,
-      .neg_mode = falling,
-      .counter_h_lim = 0,
-      .counter_l_lim = 0,
-      .unit = this->pcnt_unit,
-      .channel = this->pcnt_channel,
-  };
-  esp_err_t error = pcnt_unit_config(&pcnt_config);
+  error = pcnt_channel_set_edge_action(this->pcnt_channel, rising, falling);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Configuring Pulse Counter failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Setting PCNT edge action failed: %s", esp_err_to_name(error));
     return false;
   }
 
   if (this->filter_us != 0) {
-    uint16_t filter_val = std::min(static_cast<unsigned int>(this->filter_us * 80u), 1023u);
-    ESP_LOGCONFIG(TAG, "    Filter Value: %" PRIu32 "us (val=%u)", this->filter_us, filter_val);
-    error = pcnt_set_filter_value(this->pcnt_unit, filter_val);
+    uint32_t apb_freq;
+    esp_clk_tree_src_get_freq_hz(SOC_MOD_CLK_APB, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &apb_freq);
+    uint32_t max_glitch_ns = PCNT_LL_MAX_GLITCH_WIDTH * 1000000u / apb_freq;
+    pcnt_glitch_filter_config_t filter_config = {
+        .max_glitch_ns = std::min(this->filter_us * 1000u, max_glitch_ns),
+    };
+    error = pcnt_unit_set_glitch_filter(this->pcnt_unit, &filter_config);
     if (error != ESP_OK) {
-      ESP_LOGE(TAG, "Setting filter value failed: %s", esp_err_to_name(error));
-      return false;
-    }
-    error = pcnt_filter_enable(this->pcnt_unit);
-    if (error != ESP_OK) {
-      ESP_LOGE(TAG, "Enabling filter failed: %s", esp_err_to_name(error));
+      ESP_LOGE(TAG, "Setting PCNT glitch filter failed: %s", esp_err_to_name(error));
       return false;
     }
   }
 
-  error = pcnt_counter_pause(this->pcnt_unit);
+  error = pcnt_unit_add_watch_point(this->pcnt_unit, INT16_MIN);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Pausing pulse counter failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Adding PCNT low limit watch point failed: %s", esp_err_to_name(error));
     return false;
   }
-  error = pcnt_counter_clear(this->pcnt_unit);
+  error = pcnt_unit_add_watch_point(this->pcnt_unit, INT16_MAX);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Clearing pulse counter failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Adding PCNT high limit watch point failed: %s", esp_err_to_name(error));
     return false;
   }
-  error = pcnt_counter_resume(this->pcnt_unit);
+
+  error = pcnt_unit_enable(this->pcnt_unit);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Resuming pulse counter failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Enabling PCNT unit failed: %s", esp_err_to_name(error));
+    return false;
+  }
+  error = pcnt_unit_clear_count(this->pcnt_unit);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Clearing PCNT unit failed: %s", esp_err_to_name(error));
+    return false;
+  }
+  error = pcnt_unit_start(this->pcnt_unit);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Starting PCNT unit failed: %s", esp_err_to_name(error));
     return false;
   }
   return true;
 }
 
 pulse_counter_t HwPulseCounterStorage::read_raw_value() {
-  pulse_counter_t counter;
-  pcnt_get_counter_value(this->pcnt_unit, &counter);
-  pulse_counter_t ret = counter - this->last_value;
-  this->last_value = counter;
+  int count;
+  pcnt_unit_get_count(this->pcnt_unit, &count);
+  pulse_counter_t ret = count - this->last_value;
+  this->last_value = count;
   return ret;
 }
 #endif  // HAS_PCNT

esphome/components/pulse_counter/pulse_counter_sensor.h

@@ -6,14 +6,13 @@
 
 #include <cinttypes>
 
-// TODO: Migrate from legacy PCNT API (driver/pcnt.h) to new PCNT API (driver/pulse_cnt.h)
-// The legacy PCNT API is deprecated in ESP-IDF 5.x. Migration would allow removing the
-// "driver" IDF component dependency. See:
-// https://docs.espressif.com/projects/esp-idf/en/latest/esp32/migration-guides/release-5.x/5.0/peripherals.html#id6
-#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3)
-#include <driver/pcnt.h>
+#if defined(USE_ESP32)
+#include <soc/soc_caps.h>
+#ifdef SOC_PCNT_SUPPORTED
+#include <driver/pulse_cnt.h>
 #define HAS_PCNT
-#endif  // defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3)
+#endif  // SOC_PCNT_SUPPORTED
+#endif  // USE_ESP32
 
 namespace esphome {
 namespace pulse_counter {
@@ -24,11 +23,7 @@ enum PulseCounterCountMode {
   PULSE_COUNTER_DECREMENT,
 };
 
-#ifdef HAS_PCNT
-using pulse_counter_t = int16_t;
-#else   // HAS_PCNT
 using pulse_counter_t = int32_t;
-#endif  // HAS_PCNT
 
 struct PulseCounterStorageBase {
   virtual bool pulse_counter_setup(InternalGPIOPin *pin) = 0;
@@ -58,8 +53,8 @@ struct HwPulseCounterStorage : public PulseCounterStorageBase {
   bool pulse_counter_setup(InternalGPIOPin *pin) override;
   pulse_counter_t read_raw_value() override;
 
-  pcnt_unit_t pcnt_unit;
-  pcnt_channel_t pcnt_channel;
+  pcnt_unit_handle_t pcnt_unit{nullptr};
+  pcnt_channel_handle_t pcnt_channel{nullptr};
 };
 #endif  // HAS_PCNT
 

esphome/components/pulse_counter/sensor.py

@@ -129,10 +129,7 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     use_pcnt = config.get(CONF_USE_PCNT)
     if CORE.is_esp32 and use_pcnt:
-        # Re-enable ESP-IDF's legacy driver component (excluded by default to save compile time)
-        # Provides driver/pcnt.h header for hardware pulse counter API
-        # TODO: Remove this once pulse_counter migrates to new PCNT API (driver/pulse_cnt.h)
-        include_builtin_idf_component("driver")
+        include_builtin_idf_component("esp_driver_pcnt")
 
     var = await sensor.new_sensor(config, use_pcnt)
     await cg.register_component(var, config)

esphome/components/pylontech/pylontech.cpp

@@ -56,17 +56,23 @@ void PylontechComponent::setup() {
 void PylontechComponent::update() { this->write_str("pwr\n"); }
 
 void PylontechComponent::loop() {
-  if (this->available() > 0) {
+  size_t avail = this->available();
+  if (avail > 0) {
     // pylontech sends a lot of data very suddenly
     // we need to quickly put it all into our own buffer, otherwise the uart's buffer will overflow
-    uint8_t data;
     int recv = 0;
-    while (this->available() > 0) {
-      if (this->read_byte(&data)) {
-        buffer_[buffer_index_write_] += (char) data;
-        recv++;
-        if (buffer_[buffer_index_write_].back() == static_cast<char>(ASCII_LF) ||
-            buffer_[buffer_index_write_].length() >= MAX_DATA_LENGTH_BYTES) {
+    uint8_t buf[64];
+    while (avail > 0) {
+      size_t to_read = std::min(avail, sizeof(buf));
+      if (!this->read_array(buf, to_read)) {
+        break;
+      }
+      avail -= to_read;
+      recv += to_read;
+
+      for (size_t i = 0; i < to_read; i++) {
+        buffer_[buffer_index_write_] += (char) buf[i];
+        if (buf[i] == ASCII_LF || buffer_[buffer_index_write_].length() >= MAX_DATA_LENGTH_BYTES) {
           // complete line received
           buffer_index_write_ = (buffer_index_write_ + 1) % NUM_BUFFERS;
         }

esphome/components/rd03d/rd03d.cpp

@@ -82,10 +82,10 @@ void RD03DComponent::dump_config() {
 
 void RD03DComponent::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/remote_receiver/remote_receiver_esp32.cpp

@@ -3,15 +3,11 @@
 
 #ifdef USE_ESP32
 #include <driver/gpio.h>
+#include <esp_clk_tree.h>
 
 namespace esphome::remote_receiver {
 
 static const char *const TAG = "remote_receiver.esp32";
-#ifdef USE_ESP32_VARIANT_ESP32H2
-static const uint32_t RMT_CLK_FREQ = 32000000;
-#else
-static const uint32_t RMT_CLK_FREQ = 80000000;
-#endif
 
 static bool IRAM_ATTR HOT rmt_callback(rmt_channel_handle_t channel, const rmt_rx_done_event_data_t *event, void *arg) {
   RemoteReceiverComponentStore *store = (RemoteReceiverComponentStore *) arg;
@@ -98,7 +94,10 @@ void RemoteReceiverComponent::setup() {
   }
 
   uint32_t event_size = sizeof(rmt_rx_done_event_data_t);
-  uint32_t max_filter_ns = 255u * 1000 / (RMT_CLK_FREQ / 1000000);
+  uint32_t rmt_freq;
+  esp_clk_tree_src_get_freq_hz((soc_module_clk_t) RMT_CLK_SRC_DEFAULT, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED,
+                               &rmt_freq);
+  uint32_t max_filter_ns = UINT8_MAX * 1000u / (rmt_freq / 1000000);
   memset(&this->store_.config, 0, sizeof(this->store_.config));
   this->store_.config.signal_range_min_ns = std::min(this->filter_us_ * 1000, max_filter_ns);
   this->store_.config.signal_range_max_ns = this->idle_us_ * 1000;

esphome/components/resampler/speaker/__init__.py

@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import audio, esp32, speaker
+from esphome.components import audio, esp32, socket, speaker
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BITS_PER_SAMPLE,
@@ -34,7 +34,7 @@ def _set_stream_limits(config):
     return config
 
 
-def _validate_audio_compatability(config):
+def _validate_audio_compatibility(config):
     inherit_property_from(CONF_BITS_PER_SAMPLE, CONF_OUTPUT_SPEAKER)(config)
     inherit_property_from(CONF_NUM_CHANNELS, CONF_OUTPUT_SPEAKER)(config)
     inherit_property_from(CONF_SAMPLE_RATE, CONF_OUTPUT_SPEAKER)(config)
@@ -73,10 +73,13 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-FINAL_VALIDATE_SCHEMA = _validate_audio_compatability
+FINAL_VALIDATE_SCHEMA = _validate_audio_compatibility
 
 
 async def to_code(config):
+    # Enable wake_loop_threadsafe for immediate command processing from other tasks
+    socket.require_wake_loop_threadsafe()
+
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await speaker.register_speaker(var, config)
@@ -86,12 +89,11 @@ async def to_code(config):
 
     cg.add(var.set_buffer_duration(config[CONF_BUFFER_DURATION]))
 
-    if task_stack_in_psram := config.get(CONF_TASK_STACK_IN_PSRAM):
-        cg.add(var.set_task_stack_in_psram(task_stack_in_psram))
-        if task_stack_in_psram and config[CONF_TASK_STACK_IN_PSRAM]:
-            esp32.add_idf_sdkconfig_option(
-                "CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY", True
-            )
+    if config.get(CONF_TASK_STACK_IN_PSRAM):
+        cg.add(var.set_task_stack_in_psram(True))
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY", True
+        )
 
     cg.add(var.set_target_bits_per_sample(config[CONF_BITS_PER_SAMPLE]))
     cg.add(var.set_target_sample_rate(config[CONF_SAMPLE_RATE]))

esphome/components/resampler/speaker/resampler_speaker.cpp

@@ -4,6 +4,8 @@
 
 #include "esphome/components/audio/audio_resampler.h"
 
+#include "esphome/core/application.h"
+#include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
@@ -17,13 +19,17 @@ static const UBaseType_t RESAMPLER_TASK_PRIORITY = 1;
 
 static const uint32_t TRANSFER_BUFFER_DURATION_MS = 50;
 
-static const uint32_t TASK_DELAY_MS = 20;
 static const uint32_t TASK_STACK_SIZE = 3072;
 
+static const uint32_t STATE_TRANSITION_TIMEOUT_MS = 5000;
+
 static const char *const TAG = "resampler_speaker";
 
 enum ResamplingEventGroupBits : uint32_t {
-  COMMAND_STOP = (1 << 0),  // stops the resampler task
+  COMMAND_STOP = (1 << 0),       // signals stop request
+  COMMAND_START = (1 << 1),      // signals start request
+  COMMAND_FINISH = (1 << 2),     // signals finish request (graceful stop)
+  TASK_COMMAND_STOP = (1 << 5),  // signals the task to stop
   STATE_STARTING = (1 << 10),
   STATE_RUNNING = (1 << 11),
   STATE_STOPPING = (1 << 12),
@@ -34,9 +40,16 @@ enum ResamplingEventGroupBits : uint32_t {
   ALL_BITS = 0x00FFFFFF,  // All valid FreeRTOS event group bits
 };
 
+void ResamplerSpeaker::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Resampler Speaker:\n"
+                "  Target Bits Per Sample: %u\n"
+                "  Target Sample Rate: %" PRIu32 " Hz",
+                this->target_bits_per_sample_, this->target_sample_rate_);
+}
+
 void ResamplerSpeaker::setup() {
   this->event_group_ = xEventGroupCreate();
-
   if (this->event_group_ == nullptr) {
     ESP_LOGE(TAG, "Failed to create event group");
     this->mark_failed();
@@ -55,81 +68,155 @@ void ResamplerSpeaker::setup() {
       this->audio_output_callback_(new_frames, write_timestamp);
     }
   });
+
+  // Start with loop disabled since no task is running and no commands are pending
+  this->disable_loop();
 }
 
 void ResamplerSpeaker::loop() {
   uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
 
+  // Process commands with priority: STOP > FINISH > START
+  // This ensures stop commands take precedence over conflicting start commands
+  if (event_group_bits & ResamplingEventGroupBits::COMMAND_STOP) {
+    if (this->state_ == speaker::STATE_RUNNING || this->state_ == speaker::STATE_STARTING) {
+      // Clear STOP, START, and FINISH bits - stop takes precedence
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_STOP |
+                                                   ResamplingEventGroupBits::COMMAND_START |
+                                                   ResamplingEventGroupBits::COMMAND_FINISH);
+      this->waiting_for_output_ = false;
+      this->enter_stopping_state_();
+    } else if (this->state_ == speaker::STATE_STOPPED) {
+      // Already stopped, just clear the command bits
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_STOP |
+                                                   ResamplingEventGroupBits::COMMAND_START |
+                                                   ResamplingEventGroupBits::COMMAND_FINISH);
+    }
+    // Leave bits set if STATE_STOPPING - will be processed once stopped
+  } else if (event_group_bits & ResamplingEventGroupBits::COMMAND_FINISH) {
+    if (this->state_ == speaker::STATE_RUNNING) {
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_FINISH);
+      this->output_speaker_->finish();
+    } else if (this->state_ == speaker::STATE_STOPPED) {
+      // Already stopped, just clear the command bit
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_FINISH);
+    }
+    // Leave bit set if transitioning states - will be processed once state allows
+  } else if (event_group_bits & ResamplingEventGroupBits::COMMAND_START) {
+    if (this->state_ == speaker::STATE_STOPPED) {
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_START);
+      this->state_ = speaker::STATE_STARTING;
+    } else if (this->state_ == speaker::STATE_RUNNING) {
+      // Already running, just clear the command bit
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_START);
+    }
+    // Leave bit set if transitioning states - will be processed once state allows
+  }
+
+  // Re-read bits after command processing (enter_stopping_state_ may have set task bits)
+  event_group_bits = xEventGroupGetBits(this->event_group_);
+
   if (event_group_bits & ResamplingEventGroupBits::STATE_STARTING) {
-    ESP_LOGD(TAG, "Starting resampler task");
+    ESP_LOGD(TAG, "Starting");
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_STARTING);
   }
 
   if (event_group_bits & ResamplingEventGroupBits::ERR_ESP_NO_MEM) {
-    this->status_set_error(LOG_STR("Resampler task failed to allocate the internal buffers"));
+    this->status_set_error(LOG_STR("Not enough memory"));
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ERR_ESP_NO_MEM);
-    this->state_ = speaker::STATE_STOPPING;
+    this->enter_stopping_state_();
   }
   if (event_group_bits & ResamplingEventGroupBits::ERR_ESP_NOT_SUPPORTED) {
-    this->status_set_error(LOG_STR("Cannot resample due to an unsupported audio stream"));
+    this->status_set_error(LOG_STR("Unsupported stream"));
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ERR_ESP_NOT_SUPPORTED);
-    this->state_ = speaker::STATE_STOPPING;
+    this->enter_stopping_state_();
   }
   if (event_group_bits & ResamplingEventGroupBits::ERR_ESP_FAIL) {
-    this->status_set_error(LOG_STR("Resampler task failed"));
+    this->status_set_error(LOG_STR("Resampler failure"));
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ERR_ESP_FAIL);
-    this->state_ = speaker::STATE_STOPPING;
+    this->enter_stopping_state_();
   }
 
   if (event_group_bits & ResamplingEventGroupBits::STATE_RUNNING) {
-    ESP_LOGD(TAG, "Started resampler task");
+    ESP_LOGV(TAG, "Started");
     this->status_clear_error();
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_RUNNING);
   }
   if (event_group_bits & ResamplingEventGroupBits::STATE_STOPPING) {
-    ESP_LOGD(TAG, "Stopping resampler task");
+    ESP_LOGV(TAG, "Stopping");
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_STOPPING);
   }
   if (event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) {
-    if (this->delete_task_() == ESP_OK) {
-      ESP_LOGD(TAG, "Stopped resampler task");
-      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ALL_BITS);
-    }
+    this->delete_task_();
+    ESP_LOGD(TAG, "Stopped");
+    xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ALL_BITS);
   }
 
   switch (this->state_) {
     case speaker::STATE_STARTING: {
-      esp_err_t err = this->start_();
-      if (err == ESP_OK) {
-        this->status_clear_error();
-        this->state_ = speaker::STATE_RUNNING;
-      } else {
-        switch (err) {
-          case ESP_ERR_INVALID_STATE:
-            this->status_set_error(LOG_STR("Failed to start resampler: resampler task failed to start"));
-            break;
-          case ESP_ERR_NO_MEM:
-            this->status_set_error(LOG_STR("Failed to start resampler: not enough memory for task stack"));
-          default:
-            this->status_set_error(LOG_STR("Failed to start resampler"));
-            break;
+      if (!this->waiting_for_output_) {
+        esp_err_t err = this->start_();
+        if (err == ESP_OK) {
+          this->callback_remainder_ = 0;  // reset callback remainder
+          this->status_clear_error();
+          this->waiting_for_output_ = true;
+          this->state_start_ms_ = App.get_loop_component_start_time();
+        } else {
+          this->set_start_error_(err);
+          this->waiting_for_output_ = false;
+          this->enter_stopping_state_();
+        }
+      } else {
+        if (this->output_speaker_->is_running()) {
+          this->state_ = speaker::STATE_RUNNING;
+          this->waiting_for_output_ = false;
+        } else if ((App.get_loop_component_start_time() - this->state_start_ms_) > STATE_TRANSITION_TIMEOUT_MS) {
+          // Timed out waiting for the output speaker to start
+          this->waiting_for_output_ = false;
+          this->enter_stopping_state_();
         }
-
-        this->state_ = speaker::STATE_STOPPING;
       }
       break;
     }
     case speaker::STATE_RUNNING:
       if (this->output_speaker_->is_stopped()) {
-        this->state_ = speaker::STATE_STOPPING;
+        this->enter_stopping_state_();
+      }
+      break;
+    case speaker::STATE_STOPPING: {
+      if ((this->output_speaker_->get_pause_state()) ||
+          ((App.get_loop_component_start_time() - this->state_start_ms_) > STATE_TRANSITION_TIMEOUT_MS)) {
+        // If output speaker is paused or stopping timeout exceeded, force stop
+        this->output_speaker_->stop();
       }
 
+      if (this->output_speaker_->is_stopped() && (this->task_handle_ == nullptr)) {
+        // Only transition to stopped state once the output speaker and resampler task are fully stopped
+        this->waiting_for_output_ = false;
+        this->state_ = speaker::STATE_STOPPED;
+      }
       break;
-    case speaker::STATE_STOPPING:
-      this->stop_();
-      this->state_ = speaker::STATE_STOPPED;
-      break;
+    }
     case speaker::STATE_STOPPED:
+      event_group_bits = xEventGroupGetBits(this->event_group_);
+      if (event_group_bits == 0) {
+        // No pending events, disable loop to save CPU cycles
+        this->disable_loop();
+      }
+      break;
+  }
+}
+
+void ResamplerSpeaker::set_start_error_(esp_err_t err) {
+  switch (err) {
+    case ESP_ERR_INVALID_STATE:
+      this->status_set_error(LOG_STR("Task failed to start"));
+      break;
+    case ESP_ERR_NO_MEM:
+      this->status_set_error(LOG_STR("Not enough memory"));
+      break;
+    default:
+      this->status_set_error(LOG_STR("Failed to start"));
       break;
   }
 }
@@ -143,16 +230,33 @@ size_t ResamplerSpeaker::play(const uint8_t *data, size_t length, TickType_t tic
   if ((this->output_speaker_->is_running()) && (!this->requires_resampling_())) {
     bytes_written = this->output_speaker_->play(data, length, ticks_to_wait);
   } else {
-    if (this->ring_buffer_.use_count() == 1) {
-      std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
+    std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
+    if (temp_ring_buffer) {
+      // Only write to the ring buffer if the reference is valid
       bytes_written = temp_ring_buffer->write_without_replacement(data, length, ticks_to_wait);
+    } else {
+      // Delay to avoid repeatedly hammering while waiting for the speaker to start
+      vTaskDelay(ticks_to_wait);
     }
   }
 
   return bytes_written;
 }
 
-void ResamplerSpeaker::start() { this->state_ = speaker::STATE_STARTING; }
+void ResamplerSpeaker::send_command_(uint32_t command_bit, bool wake_loop) {
+  this->enable_loop_soon_any_context();
+  uint32_t event_bits = xEventGroupGetBits(this->event_group_);
+  if (!(event_bits & command_bit)) {
+    xEventGroupSetBits(this->event_group_, command_bit);
+#if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
+    if (wake_loop) {
+      App.wake_loop_threadsafe();
+    }
+#endif
+  }
+}
+
+void ResamplerSpeaker::start() { this->send_command_(ResamplingEventGroupBits::COMMAND_START, true); }
 
 esp_err_t ResamplerSpeaker::start_() {
   this->target_stream_info_ = audio::AudioStreamInfo(
@@ -185,7 +289,7 @@ esp_err_t ResamplerSpeaker::start_task_() {
   }
 
   if (this->task_handle_ == nullptr) {
-    this->task_handle_ = xTaskCreateStatic(resample_task, "sample", TASK_STACK_SIZE, (void *) this,
+    this->task_handle_ = xTaskCreateStatic(resample_task, "resampler", TASK_STACK_SIZE, (void *) this,
                                            RESAMPLER_TASK_PRIORITY, this->task_stack_buffer_, &this->task_stack_);
   }
 
@@ -196,43 +300,47 @@ esp_err_t ResamplerSpeaker::start_task_() {
   return ESP_OK;
 }
 
-void ResamplerSpeaker::stop() { this->state_ = speaker::STATE_STOPPING; }
+void ResamplerSpeaker::stop() { this->send_command_(ResamplingEventGroupBits::COMMAND_STOP); }
 
-void ResamplerSpeaker::stop_() {
+void ResamplerSpeaker::enter_stopping_state_() {
+  this->state_ = speaker::STATE_STOPPING;
+  this->state_start_ms_ = App.get_loop_component_start_time();
   if (this->task_handle_ != nullptr) {
-    xEventGroupSetBits(this->event_group_, ResamplingEventGroupBits::COMMAND_STOP);
+    xEventGroupSetBits(this->event_group_, ResamplingEventGroupBits::TASK_COMMAND_STOP);
   }
   this->output_speaker_->stop();
 }
 
-esp_err_t ResamplerSpeaker::delete_task_() {
-  if (!this->task_created_) {
+void ResamplerSpeaker::delete_task_() {
+  if (this->task_handle_ != nullptr) {
+    // Delete the suspended task
+    vTaskDelete(this->task_handle_);
     this->task_handle_ = nullptr;
-
-    if (this->task_stack_buffer_ != nullptr) {
-      if (this->task_stack_in_psram_) {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-        stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
-      } else {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-        stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
-      }
-
-      this->task_stack_buffer_ = nullptr;
-    }
-
-    return ESP_OK;
   }
 
-  return ESP_ERR_INVALID_STATE;
+  if (this->task_stack_buffer_ != nullptr) {
+    // Deallocate the task stack buffer
+    if (this->task_stack_in_psram_) {
+      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
+      stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
+    } else {
+      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
+      stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
+    }
+
+    this->task_stack_buffer_ = nullptr;
+  }
 }
 
-void ResamplerSpeaker::finish() { this->output_speaker_->finish(); }
+void ResamplerSpeaker::finish() { this->send_command_(ResamplingEventGroupBits::COMMAND_FINISH); }
 
 bool ResamplerSpeaker::has_buffered_data() const {
   bool has_ring_buffer_data = false;
-  if (this->requires_resampling_() && (this->ring_buffer_.use_count() > 0)) {
-    has_ring_buffer_data = (this->ring_buffer_.lock()->available() > 0);
+  if (this->requires_resampling_()) {
+    std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
+    if (temp_ring_buffer) {
+      has_ring_buffer_data = (temp_ring_buffer->available() > 0);
+    }
   }
   return (has_ring_buffer_data || this->output_speaker_->has_buffered_data());
 }
@@ -253,9 +361,8 @@ bool ResamplerSpeaker::requires_resampling_() const {
 }
 
 void ResamplerSpeaker::resample_task(void *params) {
-  ResamplerSpeaker *this_resampler = (ResamplerSpeaker *) params;
+  ResamplerSpeaker *this_resampler = static_cast<ResamplerSpeaker *>(params);
 
-  this_resampler->task_created_ = true;
   xEventGroupSetBits(this_resampler->event_group_, ResamplingEventGroupBits::STATE_STARTING);
 
   std::unique_ptr<audio::AudioResampler> resampler =
@@ -269,7 +376,7 @@ void ResamplerSpeaker::resample_task(void *params) {
     std::shared_ptr<RingBuffer> temp_ring_buffer =
         RingBuffer::create(this_resampler->audio_stream_info_.ms_to_bytes(this_resampler->buffer_duration_ms_));
 
-    if (temp_ring_buffer.use_count() == 0) {
+    if (!temp_ring_buffer) {
       err = ESP_ERR_NO_MEM;
     } else {
       this_resampler->ring_buffer_ = temp_ring_buffer;
@@ -291,7 +398,7 @@ void ResamplerSpeaker::resample_task(void *params) {
   while (err == ESP_OK) {
     uint32_t event_bits = xEventGroupGetBits(this_resampler->event_group_);
 
-    if (event_bits & ResamplingEventGroupBits::COMMAND_STOP) {
+    if (event_bits & ResamplingEventGroupBits::TASK_COMMAND_STOP) {
       break;
     }
 
@@ -310,8 +417,8 @@ void ResamplerSpeaker::resample_task(void *params) {
   xEventGroupSetBits(this_resampler->event_group_, ResamplingEventGroupBits::STATE_STOPPING);
   resampler.reset();
   xEventGroupSetBits(this_resampler->event_group_, ResamplingEventGroupBits::STATE_STOPPED);
-  this_resampler->task_created_ = false;
-  vTaskDelete(nullptr);
+
+  vTaskSuspend(nullptr);  // Suspend this task indefinitely until the loop method deletes it
 }
 
 }  // namespace resampler

esphome/components/resampler/speaker/resampler_speaker.h

@@ -8,14 +8,16 @@
 
 #include "esphome/core/component.h"
 
-#include <freertos/event_groups.h>
 #include <freertos/FreeRTOS.h>
+#include <freertos/event_groups.h>
 
 namespace esphome {
 namespace resampler {
 
 class ResamplerSpeaker : public Component, public speaker::Speaker {
  public:
+  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
+  void dump_config() override;
   void setup() override;
   void loop() override;
 
@@ -65,13 +67,18 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
   ///         ESP_ERR_INVALID_STATE if the task wasn't created
   esp_err_t start_task_();
 
-  /// @brief Stops the output speaker. If the resampling task is running, it sends the stop command.
-  void stop_();
+  /// @brief Transitions to STATE_STOPPING, records the stopping timestamp, sends the task stop command if the task is
+  /// running, and stops the output speaker.
+  void enter_stopping_state_();
 
-  /// @brief Deallocates the task stack and resets the pointers.
-  /// @return ESP_OK if successful
-  ///         ESP_ERR_INVALID_STATE if the task hasn't stopped itself
-  esp_err_t delete_task_();
+  /// @brief Sets the appropriate status error based on the start failure reason.
+  void set_start_error_(esp_err_t err);
+
+  /// @brief Deletes the resampler task if suspended, deallocates the task stack, and resets the related pointers.
+  void delete_task_();
+
+  /// @brief Sends a command via event group bits, enables the loop, and optionally wakes the main loop.
+  void send_command_(uint32_t command_bit, bool wake_loop = false);
 
   inline bool requires_resampling_() const;
   static void resample_task(void *params);
@@ -83,7 +90,7 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
   speaker::Speaker *output_speaker_{nullptr};
 
   bool task_stack_in_psram_{false};
-  bool task_created_{false};
+  bool waiting_for_output_{false};
 
   TaskHandle_t task_handle_{nullptr};
   StaticTask_t task_stack_;
@@ -98,6 +105,7 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
   uint32_t target_sample_rate_;
 
   uint32_t buffer_duration_ms_;
+  uint32_t state_start_ms_{0};
 
   uint64_t callback_remainder_{0};
 };

esphome/components/rf_bridge/rf_bridge.cpp

@@ -136,10 +136,10 @@ void RFBridgeComponent::loop() {
     this->last_bridge_byte_ = now;
   }
 
-  int avail = this->available();
+  size_t avail = this->available();
   while (avail > 0) {
     uint8_t buf[64];
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/seeed_mr24hpc1/seeed_mr24hpc1.cpp

@@ -107,10 +107,10 @@ void MR24HPC1Component::update_() {
 // main loop
 void MR24HPC1Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/seeed_mr60bha2/seeed_mr60bha2.cpp

@@ -31,10 +31,10 @@ void MR60BHA2Component::dump_config() {
 // main loop
 void MR60BHA2Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp

@@ -50,10 +50,10 @@ void MR60FDA2Component::setup() {
 // main loop
 void MR60FDA2Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/socket/bsd_sockets_impl.cpp

@@ -16,19 +16,13 @@ namespace esphome::socket {
 
 class BSDSocketImpl final : public Socket {
  public:
-  BSDSocketImpl(int fd, bool monitor_loop = false) : fd_(fd) {
-#ifdef USE_SOCKET_SELECT_SUPPORT
+  BSDSocketImpl(int fd, bool monitor_loop = false) {
+    this->fd_ = fd;
     // Register new socket with the application for select() if monitoring requested
     if (monitor_loop && this->fd_ >= 0) {
       // Only set loop_monitored_ to true if registration succeeds
       this->loop_monitored_ = App.register_socket_fd(this->fd_);
-    } else {
-      this->loop_monitored_ = false;
     }
-#else
-    // Without select support, ignore monitor_loop parameter
-    (void) monitor_loop;
-#endif
   }
   ~BSDSocketImpl() override {
     if (!this->closed_) {
@@ -52,12 +46,10 @@ class BSDSocketImpl final : public Socket {
   int bind(const struct sockaddr *addr, socklen_t addrlen) override { return ::bind(this->fd_, addr, addrlen); }
   int close() override {
     if (!this->closed_) {
-#ifdef USE_SOCKET_SELECT_SUPPORT
       // Unregister from select() before closing if monitored
       if (this->loop_monitored_) {
         App.unregister_socket_fd(this->fd_);
       }
-#endif
       int ret = ::close(this->fd_);
       this->closed_ = true;
       return ret;
@@ -130,23 +122,6 @@ class BSDSocketImpl final : public Socket {
     ::fcntl(this->fd_, F_SETFL, fl);
     return 0;
   }
-
-  int get_fd() const override { return this->fd_; }
-
-#ifdef USE_SOCKET_SELECT_SUPPORT
-  bool ready() const override {
-    if (!this->loop_monitored_)
-      return true;
-    return App.is_socket_ready(this->fd_);
-  }
-#endif
-
- protected:
-  int fd_;
-  bool closed_{false};
-#ifdef USE_SOCKET_SELECT_SUPPORT
-  bool loop_monitored_{false};
-#endif
 };
 
 // Helper to create a socket with optional monitoring

esphome/components/socket/lwip_raw_tcp_impl.cpp

@@ -452,6 +452,8 @@ class LWIPRawImpl : public Socket {
     errno = ENOSYS;
     return -1;
   }
+  bool ready() const override { return this->rx_buf_ != nullptr || this->rx_closed_ || this->pcb_ == nullptr; }
+
   int setblocking(bool blocking) final {
     if (pcb_ == nullptr) {
       errno = ECONNRESET;
@@ -576,6 +578,8 @@ class LWIPRawListenImpl final : public LWIPRawImpl {
     tcp_err(pcb_, LWIPRawImpl::s_err_fn);  // Use base class error handler
   }
 
+  bool ready() const override { return this->accepted_socket_count_ > 0; }
+
   std::unique_ptr<Socket> accept(struct sockaddr *addr, socklen_t *addrlen) override {
     if (pcb_ == nullptr) {
       errno = EBADF;

esphome/components/socket/lwip_sockets_impl.cpp

@@ -11,19 +11,13 @@ namespace esphome::socket {
 
 class LwIPSocketImpl final : public Socket {
  public:
-  LwIPSocketImpl(int fd, bool monitor_loop = false) : fd_(fd) {
-#ifdef USE_SOCKET_SELECT_SUPPORT
+  LwIPSocketImpl(int fd, bool monitor_loop = false) {
+    this->fd_ = fd;
     // Register new socket with the application for select() if monitoring requested
     if (monitor_loop && this->fd_ >= 0) {
       // Only set loop_monitored_ to true if registration succeeds
       this->loop_monitored_ = App.register_socket_fd(this->fd_);
-    } else {
-      this->loop_monitored_ = false;
     }
-#else
-    // Without select support, ignore monitor_loop parameter
-    (void) monitor_loop;
-#endif
   }
   ~LwIPSocketImpl() override {
     if (!this->closed_) {
@@ -49,12 +43,10 @@ class LwIPSocketImpl final : public Socket {
   int bind(const struct sockaddr *addr, socklen_t addrlen) override { return lwip_bind(this->fd_, addr, addrlen); }
   int close() override {
     if (!this->closed_) {
-#ifdef USE_SOCKET_SELECT_SUPPORT
       // Unregister from select() before closing if monitored
       if (this->loop_monitored_) {
         App.unregister_socket_fd(this->fd_);
       }
-#endif
       int ret = lwip_close(this->fd_);
       this->closed_ = true;
       return ret;
@@ -97,23 +89,6 @@ class LwIPSocketImpl final : public Socket {
     lwip_fcntl(this->fd_, F_SETFL, fl);
     return 0;
   }
-
-  int get_fd() const override { return this->fd_; }
-
-#ifdef USE_SOCKET_SELECT_SUPPORT
-  bool ready() const override {
-    if (!this->loop_monitored_)
-      return true;
-    return App.is_socket_ready(this->fd_);
-  }
-#endif
-
- protected:
-  int fd_;
-  bool closed_{false};
-#ifdef USE_SOCKET_SELECT_SUPPORT
-  bool loop_monitored_{false};
-#endif
 };
 
 // Helper to create a socket with optional monitoring

esphome/components/socket/socket.cpp

@@ -10,6 +10,10 @@ namespace esphome::socket {
 
 Socket::~Socket() {}
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+bool Socket::ready() const { return !this->loop_monitored_ || App.is_socket_ready_(this->fd_); }
+#endif
+
 // Platform-specific inet_ntop wrappers
 #if defined(USE_SOCKET_IMPL_LWIP_TCP)
 // LWIP raw TCP (ESP8266) uses inet_ntoa_r which takes struct by value

esphome/components/socket/socket.h

@@ -63,13 +63,29 @@ class Socket {
   virtual int setblocking(bool blocking) = 0;
   virtual int loop() { return 0; };
 
-  /// Get the underlying file descriptor (returns -1 if not supported)
-  virtual int get_fd() const { return -1; }
+    /// Get the underlying file descriptor (returns -1 if not supported)
+    /// Non-virtual: only one socket implementation is active per build.
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  int get_fd() const { return this->fd_; }
+#else
+  int get_fd() const { return -1; }
+#endif
 
   /// Check if socket has data ready to read
-  /// For loop-monitored sockets, checks with the Application's select() results
-  /// For non-monitored sockets, always returns true (assumes data may be available)
+  /// For select()-based sockets: non-virtual, checks Application's select() results
+  /// For LWIP raw TCP sockets: virtual, checks internal buffer state
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  bool ready() const;
+#else
   virtual bool ready() const { return true; }
+#endif
+
+ protected:
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  int fd_{-1};
+  bool closed_{false};
+  bool loop_monitored_{false};
+#endif
 };
 
 /// Create a socket of the given domain, type and protocol.

esphome/components/template/water_heater/__init__.py

@@ -3,6 +3,7 @@ import esphome.codegen as cg
 from esphome.components import water_heater
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_AWAY,
     CONF_ID,
     CONF_MODE,
     CONF_OPTIMISTIC,
@@ -18,6 +19,7 @@ from esphome.types import ConfigType
 from .. import template_ns
 
 CONF_CURRENT_TEMPERATURE = "current_temperature"
+CONF_IS_ON = "is_on"
 
 TemplateWaterHeater = template_ns.class_(
     "TemplateWaterHeater", cg.Component, water_heater.WaterHeater
@@ -51,6 +53,8 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_SUPPORTED_MODES): cv.ensure_list(
                 water_heater.validate_water_heater_mode
             ),
+            cv.Optional(CONF_AWAY): cv.returning_lambda,
+            cv.Optional(CONF_IS_ON): cv.returning_lambda,
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -98,6 +102,22 @@ async def to_code(config: ConfigType) -> None:
     if CONF_SUPPORTED_MODES in config:
         cg.add(var.set_supported_modes(config[CONF_SUPPORTED_MODES]))
 
+    if CONF_AWAY in config:
+        template_ = await cg.process_lambda(
+            config[CONF_AWAY],
+            [],
+            return_type=cg.optional.template(bool),
+        )
+        cg.add(var.set_away_lambda(template_))
+
+    if CONF_IS_ON in config:
+        template_ = await cg.process_lambda(
+            config[CONF_IS_ON],
+            [],
+            return_type=cg.optional.template(bool),
+        )
+        cg.add(var.set_is_on_lambda(template_))
+
 
 @automation.register_action(
     "water_heater.template.publish",
@@ -110,6 +130,8 @@ async def to_code(config: ConfigType) -> None:
             cv.Optional(CONF_MODE): cv.templatable(
                 water_heater.validate_water_heater_mode
             ),
+            cv.Optional(CONF_AWAY): cv.templatable(cv.boolean),
+            cv.Optional(CONF_IS_ON): cv.templatable(cv.boolean),
         }
     ),
 )
@@ -134,4 +156,12 @@ async def water_heater_template_publish_to_code(
         template_ = await cg.templatable(mode, args, water_heater.WaterHeaterMode)
         cg.add(var.set_mode(template_))
 
+    if CONF_AWAY in config:
+        template_ = await cg.templatable(config[CONF_AWAY], args, bool)
+        cg.add(var.set_away(template_))
+
+    if CONF_IS_ON in config:
+        template_ = await cg.templatable(config[CONF_IS_ON], args, bool)
+        cg.add(var.set_is_on(template_))
+
     return var

esphome/components/template/water_heater/automation.h

@@ -11,12 +11,15 @@ class TemplateWaterHeaterPublishAction : public Action<Ts...>, public Parented<T
   TEMPLATABLE_VALUE(float, current_temperature)
   TEMPLATABLE_VALUE(float, target_temperature)
   TEMPLATABLE_VALUE(water_heater::WaterHeaterMode, mode)
+  TEMPLATABLE_VALUE(bool, away)
+  TEMPLATABLE_VALUE(bool, is_on)
 
   void play(const Ts &...x) override {
     if (this->current_temperature_.has_value()) {
       this->parent_->set_current_temperature(this->current_temperature_.value(x...));
     }
-    bool needs_call = this->target_temperature_.has_value() || this->mode_.has_value();
+    bool needs_call = this->target_temperature_.has_value() || this->mode_.has_value() || this->away_.has_value() ||
+                      this->is_on_.has_value();
     if (needs_call) {
       auto call = this->parent_->make_call();
       if (this->target_temperature_.has_value()) {
@@ -25,6 +28,12 @@ class TemplateWaterHeaterPublishAction : public Action<Ts...>, public Parented<T
       if (this->mode_.has_value()) {
         call.set_mode(this->mode_.value(x...));
       }
+      if (this->away_.has_value()) {
+        call.set_away(this->away_.value(x...));
+      }
+      if (this->is_on_.has_value()) {
+        call.set_on(this->is_on_.value(x...));
+      }
       call.perform();
     } else {
       this->parent_->publish_state();

esphome/components/template/water_heater/template_water_heater.cpp

@@ -17,7 +17,7 @@ void TemplateWaterHeater::setup() {
     }
   }
   if (!this->current_temperature_f_.has_value() && !this->target_temperature_f_.has_value() &&
-      !this->mode_f_.has_value())
+      !this->mode_f_.has_value() && !this->away_f_.has_value() && !this->is_on_f_.has_value())
     this->disable_loop();
 }
 
@@ -32,6 +32,12 @@ water_heater::WaterHeaterTraits TemplateWaterHeater::traits() {
   if (this->target_temperature_f_.has_value()) {
     traits.add_feature_flags(water_heater::WATER_HEATER_SUPPORTS_TARGET_TEMPERATURE);
   }
+  if (this->away_f_.has_value()) {
+    traits.set_supports_away_mode(true);
+  }
+  if (this->is_on_f_.has_value()) {
+    traits.add_feature_flags(water_heater::WATER_HEATER_SUPPORTS_ON_OFF);
+  }
   return traits;
 }
 
@@ -62,6 +68,22 @@ void TemplateWaterHeater::loop() {
     }
   }
 
+  auto away = this->away_f_.call();
+  if (away.has_value()) {
+    if (*away != this->is_away()) {
+      this->set_state_flag_(water_heater::WATER_HEATER_STATE_AWAY, *away);
+      changed = true;
+    }
+  }
+
+  auto is_on = this->is_on_f_.call();
+  if (is_on.has_value()) {
+    if (*is_on != this->is_on()) {
+      this->set_state_flag_(water_heater::WATER_HEATER_STATE_ON, *is_on);
+      changed = true;
+    }
+  }
+
   if (changed) {
     this->publish_state();
   }
@@ -90,6 +112,17 @@ void TemplateWaterHeater::control(const water_heater::WaterHeaterCall &call) {
     }
   }
 
+  if (call.get_away().has_value()) {
+    if (this->optimistic_) {
+      this->set_state_flag_(water_heater::WATER_HEATER_STATE_AWAY, *call.get_away());
+    }
+  }
+  if (call.get_on().has_value()) {
+    if (this->optimistic_) {
+      this->set_state_flag_(water_heater::WATER_HEATER_STATE_ON, *call.get_on());
+    }
+  }
+
   this->set_trigger_.trigger();
 
   if (this->optimistic_) {

esphome/components/template/water_heater/template_water_heater.h

@@ -24,6 +24,8 @@ class TemplateWaterHeater : public Component, public water_heater::WaterHeater {
     this->target_temperature_f_.set(std::forward<F>(f));
   }
   template<typename F> void set_mode_lambda(F &&f) { this->mode_f_.set(std::forward<F>(f)); }
+  template<typename F> void set_away_lambda(F &&f) { this->away_f_.set(std::forward<F>(f)); }
+  template<typename F> void set_is_on_lambda(F &&f) { this->is_on_f_.set(std::forward<F>(f)); }
 
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
   void set_restore_mode(TemplateWaterHeaterRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
@@ -49,6 +51,8 @@ class TemplateWaterHeater : public Component, public water_heater::WaterHeater {
   TemplateLambda<float> current_temperature_f_;
   TemplateLambda<float> target_temperature_f_;
   TemplateLambda<water_heater::WaterHeaterMode> mode_f_;
+  TemplateLambda<bool> away_f_;
+  TemplateLambda<bool> is_on_f_;
   TemplateWaterHeaterRestoreMode restore_mode_{WATER_HEATER_NO_RESTORE};
   water_heater::WaterHeaterModeMask supported_modes_;
   bool optimistic_{true};

esphome/components/tormatic/tormatic_cover.cpp

@@ -251,7 +251,7 @@ void Tormatic::stop_at_target_() {
 // Read a GateStatus from the unit. The unit only sends messages in response to
 // status requests or commands, so a message needs to be sent first.
 optional<GateStatus> Tormatic::read_gate_status_() {
-  if (this->available() < static_cast<int>(sizeof(MessageHeader))) {
+  if (this->available() < sizeof(MessageHeader)) {
     return {};
   }
 

esphome/components/tuya/tuya.cpp

@@ -32,10 +32,10 @@ void Tuya::setup() {
 
 void Tuya::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  int avail = this->available();
+  size_t avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+    size_t to_read = std::min(avail, sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/uart/uart.cpp

@@ -3,12 +3,16 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include <cinttypes>
 
 namespace esphome::uart {
 
 static const char *const TAG = "uart";
 
+// UART parity strings indexed by UARTParityOptions enum (0-2): NONE, EVEN, ODD
+PROGMEM_STRING_TABLE(UARTParityStrings, "NONE", "EVEN", "ODD", "UNKNOWN");
+
 void UARTDevice::check_uart_settings(uint32_t baud_rate, uint8_t stop_bits, UARTParityOptions parity,
                                      uint8_t data_bits) {
   if (this->parent_->get_baud_rate() != baud_rate) {
@@ -30,16 +34,7 @@ void UARTDevice::check_uart_settings(uint32_t baud_rate, uint8_t stop_bits, UART
 }
 
 const LogString *parity_to_str(UARTParityOptions parity) {
-  switch (parity) {
-    case UART_CONFIG_PARITY_NONE:
-      return LOG_STR("NONE");
-    case UART_CONFIG_PARITY_EVEN:
-      return LOG_STR("EVEN");
-    case UART_CONFIG_PARITY_ODD:
-      return LOG_STR("ODD");
-    default:
-      return LOG_STR("UNKNOWN");
-  }
+  return UARTParityStrings::get_log_str(static_cast<uint8_t>(parity), UARTParityStrings::LAST_INDEX);
 }
 
 }  // namespace esphome::uart

esphome/components/uart/uart.h

@@ -43,7 +43,7 @@ class UARTDevice {
     return res;
   }
 
-  int available() { return this->parent_->available(); }
+  size_t available() { return this->parent_->available(); }
 
   void flush() { this->parent_->flush(); }
 

esphome/components/uart/uart_component.cpp

@@ -5,13 +5,13 @@ namespace esphome::uart {
 static const char *const TAG = "uart";
 
 bool UARTComponent::check_read_timeout_(size_t len) {
-  if (this->available() >= int(len))
+  if (this->available() >= len)
     return true;
 
   uint32_t start_time = millis();
-  while (this->available() < int(len)) {
+  while (this->available() < len) {
     if (millis() - start_time > 100) {
-      ESP_LOGE(TAG, "Reading from UART timed out at byte %u!", this->available());
+      ESP_LOGE(TAG, "Reading from UART timed out at byte %zu!", this->available());
       return false;
     }
     yield();

esphome/components/uart/uart_component.h

@@ -69,7 +69,7 @@ class UARTComponent {
 
   // Pure virtual method to return the number of bytes available for reading.
   // @return Number of available bytes.
-  virtual int available() = 0;
+  virtual size_t available() = 0;
 
   // Pure virtual method to block until all bytes have been written to the UART bus.
   virtual void flush() = 0;

esphome/components/uart/uart_component_esp8266.cpp

@@ -206,7 +206,7 @@ bool ESP8266UartComponent::read_array(uint8_t *data, size_t len) {
 #endif
   return true;
 }
-int ESP8266UartComponent::available() {
+size_t ESP8266UartComponent::available() {
   if (this->hw_serial_ != nullptr) {
     return this->hw_serial_->available();
   } else {
@@ -329,11 +329,14 @@ uint8_t ESP8266SoftwareSerial::peek_byte() {
 void ESP8266SoftwareSerial::flush() {
   // Flush is a NO-OP with software serial, all bytes are written immediately.
 }
-int ESP8266SoftwareSerial::available() {
-  int avail = int(this->rx_in_pos_) - int(this->rx_out_pos_);
-  if (avail < 0)
-    return avail + this->rx_buffer_size_;
-  return avail;
+size_t ESP8266SoftwareSerial::available() {
+  // Read volatile rx_in_pos_ once to avoid TOCTOU race with ISR.
+  // When in >= out, data is contiguous: [out..in).
+  // When in < out, data wraps: [out..buf_size) + [0..in).
+  size_t in = this->rx_in_pos_;
+  if (in >= this->rx_out_pos_)
+    return in - this->rx_out_pos_;
+  return this->rx_buffer_size_ - this->rx_out_pos_ + in;
 }
 
 }  // namespace esphome::uart

esphome/components/uart/uart_component_esp8266.h

@@ -23,7 +23,7 @@ class ESP8266SoftwareSerial {
 
   void write_byte(uint8_t data);
 
-  int available();
+  size_t available();
 
  protected:
   static void gpio_intr(ESP8266SoftwareSerial *arg);
@@ -57,7 +57,7 @@ class ESP8266UartComponent : public UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
 
-  int available() override;
+  size_t available() override;
   void flush() override;
 
   uint32_t get_config();

esphome/components/uart/uart_component_esp_idf.cpp

@@ -338,7 +338,7 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   return read_len == (int32_t) length_to_read;
 }
 
-int IDFUARTComponent::available() {
+size_t IDFUARTComponent::available() {
   size_t available = 0;
   esp_err_t err;
 

esphome/components/uart/uart_component_esp_idf.h

@@ -22,7 +22,7 @@ class IDFUARTComponent : public UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
 
-  int available() override;
+  size_t available() override;
   void flush() override;
 
   uint8_t get_hw_serial_number() { return this->uart_num_; }

esphome/components/uart/uart_component_host.cpp

@@ -265,7 +265,7 @@ bool HostUartComponent::read_array(uint8_t *data, size_t len) {
   return true;
 }
 
-int HostUartComponent::available() {
+size_t HostUartComponent::available() {
   if (this->file_descriptor_ == -1) {
     return 0;
   }
@@ -275,9 +275,10 @@ int HostUartComponent::available() {
     this->update_error_(strerror(errno));
     return 0;
   }
+  size_t result = available;
   if (this->has_peek_)
-    available++;
-  return available;
+    result++;
+  return result;
 };
 
 void HostUartComponent::flush() {

esphome/components/uart/uart_component_host.h

@@ -17,7 +17,7 @@ class HostUartComponent : public UARTComponent, public Component {
   void write_array(const uint8_t *data, size_t len) override;
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
-  int available() override;
+  size_t available() override;
   void flush() override;
   void set_name(std::string port_name) { port_name_ = port_name; };
 

esphome/components/uart/uart_component_libretiny.cpp

@@ -169,7 +169,7 @@ bool LibreTinyUARTComponent::read_array(uint8_t *data, size_t len) {
   return true;
 }
 
-int LibreTinyUARTComponent::available() { return this->serial_->available(); }
+size_t LibreTinyUARTComponent::available() { return this->serial_->available(); }
 void LibreTinyUARTComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
   this->serial_->flush();

esphome/components/uart/uart_component_libretiny.h

@@ -21,7 +21,7 @@ class LibreTinyUARTComponent : public UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
 
-  int available() override;
+  size_t available() override;
   void flush() override;
 
   uint16_t get_config();

esphome/components/uart/uart_component_rp2040.cpp

@@ -186,7 +186,7 @@ bool RP2040UartComponent::read_array(uint8_t *data, size_t len) {
 #endif
   return true;
 }
-int RP2040UartComponent::available() { return this->serial_->available(); }
+size_t RP2040UartComponent::available() { return this->serial_->available(); }
 void RP2040UartComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
   this->serial_->flush();

esphome/components/uart/uart_component_rp2040.h

@@ -24,7 +24,7 @@ class RP2040UartComponent : public UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
 
-  int available() override;
+  size_t available() override;
   void flush() override;
 
   uint16_t get_config();

esphome/components/usb_cdc_acm/usb_cdc_acm.h

@@ -81,7 +81,7 @@ class USBCDCACMInstance : public uart::UARTComponent, public Parented<USBCDCACMC
   void write_array(const uint8_t *data, size_t len) override;
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
-  int available() override;
+  size_t available() override;
   void flush() override;
 
  protected:

esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp

@@ -318,12 +318,12 @@ bool USBCDCACMInstance::read_array(uint8_t *data, size_t len) {
   return bytes_read == original_len;
 }
 
-int USBCDCACMInstance::available() {
+size_t USBCDCACMInstance::available() {
   UBaseType_t waiting = 0;
   if (this->usb_rx_ringbuf_ != nullptr) {
     vRingbufferGetInfo(this->usb_rx_ringbuf_, nullptr, nullptr, nullptr, nullptr, &waiting);
   }
-  return static_cast<int>(waiting) + (this->has_peek_ ? 1 : 0);
+  return waiting + (this->has_peek_ ? 1 : 0);
 }
 
 void USBCDCACMInstance::flush() {

esphome/components/usb_uart/usb_uart.h

@@ -97,7 +97,7 @@ class USBUartChannel : public uart::UARTComponent, public Parented<USBUartCompon
   bool peek_byte(uint8_t *data) override;
   ;
   bool read_array(uint8_t *data, size_t len) override;
-  int available() override { return static_cast<int>(this->input_buffer_.get_available()); }
+  size_t available() override { return this->input_buffer_.get_available(); }
   void flush() override {}
   void check_logger_conflict() override {}
   void set_parity(UARTParityOptions parity) { this->parity_ = parity; }

esphome/components/voice_assistant/__init__.py

@@ -371,7 +371,12 @@ async def to_code(config):
     if on_timer_tick := config.get(CONF_ON_TIMER_TICK):
         await automation.build_automation(
             var.get_timer_tick_trigger(),
-            [(cg.std_vector.template(Timer), "timers")],
+            [
+                (
+                    cg.std_vector.template(Timer).operator("const").operator("ref"),
+                    "timers",
+                )
+            ],
             on_timer_tick,
         )
         has_timers = True

esphome/components/voice_assistant/voice_assistant.cpp

@@ -430,12 +430,14 @@ void VoiceAssistant::client_subscription(api::APIConnection *client, bool subscr
   }
 
   if (this->api_client_ != nullptr) {
+    char current_peername[socket::SOCKADDR_STR_LEN];
+    char new_peername[socket::SOCKADDR_STR_LEN];
     ESP_LOGE(TAG,
              "Multiple API Clients attempting to connect to Voice Assistant\n"
              "Current client: %s (%s)\n"
              "New client: %s (%s)",
-             this->api_client_->get_name(), this->api_client_->get_peername(), client->get_name(),
-             client->get_peername());
+             this->api_client_->get_name(), this->api_client_->get_peername_to(current_peername), client->get_name(),
+             client->get_peername_to(new_peername));
     return;
   }
 
@@ -859,35 +861,43 @@ void VoiceAssistant::on_audio(const api::VoiceAssistantAudio &msg) {
 }
 
 void VoiceAssistant::on_timer_event(const api::VoiceAssistantTimerEventResponse &msg) {
-  Timer timer = {
-      .id = msg.timer_id,
-      .name = msg.name,
-      .total_seconds = msg.total_seconds,
-      .seconds_left = msg.seconds_left,
-      .is_active = msg.is_active,
-  };
-  this->timers_[timer.id] = timer;
+  // Find existing timer or add a new one
+  auto it = this->timers_.begin();
+  for (; it != this->timers_.end(); ++it) {
+    if (it->id == msg.timer_id)
+      break;
+  }
+  if (it == this->timers_.end()) {
+    this->timers_.push_back({});
+    it = this->timers_.end() - 1;
+  }
+  it->id = msg.timer_id;
+  it->name = msg.name;
+  it->total_seconds = msg.total_seconds;
+  it->seconds_left = msg.seconds_left;
+  it->is_active = msg.is_active;
+
   char timer_buf[Timer::TO_STR_BUFFER_SIZE];
   ESP_LOGD(TAG,
            "Timer Event\n"
            "  Type: %" PRId32 "\n"
            "  %s",
-           msg.event_type, timer.to_str(timer_buf));
+           msg.event_type, it->to_str(timer_buf));
 
   switch (msg.event_type) {
     case api::enums::VOICE_ASSISTANT_TIMER_STARTED:
-      this->timer_started_trigger_.trigger(timer);
+      this->timer_started_trigger_.trigger(*it);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_UPDATED:
-      this->timer_updated_trigger_.trigger(timer);
+      this->timer_updated_trigger_.trigger(*it);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_CANCELLED:
-      this->timer_cancelled_trigger_.trigger(timer);
-      this->timers_.erase(timer.id);
+      this->timer_cancelled_trigger_.trigger(*it);
+      this->timers_.erase(it);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_FINISHED:
-      this->timer_finished_trigger_.trigger(timer);
-      this->timers_.erase(timer.id);
+      this->timer_finished_trigger_.trigger(*it);
+      this->timers_.erase(it);
       break;
   }
 
@@ -901,16 +911,12 @@ void VoiceAssistant::on_timer_event(const api::VoiceAssistantTimerEventResponse
 }
 
 void VoiceAssistant::timer_tick_() {
-  std::vector<Timer> res;
-  res.reserve(this->timers_.size());
-  for (auto &pair : this->timers_) {
-    auto &timer = pair.second;
+  for (auto &timer : this->timers_) {
     if (timer.is_active && timer.seconds_left > 0) {
       timer.seconds_left--;
     }
-    res.push_back(timer);
   }
-  this->timer_tick_trigger_.trigger(res);
+  this->timer_tick_trigger_.trigger(this->timers_);
 }
 
 void VoiceAssistant::on_announce(const api::VoiceAssistantAnnounceRequest &msg) {

esphome/components/voice_assistant/voice_assistant.h

@@ -24,7 +24,6 @@
 #include "esphome/components/socket/socket.h"
 
 #include <span>
-#include <unordered_map>
 #include <vector>
 
 namespace esphome {
@@ -226,9 +225,9 @@ class VoiceAssistant : public Component {
   Trigger<Timer> *get_timer_updated_trigger() { return &this->timer_updated_trigger_; }
   Trigger<Timer> *get_timer_cancelled_trigger() { return &this->timer_cancelled_trigger_; }
   Trigger<Timer> *get_timer_finished_trigger() { return &this->timer_finished_trigger_; }
-  Trigger<std::vector<Timer>> *get_timer_tick_trigger() { return &this->timer_tick_trigger_; }
+  Trigger<const std::vector<Timer> &> *get_timer_tick_trigger() { return &this->timer_tick_trigger_; }
   void set_has_timers(bool has_timers) { this->has_timers_ = has_timers; }
-  const std::unordered_map<std::string, Timer> &get_timers() const { return this->timers_; }
+  const std::vector<Timer> &get_timers() const { return this->timers_; }
 
  protected:
   bool allocate_buffers_();
@@ -267,13 +266,13 @@ class VoiceAssistant : public Component {
 
   api::APIConnection *api_client_{nullptr};
 
-  std::unordered_map<std::string, Timer> timers_;
+  std::vector<Timer> timers_;
   void timer_tick_();
   Trigger<Timer> timer_started_trigger_;
   Trigger<Timer> timer_finished_trigger_;
   Trigger<Timer> timer_updated_trigger_;
   Trigger<Timer> timer_cancelled_trigger_;
-  Trigger<std::vector<Timer>> timer_tick_trigger_;
+  Trigger<const std::vector<Timer> &> timer_tick_trigger_;
   bool has_timers_{false};
   bool timer_tick_running_{false};
 

esphome/components/water_heater/water_heater.h

@@ -90,9 +90,22 @@ class WaterHeaterCall {
   float get_target_temperature_low() const { return this->target_temperature_low_; }
   float get_target_temperature_high() const { return this->target_temperature_high_; }
   /// Get state flags value
+  ESPDEPRECATED("get_state() is deprecated, use get_away() and get_on() instead. (Removed in 2026.8.0)", "2026.2.0")
   uint32_t get_state() const { return this->state_; }
-  /// Get mask of state flags that are being changed
-  uint32_t get_state_mask() const { return this->state_mask_; }
+
+  optional<bool> get_away() const {
+    if (this->state_mask_ & WATER_HEATER_STATE_AWAY) {
+      return (this->state_ & WATER_HEATER_STATE_AWAY) != 0;
+    }
+    return {};
+  }
+
+  optional<bool> get_on() const {
+    if (this->state_mask_ & WATER_HEATER_STATE_ON) {
+      return (this->state_ & WATER_HEATER_STATE_ON) != 0;
+    }
+    return {};
+  }
 
  protected:
   void validate_();

esphome/components/weikai/weikai.cpp

@@ -401,7 +401,7 @@ bool WeikaiChannel::peek_byte(uint8_t *buffer) {
   return this->receive_buffer_.peek(*buffer);
 }
 
-int WeikaiChannel::available() {
+size_t WeikaiChannel::available() {
   size_t available = this->receive_buffer_.count();
   if (!available)
     available = xfer_fifo_to_buffer_();

esphome/components/weikai/weikai.h

@@ -374,7 +374,7 @@ class WeikaiChannel : public uart::UARTComponent {
 
   /// @brief Returns the number of bytes in the receive buffer
   /// @return the number of bytes available in the receiver fifo
-  int available() override;
+  size_t available() override;
 
   /// @brief Flush the output fifo.
   /// @details If we refer to Serial.flush() in Arduino it says: ** Waits for the transmission of outgoing serial data

esphome/components/wifi/wpa2_eap.py

@@ -71,11 +71,9 @@ def _validate_load_certificate(value):
 
 
 def validate_certificate(value):
-    # _validate_load_certificate already calls cv.file_() internally,
-    # but returns the parsed certificate object.  We re-call cv.file_()
-    # to get the resolved path string that the bundle walker can discover.
     _validate_load_certificate(value)
-    return str(cv.file_(value))
+    # Validation result should be the path, not the loaded certificate
+    return value
 
 
 def _validate_load_private_key(key, cert_pw):