Merge branch 'dev' into esphome_build_server

.clang-tidy.hash

@@ -1 +1 @@
-74867fc82764102ce1275ea2bc43e3aeee7619679537c6db61114a33342bb4c7
+37ec8d5a343c8d0a485fd2118cbdabcbccd7b9bca197e4a392be75087974dced

.github/actions/build-image/action.yaml

@@ -47,7 +47,7 @@ runs:
 
     - name: Build and push to ghcr by digest
       id: build-ghcr
-      uses: docker/build-push-action@601a80b39c9405e50806ae38af30926f9d957c47 # v6.19.1
+      uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false
@@ -73,7 +73,7 @@ runs:
 
     - name: Build and push to dockerhub by digest
       id: build-dockerhub
-      uses: docker/build-push-action@601a80b39c9405e50806ae38af30926f9d957c47 # v6.19.1
+      uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false

CODEOWNERS

@@ -429,7 +429,6 @@ esphome/components/sen21231/* @shreyaskarnik
 esphome/components/sen5x/* @martgras
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
-esphome/components/serial_proxy/* @kbx81
 esphome/components/sfa30/* @ghsensdev
 esphome/components/sgp40/* @SenexCrenshaw
 esphome/components/sgp4x/* @martgras @SenexCrenshaw

docker/Dockerfile

@@ -23,7 +23,7 @@ RUN if command -v apk > /dev/null; then \
 
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1
 
-RUN pip install --no-cache-dir -U pip uv==0.10.1
+RUN pip install --no-cache-dir -U pip uv==0.6.14
 
 COPY requirements.txt /
 

esphome/__main__.py

@@ -965,6 +965,38 @@ 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
 
@@ -1242,6 +1274,7 @@ POST_CONFIG_ACTIONS = {
     "rename": command_rename,
     "discover": command_discover,
     "analyze-memory": command_analyze_memory,
+    "bundle": command_bundle,
 }
 
 SIMPLE_CONFIG_ACTIONS = [
@@ -1545,6 +1578,24 @@ 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>.
     #
@@ -1623,6 +1674,16 @@ 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

@@ -0,0 +1,699 @@
+"""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

@@ -69,12 +69,6 @@ service APIConnection {
   rpc zwave_proxy_request(ZWaveProxyRequest) returns (void) {}
 
   rpc infrared_rf_transmit_raw_timings(InfraredRFTransmitRawTimingsRequest) returns (void) {}
-
-  rpc serial_proxy_configure(SerialProxyConfigureRequest) returns (void) {}
-  rpc serial_proxy_write(SerialProxyWriteRequest) returns (void) {}
-  rpc serial_proxy_set_modem_pins(SerialProxySetModemPinsRequest) returns (void) {}
-  rpc serial_proxy_get_modem_pins(SerialProxyGetModemPinsRequest) returns (void) {}
-  rpc serial_proxy_flush(SerialProxyFlushRequest) returns (void) {}
 }
 
 
@@ -266,9 +260,6 @@ message DeviceInfoResponse {
   // Indicates if Z-Wave proxy support is available and features supported
   uint32 zwave_proxy_feature_flags = 23 [(field_ifdef) = "USE_ZWAVE_PROXY"];
   uint32 zwave_home_id = 24 [(field_ifdef) = "USE_ZWAVE_PROXY"];
-
-  // Number of serial proxy instances available on the device
-  uint32 serial_proxy_count = 25 [(field_ifdef) = "USE_SERIAL_PROXY"];
 }
 
 message ListEntitiesRequest {
@@ -1164,11 +1155,9 @@ 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 [deprecated=true];
+  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;
 }
 
 message WaterHeaterCommandRequest {
@@ -2497,87 +2486,3 @@ message InfraredRFReceiveEvent {
   fixed32 key = 2;                                    // Key identifying the receiver instance
   repeated sint32 timings = 3 [packed = true, (container_pointer_no_template) = "std::vector<int32_t>"];  // Raw timings in microseconds (zigzag-encoded): alternating mark/space periods
 }
-
-// ==================== SERIAL PROXY ====================
-
-enum SerialProxyParity {
-  SERIAL_PROXY_PARITY_NONE = 0;
-  SERIAL_PROXY_PARITY_EVEN = 1;
-  SERIAL_PROXY_PARITY_ODD = 2;
-}
-
-// Configure UART parameters for a serial proxy instance
-message SerialProxyConfigureRequest {
-  option (id) = 138;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_SERIAL_PROXY";
-
-  uint32 instance = 1;          // Instance index (0-based)
-  uint32 baudrate = 2;          // Baud rate in bits per second
-  bool flow_control = 3;        // Enable hardware flow control
-  SerialProxyParity parity = 4; // Parity setting
-  uint32 stop_bits = 5;         // Number of stop bits (1 or 2)
-  uint32 data_size = 6;         // Number of data bits (5-8)
-}
-
-// Data received from a serial device, forwarded to clients
-message SerialProxyDataReceived {
-  option (id) = 139;
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_SERIAL_PROXY";
-  option (no_delay) = true;
-
-  uint32 instance = 1;          // Instance index (0-based)
-  bytes data = 2;               // Raw data received from the serial device
-}
-
-// Write data to a serial device
-message SerialProxyWriteRequest {
-  option (id) = 140;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_SERIAL_PROXY";
-  option (no_delay) = true;
-
-  uint32 instance = 1;          // Instance index (0-based)
-  bytes data = 2;               // Raw data to write to the serial device
-}
-
-// Set modem control pin states (RTS and DTR)
-message SerialProxySetModemPinsRequest {
-  option (id) = 141;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_SERIAL_PROXY";
-
-  uint32 instance = 1;          // Instance index (0-based)
-  bool rts = 2;                 // Desired RTS pin state
-  bool dtr = 3;                 // Desired DTR pin state
-}
-
-// Request current modem control pin states
-message SerialProxyGetModemPinsRequest {
-  option (id) = 142;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_SERIAL_PROXY";
-
-  uint32 instance = 1;          // Instance index (0-based)
-}
-
-// Response with current modem control pin states
-message SerialProxyGetModemPinsResponse {
-  option (id) = 143;
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_SERIAL_PROXY";
-
-  uint32 instance = 1;          // Instance index (0-based)
-  bool rts = 2;                 // Current RTS pin state
-  bool dtr = 3;                 // Current DTR pin state
-}
-
-// Flush the serial port (block until all TX data is sent)
-message SerialProxyFlushRequest {
-  option (id) = 144;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_SERIAL_PROXY";
-
-  uint32 instance = 1;          // Instance index (0-based)
-}

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
-  char peername[socket::SOCKADDR_STR_LEN];
-  this->helper_->set_client_name(this->helper_->get_peername_to(peername), strlen(peername));
+  const char *peername = this->helper_->get_client_peername();
+  this->helper_->set_client_name(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 - don't close socket here, let APIServer::loop() do it
-    // so getpeername() still works for the disconnect trigger
+    // requested a disconnect
+    this->helper_->close();
     this->flags_.remove = true;
     return;
   }
@@ -219,8 +219,35 @@ void APIConnection::loop() {
     this->process_batch_();
   }
 
-  if (this->active_iterator_ != ActiveIterator::NONE) {
-    this->process_active_iterator_();
+  switch (this->active_iterator_) {
+    case ActiveIterator::LIST_ENTITIES:
+      if (this->iterator_storage_.list_entities.completed()) {
+        this->destroy_active_iterator_();
+        if (this->flags_.state_subscription) {
+          this->begin_iterator_(ActiveIterator::INITIAL_STATE);
+        }
+      } else {
+        this->process_iterator_batch_(this->iterator_storage_.list_entities);
+      }
+      break;
+    case ActiveIterator::INITIAL_STATE:
+      if (this->iterator_storage_.initial_state.completed()) {
+        this->destroy_active_iterator_();
+        // Process any remaining batched messages immediately
+        if (!this->deferred_batch_.empty()) {
+          this->process_batch_();
+        }
+        // Now that everything is sent, enable immediate sending for future state changes
+        this->flags_.should_try_send_immediately = true;
+        // Release excess memory from buffers that grew during initial sync
+        this->deferred_batch_.release_buffer();
+        this->helper_->release_buffers();
+      } else {
+        this->process_iterator_batch_(this->iterator_storage_.initial_state);
+      }
+      break;
+    case ActiveIterator::NONE:
+      break;
   }
 
   if (this->flags_.sent_ping) {
@@ -256,49 +283,6 @@ void APIConnection::loop() {
 #endif
 }
 
-void APIConnection::process_active_iterator_() {
-  // Caller ensures active_iterator_ != NONE
-  if (this->active_iterator_ == ActiveIterator::LIST_ENTITIES) {
-    if (this->iterator_storage_.list_entities.completed()) {
-      this->destroy_active_iterator_();
-      if (this->flags_.state_subscription) {
-        this->begin_iterator_(ActiveIterator::INITIAL_STATE);
-      }
-    } else {
-      this->process_iterator_batch_(this->iterator_storage_.list_entities);
-    }
-  } else {  // INITIAL_STATE
-    if (this->iterator_storage_.initial_state.completed()) {
-      this->destroy_active_iterator_();
-      // Process any remaining batched messages immediately
-      if (!this->deferred_batch_.empty()) {
-        this->process_batch_();
-      }
-      // Now that everything is sent, enable immediate sending for future state changes
-      this->flags_.should_try_send_immediately = true;
-      // Release excess memory from buffers that grew during initial sync
-      this->deferred_batch_.release_buffer();
-      this->helper_->release_buffers();
-    } else {
-      this->process_iterator_batch_(this->iterator_storage_.initial_state);
-    }
-  }
-}
-
-void APIConnection::process_iterator_batch_(ComponentIterator &iterator) {
-  size_t initial_size = this->deferred_batch_.size();
-  size_t max_batch = this->get_max_batch_size_();
-  while (!iterator.completed() && (this->deferred_batch_.size() - initial_size) < max_batch) {
-    iterator.advance();
-  }
-
-  // If the batch is full, process it immediately
-  // Note: iterator.advance() already calls schedule_batch_() via schedule_message_()
-  if (this->deferred_batch_.size() >= max_batch) {
-    this->process_batch_();
-  }
-}
-
 bool APIConnection::send_disconnect_response_() {
   // remote initiated disconnect_client
   // don't close yet, we still need to send the disconnect response
@@ -309,8 +293,7 @@ bool APIConnection::send_disconnect_response_() {
   return this->send_message(resp, DisconnectResponse::MESSAGE_TYPE);
 }
 void APIConnection::on_disconnect_response() {
-  // Don't close socket here, let APIServer::loop() do it
-  // so getpeername() still works for the disconnect trigger
+  this->helper_->close();
   this->flags_.remove = true;
 }
 
@@ -1360,12 +1343,8 @@ 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_AWAY_STATE) ||
-      (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_STATE)) {
+  if (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();
@@ -1413,66 +1392,6 @@ void APIConnection::send_infrared_rf_receive_event(const InfraredRFReceiveEvent
 }
 #endif
 
-#ifdef USE_SERIAL_PROXY
-void APIConnection::on_serial_proxy_configure_request(const SerialProxyConfigureRequest &msg) {
-  auto &proxies = App.get_serial_proxies();
-  if (msg.instance >= proxies.size()) {
-    ESP_LOGW(TAG, "Serial proxy instance %u out of range (max %u)", msg.instance,
-             static_cast<uint32_t>(proxies.size()));
-    return;
-  }
-  proxies[msg.instance]->configure(msg.baudrate, msg.flow_control, static_cast<uint8_t>(msg.parity), msg.stop_bits,
-                                   msg.data_size);
-}
-
-void APIConnection::on_serial_proxy_write_request(const SerialProxyWriteRequest &msg) {
-  auto &proxies = App.get_serial_proxies();
-  if (msg.instance >= proxies.size()) {
-    ESP_LOGW(TAG, "Serial proxy instance %u out of range", msg.instance);
-    return;
-  }
-  proxies[msg.instance]->write(msg.data, msg.data_len);
-}
-
-void APIConnection::on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &msg) {
-  auto &proxies = App.get_serial_proxies();
-  if (msg.instance >= proxies.size()) {
-    ESP_LOGW(TAG, "Serial proxy instance %u out of range", msg.instance);
-    return;
-  }
-  proxies[msg.instance]->set_modem_pins(msg.rts, msg.dtr);
-}
-
-void APIConnection::on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg) {
-  auto &proxies = App.get_serial_proxies();
-  if (msg.instance >= proxies.size()) {
-    ESP_LOGW(TAG, "Serial proxy instance %u out of range", msg.instance);
-    return;
-  }
-  bool rts, dtr;
-  proxies[msg.instance]->get_modem_pins(rts, dtr);
-
-  SerialProxyGetModemPinsResponse resp{};
-  resp.instance = msg.instance;
-  resp.rts = rts;
-  resp.dtr = dtr;
-  this->send_message(resp, SerialProxyGetModemPinsResponse::MESSAGE_TYPE);
-}
-
-void APIConnection::on_serial_proxy_flush_request(const SerialProxyFlushRequest &msg) {
-  auto &proxies = App.get_serial_proxies();
-  if (msg.instance >= proxies.size()) {
-    ESP_LOGW(TAG, "Serial proxy instance %u out of range", msg.instance);
-    return;
-  }
-  proxies[msg.instance]->flush_port();
-}
-
-void APIConnection::send_serial_proxy_data(const SerialProxyDataReceived &msg) {
-  this->send_message(msg, SerialProxyDataReceived::MESSAGE_TYPE);
-}
-#endif
-
 #ifdef USE_INFRARED
 uint16_t APIConnection::try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *infrared = static_cast<infrared::Infrared *>(entity);
@@ -1546,11 +1465,8 @@ 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
-  {
-    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)));
-  }
+  this->parent_->get_client_connected_trigger()->trigger(std::string(this->helper_->get_client_name()),
+                                                         std::string(this->helper_->get_client_peername()));
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
   if (homeassistant::global_homeassistant_time != nullptr) {
@@ -1569,9 +1485,8 @@ 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 %" PRIu16 ".%" PRIu16, this->helper_->get_client_name(),
-           this->helper_->get_peername_to(peername), this->client_api_version_major_, this->client_api_version_minor_);
+  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_);
 
   HelloResponse resp;
   resp.api_version_major = 1;
@@ -1687,9 +1602,6 @@ bool APIConnection::send_device_info_response_() {
   resp.zwave_proxy_feature_flags = zwave_proxy::global_zwave_proxy->get_feature_flags();
   resp.zwave_home_id = zwave_proxy::global_zwave_proxy->get_home_id();
 #endif
-#ifdef USE_SERIAL_PROXY
-  resp.serial_proxy_count = App.get_serial_proxies().size();
-#endif
 #ifdef USE_API_NOISE
   resp.api_encryption_supported = true;
 #endif
@@ -1922,8 +1834,7 @@ void APIConnection::on_no_setup_connection() {
   this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no connection setup"));
 }
 void APIConnection::on_fatal_error() {
-  // 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->helper_->close();
   this->flags_.remove = true;
 }
 
@@ -1984,6 +1895,10 @@ bool APIConnection::schedule_batch_() {
 }
 
 void APIConnection::process_batch_() {
+  // Ensure MessageInfo remains trivially destructible for our placement new approach
+  static_assert(std::is_trivially_destructible<MessageInfo>::value,
+                "MessageInfo must remain trivially destructible with this placement-new approach");
+
   if (this->deferred_batch_.empty()) {
     this->flags_.batch_scheduled = false;
     return;
@@ -2008,10 +1923,6 @@ void APIConnection::process_batch_() {
   for (size_t i = 0; i < num_items; i++) {
     total_estimated_size += this->deferred_batch_[i].estimated_size;
   }
-  // Clamp to MAX_BATCH_PACKET_SIZE — we won't send more than that per batch
-  if (total_estimated_size > MAX_BATCH_PACKET_SIZE) {
-    total_estimated_size = MAX_BATCH_PACKET_SIZE;
-  }
 
   this->prepare_first_message_buffer(shared_buf, header_padding, total_estimated_size);
 
@@ -2035,20 +1946,7 @@ void APIConnection::process_batch_() {
     return;
   }
 
-  // Multi-message path — heavy stack frame isolated in separate noinline function
-  this->process_batch_multi_(shared_buf, num_items, header_padding, footer_size);
-}
-
-// Separated from process_batch_() so the single-message fast path gets a minimal
-// stack frame without the MAX_MESSAGES_PER_BATCH * sizeof(MessageInfo) array.
-void APIConnection::process_batch_multi_(std::vector<uint8_t> &shared_buf, size_t num_items, uint8_t header_padding,
-                                         uint8_t footer_size) {
-  // Ensure MessageInfo remains trivially destructible for our placement new approach
-  static_assert(std::is_trivially_destructible<MessageInfo>::value,
-                "MessageInfo must remain trivially destructible with this placement-new approach");
-
-  const size_t messages_to_process = std::min(num_items, MAX_MESSAGES_PER_BATCH);
-  const uint8_t frame_overhead = header_padding + footer_size;
+  size_t messages_to_process = std::min(num_items, MAX_MESSAGES_PER_BATCH);
 
   // Stack-allocated array for message info
   alignas(MessageInfo) char message_info_storage[MAX_MESSAGES_PER_BATCH * sizeof(MessageInfo)];
@@ -2075,7 +1973,7 @@ void APIConnection::process_batch_multi_(std::vector<uint8_t> &shared_buf, size_
 
     // Message was encoded successfully
     // payload_size is header_padding + actual payload size + footer_size
-    uint16_t proto_payload_size = payload_size - frame_overhead;
+    uint16_t proto_payload_size = payload_size - header_padding - footer_size;
     // Use placement new to construct MessageInfo in pre-allocated stack array
     // This avoids default-constructing all MAX_MESSAGES_PER_BATCH elements
     // Explicit destruction is not needed because MessageInfo is trivially destructible,
@@ -2091,38 +1989,42 @@ void APIConnection::process_batch_multi_(std::vector<uint8_t> &shared_buf, size_
     current_offset = shared_buf.size() + footer_size;
   }
 
-  if (items_processed > 0) {
-    // Add footer space for the last message (for Noise protocol MAC)
-    if (footer_size > 0) {
-      shared_buf.resize(shared_buf.size() + footer_size);
-    }
-
-    // Send all collected messages
-    APIError err = this->helper_->write_protobuf_messages(ProtoWriteBuffer{&shared_buf},
-                                                          std::span<const MessageInfo>(message_info, items_processed));
-    if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
-      this->fatal_error_with_log_(LOG_STR("Batch write failed"), err);
-    }
-
-#ifdef HAS_PROTO_MESSAGE_DUMP
-    // Log messages after send attempt for VV debugging
-    // It's safe to use the buffer for logging at this point regardless of send result
-    for (size_t i = 0; i < items_processed; i++) {
-      const auto &item = this->deferred_batch_[i];
-      this->log_batch_item_(item);
-    }
-#endif
-
-    // Partial batch — remove processed items and reschedule
-    if (items_processed < this->deferred_batch_.size()) {
-      this->deferred_batch_.remove_front(items_processed);
-      this->schedule_batch_();
-      return;
-    }
+  if (items_processed == 0) {
+    this->deferred_batch_.clear();
+    return;
   }
 
-  // All items processed (or none could be processed)
-  this->clear_batch_();
+  // Add footer space for the last message (for Noise protocol MAC)
+  if (footer_size > 0) {
+    shared_buf.resize(shared_buf.size() + footer_size);
+  }
+
+  // Send all collected messages
+  APIError err = this->helper_->write_protobuf_messages(ProtoWriteBuffer{&shared_buf},
+                                                        std::span<const MessageInfo>(message_info, items_processed));
+  if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
+    this->fatal_error_with_log_(LOG_STR("Batch write failed"), err);
+  }
+
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  // Log messages after send attempt for VV debugging
+  // It's safe to use the buffer for logging at this point regardless of send result
+  for (size_t i = 0; i < items_processed; i++) {
+    const auto &item = this->deferred_batch_[i];
+    this->log_batch_item_(item);
+  }
+#endif
+
+  // Handle remaining items more efficiently
+  if (items_processed < this->deferred_batch_.size()) {
+    // Remove processed items from the beginning
+    this->deferred_batch_.remove_front(items_processed);
+    // Reschedule for remaining items
+    this->schedule_batch_();
+  } else {
+    // All items processed
+    this->clear_batch_();
+  }
 }
 
 // Dispatch message encoding based on message_type
@@ -2289,14 +2191,12 @@ 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_peername_to(peername), LOG_STR_ARG(message));
+                  this->helper_->get_client_peername(), LOG_STR_ARG(message));
 }
 
 void APIConnection::log_warning_(const LogString *message, APIError err) {
-  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),
+  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->helper_->get_client_name(), this->helper_->get_client_peername(),
            LOG_STR_ARG(message), LOG_STR_ARG(api_error_to_logstr(err)), errno);
 }
 

esphome/components/api/api_connection.h

@@ -15,10 +15,6 @@
 #include <limits>
 #include <vector>
 
-namespace esphome {
-class ComponentIterator;
-}  // namespace esphome
-
 namespace esphome::api {
 
 // Keepalive timeout in milliseconds
@@ -182,15 +178,6 @@ class APIConnection final : public APIServerConnectionBase {
   void send_infrared_rf_receive_event(const InfraredRFReceiveEvent &msg);
 #endif
 
-#ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &msg) override;
-  void on_serial_proxy_write_request(const SerialProxyWriteRequest &msg) override;
-  void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &msg) override;
-  void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg) override;
-  void on_serial_proxy_flush_request(const SerialProxyFlushRequest &msg) override;
-  void send_serial_proxy_data(const SerialProxyDataReceived &msg);
-#endif
-
 #ifdef USE_EVENT
   void send_event(event::Event *event);
 #endif
@@ -289,10 +276,8 @@ 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) 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);
-  }
+  /// Get peer name (IP address) - cached at connection init time
+  const char *get_peername() const { return this->helper_->get_client_peername(); }
 
  protected:
   // Helper function to handle authentication completion
@@ -379,13 +364,20 @@ class APIConnection final : public APIServerConnectionBase {
     return this->client_supports_api_version(1, 14) ? MAX_INITIAL_PER_BATCH : MAX_INITIAL_PER_BATCH_LEGACY;
   }
 
-  // Process active iterator (list_entities/initial_state) during connection setup.
-  // Extracted from loop() — only runs during initial handshake, NONE in steady state.
-  void __attribute__((noinline)) process_active_iterator_();
+  // Helper method to process multiple entities from an iterator in a batch
+  template<typename Iterator> void process_iterator_batch_(Iterator &iterator) {
+    size_t initial_size = this->deferred_batch_.size();
+    size_t max_batch = this->get_max_batch_size_();
+    while (!iterator.completed() && (this->deferred_batch_.size() - initial_size) < max_batch) {
+      iterator.advance();
+    }
 
-  // Helper method to process multiple entities from an iterator in a batch.
-  // Takes ComponentIterator base class reference to avoid duplicate template instantiations.
-  void process_iterator_batch_(ComponentIterator &iterator);
+    // If the batch is full, process it immediately
+    // Note: iterator.advance() already calls schedule_batch_() via schedule_message_()
+    if (this->deferred_batch_.size() >= max_batch) {
+      this->process_batch_();
+    }
+  }
 
 #ifdef USE_BINARY_SENSOR
   static uint16_t try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
@@ -557,8 +549,8 @@ class APIConnection final : public APIServerConnectionBase {
       batch_start_time = 0;
     }
 
-    // Remove processed items from the front — noinline to keep memmove out of warm callers
-    void remove_front(size_t count) __attribute__((noinline)) { items.erase(items.begin(), items.begin() + count); }
+    // Remove processed items from the front
+    void remove_front(size_t count) { items.erase(items.begin(), items.begin() + count); }
 
     bool empty() const { return items.empty(); }
     size_t size() const { return items.size(); }
@@ -630,8 +622,6 @@ class APIConnection final : public APIServerConnectionBase {
 
   bool schedule_batch_();
   void process_batch_();
-  void process_batch_multi_(std::vector<uint8_t> &shared_buf, size_t num_items, uint8_t header_padding,
-                            uint8_t footer_size) __attribute__((noinline));
   void clear_batch_() {
     this->deferred_batch_.clear();
     this->flags_.batch_scheduled = false;

esphome/components/api/api_frame_helper.cpp

@@ -16,12 +16,7 @@ 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, ...) \
-  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)
+#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif
@@ -245,20 +240,13 @@ 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,9 +90,8 @@ class APIFrameHelper {
 
   // Get client name (null-terminated)
   const char *get_client_name() const { return this->client_name_; }
-  // 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;
+  // Get client peername/IP (null-terminated, cached at init time for availability after socket failure)
+  const char *get_client_peername() const { return this->client_peername_; }
   // Set client name from buffer with length (truncates if needed)
   void set_client_name(const char *name, size_t len) {
     size_t copy_len = std::min(len, sizeof(this->client_name_) - 1);
@@ -106,8 +105,6 @@ 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)
@@ -234,6 +231,8 @@ 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,12 +29,7 @@ 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, ...) \
-  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)
+#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -21,12 +21,7 @@ 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, ...) \
-  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)
+#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif
@@ -295,8 +290,9 @@ APIError APIPlaintextFrameHelper::write_protobuf_messages(ProtoWriteBuffer buffe
     buf_start[header_offset] = 0x00;  // indicator
 
     // Encode varints directly into buffer
-    encode_varint_to_buffer(msg.payload_size, buf_start + header_offset + 1);
-    encode_varint_to_buffer(msg.message_type, buf_start + header_offset + 1 + size_varint_len);
+    ProtoVarInt(msg.payload_size).encode_to_buffer_unchecked(buf_start + header_offset + 1, size_varint_len);
+    ProtoVarInt(msg.message_type)
+        .encode_to_buffer_unchecked(buf_start + header_offset + 1 + size_varint_len, type_varint_len);
 
     // Add iovec for this message (header + payload)
     size_t msg_len = static_cast<size_t>(total_header_len + msg.payload_size);

esphome/components/api/api_pb2.cpp

@@ -119,9 +119,6 @@ void DeviceInfoResponse::encode(ProtoWriteBuffer buffer) const {
 #ifdef USE_ZWAVE_PROXY
   buffer.encode_uint32(24, this->zwave_home_id);
 #endif
-#ifdef USE_SERIAL_PROXY
-  buffer.encode_uint32(25, this->serial_proxy_count);
-#endif
 }
 void DeviceInfoResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->name.size());
@@ -177,9 +174,6 @@ void DeviceInfoResponse::calculate_size(ProtoSize &size) const {
 #ifdef USE_ZWAVE_PROXY
   size.add_uint32(2, this->zwave_home_id);
 #endif
-#ifdef USE_SERIAL_PROXY
-  size.add_uint32(2, this->serial_proxy_count);
-#endif
 }
 #ifdef USE_BINARY_SENSOR
 void ListEntitiesBinarySensorResponse::encode(ProtoWriteBuffer buffer) const {
@@ -3446,108 +3440,5 @@ void InfraredRFReceiveEvent::calculate_size(ProtoSize &size) const {
   }
 }
 #endif
-#ifdef USE_SERIAL_PROXY
-bool SerialProxyConfigureRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
-  switch (field_id) {
-    case 1:
-      this->instance = value.as_uint32();
-      break;
-    case 2:
-      this->baudrate = value.as_uint32();
-      break;
-    case 3:
-      this->flow_control = value.as_bool();
-      break;
-    case 4:
-      this->parity = static_cast<enums::SerialProxyParity>(value.as_uint32());
-      break;
-    case 5:
-      this->stop_bits = value.as_uint32();
-      break;
-    case 6:
-      this->data_size = value.as_uint32();
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-void SerialProxyDataReceived::encode(ProtoWriteBuffer buffer) const {
-  buffer.encode_uint32(1, this->instance);
-  buffer.encode_bytes(2, this->data_ptr_, this->data_len_);
-}
-void SerialProxyDataReceived::calculate_size(ProtoSize &size) const {
-  size.add_uint32(1, this->instance);
-  size.add_length(1, this->data_len_);
-}
-bool SerialProxyWriteRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
-  switch (field_id) {
-    case 1:
-      this->instance = value.as_uint32();
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-bool SerialProxyWriteRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
-  switch (field_id) {
-    case 2: {
-      this->data = value.data();
-      this->data_len = value.size();
-      break;
-    }
-    default:
-      return false;
-  }
-  return true;
-}
-bool SerialProxySetModemPinsRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
-  switch (field_id) {
-    case 1:
-      this->instance = value.as_uint32();
-      break;
-    case 2:
-      this->rts = value.as_bool();
-      break;
-    case 3:
-      this->dtr = value.as_bool();
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-bool SerialProxyGetModemPinsRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
-  switch (field_id) {
-    case 1:
-      this->instance = value.as_uint32();
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-void SerialProxyGetModemPinsResponse::encode(ProtoWriteBuffer buffer) const {
-  buffer.encode_uint32(1, this->instance);
-  buffer.encode_bool(2, this->rts);
-  buffer.encode_bool(3, this->dtr);
-}
-void SerialProxyGetModemPinsResponse::calculate_size(ProtoSize &size) const {
-  size.add_uint32(1, this->instance);
-  size.add_bool(1, this->rts);
-  size.add_bool(1, this->dtr);
-}
-bool SerialProxyFlushRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
-  switch (field_id) {
-    case 1:
-      this->instance = value.as_uint32();
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-#endif
 
 }  // namespace esphome::api

esphome/components/api/api_pb2.h

@@ -147,8 +147,6 @@ 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 {
@@ -311,13 +309,6 @@ enum ZWaveProxyRequestType : uint32_t {
   ZWAVE_PROXY_REQUEST_TYPE_HOME_ID_CHANGE = 2,
 };
 #endif
-#ifdef USE_SERIAL_PROXY
-enum SerialProxyParity : uint32_t {
-  SERIAL_PROXY_PARITY_NONE = 0,
-  SERIAL_PROXY_PARITY_EVEN = 1,
-  SERIAL_PROXY_PARITY_ODD = 2,
-};
-#endif
 
 }  // namespace enums
 
@@ -481,7 +472,7 @@ class DeviceInfo final : public ProtoMessage {
 class DeviceInfoResponse final : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 10;
-  static constexpr uint16_t ESTIMATED_SIZE = 260;
+  static constexpr uint8_t ESTIMATED_SIZE = 255;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "device_info_response"; }
 #endif
@@ -533,9 +524,6 @@ class DeviceInfoResponse final : public ProtoMessage {
 #endif
 #ifdef USE_ZWAVE_PROXY
   uint32_t zwave_home_id{0};
-#endif
-#ifdef USE_SERIAL_PROXY
-  uint32_t serial_proxy_count{0};
 #endif
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -3035,132 +3023,5 @@ class InfraredRFReceiveEvent final : public ProtoMessage {
  protected:
 };
 #endif
-#ifdef USE_SERIAL_PROXY
-class SerialProxyConfigureRequest final : public ProtoDecodableMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 138;
-  static constexpr uint8_t ESTIMATED_SIZE = 20;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_configure_request"; }
-#endif
-  uint32_t instance{0};
-  uint32_t baudrate{0};
-  bool flow_control{false};
-  enums::SerialProxyParity parity{};
-  uint32_t stop_bits{0};
-  uint32_t data_size{0};
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
-};
-class SerialProxyDataReceived final : public ProtoMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 139;
-  static constexpr uint8_t ESTIMATED_SIZE = 23;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_data_received"; }
-#endif
-  uint32_t instance{0};
-  const uint8_t *data_ptr_{nullptr};
-  size_t data_len_{0};
-  void set_data(const uint8_t *data, size_t len) {
-    this->data_ptr_ = data;
-    this->data_len_ = len;
-  }
-  void encode(ProtoWriteBuffer buffer) const override;
-  void calculate_size(ProtoSize &size) const override;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-};
-class SerialProxyWriteRequest final : public ProtoDecodableMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 140;
-  static constexpr uint8_t ESTIMATED_SIZE = 23;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_write_request"; }
-#endif
-  uint32_t instance{0};
-  const uint8_t *data{nullptr};
-  uint16_t data_len{0};
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
-  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
-};
-class SerialProxySetModemPinsRequest final : public ProtoDecodableMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 141;
-  static constexpr uint8_t ESTIMATED_SIZE = 8;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_set_modem_pins_request"; }
-#endif
-  uint32_t instance{0};
-  bool rts{false};
-  bool dtr{false};
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
-};
-class SerialProxyGetModemPinsRequest final : public ProtoDecodableMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 142;
-  static constexpr uint8_t ESTIMATED_SIZE = 4;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_get_modem_pins_request"; }
-#endif
-  uint32_t instance{0};
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
-};
-class SerialProxyGetModemPinsResponse final : public ProtoMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 143;
-  static constexpr uint8_t ESTIMATED_SIZE = 8;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_get_modem_pins_response"; }
-#endif
-  uint32_t instance{0};
-  bool rts{false};
-  bool dtr{false};
-  void encode(ProtoWriteBuffer buffer) const override;
-  void calculate_size(ProtoSize &size) const override;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-};
-class SerialProxyFlushRequest final : public ProtoDecodableMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 144;
-  static constexpr uint8_t ESTIMATED_SIZE = 4;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "serial_proxy_flush_request"; }
-#endif
-  uint32_t instance{0};
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
-};
-#endif
 
 }  // namespace esphome::api

esphome/components/api/api_pb2_dump.cpp

@@ -385,10 +385,6 @@ 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";
   }
@@ -736,20 +732,6 @@ template<> const char *proto_enum_to_string<enums::ZWaveProxyRequestType>(enums:
   }
 }
 #endif
-#ifdef USE_SERIAL_PROXY
-template<> const char *proto_enum_to_string<enums::SerialProxyParity>(enums::SerialProxyParity value) {
-  switch (value) {
-    case enums::SERIAL_PROXY_PARITY_NONE:
-      return "SERIAL_PROXY_PARITY_NONE";
-    case enums::SERIAL_PROXY_PARITY_EVEN:
-      return "SERIAL_PROXY_PARITY_EVEN";
-    case enums::SERIAL_PROXY_PARITY_ODD:
-      return "SERIAL_PROXY_PARITY_ODD";
-    default:
-      return "UNKNOWN";
-  }
-}
-#endif
 
 const char *HelloRequest::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, "HelloRequest");
@@ -859,9 +841,6 @@ const char *DeviceInfoResponse::dump_to(DumpBuffer &out) const {
 #endif
 #ifdef USE_ZWAVE_PROXY
   dump_field(out, "zwave_home_id", this->zwave_home_id);
-#endif
-#ifdef USE_SERIAL_PROXY
-  dump_field(out, "serial_proxy_count", this->serial_proxy_count);
 #endif
   return out.c_str();
 }
@@ -2486,54 +2465,6 @@ const char *InfraredRFReceiveEvent::dump_to(DumpBuffer &out) const {
   return out.c_str();
 }
 #endif
-#ifdef USE_SERIAL_PROXY
-const char *SerialProxyConfigureRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyConfigureRequest");
-  dump_field(out, "instance", this->instance);
-  dump_field(out, "baudrate", this->baudrate);
-  dump_field(out, "flow_control", this->flow_control);
-  dump_field(out, "parity", static_cast<enums::SerialProxyParity>(this->parity));
-  dump_field(out, "stop_bits", this->stop_bits);
-  dump_field(out, "data_size", this->data_size);
-  return out.c_str();
-}
-const char *SerialProxyDataReceived::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyDataReceived");
-  dump_field(out, "instance", this->instance);
-  dump_bytes_field(out, "data", this->data_ptr_, this->data_len_);
-  return out.c_str();
-}
-const char *SerialProxyWriteRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyWriteRequest");
-  dump_field(out, "instance", this->instance);
-  dump_bytes_field(out, "data", this->data, this->data_len);
-  return out.c_str();
-}
-const char *SerialProxySetModemPinsRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxySetModemPinsRequest");
-  dump_field(out, "instance", this->instance);
-  dump_field(out, "rts", this->rts);
-  dump_field(out, "dtr", this->dtr);
-  return out.c_str();
-}
-const char *SerialProxyGetModemPinsRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyGetModemPinsRequest");
-  dump_field(out, "instance", this->instance);
-  return out.c_str();
-}
-const char *SerialProxyGetModemPinsResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyGetModemPinsResponse");
-  dump_field(out, "instance", this->instance);
-  dump_field(out, "rts", this->rts);
-  dump_field(out, "dtr", this->dtr);
-  return out.c_str();
-}
-const char *SerialProxyFlushRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, "SerialProxyFlushRequest");
-  dump_field(out, "instance", this->instance);
-  return out.c_str();
-}
-#endif
 
 }  // namespace esphome::api
 

esphome/components/api/api_pb2_service.cpp

@@ -634,61 +634,6 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_infrared_rf_transmit_raw_timings_request(msg);
       break;
     }
-#endif
-#ifdef USE_SERIAL_PROXY
-    case SerialProxyConfigureRequest::MESSAGE_TYPE: {
-      SerialProxyConfigureRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_serial_proxy_configure_request"), msg);
-#endif
-      this->on_serial_proxy_configure_request(msg);
-      break;
-    }
-#endif
-#ifdef USE_SERIAL_PROXY
-    case SerialProxyWriteRequest::MESSAGE_TYPE: {
-      SerialProxyWriteRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_serial_proxy_write_request"), msg);
-#endif
-      this->on_serial_proxy_write_request(msg);
-      break;
-    }
-#endif
-#ifdef USE_SERIAL_PROXY
-    case SerialProxySetModemPinsRequest::MESSAGE_TYPE: {
-      SerialProxySetModemPinsRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_serial_proxy_set_modem_pins_request"), msg);
-#endif
-      this->on_serial_proxy_set_modem_pins_request(msg);
-      break;
-    }
-#endif
-#ifdef USE_SERIAL_PROXY
-    case SerialProxyGetModemPinsRequest::MESSAGE_TYPE: {
-      SerialProxyGetModemPinsRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_serial_proxy_get_modem_pins_request"), msg);
-#endif
-      this->on_serial_proxy_get_modem_pins_request(msg);
-      break;
-    }
-#endif
-#ifdef USE_SERIAL_PROXY
-    case SerialProxyFlushRequest::MESSAGE_TYPE: {
-      SerialProxyFlushRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_serial_proxy_flush_request"), msg);
-#endif
-      this->on_serial_proxy_flush_request(msg);
-      break;
-    }
 #endif
     default:
       break;

esphome/components/api/api_pb2_service.h

@@ -224,23 +224,6 @@ class APIServerConnectionBase : public ProtoService {
   virtual void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &value){};
 #endif
 
-#ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &value){};
-#endif
-
-#ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_write_request(const SerialProxyWriteRequest &value){};
-#endif
-#ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &value){};
-#endif
-#ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &value){};
-#endif
-
-#ifdef USE_SERIAL_PROXY
-  virtual void on_serial_proxy_flush_request(const SerialProxyFlushRequest &value){};
-#endif
  protected:
   void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
 };

esphome/components/api/api_server.cpp

@@ -192,15 +192,11 @@ void APIServer::loop() {
     ESP_LOGV(TAG, "Remove connection %s", client->get_name());
 
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    // Save client info before closing socket and removal for the trigger
-    char peername_buf[socket::SOCKADDR_STR_LEN];
+    // Save client info before removal for the trigger
     std::string client_name(client->get_name());
-    std::string client_peername(client->get_peername_to(peername_buf));
+    std::string client_peername(client->get_peername());
 #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());
@@ -370,17 +366,6 @@ void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_
 }
 #endif
 
-#ifdef USE_SERIAL_PROXY
-void APIServer::send_serial_proxy_data(uint32_t instance, const uint8_t *data, size_t len) {
-  SerialProxyDataReceived msg{};
-  msg.instance = instance;
-  msg.set_data(data, len);
-
-  for (auto &c : this->clients_)
-    c->send_serial_proxy_data(msg);
-}
-#endif
-
 #ifdef USE_ALARM_CONTROL_PANEL
 API_DISPATCH_UPDATE(alarm_control_panel::AlarmControlPanel, alarm_control_panel)
 #endif

esphome/components/api/api_server.h

@@ -189,10 +189,6 @@ class APIServer : public Component,
   void send_infrared_rf_receive_event(uint32_t device_id, uint32_t key, const std::vector<int32_t> *timings);
 #endif
 
-#ifdef USE_SERIAL_PROXY
-  void send_serial_proxy_data(uint32_t instance, const uint8_t *data, size_t len);
-#endif
-
   bool is_connected(bool state_subscription_only = false) const;
 
 #ifdef USE_API_HOMEASSISTANT_STATES

esphome/components/api/list_entities.h

@@ -94,6 +94,7 @@ class ListEntitiesIterator : public ComponentIterator {
   bool on_update(update::UpdateEntity *entity) override;
 #endif
   bool on_end() override;
+  bool completed() { return this->state_ == IteratorState::NONE; }
 
  protected:
   APIConnection *client_;

esphome/components/api/proto.cpp

@@ -133,7 +133,7 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
         break;
       }
       default:
-        ESP_LOGV(TAG, "Invalid field type %" PRIu32 " at offset %ld", field_type, (long) (ptr - buffer));
+        ESP_LOGV(TAG, "Invalid field type %u at offset %ld", field_type, (long) (ptr - buffer));
         return;
     }
   }

esphome/components/api/proto.h

@@ -57,16 +57,6 @@ inline uint16_t count_packed_varints(const uint8_t *data, size_t len) {
   return count;
 }
 
-/// Encode a varint directly into a pre-allocated buffer.
-/// Caller must ensure buffer has space (use ProtoSize::varint() to calculate).
-inline void encode_varint_to_buffer(uint32_t val, uint8_t *buffer) {
-  while (val > 0x7F) {
-    *buffer++ = static_cast<uint8_t>(val | 0x80);
-    val >>= 7;
-  }
-  *buffer = static_cast<uint8_t>(val);
-}
-
 /*
  * StringRef Ownership Model for API Protocol Messages
  * ===================================================
@@ -103,17 +93,17 @@ class ProtoVarInt {
   ProtoVarInt() : value_(0) {}
   explicit ProtoVarInt(uint64_t value) : value_(value) {}
 
-  /// Parse a varint from buffer. consumed must be a valid pointer (not null).
   static optional<ProtoVarInt> parse(const uint8_t *buffer, uint32_t len, uint32_t *consumed) {
-#ifdef ESPHOME_DEBUG_API
-    assert(consumed != nullptr);
-#endif
-    if (len == 0)
+    if (len == 0) {
+      if (consumed != nullptr)
+        *consumed = 0;
       return {};
+    }
 
     // Most common case: single-byte varint (values 0-127)
     if ((buffer[0] & 0x80) == 0) {
-      *consumed = 1;
+      if (consumed != nullptr)
+        *consumed = 1;
       return ProtoVarInt(buffer[0]);
     }
 
@@ -132,11 +122,14 @@ class ProtoVarInt {
       result |= uint64_t(val & 0x7F) << uint64_t(bitpos);
       bitpos += 7;
       if ((val & 0x80) == 0) {
-        *consumed = i + 1;
+        if (consumed != nullptr)
+          *consumed = i + 1;
         return ProtoVarInt(result);
       }
     }
 
+    if (consumed != nullptr)
+      *consumed = 0;
     return {};  // Incomplete or invalid varint
   }
 
@@ -160,6 +153,50 @@ class ProtoVarInt {
     // with ZigZag encoding
     return decode_zigzag64(this->value_);
   }
+  /**
+   * Encode the varint value to a pre-allocated buffer without bounds checking.
+   *
+   * @param buffer The pre-allocated buffer to write the encoded varint to
+   * @param len The size of the buffer in bytes
+   *
+   * @note The caller is responsible for ensuring the buffer is large enough
+   *       to hold the encoded value. Use ProtoSize::varint() to calculate
+   *       the exact size needed before calling this method.
+   * @note No bounds checking is performed for performance reasons.
+   */
+  void encode_to_buffer_unchecked(uint8_t *buffer, size_t len) {
+    uint64_t val = this->value_;
+    if (val <= 0x7F) {
+      buffer[0] = val;
+      return;
+    }
+    size_t i = 0;
+    while (val && i < len) {
+      uint8_t temp = val & 0x7F;
+      val >>= 7;
+      if (val) {
+        buffer[i++] = temp | 0x80;
+      } else {
+        buffer[i++] = temp;
+      }
+    }
+  }
+  void encode(std::vector<uint8_t> &out) {
+    uint64_t val = this->value_;
+    if (val <= 0x7F) {
+      out.push_back(val);
+      return;
+    }
+    while (val) {
+      uint8_t temp = val & 0x7F;
+      val >>= 7;
+      if (val) {
+        out.push_back(temp | 0x80);
+      } else {
+        out.push_back(temp);
+      }
+    }
+  }
 
  protected:
   uint64_t value_;
@@ -219,20 +256,8 @@ class ProtoWriteBuffer {
  public:
   ProtoWriteBuffer(std::vector<uint8_t> *buffer) : buffer_(buffer) {}
   void write(uint8_t value) { this->buffer_->push_back(value); }
-  void encode_varint_raw(uint32_t value) {
-    while (value > 0x7F) {
-      this->buffer_->push_back(static_cast<uint8_t>(value | 0x80));
-      value >>= 7;
-    }
-    this->buffer_->push_back(static_cast<uint8_t>(value));
-  }
-  void encode_varint_raw_64(uint64_t value) {
-    while (value > 0x7F) {
-      this->buffer_->push_back(static_cast<uint8_t>(value | 0x80));
-      value >>= 7;
-    }
-    this->buffer_->push_back(static_cast<uint8_t>(value));
-  }
+  void encode_varint_raw(ProtoVarInt value) { value.encode(*this->buffer_); }
+  void encode_varint_raw(uint32_t value) { this->encode_varint_raw(ProtoVarInt(value)); }
   /**
    * Encode a field key (tag/wire type combination).
    *
@@ -282,13 +307,13 @@ class ProtoWriteBuffer {
     if (value == 0 && !force)
       return;
     this->encode_field_raw(field_id, 0);  // type 0: Varint - uint64
-    this->encode_varint_raw_64(value);
+    this->encode_varint_raw(ProtoVarInt(value));
   }
   void encode_bool(uint32_t field_id, bool value, bool force = false) {
     if (!value && !force)
       return;
     this->encode_field_raw(field_id, 0);  // type 0: Varint - bool
-    this->buffer_->push_back(value ? 0x01 : 0x00);
+    this->write(0x01);
   }
   void encode_fixed32(uint32_t field_id, uint32_t value, bool force = false) {
     if (value == 0 && !force)
@@ -913,15 +938,13 @@ inline void ProtoWriteBuffer::encode_message(uint32_t field_id, const ProtoMessa
   this->buffer_->resize(this->buffer_->size() + varint_length_bytes);
 
   // Write the length varint directly
-  encode_varint_to_buffer(msg_length_bytes, this->buffer_->data() + begin);
+  ProtoVarInt(msg_length_bytes).encode_to_buffer_unchecked(this->buffer_->data() + begin, varint_length_bytes);
 
   // Now encode the message content - it will append to the buffer
   value.encode(*this);
 
-#ifdef ESPHOME_DEBUG_API
   // Verify that the encoded size matches what we calculated
   assert(this->buffer_->size() == begin + varint_length_bytes + msg_length_bytes);
-#endif
 }
 
 // Implementation of decode_to_message - must be after ProtoDecodableMessage is defined

esphome/components/api/subscribe_state.h

@@ -88,6 +88,7 @@ class InitialStateIterator : public ComponentIterator {
 #ifdef USE_UPDATE
   bool on_update(update::UpdateEntity *entity) override;
 #endif
+  bool completed() { return this->state_ == IteratorState::NONE; }
 
  protected:
   APIConnection *client_;

esphome/components/aqi/aqi_calculator.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <algorithm>
 #include <cmath>
 #include <limits>
 #include "abstract_aqi_calculator.h"
@@ -15,11 +14,7 @@ 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);
 
-    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));
+    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
   }
 
  protected:
@@ -27,27 +22,13 @@ 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] = {
-      // 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 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 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 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 float calculate_index(float value, const float array[NUM_LEVELS][2]) {
     int grid_index = get_grid_index(value, array);
@@ -64,10 +45,7 @@ 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++) {
-      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) {
+      if (value >= array[i][0] && value <= array[i][1]) {
         return i;
       }
     }

esphome/components/aqi/caqi_calculator.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <algorithm>
 #include <cmath>
 #include <limits>
 #include "abstract_aqi_calculator.h"
@@ -13,11 +12,7 @@ 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);
 
-    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));
+    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
   }
 
  protected:
@@ -26,24 +21,10 @@ 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] = {
-      // 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
-  };
+      {0.0f, 15.0f}, {15.1f, 30.0f}, {30.1f, 55.0f}, {55.1f, 110.0f}, {110.1f, std::numeric_limits<float>::max()}};
 
   static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {
-      // 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
-  };
+      {0.0f, 25.0f}, {25.1f, 50.0f}, {50.1f, 90.0f}, {90.1f, 180.0f}, {180.1f, std::numeric_limits<float>::max()}};
 
   static float calculate_index(float value, const float array[NUM_LEVELS][2]) {
     int grid_index = get_grid_index(value, array);
@@ -61,10 +42,7 @@ 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++) {
-      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) {
+      if (value >= array[i][0] && value <= array[i][1]) {
         return i;
       }
     }

esphome/components/bk72xx/boards.py

@@ -159,10 +159,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "cbu": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE1_SCL": 20,
         "WIRE1_SDA": 21,
         "WIRE2_SCL": 0,
@@ -231,10 +227,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "generic-bk7231t-qfn32-tuya": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE1_SCL": 20,
         "WIRE1_SDA": 21,
         "WIRE2_SCL": 0,
@@ -303,10 +295,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "generic-bk7231n-qfn32-tuya": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE1_SCL": 20,
         "WIRE1_SDA": 21,
         "WIRE2_SCL": 0,
@@ -497,7 +485,8 @@ BK72XX_BOARD_PINS = {
     },
     "cb3s": {
         "WIRE1_SCL": 20,
-        "WIRE1_SDA": 21,
+        "WIRE1_SDA_0": 21,
+        "WIRE1_SDA_1": 21,
         "SERIAL1_RX": 10,
         "SERIAL1_TX": 11,
         "SERIAL2_TX": 0,
@@ -658,10 +647,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "generic-bk7252": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE1_SCL": 20,
         "WIRE1_SDA": 21,
         "WIRE2_SCL": 0,
@@ -1111,10 +1096,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "cb3se": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE2_SCL": 0,
         "WIRE2_SDA": 1,
         "SERIAL1_RX": 10,

esphome/components/bl0942/bl0942.cpp

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

esphome/components/bl0942/bl0942.h

@@ -59,10 +59,10 @@ namespace bl0942 {
 //
 // Which makes BL0952_EREF = BL0942_PREF * 3600000 / 419430.4
 
-static const float BL0942_PREF = 623.0270705;  // calculated using UREF and IREF
-static const float BL0942_UREF = 15883.34116;  // calculated for (390k x 5 / 510R) voltage divider
-static const float BL0942_IREF = 251065.6814;  // calculated for 1mR shunt
-static const float BL0942_EREF = 5347.484240;  // calculated using UREF and IREF
+static const float BL0942_PREF = 596;              // taken from tasmota
+static const float BL0942_UREF = 15873.35944299;   // should be 73989/1.218
+static const float BL0942_IREF = 251213.46469622;  // 305978/1.218
+static const float BL0942_EREF = 3304.61127328;    // Measured
 
 struct DataPacket {
   uint8_t frame_header;
@@ -86,11 +86,11 @@ enum LineFrequency : uint8_t {
 
 class BL0942 : public PollingComponent, public uart::UARTDevice {
  public:
-  void set_voltage_sensor(sensor::Sensor *voltage_sensor) { this->voltage_sensor_ = voltage_sensor; }
-  void set_current_sensor(sensor::Sensor *current_sensor) { this->current_sensor_ = current_sensor; }
-  void set_power_sensor(sensor::Sensor *power_sensor) { this->power_sensor_ = power_sensor; }
-  void set_energy_sensor(sensor::Sensor *energy_sensor) { this->energy_sensor_ = energy_sensor; }
-  void set_frequency_sensor(sensor::Sensor *frequency_sensor) { this->frequency_sensor_ = frequency_sensor; }
+  void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
+  void set_current_sensor(sensor::Sensor *current_sensor) { current_sensor_ = current_sensor; }
+  void set_power_sensor(sensor::Sensor *power_sensor) { power_sensor_ = power_sensor; }
+  void set_energy_sensor(sensor::Sensor *energy_sensor) { energy_sensor_ = energy_sensor; }
+  void set_frequency_sensor(sensor::Sensor *frequency_sensor) { frequency_sensor_ = frequency_sensor; }
   void set_line_freq(LineFrequency freq) { this->line_freq_ = freq; }
   void set_address(uint8_t address) { this->address_ = address; }
   void set_reset(bool reset) { this->reset_ = reset; }

esphome/components/bmp3xx_base/bmp3xx_base.cpp

@@ -6,9 +6,8 @@
 */
 
 #include "bmp3xx_base.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
+#include "esphome/core/hal.h"
 #include <cinttypes>
 
 namespace esphome {
@@ -27,18 +26,46 @@ static const LogString *chip_type_to_str(uint8_t chip_type) {
   }
 }
 
-// Oversampling strings indexed by Oversampling enum (0-5): NONE, X2, X4, X8, X16, X32
-PROGMEM_STRING_TABLE(OversamplingStrings, "None", "2x", "4x", "8x", "16x", "32x", "");
-
 static const LogString *oversampling_to_str(Oversampling oversampling) {
-  return OversamplingStrings::get_log_str(static_cast<uint8_t>(oversampling), OversamplingStrings::LAST_INDEX);
+  switch (oversampling) {
+    case Oversampling::OVERSAMPLING_NONE:
+      return LOG_STR("None");
+    case Oversampling::OVERSAMPLING_X2:
+      return LOG_STR("2x");
+    case Oversampling::OVERSAMPLING_X4:
+      return LOG_STR("4x");
+    case Oversampling::OVERSAMPLING_X8:
+      return LOG_STR("8x");
+    case Oversampling::OVERSAMPLING_X16:
+      return LOG_STR("16x");
+    case Oversampling::OVERSAMPLING_X32:
+      return LOG_STR("32x");
+    default:
+      return LOG_STR("");
+  }
 }
 
-// IIR filter strings indexed by IIRFilter enum (0-7): OFF, 2, 4, 8, 16, 32, 64, 128
-PROGMEM_STRING_TABLE(IIRFilterStrings, "OFF", "2x", "4x", "8x", "16x", "32x", "64x", "128x", "");
-
 static const LogString *iir_filter_to_str(IIRFilter filter) {
-  return IIRFilterStrings::get_log_str(static_cast<uint8_t>(filter), IIRFilterStrings::LAST_INDEX);
+  switch (filter) {
+    case IIRFilter::IIR_FILTER_OFF:
+      return LOG_STR("OFF");
+    case IIRFilter::IIR_FILTER_2:
+      return LOG_STR("2x");
+    case IIRFilter::IIR_FILTER_4:
+      return LOG_STR("4x");
+    case IIRFilter::IIR_FILTER_8:
+      return LOG_STR("8x");
+    case IIRFilter::IIR_FILTER_16:
+      return LOG_STR("16x");
+    case IIRFilter::IIR_FILTER_32:
+      return LOG_STR("32x");
+    case IIRFilter::IIR_FILTER_64:
+      return LOG_STR("64x");
+    case IIRFilter::IIR_FILTER_128:
+      return LOG_STR("128x");
+    default:
+      return LOG_STR("");
+  }
 }
 
 void BMP3XXComponent::setup() {

esphome/components/bmp581_base/bmp581_base.cpp

@@ -11,26 +11,57 @@
  */
 
 #include "bmp581_base.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
+#include "esphome/core/hal.h"
 
 namespace esphome::bmp581_base {
 
 static const char *const TAG = "bmp581";
 
-// Oversampling strings indexed by Oversampling enum (0-7): NONE, X2, X4, X8, X16, X32, X64, X128
-PROGMEM_STRING_TABLE(OversamplingStrings, "None", "2x", "4x", "8x", "16x", "32x", "64x", "128x", "");
-
 static const LogString *oversampling_to_str(Oversampling oversampling) {
-  return OversamplingStrings::get_log_str(static_cast<uint8_t>(oversampling), OversamplingStrings::LAST_INDEX);
+  switch (oversampling) {
+    case Oversampling::OVERSAMPLING_NONE:
+      return LOG_STR("None");
+    case Oversampling::OVERSAMPLING_X2:
+      return LOG_STR("2x");
+    case Oversampling::OVERSAMPLING_X4:
+      return LOG_STR("4x");
+    case Oversampling::OVERSAMPLING_X8:
+      return LOG_STR("8x");
+    case Oversampling::OVERSAMPLING_X16:
+      return LOG_STR("16x");
+    case Oversampling::OVERSAMPLING_X32:
+      return LOG_STR("32x");
+    case Oversampling::OVERSAMPLING_X64:
+      return LOG_STR("64x");
+    case Oversampling::OVERSAMPLING_X128:
+      return LOG_STR("128x");
+    default:
+      return LOG_STR("");
+  }
 }
 
-// IIR filter strings indexed by IIRFilter enum (0-7): OFF, 2, 4, 8, 16, 32, 64, 128
-PROGMEM_STRING_TABLE(IIRFilterStrings, "OFF", "2x", "4x", "8x", "16x", "32x", "64x", "128x", "");
-
 static const LogString *iir_filter_to_str(IIRFilter filter) {
-  return IIRFilterStrings::get_log_str(static_cast<uint8_t>(filter), IIRFilterStrings::LAST_INDEX);
+  switch (filter) {
+    case IIRFilter::IIR_FILTER_OFF:
+      return LOG_STR("OFF");
+    case IIRFilter::IIR_FILTER_2:
+      return LOG_STR("2x");
+    case IIRFilter::IIR_FILTER_4:
+      return LOG_STR("4x");
+    case IIRFilter::IIR_FILTER_8:
+      return LOG_STR("8x");
+    case IIRFilter::IIR_FILTER_16:
+      return LOG_STR("16x");
+    case IIRFilter::IIR_FILTER_32:
+      return LOG_STR("32x");
+    case IIRFilter::IIR_FILTER_64:
+      return LOG_STR("64x");
+    case IIRFilter::IIR_FILTER_128:
+      return LOG_STR("128x");
+    default:
+      return LOG_STR("");
+  }
 }
 
 void BMP581Component::dump_config() {

esphome/components/cover/__init__.py

@@ -11,7 +11,6 @@ from esphome.const import (
     CONF_ICON,
     CONF_ID,
     CONF_MQTT_ID,
-    CONF_MQTT_JSON_STATE_PAYLOAD,
     CONF_ON_IDLE,
     CONF_ON_OPEN,
     CONF_POSITION,
@@ -120,9 +119,6 @@ _COVER_SCHEMA = (
     .extend(
         {
             cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTCoverComponent),
-            cv.Optional(CONF_MQTT_JSON_STATE_PAYLOAD): cv.All(
-                cv.requires_component("mqtt"), cv.boolean
-            ),
             cv.Optional(CONF_DEVICE_CLASS): cv.one_of(*DEVICE_CLASSES, lower=True),
             cv.Optional(CONF_POSITION_COMMAND_TOPIC): cv.All(
                 cv.requires_component("mqtt"), cv.subscribe_topic
@@ -152,22 +148,6 @@ _COVER_SCHEMA = (
 _COVER_SCHEMA.add_extra(entity_duplicate_validator("cover"))
 
 
-def _validate_mqtt_state_topics(config):
-    if config.get(CONF_MQTT_JSON_STATE_PAYLOAD):
-        if CONF_POSITION_STATE_TOPIC in config:
-            raise cv.Invalid(
-                f"'{CONF_POSITION_STATE_TOPIC}' cannot be used with '{CONF_MQTT_JSON_STATE_PAYLOAD}: true'"
-            )
-        if CONF_TILT_STATE_TOPIC in config:
-            raise cv.Invalid(
-                f"'{CONF_TILT_STATE_TOPIC}' cannot be used with '{CONF_MQTT_JSON_STATE_PAYLOAD}: true'"
-            )
-    return config
-
-
-_COVER_SCHEMA.add_extra(_validate_mqtt_state_topics)
-
-
 def cover_schema(
     class_: MockObjClass,
     *,
@@ -215,9 +195,6 @@ async def setup_cover_core_(var, config):
             position_command_topic := config.get(CONF_POSITION_COMMAND_TOPIC)
         ) is not None:
             cg.add(mqtt_.set_custom_position_command_topic(position_command_topic))
-        if config.get(CONF_MQTT_JSON_STATE_PAYLOAD):
-            cg.add_define("USE_MQTT_COVER_JSON")
-            cg.add(mqtt_.set_use_json_format(True))
         if (tilt_state_topic := config.get(CONF_TILT_STATE_TOPIC)) is not None:
             cg.add(mqtt_.set_custom_tilt_state_topic(tilt_state_topic))
         if (tilt_command_topic := config.get(CONF_TILT_COMMAND_TOPIC)) is not None:

esphome/components/cse7766/cse7766.cpp

@@ -16,8 +16,8 @@ void CSE7766Component::loop() {
   }
 
   // Early return prevents updating last_transmission_ when no data is available.
-  size_t avail = this->available();
-  if (avail == 0) {
+  int 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(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/debug/debug_esp8266.cpp

@@ -1,7 +1,6 @@
 #include "debug_component.h"
 #ifdef USE_ESP8266
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include <Esp.h>
 
 extern "C" {
@@ -20,38 +19,27 @@ namespace debug {
 
 static const char *const TAG = "debug";
 
-// PROGMEM string table for reset reasons, indexed by reason code (0-6), with "Unknown" as fallback
-// clang-format off
-PROGMEM_STRING_TABLE(ResetReasonStrings,
-  "Power On",                  // 0 = REASON_DEFAULT_RST
-  "Hardware Watchdog",         // 1 = REASON_WDT_RST
-  "Exception",                 // 2 = REASON_EXCEPTION_RST
-  "Software Watchdog",         // 3 = REASON_SOFT_WDT_RST
-  "Software/System restart",   // 4 = REASON_SOFT_RESTART
-  "Deep-Sleep Wake",           // 5 = REASON_DEEP_SLEEP_AWAKE
-  "External System",           // 6 = REASON_EXT_SYS_RST
-  "Unknown"                    // 7 = fallback
-);
-// clang-format on
-static_assert(REASON_DEFAULT_RST == 0, "Reset reason enum values must match table indices");
-static_assert(REASON_WDT_RST == 1, "Reset reason enum values must match table indices");
-static_assert(REASON_EXCEPTION_RST == 2, "Reset reason enum values must match table indices");
-static_assert(REASON_SOFT_WDT_RST == 3, "Reset reason enum values must match table indices");
-static_assert(REASON_SOFT_RESTART == 4, "Reset reason enum values must match table indices");
-static_assert(REASON_DEEP_SLEEP_AWAKE == 5, "Reset reason enum values must match table indices");
-static_assert(REASON_EXT_SYS_RST == 6, "Reset reason enum values must match table indices");
-
-// PROGMEM string table for flash chip modes, indexed by mode code (0-3), with "UNKNOWN" as fallback
-PROGMEM_STRING_TABLE(FlashModeStrings, "QIO", "QOUT", "DIO", "DOUT", "UNKNOWN");
-static_assert(FM_QIO == 0, "Flash mode enum values must match table indices");
-static_assert(FM_QOUT == 1, "Flash mode enum values must match table indices");
-static_assert(FM_DIO == 2, "Flash mode enum values must match table indices");
-static_assert(FM_DOUT == 3, "Flash mode enum values must match table indices");
-
 // Get reset reason string from reason code (no heap allocation)
 // Returns LogString* pointing to flash (PROGMEM) on ESP8266
 static const LogString *get_reset_reason_str(uint32_t reason) {
-  return ResetReasonStrings::get_log_str(static_cast<uint8_t>(reason), ResetReasonStrings::LAST_INDEX);
+  switch (reason) {
+    case REASON_DEFAULT_RST:
+      return LOG_STR("Power On");
+    case REASON_WDT_RST:
+      return LOG_STR("Hardware Watchdog");
+    case REASON_EXCEPTION_RST:
+      return LOG_STR("Exception");
+    case REASON_SOFT_WDT_RST:
+      return LOG_STR("Software Watchdog");
+    case REASON_SOFT_RESTART:
+      return LOG_STR("Software/System restart");
+    case REASON_DEEP_SLEEP_AWAKE:
+      return LOG_STR("Deep-Sleep Wake");
+    case REASON_EXT_SYS_RST:
+      return LOG_STR("External System");
+    default:
+      return LOG_STR("Unknown");
+  }
 }
 
 // Size for core version hex buffer
@@ -104,9 +92,23 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
   char *buf = buffer.data();
 
-  const LogString *flash_mode = FlashModeStrings::get_log_str(
-      static_cast<uint8_t>(ESP.getFlashChipMode()),  // NOLINT(readability-static-accessed-through-instance)
-      FlashModeStrings::LAST_INDEX);
+  const LogString *flash_mode;
+  switch (ESP.getFlashChipMode()) {  // NOLINT(readability-static-accessed-through-instance)
+    case FM_QIO:
+      flash_mode = LOG_STR("QIO");
+      break;
+    case FM_QOUT:
+      flash_mode = LOG_STR("QOUT");
+      break;
+    case FM_DIO:
+      flash_mode = LOG_STR("DIO");
+      break;
+    case FM_DOUT:
+      flash_mode = LOG_STR("DOUT");
+      break;
+    default:
+      flash_mode = LOG_STR("UNKNOWN");
+  }
   uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT(readability-static-accessed-through-instance)
   uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT(readability-static-accessed-through-instance)
   ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed,

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.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/dlms_meter/dlms_meter.cpp

@@ -28,28 +28,15 @@ void DlmsMeterComponent::dump_config() {
 
 void DlmsMeterComponent::loop() {
   // Read while data is available, netznoe uses two frames so allow 2x max frame length
-  size_t avail = this->available();
-  if (avail > 0) {
-    size_t remaining = MBUS_MAX_FRAME_LENGTH * 2 - this->receive_buffer_.size();
-    if (remaining == 0) {
+  while (this->available()) {
+    if (this->receive_buffer_.size() >= MBUS_MAX_FRAME_LENGTH * 2) {
       ESP_LOGW(TAG, "Receive buffer full, dropping remaining bytes");
-    } 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();
-      }
+      break;
     }
+    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,7 +40,9 @@ bool Dsmr::ready_to_request_data_() {
       this->start_requesting_data_();
     }
     if (!this->requesting_data_) {
-      this->drain_rx_buffer_();
+      while (this->available()) {
+        this->read();
+      }
     }
   }
   return this->requesting_data_;
@@ -113,18 +115,10 @@ void Dsmr::stop_requesting_data_() {
     } else {
       ESP_LOGV(TAG, "Stop reading data from P1 port");
     }
-    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;
+    while (this->available()) {
+      this->read();
     }
+    this->requesting_data_ = false;
   }
 }
 
@@ -134,148 +128,125 @@ void Dsmr::reset_telegram_() {
   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_()) {
-    // 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;
+    const char c = this->read();
 
-      for (size_t i = 0; i < to_read; i++) {
-        const char c = static_cast<char>(buf[i]);
+    // 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;
 
-        // 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;
+    // 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;
+    }
 
-        // 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;
+    // 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;
+    }
   }
 }
 
 void Dsmr::receive_encrypted_telegram_() {
   while (this->available_within_timeout_()) {
-    // 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;
+    const char c = this->read();
 
-      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;
+    // 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;
   }
 }
 

esphome/components/dsmr/dsmr.h

@@ -85,7 +85,6 @@ 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,7 +135,6 @@ 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
@@ -1436,6 +1435,10 @@ async def to_code(config):
         CORE.relative_internal_path(".espressif")
     )
 
+    # Set the uv cache inside the data dir so "Clean All" clears it.
+    # Avoids persistent corrupted cache from mid-stream download failures.
+    os.environ["UV_CACHE_DIR"] = str(CORE.relative_internal_path(".uv_cache"))
+
     if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
         cg.add_build_flag("-DUSE_ESP_IDF")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")

esphome/components/esp32/preferences.cpp

@@ -124,11 +124,14 @@ class ESP32Preferences : public ESPPreferences {
       return true;
 
     ESP_LOGV(TAG, "Saving %zu items...", s_pending_save.size());
+    // goal try write all pending saves even if one fails
     int cached = 0, written = 0, failed = 0;
     esp_err_t last_err = ESP_OK;
     uint32_t last_key = 0;
 
-    for (const auto &save : s_pending_save) {
+    // go through vector from back to front (makes erase easier/more efficient)
+    for (ssize_t i = s_pending_save.size() - 1; i >= 0; i--) {
+      const auto &save = s_pending_save[i];
       char key_str[KEY_BUFFER_SIZE];
       snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
       ESP_LOGVV(TAG, "Checking if NVS data %s has changed", key_str);
@@ -147,9 +150,8 @@ class ESP32Preferences : public ESPPreferences {
         ESP_LOGV(TAG, "NVS data not changed skipping %" PRIu32 "  len=%zu", save.key, save.len);
         cached++;
       }
+      s_pending_save.erase(s_pending_save.begin() + i);
     }
-    s_pending_save.clear();
-
     ESP_LOGD(TAG, "Writing %d items: %d cached, %d written, %d failed", cached + written + failed, cached, written,
              failed);
     if (failed > 0) {

esphome/components/esp32_ble/ble.cpp

@@ -369,9 +369,42 @@ bool ESP32BLE::ble_dismantle_() {
 }
 
 void ESP32BLE::loop() {
-  if (this->state_ != BLE_COMPONENT_STATE_ACTIVE) {
-    this->loop_handle_state_transition_not_active_();
-    return;
+  switch (this->state_) {
+    case BLE_COMPONENT_STATE_OFF:
+    case BLE_COMPONENT_STATE_DISABLED:
+      return;
+    case BLE_COMPONENT_STATE_DISABLE: {
+      ESP_LOGD(TAG, "Disabling");
+
+#ifdef ESPHOME_ESP32_BLE_BLE_STATUS_EVENT_HANDLER_COUNT
+      for (auto *ble_event_handler : this->ble_status_event_handlers_) {
+        ble_event_handler->ble_before_disabled_event_handler();
+      }
+#endif
+
+      if (!ble_dismantle_()) {
+        ESP_LOGE(TAG, "Could not be dismantled");
+        this->mark_failed();
+        return;
+      }
+      this->state_ = BLE_COMPONENT_STATE_DISABLED;
+      return;
+    }
+    case BLE_COMPONENT_STATE_ENABLE: {
+      ESP_LOGD(TAG, "Enabling");
+      this->state_ = BLE_COMPONENT_STATE_OFF;
+
+      if (!ble_setup_()) {
+        ESP_LOGE(TAG, "Could not be set up");
+        this->mark_failed();
+        return;
+      }
+
+      this->state_ = BLE_COMPONENT_STATE_ACTIVE;
+      return;
+    }
+    case BLE_COMPONENT_STATE_ACTIVE:
+      break;
   }
 
   BLEEvent *ble_event = this->ble_events_.pop();
@@ -487,37 +520,6 @@ void ESP32BLE::loop() {
   }
 }
 
-void ESP32BLE::loop_handle_state_transition_not_active_() {
-  // Caller ensures state_ != ACTIVE
-  if (this->state_ == BLE_COMPONENT_STATE_DISABLE) {
-    ESP_LOGD(TAG, "Disabling");
-
-#ifdef ESPHOME_ESP32_BLE_BLE_STATUS_EVENT_HANDLER_COUNT
-    for (auto *ble_event_handler : this->ble_status_event_handlers_) {
-      ble_event_handler->ble_before_disabled_event_handler();
-    }
-#endif
-
-    if (!ble_dismantle_()) {
-      ESP_LOGE(TAG, "Could not be dismantled");
-      this->mark_failed();
-      return;
-    }
-    this->state_ = BLE_COMPONENT_STATE_DISABLED;
-  } else if (this->state_ == BLE_COMPONENT_STATE_ENABLE) {
-    ESP_LOGD(TAG, "Enabling");
-    this->state_ = BLE_COMPONENT_STATE_OFF;
-
-    if (!ble_setup_()) {
-      ESP_LOGE(TAG, "Could not be set up");
-      this->mark_failed();
-      return;
-    }
-
-    this->state_ = BLE_COMPONENT_STATE_ACTIVE;
-  }
-}
-
 // Helper function to load new event data based on type
 void load_ble_event(BLEEvent *event, esp_gap_ble_cb_event_t e, esp_ble_gap_cb_param_t *p) {
   event->load_gap_event(e, p);

esphome/components/esp32_ble/ble.h

@@ -155,10 +155,6 @@ class ESP32BLE : public Component {
 #endif
   static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param);
 
-  // Handle DISABLE and ENABLE transitions when not in the ACTIVE state.
-  // Other non-ACTIVE states (e.g. OFF, DISABLED) are currently treated as no-ops.
-  void __attribute__((noinline)) loop_handle_state_transition_not_active_();
-
   bool ble_setup_();
   bool ble_dismantle_();
   bool ble_pre_setup_();

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.3.2")
+        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.2.4")
         esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.4")
-        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.11.5")
+        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.9.3")
     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_improv/esp32_improv_component.cpp

@@ -338,8 +338,8 @@ void ESP32ImprovComponent::process_incoming_data_() {
           return;
         }
         wifi::WiFiAP sta{};
-        sta.set_ssid(command.ssid.c_str());
-        sta.set_password(command.password.c_str());
+        sta.set_ssid(command.ssid);
+        sta.set_password(command.password);
         this->connecting_sta_ = sta;
 
         wifi::global_wifi_component->set_sta(sta);

esphome/components/esp32_rmt_led_strip/led_strip.cpp

@@ -7,24 +7,21 @@
 #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";
 
-static const size_t RMT_SYMBOLS_PER_BYTE = 8;
+#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
 
-// 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;
-}
+static const size_t RMT_SYMBOLS_PER_BYTE = 8;
 
 #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,
@@ -95,7 +92,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_resolution_hz();
+  channel.resolution_hz = RMT_CLK_FREQ / RMT_CLK_DIV;
   channel.gpio_num = gpio_num_t(this->pin_);
   channel.mem_block_symbols = this->rmt_symbols_;
   channel.trans_queue_depth = 1;
@@ -140,7 +137,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_resolution_hz() / 1e09f;
+  float ratio = (float) RMT_CLK_FREQ / RMT_CLK_DIV / 1e09f;
 
   // 0-bit
   this->params_.bit0.duration0 = (uint32_t) (ratio * bit0_high);

esphome/components/esp8266/preferences.cpp

@@ -33,10 +33,6 @@ static constexpr uint32_t MAX_PREFERENCE_WORDS = 255;
 
 #define ESP_RTC_USER_MEM ((uint32_t *) ESP_RTC_USER_MEM_START)
 
-// Flash storage size depends on esp8266 -> restore_from_flash YAML option (default: false).
-// When enabled (USE_ESP8266_PREFERENCES_FLASH), all preferences default to flash and need
-// 128 words (512 bytes). When disabled, only explicit flash prefs use this storage so
-// 64 words (256 bytes) suffices since most preferences go to RTC memory instead.
 #ifdef USE_ESP8266_PREFERENCES_FLASH
 static constexpr uint32_t ESP8266_FLASH_STORAGE_SIZE = 128;
 #else
@@ -131,11 +127,9 @@ static bool load_from_rtc(size_t offset, uint32_t *data, size_t len) {
   return true;
 }
 
-// Maximum buffer for any single preference - bounded by storage sizes.
-// Flash prefs: bounded by ESP8266_FLASH_STORAGE_SIZE (128 or 64 words).
-// RTC prefs: bounded by RTC_NORMAL_REGION_WORDS (96) - a single pref can't span both RTC regions.
-static constexpr size_t PREF_MAX_BUFFER_WORDS =
-    ESP8266_FLASH_STORAGE_SIZE > RTC_NORMAL_REGION_WORDS ? ESP8266_FLASH_STORAGE_SIZE : RTC_NORMAL_REGION_WORDS;
+// Stack buffer size - 16 words total: up to 15 words of preference data + 1 word CRC (60 bytes of preference data)
+// This handles virtually all real-world preferences without heap allocation
+static constexpr size_t PREF_BUFFER_WORDS = 16;
 
 class ESP8266PreferenceBackend : public ESPPreferenceBackend {
  public:
@@ -147,13 +141,15 @@ class ESP8266PreferenceBackend : public ESPPreferenceBackend {
   bool save(const uint8_t *data, size_t len) override {
     if (bytes_to_words(len) != this->length_words)
       return false;
+
     const size_t buffer_size = static_cast<size_t>(this->length_words) + 1;
-    if (buffer_size > PREF_MAX_BUFFER_WORDS)
-      return false;
-    uint32_t buffer[PREF_MAX_BUFFER_WORDS];
+    SmallBufferWithHeapFallback<PREF_BUFFER_WORDS, uint32_t> buffer_alloc(buffer_size);
+    uint32_t *buffer = buffer_alloc.get();
     memset(buffer, 0, buffer_size * sizeof(uint32_t));
+
     memcpy(buffer, data, len);
     buffer[this->length_words] = calculate_crc(buffer, buffer + this->length_words, this->type);
+
     return this->in_flash ? save_to_flash(this->offset, buffer, buffer_size)
                           : save_to_rtc(this->offset, buffer, buffer_size);
   }
@@ -161,16 +157,19 @@ class ESP8266PreferenceBackend : public ESPPreferenceBackend {
   bool load(uint8_t *data, size_t len) override {
     if (bytes_to_words(len) != this->length_words)
       return false;
+
     const size_t buffer_size = static_cast<size_t>(this->length_words) + 1;
-    if (buffer_size > PREF_MAX_BUFFER_WORDS)
-      return false;
-    uint32_t buffer[PREF_MAX_BUFFER_WORDS];
+    SmallBufferWithHeapFallback<PREF_BUFFER_WORDS, uint32_t> buffer_alloc(buffer_size);
+    uint32_t *buffer = buffer_alloc.get();
+
     bool ret = this->in_flash ? load_from_flash(this->offset, buffer, buffer_size)
                               : load_from_rtc(this->offset, buffer, buffer_size);
     if (!ret)
       return false;
+
     if (buffer[this->length_words] != calculate_crc(buffer, buffer + this->length_words, this->type))
       return false;
+
     memcpy(data, buffer, len);
     return true;
   }

esphome/components/hlk_fm22x/hlk_fm22x.cpp

@@ -1,16 +1,20 @@
 #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() > 0) {
+  while (this->available()) {
     this->read();
   }
   this->defer([this]() { this->send_command_(HlkFm22xCommand::GET_STATUS); });
@@ -31,7 +35,7 @@ void HlkFm22xComponent::update() {
 }
 
 void HlkFm22xComponent::enroll_face(const std::string &name, HlkFm22xFaceDirection direction) {
-  if (name.length() > HLK_FM22X_NAME_SIZE - 1) {
+  if (name.length() > 31) {
     ESP_LOGE(TAG, "enroll_face(): name too long '%s'", name.c_str());
     return;
   }
@@ -84,7 +88,7 @@ void HlkFm22xComponent::send_command_(HlkFm22xCommand command, const uint8_t *da
   }
   this->wait_cycles_ = 0;
   this->active_command_ = command;
-  while (this->available() > 0)
+  while (this->available())
     this->read();
   this->write((uint8_t) (START_CODE >> 8));
   this->write((uint8_t) (START_CODE & 0xFF));
@@ -133,24 +137,17 @@ void HlkFm22xComponent::recv_command_() {
   checksum ^= byte;
   length |= byte;
 
-  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;
-  }
-
+  std::vector<uint8_t> data;
+  data.reserve(length);
   for (uint16_t idx = 0; idx < length; ++idx) {
     byte = this->read();
     checksum ^= byte;
-    this->recv_buf_[idx] = byte;
+    data.push_back(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, this->recv_buf_.data(), length));
+  ESP_LOGV(TAG, "Recv type: 0x%.2X, data: %s", response_type, format_hex_pretty_to(hex_buf, data.data(), data.size()));
 #endif
 
   byte = this->read();
@@ -160,10 +157,10 @@ void HlkFm22xComponent::recv_command_() {
   }
   switch (response_type) {
     case HlkFm22xResponseType::NOTE:
-      this->handle_note_(this->recv_buf_.data(), length);
+      this->handle_note_(data);
       break;
     case HlkFm22xResponseType::REPLY:
-      this->handle_reply_(this->recv_buf_.data(), length);
+      this->handle_reply_(data);
       break;
     default:
       ESP_LOGW(TAG, "Unexpected response type: 0x%.2X", response_type);
@@ -171,15 +168,11 @@ void HlkFm22xComponent::recv_command_() {
   }
 }
 
-void HlkFm22xComponent::handle_note_(const uint8_t *data, size_t length) {
-  if (length < 1) {
-    ESP_LOGE(TAG, "Empty note data");
-    return;
-  }
+void HlkFm22xComponent::handle_note_(const std::vector<uint8_t> &data) {
   switch (data[0]) {
     case HlkFm22xNoteType::FACE_STATE:
-      if (length < 17) {
-        ESP_LOGE(TAG, "Invalid face note data size: %zu", length);
+      if (data.size() < 17) {
+        ESP_LOGE(TAG, "Invalid face note data size: %u", data.size());
         break;
       }
       {
@@ -216,13 +209,9 @@ void HlkFm22xComponent::handle_note_(const uint8_t *data, size_t length) {
   }
 }
 
-void HlkFm22xComponent::handle_reply_(const uint8_t *data, size_t length) {
+void HlkFm22xComponent::handle_reply_(const std::vector<uint8_t> &data) {
   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;
@@ -249,20 +238,16 @@ void HlkFm22xComponent::handle_reply_(const uint8_t *data, size_t length) {
   }
   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];
-      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);
+      std::string name(data.begin() + 4, data.begin() + 36);
+      ESP_LOGD(TAG, "Face verified. ID: %d, name: %s", face_id, name.c_str());
       if (this->last_face_id_sensor_ != nullptr) {
         this->last_face_id_sensor_->publish_state(face_id);
       }
       if (this->last_face_name_text_sensor_ != nullptr) {
-        this->last_face_name_text_sensor_->publish_state(name_ptr, HLK_FM22X_NAME_SIZE);
+        this->last_face_name_text_sensor_->publish_state(name);
       }
-      this->face_scan_matched_callback_.call(face_id, std::string(name_ptr, HLK_FM22X_NAME_SIZE));
+      this->face_scan_matched_callback_.call(face_id, name);
       break;
     }
     case HlkFm22xCommand::ENROLL: {
@@ -281,8 +266,9 @@ void HlkFm22xComponent::handle_reply_(const uint8_t *data, size_t length) {
       this->defer([this]() { this->send_command_(HlkFm22xCommand::GET_VERSION); });
       break;
     case HlkFm22xCommand::GET_VERSION:
-      if (this->version_text_sensor_ != nullptr && length > 2) {
-        this->version_text_sensor_->publish_state(reinterpret_cast<const char *>(data + 2), length - 2);
+      if (this->version_text_sensor_ != nullptr) {
+        std::string version(data.begin() + 2, data.end());
+        this->version_text_sensor_->publish_state(version);
       }
       this->defer([this]() { this->get_face_count_(); });
       break;

esphome/components/hlk_fm22x/hlk_fm22x.h

@@ -7,15 +7,12 @@
 #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,
@@ -121,11 +118,10 @@ 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 uint8_t *data, size_t length);
-  void handle_reply_(const uint8_t *data, size_t length);
+  void handle_note_(const std::vector<uint8_t> &data);
+  void handle_reply_(const std::vector<uint8_t> &data);
   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,7 +94,10 @@ CONFIG_SCHEMA = cv.Schema(
 
 async def to_code(config):
     if CORE.is_esp32:
-        include_builtin_idf_component("esp_driver_pcnt")
+        # 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")
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/http_request/http_request.h

@@ -103,42 +103,6 @@ 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
@@ -240,13 +204,9 @@ class HttpContainer : public Parented<HttpRequestComponent> {
 
   size_t get_bytes_read() const { return this->bytes_read_; }
 
-  /// 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 {
+  /// 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 {
     // 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,50 +218,32 @@ 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: all chunked data received (is_chunk_complete true) or connection closed
-//   -ESP_ERR_HTTP_EAGAIN: transport timeout, no data available yet
+//   0: connection closed (end of stream)
 //   < 0: error
 //
 // We normalize to HttpContainer::read() contract:
 //   > 0: bytes read
-//   0: all content read (for both content_length-based and chunked completion)
+//   0: all content read (only returned when content_length is known and fully read)
 //   < 0: error/connection closed
 //
 // Note on chunked transfer encoding:
 //   esp_http_client_fetch_headers() returns 0 for chunked responses (no Content-Length header).
-//   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.
+//   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.
 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 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()) {
+  // 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()) {
     return 0;  // All content read successfully
   }
 
@@ -276,18 +258,15 @@ int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
     return read_len_or_error;
   }
 
-  // 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)
+  // 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.
   if (read_len_or_error == 0) {
-    return 0;
+    return HTTP_ERROR_CONNECTION_CLOSED;
   }
 
   // Negative value - error, return the actual error code for debugging

esphome/components/http_request/http_request_idf.h

@@ -16,7 +16,6 @@ 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/http_request/update/http_request_update.cpp

@@ -90,14 +90,16 @@ void HttpRequestUpdate::update_task(void *params) {
     UPDATE_RETURN;
   }
   size_t read_index = container->get_bytes_read();
-  size_t content_length = container->content_length;
-
-  container->end();
-  container.reset();  // Release ownership of the container's shared_ptr
 
   bool valid = false;
-  {  // Scope to ensure JsonDocument is destroyed before deallocating buffer
-    valid = json::parse_json(data, read_index, [this_update](JsonObject root) -> bool {
+  {  // Ensures the response string falls out of scope and deallocates before the task ends
+    std::string response((char *) data, read_index);
+    allocator.deallocate(data, container->content_length);
+
+    container->end();
+    container.reset();  // Release ownership of the container's shared_ptr
+
+    valid = json::parse_json(response, [this_update](JsonObject root) -> bool {
       if (!root[ESPHOME_F("name")].is<const char *>() || !root[ESPHOME_F("version")].is<const char *>() ||
           !root[ESPHOME_F("builds")].is<JsonArray>()) {
         ESP_LOGE(TAG, "Manifest does not contain required fields");
@@ -135,7 +137,6 @@ void HttpRequestUpdate::update_task(void *params) {
       return false;
     });
   }
-  allocator.deallocate(data, content_length);
 
   if (!valid) {
     ESP_LOGE(TAG, "Failed to parse JSON from %s", this_update->source_url_.c_str());
@@ -156,12 +157,17 @@ void HttpRequestUpdate::update_task(void *params) {
     }
   }
 
+  {  // Ensures the current version string falls out of scope and deallocates before the task ends
+    std::string current_version;
 #ifdef ESPHOME_PROJECT_VERSION
-  this_update->update_info_.current_version = ESPHOME_PROJECT_VERSION;
+    current_version = ESPHOME_PROJECT_VERSION;
 #else
-  this_update->update_info_.current_version = ESPHOME_VERSION;
+    current_version = ESPHOME_VERSION;
 #endif
 
+    this_update->update_info_.current_version = current_version;
+  }
+
   bool trigger_update_available = false;
 
   if (this_update->update_info_.latest_version.empty() ||

esphome/components/improv_serial/improv_serial_component.cpp

@@ -235,8 +235,8 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
   switch (command.command) {
     case improv::WIFI_SETTINGS: {
       wifi::WiFiAP sta{};
-      sta.set_ssid(command.ssid.c_str());
-      sta.set_password(command.password.c_str());
+      sta.set_ssid(command.ssid);
+      sta.set_password(command.password);
       this->connecting_sta_ = sta;
 
       wifi::global_wifi_component->set_sta(sta);
@@ -267,26 +267,16 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
       for (auto &scan : results) {
         if (scan.get_is_hidden())
           continue;
-        const char *ssid_cstr = scan.get_ssid().c_str();
-        // Check if we've already sent this SSID
-        bool duplicate = false;
-        for (const auto &seen : networks) {
-          if (strcmp(seen.c_str(), ssid_cstr) == 0) {
-            duplicate = true;
-            break;
-          }
-        }
-        if (duplicate)
+        const std::string &ssid = scan.get_ssid();
+        if (std::find(networks.begin(), networks.end(), ssid) != networks.end())
           continue;
-        // Only allocate std::string after confirming it's not a duplicate
-        std::string ssid(ssid_cstr);
         // Send each ssid separately to avoid overflowing the buffer
         char rssi_buf[5];  // int8_t: -128 to 127, max 4 chars + null
         *int8_to_str(rssi_buf, scan.get_rssi()) = '\0';
         std::vector<uint8_t> data =
             improv::build_rpc_response(improv::GET_WIFI_NETWORKS, {ssid, rssi_buf, YESNO(scan.get_with_auth())}, false);
         this->send_response_(data);
-        networks.push_back(std::move(ssid));
+        networks.push_back(ssid);
       }
       // Send empty response to signify the end of the list.
       std::vector<uint8_t> data =

esphome/components/json/json_util.cpp

@@ -25,13 +25,8 @@ std::string build_json(const json_build_t &f) {
 }
 
 bool parse_json(const std::string &data, const json_parse_t &f) {
-  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  return parse_json(reinterpret_cast<const uint8_t *>(data.c_str()), data.size(), f);
-}
-
-bool parse_json(const uint8_t *data, size_t len, const json_parse_t &f) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  JsonDocument doc = parse_json(data, len);
+  JsonDocument doc = parse_json(reinterpret_cast<const uint8_t *>(data.c_str()), data.size());
   if (doc.overflowed() || doc.isNull())
     return false;
   return f(doc.as<JsonObject>());

esphome/components/json/json_util.h

@@ -50,8 +50,6 @@ std::string build_json(const json_build_t &f);
 
 /// Parse a JSON string and run the provided json parse function if it's valid.
 bool parse_json(const std::string &data, const json_parse_t &f);
-/// Parse JSON from raw bytes and run the provided json parse function if it's valid.
-bool parse_json(const uint8_t *data, size_t len, const json_parse_t &f);
 
 /// Parse a JSON string and return the root JsonDocument (or an unbound object on error)
 JsonDocument parse_json(const uint8_t *data, size_t len);

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.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(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.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/ld2420/ld2420.cpp

@@ -335,10 +335,9 @@ 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.
-  if (this->cmd_active_) {
-    return;
+  while (!this->cmd_active_ && this->available()) {
+    this->readline_(this->read(), this->buffer_data_, MAX_LINE_LENGTH);
   }
-  this->read_batch_(this->buffer_data_);
 }
 
 void LD2420Component::update_radar_data(uint16_t const *gate_energy, uint8_t sample_number) {
@@ -540,23 +539,6 @@ 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,7 +4,6 @@
 #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
@@ -166,7 +165,6 @@ 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,8 +1,7 @@
-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_ON_DATA, CONF_THROTTLE, CONF_TRIGGER_ID
+from esphome.const import CONF_ID, CONF_THROTTLE
 
 AUTO_LOAD = ["ld24xx"]
 DEPENDENCIES = ["uart"]
@@ -12,8 +11,6 @@ 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(
@@ -23,11 +20,6 @@ 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)
@@ -53,6 +45,3 @@ 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.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }
@@ -413,10 +413,6 @@ 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);
@@ -617,8 +613,6 @@ 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,9 +141,6 @@ 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);
@@ -193,15 +190,6 @@ 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/libretiny/__init__.py

@@ -193,14 +193,14 @@ def _notify_old_style(config):
 # The dev and latest branches will be at *least* this version, which is what matters.
 # Use GitHub releases directly to avoid PlatformIO moderation delays.
 ARDUINO_VERSIONS = {
-    "dev": (cv.Version(1, 12, 1), "https://github.com/libretiny-eu/libretiny.git"),
+    "dev": (cv.Version(1, 11, 0), "https://github.com/libretiny-eu/libretiny.git"),
     "latest": (
-        cv.Version(1, 12, 1),
-        "https://github.com/libretiny-eu/libretiny.git#v1.12.1",
+        cv.Version(1, 11, 0),
+        "https://github.com/libretiny-eu/libretiny.git#v1.11.0",
     ),
     "recommended": (
-        cv.Version(1, 12, 1),
-        "https://github.com/libretiny-eu/libretiny.git#v1.12.1",
+        cv.Version(1, 11, 0),
+        "https://github.com/libretiny-eu/libretiny.git#v1.11.0",
     ),
 }
 

esphome/components/libretiny/preferences.cpp

@@ -114,11 +114,14 @@ class LibreTinyPreferences : public ESPPreferences {
       return true;
 
     ESP_LOGV(TAG, "Saving %zu items...", s_pending_save.size());
+    // goal try write all pending saves even if one fails
     int cached = 0, written = 0, failed = 0;
     fdb_err_t last_err = FDB_NO_ERR;
     uint32_t last_key = 0;
 
-    for (const auto &save : s_pending_save) {
+    // go through vector from back to front (makes erase easier/more efficient)
+    for (ssize_t i = s_pending_save.size() - 1; i >= 0; i--) {
+      const auto &save = s_pending_save[i];
       char key_str[KEY_BUFFER_SIZE];
       snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
       ESP_LOGVV(TAG, "Checking if FDB data %s has changed", key_str);
@@ -138,9 +141,8 @@ class LibreTinyPreferences : public ESPPreferences {
         ESP_LOGD(TAG, "FDB data not changed; skipping %" PRIu32 "  len=%zu", save.key, save.len);
         cached++;
       }
+      s_pending_save.erase(s_pending_save.begin() + i);
     }
-    s_pending_save.clear();
-
     ESP_LOGD(TAG, "Writing %d items: %d cached, %d written, %d failed", cached + written + failed, cached, written,
              failed);
     if (failed > 0) {

esphome/components/light/light_call.cpp

@@ -270,23 +270,22 @@ LightColorValues LightCall::validate_() {
   if (this->has_state())
     v.set_state(this->state_);
 
-    // clamp_and_log_if_invalid already clamps in-place, so assign directly
-    // to avoid redundant clamp code from the setter being inlined.
-#define VALIDATE_AND_APPLY(field, name_str, ...) \
+#define VALIDATE_AND_APPLY(field, setter, name_str, ...) \
   if (this->has_##field()) { \
     clamp_and_log_if_invalid(name, this->field##_, LOG_STR(name_str), ##__VA_ARGS__); \
-    v.field##_ = this->field##_; \
+    v.setter(this->field##_); \
   }
 
-  VALIDATE_AND_APPLY(brightness, "Brightness")
-  VALIDATE_AND_APPLY(color_brightness, "Color brightness")
-  VALIDATE_AND_APPLY(red, "Red")
-  VALIDATE_AND_APPLY(green, "Green")
-  VALIDATE_AND_APPLY(blue, "Blue")
-  VALIDATE_AND_APPLY(white, "White")
-  VALIDATE_AND_APPLY(cold_white, "Cold white")
-  VALIDATE_AND_APPLY(warm_white, "Warm white")
-  VALIDATE_AND_APPLY(color_temperature, "Color temperature", traits.get_min_mireds(), traits.get_max_mireds())
+  VALIDATE_AND_APPLY(brightness, set_brightness, "Brightness")
+  VALIDATE_AND_APPLY(color_brightness, set_color_brightness, "Color brightness")
+  VALIDATE_AND_APPLY(red, set_red, "Red")
+  VALIDATE_AND_APPLY(green, set_green, "Green")
+  VALIDATE_AND_APPLY(blue, set_blue, "Blue")
+  VALIDATE_AND_APPLY(white, set_white, "White")
+  VALIDATE_AND_APPLY(cold_white, set_cold_white, "Cold white")
+  VALIDATE_AND_APPLY(warm_white, set_warm_white, "Warm white")
+  VALIDATE_AND_APPLY(color_temperature, set_color_temperature, "Color temperature", traits.get_min_mireds(),
+                     traits.get_max_mireds())
 
 #undef VALIDATE_AND_APPLY
 

esphome/components/light/light_color_values.h

@@ -95,18 +95,15 @@ class LightColorValues {
    */
   void normalize_color() {
     if (this->color_mode_ & ColorCapability::RGB) {
-      float max_value = fmaxf(this->red_, fmaxf(this->green_, this->blue_));
-      // Assign directly to avoid redundant clamp in set_red/green/blue.
-      // Values are guaranteed in [0,1]: inputs are already clamped to [0,1],
-      // and dividing by max_value (the largest) keeps results in [0,1].
+      float max_value = fmaxf(this->get_red(), fmaxf(this->get_green(), this->get_blue()));
       if (max_value == 0.0f) {
-        this->red_ = 1.0f;
-        this->green_ = 1.0f;
-        this->blue_ = 1.0f;
+        this->set_red(1.0f);
+        this->set_green(1.0f);
+        this->set_blue(1.0f);
       } else {
-        this->red_ /= max_value;
-        this->green_ /= max_value;
-        this->blue_ /= max_value;
+        this->set_red(this->get_red() / max_value);
+        this->set_green(this->get_green() / max_value);
+        this->set_blue(this->get_blue() / max_value);
       }
     }
   }
@@ -279,8 +276,6 @@ class LightColorValues {
   /// Set the warm white property of these light color values. In range 0.0 to 1.0.
   void set_warm_white(float warm_white) { this->warm_white_ = clamp(warm_white, 0.0f, 1.0f); }
 
-  friend class LightCall;
-
  protected:
   float state_;  ///< ON / OFF, float for transition
   float brightness_;

esphome/components/ln882x/boards.py

@@ -154,26 +154,28 @@ LN882X_BOARD_PINS = {
         "A7": 21,
     },
     "wb02a": {
-        "WIRE0_SCL_0": 1,
-        "WIRE0_SCL_1": 2,
+        "WIRE0_SCL_0": 7,
+        "WIRE0_SCL_1": 5,
         "WIRE0_SCL_2": 3,
-        "WIRE0_SCL_3": 4,
-        "WIRE0_SCL_4": 5,
-        "WIRE0_SCL_5": 7,
-        "WIRE0_SCL_6": 9,
-        "WIRE0_SCL_7": 10,
-        "WIRE0_SCL_8": 24,
-        "WIRE0_SCL_9": 25,
-        "WIRE0_SDA_0": 1,
-        "WIRE0_SDA_1": 2,
+        "WIRE0_SCL_3": 10,
+        "WIRE0_SCL_4": 2,
+        "WIRE0_SCL_5": 1,
+        "WIRE0_SCL_6": 4,
+        "WIRE0_SCL_7": 5,
+        "WIRE0_SCL_8": 9,
+        "WIRE0_SCL_9": 24,
+        "WIRE0_SCL_10": 25,
+        "WIRE0_SDA_0": 7,
+        "WIRE0_SDA_1": 5,
         "WIRE0_SDA_2": 3,
-        "WIRE0_SDA_3": 4,
-        "WIRE0_SDA_4": 5,
-        "WIRE0_SDA_5": 7,
-        "WIRE0_SDA_6": 9,
-        "WIRE0_SDA_7": 10,
-        "WIRE0_SDA_8": 24,
-        "WIRE0_SDA_9": 25,
+        "WIRE0_SDA_3": 10,
+        "WIRE0_SDA_4": 2,
+        "WIRE0_SDA_5": 1,
+        "WIRE0_SDA_6": 4,
+        "WIRE0_SDA_7": 5,
+        "WIRE0_SDA_8": 9,
+        "WIRE0_SDA_9": 24,
+        "WIRE0_SDA_10": 25,
         "SERIAL0_RX": 3,
         "SERIAL0_TX": 2,
         "SERIAL1_RX": 24,
@@ -219,32 +221,32 @@ LN882X_BOARD_PINS = {
         "A1": 4,
     },
     "wl2s": {
-        "WIRE0_SCL_0": 0,
-        "WIRE0_SCL_1": 1,
-        "WIRE0_SCL_2": 2,
-        "WIRE0_SCL_3": 3,
-        "WIRE0_SCL_4": 5,
-        "WIRE0_SCL_5": 7,
-        "WIRE0_SCL_6": 9,
-        "WIRE0_SCL_7": 10,
-        "WIRE0_SCL_8": 11,
-        "WIRE0_SCL_9": 12,
-        "WIRE0_SCL_10": 19,
-        "WIRE0_SCL_11": 24,
-        "WIRE0_SCL_12": 25,
-        "WIRE0_SDA_0": 0,
-        "WIRE0_SDA_1": 1,
-        "WIRE0_SDA_2": 2,
-        "WIRE0_SDA_3": 3,
-        "WIRE0_SDA_4": 5,
-        "WIRE0_SDA_5": 7,
-        "WIRE0_SDA_6": 9,
-        "WIRE0_SDA_7": 10,
-        "WIRE0_SDA_8": 11,
-        "WIRE0_SDA_9": 12,
-        "WIRE0_SDA_10": 19,
-        "WIRE0_SDA_11": 24,
-        "WIRE0_SDA_12": 25,
+        "WIRE0_SCL_0": 7,
+        "WIRE0_SCL_1": 12,
+        "WIRE0_SCL_2": 3,
+        "WIRE0_SCL_3": 10,
+        "WIRE0_SCL_4": 2,
+        "WIRE0_SCL_5": 0,
+        "WIRE0_SCL_6": 19,
+        "WIRE0_SCL_7": 11,
+        "WIRE0_SCL_8": 9,
+        "WIRE0_SCL_9": 24,
+        "WIRE0_SCL_10": 25,
+        "WIRE0_SCL_11": 5,
+        "WIRE0_SCL_12": 1,
+        "WIRE0_SDA_0": 7,
+        "WIRE0_SDA_1": 12,
+        "WIRE0_SDA_2": 3,
+        "WIRE0_SDA_3": 10,
+        "WIRE0_SDA_4": 2,
+        "WIRE0_SDA_5": 0,
+        "WIRE0_SDA_6": 19,
+        "WIRE0_SDA_7": 11,
+        "WIRE0_SDA_8": 9,
+        "WIRE0_SDA_9": 24,
+        "WIRE0_SDA_10": 25,
+        "WIRE0_SDA_11": 5,
+        "WIRE0_SDA_12": 1,
         "SERIAL0_RX": 3,
         "SERIAL0_TX": 2,
         "SERIAL1_RX": 24,
@@ -299,24 +301,24 @@ LN882X_BOARD_PINS = {
         "A2": 1,
     },
     "ln-02": {
-        "WIRE0_SCL_0": 0,
-        "WIRE0_SCL_1": 1,
-        "WIRE0_SCL_2": 2,
-        "WIRE0_SCL_3": 3,
-        "WIRE0_SCL_4": 9,
-        "WIRE0_SCL_5": 11,
-        "WIRE0_SCL_6": 19,
-        "WIRE0_SCL_7": 24,
-        "WIRE0_SCL_8": 25,
-        "WIRE0_SDA_0": 0,
-        "WIRE0_SDA_1": 1,
-        "WIRE0_SDA_2": 2,
-        "WIRE0_SDA_3": 3,
-        "WIRE0_SDA_4": 9,
-        "WIRE0_SDA_5": 11,
-        "WIRE0_SDA_6": 19,
-        "WIRE0_SDA_7": 24,
-        "WIRE0_SDA_8": 25,
+        "WIRE0_SCL_0": 11,
+        "WIRE0_SCL_1": 19,
+        "WIRE0_SCL_2": 3,
+        "WIRE0_SCL_3": 24,
+        "WIRE0_SCL_4": 2,
+        "WIRE0_SCL_5": 25,
+        "WIRE0_SCL_6": 1,
+        "WIRE0_SCL_7": 0,
+        "WIRE0_SCL_8": 9,
+        "WIRE0_SDA_0": 11,
+        "WIRE0_SDA_1": 19,
+        "WIRE0_SDA_2": 3,
+        "WIRE0_SDA_3": 24,
+        "WIRE0_SDA_4": 2,
+        "WIRE0_SDA_5": 25,
+        "WIRE0_SDA_6": 1,
+        "WIRE0_SDA_7": 0,
+        "WIRE0_SDA_8": 9,
         "SERIAL0_RX": 3,
         "SERIAL0_TX": 2,
         "SERIAL1_RX": 24,

esphome/components/logger/__init__.py

@@ -231,16 +231,9 @@ CONFIG_SCHEMA = cv.All(
                 bk72xx=768,
                 ln882x=768,
                 rtl87xx=768,
-                nrf52=768,
             ): cv.All(
                 cv.only_on(
-                    [
-                        PLATFORM_ESP32,
-                        PLATFORM_BK72XX,
-                        PLATFORM_LN882X,
-                        PLATFORM_RTL87XX,
-                        PLATFORM_NRF52,
-                    ]
+                    [PLATFORM_ESP32, PLATFORM_BK72XX, PLATFORM_LN882X, PLATFORM_RTL87XX]
                 ),
                 cv.validate_bytes,
                 cv.Any(
@@ -320,13 +313,11 @@ async def to_code(config):
     )
     if CORE.is_esp32:
         cg.add(log.create_pthread_key())
-    if CORE.is_esp32 or CORE.is_libretiny or CORE.is_nrf52:
+    if CORE.is_esp32 or CORE.is_libretiny:
         task_log_buffer_size = config[CONF_TASK_LOG_BUFFER_SIZE]
         if task_log_buffer_size > 0:
             cg.add_define("USE_ESPHOME_TASK_LOG_BUFFER")
             cg.add(log.init_log_buffer(task_log_buffer_size))
-            if CORE.using_zephyr:
-                zephyr_add_prj_conf("MPSC_PBUF", True)
     elif CORE.is_host:
         cg.add(log.create_pthread_key())
         cg.add_define("USE_ESPHOME_TASK_LOG_BUFFER")
@@ -426,7 +417,6 @@ async def to_code(config):
         pass
 
     if CORE.is_nrf52:
-        zephyr_add_prj_conf("THREAD_LOCAL_STORAGE", True)
         if config[CONF_HARDWARE_UART] == UART0:
             zephyr_add_overlay("""&uart0 { status = "okay";};""")
         if config[CONF_HARDWARE_UART] == UART1:

esphome/components/logger/log_buffer.h

@@ -1,190 +0,0 @@
-#pragma once
-
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::logger {
-
-// Maximum header size: 35 bytes fixed + 32 bytes tag + 16 bytes thread name = 83 bytes (45 byte safety margin)
-static constexpr uint16_t MAX_HEADER_SIZE = 128;
-
-// ANSI color code last digit (30-38 range, store only last digit to save RAM)
-static constexpr char LOG_LEVEL_COLOR_DIGIT[] = {
-    '\0',  // NONE
-    '1',   // ERROR (31 = red)
-    '3',   // WARNING (33 = yellow)
-    '2',   // INFO (32 = green)
-    '5',   // CONFIG (35 = magenta)
-    '6',   // DEBUG (36 = cyan)
-    '7',   // VERBOSE (37 = gray)
-    '8',   // VERY_VERBOSE (38 = white)
-};
-
-static constexpr char LOG_LEVEL_LETTER_CHARS[] = {
-    '\0',  // NONE
-    'E',   // ERROR
-    'W',   // WARNING
-    'I',   // INFO
-    'C',   // CONFIG
-    'D',   // DEBUG
-    'V',   // VERBOSE (VERY_VERBOSE uses two 'V's)
-};
-
-// Buffer wrapper for log formatting functions
-struct LogBuffer {
-  char *data;
-  uint16_t size;
-  uint16_t pos{0};
-  // Replaces the null terminator with a newline for console output.
-  // Must be called after notify_listeners_() since listeners need null-terminated strings.
-  // Console output uses length-based writes (buf.pos), so null terminator is not needed.
-  void terminate_with_newline() {
-    if (this->pos < this->size) {
-      this->data[this->pos++] = '\n';
-    } else if (this->size > 0) {
-      // Buffer was full - replace last char with newline to ensure it's visible
-      this->data[this->size - 1] = '\n';
-      this->pos = this->size;
-    }
-  }
-  void HOT write_header(uint8_t level, const char *tag, int line, const char *thread_name) {
-    // Early return if insufficient space - intentionally don't update pos to prevent partial writes
-    if (this->pos + MAX_HEADER_SIZE > this->size)
-      return;
-
-    char *p = this->current_();
-
-    // Write ANSI color
-    this->write_ansi_color_(p, level);
-
-    // Construct: [LEVEL][tag:line]
-    *p++ = '[';
-    if (level != 0) {
-      if (level >= 7) {
-        *p++ = 'V';  // VERY_VERBOSE = "VV"
-        *p++ = 'V';
-      } else {
-        *p++ = LOG_LEVEL_LETTER_CHARS[level];
-      }
-    }
-    *p++ = ']';
-    *p++ = '[';
-
-    // Copy tag
-    this->copy_string_(p, tag);
-
-    *p++ = ':';
-
-    // Format line number without modulo operations
-    if (line > 999) [[unlikely]] {
-      int thousands = line / 1000;
-      *p++ = '0' + thousands;
-      line -= thousands * 1000;
-    }
-    int hundreds = line / 100;
-    int remainder = line - hundreds * 100;
-    int tens = remainder / 10;
-    *p++ = '0' + hundreds;
-    *p++ = '0' + tens;
-    *p++ = '0' + (remainder - tens * 10);
-    *p++ = ']';
-
-#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR) || defined(USE_HOST)
-    // Write thread name with bold red color
-    if (thread_name != nullptr) {
-      this->write_ansi_color_(p, 1);  // Bold red for thread name
-      *p++ = '[';
-      this->copy_string_(p, thread_name);
-      *p++ = ']';
-      this->write_ansi_color_(p, level);  // Restore original color
-    }
-#endif
-
-    *p++ = ':';
-    *p++ = ' ';
-
-    this->pos = p - this->data;
-  }
-  void HOT format_body(const char *format, va_list args) {
-    this->format_vsnprintf_(format, args);
-    this->finalize_();
-  }
-#ifdef USE_STORE_LOG_STR_IN_FLASH
-  void HOT format_body_P(PGM_P format, va_list args) {
-    this->format_vsnprintf_P_(format, args);
-    this->finalize_();
-  }
-#endif
-  void write_body(const char *text, uint16_t text_length) {
-    this->write_(text, text_length);
-    this->finalize_();
-  }
-
- private:
-  bool full_() const { return this->pos >= this->size; }
-  uint16_t remaining_() const { return this->size - this->pos; }
-  char *current_() { return this->data + this->pos; }
-  void write_(const char *value, uint16_t length) {
-    const uint16_t available = this->remaining_();
-    const uint16_t copy_len = (length < available) ? length : available;
-    if (copy_len > 0) {
-      memcpy(this->current_(), value, copy_len);
-      this->pos += copy_len;
-    }
-  }
-  void finalize_() {
-    // Write color reset sequence
-    static constexpr uint16_t RESET_COLOR_LEN = sizeof(ESPHOME_LOG_RESET_COLOR) - 1;
-    this->write_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN);
-    // Null terminate
-    this->data[this->full_() ? this->size - 1 : this->pos] = '\0';
-  }
-  void strip_trailing_newlines_() {
-    while (this->pos > 0 && this->data[this->pos - 1] == '\n')
-      this->pos--;
-  }
-  void process_vsnprintf_result_(int ret) {
-    if (ret < 0)
-      return;
-    const uint16_t rem = this->remaining_();
-    this->pos += (ret >= rem) ? (rem - 1) : static_cast<uint16_t>(ret);
-    this->strip_trailing_newlines_();
-  }
-  void format_vsnprintf_(const char *format, va_list args) {
-    if (this->full_())
-      return;
-    this->process_vsnprintf_result_(vsnprintf(this->current_(), this->remaining_(), format, args));
-  }
-#ifdef USE_STORE_LOG_STR_IN_FLASH
-  void format_vsnprintf_P_(PGM_P format, va_list args) {
-    if (this->full_())
-      return;
-    this->process_vsnprintf_result_(vsnprintf_P(this->current_(), this->remaining_(), format, args));
-  }
-#endif
-  // Write ANSI color escape sequence to buffer, updates pointer in place
-  // Caller is responsible for ensuring buffer has sufficient space
-  void write_ansi_color_(char *&p, uint8_t level) {
-    if (level == 0)
-      return;
-    // Direct buffer fill: "\033[{bold};3{color}m" (7 bytes)
-    *p++ = '\033';
-    *p++ = '[';
-    *p++ = (level == 1) ? '1' : '0';  // Only ERROR is bold
-    *p++ = ';';
-    *p++ = '3';
-    *p++ = LOG_LEVEL_COLOR_DIGIT[level];
-    *p++ = 'm';
-  }
-  // Copy string without null terminator, updates pointer in place
-  // Caller is responsible for ensuring buffer has sufficient space
-  void copy_string_(char *&p, const char *str) {
-    const size_t len = strlen(str);
-    // NOLINTNEXTLINE(bugprone-not-null-terminated-result) - intentionally no null terminator, building string piece by
-    // piece
-    memcpy(p, str, len);
-    p += len;
-  }
-};
-
-}  // namespace esphome::logger

esphome/components/logger/logger.cpp

@@ -10,9 +10,9 @@ namespace esphome::logger {
 
 static const char *const TAG = "logger";
 
-#if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
-// Implementation for multi-threaded platforms (ESP32 with FreeRTOS, Host with pthreads, LibreTiny with FreeRTOS,
-// Zephyr) Main thread/task always uses direct buffer access for console output and callbacks
+#if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY)
+// Implementation for multi-threaded platforms (ESP32 with FreeRTOS, Host with pthreads, LibreTiny with FreeRTOS)
+// Main thread/task always uses direct buffer access for console output and callbacks
 //
 // For non-main threads/tasks:
 //  - WITH task log buffer: Prefer sending to ring buffer for async processing
@@ -31,17 +31,13 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
   // Get task handle once - used for both main task check and passing to non-main thread handler
   TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
   const bool is_main_task = (current_task == this->main_task_);
-#elif (USE_ZEPHYR)
-  k_tid_t current_task = k_current_get();
-  const bool is_main_task = (current_task == this->main_task_);
 #else  // USE_HOST
   const bool is_main_task = pthread_equal(pthread_self(), this->main_thread_);
 #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, nullptr);
+    this->log_message_to_buffer_and_send_(this->main_task_recursion_guard_, level, tag, line, format, args);
     return;
   }
 
@@ -51,26 +47,21 @@ 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)
-  const char *thread_name = get_thread_name_(current_task);
-#elif defined(USE_ZEPHYR)
-  char thread_name_buf[MAX_POINTER_REPRESENTATION];
-  const char *thread_name = get_thread_name_(thread_name_buf, current_task);
+  this->log_vprintf_non_main_thread_(level, tag, line, format, args, current_task);
 #else  // USE_HOST
-  char thread_name_buf[THREAD_NAME_BUF_SIZE];
-  const char *thread_name = this->get_thread_name_(thread_name_buf);
+  this->log_vprintf_non_main_thread_(level, tag, line, format, args);
 #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,
-                                          const char *thread_name) {
+                                          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
   // Check if already in recursion for this non-main thread/task
   if (this->is_non_main_task_recursive_()) {
     return;
@@ -82,50 +73,49 @@ 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), thread_name, format, args);
+      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
   if (message_sent) {
     // Enable logger loop to process the buffered message
     // This is safe to call from any context including ISRs
     this->enable_loop_soon_any_context();
   }
-#endif
+#endif  // USE_ESPHOME_TASK_LOG_BUFFER
+
   // Emergency console logging for non-main threads when ring buffer is full or disabled
   // This is a fallback mechanism to ensure critical log messages are visible
   // Note: This may cause interleaved/corrupted console output if multiple threads
   // log simultaneously, but it's better than losing important messages entirely
 #ifdef USE_HOST
-  if (!message_sent)
-#else
-  if (!message_sent && this->baud_rate_ > 0)  // If logging is enabled, write to console
-#endif
-  {
-#ifdef USE_HOST
+  if (!message_sent) {
     // Host always has console output - no baud_rate check needed
     static const size_t MAX_CONSOLE_LOG_MSG_SIZE = 512;
 #else
+  if (!message_sent && this->baud_rate_ > 0) {  // If logging is enabled, write to console
     // Maximum size for console log messages (includes null terminator)
     static const size_t MAX_CONSOLE_LOG_MSG_SIZE = 144;
 #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, thread_name);
+    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
     this->write_to_console_(buf);
   }
 
   // RAII guard automatically resets on return
 }
 #else
-// Implementation for single-task platforms (ESP8266, RP2040)
-// 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).
+// Implementation for all other platforms (single-task, no threading)
 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;
-  // 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);
+
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
 }
-#endif  // USE_ESP32 || USE_HOST || USE_LIBRETINY || USE_ZEPHYR
+#endif  // USE_ESP32 / USE_HOST / USE_LIBRETINY
 
 #ifdef USE_STORE_LOG_STR_IN_FLASH
 // Implementation for ESP8266 with flash string support.
@@ -139,7 +129,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, nullptr);
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
 }
 #endif  // USE_STORE_LOG_STR_IN_FLASH
 
@@ -166,12 +156,19 @@ Logger::Logger(uint32_t baud_rate, size_t tx_buffer_size) : baud_rate_(baud_rate
 }
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
 void Logger::init_log_buffer(size_t total_buffer_size) {
+#ifdef USE_HOST
   // Host uses slot count instead of byte size
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) - allocated once, never freed
+  this->log_buffer_ = new logger::TaskLogBufferHost(total_buffer_size);
+#elif defined(USE_ESP32)
   // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) - allocated once, never freed
   this->log_buffer_ = new logger::TaskLogBuffer(total_buffer_size);
+#elif defined(USE_LIBRETINY)
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) - allocated once, never freed
+  this->log_buffer_ = new logger::TaskLogBufferLibreTiny(total_buffer_size);
+#endif
 
-// Zephyr needs loop working to check when CDC port is open
-#if !(defined(USE_ZEPHYR) || defined(USE_LOGGER_USB_CDC))
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
   // Start with loop disabled when using task buffer (unless using USB CDC on ESP32)
   // The loop will be enabled automatically when messages arrive
   this->disable_loop_when_buffer_empty_();
@@ -179,33 +176,52 @@ void Logger::init_log_buffer(size_t total_buffer_size) {
 }
 #endif
 
-#if defined(USE_ESPHOME_TASK_LOG_BUFFER) || (defined(USE_ZEPHYR) && defined(USE_LOGGER_USB_CDC))
-void Logger::loop() {
-  this->process_messages_();
-#if defined(USE_ZEPHYR) && defined(USE_LOGGER_USB_CDC)
-  this->cdc_loop_();
-#endif
-}
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+void Logger::loop() { this->process_messages_(); }
 #endif
 
 void Logger::process_messages_() {
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   // Process any buffered messages when available
   if (this->log_buffer_->has_messages()) {
-    logger::TaskLogBuffer::LogMessage *message;
-    uint16_t text_length;
-    while (this->log_buffer_->borrow_message_main_loop(message, text_length)) {
+#ifdef USE_HOST
+    logger::TaskLogBufferHost::LogMessage *message;
+    while (this->log_buffer_->get_message_main_loop(&message)) {
       const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
       LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
-      this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name,
-                                                message->text_data(), text_length, buf);
+      this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name, message->text,
+                                                message->text_length, buf);
+      this->log_buffer_->release_message_main_loop();
+      this->write_log_buffer_to_console_(buf);
+    }
+#elif defined(USE_ESP32)
+    logger::TaskLogBuffer::LogMessage *message;
+    const char *text;
+    void *received_token;
+    while (this->log_buffer_->borrow_message_main_loop(&message, &text, &received_token)) {
+      const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
+      LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
+      this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name, text,
+                                                message->text_length, buf);
+      // Release the message to allow other tasks to use it as soon as possible
+      this->log_buffer_->release_message_main_loop(received_token);
+      this->write_log_buffer_to_console_(buf);
+    }
+#elif defined(USE_LIBRETINY)
+    logger::TaskLogBufferLibreTiny::LogMessage *message;
+    const char *text;
+    while (this->log_buffer_->borrow_message_main_loop(&message, &text)) {
+      const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
+      LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
+      this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name, text,
+                                                message->text_length, buf);
       // Release the message to allow other tasks to use it as soon as possible
       this->log_buffer_->release_message_main_loop();
       this->write_log_buffer_to_console_(buf);
     }
+#endif
   }
-// Zephyr needs loop working to check when CDC port is open
-#if !(defined(USE_ZEPHYR) || defined(USE_LOGGER_USB_CDC))
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
   else {
     // No messages to process, disable loop if appropriate
     // This reduces overhead when there's no async logging activity

esphome/components/logger/logger.h

@@ -2,7 +2,6 @@
 
 #include <cstdarg>
 #include <map>
-#include <span>
 #include <type_traits>
 #if defined(USE_ESP32) || defined(USE_HOST)
 #include <pthread.h>
@@ -13,11 +12,15 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-#include "log_buffer.h"
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+#ifdef USE_HOST
 #include "task_log_buffer_host.h"
+#elif defined(USE_ESP32)
 #include "task_log_buffer_esp32.h"
+#elif defined(USE_LIBRETINY)
 #include "task_log_buffer_libretiny.h"
-#include "task_log_buffer_zephyr.h"
+#endif
+#endif
 
 #ifdef USE_ARDUINO
 #if defined(USE_ESP8266)
@@ -93,9 +96,190 @@ struct CStrCompare {
 };
 #endif
 
-// 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;
+// ANSI color code last digit (30-38 range, store only last digit to save RAM)
+static constexpr char LOG_LEVEL_COLOR_DIGIT[] = {
+    '\0',  // NONE
+    '1',   // ERROR (31 = red)
+    '3',   // WARNING (33 = yellow)
+    '2',   // INFO (32 = green)
+    '5',   // CONFIG (35 = magenta)
+    '6',   // DEBUG (36 = cyan)
+    '7',   // VERBOSE (37 = gray)
+    '8',   // VERY_VERBOSE (38 = white)
+};
+
+static constexpr char LOG_LEVEL_LETTER_CHARS[] = {
+    '\0',  // NONE
+    'E',   // ERROR
+    'W',   // WARNING
+    'I',   // INFO
+    'C',   // CONFIG
+    'D',   // DEBUG
+    'V',   // VERBOSE (VERY_VERBOSE uses two 'V's)
+};
+
+// Maximum header size: 35 bytes fixed + 32 bytes tag + 16 bytes thread name = 83 bytes (45 byte safety margin)
+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;
+
+// Buffer wrapper for log formatting functions
+struct LogBuffer {
+  char *data;
+  uint16_t size;
+  uint16_t pos{0};
+  // Replaces the null terminator with a newline for console output.
+  // Must be called after notify_listeners_() since listeners need null-terminated strings.
+  // Console output uses length-based writes (buf.pos), so null terminator is not needed.
+  void terminate_with_newline() {
+    if (this->pos < this->size) {
+      this->data[this->pos++] = '\n';
+    } else if (this->size > 0) {
+      // Buffer was full - replace last char with newline to ensure it's visible
+      this->data[this->size - 1] = '\n';
+      this->pos = this->size;
+    }
+  }
+  void HOT write_header(uint8_t level, const char *tag, int line, const char *thread_name) {
+    // Early return if insufficient space - intentionally don't update pos to prevent partial writes
+    if (this->pos + MAX_HEADER_SIZE > this->size)
+      return;
+
+    char *p = this->current_();
+
+    // Write ANSI color
+    this->write_ansi_color_(p, level);
+
+    // Construct: [LEVEL][tag:line]
+    *p++ = '[';
+    if (level != 0) {
+      if (level >= 7) {
+        *p++ = 'V';  // VERY_VERBOSE = "VV"
+        *p++ = 'V';
+      } else {
+        *p++ = LOG_LEVEL_LETTER_CHARS[level];
+      }
+    }
+    *p++ = ']';
+    *p++ = '[';
+
+    // Copy tag
+    this->copy_string_(p, tag);
+
+    *p++ = ':';
+
+    // Format line number without modulo operations
+    if (line > 999) [[unlikely]] {
+      int thousands = line / 1000;
+      *p++ = '0' + thousands;
+      line -= thousands * 1000;
+    }
+    int hundreds = line / 100;
+    int remainder = line - hundreds * 100;
+    int tens = remainder / 10;
+    *p++ = '0' + hundreds;
+    *p++ = '0' + tens;
+    *p++ = '0' + (remainder - tens * 10);
+    *p++ = ']';
+
+#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR) || defined(USE_HOST)
+    // Write thread name with bold red color
+    if (thread_name != nullptr) {
+      this->write_ansi_color_(p, 1);  // Bold red for thread name
+      *p++ = '[';
+      this->copy_string_(p, thread_name);
+      *p++ = ']';
+      this->write_ansi_color_(p, level);  // Restore original color
+    }
+#endif
+
+    *p++ = ':';
+    *p++ = ' ';
+
+    this->pos = p - this->data;
+  }
+  void HOT format_body(const char *format, va_list args) {
+    this->format_vsnprintf_(format, args);
+    this->finalize_();
+  }
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  void HOT format_body_P(PGM_P format, va_list args) {
+    this->format_vsnprintf_P_(format, args);
+    this->finalize_();
+  }
+#endif
+  void write_body(const char *text, uint16_t text_length) {
+    this->write_(text, text_length);
+    this->finalize_();
+  }
+
+ private:
+  bool full_() const { return this->pos >= this->size; }
+  uint16_t remaining_() const { return this->size - this->pos; }
+  char *current_() { return this->data + this->pos; }
+  void write_(const char *value, uint16_t length) {
+    const uint16_t available = this->remaining_();
+    const uint16_t copy_len = (length < available) ? length : available;
+    if (copy_len > 0) {
+      memcpy(this->current_(), value, copy_len);
+      this->pos += copy_len;
+    }
+  }
+  void finalize_() {
+    // Write color reset sequence
+    static constexpr uint16_t RESET_COLOR_LEN = sizeof(ESPHOME_LOG_RESET_COLOR) - 1;
+    this->write_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN);
+    // Null terminate
+    this->data[this->full_() ? this->size - 1 : this->pos] = '\0';
+  }
+  void strip_trailing_newlines_() {
+    while (this->pos > 0 && this->data[this->pos - 1] == '\n')
+      this->pos--;
+  }
+  void process_vsnprintf_result_(int ret) {
+    if (ret < 0)
+      return;
+    const uint16_t rem = this->remaining_();
+    this->pos += (ret >= rem) ? (rem - 1) : static_cast<uint16_t>(ret);
+    this->strip_trailing_newlines_();
+  }
+  void format_vsnprintf_(const char *format, va_list args) {
+    if (this->full_())
+      return;
+    this->process_vsnprintf_result_(vsnprintf(this->current_(), this->remaining_(), format, args));
+  }
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  void format_vsnprintf_P_(PGM_P format, va_list args) {
+    if (this->full_())
+      return;
+    this->process_vsnprintf_result_(vsnprintf_P(this->current_(), this->remaining_(), format, args));
+  }
+#endif
+  // Write ANSI color escape sequence to buffer, updates pointer in place
+  // Caller is responsible for ensuring buffer has sufficient space
+  void write_ansi_color_(char *&p, uint8_t level) {
+    if (level == 0)
+      return;
+    // Direct buffer fill: "\033[{bold};3{color}m" (7 bytes)
+    *p++ = '\033';
+    *p++ = '[';
+    *p++ = (level == 1) ? '1' : '0';  // Only ERROR is bold
+    *p++ = ';';
+    *p++ = '3';
+    *p++ = LOG_LEVEL_COLOR_DIGIT[level];
+    *p++ = 'm';
+  }
+  // Copy string without null terminator, updates pointer in place
+  // Caller is responsible for ensuring buffer has sufficient space
+  void copy_string_(char *&p, const char *str) {
+    const size_t len = strlen(str);
+    // NOLINTNEXTLINE(bugprone-not-null-terminated-result) - intentionally no null terminator, building string piece by
+    // piece
+    memcpy(p, str, len);
+    p += len;
+  }
+};
 
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
 /** Enum for logging UART selection
@@ -222,29 +406,36 @@ class Logger : public Component {
     bool &flag_;
   };
 
-#if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
+#if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY)
   // Handles non-main thread logging only (~0.1% of calls)
-  // thread_name is resolved by the caller from the task handle, avoiding redundant lookups
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+  // ESP32/LibreTiny: Pass task handle to avoid calling xTaskGetCurrentTaskHandle() twice
   void log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args,
-                                    const char *thread_name);
+                                    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
-#if defined(USE_ZEPHYR) && defined(USE_LOGGER_USB_CDC)
-  void cdc_loop_();
 #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, const char *thread_name) {
-    buf.write_header(level, tag, line, thread_name);
+                                                        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
     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) {
@@ -275,10 +466,9 @@ 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, const char *thread_name) {
+                                                  FormatType format, va_list args) {
     RecursionGuard guard(recursion_guard);
     LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
 #ifdef USE_STORE_LOG_STR_IN_FLASH
@@ -287,7 +477,7 @@ class Logger : public Component {
     } else
 #endif
     {
-      this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf, thread_name);
+      this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
     }
     this->notify_listeners_(level, tag, buf);
     this->write_log_buffer_to_console_(buf);
@@ -348,7 +538,13 @@ class Logger : public Component {
   std::vector<LoggerLevelListener *> level_listeners_;  // Log level change listeners
 #endif
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
+#ifdef USE_HOST
+  logger::TaskLogBufferHost *log_buffer_{nullptr};  // Allocated once, never freed
+#elif defined(USE_ESP32)
   logger::TaskLogBuffer *log_buffer_{nullptr};  // Allocated once, never freed
+#elif defined(USE_LIBRETINY)
+  logger::TaskLogBufferLibreTiny *log_buffer_{nullptr};  // Allocated once, never freed
+#endif
 #endif
 
   // Group smaller types together at the end
@@ -360,7 +556,7 @@ class Logger : public Component {
 #ifdef USE_LIBRETINY
   UARTSelection uart_{UART_SELECTION_DEFAULT};
 #endif
-#if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
+#if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY)
   bool main_task_recursion_guard_{false};
 #ifdef USE_LIBRETINY
   bool non_main_task_recursion_guard_{false};  // Shared guard for all non-main tasks on LibreTiny
@@ -369,59 +565,37 @@ class Logger : public Component {
   bool global_recursion_guard_{false};  // Simple global recursion guard for single-task platforms
 #endif
 
-  // --- 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);
+#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
+  const char *HOT get_thread_name_(
+#ifdef USE_ZEPHYR
+      char *buff
+#endif
+  ) {
+#ifdef USE_ZEPHYR
+    k_tid_t current_task = k_current_get();
+#else
+    TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
 #endif
-  }
-
-  // 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 = nullptr) {
-    if (current_task == nullptr) {
-      current_task = k_current_get();
-    }
     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 {
@@ -445,7 +619,7 @@ class Logger : public Component {
   // Create RAII guard for non-main task recursion
   inline NonMainTaskRecursionGuard make_non_main_task_guard_() { return NonMainTaskRecursionGuard(log_recursion_key_); }
 
-#elif defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
+#elif defined(USE_LIBRETINY)
   // LibreTiny doesn't have FreeRTOS TLS, so use a simple approach:
   // - Main task uses dedicated boolean (same as ESP32)
   // - Non-main tasks share a single recursion guard
@@ -453,8 +627,6 @@ class Logger : public Component {
   // - Recursion from logging within logging is the main concern
   // - Cross-task "recursion" is prevented by the buffer mutex anyway
   // - Missing a recursive call from another task is acceptable (falls back to direct output)
-  //
-  // Zephyr use __thread as TLS
 
   // Check if non-main task is already in recursion
   inline bool HOT is_non_main_task_recursive_() const { return non_main_task_recursion_guard_; }
@@ -463,8 +635,23 @@ class Logger : public Component {
   inline RecursionGuard make_non_main_task_guard_() { return RecursionGuard(non_main_task_recursion_guard_); }
 #endif
 
-// Zephyr needs loop working to check when CDC port is open
-#if defined(USE_ESPHOME_TASK_LOG_BUFFER) && !(defined(USE_ZEPHYR) || defined(USE_LOGGER_USB_CDC))
+#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_() {
     // Thread safety note: This is safe even if another task calls enable_loop_soon_any_context()

esphome/components/logger/logger_zephyr.cpp

@@ -14,7 +14,7 @@ namespace esphome::logger {
 static const char *const TAG = "logger";
 
 #ifdef USE_LOGGER_USB_CDC
-void Logger::cdc_loop_() {
+void Logger::loop() {
   if (this->uart_ != UART_SELECTION_USB_CDC || this->uart_dev_ == nullptr) {
     return;
   }

esphome/components/logger/task_log_buffer_esp32.cpp

@@ -31,8 +31,8 @@ TaskLogBuffer::~TaskLogBuffer() {
   }
 }
 
-bool TaskLogBuffer::borrow_message_main_loop(LogMessage *&message, uint16_t &text_length) {
-  if (this->current_token_) {
+bool TaskLogBuffer::borrow_message_main_loop(LogMessage **message, const char **text, void **received_token) {
+  if (message == nullptr || text == nullptr || received_token == nullptr) {
     return false;
   }
 
@@ -43,24 +43,23 @@ bool TaskLogBuffer::borrow_message_main_loop(LogMessage *&message, uint16_t &tex
   }
 
   LogMessage *msg = static_cast<LogMessage *>(received_item);
-  message = msg;
-  text_length = msg->text_length;
-  this->current_token_ = received_item;
+  *message = msg;
+  *text = msg->text_data();
+  *received_token = received_item;
 
   return true;
 }
 
-void TaskLogBuffer::release_message_main_loop() {
-  if (this->current_token_ == nullptr) {
+void TaskLogBuffer::release_message_main_loop(void *token) {
+  if (token == nullptr) {
     return;
   }
-  vRingbufferReturnItem(ring_buffer_, this->current_token_);
-  this->current_token_ = nullptr;
+  vRingbufferReturnItem(ring_buffer_, token);
   // Update counter to mark all messages as processed
   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, const char *thread_name,
+bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
                                              const char *format, va_list args) {
   // First, calculate the exact length needed using a null buffer (no actual writing)
   va_list args_copy;
@@ -96,6 +95,7 @@ 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

@@ -52,13 +52,13 @@ class TaskLogBuffer {
   ~TaskLogBuffer();
 
   // NOT thread-safe - borrow a message from the ring buffer, only call from main loop
-  bool borrow_message_main_loop(LogMessage *&message, uint16_t &text_length);
+  bool borrow_message_main_loop(LogMessage **message, const char **text, void **received_token);
 
   // NOT thread-safe - release a message buffer and update the counter, only call from main loop
-  void release_message_main_loop();
+  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, const char *thread_name,
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
                                 const char *format, va_list args);
 
   // Check if there are messages ready to be processed using an atomic counter for performance
@@ -78,7 +78,6 @@ class TaskLogBuffer {
   // Atomic counter for message tracking (only differences matter)
   std::atomic<uint16_t> message_counter_{0};    // Incremented when messages are committed
   mutable uint16_t last_processed_counter_{0};  // Tracks last processed message
-  void *current_token_{nullptr};
 };
 
 }  // namespace esphome::logger

esphome/components/logger/task_log_buffer_host.cpp

@@ -10,16 +10,16 @@
 
 namespace esphome::logger {
 
-TaskLogBuffer::TaskLogBuffer(size_t slot_count) : slot_count_(slot_count) {
+TaskLogBufferHost::TaskLogBufferHost(size_t slot_count) : slot_count_(slot_count) {
   // Allocate message slots
   this->slots_ = std::make_unique<LogMessage[]>(slot_count);
 }
 
-TaskLogBuffer::~TaskLogBuffer() {
+TaskLogBufferHost::~TaskLogBufferHost() {
   // unique_ptr handles cleanup automatically
 }
 
-int TaskLogBuffer::acquire_write_slot_() {
+int TaskLogBufferHost::acquire_write_slot_() {
   // Try to reserve a slot using compare-and-swap
   size_t current_reserve = this->reserve_index_.load(std::memory_order_relaxed);
 
@@ -43,7 +43,7 @@ int TaskLogBuffer::acquire_write_slot_() {
   }
 }
 
-void TaskLogBuffer::commit_write_slot_(int slot_index) {
+void TaskLogBufferHost::commit_write_slot_(int slot_index) {
   // Mark the slot as ready for reading
   this->slots_[slot_index].ready.store(true, std::memory_order_release);
 
@@ -70,8 +70,8 @@ void TaskLogBuffer::commit_write_slot_(int slot_index) {
   }
 }
 
-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) {
+bool TaskLogBufferHost::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *format,
+                                                 va_list args) {
   // Acquire a slot
   int slot_index = this->acquire_write_slot_();
   if (slot_index < 0) {
@@ -85,9 +85,11 @@ bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uin
   msg.tag = tag;
   msg.line = line;
 
-  // 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);
+  // 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);
     msg.thread_name[sizeof(msg.thread_name) - 1] = '\0';
   } else {
     msg.thread_name[0] = '\0';
@@ -115,7 +117,11 @@ bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uin
   return true;
 }
 
-bool TaskLogBuffer::borrow_message_main_loop(LogMessage *&message, uint16_t &text_length) {
+bool TaskLogBufferHost::get_message_main_loop(LogMessage **message) {
+  if (message == nullptr) {
+    return false;
+  }
+
   size_t current_read = this->read_index_.load(std::memory_order_relaxed);
   size_t current_write = this->write_index_.load(std::memory_order_acquire);
 
@@ -130,12 +136,11 @@ bool TaskLogBuffer::borrow_message_main_loop(LogMessage *&message, uint16_t &tex
     return false;
   }
 
-  message = &msg;
-  text_length = msg.text_length;
+  *message = &msg;
   return true;
 }
 
-void TaskLogBuffer::release_message_main_loop() {
+void TaskLogBufferHost::release_message_main_loop() {
   size_t current_read = this->read_index_.load(std::memory_order_relaxed);
 
   // Clear the ready flag

esphome/components/logger/task_log_buffer_host.h

@@ -21,12 +21,12 @@ namespace esphome::logger {
  *
  * Threading Model: Multi-Producer Single-Consumer (MPSC)
  * - Multiple threads can safely call send_message_thread_safe() concurrently
- * - Only the main loop thread calls borrow_message_main_loop() and release_message_main_loop()
+ * - Only the main loop thread calls get_message_main_loop() and release_message_main_loop()
  *
  *   Producers (multiple threads)              Consumer (main loop only)
  *            │                                        │
  *            ▼                                        ▼
- *     acquire_write_slot_()                  bool borrow_message_main_loop()
+ *     acquire_write_slot_()                  get_message_main_loop()
  *       CAS on reserve_index_                  read write_index_
  *            │                                   check ready flag
  *            ▼                                        │
@@ -48,7 +48,7 @@ namespace esphome::logger {
  * - Atomic CAS for slot reservation allows multiple producers without locks
  * - Single consumer (main loop) processes messages in order
  */
-class TaskLogBuffer {
+class TaskLogBufferHost {
  public:
   // Default number of message slots - host has plenty of memory
   static constexpr size_t DEFAULT_SLOT_COUNT = 64;
@@ -71,24 +71,22 @@ class TaskLogBuffer {
       thread_name[0] = '\0';
       text[0] = '\0';
     }
-    inline char *text_data() { return this->text; }
   };
 
   /// Constructor that takes the number of message slots
-  explicit TaskLogBuffer(size_t slot_count);
-  ~TaskLogBuffer();
+  explicit TaskLogBufferHost(size_t slot_count);
+  ~TaskLogBufferHost();
 
   // NOT thread-safe - get next message from buffer, only call from main loop
   // Returns true if a message was retrieved, false if buffer is empty
-  bool borrow_message_main_loop(LogMessage *&message, uint16_t &text_length);
+  bool get_message_main_loop(LogMessage **message);
 
   // NOT thread-safe - release the message after processing, only call from main loop
   void release_message_main_loop();
 
   // 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 *thread_name,
-                                const char *format, va_list args);
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, 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

@@ -8,7 +8,7 @@
 
 namespace esphome::logger {
 
-TaskLogBuffer::TaskLogBuffer(size_t total_buffer_size) {
+TaskLogBufferLibreTiny::TaskLogBufferLibreTiny(size_t total_buffer_size) {
   this->size_ = total_buffer_size;
   // Allocate memory for the circular buffer using ESPHome's RAM allocator
   RAMAllocator<uint8_t> allocator;
@@ -17,7 +17,7 @@ TaskLogBuffer::TaskLogBuffer(size_t total_buffer_size) {
   this->mutex_ = xSemaphoreCreateMutex();
 }
 
-TaskLogBuffer::~TaskLogBuffer() {
+TaskLogBufferLibreTiny::~TaskLogBufferLibreTiny() {
   if (this->mutex_ != nullptr) {
     vSemaphoreDelete(this->mutex_);
     this->mutex_ = nullptr;
@@ -29,7 +29,7 @@ TaskLogBuffer::~TaskLogBuffer() {
   }
 }
 
-size_t TaskLogBuffer::available_contiguous_space() const {
+size_t TaskLogBufferLibreTiny::available_contiguous_space() const {
   if (this->head_ >= this->tail_) {
     // head is ahead of or equal to tail
     // Available space is from head to end, plus from start to tail
@@ -47,7 +47,11 @@ size_t TaskLogBuffer::available_contiguous_space() const {
   }
 }
 
-bool TaskLogBuffer::borrow_message_main_loop(LogMessage *&message, uint16_t &text_length) {
+bool TaskLogBufferLibreTiny::borrow_message_main_loop(LogMessage **message, const char **text) {
+  if (message == nullptr || text == nullptr) {
+    return false;
+  }
+
   // Check if buffer was initialized successfully
   if (this->mutex_ == nullptr || this->storage_ == nullptr) {
     return false;
@@ -73,15 +77,15 @@ bool TaskLogBuffer::borrow_message_main_loop(LogMessage *&message, uint16_t &tex
     this->tail_ = 0;
     msg = reinterpret_cast<LogMessage *>(this->storage_);
   }
-  message = msg;
-  text_length = msg->text_length;
+  *message = msg;
+  *text = msg->text_data();
   this->current_message_size_ = message_total_size(msg->text_length);
 
   // Keep mutex held until release_message_main_loop()
   return true;
 }
 
-void TaskLogBuffer::release_message_main_loop() {
+void TaskLogBufferLibreTiny::release_message_main_loop() {
   // Advance tail past the current message
   this->tail_ += this->current_message_size_;
 
@@ -96,8 +100,8 @@ void TaskLogBuffer::release_message_main_loop() {
   xSemaphoreGive(this->mutex_);
 }
 
-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) {
+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) {
   // First, calculate the exact length needed using a null buffer (no actual writing)
   va_list args_copy;
   va_copy(args_copy, args);
@@ -158,6 +162,7 @@ bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uin
   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

@@ -40,7 +40,7 @@ namespace esphome::logger {
  * - Volatile counter enables fast has_messages() without lock overhead
  * - If message doesn't fit at end, padding is added and message wraps to start
  */
-class TaskLogBuffer {
+class TaskLogBufferLibreTiny {
  public:
   // Structure for a log message header (text data follows immediately after)
   struct LogMessage {
@@ -60,17 +60,17 @@ class TaskLogBuffer {
   static constexpr uint8_t PADDING_MARKER_LEVEL = 0xFF;
 
   // Constructor that takes a total buffer size
-  explicit TaskLogBuffer(size_t total_buffer_size);
-  ~TaskLogBuffer();
+  explicit TaskLogBufferLibreTiny(size_t total_buffer_size);
+  ~TaskLogBufferLibreTiny();
 
   // NOT thread-safe - borrow a message from the buffer, only call from main loop
-  bool borrow_message_main_loop(LogMessage *&message, uint16_t &text_length);
+  bool borrow_message_main_loop(LogMessage **message, const char **text);
 
   // NOT thread-safe - release a message buffer, only call from main loop
   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, const char *thread_name,
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
                                 const char *format, va_list args);
 
   // Fast check using volatile counter - no lock needed

esphome/components/logger/task_log_buffer_zephyr.cpp

@@ -1,116 +0,0 @@
-#ifdef USE_ZEPHYR
-
-#include "task_log_buffer_zephyr.h"
-
-namespace esphome::logger {
-
-__thread bool non_main_task_recursion_guard_;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
-#ifdef USE_ESPHOME_TASK_LOG_BUFFER
-
-static inline uint32_t total_size_in_32bit_words(uint16_t text_length) {
-  // Calculate total size in 32-bit words needed (header + text length + null terminator + 3(4 bytes alignment)
-  return (sizeof(TaskLogBuffer::LogMessage) + text_length + 1 + 3) / sizeof(uint32_t);
-}
-
-static inline uint32_t get_wlen(const mpsc_pbuf_generic *item) {
-  return total_size_in_32bit_words(reinterpret_cast<const TaskLogBuffer::LogMessage *>(item)->text_length);
-}
-
-TaskLogBuffer::TaskLogBuffer(size_t total_buffer_size) {
-  // alignment to 4 bytes
-  total_buffer_size = (total_buffer_size + 3) / sizeof(uint32_t);
-  this->mpsc_config_.buf = new uint32_t[total_buffer_size];
-  this->mpsc_config_.size = total_buffer_size;
-  this->mpsc_config_.flags = MPSC_PBUF_MODE_OVERWRITE;
-  this->mpsc_config_.get_wlen = get_wlen,
-
-  mpsc_pbuf_init(&this->log_buffer_, &this->mpsc_config_);
-}
-
-TaskLogBuffer::~TaskLogBuffer() { delete[] this->mpsc_config_.buf; }
-
-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;
-  va_copy(args_copy, args);
-  int ret = vsnprintf(nullptr, 0, format, args_copy);
-  va_end(args_copy);
-
-  if (ret <= 0) {
-    return false;  // Formatting error or empty message
-  }
-
-  // Calculate actual text length (capped to maximum size)
-  static constexpr size_t MAX_TEXT_SIZE = 255;
-  size_t text_length = (static_cast<size_t>(ret) > MAX_TEXT_SIZE) ? MAX_TEXT_SIZE : ret;
-  size_t total_size = total_size_in_32bit_words(text_length);
-  auto *msg = reinterpret_cast<LogMessage *>(mpsc_pbuf_alloc(&this->log_buffer_, total_size, K_NO_WAIT));
-  if (msg == nullptr) {
-    return false;
-  }
-  msg->level = level;
-  msg->tag = tag;
-  msg->line = line;
-  strncpy(msg->thread_name, thread_name, sizeof(msg->thread_name) - 1);
-  msg->thread_name[sizeof(msg->thread_name) - 1] = '\0';  // Ensure null termination
-
-  // Format the message text directly into the acquired memory
-  // We add 1 to text_length to ensure space for null terminator during formatting
-  char *text_area = msg->text_data();
-  ret = vsnprintf(text_area, text_length + 1, format, args);
-
-  // Handle unexpected formatting error (ret < 0 is encoding error; ret == 0 is valid empty output)
-  if (ret < 0) {
-    // this should not happen, vsnprintf was called already once
-    // fill with '\n' to not call mpsc_pbuf_free from producer
-    // it will be trimmed anyway
-    for (size_t i = 0; i < text_length; ++i) {
-      text_area[i] = '\n';
-    }
-    text_area[text_length] = 0;
-    // do not return false to free the buffer from main thread
-  }
-
-  msg->text_length = text_length;
-
-  mpsc_pbuf_commit(&this->log_buffer_, reinterpret_cast<mpsc_pbuf_generic *>(msg));
-  return true;
-}
-
-bool TaskLogBuffer::borrow_message_main_loop(LogMessage *&message, uint16_t &text_length) {
-  if (this->current_token_) {
-    return false;
-  }
-
-  this->current_token_ = mpsc_pbuf_claim(&this->log_buffer_);
-
-  if (this->current_token_ == nullptr) {
-    return false;
-  }
-
-  // we claimed buffer already, const_cast is safe here
-  message = const_cast<LogMessage *>(reinterpret_cast<const LogMessage *>(this->current_token_));
-
-  text_length = message->text_length;
-  // Remove trailing newlines
-  while (text_length > 0 && message->text_data()[text_length - 1] == '\n') {
-    text_length--;
-  }
-
-  return true;
-}
-
-void TaskLogBuffer::release_message_main_loop() {
-  if (this->current_token_ == nullptr) {
-    return;
-  }
-  mpsc_pbuf_free(&this->log_buffer_, this->current_token_);
-  this->current_token_ = nullptr;
-}
-#endif  // USE_ESPHOME_TASK_LOG_BUFFER
-
-}  // namespace esphome::logger
-
-#endif  // USE_ZEPHYR

esphome/components/logger/task_log_buffer_zephyr.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#ifdef USE_ZEPHYR
-
-#include "esphome/core/defines.h"
-#include "esphome/core/helpers.h"
-#include <zephyr/sys/mpsc_pbuf.h>
-
-namespace esphome::logger {
-
-// "0x" + 2 hex digits per byte + '\0'
-static constexpr size_t MAX_POINTER_REPRESENTATION = 2 + sizeof(void *) * 2 + 1;
-
-extern __thread bool non_main_task_recursion_guard_;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
-#ifdef USE_ESPHOME_TASK_LOG_BUFFER
-
-class TaskLogBuffer {
- public:
-  // Structure for a log message header (text data follows immediately after)
-  struct LogMessage {
-    MPSC_PBUF_HDR;  // this is only 2 bits but no more than 30 bits directly after
-    uint16_t line;  // Source code line number
-    uint8_t level;  // Log level (0-7)
-#if defined(CONFIG_THREAD_NAME)
-    char thread_name[CONFIG_THREAD_MAX_NAME_LEN];  // Store thread name directly (only used for non-main threads)
-#else
-    char thread_name[MAX_POINTER_REPRESENTATION];  // Store thread name directly (only used for non-main threads)
-#endif
-    const char *tag;       // We store the pointer, assuming tags are static
-    uint16_t text_length;  // Length of the message text (up to ~64KB)
-
-    // Methods for accessing message contents
-    inline char *text_data() { return reinterpret_cast<char *>(this) + sizeof(LogMessage); }
-  };
-  // Constructor that takes a total buffer size
-  explicit TaskLogBuffer(size_t total_buffer_size);
-  ~TaskLogBuffer();
-
-  // Check if there are messages ready to be processed using an atomic counter for performance
-  inline bool HOT has_messages() { return mpsc_pbuf_is_pending(&this->log_buffer_); }
-
-  // Get the total buffer size in bytes
-  inline size_t size() const { return this->mpsc_config_.size * sizeof(uint32_t); }
-
-  // NOT thread-safe - borrow a message from the ring buffer, only call from main loop
-  bool borrow_message_main_loop(LogMessage *&message, uint16_t &text_length);
-
-  // NOT thread-safe - release a message buffer and update the counter, only call from main loop
-  void release_message_main_loop();
-
-  // 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, const char *thread_name,
-                                const char *format, va_list args);
-
- protected:
-  mpsc_pbuf_buffer_config mpsc_config_{};
-  mpsc_pbuf_buffer log_buffer_{};
-  const mpsc_pbuf_generic *current_token_{};
-};
-
-#endif  // USE_ESPHOME_TASK_LOG_BUFFER
-
-}  // namespace esphome::logger
-
-#endif  // USE_ZEPHYR

esphome/components/mdns/mdns_component.h

@@ -45,28 +45,9 @@ class MDNSComponent : public Component {
   void setup() override;
   void dump_config() override;
 
-  // Polling interval for MDNS.update() on platforms that require it (ESP8266, RP2040).
-  //
-  // On these platforms, MDNS.update() calls _process(true) which only manages timer-driven
-  // state machines (probe/announce timeouts and service query cache TTLs). Incoming mDNS
-  // packets are handled independently via the lwIP onRx UDP callback and are NOT affected
-  // by how often update() is called.
-  //
-  // The shortest internal timer is the 250ms probe interval (RFC 6762 Section 8.1).
-  // Announcement intervals are 1000ms and cache TTL checks are on the order of seconds
-  // to minutes. A 50ms polling interval provides sufficient resolution for all timers
-  // while completely removing mDNS from the per-iteration loop list.
-  //
-  // In steady state (after the ~8 second boot probe/announce phase completes), update()
-  // checks timers that are set to never expire, making every call pure overhead.
-  //
-  // Tasmota uses a 50ms main loop cycle with mDNS working correctly, confirming this
-  // interval is safe in production.
-  //
-  // By using set_interval() instead of overriding loop(), the component is excluded from
-  // the main loop list via has_overridden_loop(), eliminating all per-iteration overhead
-  // including virtual dispatch.
-  static constexpr uint32_t MDNS_UPDATE_INTERVAL_MS = 50;
+#if (defined(USE_ESP8266) || defined(USE_RP2040)) && defined(USE_ARDUINO)
+  void loop() override;
+#endif
   float get_setup_priority() const override { return setup_priority::AFTER_CONNECTION; }
 
 #ifdef USE_MDNS_EXTRA_SERVICES

esphome/components/mdns/mdns_esp8266.cpp

@@ -36,14 +36,9 @@ static void register_esp8266(MDNSComponent *, StaticVector<MDNSService, MDNS_SER
   }
 }
 
-void MDNSComponent::setup() {
-  this->setup_buffers_and_register_(register_esp8266);
-  // Schedule MDNS.update() via set_interval() instead of overriding loop().
-  // This removes the component from the per-iteration loop list entirely,
-  // eliminating virtual dispatch overhead on every main loop cycle.
-  // See MDNS_UPDATE_INTERVAL_MS comment in mdns_component.h for safety analysis.
-  this->set_interval(MDNS_UPDATE_INTERVAL_MS, []() { MDNS.update(); });
-}
+void MDNSComponent::setup() { this->setup_buffers_and_register_(register_esp8266); }
+
+void MDNSComponent::loop() { MDNS.update(); }
 
 void MDNSComponent::on_shutdown() {
   MDNS.close();

esphome/components/mdns/mdns_rp2040.cpp

@@ -35,14 +35,9 @@ static void register_rp2040(MDNSComponent *, StaticVector<MDNSService, MDNS_SERV
   }
 }
 
-void MDNSComponent::setup() {
-  this->setup_buffers_and_register_(register_rp2040);
-  // Schedule MDNS.update() via set_interval() instead of overriding loop().
-  // This removes the component from the per-iteration loop list entirely,
-  // eliminating virtual dispatch overhead on every main loop cycle.
-  // See MDNS_UPDATE_INTERVAL_MS comment in mdns_component.h for safety analysis.
-  this->set_interval(MDNS_UPDATE_INTERVAL_MS, []() { MDNS.update(); });
-}
+void MDNSComponent::setup() { this->setup_buffers_and_register_(register_rp2040); }
+
+void MDNSComponent::loop() { MDNS.update(); }
 
 void MDNSComponent::on_shutdown() {
   MDNS.close();

esphome/components/mipi_dsi/models/waveshare.py

@@ -120,101 +120,3 @@ 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_ESP32P4, VARIANT_ESP32S3, only_on_variant
+from esphome.components.esp32 import 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, VARIANT_ESP32P4]),
+        only_on_variant(supported=[VARIANT_ESP32S3]),
     )(config)
 
 

esphome/components/mipi_rgb/mipi_rgb.cpp

@@ -1,4 +1,4 @@
-#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)
+#ifdef USE_ESP32_VARIANT_ESP32S3
 #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  // defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)
+#endif  // USE_ESP32_VARIANT_ESP32S3

esphome/components/mipi_rgb/mipi_rgb.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)
+#ifdef USE_ESP32_VARIANT_ESP32S3
 #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) override;
+  void fill(Color color);
   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() override;
+  void dump_config();
 
   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.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/mqtt/mqtt_client.cpp

@@ -170,8 +170,10 @@ void MQTTClientComponent::send_device_info_() {
 void MQTTClientComponent::on_log(uint8_t level, const char *tag, const char *message, size_t message_len) {
   (void) tag;
   if (level <= this->log_level_ && this->is_connected()) {
-    this->publish(this->log_message_.topic.c_str(), message, message_len, this->log_message_.qos,
-                  this->log_message_.retain);
+    this->publish({.topic = this->log_message_.topic,
+                   .payload = std::string(message, message_len),
+                   .qos = this->log_message_.qos,
+                   .retain = this->log_message_.retain});
   }
 }
 #endif

esphome/components/mqtt/mqtt_climate.cpp

@@ -300,11 +300,9 @@ const EntityBase *MQTTClimateComponent::get_entity() const { return this->device
 
 bool MQTTClimateComponent::publish_state_() {
   auto traits = this->device_->get_traits();
-  // Reusable stack buffer for topic construction (avoids heap allocation per publish)
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   // mode
   bool success = true;
-  if (!this->publish(this->get_mode_state_topic_to(topic_buf), climate_mode_to_mqtt_str(this->device_->mode)))
+  if (!this->publish(this->get_mode_state_topic(), climate_mode_to_mqtt_str(this->device_->mode)))
     success = false;
   int8_t target_accuracy = traits.get_target_temperature_accuracy_decimals();
   int8_t current_accuracy = traits.get_current_temperature_accuracy_decimals();
@@ -313,70 +311,68 @@ bool MQTTClimateComponent::publish_state_() {
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE) &&
       !std::isnan(this->device_->current_temperature)) {
     len = value_accuracy_to_buf(payload, this->device_->current_temperature, current_accuracy);
-    if (!this->publish(this->get_current_temperature_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_current_temperature_state_topic(), payload, len))
       success = false;
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
                                climate::CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE)) {
     len = value_accuracy_to_buf(payload, this->device_->target_temperature_low, target_accuracy);
-    if (!this->publish(this->get_target_temperature_low_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_target_temperature_low_state_topic(), payload, len))
       success = false;
     len = value_accuracy_to_buf(payload, this->device_->target_temperature_high, target_accuracy);
-    if (!this->publish(this->get_target_temperature_high_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_target_temperature_high_state_topic(), payload, len))
       success = false;
   } else {
     len = value_accuracy_to_buf(payload, this->device_->target_temperature, target_accuracy);
-    if (!this->publish(this->get_target_temperature_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_target_temperature_state_topic(), payload, len))
       success = false;
   }
 
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY) &&
       !std::isnan(this->device_->current_humidity)) {
     len = value_accuracy_to_buf(payload, this->device_->current_humidity, 0);
-    if (!this->publish(this->get_current_humidity_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_current_humidity_state_topic(), payload, len))
       success = false;
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY) &&
       !std::isnan(this->device_->target_humidity)) {
     len = value_accuracy_to_buf(payload, this->device_->target_humidity, 0);
-    if (!this->publish(this->get_target_humidity_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_target_humidity_state_topic(), payload, len))
       success = false;
   }
 
   if (traits.get_supports_presets() || !traits.get_supported_custom_presets().empty()) {
     if (this->device_->has_custom_preset()) {
-      if (!this->publish(this->get_preset_state_topic_to(topic_buf), this->device_->get_custom_preset().c_str()))
+      if (!this->publish(this->get_preset_state_topic(), this->device_->get_custom_preset()))
         success = false;
     } else if (this->device_->preset.has_value()) {
-      if (!this->publish(this->get_preset_state_topic_to(topic_buf),
-                         climate_preset_to_mqtt_str(this->device_->preset.value())))
+      if (!this->publish(this->get_preset_state_topic(), climate_preset_to_mqtt_str(this->device_->preset.value())))
         success = false;
-    } else if (!this->publish(this->get_preset_state_topic_to(topic_buf), "")) {
+    } else if (!this->publish(this->get_preset_state_topic(), "")) {
       success = false;
     }
   }
 
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION)) {
-    if (!this->publish(this->get_action_state_topic_to(topic_buf), climate_action_to_mqtt_str(this->device_->action)))
+    if (!this->publish(this->get_action_state_topic(), climate_action_to_mqtt_str(this->device_->action)))
       success = false;
   }
 
   if (traits.get_supports_fan_modes()) {
     if (this->device_->has_custom_fan_mode()) {
-      if (!this->publish(this->get_fan_mode_state_topic_to(topic_buf), this->device_->get_custom_fan_mode().c_str()))
+      if (!this->publish(this->get_fan_mode_state_topic(), this->device_->get_custom_fan_mode()))
         success = false;
     } else if (this->device_->fan_mode.has_value()) {
-      if (!this->publish(this->get_fan_mode_state_topic_to(topic_buf),
+      if (!this->publish(this->get_fan_mode_state_topic(),
                          climate_fan_mode_to_mqtt_str(this->device_->fan_mode.value())))
         success = false;
-    } else if (!this->publish(this->get_fan_mode_state_topic_to(topic_buf), "")) {
+    } else if (!this->publish(this->get_fan_mode_state_topic(), "")) {
       success = false;
     }
   }
 
   if (traits.get_supports_swing_modes()) {
-    if (!this->publish(this->get_swing_mode_state_topic_to(topic_buf),
-                       climate_swing_mode_to_mqtt_str(this->device_->swing_mode)))
+    if (!this->publish(this->get_swing_mode_state_topic(), climate_swing_mode_to_mqtt_str(this->device_->swing_mode)))
       success = false;
   }
 

esphome/components/mqtt/mqtt_component.h

@@ -59,11 +59,6 @@ void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, b
 \
  public: \
   void set_custom_##name##_##type##_topic(const std::string &topic) { this->custom_##name##_##type##_topic_ = topic; } \
-  StringRef get_##name##_##type##_topic_to(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const { \
-    if (!this->custom_##name##_##type##_topic_.empty()) \
-      return StringRef(this->custom_##name##_##type##_topic_.data(), this->custom_##name##_##type##_topic_.size()); \
-    return this->get_default_topic_for_to_(buf, #name "/" #type, sizeof(#name "/" #type) - 1); \
-  } \
   std::string get_##name##_##type##_topic() const { \
     if (this->custom_##name##_##type##_topic_.empty()) \
       return this->get_default_topic_for_(#name "/" #type); \

esphome/components/mqtt/mqtt_cover.cpp

@@ -67,26 +67,17 @@ void MQTTCoverComponent::dump_config() {
   auto traits = this->cover_->get_traits();
   bool has_command_topic = traits.get_supports_position() || !traits.get_supports_tilt();
   LOG_MQTT_COMPONENT(true, has_command_topic);
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-#ifdef USE_MQTT_COVER_JSON
-  if (this->use_json_format_) {
-    ESP_LOGCONFIG(TAG, "  JSON State Payload: YES");
-  } else {
-#endif
-    if (traits.get_supports_position()) {
-      ESP_LOGCONFIG(TAG, "  Position State Topic: '%s'", this->get_position_state_topic_to(topic_buf).c_str());
-    }
-    if (traits.get_supports_tilt()) {
-      ESP_LOGCONFIG(TAG, "  Tilt State Topic: '%s'", this->get_tilt_state_topic_to(topic_buf).c_str());
-    }
-#ifdef USE_MQTT_COVER_JSON
-  }
-#endif
   if (traits.get_supports_position()) {
-    ESP_LOGCONFIG(TAG, "  Position Command Topic: '%s'", this->get_position_command_topic_to(topic_buf).c_str());
+    ESP_LOGCONFIG(TAG,
+                  "  Position State Topic: '%s'\n"
+                  "  Position Command Topic: '%s'",
+                  this->get_position_state_topic().c_str(), this->get_position_command_topic().c_str());
   }
   if (traits.get_supports_tilt()) {
-    ESP_LOGCONFIG(TAG, "  Tilt Command Topic: '%s'", this->get_tilt_command_topic_to(topic_buf).c_str());
+    ESP_LOGCONFIG(TAG,
+                  "  Tilt State Topic: '%s'\n"
+                  "  Tilt Command Topic: '%s'",
+                  this->get_tilt_state_topic().c_str(), this->get_tilt_command_topic().c_str());
   }
 }
 void MQTTCoverComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
@@ -101,33 +92,13 @@ void MQTTCoverComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConf
   if (traits.get_is_assumed_state()) {
     root[MQTT_OPTIMISTIC] = true;
   }
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-#ifdef USE_MQTT_COVER_JSON
-  if (this->use_json_format_) {
-    // JSON mode: all state published to state_topic as JSON, use templates to extract
-    root[MQTT_VALUE_TEMPLATE] = ESPHOME_F("{{ value_json.state }}");
-    if (traits.get_supports_position()) {
-      root[MQTT_POSITION_TOPIC] = this->get_state_topic_to_(topic_buf);
-      root[MQTT_POSITION_TEMPLATE] = ESPHOME_F("{{ value_json.position }}");
-      root[MQTT_SET_POSITION_TOPIC] = this->get_position_command_topic_to(topic_buf);
-    }
-    if (traits.get_supports_tilt()) {
-      root[MQTT_TILT_STATUS_TOPIC] = this->get_state_topic_to_(topic_buf);
-      root[MQTT_TILT_STATUS_TEMPLATE] = ESPHOME_F("{{ value_json.tilt }}");
-      root[MQTT_TILT_COMMAND_TOPIC] = this->get_tilt_command_topic_to(topic_buf);
-    }
-  } else
-#endif
-  {
-    // Standard mode: separate topics for position and tilt
-    if (traits.get_supports_position()) {
-      root[MQTT_POSITION_TOPIC] = this->get_position_state_topic_to(topic_buf);
-      root[MQTT_SET_POSITION_TOPIC] = this->get_position_command_topic_to(topic_buf);
-    }
-    if (traits.get_supports_tilt()) {
-      root[MQTT_TILT_STATUS_TOPIC] = this->get_tilt_state_topic_to(topic_buf);
-      root[MQTT_TILT_COMMAND_TOPIC] = this->get_tilt_command_topic_to(topic_buf);
-    }
+  if (traits.get_supports_position()) {
+    root[MQTT_POSITION_TOPIC] = this->get_position_state_topic();
+    root[MQTT_SET_POSITION_TOPIC] = this->get_position_command_topic();
+  }
+  if (traits.get_supports_tilt()) {
+    root[MQTT_TILT_STATUS_TOPIC] = this->get_tilt_state_topic();
+    root[MQTT_TILT_COMMAND_TOPIC] = this->get_tilt_command_topic();
   }
   if (traits.get_supports_tilt() && !traits.get_supports_position()) {
     config.command_topic = false;
@@ -140,36 +111,20 @@ const EntityBase *MQTTCoverComponent::get_entity() const { return this->cover_;
 bool MQTTCoverComponent::send_initial_state() { return this->publish_state(); }
 bool MQTTCoverComponent::publish_state() {
   auto traits = this->cover_->get_traits();
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-#ifdef USE_MQTT_COVER_JSON
-  if (this->use_json_format_) {
-    return this->publish_json(this->get_state_topic_to_(topic_buf), [this, traits](JsonObject root) {
-      // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-      root[ESPHOME_F("state")] = cover_state_to_mqtt_str(this->cover_->current_operation, this->cover_->position,
-                                                         traits.get_supports_position());
-      if (traits.get_supports_position()) {
-        root[ESPHOME_F("position")] = static_cast<int>(roundf(this->cover_->position * 100));
-      }
-      if (traits.get_supports_tilt()) {
-        root[ESPHOME_F("tilt")] = static_cast<int>(roundf(this->cover_->tilt * 100));
-      }
-      // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
-    });
-  }
-#endif
   bool success = true;
   if (traits.get_supports_position()) {
     char pos[VALUE_ACCURACY_MAX_LEN];
     size_t len = value_accuracy_to_buf(pos, roundf(this->cover_->position * 100), 0);
-    if (!this->publish(this->get_position_state_topic_to(topic_buf), pos, len))
+    if (!this->publish(this->get_position_state_topic(), pos, len))
       success = false;
   }
   if (traits.get_supports_tilt()) {
     char pos[VALUE_ACCURACY_MAX_LEN];
     size_t len = value_accuracy_to_buf(pos, roundf(this->cover_->tilt * 100), 0);
-    if (!this->publish(this->get_tilt_state_topic_to(topic_buf), pos, len))
+    if (!this->publish(this->get_tilt_state_topic(), pos, len))
       success = false;
   }
+  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   if (!this->publish(this->get_state_topic_to_(topic_buf),
                      cover_state_to_mqtt_str(this->cover_->current_operation, this->cover_->position,
                                              traits.get_supports_position())))

esphome/components/mqtt/mqtt_cover.h

@@ -27,18 +27,12 @@ class MQTTCoverComponent : public mqtt::MQTTComponent {
   bool publish_state();
 
   void dump_config() override;
-#ifdef USE_MQTT_COVER_JSON
-  void set_use_json_format(bool use_json_format) { this->use_json_format_ = use_json_format; }
-#endif
 
  protected:
   const char *component_type() const override;
   const EntityBase *get_entity() const override;
 
   cover::Cover *cover_;
-#ifdef USE_MQTT_COVER_JSON
-  bool use_json_format_{false};
-#endif
 };
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_fan.cpp

@@ -173,20 +173,19 @@ bool MQTTFanComponent::publish_state() {
   this->publish(this->get_state_topic_to_(topic_buf), state_s);
   bool failed = false;
   if (this->state_->get_traits().supports_direction()) {
-    bool success = this->publish(this->get_direction_state_topic_to(topic_buf),
-                                 fan_direction_to_mqtt_str(this->state_->direction));
+    bool success = this->publish(this->get_direction_state_topic(), fan_direction_to_mqtt_str(this->state_->direction));
     failed = failed || !success;
   }
   if (this->state_->get_traits().supports_oscillation()) {
-    bool success = this->publish(this->get_oscillation_state_topic_to(topic_buf),
-                                 fan_oscillation_to_mqtt_str(this->state_->oscillating));
+    bool success =
+        this->publish(this->get_oscillation_state_topic(), fan_oscillation_to_mqtt_str(this->state_->oscillating));
     failed = failed || !success;
   }
   auto traits = this->state_->get_traits();
   if (traits.supports_speed()) {
     char buf[12];
     size_t len = buf_append_printf(buf, sizeof(buf), 0, "%d", this->state_->speed);
-    bool success = this->publish(this->get_speed_level_state_topic_to(topic_buf), buf, len);
+    bool success = this->publish(this->get_speed_level_state_topic(), buf, len);
     failed = failed || !success;
   }
   return !failed;

esphome/components/mqtt/mqtt_valve.cpp

@@ -87,13 +87,13 @@ bool MQTTValveComponent::send_initial_state() { return this->publish_state(); }
 bool MQTTValveComponent::publish_state() {
   auto traits = this->valve_->get_traits();
   bool success = true;
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   if (traits.get_supports_position()) {
     char pos[VALUE_ACCURACY_MAX_LEN];
     size_t len = value_accuracy_to_buf(pos, roundf(this->valve_->position * 100), 0);
-    if (!this->publish(this->get_position_state_topic_to(topic_buf), pos, len))
+    if (!this->publish(this->get_position_state_topic(), pos, len))
       success = false;
   }
+  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   if (!this->publish(this->get_state_topic_to_(topic_buf),
                      valve_state_to_mqtt_str(this->valve_->current_operation, this->valve_->position,
                                              traits.get_supports_position())))

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.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/openthread/openthread_esp.cpp

@@ -104,7 +104,7 @@ void OpenThreadComponent::ot_main() {
   esp_cli_custom_command_init();
 #endif  // CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
 
-  otLinkModeConfig link_mode_config{};
+  otLinkModeConfig link_mode_config = {0};
 #if CONFIG_OPENTHREAD_FTD
   link_mode_config.mRxOnWhenIdle = true;
   link_mode_config.mDeviceType = true;

esphome/components/pipsolar/pipsolar.cpp

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

esphome/components/pulse_counter/pulse_counter_sensor.cpp

@@ -1,11 +1,6 @@
 #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 {
 
@@ -61,109 +56,103 @@ 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();
-
-  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;
+  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_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;
-  }
+  ESP_LOGCONFIG(TAG,
+                "    PCNT Unit Number: %u\n"
+                "    PCNT Channel Number: %u",
+                this->pcnt_unit, this->pcnt_channel);
 
-  pcnt_channel_edge_action_t rising = PCNT_CHANNEL_EDGE_ACTION_HOLD;
-  pcnt_channel_edge_action_t falling = PCNT_CHANNEL_EDGE_ACTION_HOLD;
+  pcnt_count_mode_t rising = PCNT_COUNT_DIS, falling = PCNT_COUNT_DIS;
   switch (this->rising_edge_mode) {
     case PULSE_COUNTER_DISABLE:
-      rising = PCNT_CHANNEL_EDGE_ACTION_HOLD;
+      rising = PCNT_COUNT_DIS;
       break;
     case PULSE_COUNTER_INCREMENT:
-      rising = PCNT_CHANNEL_EDGE_ACTION_INCREASE;
+      rising = PCNT_COUNT_INC;
       break;
     case PULSE_COUNTER_DECREMENT:
-      rising = PCNT_CHANNEL_EDGE_ACTION_DECREASE;
+      rising = PCNT_COUNT_DEC;
       break;
   }
   switch (this->falling_edge_mode) {
     case PULSE_COUNTER_DISABLE:
-      falling = PCNT_CHANNEL_EDGE_ACTION_HOLD;
+      falling = PCNT_COUNT_DIS;
       break;
     case PULSE_COUNTER_INCREMENT:
-      falling = PCNT_CHANNEL_EDGE_ACTION_INCREASE;
+      falling = PCNT_COUNT_INC;
       break;
     case PULSE_COUNTER_DECREMENT:
-      falling = PCNT_CHANNEL_EDGE_ACTION_DECREASE;
+      falling = PCNT_COUNT_DEC;
       break;
   }
 
-  error = pcnt_channel_set_edge_action(this->pcnt_channel, rising, falling);
+  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);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Setting PCNT edge action failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Configuring Pulse Counter failed: %s", esp_err_to_name(error));
     return false;
   }
 
   if (this->filter_us != 0) {
-    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);
+    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);
     if (error != ESP_OK) {
-      ESP_LOGE(TAG, "Setting PCNT glitch filter failed: %s", esp_err_to_name(error));
+      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));
       return false;
     }
   }
 
-  error = pcnt_unit_add_watch_point(this->pcnt_unit, INT16_MIN);
+  error = pcnt_counter_pause(this->pcnt_unit);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Adding PCNT low limit watch point failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Pausing pulse counter failed: %s", esp_err_to_name(error));
     return false;
   }
-  error = pcnt_unit_add_watch_point(this->pcnt_unit, INT16_MAX);
+  error = pcnt_counter_clear(this->pcnt_unit);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Adding PCNT high limit watch point failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Clearing pulse counter failed: %s", esp_err_to_name(error));
     return false;
   }
-
-  error = pcnt_unit_enable(this->pcnt_unit);
+  error = pcnt_counter_resume(this->pcnt_unit);
   if (error != ESP_OK) {
-    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));
+    ESP_LOGE(TAG, "Resuming pulse counter failed: %s", esp_err_to_name(error));
     return false;
   }
   return true;
 }
 
 pulse_counter_t HwPulseCounterStorage::read_raw_value() {
-  int count;
-  pcnt_unit_get_count(this->pcnt_unit, &count);
-  pulse_counter_t ret = count - this->last_value;
-  this->last_value = count;
+  pulse_counter_t counter;
+  pcnt_get_counter_value(this->pcnt_unit, &counter);
+  pulse_counter_t ret = counter - this->last_value;
+  this->last_value = counter;
   return ret;
 }
 #endif  // HAS_PCNT