[api] Assert the switch frame count instead of reading for it separately

Ping, device info, list entities done and disconnect all travel through
the ProtoMessage static entry points now that the no-op thunk is gone.

.github/workflows/ci.yml

@@ -244,20 +244,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      - name: Read prek version from requirements_test.txt
-        id: prek
-        # requirements_test.txt is the only place the version is pinned, so a
-        # Dependabot bump there is picked up here without a second edit.
-        run: |
-          if ! version=$(sed -nE 's/^prek==([^[:space:]#]+).*/\1/p' requirements_test.txt) || [ -z "$version" ]; then
-            echo "::error::No prek== pin found in requirements_test.txt."
-            exit 1
-          fi
-          echo "version=$version" >> "$GITHUB_OUTPUT"
       - name: Run prek
         uses: j178/prek-action@4e14d07f9231acabce116ccfca13b13dd9755ece # v3.0.0
         with:
-          prek-version: ${{ steps.prek.outputs.version }}
+          # Keep in sync with requirements_test.txt.
+          prek-version: "0.4.11"
           # This job only runs on pull requests, so nothing ever populates
           # the cache on dev. Every run would miss and then write a per-pull
           # request copy, which is what the old seed-cache job existed to

.github/workflows/sync-dependency-versions.yml

@@ -1,94 +0,0 @@
-# Keeps pre-commit hook revs in sync with the requirements files.
-#
-# Dependabot only bumps the pins in requirements*.txt. Some of those tools
-# are pinned again as hook revs in .pre-commit-config.yaml. This workflow
-# runs script/sync_dependency_versions.py against the pull request branch
-# and pushes a commit with the revs updated.
-
-name: Sync dependency versions
-
-on:
-  # pull_request_target rather than pull_request so the App secret is
-  # available on Dependabot pull requests (pull_request runs opened by
-  # Dependabot only see Dependabot secrets). The job below only touches
-  # branches in this repository and only ever executes the script from the
-  # base branch checkout, so fork code never runs with the token.
-  pull_request_target:
-    types: [opened, synchronize, reopened]
-    paths:
-      - requirements_dev.txt
-      - requirements_test.txt
-      - .pre-commit-config.yaml
-      - script/sync_dependency_versions.py
-
-# The push to the pull request branch uses the App token minted below, so
-# the workflow's GITHUB_TOKEN does not need any scopes.
-permissions: {}
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
-  cancel-in-progress: true
-
-jobs:
-  sync:
-    name: Sync pinned versions
-    runs-on: ubuntu-latest
-    # Same-repository branches only: a push to a fork is not possible with
-    # this token, and it keeps untrusted heads out of a privileged job.
-    if: >-
-      github.repository == 'esphome/esphome'
-      && github.event.pull_request.head.repo.full_name == github.repository
-    steps:
-      - name: Generate a token
-        id: generate-token
-        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1 # v3.2.0
-        with:
-          client-id: ${{ vars.ESPHOME_GITHUB_APP_CLIENT_ID }}
-          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
-          # A push made with the workflow's own GITHUB_TOKEN would not start
-          # CI on the new commit; a push with the App token does.
-          permission-contents: write  # git push of the sync commit to the pull request branch
-
-      - name: Check out base branch
-        # Provides the script that runs below. Deliberately the base branch
-        # so the pull request cannot change what executes here.
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.event.pull_request.base.sha }}
-          persist-credentials: false
-
-      - name: Check out pull request branch
-        # No allow-unsafe-pr-checkout here on purpose: checkout v7 only
-        # refuses heads that live in a different repository, and the job
-        # condition above already limits runs to same-repository branches.
-        # Leaving it off keeps that refusal as a backstop for fork heads.
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.event.pull_request.head.ref }}
-          path: pull-request
-          token: ${{ steps.generate-token.outputs.token }}
-
-      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
-        with:
-          python-version: "3.12"
-
-      - name: Install yamlrocks
-        # The script edits YAML through yamlrocks. Take the pin from the
-        # base branch requirements so this workflow has no copy of its own.
-        run: pip install "$(grep -E '^yamlrocks==' requirements_test.txt | cut -d'#' -f1)"
-
-      - name: Sync pinned versions
-        run: python script/sync_dependency_versions.py --root pull-request
-
-      - name: Push changes
-        working-directory: pull-request
-        run: |
-          if git diff --quiet; then
-            echo "All pinned versions already match the requirements files."
-            exit 0
-          fi
-          git config user.name "esphome[bot]"
-          git config user.email "115708604+esphome[bot]@users.noreply.github.com"
-          git commit -am "Sync pinned tool versions with requirements files"
-          git push

.pre-commit-config.yaml

@@ -1,6 +1,7 @@
 ---
 # See https://pre-commit.com for more information
 # See https://pre-commit.com/hooks.html for more hooks
+
 ci:
   autoupdate_commit_msg: 'pre-commit: autoupdate'
   autoupdate_schedule: off  # Disabled until ruff versions are synced between deps and pre-commit
@@ -10,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.16.6
+    rev: v0.16.3
     hooks:
       # Run the linter.
       - id: ruff
@@ -41,7 +42,7 @@ repos:
       - id: pyupgrade
         args: [--py312-plus]
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.38.0
+    rev: v1.37.1
     hooks:
       - id: yamllint
         exclude: ^(\.clang-format|\.clang-tidy)$

AGENTS.md

@@ -840,7 +840,7 @@ file does, and it is the authority when they disagree. The most useful starting
         cv.rename_key(
             CONF_OLD_KEY, CONF_NEW_KEY, removed_in="2026.6.0", component="my_component"
         ),
-        cv.Schema({...}),
+        cv.Schema({ ... }),
     )
     ```
     For other deprecations, warn manually during validation:

docker/Dockerfile

@@ -22,7 +22,7 @@ RUN \
     -r /requirements.txt
 
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.14.5
+RUN uv pip install --no-cache-dir esphome-device-builder==1.14.4
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/api_client.py

@@ -23,7 +23,9 @@ from esphome.util import safe_print
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from aioesphomeapi.api_pb2 import SubscribeLogsResponse  # pylint: disable=no-name-in-module
+    from aioesphomeapi.api_pb2 import (
+        SubscribeLogsResponse,  # pylint: disable=no-name-in-module
+    )
 
 
 _LOGGER = logging.getLogger(__name__)

esphome/build_gen/arduino8266.py

@@ -1,773 +0,0 @@
-"""Build specification for the native ESP8266 Arduino toolchain.
-
-Transliterates the PlatformIO build spec for the Arduino ESP8266 framework
-(``framework-arduinoespressif8266/tools/platformio-build.py`` plus
-``platform-espressif8266/builder/main.py``): the flag sets, defines, and
-linker-script generation deliberately match what PlatformIO produces so the
-binaries stay near-identical between the two toolchains. The ninja emission
-(``write_project``) builds on these pieces.
-
-The ``PIO_FRAMEWORK_ARDUINO_*`` knob defines (lwIP variant, NONOS SDK
-version, MMU layout, exceptions, waveform phase) keep working: they are read
-from the build flags with the same precedence as the PlatformIO builder.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import hashlib
-import logging
-import os
-from pathlib import Path
-import re
-import shlex
-import subprocess
-from typing import TYPE_CHECKING, NamedTuple
-
-from esphome.arduino8266.framework import toolchain_tool
-from esphome.build_helpers.ninja import shell_token as _shell_token
-from esphome.components.esp8266 import build_surgery
-from esphome.core import CORE, EsphomeError
-from esphome.helpers import mkdir_p, write_file_if_changed
-from esphome.platformio.library import lex_build_flags
-
-if TYPE_CHECKING:
-    from esphome.arduino8266.framework import InstalledPaths
-
-_LOGGER = logging.getLogger(__name__)
-
-# Values that land unquoted on generated command lines are shape-checked
-# against these before use. re.ASCII: a Unicode digit or word character
-# (Arabic-Indic numerals) would pass \d/\w and defeat the named error
-_MMU_VALUE_RE = re.compile(r"(?:0[xX][0-9a-fA-F]+|\d+)[uUlL]*", re.ASCII)
-_MMU_HEX_VALUE_RE = re.compile(r"0[xX][0-9a-fA-F]+[uUlL]*", re.ASCII)
-# Only these land in the preprocessed script's ``len =`` fields, which
-# build_surgery's segment parser reads back as hex; the other MMU_* macros
-# (MMU_EXTERNAL_HEAP=128) are consumed by mmu_iram.h and may be decimal
-_MMU_SEGMENT_SIZE_NAMES = ("MMU_IRAM_SIZE", "MMU_ICACHE_SIZE")
-_BOARD_NAME_RE = re.compile(r"[\w.-]+", re.ASCII)
-_F_CPU_RE = re.compile(r"\d+L?", re.ASCII)
-_FLASH_LD_NAME_RE = re.compile(r"[\w.-]+\.ld", re.ASCII)
-
-# Every supported board ships this clock; board_build.f_cpu overrides
-_DEFAULT_F_CPU = "80000000L"
-
-# The SDK linker-script template and the preprocessed copy the build links
-# against; the cache stamp and stderr sidecars derive from the output name
-_COMMON_LD_HEADER = "eagle.app.v6.common.ld.h"
-_COMMON_LD_NAME = "local.eagle.app.v6.common.ld"
-# Testing mode shadows the SDK flash ld with a patched copy under this name
-_TESTING_LD_PREFIX = "testing_"
-
-# The recovery hint for a half-extracted or damaged framework cache
-_CLEAN_HINT = "run 'esphome clean-all' and retry"
-
-
-def _sdk_ld_dir(framework: Path) -> Path:
-    return framework / "tools" / "sdk" / "ld"
-
-
-def _apply_surgery(fn, *args: object) -> str:
-    """Run one build_surgery edit, naming a failed anchor instead of a
-    traceback (the surgery module raises bare RuntimeError so its
-    ``.py.script`` twins stay importable without esphome)."""
-    try:
-        return fn(*args)
-    except RuntimeError as err:
-        raise EsphomeError(str(err)) from err
-
-
-# From platformio-build.py. Knob suffix -> SDK define; the first entry is
-# the default (dicts preserve insertion order). With multiple SDK knobs set
-# (a pathological config) ties break by table order, since upstream's
-# tie-break depends on define order and is not reproducible here.
-_NONOSDK_VERSIONS = {
-    "SDK22x_190703": "NONOSDK22x_190703",
-    "SDK221": "NONOSDK221",
-    "SDK22x_190313": "NONOSDK22x_190313",
-    "SDK22x_191024": "NONOSDK22x_191024",
-    "SDK22x_191105": "NONOSDK22x_191105",
-    "SDK22x_191122": "NONOSDK22x_191122",
-    "SDK305": "NONOSDK305",
-}
-
-
-class _LwipVariant(NamedTuple):
-    """One lwIP build variant: the defines and the prebuilt library that
-    was compiled with them."""
-
-    tcp_mss: int
-    features: int
-    ipv6: int
-    lib: str
-
-
-# Knob define -> variant; first match wins, in insertion order (as in
-# platformio-build.py)
-_LWIP_VARIANTS = {
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_IPV6_LOW_MEMORY": _LwipVariant(
-        536, 1, 1, "lwip6-536-feat"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_IPV6_HIGHER_BANDWIDTH": _LwipVariant(
-        1460, 1, 1, "lwip6-1460-feat"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH": _LwipVariant(
-        1460, 1, 0, "lwip2-1460-feat"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_LOW_MEMORY_LOW_FLASH": _LwipVariant(
-        536, 0, 0, "lwip2-536"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH_LOW_FLASH": _LwipVariant(
-        1460, 0, 0, "lwip2-1460"
-    ),
-}
-# The default is PIO_FRAMEWORK_ARDUINO_LWIP2_LOW_MEMORY's variant: upstream
-# has no branch for that spelling (it is the else), so any listed knob wins
-# over it -- sntp emits LOW_MEMORY while esp8266 always emits
-# HIGHER_BANDWIDTH_LOW_FLASH, and the latter must win as under PlatformIO
-_LWIP_DEFAULT = _LwipVariant(536, 1, 0, "lwip2-536-feat")
-
-# Knob define -> MMU_* defines; first match wins, in insertion order (as
-# in platformio-build.py)
-_MMU_VARIANTS = {
-    "PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48": (
-        "MMU_IRAM_SIZE=0xC000",
-        "MMU_ICACHE_SIZE=0x4000",
-    ),
-    "PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48_SECHEAP_SHARED": (
-        "MMU_IRAM_SIZE=0xC000",
-        "MMU_ICACHE_SIZE=0x4000",
-        "MMU_IRAM_HEAP",
-    ),
-    "PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM32_SECHEAP_NOTSHARED": (
-        "MMU_IRAM_SIZE=0x8000",
-        "MMU_ICACHE_SIZE=0x4000",
-        "MMU_SEC_HEAP_SIZE=0x4000",
-        "MMU_SEC_HEAP=0x40108000",
-    ),
-    "PIO_FRAMEWORK_ARDUINO_MMU_EXTERNAL_128K": (
-        "MMU_IRAM_SIZE=0x8000",
-        "MMU_ICACHE_SIZE=0x8000",
-        "MMU_EXTERNAL_HEAP=128",
-    ),
-    # Upstream really does cap the 1024K option's heap knob at 256
-    # (platformio-build.py's MMU_EXTERNAL_1024K branch); transliterated
-    # verbatim
-    "PIO_FRAMEWORK_ARDUINO_MMU_EXTERNAL_1024K": (
-        "MMU_IRAM_SIZE=0x8000",
-        "MMU_ICACHE_SIZE=0x8000",
-        "MMU_EXTERNAL_HEAP=256",
-    ),
-}
-# From platformio-build.py: the invariant framework defines every TU gets
-# (ARDUINO=10805 encodes the IDE compatibility level); the board, flash-mode,
-# knob, and MMU defines are composed around them in _defines_flags, in
-# upstream's order.
-_FRAMEWORK_DEFINES = ("__ets__", "ICACHE_FLASH", "_GNU_SOURCE", "ARDUINO=10805")
-_ARCH_DEFINES = ("ESP8266", "ARDUINO_ARCH_ESP8266")
-
-# Upstream reads these from the board manifest (build.mmu_iram_size etc.);
-# no supported board sets them, so the platformio-build.py defaults are
-# hardcoded here rather than drift
-_MMU_DEFAULT = ("MMU_IRAM_SIZE=0x8000", "MMU_ICACHE_SIZE=0x8000")
-
-# Upstream's CXXFLAGS (-fno-rtti, the -std level, -f(no-)exceptions) and the
-# trailing stdc++/m/c/gcc system libs are composed at emission
-# (write_project) from CORE.cpp_standard and _BuildConfig.exceptions.
-_ASFLAGS = ["-mlongcalls", "-mtext-section-literals"]
-_CFLAGS = [
-    "-std=gnu17",
-    "-Wpointer-arith",
-    "-Wno-implicit-function-declaration",
-    "-Wl,-EL",
-    "-fno-inline-functions",
-    "-nostdlib",
-]
-_CCFLAGS = [
-    "-Os",
-    "-mlongcalls",
-    "-mtext-section-literals",
-    "-falign-functions=4",
-    "-U__STRICT_ANSI__",
-    "-ffunction-sections",
-    "-fdata-sections",
-    "-Wall",
-    "-Werror=return-type",
-    "-free",
-    "-fipa-pta",
-]
-# Upstream's -u _scanf_float is deliberately absent: it is re-added from
-# KEY_SCANF_FLOAT at emission (the remove_float_scanf extra script's job).
-_LINKFLAGS = [
-    "-Os",
-    "-nostdlib",
-    "-Wl,--no-check-sections",
-    "-Wl,-static",
-    "-Wl,--gc-sections",
-    "-Wl,-wrap,system_restart_local",
-    "-Wl,-wrap,spi_flash_read",
-    "-u",
-    "app_entry",
-    "-u",
-    "_printf_float",
-    "-u",
-    "_DebugExceptionVector",
-    "-u",
-    "_DoubleExceptionVector",
-    "-u",
-    "_KernelExceptionVector",
-    "-u",
-    "_NMIExceptionVector",
-    "-u",
-    "_UserExceptionVector",
-]
-_SYSTEM_LIBS_PRE_LWIP = ["hal", "phy", "pp", "net80211"]
-_SYSTEM_LIBS_POST_LWIP = [
-    "wpa",
-    "crypto",
-    "main",
-    "wps",
-    "bearssl",
-    "espnow",
-    "smartconfig",
-    "airkiss",
-    "wpa2",
-]
-
-
-@dataclass
-class _BuildConfig:
-    """Knob-derived build configuration (PIO_FRAMEWORK_ARDUINO_* defines)."""
-
-    nonosdk: str
-    lwip_lib: str
-    exceptions: bool
-    vtables: str
-    fp_in_irom: bool
-    knob_defines: list[str]
-    mmu_defines: list[str]
-
-
-def _lexed_build_flags() -> list[str]:
-    """Shell-lex ``CORE.build_flags`` as PlatformIO's ``ParseFlags`` does,
-    sorted so duplicate defines resolve deterministically.
-
-    Lex once per build; consumers share the tokens.
-    """
-    # The funnel warns and drops empty glued arguments (-D "") itself
-    return lex_build_flags(sorted(CORE.build_flags), "esphome")
-
-
-def _flag_defines(unflags: set[str], tokens: list[str]) -> dict[str, str]:
-    """Map define name -> full ``NAME[=VALUE]`` for every -D build flag.
-
-    ``tokens`` comes from one ``_lexed_build_flags()`` call shared with
-    ``_project_flags``, which already warned about and dropped any bare "-D".
-    """
-    defines: dict[str, str] = {}
-    for tok in tokens:
-        # An unflagged knob must not drive lwIP/SDK/MMU selection while
-        # being absent from the compile line
-        if tok in unflags:
-            continue
-        if tok.startswith("-D"):
-            body = tok[2:]
-            defines[body.split("=", 1)[0]] = body
-    return defines
-
-
-def _resolve_build_config(defines: dict[str, str]) -> _BuildConfig:
-    nonosdk = next(
-        (
-            define
-            for name, define in _NONOSDK_VERSIONS.items()
-            if f"PIO_FRAMEWORK_ARDUINO_ESPRESSIF_{name}" in defines
-        ),
-        next(iter(_NONOSDK_VERSIONS.values())),
-    )
-    # Same compile-line/linked-artifact split as the lwIP knobs below: a
-    # raw NONOSDK* would define a second SDK macro while the link still
-    # resolves against the knob's libraries
-    if raw_sdk := sorted(n for n in defines if n.startswith("NONOSDK")):
-        raise EsphomeError(
-            f"{', '.join(raw_sdk)} are set by the "
-            "PIO_FRAMEWORK_ARDUINO_ESPRESSIF_SDK* knobs; drop the raw "
-            "build flags"
-        )
-
-    lwip = next(
-        (variant for knob, variant in _LWIP_VARIANTS.items() if knob in defines),
-        _LWIP_DEFAULT,
-    )
-
-    # The lwIP triple selects a prebuilt library; a raw override would win
-    # the compile line (user tokens come last here) while the link still
-    # pulls the library built for the knob's values
-    if owned := sorted(
-        n for n in ("TCP_MSS", "LWIP_FEATURES", "LWIP_IPV6") if n in defines
-    ):
-        raise EsphomeError(
-            f"{', '.join(owned)} are set by the PIO_FRAMEWORK_ARDUINO_LWIP2_* "
-            "knobs; drop the raw build flags"
-        )
-    knob_defines = [
-        f"{nonosdk}=1",
-        f"TCP_MSS={lwip.tcp_mss}",
-        f"LWIP_FEATURES={lwip.features}",
-        f"LWIP_IPV6={lwip.ipv6}",
-    ]
-    if "PIO_FRAMEWORK_ARDUINO_WAVEFORM_LOCKED_PHASE" in defines:
-        knob_defines.append("WAVEFORM_LOCKED_PHASE=1")
-
-    # Sorted so the pick is deterministic: the dict is built from a set of
-    # build flags, whose iteration order varies between processes.
-    vtables_knobs = sorted(name for name in defines if name.startswith("VTABLES_IN_"))
-    known_vtables = {"VTABLES_IN_FLASH", "VTABLES_IN_DRAM", "VTABLES_IN_IRAM"}
-    # A typo'd or conflicting knob would otherwise fail obscurely in the
-    # SDK header's #error
-    if unknown := [k for k in vtables_knobs if k not in known_vtables]:
-        raise EsphomeError(f"Unknown VTABLES_IN_* define(s): {', '.join(unknown)}")
-    # A body (e.g. VTABLES_IN_FLASH=0) would split the compile line from the
-    # linker script, which always defines the bare name
-    if valued := [defines[k] for k in vtables_knobs if defines[k] not in (k, f"{k}=1")]:
-        raise EsphomeError(f"VTABLES_IN_* defines take no value: {', '.join(valued)}")
-    if len(vtables_knobs) > 1:
-        raise EsphomeError(
-            f"Conflicting VTABLES_IN_* defines: {', '.join(vtables_knobs)}"
-        )
-    vtables = vtables_knobs[0] if vtables_knobs else "VTABLES_IN_FLASH"
-
-    mmu_knob = next((knob for knob in _MMU_VARIANTS if knob in defines), None)
-    if mmu_knob is not None:
-        if raw := sorted(n for n in defines if n.startswith("MMU_")):
-            # Same compile-line/linker-script split as the no-knob case below
-            fix = (
-                f"drop {mmu_knob} to use the custom sizes"
-                if "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM" in defines
-                else "drop the raw MMU_* build flags or use "
-                "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM"
-            )
-            raise EsphomeError(f"{', '.join(raw)} conflict with {mmu_knob}; {fix}")
-        mmu = list(_MMU_VARIANTS[mmu_knob])
-    elif "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM" in defines:
-        if "MMU_IRAM_SIZE" not in defines or "MMU_ICACHE_SIZE" not in defines:
-            raise EsphomeError(
-                "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM requires MMU_IRAM_SIZE and "
-                "MMU_ICACHE_SIZE build flags"
-            )
-        for name in _MMU_SEGMENT_SIZE_NAMES:
-            # A bare -Dname would preprocess to len = 1 and fail far away
-            if "=" not in defines[name]:
-                raise EsphomeError(
-                    f"{name} must be a hex literal (e.g. 0x8000), got (no value)"
-                )
-        for name, body in defines.items():
-            if not name.startswith("MMU_") or "=" not in body:
-                # Valueless flags (MMU_IRAM_HEAP) are legitimate switches
-                continue
-            # Every valued MMU_* reaches the linker-script preprocessor; a
-            # bare or non-numeric value would corrupt it and fail far away
-            # in ld. The two segment sizes must additionally be hex:
-            # build_surgery's segment parser cannot read decimal back.
-            value = body.partition("=")[2]
-            rule = (
-                _MMU_HEX_VALUE_RE if name in _MMU_SEGMENT_SIZE_NAMES else _MMU_VALUE_RE
-            )
-            if not rule.fullmatch(value):
-                shape = (
-                    "a hex literal (e.g. 0x8000)"
-                    if name in _MMU_SEGMENT_SIZE_NAMES
-                    else "a numeric literal"
-                )
-                raise EsphomeError(
-                    f"{name} must be {shape}, got {value or '(no value)'}"
-                )
-        # Sorted so build.ninja and the linker-script stamp stay
-        # byte-stable across runs (the flag set has no deterministic
-        # iteration order).
-        mmu = sorted(body for name, body in defines.items() if name.startswith("MMU_"))
-    else:
-        if raw := sorted(n for n in defines if n.startswith("MMU_")):
-            # Unlike PlatformIO (whose defaults win the compile line), user
-            # MMU_* here would win the compile but not the linker script;
-            # refuse them all, like the knob branch above.
-            raise EsphomeError(
-                f"Raw {', '.join(raw)} build flags require "
-                "-DPIO_FRAMEWORK_ARDUINO_MMU_CUSTOM"
-            )
-        mmu = list(_MMU_DEFAULT)
-
-    return _BuildConfig(
-        nonosdk=nonosdk,
-        lwip_lib=lwip.lib,
-        exceptions="PIO_FRAMEWORK_ARDUINO_ENABLE_EXCEPTIONS" in defines,
-        vtables=vtables,
-        fp_in_irom="FP_IN_IROM" in defines,
-        knob_defines=knob_defines,
-        mmu_defines=mmu,
-    )
-
-
-def _pio_option(key: str, default: str) -> str:
-    """A platformio_options value the native build honors (str-normalized).
-
-    core/config.py routes these into ``CORE.platformio_options`` under the
-    arduino toolchain and already collapses a repeated option to its last
-    value (like a later platformio.ini line), so a scalar always arrives.
-    """
-    value = CORE.platformio_options.get(key)
-    if value is None:
-        return default
-    value = str(value).strip()
-    if not value:
-        raise EsphomeError(f"platformio_options {key} is empty")
-    return value
-
-
-def _defines_flags(
-    config: _BuildConfig, flash_mode: str, board: str, board_defines: tuple[str, ...]
-) -> list[str]:
-    r"""The framework/board -D tokens for the compile line.
-
-    The returned tokens already carry shell-level escaping (the board
-    defines embed ``\"``), so they must be emitted unquoted; wrapping
-    them in ``_shell_token`` would deliver literal backslashes to gcc.
-    ``flash_mode`` also lands unquoted: callers pass it pre-validated
-    against ``BUILD_FLASH_MODES`` (cv.one_of at config time, the
-    ``_FLASH_MODES`` check at the emission half's read site).
-    """
-    if not _BOARD_NAME_RE.fullmatch(board):
-        # The name lands unquoted in two -D bodies; reject it by name
-        # instead of corrupting the compile line
-        raise EsphomeError(f"Invalid board name {board!r}")
-    # Every supported board ships 80 MHz; board_build.f_cpu overrides
-    f_cpu = _pio_option("board_build.f_cpu", _DEFAULT_F_CPU)
-    if not _F_CPU_RE.fullmatch(f_cpu):
-        # The value lands unquoted on the compile line; reject by name
-        # instead of corrupting it
-        raise EsphomeError(f"Invalid board_build.f_cpu value {f_cpu!r}")
-    return [
-        f"-D{d}"
-        for d in (
-            f"F_CPU={f_cpu}",
-            *_FRAMEWORK_DEFINES,
-            f'ARDUINO_BOARD=\\"PLATFORMIO_{board.upper()}\\"',
-            f'ARDUINO_BOARD_ID=\\"{board}\\"',
-            f"FLASHMODE_{flash_mode.upper()}",
-            "LWIP_OPEN_SRC",
-            *config.knob_defines,
-            config.vtables,
-            # User-supplied bodies re-quote like every other user token
-            # (a no-op for real MMU values)
-            *(_shell_token(d) for d in config.mmu_defines),
-            *_ARCH_DEFINES,
-            *board_defines,
-        )
-    ]
-
-
-def _unflag_tokens() -> set[str]:
-    """``build_unflags`` entries shell-lexed to tokens, as PlatformIO matches."""
-    # Lexed like _lexed_build_flags reads build_flags, so "-D FOO" removes
-    # -DFOO in both spellings (PlatformIO's ProcessUnFlags parses the same
-    # way) and no bare half can collaterally drop an unrelated token
-    return set(lex_build_flags(list(CORE.build_unflags), "esphome build_unflags"))
-
-
-def _project_flags(
-    unflags: set[str], tokens: list[str]
-) -> tuple[list[str], list[str], list[Path], list[str]]:
-    """Split the ESPHome build flags into compile, linker, -L, and -l lists.
-
-    Plain-form linker flags (``_PLAIN_LINKER_FLAGS``/``_PLAIN_LINKER_PREFIXES``)
-    raise: they would be inert on the ``-c`` compile line.
-    ``compile_flags``/``link_flags`` come back shell-quoted;
-    ``lib_dirs``/``libs`` are raw, quote at emission.
-    """
-    compile_flags: list[str] = []
-    link_flags: list[str] = []
-    lib_dirs: list[Path] = []
-    libs: list[str] = []
-    for tok in tokens:
-        if tok in unflags:
-            continue
-        # _lexed_build_flags warned about and dropped any bare -I/-D/-L/-l
-        if tok.startswith("-Wl,"):
-            link_flags.append(_shell_token(tok))
-        elif tok.startswith("-L"):
-            lib_dirs.append(Path(tok[2:]))
-        elif tok.startswith("-l"):
-            libs.append(tok[2:])
-        else:
-            if tok.startswith(_PLAIN_DRIVER_LINK_PREFIXES):
-                # Driver options with no -Wl, spelling; ld would reject them
-                raise EsphomeError(
-                    f"Link flag {tok} in build_flags is not supported by the "
-                    "native toolchain"
-                )
-            if tok in _PLAIN_LINKER_FLAGS or tok.startswith(_PLAIN_LINKER_PREFIXES):
-                raise EsphomeError(
-                    f"Linker flag {tok} in build_flags is not routed to the "
-                    "link line; use the -Wl, form"
-                )
-            if tok.startswith("-") and not tok.startswith(_COMPILE_FLAG_PREFIXES):
-                # The linker deny lists are not exhaustive; an unlisted
-                # link-only spelling would be inert on the -c compile line,
-                # so at least surface the odd shape
-                _LOGGER.warning(
-                    "Build flag %s is not a recognized compile-flag shape; "
-                    "it is passed to the compile line only",
-                    tok,
-                )
-            compile_flags.append(_shell_token(tok))
-    return compile_flags, link_flags, lib_dirs, libs
-
-
-# Recognized compile-flag shapes: the allow-list feeding the fall-through
-# warning in _project_flags (an unlisted link-only spelling still reaches
-# the compile line, but not silently)
-_COMPILE_FLAG_PREFIXES = (
-    "-D",
-    "-I",
-    "-U",
-    "-W",
-    "-f",
-    "-m",
-    "-O",
-    "-g",
-    "-std=",
-    "-include",
-)
-# Plain-form linker flags rejected by _project_flags: inert on a -c compile
-# line, so the firmware would silently lack the requested link behavior.
-# Best-effort, not exhaustive; see _COMPILE_FLAG_PREFIXES above.
-_PLAIN_LINKER_FLAGS = (
-    "-u",
-    "-e",
-    "-s",
-    "-static",
-    "-nostartfiles",
-    "-nodefaultlibs",
-    "-nostdlib",
-    "-rdynamic",
-)
-_PLAIN_LINKER_PREFIXES = ("-T", "-Xlinker")
-# Driver options, not ld options: -Wl, has no equivalent for these
-_PLAIN_DRIVER_LINK_PREFIXES = ("-fuse-ld=", "--specs=", "-specs=")
-
-
-def _stat_sig(path: Path) -> str:
-    """Size and mtime cache-stamp signature for one input file.
-
-    Absent stays deterministic ("missing": the spawn names it); unreadable
-    forces a cache miss every run rather than pinning the stamp to a
-    constant that can never notice a later edit.
-    """
-    try:
-        st = path.stat()
-        return f"{st.st_size}:{st.st_mtime_ns}"
-    except FileNotFoundError:
-        return "missing"
-    except OSError as err:
-        _LOGGER.warning(
-            "Could not stat %s (%s); regenerating the linker script every "
-            "build. Run 'esphome clean-all' to reinstall the framework.",
-            path,
-            err,
-        )
-        return f"unreadable:{os.urandom(8).hex()}"
-
-
-def _write_note(path: Path, text: str, *, warn: bool = False) -> bool:
-    """Best-effort bookkeeping write; a failure never fails the build.
-
-    ``warn`` marks notes whose loss drops a diagnostic on later cached
-    builds; a lost stamp only costs a cache miss and stays at debug.
-    Returns whether the write persisted, so a lost warn note can veto
-    the cache stamp and keep the diagnostic re-derivable.
-    """
-    try:
-        path.write_text(text, encoding="utf-8")
-    except OSError as err:
-        log = _LOGGER.warning if warn else _LOGGER.debug
-        log("Could not write %s: %s", path, err)
-        return False
-    return True
-
-
-def generate_ld_scripts(
-    paths: InstalledPaths, config: _BuildConfig, flash_ld_name: str
-) -> None:
-    """Generate the common linker script (and testing-mode flash ld copy).
-
-    Runs the same preprocessor invocation as the PlatformIO builder over
-    ``eagle.app.v6.common.ld.h``, then applies ESPHome's surgeries: the wifi
-    rate-table DRAM relocation, and enlarged memory segments in testing mode.
-    """
-    if not _FLASH_LD_NAME_RE.fullmatch(flash_ld_name):
-        # Joined under the SDK and build ld dirs; never a path or traversal
-        raise EsphomeError(f"Invalid flash linker script name {flash_ld_name!r}")
-    framework = paths.framework
-    gcc = toolchain_tool(paths.toolchain, "gcc")
-    ld_dir = CORE.relative_pioenvs_path(CORE.name, "ld")
-    mkdir_p(ld_dir)
-
-    cmd = [str(gcc), "-CC", "-E", "-P", f"-D{config.vtables}"]
-    cmd += [f"-D{d}" for d in config.mmu_defines]
-    if config.fp_in_irom:
-        cmd.append("-DFP_IN_IROM")
-    header = _sdk_ld_dir(framework) / _COMMON_LD_HEADER
-    cmd += [str(header), "-o", "-"]
-
-    # The inputs are the command line (defines + framework version, which is
-    # baked into the paths) plus testing mode; skip the preprocessor spawn on
-    # incremental builds when nothing changed.
-    output = ld_dir / _COMMON_LD_NAME
-    stamp = ld_dir / f".{_COMMON_LD_NAME}.stamp"
-    # Stamp includes the header/gcc stat (catches in-place re-extraction)
-    # and the surgery fingerprint (a build_surgery edit invalidates old
-    # build dirs)
-    stamp_content = (
-        # shlex.join: a spaced path stays one quoted element, so two
-        # different cmd lists can never collide to the same stamp string
-        shlex.join(cmd)
-        + f" testing={CORE.testing_mode}"
-        + f" header={_stat_sig(header)}"
-        + f" gcc={_stat_sig(gcc)}"
-        + f" {build_surgery.surgery_fingerprint()}"
-    )
-
-    stderr_note = ld_dir / f".{_COMMON_LD_NAME}.stderr"
-
-    def _note_digest() -> str:
-        # The note is an output like the script itself; folding its state
-        # into the stamp makes an externally removed or edited note a cache
-        # miss that re-runs -E and re-derives the diagnostic
-        if not stderr_note.is_file():
-            return "none"
-        return hashlib.sha256(stderr_note.read_bytes()).hexdigest()
-
-    def _cached_ld_is_valid() -> bool:
-        # Any damaged cache regenerates; never abort the build over it. The
-        # stamp records the sha256 of the content written, so an externally
-        # edited script regenerates too.
-        try:
-            if not (output.is_file() and stamp.is_file()):
-                return False
-            rest, sep, digest = stamp.read_text(encoding="utf-8").rpartition(
-                " content="
-            )
-            inputs, note_sep, note_digest = rest.rpartition(" note=")
-            return (
-                bool(sep)
-                and bool(note_sep)
-                and inputs == stamp_content
-                and note_digest == _note_digest()
-                and hashlib.sha256(output.read_bytes()).hexdigest() == digest
-            )
-        except (OSError, UnicodeDecodeError):
-            return False
-
-    if not _cached_ld_is_valid():
-        try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                check=False,
-                close_fds=False,
-            )
-        except OSError as err:
-            # A half-extracted or half-deleted toolchain cache reaches here
-            raise EsphomeError(f"Could not run {gcc}: {err}; {_CLEAN_HINT}") from err
-        # Localized gcc diagnostics on a non-UTF-8 console must degrade,
-        # not UnicodeDecodeError the build; the script itself (below) is
-        # decoded strictly instead, so a mangled byte can never be cached
-        stderr_text = result.stderr.decode("utf-8", errors="replace")
-        if result.returncode != 0:
-            raise EsphomeError(f"Generating the linker script failed:\n{stderr_text}")
-        note_persisted = True
-        if stderr_text.strip():
-            # Preprocessor warnings on the success path must reach the user
-            # on this and every later cached build (see the re-emit below)
-            _LOGGER.warning("Linker-script preprocessor: %s", stderr_text.strip())
-            note_persisted = _write_note(stderr_note, stderr_text.strip(), warn=True)
-        else:
-            try:
-                stderr_note.unlink(missing_ok=True)
-            except OSError as err:
-                # A kept stale note would re-emit an obsolete diagnostic on
-                # every cache hit; skip the stamp so -E re-derives the truth
-                _LOGGER.warning(
-                    "Could not remove %s (%s); the linker script will "
-                    "regenerate every build until it is removable; %s",
-                    stderr_note,
-                    err,
-                    _CLEAN_HINT,
-                )
-                note_persisted = False
-        try:
-            stdout_text = result.stdout.decode("utf-8")
-        except UnicodeDecodeError as err:
-            # -CC keeps header comments verbatim; a non-UTF-8 byte replaced
-            # with U+FFFD would be cached as valid for the build dir's life
-            raise EsphomeError(
-                f"Preprocessed linker script from {header} is not UTF-8: "
-                f"{err}; {_CLEAN_HINT}"
-            ) from err
-        if "SECTIONS" not in stdout_text:
-            # A degenerate zero-exit run must not be stamped as a good cache
-            raise EsphomeError(
-                f"Generated linker script is missing its SECTIONS block; {_CLEAN_HINT}"
-            )
-        content = _apply_surgery(build_surgery.relocate_ratetable, stdout_text)
-        if CORE.testing_mode:
-            content = _apply_surgery(
-                build_surgery.apply_testing_memory_patches, content, ("iram1_0_seg",)
-            )
-        write_file_if_changed(output, content)
-        if note_persisted:
-            # An unstamped cache re-runs -E next build, re-deriving the
-            # diagnostic the lost note would have re-emitted
-            _write_note(
-                stamp,
-                f"{stamp_content} note={_note_digest()} "
-                f"content={hashlib.sha256(content.encode('utf-8')).hexdigest()}",
-            )
-    elif stderr_note.is_file():
-        # Re-emit cached preprocessor warnings on cache hits
-        try:
-            _LOGGER.warning(
-                "Linker-script preprocessor: %s",
-                stderr_note.read_text(encoding="utf-8"),
-            )
-        except (OSError, UnicodeDecodeError) as err:
-            _LOGGER.warning(
-                "A cached linker-script preprocessor diagnostic exists at %s "
-                "but could not be read: %s",
-                stderr_note,
-                err,
-            )
-
-    if CORE.testing_mode:
-        _generate_testing_flash_ld(framework, ld_dir, flash_ld_name)
-
-
-def _generate_testing_flash_ld(
-    framework: Path, ld_dir: Path, flash_ld_name: str
-) -> None:
-    """A patched copy of the flash ld in the build dir; resolved through the
-    same -L path as the SDK original it shadows."""
-    flash_ld = _sdk_ld_dir(framework) / flash_ld_name
-    try:
-        flash_ld_text = flash_ld.read_text(encoding="utf-8")
-    except OSError as err:
-        # Same half-extracted-cache hazard as the preprocessor spawn
-        raise EsphomeError(f"Could not read {flash_ld}: {err}; {_CLEAN_HINT}") from err
-    patched_flash_ld = _apply_surgery(
-        build_surgery.apply_testing_memory_patches,
-        flash_ld_text,
-        ("dram0_0_seg", "irom0_0_seg"),
-    )
-    write_file_if_changed(
-        ld_dir / f"{_TESTING_LD_PREFIX}{flash_ld_name}", patched_flash_ld
-    )

esphome/components/anova/anova.cpp

@@ -13,7 +13,7 @@ void Anova::dump_config() { LOG_CLIMATE("", "Anova BLE Cooker", this); }
 
 void Anova::setup() {
   this->codec_ = make_unique<AnovaCodec>();
-  this->poll_step_ = PollStep::IDLE;
+  this->current_request_ = 0;
 }
 
 void Anova::loop() {
@@ -22,15 +22,6 @@ void Anova::loop() {
   this->disable_loop();
 }
 
-void Anova::write_request_(AnovaPacket *pkt) {
-  auto status =
-      esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
-                               pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-  if (status) {
-    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
-  }
-}
-
 void Anova::control(const ClimateCall &call) {
   auto mode_val = call.get_mode();
   if (mode_val.has_value()) {
@@ -47,11 +38,22 @@ void Anova::control(const ClimateCall &call) {
         ESP_LOGW(TAG, "Unsupported mode: %d", mode);
         return;
     }
-    this->write_request_(pkt);
+    auto status =
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
+    }
   }
   auto target_temp = call.get_target_temperature();
   if (target_temp.has_value()) {
-    this->write_request_(this->codec_->get_set_target_temp_request(*target_temp));
+    auto *pkt = this->codec_->get_set_target_temp_request(*target_temp);
+    auto status =
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
+    }
   }
 }
 
@@ -60,7 +62,6 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
     case ESP_GATTC_DISCONNECT_EVT: {
       this->current_temperature = NAN;
       this->target_temperature = NAN;
-      this->poll_step_ = PollStep::IDLE;
       this->publish_state();
       break;
     }
@@ -82,8 +83,8 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
     }
     case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
       this->node_state = espbt::ClientState::ESTABLISHED;
-      this->poll_step_ = PollStep::IDLE;
-      this->update();  // begin the first poll cycle immediately
+      this->current_request_ = 0;
+      this->update();
       break;
     }
     case ESP_GATTC_NOTIFY_EVT: {
@@ -100,30 +101,33 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
         this->mode = this->codec_->running_ ? climate::CLIMATE_MODE_HEAT : climate::CLIMATE_MODE_OFF;
       }
       if (this->codec_->has_unit()) {
-        ESP_LOGD(TAG, "Anova units is %s", (this->codec_->unit_ == 'f') ? "fahrenheit" : "celsius");
+        this->fahrenheit_ = (this->codec_->unit_ == 'f');
+        ESP_LOGD(TAG, "Anova units is %s", this->fahrenheit_ ? "fahrenheit" : "celsius");
+        this->current_request_++;
       }
       this->publish_state();
 
-      // Advance the poll cycle to its next request based on the reply we got.
-      switch (this->poll_step_) {
-        case PollStep::SET_UNIT:
-          this->poll_step_ = PollStep::STATUS;
-          this->write_request_(this->codec_->get_read_device_status_request());
-          break;
-        case PollStep::STATUS:
-          this->poll_step_ = PollStep::TARGET;
-          this->write_request_(this->codec_->get_read_target_temp_request());
-          break;
-        case PollStep::TARGET:
-          this->poll_step_ = PollStep::CURRENT;
-          this->write_request_(this->codec_->get_read_current_temp_request());
-          break;
-        case PollStep::CURRENT:
-          this->poll_step_ = PollStep::IDLE;  // full cycle complete
-          break;
-        default:
-          // A reply to an ad-hoc control() write, outside a managed cycle.
-          break;
+      if (this->current_request_ > 1) {
+        AnovaPacket *pkt = nullptr;
+        switch (this->current_request_++) {
+          case 2:
+            pkt = this->codec_->get_read_target_temp_request();
+            break;
+          case 3:
+            pkt = this->codec_->get_read_current_temp_request();
+            break;
+          default:
+            this->current_request_ = 1;
+            break;
+        }
+        if (pkt != nullptr) {
+          auto status =
+              esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                       pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+          if (status) {
+            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
+          }
+        }
       }
       break;
     }
@@ -132,26 +136,27 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
   }
 }
 
-void Anova::set_unit_of_measurement(const char *unit) { this->want_fahrenheit_ = !strncmp(unit, "f", 1); }
+void Anova::set_unit_of_measurement(const char *unit) { this->fahrenheit_ = !strncmp(unit, "f", 1); }
 
 void Anova::update() {
   if (this->node_state != espbt::ClientState::ESTABLISHED)
     return;
-  if (this->poll_step_ != PollStep::IDLE) {
-    // The previous cycle never finished within a full polling interval -- a
-    // reply was missed or a write failed. Restart the cycle rather than stall;
-    // the polling interval itself acts as the timeout. A late reply from the
-    // abandoned cycle is harmless: state decoding happens on every notify
-    // regardless of step, and each notify sends at most one follow-up request.
-    ESP_LOGW(TAG, "[%s] Poll cycle incomplete (step %u); restarting cycle", this->parent_->address_str(),
-             static_cast<uint8_t>(this->poll_step_));
+
+  if (this->current_request_ < 2) {
+    AnovaPacket *pkt;
+    if (this->current_request_ == 0) {
+      pkt = this->codec_->get_set_unit_request(this->fahrenheit_ ? 'f' : 'c');
+    } else {
+      pkt = this->codec_->get_read_device_status_request();
+    }
+    auto status =
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
+    }
+    this->current_request_++;
   }
-  // Re-assert the configured unit at the start of every poll cycle, then fall
-  // through the status/temperature reads via the notification handler. Always
-  // command the configured unit (want_fahrenheit_) -- never the last value the
-  // device reported, or a drift to 'c' would lock itself in.
-  this->poll_step_ = PollStep::SET_UNIT;
-  this->write_request_(this->codec_->get_set_unit_request(this->want_fahrenheit_ ? 'f' : 'c'));
 }
 
 }  // namespace esphome::anova

esphome/components/anova/anova.h

@@ -37,20 +37,11 @@ class Anova final : public climate::Climate, public esphome::ble_client::BLEClie
   void set_unit_of_measurement(const char *unit);
 
  protected:
-  // A poll cycle re-asserts the configured unit, then reads device state.
-  // Re-asserting every cycle prevents the cooker from silently reverting to
-  // its default (Celsius); previously the unit was only set once on
-  // connection, so a drift persisted (and corrupted the F/C interpretation of
-  // subsequent readings) until the BLE link was re-established.
-  enum class PollStep : uint8_t { SET_UNIT, STATUS, TARGET, CURRENT, IDLE };
-
-  void write_request_(AnovaPacket *pkt);
-
   std::unique_ptr<AnovaCodec> codec_;
   void control(const climate::ClimateCall &call) override;
   uint16_t char_handle_;
-  bool want_fahrenheit_{true};  // configured target unit; never overwritten by device replies
-  PollStep poll_step_{PollStep::IDLE};
+  uint8_t current_request_;
+  bool fahrenheit_;
 };
 
 }  // namespace esphome::anova

esphome/components/api/api_connection.cpp

@@ -2255,7 +2255,12 @@ bool APIConnection::send_message_(uint32_t payload_size, uint16_t message_type,
   // Capacity reserved above, cannot fail
   (void) shared_buf.resize(write_start + payload_size);
   ProtoWriteBuffer buffer{&shared_buf, write_start};
-  encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
+  uint8_t *end = encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
+#ifdef ESPHOME_DEBUG_API
+  assert(end == shared_buf.data() + shared_buf.size());
+#else
+  (void) end;
+#endif
   return this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type);
 }
 // encode_to_buffer is defined inline in api_connection.h (ESPHOME_ALWAYS_INLINE)

esphome/components/api/api_connection.h

@@ -345,11 +345,7 @@ class APIConnection final : public APIServerConnectionBase {
   /// Returns false as soon as the TCP buffer is full. Marked nodiscard so we
   /// have no silent failures: every caller must handle (or log) a refusal.
   template<typename T> [[nodiscard]] bool send_message(const T &msg) {
-    if constexpr (T::ESTIMATED_SIZE == 0) {
-      return this->send_message_(0, T::MESSAGE_TYPE, &encode_msg_noop, &msg);
-    } else {
-      return this->send_message_(msg.calculate_size(), T::MESSAGE_TYPE, &proto_encode_msg<T>, &msg);
-    }
+    return this->send_message_(T::calc_size_msg(&msg), T::MESSAGE_TYPE, &T::encode_msg, &msg);
   }
 
   /// Clear the shared write buffer and reserve space for the first message.
@@ -405,16 +401,6 @@ class APIConnection final : public APIServerConnectionBase {
   void process_state_subscriptions_();
 #endif
 
-  // Size thunk — converts void* back to concrete type for direct calculate_size() call
-  template<typename T> static uint32_t calc_size(const void *msg) {
-    return static_cast<const T *>(msg)->calculate_size();
-  }
-
-  // Shared no-op encode thunk for empty messages (ESTIMATED_SIZE == 0)
-  static uint8_t *encode_msg_noop(const void *, ProtoWriteBuffer &buf PROTO_ENCODE_DEBUG_PARAM) {
-    return buf.get_pos();
-  }
-
   // Non-template buffer management for send_message
   bool send_message_(uint32_t payload_size, uint16_t message_type, MessageEncodeFn encode_fn, const void *msg);
 
@@ -433,11 +419,7 @@ class APIConnection final : public APIServerConnectionBase {
   // Hot paths (state/info) go through fill_and_encode_entity_state/info instead.
   // batch_message_type_ is already set by dispatch_message_ before reaching here.
   template<typename T> static uint16_t encode_message_to_buffer(T &msg, APIConnection *conn, uint32_t remaining_size) {
-    if constexpr (T::ESTIMATED_SIZE == 0) {
-      return encode_to_buffer_slow(0, &encode_msg_noop, &msg, conn, remaining_size);
-    } else {
-      return encode_to_buffer_slow(msg.calculate_size(), &proto_encode_msg<T>, &msg, conn, remaining_size);
-    }
+    return encode_to_buffer_slow(T::calc_size_msg(&msg), &T::encode_msg, &msg, conn, remaining_size);
   }
 
   // Non-template core — fills state fields and encodes
@@ -449,7 +431,7 @@ class APIConnection final : public APIServerConnectionBase {
   template<typename T>
   static uint16_t fill_and_encode_entity_state(EntityBase *entity, T &msg, APIConnection *conn,
                                                uint32_t remaining_size) {
-    return fill_and_encode_entity_state(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
+    return fill_and_encode_entity_state(entity, msg, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
   }
 
   // Non-template core — fills info fields, allocates buffers, and encodes
@@ -461,7 +443,7 @@ class APIConnection final : public APIServerConnectionBase {
   template<typename T>
   static uint16_t fill_and_encode_entity_info(EntityBase *entity, T &msg, APIConnection *conn,
                                               uint32_t remaining_size) {
-    return fill_and_encode_entity_info(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
+    return fill_and_encode_entity_info(entity, msg, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
   }
 
   // Non-template core — fills device_class, then delegates to fill_and_encode_entity_info
@@ -475,8 +457,8 @@ class APIConnection final : public APIServerConnectionBase {
   static uint16_t fill_and_encode_entity_info_with_device_class(EntityBase *entity, T &msg,
                                                                 StringRef &device_class_field, APIConnection *conn,
                                                                 uint32_t remaining_size) {
-    return fill_and_encode_entity_info_with_device_class(entity, msg, device_class_field, &calc_size<T>,
-                                                         &proto_encode_msg<T>, conn, remaining_size);
+    return fill_and_encode_entity_info_with_device_class(entity, msg, device_class_field, &T::calc_size_msg,
+                                                         &T::encode_msg, conn, remaining_size);
   }
 
 #ifdef USE_VOICE_ASSISTANT

esphome/components/api/api_connection_buffer.h

@@ -46,7 +46,13 @@ inline uint16_t ESPHOME_ALWAYS_INLINE APIConnection::encode_to_buffer(uint32_t c
     return 0;
   }
   ProtoWriteBuffer buffer{&shared_buf, shared_buf.size() - calculated_size};
-  encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
+  uint8_t *end = encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
+#ifdef ESPHOME_DEBUG_API
+  // A body that writes fewer bytes than calculate_size() promised would ship stale buffer bytes
+  assert(end == shared_buf.data() + shared_buf.size());
+#else
+  (void) end;
+#endif
 
   return total_calculated_size;
 }

esphome/components/api/proto.h

@@ -287,19 +287,31 @@ class ProtoWriteBuffer {
   uint8_t *pos_;
 };
 
+// A four byte unaligned store is a memcpy call on ESP-IDF (-fno-builtin-memcpy) and on ARM cores without
+// unaligned access (Cortex-M0+, ARM9), so those targets share one outlined byte store helper per fixed32
+// field. Elsewhere the write inlines to a single store, or on ESP8266 to a few stores that measured
+// faster than a call, so it stays inline.
+#if defined(USE_ESP32) || (defined(__arm__) && !defined(__ARM_FEATURE_UNALIGNED))
+#define PROTO_OUTLINE_FOR_SIZE __attribute__((noinline))
+#define PROTO_FIXED32_BYTE_STORES true
+#else
+#define PROTO_OUTLINE_FOR_SIZE inline
+#define PROTO_FIXED32_BYTE_STORES false
+#endif
+
 // Varint encoding thresholds — used by both proto_encode_* free functions and ProtoSize.
 constexpr uint32_t VARINT_MAX_1_BYTE = 1 << 7;   // 128
 constexpr uint32_t VARINT_MAX_2_BYTE = 1 << 14;  // 16384
 
-/// Static encode helpers for generated encode() functions.
-/// Generated code hoists buffer.pos_ into a local uint8_t *__restrict__ pos,
-/// then calls these methods which take pos by reference. No struct, no overhead.
-/// For sub-messages, pos is synced back to buffer before the call and reloaded after.
+/// Static encode helpers for the generated encode bodies. Each takes the write cursor by value and
+/// returns it advanced, so outlined calls at -Os chain through the return register instead of a
+/// stack slot. Helpers without a _force suffix skip fields holding the proto3 default.
 class ProtoEncode {
  public:
   /// Write a multi-byte varint directly through a pos pointer.
   template<typename T>
-  static inline void encode_varint_raw_loop(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, T value) {
+  [[nodiscard]] static inline uint8_t *encode_varint_raw_loop(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                              T value) {
     do {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value | 0x80);
@@ -307,48 +319,49 @@ class ProtoEncode {
     } while (value > 0x7F);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = static_cast<uint8_t>(value);
+    return pos;
   }
-  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                             uint32_t value) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_varint_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t value) {
     if (value < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value);
-      return;
+      return pos;
     }
-    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
   /// Encode a varint that is expected to be 1-2 bytes (e.g. zigzag RSSI, small lengths).
-  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_short(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                   uint32_t value) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_varint_raw_short(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t value) {
     if (value < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value);
-      return;
+      return pos;
     }
     if (value < VARINT_MAX_2_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 2);
       *pos++ = static_cast<uint8_t>(value | 0x80);
       *pos++ = static_cast<uint8_t>(value >> 7);
-      return;
+      return pos;
     }
-    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
-  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                uint64_t value) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_varint_raw_64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint64_t value) {
     if (value < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value);
-      return;
+      return pos;
     }
-    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
   /// Encode a 48-bit MAC address (stored in a uint64) as varint.
   /// Real MAC addresses occupy the full 48 bits (OUI in upper 24), so the
   /// fast path -- any non-zero bit in the top 6 of 48 -- emits exactly 7 bytes
   /// with no per-byte branch. Falls back to the general loop otherwise.
   /// Caller must guarantee value fits in 48 bits (checked in debug builds).
-  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_48bit(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                   uint64_t value) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_varint_raw_48bit(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint64_t value) {
 #ifdef ESPHOME_DEBUG_API
     assert(value < (1ULL << (MAC_ADDRESS_SIZE * 8)) && "encode_varint_raw_48bit: value exceeds 48 bits");
 #endif
@@ -363,38 +376,39 @@ class ProtoEncode {
       pos[4] = static_cast<uint8_t>((value >> 28) | 0x80);
       pos[5] = static_cast<uint8_t>((value >> 35) | 0x80);
       pos[6] = static_cast<uint8_t>(value >> 42);
-      pos += 7;
-      return;
+      return pos + 7;
     }
-    encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+    return encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
-  static inline void ESPHOME_ALWAYS_INLINE encode_field_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                            uint32_t field_id, uint32_t type) {
-    encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, (field_id << 3) | type);
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_field_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, uint32_t type) {
+    return encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, (field_id << 3) | type);
   }
   /// Write a single precomputed tag byte. Tag must be < 128.
-  static inline void ESPHOME_ALWAYS_INLINE write_raw_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                          uint8_t b) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  write_raw_byte(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t b) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = b;
+    return pos;
   }
   /// Reserve one byte for later backpatch (e.g., sub-message length).
   /// Advances pos past the reserved byte without writing a value.
-  static inline void ESPHOME_ALWAYS_INLINE reserve_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  reserve_byte(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
-    pos++;
+    return pos + 1;
   }
   /// Write raw bytes to the buffer (no tag, no length prefix).
-  static inline void ESPHOME_ALWAYS_INLINE encode_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                      const void *data, size_t len) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, const void *data, size_t len) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, len);
     std::memcpy(pos, data, len);
-    pos += len;
+    return pos + len;
   }
   /// Encode tag + 1-byte length + raw string data. For strings with max_data_length < 128.
   /// Tag must be a single-byte varint (< 128). Always encodes (no zero check).
-  static inline void encode_short_string_force(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag,
-                                               const StringRef &ref) {
+  [[nodiscard]] static inline uint8_t *encode_short_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                 uint8_t tag, const StringRef &ref) {
 #ifdef ESPHOME_DEBUG_API
     assert(ref.size() < 128 && "encode_short_string_force: string exceeds max_data_length < 128");
 #endif
@@ -402,137 +416,191 @@ class ProtoEncode {
     pos[0] = tag;
     pos[1] = static_cast<uint8_t>(ref.size());
     std::memcpy(pos + 2, ref.c_str(), ref.size());
-    pos += 2 + ref.size();
+    return pos + 2 + ref.size();
   }
-  /// Write a precomputed tag byte + 32-bit value in one operation.
-  static inline void ESPHOME_ALWAYS_INLINE write_tag_and_fixed32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                 uint8_t tag, uint32_t value) {
+  /// Write a precomputed tag byte + 32-bit value. Outlined on embedded: one copy beats inline stores per field.
+  [[nodiscard]] static PROTO_OUTLINE_FOR_SIZE uint8_t *write_tag_and_fixed32(
+      uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag, uint32_t value) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 5);
     pos[0] = tag;
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    std::memcpy(pos + 1, &value, 4);
-#else
-    pos[1] = static_cast<uint8_t>(value & 0xFF);
-    pos[2] = static_cast<uint8_t>((value >> 8) & 0xFF);
-    pos[3] = static_cast<uint8_t>((value >> 16) & 0xFF);
-    pos[4] = static_cast<uint8_t>((value >> 24) & 0xFF);
-#endif
-    pos += 5;
+    write_fixed32_le(pos + 1, value);
+    return pos + 5;
   }
-  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   const char *string, size_t len, bool force = false) {
-    if (len == 0 && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 2);  // type 2: Length-delimited string
+  [[nodiscard]] static inline uint8_t *encode_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, const char *string, size_t len) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 2);  // type 2: Length-delimited string
     // NOLINTNEXTLINE(readability-inconsistent-ifelse-braces) -- false positive on [[likely]] attribute
     if (len < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1 + len);
       *pos++ = static_cast<uint8_t>(len);
     } else {
-      encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
+      pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
       PROTO_ENCODE_CHECK_BOUNDS(pos, len);
     }
     std::memcpy(pos, string, len);
-    pos += len;
+    return pos + len;
   }
-  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   const std::string &value, bool force = false) {
-    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, value.data(), value.size(), force);
+  [[nodiscard]] static inline uint8_t *encode_string(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, const char *string, size_t len) {
+    if (len == 0)
+      return pos;
+    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, string, len);
   }
-  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   const StringRef &ref, bool force = false) {
-    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size(), force);
+  [[nodiscard]] static inline uint8_t *encode_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, const std::string &value) {
+    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value.data(), value.size());
   }
-  static inline void encode_bytes(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                  const uint8_t *data, size_t len, bool force = false) {
-    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len, force);
+  [[nodiscard]] static inline uint8_t *encode_string(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, const StringRef &ref) {
+    return encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size());
   }
-  static inline void encode_uint32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   uint32_t value, bool force = false) {
-    if (value == 0 && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
-    encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, value);
+  [[nodiscard]] static inline uint8_t *encode_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, const StringRef &ref) {
+    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size());
   }
-  static inline void encode_uint64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   uint64_t value, bool force = false) {
-    if (value == 0 && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
-    encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+  [[nodiscard]] static inline uint8_t *encode_bytes(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                    uint32_t field_id, const uint8_t *data, size_t len) {
+    return encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len);
   }
-  static inline void encode_bool(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, bool value,
-                                 bool force = false) {
-    if (!value && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+  [[nodiscard]] static inline uint8_t *encode_bytes_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint32_t field_id, const uint8_t *data, size_t len) {
+    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len);
+  }
+  [[nodiscard]] static inline uint8_t *encode_uint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, uint32_t value) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+    return encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, value);
+  }
+  [[nodiscard]] static inline uint8_t *encode_uint32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, uint32_t value) {
+    if (value == 0)
+      return pos;
+    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
+  }
+  [[nodiscard]] static inline uint8_t *encode_uint64_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, uint64_t value) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+    return encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+  }
+  [[nodiscard]] static inline uint8_t *encode_uint64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, uint64_t value) {
+    if (value == 0)
+      return pos;
+    return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
+  }
+  [[nodiscard]] static inline uint8_t *encode_bool_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                         uint32_t field_id, bool value) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = value ? 0x01 : 0x00;
+    return pos;
   }
-  static inline void encode_fixed32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                    uint32_t value, bool force = false) {
-    if (value == 0 && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 5);
+  [[nodiscard]] static inline uint8_t *encode_bool(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                   uint32_t field_id, bool value) {
+    if (!value)
+      return pos;
+    return encode_bool_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
+  }
+  /// Tag + fixed32 for multi-byte tags; single-byte tags use write_tag_and_fixed32.
+  [[nodiscard]] static PROTO_OUTLINE_FOR_SIZE uint8_t *encode_fixed32_force(
+      uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, uint32_t value) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 5);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 4);
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    std::memcpy(pos, &value, 4);
-    pos += 4;
-#else
-    *pos++ = (value >> 0) & 0xFF;
-    *pos++ = (value >> 8) & 0xFF;
-    *pos++ = (value >> 16) & 0xFF;
-    *pos++ = (value >> 24) & 0xFF;
-#endif
+    write_fixed32_le(pos, value);
+    return pos + 4;
+  }
+  [[nodiscard]] static inline uint8_t *encode_fixed32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                      uint32_t field_id, uint32_t value) {
+    if (value == 0)
+      return pos;
+    return encode_fixed32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
   }
   // NOTE: Wire type 1 (64-bit fixed: double, fixed64, sfixed64) is intentionally
   // not supported to reduce overhead on embedded systems. All ESPHome devices are
   // 32-bit microcontrollers where 64-bit operations are expensive. If 64-bit support
   // is needed in the future, the necessary encoding/decoding functions must be added.
-  static inline void encode_float(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, float value,
-                                  bool force = false) {
-    uint32_t raw = float_to_raw(value);
-    if (raw == 0 && !force)
-      return;
-    encode_fixed32(pos PROTO_ENCODE_DEBUG_ARG, field_id, raw);
+  [[nodiscard]] static inline uint8_t *encode_float(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                    uint32_t field_id, float value) {
+    return encode_fixed32(pos PROTO_ENCODE_DEBUG_ARG, field_id, float_to_raw(value));
   }
-  static inline void encode_int32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, int32_t value,
-                                  bool force = false) {
+  [[nodiscard]] static inline uint8_t *encode_float_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint32_t field_id, float value) {
+    return encode_fixed32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, float_to_raw(value));
+  }
+  [[nodiscard]] static inline uint8_t *encode_int32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint32_t field_id, int32_t value) {
     if (value < 0) {
       // negative int32 is always 10 byte long
-      encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value), force);
-      return;
+      return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
     }
-    encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint32_t>(value), force);
+    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint32_t>(value));
   }
-  static inline void encode_int64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, int64_t value,
-                                  bool force = false) {
-    encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value), force);
+  [[nodiscard]] static inline uint8_t *encode_int32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                    uint32_t field_id, int32_t value) {
+    if (value == 0)
+      return pos;
+    return encode_int32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
   }
-  static inline void encode_sint32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   int32_t value, bool force = false) {
-    encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value), force);
+  [[nodiscard]] static inline uint8_t *encode_int64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                    uint32_t field_id, int64_t value) {
+    return encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
   }
-  static inline void encode_sint64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   int64_t value, bool force = false) {
-    encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value), force);
+  [[nodiscard]] static inline uint8_t *encode_int64_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint32_t field_id, int64_t value) {
+    return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
   }
-  /// Sub-message encoding: sync pos to buffer, delegate, get pos from return value.
+  [[nodiscard]] static inline uint8_t *encode_sint32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, int32_t value) {
+    return encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value));
+  }
+  [[nodiscard]] static inline uint8_t *encode_sint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, int32_t value) {
+    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value));
+  }
+  [[nodiscard]] static inline uint8_t *encode_sint64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, int64_t value) {
+    return encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value));
+  }
+  [[nodiscard]] static inline uint8_t *encode_sint64_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, int64_t value) {
+    return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value));
+  }
+  /// Sub-message encoding: sync pos to buffer, delegate, read the cursor back.
   template<typename T>
-  static inline void encode_sub_message(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, ProtoWriteBuffer &buffer,
-                                        uint32_t field_id, const T &value) {
+  [[nodiscard]] static inline uint8_t *encode_sub_message(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          ProtoWriteBuffer &buffer, uint32_t field_id, const T &value) {
     buffer.set_pos(pos);
     buffer.encode_sub_message(field_id, value);
-    pos = buffer.get_pos();
+    return buffer.get_pos();
   }
   template<typename T>
-  static inline void encode_optional_sub_message(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                 ProtoWriteBuffer &buffer, uint32_t field_id, const T &value) {
+  [[nodiscard]] static inline uint8_t *encode_optional_sub_message(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                   ProtoWriteBuffer &buffer, uint32_t field_id,
+                                                                   const T &value) {
     buffer.set_pos(pos);
     buffer.encode_optional_sub_message(field_id, value);
-    pos = buffer.get_pos();
+    return buffer.get_pos();
+  }
+
+ private:
+  /// Unaligned little endian store of four bytes: byte stores where the outlined helper lives (ESP-IDF, ARM
+  /// without unaligned access), otherwise a memcpy the compiler folds into one store. Callers bounds check
+  /// and advance the cursor themselves.
+  static inline void ESPHOME_ALWAYS_INLINE write_fixed32_le(uint8_t *__restrict__ pos, uint32_t value) {
+    if constexpr (PROTO_FIXED32_BYTE_STORES) {
+      // Spelled out so the outlined helper does not itself become a memcpy call
+      pos[0] = static_cast<uint8_t>(value);
+      pos[1] = static_cast<uint8_t>(value >> 8);
+      pos[2] = static_cast<uint8_t>(value >> 16);
+      pos[3] = static_cast<uint8_t>(value >> 24);
+    } else {
+      const uint32_t le = convert_little_endian(value);
+      __builtin_memcpy(pos, &le, 4);
+    }
   }
 };
+#undef PROTO_OUTLINE_FOR_SIZE
+#undef PROTO_FIXED32_BYTE_STORES
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
 /**
@@ -624,11 +692,12 @@ class DumpBuffer {
 
 class ProtoMessage {
  public:
-  // Non-virtual defaults for messages with no fields.
-  // Concrete message classes hide these with their own implementations.
-  // All call sites use templates to preserve the concrete type, so virtual
-  // dispatch is not needed. This eliminates per-message vtable entries for
-  // encode/calculate_size, saving ~1.3 KB of flash across all message types.
+  // Non-virtual defaults for messages with no fields; generated classes hide all four. The
+  // static encode_msg/calc_size_msg take const void * so &T::encode_msg needs no thunk.
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+    return buffer.get_pos();
+  }
+  static uint32_t calc_size_msg(const void *self) { return 0; }
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const { return buffer.get_pos(); }
   uint32_t calculate_size() const { return 0; }
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -876,19 +945,14 @@ class ProtoSize {
 
 // Implementation of methods that depend on ProtoSize being fully defined
 
-// Encode thunk — converts void* back to concrete type for direct encode() call
-template<typename T> uint8_t *proto_encode_msg(const void *msg, ProtoWriteBuffer &buf PROTO_ENCODE_DEBUG_PARAM) {
-  return static_cast<const T *>(msg)->encode(buf PROTO_ENCODE_DEBUG_ARG);
-}
-
 // Thin template wrapper; delegates to non-template core in proto.cpp.
 template<typename T> inline void ProtoWriteBuffer::encode_sub_message(uint32_t field_id, const T &value) {
-  this->encode_sub_message(field_id, &value, &proto_encode_msg<T>);
+  this->encode_sub_message(field_id, &value, &T::encode_msg);
 }
 
 // Thin template wrapper; delegates to non-template core.
 template<typename T> inline void ProtoWriteBuffer::encode_optional_sub_message(uint32_t field_id, const T &value) {
-  this->encode_optional_sub_message(field_id, value.calculate_size(), &value, &proto_encode_msg<T>);
+  this->encode_optional_sub_message(field_id, T::calc_size_msg(&value), &value, &T::encode_msg);
 }
 
 // Template decode_to_message - preserves concrete type so decode() resolves statically

esphome/components/atm90e32/atm90e32.cpp

@@ -9,10 +9,6 @@ namespace esphome::atm90e32 {
 
 static const char *const TAG = "atm90e32";
 
-static const LogString *offset_calibration_name(bool power_offsets) {
-  return power_offsets ? LOG_STR("Power offset") : LOG_STR("Offset");
-}
-
 static uint32_t pref_hash(const char *prefix, const char *name_space) {
   auto hash = fnv1_hash(prefix);
   return fnv1_hash_extend(hash, name_space);
@@ -207,12 +203,13 @@ void ATM90E32Component::setup() {
 
     // Initialize flash storage for power offset calibrations
     uint32_t po_hash = pref_hash("_power_offset_calibration_", cs);
-    this->power_offset_pref_ = global_preferences->make_preference<OffsetCalibration[3]>(po_hash, true);
+    this->power_offset_pref_ = global_preferences->make_preference<PowerOffsetCalibration[3]>(po_hash, true);
     bool migrated_power_offset = false;
     if (has_distinct_legacy_namespace) {
       uint32_t legacy_po_hash = pref_hash("_power_offset_calibration_", legacy_cs);
-      auto legacy_power_offset_pref = global_preferences->make_preference<OffsetCalibration[3]>(legacy_po_hash, true);
-      OffsetCalibration power_offset_data[3]{};
+      auto legacy_power_offset_pref =
+          global_preferences->make_preference<PowerOffsetCalibration[3]>(legacy_po_hash, true);
+      PowerOffsetCalibration power_offset_data[3]{};
       int migration_status =
           migrate_legacy_pref_if_needed(this->power_offset_pref_, legacy_power_offset_pref, &power_offset_data);
       migrated_power_offset = migration_status > 0;
@@ -227,20 +224,20 @@ void ATM90E32Component::setup() {
       global_preferences->sync();
     }
 
-    this->restore_offset_calibrations_(OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
-    this->restore_offset_calibrations_(OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
+    this->restore_offset_calibrations_();
+    this->restore_power_offset_calibrations_();
   } else {
     ESP_LOGI(TAG, "[CALIBRATION][%s] Power & Voltage/Current offset calibration is disabled. Using config file values.",
              cs);
     for (uint8_t phase = 0; phase < 3; ++phase) {
       this->write16_(this->voltage_offset_registers[phase],
-                     static_cast<uint16_t>(this->offset_phase_[phase].first_offset));
+                     static_cast<uint16_t>(this->offset_phase_[phase].voltage_offset_));
       this->write16_(this->current_offset_registers[phase],
-                     static_cast<uint16_t>(this->offset_phase_[phase].second_offset));
+                     static_cast<uint16_t>(this->offset_phase_[phase].current_offset_));
       this->write16_(this->power_offset_registers[phase],
-                     static_cast<uint16_t>(this->power_offset_phase_[phase].first_offset));
+                     static_cast<uint16_t>(this->power_offset_phase_[phase].active_power_offset));
       this->write16_(this->reactive_power_offset_registers[phase],
-                     static_cast<uint16_t>(this->power_offset_phase_[phase].second_offset));
+                     static_cast<uint16_t>(this->power_offset_phase_[phase].reactive_power_offset));
     }
   }
 
@@ -320,8 +317,8 @@ void ATM90E32Component::log_calibration_status_() {
              cs);
     for (uint8_t phase = 0; phase < 3; ++phase) {
       ESP_LOGW(TAG, "[CALIBRATION][%s] |   %c   |  %6d  | %6d  |  %6d  | %6d  |", cs, 'A' + phase,
-               this->config_offset_phase_[phase].first_offset, this->offset_phase_[phase].first_offset,
-               this->config_offset_phase_[phase].second_offset, this->offset_phase_[phase].second_offset);
+               this->config_offset_phase_[phase].voltage_offset_, this->offset_phase_[phase].voltage_offset_,
+               this->config_offset_phase_[phase].current_offset_, this->offset_phase_[phase].current_offset_);
     }
     ESP_LOGW(TAG,
              "[CALIBRATION][%s] ===============================================================================", cs);
@@ -338,8 +335,10 @@ void ATM90E32Component::log_calibration_status_() {
              cs);
     for (uint8_t phase = 0; phase < 3; ++phase) {
       ESP_LOGW(TAG, "[CALIBRATION][%s] |   %c   |  %6d  | %6d  |  %6d  | %6d  |", cs, 'A' + phase,
-               this->config_power_offset_phase_[phase].first_offset, this->power_offset_phase_[phase].first_offset,
-               this->config_power_offset_phase_[phase].second_offset, this->power_offset_phase_[phase].second_offset);
+               this->config_power_offset_phase_[phase].active_power_offset,
+               this->power_offset_phase_[phase].active_power_offset,
+               this->config_power_offset_phase_[phase].reactive_power_offset,
+               this->power_offset_phase_[phase].reactive_power_offset);
     }
     ESP_LOGW(TAG,
              "[CALIBRATION][%s] ===============================================================================", cs);
@@ -373,7 +372,7 @@ void ATM90E32Component::log_calibration_status_() {
     ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase,
-               this->offset_phase_[phase].first_offset, this->offset_phase_[phase].second_offset);
+               this->offset_phase_[phase].voltage_offset_, this->offset_phase_[phase].current_offset_);
     }
     ESP_LOGI(TAG, "[CALIBRATION][%s] ==============================================================\\n", cs);
   }
@@ -386,7 +385,8 @@ void ATM90E32Component::log_calibration_status_() {
     ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase,
-               this->power_offset_phase_[phase].first_offset, this->power_offset_phase_[phase].second_offset);
+               this->power_offset_phase_[phase].active_power_offset,
+               this->power_offset_phase_[phase].reactive_power_offset);
     }
     ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
   }
@@ -756,68 +756,36 @@ void ATM90E32Component::save_gain_calibration_to_memory_() {
   }
 }
 
-void ATM90E32Component::finish_offset_calibration_(const OffsetCalibration (&previous)[3], bool previous_restored,
-                                                   bool previous_using_saved, OffsetCalibrationType type) {
-  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
+void ATM90E32Component::save_offset_calibration_to_memory_() {
   const char *cs = this->get_calibration_id_();
-  const LogString *name = offset_calibration_name(power_offsets);
-  OffsetCalibration(*offsets)[3] = power_offsets ? &this->power_offset_phase_ : &this->offset_phase_;
-  ESPPreferenceObject *preference = power_offsets ? &this->power_offset_pref_ : &this->offset_pref_;
-  bool *has_stored =
-      power_offsets ? &this->has_stored_power_offset_calibration_ : &this->has_stored_offset_calibration_;
-  bool *restored = power_offsets ? &this->restored_power_offset_calibration_ : &this->restored_offset_calibration_;
-  bool *mismatches = power_offsets ? this->power_offset_calibration_mismatch_ : this->offset_calibration_mismatch_;
-
-  const bool writes_verified = this->verify_offset_writes_(type);
-  bool saved = false;
-  bool synced = false;
-  if (writes_verified) {
-    saved = preference->save(offsets);
-    synced = global_preferences->sync();
-  }
-
-  if (writes_verified && saved && synced) {
+  bool success = this->offset_pref_.save(&this->offset_phase_);
+  global_preferences->sync();
+  if (success) {
     this->using_saved_calibrations_ = true;
-    *has_stored = true;
-    *restored = true;
-    for (uint8_t phase = 0; phase < 3; phase++)
-      mismatches[phase] = false;
-    ESP_LOGI(TAG, "[CALIBRATION][%s] %s calibration saved to memory. %s calibration completed and verified.", cs,
-             LOG_STR_ARG(name), LOG_STR_ARG(name));
-    return;
+    this->restored_offset_calibration_ = true;
+    for (bool &phase : this->offset_calibration_mismatch_)
+      phase = false;
+    ESP_LOGI(TAG, "[CALIBRATION][%s] Offset calibration saved to memory.", cs);
+  } else {
+    this->using_saved_calibrations_ = false;
+    ESP_LOGE(TAG, "[CALIBRATION][%s] Failed to save offset calibration to memory!", cs);
   }
+}
 
-  if (writes_verified) {
-    ESP_LOGE(TAG, "[CALIBRATION][%s] Failed to save %s calibration to memory!", cs, LOG_STR_ARG(name));
+void ATM90E32Component::save_power_offset_calibration_to_memory_() {
+  const char *cs = this->get_calibration_id_();
+  bool success = this->power_offset_pref_.save(&this->power_offset_phase_);
+  global_preferences->sync();
+  if (success) {
+    this->using_saved_calibrations_ = true;
+    this->restored_power_offset_calibration_ = true;
+    for (bool &phase : this->power_offset_calibration_mismatch_)
+      phase = false;
+    ESP_LOGI(TAG, "[CALIBRATION][%s] Power offset calibration saved to memory.", cs);
+  } else {
+    this->using_saved_calibrations_ = false;
+    ESP_LOGE(TAG, "[CALIBRATION][%s] Failed to save power offset calibration to memory!", cs);
   }
-
-  for (uint8_t phase = 0; phase < 3; phase++) {
-    this->write_offsets_to_registers_(phase, previous[phase].first_offset, previous[phase].second_offset, type);
-  }
-  const bool rollback_verified = this->verify_offset_writes_(type);
-
-  bool rollback_persisted = false;
-  if (writes_verified) {
-    OffsetCalibration rollback[3]{};
-    prepare_offset_rollback(previous, previous_restored, rollback);
-    const bool rollback_saved = preference->save(&rollback);
-    const bool rollback_synced = global_preferences->sync();
-    rollback_persisted = rollback_saved && rollback_synced;
-    if (!rollback_saved || !rollback_synced) {
-      ESP_LOGE(TAG, "[CALIBRATION][%s] Failed to persist restored %s calibration values!", cs, LOG_STR_ARG(name));
-    }
-  }
-
-  *restored = previous_restored;
-  if (rollback_persisted)
-    *has_stored = previous_restored;
-  this->using_saved_calibrations_ = previous_using_saved;
-  if (!rollback_verified) {
-    ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration failed; rollback readback verification failed.", cs,
-             LOG_STR_ARG(name));
-    return;
-  }
-  ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration failed; previous values restored.", cs, LOG_STR_ARG(name));
 }
 
 void ATM90E32Component::run_offset_calibrations() {
@@ -835,16 +803,11 @@ void ATM90E32Component::run_offset_calibrations() {
   ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |", cs);
   ESP_LOGI(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------", cs);
 
-  OffsetCalibration previous_offsets[3] = {this->offset_phase_[0], this->offset_phase_[1], this->offset_phase_[2]};
-  const bool previous_restored = this->restored_offset_calibration_;
-  const bool previous_using_saved = this->using_saved_calibrations_;
-
   for (uint8_t phase = 0; phase < 3; phase++) {
     int16_t voltage_offset = calibrate_offset(phase, true);
     int16_t current_offset = calibrate_offset(phase, false);
 
-    this->write_offsets_to_registers_(phase, voltage_offset, current_offset,
-                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
+    this->write_offsets_to_registers_(phase, voltage_offset, current_offset);
 
     ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase, voltage_offset,
              current_offset);
@@ -852,8 +815,7 @@ void ATM90E32Component::run_offset_calibrations() {
 
   ESP_LOGI(TAG, "[CALIBRATION][%s] ==================================================================\n", cs);
 
-  this->finish_offset_calibration_(previous_offsets, previous_restored, previous_using_saved,
-                                   OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
+  this->save_offset_calibration_to_memory_();
 }
 
 void ATM90E32Component::run_power_offset_calibrations() {
@@ -872,25 +834,18 @@ void ATM90E32Component::run_power_offset_calibrations() {
   ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |", cs);
   ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
 
-  OffsetCalibration previous_offsets[3] = {this->power_offset_phase_[0], this->power_offset_phase_[1],
-                                           this->power_offset_phase_[2]};
-  const bool previous_restored = this->restored_power_offset_calibration_;
-  const bool previous_using_saved = this->using_saved_calibrations_;
-
   for (uint8_t phase = 0; phase < 3; ++phase) {
     int16_t active_offset = calibrate_power_offset(phase, false);
     int16_t reactive_offset = calibrate_power_offset(phase, true);
 
-    this->write_offsets_to_registers_(phase, active_offset, reactive_offset,
-                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
+    this->write_power_offsets_to_registers_(phase, active_offset, reactive_offset);
 
     ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase, active_offset,
              reactive_offset);
   }
   ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
 
-  this->finish_offset_calibration_(previous_offsets, previous_restored, previous_using_saved,
-                                   OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
+  this->save_power_offset_calibration_to_memory_();
 }
 
 void ATM90E32Component::write_gains_to_registers_() {
@@ -904,26 +859,35 @@ void ATM90E32Component::write_gains_to_registers_() {
   this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x0000);
 }
 
-void ATM90E32Component::write_offsets_to_registers_(uint8_t phase, int16_t first_offset, int16_t second_offset,
-                                                    OffsetCalibrationType type) {
-  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
-  OffsetCalibration &offsets = power_offsets ? this->power_offset_phase_[phase] : this->offset_phase_[phase];
-  offsets.first_offset = first_offset;
-  offsets.second_offset = second_offset;
-  if (power_offsets) {
-    this->phase_[phase].active_power_offset_ = first_offset;
-    this->phase_[phase].reactive_power_offset_ = second_offset;
-  } else {
-    this->phase_[phase].voltage_offset_ = first_offset;
-    this->phase_[phase].current_offset_ = second_offset;
-  }
+void ATM90E32Component::write_offsets_to_registers_(uint8_t phase, int16_t voltage_offset, int16_t current_offset) {
+  // Save to runtime
+  this->offset_phase_[phase].voltage_offset_ = voltage_offset;
+  this->phase_[phase].voltage_offset_ = voltage_offset;
 
-  const uint16_t *first_registers = power_offsets ? this->power_offset_registers : this->voltage_offset_registers;
-  const uint16_t *second_registers =
-      power_offsets ? this->reactive_power_offset_registers : this->current_offset_registers;
+  // Save to flash-storable struct
+  this->offset_phase_[phase].current_offset_ = current_offset;
+  this->phase_[phase].current_offset_ = current_offset;
+
+  // Write to registers
   this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x55AA);
-  this->write16_(first_registers[phase], static_cast<uint16_t>(first_offset));
-  this->write16_(second_registers[phase], static_cast<uint16_t>(second_offset));
+  this->write16_(voltage_offset_registers[phase], static_cast<uint16_t>(voltage_offset));
+  this->write16_(current_offset_registers[phase], static_cast<uint16_t>(current_offset));
+  this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x0000);
+}
+
+void ATM90E32Component::write_power_offsets_to_registers_(uint8_t phase, int16_t p_offset, int16_t q_offset) {
+  // Save to runtime
+  this->phase_[phase].active_power_offset_ = p_offset;
+  this->phase_[phase].reactive_power_offset_ = q_offset;
+
+  // Save to flash-storable struct
+  this->power_offset_phase_[phase].active_power_offset = p_offset;
+  this->power_offset_phase_[phase].reactive_power_offset = q_offset;
+
+  // Write to registers
+  this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x55AA);
+  this->write16_(this->power_offset_registers[phase], static_cast<uint16_t>(p_offset));
+  this->write16_(this->reactive_power_offset_registers[phase], static_cast<uint16_t>(q_offset));
   this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x0000);
 }
 
@@ -983,78 +947,89 @@ void ATM90E32Component::restore_gain_calibrations_() {
   ESP_LOGW(TAG, "[CALIBRATION][%s] No stored gain calibrations found. Using config file values.", cs);
 }
 
-void ATM90E32Component::restore_offset_calibrations_(OffsetCalibrationType type) {
-  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
+void ATM90E32Component::restore_offset_calibrations_() {
   const char *cs = this->get_calibration_id_();
-  const LogString *name = power_offsets ? LOG_STR("power offset") : LOG_STR("offset");
-  OffsetCalibration(*offsets)[3] = power_offsets ? &this->power_offset_phase_ : &this->offset_phase_;
-  OffsetCalibration(*config_offsets)[3] =
-      power_offsets ? &this->config_power_offset_phase_ : &this->config_offset_phase_;
-  ESPPreferenceObject *preference = power_offsets ? &this->power_offset_pref_ : &this->offset_pref_;
-  bool *has_stored =
-      power_offsets ? &this->has_stored_power_offset_calibration_ : &this->has_stored_offset_calibration_;
-  bool *restored = power_offsets ? &this->restored_power_offset_calibration_ : &this->restored_offset_calibration_;
-  bool *mismatches = power_offsets ? this->power_offset_calibration_mismatch_ : this->offset_calibration_mismatch_;
-  const bool *has_first = power_offsets ? this->has_config_active_power_offset_ : this->has_config_voltage_offset_;
-  const bool *has_second = power_offsets ? this->has_config_reactive_power_offset_ : this->has_config_current_offset_;
-
   for (uint8_t i = 0; i < 3; ++i)
-    (*config_offsets)[i] = (*offsets)[i];
+    this->config_offset_phase_[i] = this->offset_phase_[i];
+
+  bool have_data = this->offset_pref_.load(&this->offset_phase_);
 
-  const bool have_data = preference->load(offsets);
   bool all_zero = true;
   if (have_data) {
-    for (const auto &phase : *offsets) {
-      if (phase.first_offset != 0 || phase.second_offset != 0) {
+    for (auto &phase : this->offset_phase_) {
+      if (phase.voltage_offset_ != 0 || phase.current_offset_ != 0) {
         all_zero = false;
         break;
       }
     }
   }
 
-  *has_stored = have_data && !all_zero;
-  *restored = false;
+  if (have_data && !all_zero) {
+    this->restored_offset_calibration_ = true;
+    for (uint8_t phase = 0; phase < 3; phase++) {
+      auto &offset = this->offset_phase_[phase];
+      bool mismatch = false;
+      if (this->has_config_voltage_offset_[phase] &&
+          offset.voltage_offset_ != this->config_offset_phase_[phase].voltage_offset_)
+        mismatch = true;
+      if (this->has_config_current_offset_[phase] &&
+          offset.current_offset_ != this->config_offset_phase_[phase].current_offset_)
+        mismatch = true;
+      if (mismatch)
+        this->offset_calibration_mismatch_[phase] = true;
+    }
+  } else {
+    for (uint8_t phase = 0; phase < 3; phase++)
+      this->offset_phase_[phase] = this->config_offset_phase_[phase];
+    ESP_LOGW(TAG, "[CALIBRATION][%s] No stored offset calibrations found. Using default values.", cs);
+  }
+
   for (uint8_t phase = 0; phase < 3; phase++) {
-    mismatches[phase] = false;
-    if (*has_stored) {
-      mismatches[phase] =
-          (has_first[phase] && (*offsets)[phase].first_offset != (*config_offsets)[phase].first_offset) ||
-          (has_second[phase] && (*offsets)[phase].second_offset != (*config_offsets)[phase].second_offset);
+    write_offsets_to_registers_(phase, this->offset_phase_[phase].voltage_offset_,
+                                this->offset_phase_[phase].current_offset_);
+  }
+}
+
+void ATM90E32Component::restore_power_offset_calibrations_() {
+  const char *cs = this->get_calibration_id_();
+  for (uint8_t i = 0; i < 3; ++i)
+    this->config_power_offset_phase_[i] = this->power_offset_phase_[i];
+
+  bool have_data = this->power_offset_pref_.load(&this->power_offset_phase_);
+
+  bool all_zero = true;
+  if (have_data) {
+    for (auto &phase : this->power_offset_phase_) {
+      if (phase.active_power_offset != 0 || phase.reactive_power_offset != 0) {
+        all_zero = false;
+        break;
+      }
     }
   }
 
-  if (!*has_stored) {
-    for (uint8_t phase = 0; phase < 3; phase++)
-      (*offsets)[phase] = (*config_offsets)[phase];
-    ESP_LOGW(TAG, "[CALIBRATION][%s] No stored %s calibrations found. Using default values.", cs, LOG_STR_ARG(name));
-  }
-
-  for (uint8_t phase = 0; phase < 3; phase++) {
-    this->write_offsets_to_registers_(phase, (*offsets)[phase].first_offset, (*offsets)[phase].second_offset, type);
-  }
-  const bool initial_values_verified = this->verify_offset_writes_(type);
-  if (initial_values_verified) {
-    const auto state = resolve_offset_restore_state(*has_stored, true, false);
-    *restored = state.restored;
-    ESP_LOGI(TAG, "[CALIBRATION][%s] %s calibration values verified.", cs, LOG_STR_ARG(name));
-    return;
-  }
-
-  this->using_saved_calibrations_ = false;
-  for (uint8_t phase = 0; phase < 3; phase++)
-    mismatches[phase] = false;
-  for (uint8_t phase = 0; phase < 3; phase++) {
-    (*offsets)[phase] = (*config_offsets)[phase];
-    this->write_offsets_to_registers_(phase, (*offsets)[phase].first_offset, (*offsets)[phase].second_offset, type);
-  }
-  const auto state = resolve_offset_restore_state(*has_stored, false, this->verify_offset_writes_(type));
-  *restored = state.restored;
-  if (state.values_verified) {
-    ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration restore failed verification; config values verified.", cs,
-             LOG_STR_ARG(name));
+  if (have_data && !all_zero) {
+    this->restored_power_offset_calibration_ = true;
+    for (uint8_t phase = 0; phase < 3; ++phase) {
+      auto &offset = this->power_offset_phase_[phase];
+      bool mismatch = false;
+      if (this->has_config_active_power_offset_[phase] &&
+          offset.active_power_offset != this->config_power_offset_phase_[phase].active_power_offset)
+        mismatch = true;
+      if (this->has_config_reactive_power_offset_[phase] &&
+          offset.reactive_power_offset != this->config_power_offset_phase_[phase].reactive_power_offset)
+        mismatch = true;
+      if (mismatch)
+        this->power_offset_calibration_mismatch_[phase] = true;
+    }
   } else {
-    ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration restore and config fallback both failed verification.", cs,
-             LOG_STR_ARG(name));
+    for (uint8_t phase = 0; phase < 3; ++phase)
+      this->power_offset_phase_[phase] = this->config_power_offset_phase_[phase];
+    ESP_LOGW(TAG, "[CALIBRATION][%s] No stored power offsets found. Using default values.", cs);
+  }
+
+  for (uint8_t phase = 0; phase < 3; ++phase) {
+    write_power_offsets_to_registers_(phase, this->power_offset_phase_[phase].active_power_offset,
+                                      this->power_offset_phase_[phase].reactive_power_offset);
   }
 }
 
@@ -1109,14 +1084,14 @@ void ATM90E32Component::clear_gain_calibrations() {
 
 void ATM90E32Component::clear_offset_calibrations() {
   const char *cs = this->get_calibration_id_();
-  if (!this->has_stored_offset_calibration_) {
+  if (!this->restored_offset_calibration_) {
     ESP_LOGI(TAG, "[CALIBRATION][%s] No stored offset calibrations to clear. Current values:", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase,
-               this->offset_phase_[phase].first_offset, this->offset_phase_[phase].second_offset);
+               this->offset_phase_[phase].voltage_offset_, this->offset_phase_[phase].current_offset_);
     }
     ESP_LOGI(TAG, "[CALIBRATION][%s] ==============================================================\n", cs);
     return;
@@ -1129,11 +1104,10 @@ void ATM90E32Component::clear_offset_calibrations() {
 
   for (uint8_t phase = 0; phase < 3; phase++) {
     int16_t voltage_offset =
-        this->has_config_voltage_offset_[phase] ? this->config_offset_phase_[phase].first_offset : 0;
+        this->has_config_voltage_offset_[phase] ? this->config_offset_phase_[phase].voltage_offset_ : 0;
     int16_t current_offset =
-        this->has_config_current_offset_[phase] ? this->config_offset_phase_[phase].second_offset : 0;
-    this->write_offsets_to_registers_(phase, voltage_offset, current_offset,
-                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
+        this->has_config_current_offset_[phase] ? this->config_offset_phase_[phase].current_offset_ : 0;
+    this->write_offsets_to_registers_(phase, voltage_offset, current_offset);
     ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase, voltage_offset,
              current_offset);
   }
@@ -1143,7 +1117,6 @@ void ATM90E32Component::clear_offset_calibrations() {
   this->offset_pref_.save(&zero_offsets);  // Clear stored values in flash
   global_preferences->sync();
 
-  this->has_stored_offset_calibration_ = false;
   this->restored_offset_calibration_ = false;
   for (bool &phase : this->offset_calibration_mismatch_)
     phase = false;
@@ -1153,14 +1126,15 @@ void ATM90E32Component::clear_offset_calibrations() {
 
 void ATM90E32Component::clear_power_offset_calibrations() {
   const char *cs = this->get_calibration_id_();
-  if (!this->has_stored_power_offset_calibration_) {
+  if (!this->restored_power_offset_calibration_) {
     ESP_LOGI(TAG, "[CALIBRATION][%s] No stored power offsets to clear. Current values:", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase,
-               this->power_offset_phase_[phase].first_offset, this->power_offset_phase_[phase].second_offset);
+               this->power_offset_phase_[phase].active_power_offset,
+               this->power_offset_phase_[phase].reactive_power_offset);
     }
     ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
     return;
@@ -1173,21 +1147,20 @@ void ATM90E32Component::clear_power_offset_calibrations() {
 
   for (uint8_t phase = 0; phase < 3; phase++) {
     int16_t active_offset =
-        this->has_config_active_power_offset_[phase] ? this->config_power_offset_phase_[phase].first_offset : 0;
-    int16_t reactive_offset =
-        this->has_config_reactive_power_offset_[phase] ? this->config_power_offset_phase_[phase].second_offset : 0;
-    this->write_offsets_to_registers_(phase, active_offset, reactive_offset,
-                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
+        this->has_config_active_power_offset_[phase] ? this->config_power_offset_phase_[phase].active_power_offset : 0;
+    int16_t reactive_offset = this->has_config_reactive_power_offset_[phase]
+                                  ? this->config_power_offset_phase_[phase].reactive_power_offset
+                                  : 0;
+    this->write_power_offsets_to_registers_(phase, active_offset, reactive_offset);
     ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase, active_offset,
              reactive_offset);
   }
   ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
 
-  OffsetCalibration zero_power_offsets[3]{{0, 0}, {0, 0}, {0, 0}};
+  PowerOffsetCalibration zero_power_offsets[3]{{0, 0}, {0, 0}, {0, 0}};
   this->power_offset_pref_.save(&zero_power_offsets);
   global_preferences->sync();
 
-  this->has_stored_power_offset_calibration_ = false;
   this->restored_power_offset_calibration_ = false;
   for (bool &phase : this->power_offset_calibration_mismatch_)
     phase = false;
@@ -1242,31 +1215,6 @@ bool ATM90E32Component::verify_gain_writes_() {
   return success;  // Return true if all writes were successful, false otherwise
 }
 
-bool ATM90E32Component::verify_offset_writes_(OffsetCalibrationType type) {
-  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
-  const char *cs = this->get_calibration_id_();
-  const LogString *name = offset_calibration_name(power_offsets);
-  const LogString *first_name = power_offsets ? LOG_STR("active") : LOG_STR("voltage");
-  const LogString *second_name = power_offsets ? LOG_STR("reactive") : LOG_STR("current");
-  const OffsetCalibration *offsets = power_offsets ? this->power_offset_phase_ : this->offset_phase_;
-  const uint16_t *first_registers = power_offsets ? this->power_offset_registers : this->voltage_offset_registers;
-  const uint16_t *second_registers =
-      power_offsets ? this->reactive_power_offset_registers : this->current_offset_registers;
-  bool success = true;
-  for (uint8_t phase = 0; phase < 3; phase++) {
-    const uint16_t first = this->read16_(first_registers[phase]);
-    const uint16_t second = this->read16_(second_registers[phase]);
-    if (!offset_register_value_matches(first, offsets[phase].first_offset) ||
-        !offset_register_value_matches(second, offsets[phase].second_offset)) {
-      ESP_LOGE(TAG, "[CALIBRATION][%s] %s readback failed for Phase %s: %s %d/%d, %s %d/%d.", cs, LOG_STR_ARG(name),
-               phase_labels[phase], LOG_STR_ARG(first_name), static_cast<int16_t>(first), offsets[phase].first_offset,
-               LOG_STR_ARG(second_name), static_cast<int16_t>(second), offsets[phase].second_offset);
-      success = false;
-    }
-  }
-  return success;
-}
-
 #ifdef USE_TEXT_SENSOR
 void ATM90E32Component::check_phase_status() {
   uint16_t state0 = this->read16_(ATM90E32_REGISTER_EMMSTATE0);

esphome/components/atm90e32/atm90e32.h

@@ -13,40 +13,6 @@
 
 namespace esphome::atm90e32 {
 
-inline bool offset_register_value_matches(uint16_t actual, int16_t expected) {
-  return actual == static_cast<uint16_t>(expected);
-}
-
-struct OffsetCalibration {
-  int16_t first_offset{0};
-  int16_t second_offset{0};
-};
-
-static_assert(sizeof(OffsetCalibration[3]) == 12, "Offset calibration preference layout must remain compatible");
-
-enum class OffsetCalibrationType : uint8_t {
-  OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT,
-  OFFSET_CALIBRATION_TYPE_POWER,
-};
-
-struct OffsetRestoreState {
-  bool restored;
-  bool values_verified;
-};
-
-inline OffsetRestoreState resolve_offset_restore_state(bool has_stored_values, bool initial_values_verified,
-                                                       bool fallback_values_verified) {
-  if (initial_values_verified)
-    return {has_stored_values, true};
-  return {false, fallback_values_verified};
-}
-
-inline void prepare_offset_rollback(const OffsetCalibration (&previous)[3], bool had_stored_values,
-                                    OffsetCalibration (&rollback)[3]) {
-  for (uint8_t phase = 0; phase < 3; phase++)
-    rollback[phase] = had_stored_values ? previous[phase] : OffsetCalibration{};
-}
-
 class ATM90E32Component final : public PollingComponent,
                                 public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH,
                                                       spi::CLOCK_PHASE_TRAILING, spi::DATA_RATE_1MHZ> {
@@ -105,19 +71,19 @@ class ATM90E32Component final : public PollingComponent,
     this->has_config_current_gain_[phase] = true;
   }
   void set_voltage_offset(uint8_t phase, int16_t offset) {
-    this->offset_phase_[phase].first_offset = offset;
+    this->offset_phase_[phase].voltage_offset_ = offset;
     this->has_config_voltage_offset_[phase] = true;
   }
   void set_current_offset(uint8_t phase, int16_t offset) {
-    this->offset_phase_[phase].second_offset = offset;
+    this->offset_phase_[phase].current_offset_ = offset;
     this->has_config_current_offset_[phase] = true;
   }
   void set_active_power_offset(uint8_t phase, int16_t offset) {
-    this->power_offset_phase_[phase].first_offset = offset;
+    this->power_offset_phase_[phase].active_power_offset = offset;
     this->has_config_active_power_offset_[phase] = true;
   }
   void set_reactive_power_offset(uint8_t phase, int16_t offset) {
-    this->power_offset_phase_[phase].second_offset = offset;
+    this->power_offset_phase_[phase].reactive_power_offset = offset;
     this->has_config_reactive_power_offset_[phase] = true;
   }
   void set_freq_sensor(sensor::Sensor *freq_sensor) { freq_sensor_ = freq_sensor; }
@@ -205,16 +171,16 @@ class ATM90E32Component final : public PollingComponent,
   float get_chip_temperature_();
   bool get_publish_interval_flag_() { return publish_interval_flag_; };
   void set_publish_interval_flag_(bool flag) { publish_interval_flag_ = flag; };
-  void restore_offset_calibrations_(OffsetCalibrationType type);
+  void restore_offset_calibrations_();
+  void restore_power_offset_calibrations_();
   void restore_gain_calibrations_();
+  void save_offset_calibration_to_memory_();
   void save_gain_calibration_to_memory_();
-  void finish_offset_calibration_(const OffsetCalibration (&previous)[3], bool previous_restored,
-                                  bool previous_using_saved, OffsetCalibrationType type);
-  void write_offsets_to_registers_(uint8_t phase, int16_t first_offset, int16_t second_offset,
-                                   OffsetCalibrationType type);
+  void save_power_offset_calibration_to_memory_();
+  void write_offsets_to_registers_(uint8_t phase, int16_t voltage_offset, int16_t current_offset);
+  void write_power_offsets_to_registers_(uint8_t phase, int16_t p_offset, int16_t q_offset);
   void write_gains_to_registers_();
   bool verify_gain_writes_();
-  bool verify_offset_writes_(OffsetCalibrationType type);
   bool validate_spi_read_(uint16_t expected, const char *context = nullptr);
   void log_calibration_status_();
   const char *get_calibration_id_();
@@ -253,10 +219,19 @@ class ATM90E32Component final : public PollingComponent,
     uint32_t cumulative_reverse_active_energy_{0};
   } phase_[3];
 
-  OffsetCalibration offset_phase_[3];
+  struct OffsetCalibration {
+    int16_t voltage_offset_{0};
+    int16_t current_offset_{0};
+  } offset_phase_[3];
+
   OffsetCalibration config_offset_phase_[3];
-  OffsetCalibration power_offset_phase_[3];
-  OffsetCalibration config_power_offset_phase_[3];
+
+  struct PowerOffsetCalibration {
+    int16_t active_power_offset{0};
+    int16_t reactive_power_offset{0};
+  } power_offset_phase_[3];
+
+  PowerOffsetCalibration config_power_offset_phase_[3];
 
   struct GainCalibration {
     uint16_t voltage_gain{1};
@@ -290,8 +265,6 @@ class ATM90E32Component final : public PollingComponent,
   bool enable_offset_calibration_{false};
   bool enable_gain_calibration_{false};
   const char *instance_id_{nullptr};
-  bool has_stored_offset_calibration_{false};
-  bool has_stored_power_offset_calibration_{false};
   bool restored_offset_calibration_{false};
   bool restored_power_offset_calibration_{false};
   bool restored_gain_calibration_{false};

esphome/components/audio/audio_decoder.cpp

@@ -313,10 +313,9 @@ FileDecoderState AudioDecoder::decode_mp3_() {
       this->output_transfer_buffer_->increase_buffer_length(
           this->audio_stream_info_.value().frames_to_bytes(samples_decoded));
     }
-  } else if (result == micro_mp3::MP3_STREAM_INFO_READY || result == micro_mp3::MP3_STREAM_INFO_CHANGED) {
-    // Header parsed: capture stream info and resize the output buffer to fit one full frame.
-    // microMP3 always outputs 16-bit PCM. MP3_STREAM_INFO_CHANGED is handled identically: despite its
-    // negative value it is documented as recoverable, so it must not reach the catch-all below.
+  } else if (result == micro_mp3::MP3_STREAM_INFO_READY) {
+    // First successful header parse: capture stream info and resize the output buffer to fit one full frame.
+    // microMP3 always outputs 16-bit PCM.
     this->audio_stream_info_ =
         audio::AudioStreamInfo(16, this->mp3_decoder_->get_channels(), this->mp3_decoder_->get_sample_rate());
     this->free_buffer_required_ =

esphome/components/ble_client/automation.h

@@ -22,23 +22,6 @@ class Automation {
   static const char *const TAG;
 };
 
-// Base for nodes that never read the parent's services.
-// The parent releases its services only once every node reports Established, so a node that never
-// reports it keeps that memory allocated for the life of the connection.
-class BLEClientServicelessNode : public BLEClientNode {
- public:
-  // Final so that Established is always reported on SEARCH_CMPL, before the derived node sees the event.
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) final {
-    if (event == ESP_GATTC_SEARCH_CMPL_EVT)
-      this->node_state = espbt::ClientState::ESTABLISHED;
-    this->on_gattc_event(event, gattc_if, param);
-  }
-
- protected:
-  // Derived nodes handle GATT events here rather than by overriding the handler above.
-  virtual void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) {}
-};
-
 // implement on_connect automation.
 class BLEClientConnectTrigger final : public Trigger<>, public BLEClientNode {
  public:
@@ -78,7 +61,7 @@ class BLEClientDisconnectTrigger final : public Trigger<>, public BLEClientNode
   }
 };
 
-class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientServicelessNode {
+class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientNode {
  public:
   explicit BLEClientPasskeyRequestTrigger(BLEClient *parent) { parent->register_ble_node(this); }
   void loop() override {}
@@ -88,7 +71,7 @@ class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientS
   }
 };
 
-class BLEClientPasskeyNotificationTrigger final : public Trigger<uint32_t>, public BLEClientServicelessNode {
+class BLEClientPasskeyNotificationTrigger final : public Trigger<uint32_t>, public BLEClientNode {
  public:
   explicit BLEClientPasskeyNotificationTrigger(BLEClient *parent) { parent->register_ble_node(this); }
   void loop() override {}
@@ -99,7 +82,7 @@ class BLEClientPasskeyNotificationTrigger final : public Trigger<uint32_t>, publ
   }
 };
 
-class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>, public BLEClientServicelessNode {
+class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>, public BLEClientNode {
  public:
   explicit BLEClientNumericComparisonRequestTrigger(BLEClient *parent) { parent->register_ble_node(this); }
   void loop() override {}
@@ -332,17 +315,19 @@ template<typename... Ts> class BLEClientRemoveBondAction final : public Action<T
   BLEClient *parent_{nullptr};
 };
 
-template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...>, public BLEClientServicelessNode {
+template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...>, public BLEClientNode {
  public:
   BLEClientConnectAction(BLEClient *ble_client) {
     ble_client->register_ble_node(this);
     ble_client_ = ble_client;
   }
-  void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) override {
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override {
     if (this->num_running_ == 0)
       return;
     switch (event) {
       case ESP_GATTC_SEARCH_CMPL_EVT:
+        this->node_state = espbt::ClientState::ESTABLISHED;
         this->parent()->run_later([this]() { this->play_next_tuple_(this->var_); });
         break;
       // if the connection is closed, terminate the automation chain.
@@ -379,13 +364,14 @@ template<typename... Ts> class BLEClientConnectAction final : public Action<Ts..
   std::tuple<Ts...> var_{};
 };
 
-template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...>, public BLEClientServicelessNode {
+template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...>, public BLEClientNode {
  public:
   BLEClientDisconnectAction(BLEClient *ble_client) {
     ble_client->register_ble_node(this);
     ble_client_ = ble_client;
   }
-  void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) override {
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override {
     if (this->num_running_ == 0)
       return;
     switch (event) {

esphome/components/dallas_temp/dallas_temp.cpp

@@ -6,7 +6,6 @@ namespace esphome::dallas_temp {
 static const char *const TAG = "dallas.temp.sensor";
 
 static const uint8_t DALLAS_MODEL_DS18S20 = 0x10;
-static const uint8_t DALLAS_MODEL_DS18B20 = 0x28;
 static const uint8_t DALLAS_COMMAND_START_CONVERSION = 0x44;
 static const uint8_t DALLAS_COMMAND_READ_SCRATCH_PAD = 0xBE;
 static const uint8_t DALLAS_COMMAND_WRITE_SCRATCH_PAD = 0x4E;
@@ -155,14 +154,7 @@ float DallasTemperatureSensor::get_temp_c_() {
     default:
       break;
   }
-  // undocumented test for powerup measurement of 85
-  // https://github.com/cpetrich/counterfeit_DS18B20#solution-to-the-85-c-problem
-  if ((this->address_ & 0xff) == DALLAS_MODEL_DS18B20) {
-    if ((temp == 85 * 16) && (this->scratch_pad_[6] == 0xc)) {
-      ESP_LOGD(TAG, "dropping reading caused by sensor reset");
-      return NAN;
-    }
-  }
+
   return temp / 16.0f;
 }
 

esphome/components/debug/debug_esp32.cpp

@@ -66,15 +66,11 @@ const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFE
 
   unsigned reason = esp_reset_reason();
   if (reason < sizeof(RESET_REASONS) / sizeof(RESET_REASONS[0])) {
-    if (reason == ESP_RST_SW || reason == ESP_RST_WDT) {
-      // On some ESP32-S3 configurations (e.g. SPIRAM with fetch-instructions/rodata),
-      // esp_restart() intermittently produces RTCWDT_RTC_RST (ESP_RST_WDT) instead of
-      // ESP_RST_SW. Check the stored reboot source for both reset reasons so a software
-      // reboot that ends up as WDT still reports the correct source.
+    if (reason == ESP_RST_SW) {
       auto pref = global_preferences->make_preference(REBOOT_MAX_LEN,
                                                       fnv1_hash_extend(fnv1_hash(REBOOT_KEY), App.get_name().c_str()));
       char reboot_source[REBOOT_MAX_LEN]{};
-      if (pref.load(&reboot_source) && reboot_source[0] != '\0') {
+      if (pref.load(&reboot_source)) {
         reboot_source[REBOOT_MAX_LEN - 1] = '\0';
         snprintf(buf, size, "Reboot request from %s", reboot_source);
       } else {

esphome/components/debug/sensor.py

@@ -23,7 +23,11 @@ from esphome.const import (
 )
 from esphome.types import ConfigType
 
-from . import CONF_DEBUG_ID, FILTER_SOURCE_FILES, DebugComponent  # noqa: F401  pylint: disable=unused-import
+from . import (  # noqa: F401  pylint: disable=unused-import
+    CONF_DEBUG_ID,
+    FILTER_SOURCE_FILES,
+    DebugComponent,
+)
 
 DEPENDENCIES = ["debug"]
 

esphome/components/debug/text_sensor.py

@@ -9,7 +9,11 @@ from esphome.const import (
 )
 from esphome.types import ConfigType
 
-from . import CONF_DEBUG_ID, FILTER_SOURCE_FILES, DebugComponent  # noqa: F401  pylint: disable=unused-import
+from . import (  # noqa: F401  pylint: disable=unused-import
+    CONF_DEBUG_ID,
+    FILTER_SOURCE_FILES,
+    DebugComponent,
+)
 
 DEPENDENCIES = ["debug"]
 

esphome/components/esp32/const.py

@@ -3,11 +3,18 @@ import esphome.codegen as cg
 # Re-exported for the many esp32-side users; defined in esphome.const
 # and esphome.espidf so the upload/logs fast path can use them without
 # importing this package.
-from esphome.const import KEY_ESP32, KEY_FLASH_SIZE, KEY_IDF_VERSION, KEY_VARIANT  # noqa: F401  # pylint: disable=unused-import
+from esphome.const import (  # noqa: F401  # pylint: disable=unused-import
+    KEY_ESP32,
+    KEY_FLASH_SIZE,
+    KEY_IDF_VERSION,
+    KEY_VARIANT,
+)
 
 # Back compat for external components only; in-tree callers import it
 # from esphome.espidf directly.
-from esphome.espidf import variant_to_idf_target  # noqa: F401  # pylint: disable=unused-import
+from esphome.espidf import (  # noqa: F401  # pylint: disable=unused-import
+    variant_to_idf_target,
+)
 
 KEY_BOARD = "board"
 KEY_SDKCONFIG_OPTIONS = "sdkconfig_options"

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -91,14 +91,7 @@ void I2SAudioSpeakerBase::loop() {
     this->speaker_task_handle_ = nullptr;
 
     this->stop_i2s_driver_();
-    // ALL_BITS includes COMMAND_START. Take the bits from the clear itself, not from the snapshot at
-    // the top of loop(): the audio source's task can raise a start at any point above, including
-    // during stop_i2s_driver_(), and nothing would ever re-issue it.
-    const EventBits_t bits_before_clear = xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ALL_BITS);
-    if (bits_before_clear & SpeakerEventGroupBits::COMMAND_START) {
-      ESP_LOGD(TAG, "Start requested while stopping; keeping the request");
-      xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::COMMAND_START);
-    }
+    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ALL_BITS);
     this->status_clear_error();
 
     this->on_task_stopped();

esphome/components/logger/logger_esp32.cpp

@@ -5,7 +5,6 @@
 #include <esp_log.h>
 
 #include <driver/uart.h>
-#include <soc/soc_caps.h>
 
 #ifdef USE_LOGGER_UART_SELECTION_USB_SERIAL_JTAG
 #include <driver/usb_serial_jtag.h>
@@ -77,11 +76,7 @@ void init_uart(uart_port_t uart_num, uint32_t baud_rate, int tx_buffer_size) {
   uart_config.parity = UART_PARITY_DISABLE;
   uart_config.stop_bits = UART_STOP_BITS_1;
   uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
-#if SOC_UART_SUPPORT_XTAL_CLK
-  uart_config.source_clk = UART_SCLK_XTAL;
-#else
   uart_config.source_clk = UART_SCLK_DEFAULT;
-#endif
   uart_param_config(uart_num, &uart_config);
   // The logger only writes to UART, never reads, so use the minimum RX buffer.
   // ESP-IDF requires rx_buffer_size > UART_HW_FIFO_LEN (128 bytes).

esphome/components/lvgl/widgets/keyboard.py

@@ -15,7 +15,6 @@ from ..defines import (
 from ..types import LvCompound, LvType
 from . import Widget, WidgetType, get_widgets
 from .buttonmatrix import CONF_BUTTONMATRIX
-from .label import CONF_LABEL
 from .textarea import CONF_TEXTAREA, lv_textarea_t
 
 CONF_KEYBOARD = "keyboard"
@@ -50,7 +49,7 @@ class KeyboardType(WidgetType):
         )
 
     def get_uses(self):
-        return CONF_KEYBOARD, CONF_TEXTAREA, CONF_BUTTONMATRIX, CONF_LABEL
+        return CONF_KEYBOARD, CONF_TEXTAREA, CONF_BUTTONMATRIX
 
     async def to_code(self, w: Widget, config: dict):
         add_lv_use("KEY_LISTENER")

esphome/components/lvgl/widgets/qrcode.py

@@ -10,7 +10,6 @@ from ..types import lv_obj_t
 from . import Widget, WidgetType
 from .canvas import CONF_CANVAS
 from .img import CONF_IMAGE
-from .label import CONF_LABEL
 
 CONF_QRCODE = "qrcode"
 CONF_DARK_COLOR = "dark_color"
@@ -42,7 +41,7 @@ class QrCodeType(WidgetType):
         )
 
     def get_uses(self):
-        return CONF_CANVAS, CONF_IMAGE, CONF_LABEL
+        return CONF_CANVAS, CONF_IMAGE
 
     async def to_code(self, w: Widget, config):
         await w.set_property(

esphome/components/lvgl/widgets/tabview.py

@@ -28,7 +28,6 @@ from ..types import LV_EVENT, LvType, ObjUpdateAction, lv_obj_t, lv_obj_t_ptr
 from . import Widget, WidgetType, add_widgets, get_widgets, set_obj_properties
 from .button import button_spec
 from .buttonmatrix import CONF_BUTTONMATRIX, buttonmatrix_spec
-from .label import CONF_LABEL
 from .obj import obj_spec
 
 CONF_TABVIEW = "tabview"
@@ -75,7 +74,7 @@ class TabviewType(WidgetType):
         )
 
     def get_uses(self):
-        return CONF_BUTTONMATRIX, TYPE_FLEX, CONF_BUTTON, CONF_LABEL
+        return CONF_BUTTONMATRIX, TYPE_FLEX, CONF_BUTTON
 
     async def to_code(self, w: Widget, config: dict):
         await w.set_property(

esphome/components/mqtt/mqtt_light.cpp

@@ -67,9 +67,6 @@ void MQTTJSONLightComponent::send_discovery(JsonObject root, mqtt::SendDiscovery
   if (traits.supports_color_mode(ColorMode::RGB_COLD_WARM_WHITE))
     color_modes.add(ESPHOME_F("rgbww"));
 
-  if (traits.supports_color_capability(ColorCapability::BRIGHTNESS))
-    root[ESPHOME_F("brightness")] = true;
-
   if (traits.supports_color_mode(ColorMode::COLOR_TEMPERATURE) ||
       traits.supports_color_mode(ColorMode::COLD_WARM_WHITE)) {
     root[MQTT_MIN_MIREDS] = traits.get_min_mireds();

esphome/components/nextion/display.py

@@ -14,7 +14,12 @@ from esphome.const import (
 )
 from esphome.core import CORE, TimePeriod
 
-from . import FILTER_SOURCE_FILES, Nextion, nextion_ns, nextion_ref  # noqa: F401  pylint: disable=unused-import
+from . import (  # noqa: F401  pylint: disable=unused-import
+    FILTER_SOURCE_FILES,
+    Nextion,
+    nextion_ns,
+    nextion_ref,
+)
 from .base_component import (
     CONF_AUTO_WAKE_ON_TOUCH,
     CONF_COMMAND_SPACING,

esphome/components/rf_bridge/rf_bridge.cpp

@@ -18,16 +18,6 @@ void RFBridgeComponent::ack_() {
 }
 
 bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
-  if (this->bucket_frame_candidate_ && byte == RF_CODE_START) {
-    // A queued next frame proves the trailing 0x55 really was the bucket
-    // frame's terminator: Portisch builds pulse entries from alternating
-    // signal edges, so the two level bits inside one pulse byte are always
-    // opposite — 0xAA (two high-level nibbles) cannot occur in pulse data.
-    // Finalize before this byte starts the new frame, so back-to-back
-    // deliveries are split even when loop() never observed a quiet gap
-    // between them.
-    this->finish_bucket_frame_();
-  }
   size_t at = this->rx_buffer_.size();
   this->rx_buffer_.push_back(byte);
   const uint8_t *raw = &this->rx_buffer_[0];
@@ -94,21 +84,26 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
       break;
     }
     case RF_CODE_RFIN_BUCKET: {
-      if (at == 2) {
-        // The count byte: Portisch sends at most 7 buckets + sync, so 0 or
-        // >8 cannot be a genuine capture — reject before it can occupy the
-        // buffer for a full frame timeout.
-        return byte != 0 && byte <= B1_MAX_BUCKET_COUNT;
+      if (byte != RF_CODE_STOP) {
+        return true;
       }
-      // 0x55 is legal DATA inside a B1 frame: bucket durations are sent
-      // with only their HIGH byte masked to 7 bits, so a duration such as
-      // 0x0155 puts a raw 0x55 low byte inside the table — the first 0x55
-      // must therefore not end the capture. The header declares the table
-      // length (raw[2] pairs), so a 0x55 there is always data; one at or
-      // past the first pulse index is a terminator CANDIDATE, confirmed
-      // once the UART goes quiet (finish_bucket_frame_ in loop()).
-      this->bucket_frame_candidate_ = byte == RF_CODE_STOP && at >= 3 + static_cast<size_t>(raw[2]) * 2;
-      return true;
+
+      uint8_t buckets = raw[2] << 1;
+      std::string str;
+      char next_byte[3];  // 2 hex chars + null
+
+      for (uint32_t i = 0; i <= at; i++) {
+        buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[i]);
+        str += next_byte;
+        if ((i > 3) && buckets) {
+          buckets--;
+        }
+        if ((i < 3) || (buckets % 2) || (i == at - 1)) {
+          str += " ";
+        }
+      }
+      ESP_LOGI(TAG, "Received RFBridge Bucket: %s", str.c_str());
+      break;
     }
     default:
       ESP_LOGW(TAG, "Unknown action: 0x%02X", action);
@@ -124,47 +119,6 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
   return false;
 }
 
-void RFBridgeComponent::finish_bucket_frame_() {
-  if (this->rx_buffer_.size() < 4) {
-    // The candidate flag requires a header + non-empty bucket table, so
-    // this cannot happen while flag and buffer stay consistent; guard the
-    // raw[2] / size-1 reads against any future divergence anyway.
-    this->rx_buffer_.clear();
-    this->bucket_frame_candidate_ = false;
-    return;
-  }
-  const uint8_t *raw = this->rx_buffer_.data();
-  const size_t at = this->rx_buffer_.size() - 1;
-
-  uint8_t buckets = raw[2] << 1;
-  std::string str;
-  char next_byte[3];  // 2 hex chars + null
-
-  for (uint32_t i = 0; i <= at; i++) {
-    buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[i]);
-    str += next_byte;
-    if ((i > 3) && buckets) {
-      buckets--;
-    }
-    if ((i < 3) || (buckets % 2) || (i == at - 1)) {
-      str += " ";
-    }
-  }
-  ESP_LOGI(TAG, "Received RFBridge Bucket: %s", str.c_str());
-
-  // Deliberately NOT ACKed: Portisch's B1 command handler leaves its
-  // last_sniffing_command at the previous mode (RF_CODE_RFIN), and its
-  // host-ACK handler re-arms sniffing from that stale value — so ACKing a
-  // bucket delivery silently reverts the radio to standard sniffing and
-  // ends bucket capture. Its delivery path is fire-and-forget and never
-  // waits for a host ACK. Stock Itead firmware never sends B1 frames, so
-  // suppressing this ACK cannot change stock-firmware behavior.
-  // https://github.com/esphome/esphome/issues/17682
-
-  this->rx_buffer_.clear();
-  this->bucket_frame_candidate_ = false;
-}
-
 void RFBridgeComponent::write_byte_str_(const std::string &codes) {
   uint8_t code;
   int size = codes.length();
@@ -176,31 +130,12 @@ void RFBridgeComponent::write_byte_str_(const std::string &codes) {
 
 void RFBridgeComponent::loop() {
   const uint32_t now = App.get_loop_component_start_time();
-  size_t avail = this->available();
-  if (avail == 0 && this->bucket_frame_candidate_ && now - this->last_bridge_byte_ > BUCKET_CANDIDATE_QUIET_MS) {
-    // The trailing 0x55 was followed by UART quiet, so it really was the
-    // frame terminator and not an interior data byte.
-    this->finish_bucket_frame_();
-    this->last_bridge_byte_ = now;
-  }
-  const bool receiving_bucket = this->rx_buffer_.size() >= 2 && this->rx_buffer_[1] == RF_CODE_RFIN_BUCKET;
-  if (receiving_bucket) {
-    // Never declare an in-progress bucket frame dead while its continuation
-    // bytes are already queued: a stalled loop() otherwise discards a live
-    // frame that the UART buffer proves is still arriving.
-    if (avail == 0 && now - this->last_bridge_byte_ > BUCKET_FRAME_TIMEOUT_MS) {
-      ESP_LOGD(TAG, "Discarding incomplete RFBridge Bucket frame (%u bytes)",
-               static_cast<unsigned>(this->rx_buffer_.size()));
-      this->rx_buffer_.clear();
-      this->bucket_frame_candidate_ = false;
-      this->last_bridge_byte_ = now;
-    }
-  } else if (now - this->last_bridge_byte_ > 50) {
+  if (now - this->last_bridge_byte_ > 50) {
     this->rx_buffer_.clear();
-    this->bucket_frame_candidate_ = false;
     this->last_bridge_byte_ = now;
   }
 
+  size_t avail = this->available();
   while (avail > 0) {
     uint8_t buf[64];
     size_t to_read = std::min(avail, sizeof(buf));
@@ -211,14 +146,12 @@ void RFBridgeComponent::loop() {
     for (size_t i = 0; i < to_read; i++) {
       if (this->rx_buffer_.size() > MAX_RX_BUFFER_SIZE) {
         this->rx_buffer_.clear();
-        this->bucket_frame_candidate_ = false;
       }
       if (this->parse_bridge_byte_(buf[i])) {
         ESP_LOGVV(TAG, "Parsed: 0x%02X", buf[i]);
         this->last_bridge_byte_ = now;
       } else {
         this->rx_buffer_.clear();
-        this->bucket_frame_candidate_ = false;
       }
     }
   }

esphome/components/rf_bridge/rf_bridge.h

@@ -30,17 +30,6 @@ static const uint8_t RF_CODE_BEEP = 0xC0;
 static const uint8_t RF_CODE_STOP = 0x55;
 static const uint8_t RF_DEBOUNCE = 200;
 static const size_t MAX_RX_BUFFER_SIZE = 512;
-// ~10 byte times at 19200 baud: long enough to prove the UART went quiet
-// after a possible bucket-frame terminator, short enough to finish well
-// before the next radio capture can be delivered.
-static const uint32_t BUCKET_CANDIDATE_QUIET_MS = 5;
-// Portisch drains a B1 frame's header, bucket table, and pulse data as
-// separate UART writes, so an in-progress bucket frame tolerates a longer
-// inter-region gap than the generic 50 ms inter-byte timeout.
-static const uint32_t BUCKET_FRAME_TIMEOUT_MS = 250;
-// Portisch's uart_put_RF_buckets sends at most 7 buckets plus the sync
-// bucket, so a B1 count byte above 8 (or 0) is malformed for any protocol.
-static const uint8_t B1_MAX_BUCKET_COUNT = 8;
 
 struct RFBridgeData {
   uint16_t sync;
@@ -78,12 +67,10 @@ class RFBridgeComponent final : public uart::UARTDevice, public Component {
   void ack_();
   void decode_();
   bool parse_bridge_byte_(uint8_t byte);
-  void finish_bucket_frame_();
   void write_byte_str_(const std::string &codes);
 
   std::vector<uint8_t> rx_buffer_;
   uint32_t last_bridge_byte_{0};
-  bool bucket_frame_candidate_{false};
 
   CallbackManager<void(RFBridgeData)> data_callback_;
   CallbackManager<void(RFBridgeAdvancedData)> advanced_data_callback_;

esphome/components/tuya/tuya.cpp

@@ -1,13 +1,10 @@
 #include "tuya.h"
+#include "esphome/components/network/util.h"
 #include "esphome/core/gpio.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
-#ifdef USE_NETWORK
-#include "esphome/components/network/util.h"
-#endif
-
 #ifdef USE_WIFI
 #include "esphome/components/wifi/wifi_component.h"
 #endif
@@ -25,14 +22,6 @@ static const int MAX_RETRIES = 5;
 // Max bytes to log for datapoint values (larger values are truncated)
 static constexpr size_t MAX_DATAPOINT_LOG_BYTES = 16;
 
-static bool network_is_connected() {
-#ifdef USE_NETWORK
-  return network::is_connected();
-#else
-  return false;
-#endif
-}
-
 void Tuya::setup() {
   this->set_interval("heartbeat", 15000, [this] { this->send_empty_command_(TuyaCommandType::HEARTBEAT); });
   if (this->status_pin_ != nullptr) {
@@ -565,14 +554,14 @@ void Tuya::send_empty_command_(TuyaCommandType command) {
 }
 
 void Tuya::set_status_pin_() {
-  bool is_network_ready = network_is_connected() && remote_is_connected();
+  bool is_network_ready = network::is_connected() && remote_is_connected();
   this->status_pin_->digital_write(is_network_ready);
 }
 
 uint8_t Tuya::get_wifi_status_code_() {
   uint8_t status = 0x02;
 
-  if (network_is_connected()) {
+  if (network::is_connected()) {
     status = 0x03;
 
     // Protocol version 3 also supports specifying when connected to "the cloud"

esphome/components/udp/__init__.py

@@ -1,4 +1,5 @@
-from typing import Any
+from collections.abc import Callable
+from typing import Any, NoReturn
 
 from esphome import automation
 from esphome.automation import Trigger
@@ -47,10 +48,17 @@ UDP_SCHEMA = cv.Schema(
 )
 
 
+def is_relocated(option: str) -> Callable[[Any], NoReturn]:
+    def validator(value: Any) -> NoReturn:
+        raise cv.Invalid(
+            f"The '{option}' option should now be configured in the 'packet_transport' component"
+        )
+
+    return validator
+
+
 RELOCATED = {
-    cv.Optional(x): cv.invalid(
-        f"The '{x}' option should now be configured in the 'packet_transport' component"
-    )
+    cv.Optional(x): is_relocated(x)
     for x in (
         CONF_PROVIDERS,
         CONF_ENCRYPTION,

esphome/happy_eyeballs.py

@@ -69,7 +69,10 @@ def _make_create_connection() -> Callable[..., socket.socket]:
 
     from aiohappyeyeballs import start_connection
     from urllib3.exceptions import LocationParseError
-    from urllib3.util.connection import _set_socket_options, allowed_gai_family  # noqa: PLC2701
+    from urllib3.util.connection import (  # noqa: PLC2701
+        _set_socket_options,
+        allowed_gai_family,
+    )
     from urllib3.util.timeout import _DEFAULT_TIMEOUT  # noqa: PLC2701
 
     from esphome import async_thread

esphome/platformio/library.py

@@ -616,15 +616,11 @@ def _make_registry_client() -> Any:
     elsewhere, not by the PlatformIO registry.
     """
     from platformio.package.manager._registry import PackageManagerRegistryMixin
-    from platformio.registry.client import RegistryClient
 
     class _Registry(PackageManagerRegistryMixin):
         def __init__(self) -> None:
+            self._registry_client = None
             self.pkg_type = "library"
-            self._registry_client = RegistryClient()
-            # The probe sleeps ~500 ms per lookup (see runner.patch_registry_private_packages);
-            # instance-level so the ESPHome process never patches PlatformIO's class
-            self._registry_client.allowed_private_packages = lambda: False
 
         @staticmethod
         def is_system_compatible(value: Any, custom_system: Any = None) -> bool:

esphome/platformio/prefetch.py

@@ -951,10 +951,8 @@ def main(argv: list[str]) -> int:
     """Subprocess entry point: ``prefetch <build_dir> <env_name>``."""
     from esphome.core import CORE
     from esphome.log import setup_log
-    from esphome.platformio.runner import patch_registry_private_packages
 
     signal.signal(signal.SIGTERM, _sigterm)
-    patch_registry_private_packages()
     raw_level = os.environ.get("ESPHOME_PREFETCH_LOG_LEVEL")
     try:
         level = int(raw_level) if raw_level is not None else logging.INFO

esphome/platformio/runner.py

@@ -2,8 +2,7 @@
 
 Invoked via ``python -m esphome.platformio.runner`` instead of
 ``python -m platformio`` so that the patches (incremental rebuild
-preservation, download retries, skipping the private-package probe) apply
-inside the subprocess. Running
+preservation, download retries) apply inside the subprocess. Running
 PlatformIO in a subprocess keeps its ``sys.path`` mutations and other
 global state from leaking into the ESPHome process.
 """
@@ -106,16 +105,6 @@ def patch_file_downloader() -> None:
     FileDownloader.__init__ = patched_init
 
 
-def patch_registry_private_packages() -> None:
-    """Skip PlatformIO's private-package probe; it sleeps ~500 ms per lookup.
-
-    ESPHome never uses private packages, so the answer is always False.
-    """
-    from platformio.registry.client import RegistryClient
-
-    RegistryClient.allowed_private_packages = staticmethod(lambda: False)  # type: ignore[method-assign]
-
-
 _IGNORE_LIB_WARNINGS = "(?:Hash|Update)"
 # Regex patterns matched against each line of PlatformIO output. Lines that
 # match are dropped by RedirectText before they reach the parent process.
@@ -163,7 +152,6 @@ FILTER_PLATFORMIO_LINES = [
 def main() -> int:
     patch_structhash()
     patch_file_downloader()
-    patch_registry_private_packages()
 
     # Wrap stdout/stderr with RedirectText before PlatformIO runs:
     #

requirements_dev.txt

@@ -1,4 +1,4 @@
 # Useful stuff when working in a development environment
-clang-format==13.0.1  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
+clang-format==13.0.1  # also change in .pre-commit-config.yaml and Dockerfile when updating
 clang-tidy==22.1.8
-yamllint==1.38.0  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
+yamllint==1.38.0  # also change in .pre-commit-config.yaml when updating

requirements_test.txt

@@ -1,9 +1,8 @@
 pylint==4.0.8
-flake8==7.3.0  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-ruff==0.16.6  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-pyupgrade==3.21.2  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-prek==0.5.2  # .github/workflows/ci.yml reads this pin
-yamlrocks==0.6.1  # used by script/sync_dependency_versions.py
+flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
+ruff==0.16.5  # also change in .pre-commit-config.yaml when updating
+pyupgrade==3.21.2  # also change in .pre-commit-config.yaml when updating
+prek==0.5.1  # also change in .github/workflows/ci.yml when updating
 
 # Unit tests
 pytest==9.1.1

script/api_protobuf/api_protobuf.py

@@ -131,6 +131,12 @@ def force_str(force: bool) -> str:
     return str(force).lower()
 
 
+def _encode_call(func: str, *args: str, force: bool = False) -> str:
+    """Emit one ProtoEncode call; every helper takes the cursor and returns it advanced."""
+    suffix = "_force" if force else ""
+    return f"pos = ProtoEncode::{func}{suffix}({', '.join(('pos', *args))});"
+
+
 class TypeInfo(ABC):
     """Base class for all type information."""
 
@@ -264,14 +270,16 @@ class TypeInfo(ABC):
     # write_raw_byte(tag) + raw encode instead of the full encode_* method,
     # eliminating the zero-check branch and encode_field_raw indirection.
     # {value} is replaced with the actual field expression.
-    RAW_ENCODE_MAP: dict[str, str] = {
-        "encode_uint32": "ProtoEncode::encode_varint_raw(pos, {value});",
-        "encode_uint64": "ProtoEncode::encode_varint_raw_64(pos, {value});",
-        "encode_sint32": "ProtoEncode::encode_varint_raw_short(pos, encode_zigzag32({value}));",
-        "encode_sint64": "ProtoEncode::encode_varint_raw_64(pos, encode_zigzag64({value}));",
-        "encode_int64": "ProtoEncode::encode_varint_raw_64(pos, static_cast<uint64_t>({value}));",
-        "encode_bool": "ProtoEncode::write_raw_byte(pos, {value} ? 0x01 : 0x00);",
+    RAW_ENCODE_MAP: dict[str, tuple[str, str]] = {
+        "encode_uint32": ("encode_varint_raw", "{value}"),
+        "encode_uint64": ("encode_varint_raw_64", "{value}"),
+        "encode_sint32": ("encode_varint_raw_short", "encode_zigzag32({value})"),
+        "encode_sint64": ("encode_varint_raw_64", "encode_zigzag64({value})"),
+        "encode_int64": ("encode_varint_raw_64", "static_cast<uint64_t>({value})"),
+        "encode_bool": ("write_raw_byte", "{value} ? 0x01 : 0x00"),
     }
+    # Fixed32 value expression for the shared tag+fixed32 writer; None for other wire types
+    fixed32_value_template: str | None = None
 
     def _encode_with_precomputed_tag(self, value_expr: str) -> str | None:
         """Try to emit a precomputed-tag encode for a field.
@@ -288,12 +296,17 @@ class TypeInfo(ABC):
             return None
         max_val = self.max_value
         # Only use RAW_ENCODE_MAP for forced fields or fields with max_value
-        raw_expr = None
+        raw = None
         if self.force or max_val is not None:
-            raw_expr = self.RAW_ENCODE_MAP.get(self.encode_func)
-        if raw_expr is None:
+            raw = self.RAW_ENCODE_MAP.get(self.encode_func)
+        if raw is None:
             return None
-        body = f"ProtoEncode::write_raw_byte(pos, {tag});\n{raw_expr.format(value=value_expr)}"
+        func, arg = raw
+        body = (
+            _encode_call("write_raw_byte", str(tag))
+            + "\n"
+            + _encode_call(func, arg.format(value=value_expr))
+        )
         if self.force:
             return body
         # Non-forced with max_value: inline zero-check + raw encode
@@ -314,23 +327,43 @@ class TypeInfo(ABC):
             return None
         # When max_len < 128, length varint is always 1 byte
         len_encode = (
-            f"ProtoEncode::write_raw_byte(pos, static_cast<uint8_t>({len_expr}));"
+            _encode_call("write_raw_byte", f"static_cast<uint8_t>({len_expr})")
             if max_len is not None and max_len < 128
-            else f"ProtoEncode::encode_varint_raw(pos, {len_expr});"
+            else _encode_call("encode_varint_raw", len_expr)
         )
+        return "\n".join(
+            (
+                _encode_call("write_raw_byte", str(tag)),
+                len_encode,
+                _encode_call("encode_raw", data_expr, len_expr),
+            )
+        )
+
+    def _encode_fixed32_with_precomputed_tag(self, value_expr: str) -> str | None:
+        """Single-byte tag fixed32 write, or None for multi-byte tags."""
+        tag = self.calculate_tag()
+        if tag >= 128:
+            return None
+        if self.force:
+            return _encode_call("write_tag_and_fixed32", str(tag), value_expr)
         return (
-            f"ProtoEncode::write_raw_byte(pos, {tag});\n"
-            f"{len_encode}\n"
-            f"ProtoEncode::encode_raw(pos, {data_expr}, {len_expr});"
+            f"if (uint32_t raw = {value_expr}; raw != 0) [[likely]] {{\n"
+            f"  {_encode_call('write_tag_and_fixed32', str(tag), 'raw')}\n"
+            "}"
         )
 
     @property
     def encode_content(self) -> str:
-        if result := self._encode_with_precomputed_tag(f"this->{self.field_name}"):
+        value = f"this->{self.field_name}"
+        if result := self._encode_with_precomputed_tag(value):
             return result
-        if self.force:
-            return f"ProtoEncode::{self.encode_func}(pos, {self.number}, this->{self.field_name}, true);"
-        return f"ProtoEncode::{self.encode_func}(pos, {self.number}, this->{self.field_name});"
+        if self.fixed32_value_template is not None and (
+            result := self._encode_fixed32_with_precomputed_tag(
+                self.fixed32_value_template.format(value=value)
+            )
+        ):
+            return result
+        return _encode_call(self.encode_func, str(self.number), value, force=self.force)
 
     encode_func = None
 
@@ -635,6 +668,8 @@ class FloatType(FixedSizeTypeMixin, TypeInfo):
     encode_func = "encode_float"
     wire_type = WireType.FIXED32  # Uses wire type 5
 
+    fixed32_value_template = "float_to_raw({value})"
+
     def dump(self, name: str) -> str:
         o = f'snprintf(buffer, sizeof(buffer), "%g", {name});\n'
         o += "out.append(buffer);"
@@ -697,11 +732,11 @@ class UInt64Type(VarintTypeMixin, TypeInfo):
         return self._get_simple_size_calculation(name, force, "uint64")
 
     @property
-    def RAW_ENCODE_MAP(self) -> dict[str, str]:  # noqa: N802
+    def RAW_ENCODE_MAP(self) -> dict[str, tuple[str, str]]:  # noqa: N802
         if self.mac_address:
             return {
                 **TypeInfo.RAW_ENCODE_MAP,
-                "encode_uint64": "ProtoEncode::encode_varint_raw_48bit(pos, {value});",
+                "encode_uint64": ("encode_varint_raw_48bit", "{value}"),
             }
         return TypeInfo.RAW_ENCODE_MAP
 
@@ -769,15 +804,7 @@ class Fixed32Type(FixedSizeTypeMixin, TypeInfo):
         o += "out.append(buffer);"
         return o
 
-    @property
-    def encode_content(self) -> str:
-        tag = self.calculate_tag()
-        if self.force and tag < 128:
-            # Emit combined tag+value write: precomputed tag + direct memcpy
-            return f"ProtoEncode::write_tag_and_fixed32(pos, {tag}, this->{self.field_name});"
-        if self.force:
-            return f"ProtoEncode::{self.encode_func}(pos, {self.number}, this->{self.field_name}, true);"
-        return f"ProtoEncode::{self.encode_func}(pos, {self.number}, this->{self.field_name});"
+    fixed32_value_template = "{value}"
 
     def get_size_calculation(self, name: str, force: bool = False) -> str:
         field_id_size = self.calculate_field_id_size()
@@ -851,9 +878,12 @@ class StringType(TypeInfo):
             f"this->{self.field_name}_ref_.size()",
         ):
             return result
-        if self.force:
-            return f"ProtoEncode::encode_string(pos, {self.number}, this->{self.field_name}_ref_, true);"
-        return f"ProtoEncode::encode_string(pos, {self.number}, this->{self.field_name}_ref_);"
+        return _encode_call(
+            "encode_string",
+            str(self.number),
+            f"this->{self.field_name}_ref_",
+            force=self.force,
+        )
 
     def dump(self, name):
         # If name is 'it', this is a repeated field element - always use string
@@ -951,7 +981,9 @@ class MessageType(TypeInfo):
     @property
     def encode_content(self) -> str:
         # Sub-message encoding needs buffer for backpatch/sync
-        return f"ProtoEncode::{self.encode_func}(pos, buffer, {self.number}, this->{self.field_name});"
+        return _encode_call(
+            self.encode_func, "buffer", str(self.number), f"this->{self.field_name}"
+        )
 
     @property
     def decode_length(self) -> str:
@@ -1058,9 +1090,13 @@ class BytesType(TypeInfo):
             f"this->{self.field_name}_ptr_", f"this->{self.field_name}_len_"
         ):
             return result
-        if self.force:
-            return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}_ptr_, this->{self.field_name}_len_, true);"
-        return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}_ptr_, this->{self.field_name}_len_);"
+        return _encode_call(
+            "encode_bytes",
+            str(self.number),
+            f"this->{self.field_name}_ptr_",
+            f"this->{self.field_name}_len_",
+            force=self.force,
+        )
 
     def dump(self, name: str) -> str:
         ptr_dump = f"format_hex_pretty(this->{self.field_name}_ptr_, this->{self.field_name}_len_)"
@@ -1170,9 +1206,13 @@ class PointerToBytesBufferType(PointerToBufferTypeBase):
             f"this->{self.field_name}", f"this->{self.field_name}_len"
         ):
             return result
-        if self.force:
-            return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}, this->{self.field_name}_len, true);"
-        return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}, this->{self.field_name}_len);"
+        return _encode_call(
+            "encode_bytes",
+            str(self.number),
+            f"this->{self.field_name}",
+            f"this->{self.field_name}_len",
+            force=self.force,
+        )
 
     @property
     def decode_length_content(self) -> str | None:
@@ -1224,16 +1264,19 @@ class PointerToStringBufferType(PointerToBufferTypeBase):
         if max_len is not None and max_len < 128 and self.force:
             tag = self.calculate_tag()
             if tag < 128:
-                return f"ProtoEncode::encode_short_string_force(pos, {tag}, this->{self.field_name});"
+                return _encode_call(
+                    "encode_short_string_force", str(tag), f"this->{self.field_name}"
+                )
         if result := self._encode_bytes_with_precomputed_tag(
             f"this->{self.field_name}.c_str()",
             f"this->{self.field_name}.size()",
         ):
             return result
-        if self.force:
-            return f"ProtoEncode::encode_string(pos, {self.number}, this->{self.field_name}, true);"
-        return (
-            f"ProtoEncode::encode_string(pos, {self.number}, this->{self.field_name});"
+        return _encode_call(
+            "encode_string",
+            str(self.number),
+            f"this->{self.field_name}",
+            force=self.force,
         )
 
     @property
@@ -1421,9 +1464,13 @@ class FixedArrayBytesType(TypeInfo):
             f"this->{self.field_name}", f"this->{self.field_name}_len", max_len=max_len
         ):
             return result
-        if self.force:
-            return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}, this->{self.field_name}_len, true);"
-        return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}, this->{self.field_name}_len);"
+        return _encode_call(
+            "encode_bytes",
+            str(self.number),
+            f"this->{self.field_name}",
+            f"this->{self.field_name}_len",
+            force=self.force,
+        )
 
     def dump(self, name: str) -> str:
         return f"out.append(format_hex_pretty({name}, {name}_len));"
@@ -1520,9 +1567,9 @@ class EnumType(VarintTypeMixin, TypeInfo):
     @property
     def encode_content(self) -> str:
         value_expr = f"static_cast<uint32_t>(this->{self.field_name})"
-        if self.force:
-            return f"ProtoEncode::{self.encode_func}(pos, {self.number}, {value_expr}, true);"
-        return f"ProtoEncode::{self.encode_func}(pos, {self.number}, {value_expr});"
+        return _encode_call(
+            self.encode_func, str(self.number), value_expr, force=self.force
+        )
 
     def dump(self, name: str) -> str:
         return f"out.append_p(proto_enum_to_string<{self.cpp_type}>({name}));"
@@ -1701,9 +1748,9 @@ def _generate_inline_encode_block(
 
     lines = []
     lines.append(f"auto &sub_msg = {element};")
-    lines.append(f"ProtoEncode::write_raw_byte(pos, {tag});")
+    lines.append(_encode_call("write_raw_byte", str(tag)))
     lines.append("uint8_t *len_pos = pos;")
-    lines.append("ProtoEncode::reserve_byte(pos);")
+    lines.append(_encode_call("reserve_byte"))
 
     # Generate inline field encoding for each sub-message field
     for field in sub_desc.field:
@@ -1775,17 +1822,22 @@ class FixedArrayRepeatedType(TypeInfo):
     def _encode_element(self, element: str) -> str:
         """Helper to generate encode statement for a single element."""
         if isinstance(self._ti, EnumType):
-            return f"ProtoEncode::{self._ti.encode_func}(pos, {self.number}, static_cast<uint32_t>({element}), true);"
+            return _encode_call(
+                self._ti.encode_func,
+                str(self.number),
+                f"static_cast<uint32_t>({element})",
+                force=True,
+            )
         # Repeated message elements use encode_sub_message (force=true is default)
         if isinstance(self._ti, MessageType):
             if _is_inline_encode(self._ti.cpp_type):
                 return _generate_inline_encode_block(
                     self.number, self._ti.cpp_type, element
                 )
-            return f"ProtoEncode::encode_sub_message(pos, buffer, {self.number}, {element});"
-        return (
-            f"ProtoEncode::{self._ti.encode_func}(pos, {self.number}, {element}, true);"
-        )
+            return _encode_call(
+                "encode_sub_message", "buffer", str(self.number), element
+            )
+        return _encode_call(self._ti.encode_func, str(self.number), element, force=True)
 
     @property
     def cpp_type(self) -> str:
@@ -2137,13 +2189,18 @@ class RepeatedTypeInfo(TypeInfo):
     def _encode_element_call(self, element: str) -> str:
         """Helper to generate encode call for a single element."""
         if isinstance(self._ti, EnumType):
-            return f"ProtoEncode::{self._ti.encode_func}(pos, {self.number}, static_cast<uint32_t>({element}), true);"
+            return _encode_call(
+                self._ti.encode_func,
+                str(self.number),
+                f"static_cast<uint32_t>({element})",
+                force=True,
+            )
         # Repeated message elements use encode_sub_message (force=true is default)
         if isinstance(self._ti, MessageType):
-            return f"ProtoEncode::encode_sub_message(pos, buffer, {self.number}, {element});"
-        return (
-            f"ProtoEncode::{self._ti.encode_func}(pos, {self.number}, {element}, true);"
-        )
+            return _encode_call(
+                "encode_sub_message", "buffer", str(self.number), element
+            )
+        return _encode_call(self._ti.encode_func, str(self.number), element, force=True)
 
     @property
     def encode_content(self) -> str:
@@ -2152,7 +2209,7 @@ class RepeatedTypeInfo(TypeInfo):
             # Special handling for const char* elements (when container_no_template contains "const char")
             if "const char" in self._container_no_template:
                 o = f"for (const char *it : *this->{self.field_name}) {{\n"
-                o += f"  ProtoEncode::{self._ti.encode_func}(pos, {self.number}, it, strlen(it), true);\n"
+                o += f"  {_encode_call(self._ti.encode_func, str(self.number), 'it', 'strlen(it)', force=True)}\n"
             else:
                 o = f"for (const auto &it : *this->{self.field_name}) {{\n"
                 o += f"  {self._encode_element_call('it')}\n"
@@ -2784,28 +2841,36 @@ def build_message_type(
             )
             for line in encode
         ]
-        o = f"{speed_attr}uint8_t *{desc.name}::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {{\n"
+        o = f"{speed_attr}uint8_t *{desc.name}::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {{\n"
+        o += f"  const auto &msg = *static_cast<const {desc.name} *>(self);\n"
         o += "  uint8_t *__restrict__ pos = buffer.get_pos();\n"
-        o += indent("\n".join(encode_debug)) + "\n"
+        o += indent("\n".join(encode_debug)).replace("this->", "msg.") + "\n"
         o += "  return pos;\n"
         o += "}\n"
         cpp += o
-        prot = (
-            "uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;"
+        public_content.append(
+            "static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);"
+        )
+        public_content.append(
+            "uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {\n"
+            "  return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);\n"
+            "}"
         )
-        public_content.append(prot)
     # If no fields to encode or message doesn't need encoding, the default implementation in ProtoMessage will be used
 
     # Add calculate_size method only if this message needs encoding and has fields
     if needs_encode and size_calc and not is_inline_only:
-        o = f"{speed_attr}uint32_t {desc.name}::calculate_size() const {{\n"
+        o = f"{speed_attr}uint32_t {desc.name}::calc_size_msg(const void *self) {{\n"
+        o += f"  const auto &msg = *static_cast<const {desc.name} *>(self);\n"
         o += "  uint32_t size = 0;\n"
-        o += indent("\n".join(size_calc)) + "\n"
+        o += indent("\n".join(size_calc)).replace("this->", "msg.") + "\n"
         o += "  return size;\n"
         o += "}\n"
         cpp += o
-        prot = "uint32_t calculate_size() const;"
-        public_content.append(prot)
+        public_content.append("static uint32_t calc_size_msg(const void *self);")
+        public_content.append(
+            "uint32_t calculate_size() const { return calc_size_msg(this); }"
+        )
     # If no fields to calculate size for or message doesn't need encoding, the default implementation in ProtoMessage will be used
 
     # dump_to method declaration in header

script/git-hooks/post-checkout

@@ -14,31 +14,7 @@ top=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0
 [ -x "$top/venv/bin/python" ] && exit 0
 [ -x "$top/script/setup" ] || exit 0
 
-# Every worktree shares the hooks directory of the checkout it was created
-# from, and the script/setup run below is the one from whichever branch was just
-# checked out. Older branches install their own pre-commit hook without checking
-# for a worktree: that moves the shared hook aside as pre-commit.legacy and
-# replaces it with one tied to this worktree's virtual environment, so commits
-# break in every checkout. To rule that out, the hooks directory is copied
-# before script/setup runs and put back exactly as it was afterwards, including
-# removing any file script/setup added.
-hooks=$(git rev-parse --path-format=absolute --git-path hooks 2>/dev/null) || exit 0
-snap=$(mktemp -d "$hooks/.post-checkout.XXXXXX") || exit 0
-cp -p "$hooks"/* "$snap"/ 2>/dev/null
-
 # Clear VIRTUAL_ENV so a checkout made from a shell with an environment already
 # activated still gets its own, rather than having the active one repointed at
 # this working tree.
-env -u VIRTUAL_ENV "$top/script/setup"
-status=$?
-
-for f in "$hooks"/*; do
-  [ -e "$snap/${f##*/}" ] || rm -f "$f"
-done
-# Files are moved rather than copied so a hook that is still running, such as
-# this one, is swapped out atomically instead of being rewritten in place.
-for f in "$snap"/*; do
-  cmp -s "$f" "$hooks/${f##*/}" 2>/dev/null || mv -f "$f" "$hooks/${f##*/}"
-done
-rm -rf "$snap"
-exit $status
+exec env -u VIRTUAL_ENV "$top/script/setup"

script/sync_dependency_versions.py

@@ -1,164 +0,0 @@
-#!/usr/bin/env python3
-"""Keep pre-commit hook revs in sync with the requirements files.
-
-Dependabot only bumps the ``package==version`` pins in ``requirements*.txt``.
-Some of those tools are pinned a second time as hook ``rev`` values in
-``.pre-commit-config.yaml``. This script treats the requirements files as
-the source of truth and rewrites the revs to match, editing the config
-through yamlrocks so comments and layout survive.
-
-Run without arguments to apply the changes in place, or with ``--check`` to
-only report drift (exit status 1 when anything is out of sync).
-"""
-
-from __future__ import annotations
-
-import argparse
-from dataclasses import dataclass
-from pathlib import Path
-import re
-import sys
-from typing import Any
-
-import yamlrocks
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-PRECOMMIT_CONFIG = ".pre-commit-config.yaml"
-
-
-class SyncError(Exception):
-    """A pin could not be located in a requirements file or the config."""
-
-
-@dataclass(frozen=True)
-class SyncTarget:
-    """A requirements pin and the pre-commit repo whose rev mirrors it."""
-
-    package: str
-    requirements_file: str
-    repo: str
-
-
-SYNC_TARGETS: tuple[SyncTarget, ...] = (
-    SyncTarget(
-        "ruff", "requirements_test.txt", "https://github.com/astral-sh/ruff-pre-commit"
-    ),
-    SyncTarget("flake8", "requirements_test.txt", "https://github.com/PyCQA/flake8"),
-    SyncTarget(
-        "pyupgrade", "requirements_test.txt", "https://github.com/asottile/pyupgrade"
-    ),
-    SyncTarget(
-        "clang-format",
-        "requirements_dev.txt",
-        "https://github.com/pre-commit/mirrors-clang-format",
-    ),
-    SyncTarget(
-        "yamllint",
-        "requirements_dev.txt",
-        "https://github.com/adrienverge/yamllint.git",
-    ),
-)
-
-
-def read_requirement_version(requirements: str, package: str) -> str | None:
-    """Return the ``==`` pin for ``package`` or None when it is not pinned."""
-    pattern = re.compile(
-        rf"^{re.escape(package)}==(?P<version>[^\s#]+)",
-        re.MULTILINE | re.IGNORECASE,
-    )
-    match = pattern.search(requirements)
-    return match.group("version") if match else None
-
-
-def find_repo_entry(doc: Any, repo: str) -> Any:
-    """Return the single ``- repo:`` block for ``repo`` in a pre-commit doc."""
-    try:
-        entries = [entry for entry in doc["repos"] if entry["repo"] == repo]
-    except KeyError as err:
-        raise SyncError(f"malformed pre-commit config, missing key {err}") from None
-    if len(entries) != 1:
-        raise SyncError(
-            f"expected exactly one block for repo {repo}, found {len(entries)}"
-        )
-    return entries[0]
-
-
-def current_rev(entry: Any, repo: str) -> tuple[str, str]:
-    """Split the block's rev into its tag prefix (``v`` or empty) and version."""
-    if "rev" not in entry:
-        raise SyncError(f"repo {repo} has no rev")
-    rev = entry["rev"]
-    if not isinstance(rev, str):
-        # A rev such as ``1.0`` parses as a number and cannot be compared or
-        # rewritten safely; quote it in the config instead.
-        raise SyncError(f"rev of repo {repo} is not a string: {rev!r}")
-    prefix = "v" if rev.startswith("v") else ""
-    return prefix, rev.removeprefix("v")
-
-
-def sync(root: Path, *, write: bool) -> list[str]:
-    """Bring every hook rev in line with its requirements pin.
-
-    Returns one description per rev that was (or, when ``write`` is False,
-    would be) changed. Raises SyncError when a pin cannot be found, which
-    means SYNC_TARGETS has gone stale and needs updating by hand.
-    """
-    config_path = root / PRECOMMIT_CONFIG
-    doc = yamlrocks.loads(config_path.read_bytes(), option=yamlrocks.OPT_ROUND_TRIP)
-    requirements: dict[str, str] = {}
-    changes: list[str] = []
-    for target in SYNC_TARGETS:
-        if target.requirements_file not in requirements:
-            requirements[target.requirements_file] = (
-                root / target.requirements_file
-            ).read_text()
-        version = read_requirement_version(
-            requirements[target.requirements_file], target.package
-        )
-        if version is None:
-            raise SyncError(
-                f"{target.requirements_file}: no '{target.package}==' pin found"
-            )
-
-        entry = find_repo_entry(doc, target.repo)
-        prefix, current = current_rev(entry, target.repo)
-        if current == version:
-            continue
-        changes.append(f"{target.package}: {current} -> {version}")
-        entry["rev"] = f"{prefix}{version}"
-
-    if changes and write:
-        config_path.write_bytes(doc.to_yaml())
-    return changes
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument(
-        "--check",
-        action="store_true",
-        help="report drift without modifying any file; exit 1 if out of sync",
-    )
-    parser.add_argument(
-        "--root",
-        type=Path,
-        default=REPO_ROOT,
-        help="repository checkout to operate on (default: this checkout)",
-    )
-    args = parser.parse_args(argv)
-
-    try:
-        changes = sync(args.root, write=not args.check)
-    except SyncError as err:
-        print(f"error: {err}", file=sys.stderr)
-        return 1
-
-    for change in changes:
-        print(change)
-    if args.check and changes:
-        return 1
-    return 0
-
-
-if __name__ == "__main__":  # pragma: no cover
-    sys.exit(main())

tests/component_tests/lvgl/config/keyboard_no_label.yaml

@@ -1,32 +0,0 @@
-esphome:
-  name: test-keyboard-no-label
-
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-spi:
-  - id: spi_bus
-    clk_pin: GPIO18
-    mosi_pin: GPIO23
-
-display:
-  - platform: mipi_spi
-    spi_id: spi_bus
-    model: st7789v
-    id: tft_display
-    dimensions:
-      width: 240
-      height: 320
-    cs_pin: GPIO22
-    dc_pin: GPIO21
-    auto_clear_enabled: false
-    invert_colors: false
-    update_interval: never
-
-lvgl:
-  displays: tft_display
-  widgets:
-    - keyboard:
-        id: keyboard_widget

tests/component_tests/lvgl/config/qrcode_no_label.yaml

@@ -1,34 +0,0 @@
-esphome:
-  name: test-qrcode-no-label
-
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-spi:
-  - id: spi_bus
-    clk_pin: GPIO18
-    mosi_pin: GPIO23
-
-display:
-  - platform: mipi_spi
-    spi_id: spi_bus
-    model: st7789v
-    id: tft_display
-    dimensions:
-      width: 240
-      height: 320
-    cs_pin: GPIO22
-    dc_pin: GPIO21
-    auto_clear_enabled: false
-    invert_colors: false
-    update_interval: never
-
-lvgl:
-  displays: tft_display
-  widgets:
-    - qrcode:
-        id: qr_widget
-        size: 100
-        text: "esphome.io"

tests/component_tests/lvgl/config/tabview_no_label.yaml

@@ -1,35 +0,0 @@
-esphome:
-  name: test-tabview-no-label
-
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-spi:
-  - id: spi_bus
-    clk_pin: GPIO18
-    mosi_pin: GPIO23
-
-display:
-  - platform: mipi_spi
-    spi_id: spi_bus
-    model: st7789v
-    id: tft_display
-    dimensions:
-      width: 240
-      height: 320
-    cs_pin: GPIO22
-    dc_pin: GPIO21
-    auto_clear_enabled: false
-    invert_colors: false
-    update_interval: never
-
-lvgl:
-  displays: tft_display
-  widgets:
-    - tabview:
-        id: tabview_widget
-        tabs:
-          - name: "Tab 1"
-            id: tab_1

tests/component_tests/lvgl/test_widget_label_dependency.py

@@ -1,32 +0,0 @@
-"""Widgets whose LVGL C implementation creates or references labels
-internally (tab titles, key legends, the QR canvas fallback) must declare
-the label dependency in ``get_uses()``. Otherwise a config that contains
-no ``label`` widget of its own compiles LVGL without ``LV_USE_LABEL`` and
-fails at C compile time with undefined ``lv_label_*`` symbols.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from pathlib import Path
-
-import pytest
-
-from esphome.components.lvgl import defines as df
-
-
-@pytest.mark.parametrize(
-    "yaml_file",
-    [
-        "qrcode_no_label.yaml",
-        "keyboard_no_label.yaml",
-        "tabview_no_label.yaml",
-    ],
-)
-def test_label_less_config_enables_lv_use_label(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
-    yaml_file: str,
-) -> None:
-    generate_main(component_config_path(yaml_file))
-    assert "LV_USE_LABEL" in df.get_defines()

tests/components/api/test_proto_mac_varint.cpp

@@ -59,7 +59,7 @@ static void verify_mac(uint64_t mac, size_t expected_bytes) {
 #ifdef ESPHOME_DEBUG_API
   uint8_t *proto_debug_end_ = api_buf.data() + api_buf.size();
 #endif
-  ProtoEncode::encode_varint_raw_48bit(pos PROTO_ENCODE_DEBUG_ARG, mac);
+  pos = ProtoEncode::encode_varint_raw_48bit(pos PROTO_ENCODE_DEBUG_ARG, mac);
   size_t new_len = pos - api_buf.data();
 
   EXPECT_EQ(new_len, expected_bytes) << "mac=0x" << std::hex << mac << std::dec;

tests/components/atm90e32/__init__.py

@@ -1,5 +0,0 @@
-from tests.testing_helpers import ComponentManifestOverride
-
-
-def override_manifest(manifest: ComponentManifestOverride) -> None:
-    manifest.dependencies = manifest.dependencies + ["sensor", "spi"]

tests/components/atm90e32/offset_register_verification_test.cpp

@@ -1,62 +0,0 @@
-#include <gtest/gtest.h>
-
-#include "esphome/components/atm90e32/atm90e32.h"
-
-namespace esphome::atm90e32::testing {
-
-TEST(ATM90E32OffsetRegisterVerification, AcceptsExactSignedReadback) {
-  EXPECT_TRUE(offset_register_value_matches(0x007B, 123));
-  EXPECT_TRUE(offset_register_value_matches(0xFF85, -123));
-}
-
-TEST(ATM90E32OffsetRegisterVerification, RejectsMismatchedReadback) {
-  EXPECT_FALSE(offset_register_value_matches(0x007C, 123));
-  EXPECT_FALSE(offset_register_value_matches(0xFF84, -123));
-}
-
-TEST(ATM90E32OffsetRestoreState, ReportsVerifiedStoredValuesAsRestored) {
-  const auto state = resolve_offset_restore_state(true, true, false);
-
-  EXPECT_TRUE(state.restored);
-  EXPECT_TRUE(state.values_verified);
-}
-
-TEST(ATM90E32OffsetRestoreState, ReportsVerifiedConfigFallbackAsNotRestored) {
-  const auto state = resolve_offset_restore_state(true, false, true);
-
-  EXPECT_FALSE(state.restored);
-  EXPECT_TRUE(state.values_verified);
-}
-
-TEST(ATM90E32OffsetRestoreState, ReportsFailedConfigFallbackAsUnverified) {
-  const auto state = resolve_offset_restore_state(true, false, false);
-
-  EXPECT_FALSE(state.restored);
-  EXPECT_FALSE(state.values_verified);
-}
-
-TEST(ATM90E32OffsetRestoreState, ReportsConfigWithoutStoredValuesAsNotRestored) {
-  const auto state = resolve_offset_restore_state(false, true, false);
-
-  EXPECT_FALSE(state.restored);
-  EXPECT_TRUE(state.values_verified);
-}
-
-TEST(ATM90E32OffsetPersistence, RollsBackStoredValuesOrZeroSentinel) {
-  const OffsetCalibration previous[3]{{1, -1}, {2, -2}, {3, -3}};
-  OffsetCalibration rollback[3]{};
-
-  prepare_offset_rollback(previous, true, rollback);
-  for (uint8_t phase = 0; phase < 3; phase++) {
-    EXPECT_EQ(rollback[phase].first_offset, previous[phase].first_offset);
-    EXPECT_EQ(rollback[phase].second_offset, previous[phase].second_offset);
-  }
-
-  prepare_offset_rollback(previous, false, rollback);
-  for (const auto &phase : rollback) {
-    EXPECT_EQ(phase.first_offset, 0);
-    EXPECT_EQ(phase.second_offset, 0);
-  }
-}
-
-}  // namespace esphome::atm90e32::testing

tests/components/tuya/test-no-network.bk72xx-ard.yaml

@@ -1,29 +0,0 @@
-# Tuya without any network component (no wifi/ethernet/api), as used on
-# serial-only or BLE-only Tuya MCU boards. Regression test for
-# https://github.com/esphome/esphome/issues/18942
-substitutions:
-  status_pin: P6
-
-packages:
-  uart: !include ../../test_build_components/common/uart/bk72xx-ard.yaml
-
-tuya:
-  status_pin: ${status_pin}
-
-binary_sensor:
-  - platform: tuya
-    id: tuya_presence
-    sensor_datapoint: 101
-
-sensor:
-  - platform: tuya
-    id: tuya_light_intensity
-    sensor_datapoint: 103
-
-number:
-  - platform: tuya
-    id: tuya_far_detection
-    number_datapoint: 109
-    min_value: 0
-    max_value: 600
-    step: 1

tests/integration/fixtures/api_empty_message_roundtrip.yaml

@@ -0,0 +1,11 @@
+esphome:
+  name: api-empty-message-test
+host:
+api:
+logger:
+  level: DEBUG
+
+switch:
+  - platform: template
+    name: "Empty Message Switch"
+    optimistic: true

tests/integration/fixtures/api_encode_boundaries.yaml

@@ -0,0 +1,58 @@
+esphome:
+  name: api-encode-boundaries-test
+  # Top-level area fills DeviceInfoResponse.suggested_area (field 16, a two-byte tag)
+  area:
+    id: kitchen_area
+    name: Kitchen
+  on_boot:
+    - sensor.template.publish:
+        id: zero_then_value
+        state: 0.0
+
+host:
+api:
+logger:
+  level: DEBUG
+
+sensor:
+  - platform: template
+    name: "Zero Then Value"
+    id: zero_then_value
+    # Negative int32 takes the ten byte varint path
+    accuracy_decimals: -2
+    update_interval: never
+
+text_sensor:
+  - platform: template
+    name: "Long Text"
+    id: long_text
+    update_interval: never
+
+number:
+  - platform: template
+    name: "Negative Number"
+    optimistic: true
+    min_value: -1000
+    max_value: 1000
+    step: 0.5
+    initial_value: -123.5
+
+select:
+  - platform: template
+    name: "Long Option Select"
+    optimistic: true
+    options:
+      - short
+      - "option-with-a-name-long-enough-that-its-length-prefix-needs-two-varint-bytes-when-the-list-entities-response-is-encoded-xxxxxxxxxx"
+    initial_option: short
+
+button:
+  - platform: template
+    name: "Publish Values"
+    on_press:
+      - sensor.template.publish:
+          id: zero_then_value
+          state: 12.5
+      - text_sensor.template.publish:
+          id: long_text
+          state: !lambda return std::string(200, 'y');

tests/integration/state_utils.py

@@ -57,6 +57,46 @@ async def wait_for_state(
     return await asyncio.wait_for(future, timeout=timeout)
 
 
+class StateWaiter:
+    """Route one state subscription to any number of predicate waits."""
+
+    def __init__(self) -> None:
+        self._waiters: list[
+            tuple[Callable[[EntityState], bool], asyncio.Future[EntityState]]
+        ] = []
+
+    def on_state(self, state: EntityState) -> None:
+        for predicate, future in self._waiters:
+            if future.done():
+                continue
+            try:
+                matched = predicate(state)
+            except Exception as exc:  # noqa: BLE001  the wait re-raises it, the callback must not die
+                future.set_exception(exc)
+                continue
+            if matched:
+                future.set_result(state)
+
+    async def expect(
+        self,
+        predicate: Callable[[EntityState], bool],
+        timeout: float = 5.0,
+        label: str | None = None,
+    ) -> EntityState:
+        """Wait for the next state matching ``predicate``; states seen before this call do not count."""
+        entry = (predicate, asyncio.get_running_loop().create_future())
+        self._waiters.append(entry)
+        try:
+            async with asyncio.timeout(timeout):
+                return await entry[1]
+        except TimeoutError:
+            raise TimeoutError(
+                f"no state matched {label or predicate} within {timeout}s"
+            ) from None
+        finally:
+            self._waiters.remove(entry)
+
+
 def find_entity[T: EntityInfo](
     entities: list[EntityInfo],
     object_id_substring: str,

tests/integration/test_api_empty_message_roundtrip.py

@@ -0,0 +1,37 @@
+"""Messages without fields go through the shared ProtoMessage entry points on both directions."""
+
+from __future__ import annotations
+
+from aioesphomeapi import api_pb2
+import pytest
+
+from .raw_api_client import MESSAGE_TYPE_OF, RawApiClient
+from .types import RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_api_empty_message_roundtrip(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    unused_tcp_port: int,
+) -> None:
+    async with run_compiled(yaml_config), RawApiClient(unused_tcp_port) as client:
+        await client.connect()
+
+        # Field free request and reply on the plain send path
+        await client.send_message(api_pb2.PingRequest())
+        await client.read_until_frame(MESSAGE_TYPE_OF[api_pb2.PingResponse])
+
+        # Field free request answered by a message with fields, and a list that ends with
+        # the field free ListEntitiesDoneResponse through the batching path
+        await client.send_message(api_pb2.DeviceInfoRequest())
+        await client.read_until_frame(MESSAGE_TYPE_OF[api_pb2.DeviceInfoResponse])
+        await client.send_message(api_pb2.ListEntitiesRequest())
+        await client.read_until_frame(MESSAGE_TYPE_OF[api_pb2.ListEntitiesDoneResponse])
+        assert (
+            client.frame_counts[MESSAGE_TYPE_OF[api_pb2.ListEntitiesSwitchResponse]]
+            == 1
+        )
+
+        await client.send_message(api_pb2.DisconnectRequest())
+        await client.read_until_frame(MESSAGE_TYPE_OF[api_pb2.DisconnectResponse])

tests/integration/test_api_encode_boundaries.py

@@ -0,0 +1,78 @@
+"""Encode paths at their branch boundaries: zero skipped float, fixed32 state, negative int32,
+length prefixes of two varint bytes and two byte field tags."""
+
+from __future__ import annotations
+
+import asyncio
+
+from aioesphomeapi import (
+    NumberState,
+    SelectInfo,
+    SensorInfo,
+    SensorState,
+    TextSensorState,
+)
+import pytest
+
+from .state_utils import InitialStateHelper, StateWaiter, require_entity
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+LONG_OPTION = (
+    "option-with-a-name-long-enough-that-its-length-prefix-needs-two-varint-bytes-"
+    "when-the-list-entities-response-is-encoded-xxxxxxxxxx"
+)
+
+
+@pytest.mark.asyncio
+async def test_api_encode_boundaries(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    async with run_compiled(yaml_config), api_client_connected() as client:
+        device_info, (entities, _) = await asyncio.gather(
+            client.device_info(), client.list_entities_services()
+        )
+        assert device_info.suggested_area == "Kitchen"
+
+        sensor = require_entity(entities, "zero_then_value", SensorInfo)
+        assert sensor.accuracy_decimals == -2
+        select = require_entity(entities, "long_option_select", SelectInfo)
+        assert len(LONG_OPTION) >= 128
+        assert select.options == ["short", LONG_OPTION]
+        text = require_entity(entities, "long_text")
+        number = require_entity(entities, "negative_number")
+        button = require_entity(entities, "publish_values")
+
+        initial = InitialStateHelper(entities)
+        waiter = StateWaiter()
+        client.subscribe_states(initial.on_state_wrapper(waiter.on_state))
+        await initial.wait_for_initial_states()
+
+        # A float of exactly zero is skipped on the wire and must still read as 0.0, not missing
+        first = initial.initial_states[sensor.key]
+        assert isinstance(first, SensorState)
+        assert first.state == 0.0 and not first.missing_state
+        first_number = initial.initial_states[number.key]
+        assert isinstance(first_number, NumberState)
+        assert first_number.state == -123.5
+
+        client.button_command(button.key)
+        await asyncio.gather(
+            waiter.expect(
+                lambda s: (
+                    isinstance(s, SensorState)
+                    and s.key == sensor.key
+                    and s.state == 12.5
+                ),
+                label="sensor 12.5",
+            ),
+            waiter.expect(
+                lambda s: (
+                    isinstance(s, TextSensorState)
+                    and s.key == text.key
+                    and s.state == "y" * 200
+                ),
+                label="text 200 x y",
+            ),
+        )

tests/script/test_sync_dependency_versions.py

@@ -1,219 +0,0 @@
-"""Unit tests for script/sync_dependency_versions.py."""
-
-from pathlib import Path
-import subprocess
-import sys
-
-import pytest
-import yamlrocks
-
-sys.path.insert(0, str((Path(__file__).parent / ".." / ".." / "script").resolve()))
-
-import sync_dependency_versions as sync_mod  # noqa: E402
-
-PRECOMMIT = """\
-# See https://pre-commit.com for more information
-repos:
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    # Ruff version.
-    rev: v0.1.0
-    hooks:
-      - id: ruff
-  - repo: https://github.com/PyCQA/flake8
-    rev: 7.0.0
-    hooks:
-      - id: flake8
-  - repo: https://github.com/asottile/pyupgrade
-    rev: v3.0.0
-    hooks:
-      - id: pyupgrade
-  - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v13.0.1
-    hooks:
-      - id: clang-format
-  - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.0.0
-    hooks:
-      - id: yamllint
-  - repo: local
-    hooks:
-      - id: pylint
-"""
-
-REQ_TEST = """\
-pylint==4.0.8
-flake8==7.1.0
-ruff==0.2.0  # comment
-pyupgrade==3.0.0
-"""
-
-REQ_DEV = """\
-clang-format==13.0.1
-yamllint==1.0.0
-"""
-
-RUFF_REPO = "https://github.com/astral-sh/ruff-pre-commit"
-DUPLICATE_RUFF_BLOCK = f"  - repo: {RUFF_REPO}\n    rev: v0.3.0\n    hooks: []\n"
-
-EXPECTED_DRIFT = ["ruff: 0.1.0 -> 0.2.0", "flake8: 7.0.0 -> 7.1.0"]
-EXPECTED_PRECOMMIT = PRECOMMIT.replace("rev: v0.1.0", "rev: v0.2.0").replace(
-    "rev: 7.0.0", "rev: 7.1.0"
-)
-
-
-@pytest.fixture
-def root(tmp_path: Path) -> Path:
-    """A fake checkout where ruff (v-prefixed) and flake8 (bare) have drifted."""
-    (tmp_path / ".pre-commit-config.yaml").write_text(PRECOMMIT)
-    (tmp_path / "requirements_test.txt").write_text(REQ_TEST)
-    (tmp_path / "requirements_dev.txt").write_text(REQ_DEV)
-    return tmp_path
-
-
-def _load(text: str) -> object:
-    return yamlrocks.loads(text.encode(), option=yamlrocks.OPT_ROUND_TRIP)
-
-
-@pytest.mark.parametrize(
-    ("requirements", "expected"),
-    [
-        ("prek==0.5.1  # comment\n", "0.5.1"),
-        ("Prek==0.5.1\n", "0.5.1"),
-        ("other==1.0\nprek==0.5.1\n", "0.5.1"),
-        ("prek>=0.5.1\n", None),
-        ("prek-extra==0.5.1\n", None),
-        ("", None),
-    ],
-)
-def test_read_requirement_version(requirements: str, expected: str | None) -> None:
-    assert sync_mod.read_requirement_version(requirements, "prek") == expected
-
-
-def test_find_repo_entry() -> None:
-    entry = sync_mod.find_repo_entry(_load(PRECOMMIT), RUFF_REPO)
-    assert entry["rev"] == "v0.1.0"
-
-
-@pytest.mark.parametrize(
-    ("text", "message"),
-    [
-        ("hooks: []\n", "missing key 'repos'"),
-        ("repos:\n  - rev: 1.0.0\n", "missing key 'repo'"),
-        (PRECOMMIT + DUPLICATE_RUFF_BLOCK, "found 2"),
-        ("repos:\n  - repo: other\n    rev: 1.0.0\n", "found 0"),
-    ],
-)
-def test_find_repo_entry_errors(text: str, message: str) -> None:
-    with pytest.raises(sync_mod.SyncError, match=message):
-        sync_mod.find_repo_entry(_load(text), RUFF_REPO)
-
-
-@pytest.mark.parametrize(
-    ("rev", "expected"),
-    [("v0.1.0", ("v", "0.1.0")), ("7.0.0", ("", "7.0.0")), ("'1.0'", ("", "1.0"))],
-)
-def test_current_rev(rev: str, expected: tuple[str, str]) -> None:
-    doc = _load(f"repos:\n  - repo: {RUFF_REPO}\n    rev: {rev}\n")
-    assert sync_mod.current_rev(doc["repos"][0], RUFF_REPO) == expected
-
-
-@pytest.mark.parametrize(
-    ("block", "message"),
-    [("    hooks: []\n", "has no rev"), ("    rev: 1.0\n", "not a string: 1.0")],
-)
-def test_current_rev_errors(block: str, message: str) -> None:
-    doc = _load(f"repos:\n  - repo: {RUFF_REPO}\n{block}")
-    with pytest.raises(sync_mod.SyncError, match=message):
-        sync_mod.current_rev(doc["repos"][0], RUFF_REPO)
-
-
-def test_sync_reports_without_writing(root: Path) -> None:
-    assert sync_mod.sync(root, write=False) == EXPECTED_DRIFT
-    assert (root / ".pre-commit-config.yaml").read_text() == PRECOMMIT
-
-
-def test_sync_writes_keeps_layout_and_is_idempotent(root: Path) -> None:
-    assert sync_mod.sync(root, write=True) == EXPECTED_DRIFT
-    assert (root / ".pre-commit-config.yaml").read_text() == EXPECTED_PRECOMMIT
-    assert sync_mod.sync(root, write=True) == []
-
-
-def test_sync_does_not_touch_a_config_that_matches(root: Path) -> None:
-    (root / ".pre-commit-config.yaml").write_text(EXPECTED_PRECOMMIT)
-    before = (root / ".pre-commit-config.yaml").stat().st_mtime_ns
-    assert sync_mod.sync(root, write=True) == []
-    assert (root / ".pre-commit-config.yaml").stat().st_mtime_ns == before
-
-
-def test_sync_missing_requirement_pin(root: Path) -> None:
-    (root / "requirements_dev.txt").write_text("")
-    with pytest.raises(sync_mod.SyncError, match="no 'clang-format==' pin"):
-        sync_mod.sync(root, write=True)
-
-
-def test_sync_propagates_config_errors(root: Path) -> None:
-    (root / ".pre-commit-config.yaml").write_text(PRECOMMIT + DUPLICATE_RUFF_BLOCK)
-    with pytest.raises(sync_mod.SyncError, match="found 2"):
-        sync_mod.sync(root, write=True)
-
-
-def test_main_check_reports_drift(
-    root: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    assert sync_mod.main(["--check", "--root", str(root)]) == 1
-    assert capsys.readouterr().out.splitlines() == EXPECTED_DRIFT
-    assert (root / ".pre-commit-config.yaml").read_text() == PRECOMMIT
-
-
-def test_main_writes_then_check_is_clean(
-    root: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    assert sync_mod.main(["--root", str(root)]) == 0
-    assert capsys.readouterr().out.splitlines() == EXPECTED_DRIFT
-    assert sync_mod.main(["--check", "--root", str(root)]) == 0
-    assert capsys.readouterr().out == ""
-
-
-def test_main_reports_sync_error(
-    root: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    (root / "requirements_dev.txt").write_text("")
-    assert sync_mod.main(["--root", str(root)]) == 1
-    assert (
-        "error: requirements_dev.txt: no 'clang-format==' pin"
-        in capsys.readouterr().err
-    )
-
-
-def test_main_defaults_to_repo_root(monkeypatch: pytest.MonkeyPatch) -> None:
-    seen: dict[str, object] = {}
-
-    def fake_sync(root: Path, *, write: bool) -> list[str]:
-        seen["root"] = root
-        seen["write"] = write
-        return []
-
-    monkeypatch.setattr(sync_mod, "sync", fake_sync)
-    assert sync_mod.main([]) == 0
-    assert seen == {"root": sync_mod.REPO_ROOT, "write": True}
-
-
-def test_repository_is_in_sync() -> None:
-    """The real checkout must match; a failure here means a rev has drifted.
-
-    Also proves every SYNC_TARGETS entry still resolves in the real files.
-    """
-    assert sync_mod.sync(sync_mod.REPO_ROOT, write=False) == []
-
-
-def test_cli_entry_point(root: Path) -> None:
-    """Run the script the way the workflow does, as a subprocess."""
-    script = Path(sync_mod.__file__)
-    result = subprocess.run(
-        [sys.executable, str(script), "--check", "--root", str(root)],
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    assert result.returncode == 1
-    assert result.stdout.splitlines() == EXPECTED_DRIFT

tests/unit_tests/components/api/test_api_proto.py

@@ -194,17 +194,17 @@ def test_superseded_device_info_fields_still_declared_in_header() -> None:
 
 def test_superseded_device_info_fields_still_encoded_and_sized() -> None:
     """Each superseded field must still be touched by DeviceInfoResponse's
-    generated encode() and calculate_size(), i.e. it is still put on the wire.
+    generated encode_msg() and calc_size_msg(), i.e. it is still put on the wire.
     """
-    encode_body = _extract_function_body(CPP_TEXT, "DeviceInfoResponse::encode")
-    size_body = _extract_function_body(CPP_TEXT, "DeviceInfoResponse::calculate_size")
+    encode_body = _extract_function_body(CPP_TEXT, "DeviceInfoResponse::encode_msg")
+    size_body = _extract_function_body(CPP_TEXT, "DeviceInfoResponse::calc_size_msg")
     for field_name in SUPERSEDED_FIELDS:
-        assert f"this->{field_name}" in encode_body, (
-            f"DeviceInfoResponse::encode() no longer references {field_name}. "
+        assert f"msg.{field_name}" in encode_body, (
+            f"DeviceInfoResponse::encode_msg() no longer references {field_name}. "
             f"{DEPRECATED_FIELD_TRAP}"
         )
-        assert f"this->{field_name}" in size_body, (
-            f"DeviceInfoResponse::calculate_size() no longer references "
+        assert f"msg.{field_name}" in size_body, (
+            f"DeviceInfoResponse::calc_size_msg() no longer references "
             f"{field_name}. {DEPRECATED_FIELD_TRAP}"
         )
 
@@ -380,3 +380,13 @@ def test_api_version_minor_is_at_least_15() -> None:
         "clients to see api_version >= 1.15 in HelloResponse before they will "
         "ever request it."
     )
+
+
+def test_generated_encode_calls_keep_the_cursor() -> None:
+    """No generated ProtoEncode call may drop the returned cursor."""
+    dropped = [
+        line
+        for line in CPP_TEXT.splitlines()
+        if "ProtoEncode::" in line and "pos = ProtoEncode::" not in line
+    ]
+    assert not dropped, dropped[:5]

tests/unit_tests/components/api/test_api_protobuf_generator.py

@@ -15,9 +15,11 @@ import pytest
 
 sys.path.insert(0, str(Path(__file__).parents[4] / "script" / "api_protobuf"))
 
+import aioesphomeapi.api_options_pb2 as pb  # noqa: E402
 from api_protobuf import (  # noqa: E402
     MAX_MESSAGE_ID,
     _make_ifdef_line,
+    create_field_type_info,
     get_varint64_ifdef,
     validate_message_id,
 )
@@ -43,7 +45,14 @@ UINT64 = descriptor_pb2.FieldDescriptorProto.TYPE_UINT64
 INT64 = descriptor_pb2.FieldDescriptorProto.TYPE_INT64
 SINT64 = descriptor_pb2.FieldDescriptorProto.TYPE_SINT64
 UINT32 = descriptor_pb2.FieldDescriptorProto.TYPE_UINT32
+INT32 = descriptor_pb2.FieldDescriptorProto.TYPE_INT32
+SINT32 = descriptor_pb2.FieldDescriptorProto.TYPE_SINT32
 FIXED64 = descriptor_pb2.FieldDescriptorProto.TYPE_FIXED64
+FIXED32 = descriptor_pb2.FieldDescriptorProto.TYPE_FIXED32
+FLOAT = descriptor_pb2.FieldDescriptorProto.TYPE_FLOAT
+BOOL = descriptor_pb2.FieldDescriptorProto.TYPE_BOOL
+STRING = descriptor_pb2.FieldDescriptorProto.TYPE_STRING
+BYTES = descriptor_pb2.FieldDescriptorProto.TYPE_BYTES
 
 
 def test_no_varint64_fields() -> None:
@@ -107,3 +116,69 @@ def test_message_id_at_maximum_is_accepted() -> None:
 def test_message_id_above_maximum_is_rejected() -> None:
     with pytest.raises(ValueError, match="exceeds the plaintext"):
         validate_message_id(MAX_MESSAGE_ID + 1, "TooBigMessage")
+
+
+def _field(
+    field_type: int, number: int = 1, *, force: bool = False, repeated: bool = False
+) -> descriptor_pb2.FieldDescriptorProto:
+    field = descriptor_pb2.FieldDescriptorProto(
+        name="value", number=number, type=field_type
+    )
+    if repeated:
+        field.label = descriptor_pb2.FieldDescriptorProto.LABEL_REPEATED
+    if force:
+        field.options.Extensions[pb.force] = True
+    return field
+
+
+def _encode_field(
+    field_type: int, number: int = 1, force: bool = False, repeated: bool = False
+) -> str:
+    """Return the encode statement the generator emits for one encode-only field."""
+    field = _field(field_type, number, force=force, repeated=repeated)
+    return create_field_type_info(
+        field, needs_decode=False, needs_encode=True
+    ).encode_content
+
+
+SCALAR_TYPES = [
+    BOOL,
+    UINT32,
+    INT32,
+    UINT64,
+    INT64,
+    SINT32,
+    FLOAT,
+    FIXED32,
+    STRING,
+    BYTES,
+]
+
+
+@pytest.mark.parametrize("field_type", SCALAR_TYPES)
+def test_forced_fields_use_the_force_overload_or_raw_writes(field_type: int) -> None:
+    content = _encode_field(field_type, force=True)
+    assert (
+        "_force(" in content
+        or "write_raw_byte(" in content
+        or "write_tag_and_fixed32(" in content
+    ), content
+
+
+@pytest.mark.parametrize("field_type", [FLOAT, FIXED32])
+def test_single_byte_tag_fixed32_shares_the_outlined_writer(field_type: int) -> None:
+    unconditional = _encode_field(field_type, force=True)
+    assert unconditional.count("write_tag_and_fixed32(pos, 13,") == 1, unconditional
+    guarded = _encode_field(field_type, force=False)
+    assert guarded.startswith("if ("), guarded
+    assert "[[likely]]" in guarded
+    assert "write_tag_and_fixed32(pos, 13," in guarded
+
+
+@pytest.mark.parametrize("field_type", [FLOAT, FIXED32])
+def test_multi_byte_tag_fixed32_falls_back_to_the_generic_helper(
+    field_type: int,
+) -> None:
+    content = _encode_field(field_type, number=16)
+    assert "write_tag_and_fixed32" not in content, content
+    assert content.startswith("pos = ProtoEncode::encode_"), content

tests/unit_tests/components/udp/test_init.py

@@ -1,37 +0,0 @@
-"""Tests for the udp component configuration schema."""
-
-from __future__ import annotations
-
-import pytest
-
-from esphome.components import udp
-from esphome.components.packet_transport import (
-    CONF_BINARY_SENSORS,
-    CONF_ENCRYPTION,
-    CONF_PING_PONG_ENABLE,
-    CONF_PROVIDERS,
-    CONF_ROLLING_CODE_ENABLE,
-    CONF_SENSORS,
-)
-import esphome.config_validation as cv
-
-
-@pytest.mark.parametrize(
-    "option",
-    [
-        CONF_PROVIDERS,
-        CONF_ENCRYPTION,
-        CONF_PING_PONG_ENABLE,
-        CONF_ROLLING_CODE_ENABLE,
-        CONF_SENSORS,
-        CONF_BINARY_SENSORS,
-    ],
-)
-def test_relocated_option_rejected(option: str) -> None:
-    """Options that moved to packet_transport raise a pointing error."""
-    with pytest.raises(cv.Invalid) as exc_info:
-        udp.CONFIG_SCHEMA({option: True})
-    assert (
-        f"The '{option}' option should now be configured in the 'packet_transport' component"
-        in str(exc_info.value)
-    )

tests/unit_tests/test_platformio_library.py

@@ -7,7 +7,6 @@ exercised in their own test modules)."""
 import json
 import logging
 from pathlib import Path
-from unittest.mock import Mock
 
 import pytest
 
@@ -229,24 +228,6 @@ def test_resolve_registry_version_raises_without_pkg_file(monkeypatch):
         _resolve_registry_version("owner", "pkg", set())
 
 
-def test_make_registry_client_skips_private_package_probe(monkeypatch):
-    """Our client answers the probe locally without patching PlatformIO's class."""
-    from platformio.account.client import AccountClient
-    from platformio.registry.client import RegistryClient
-
-    pio_probe = RegistryClient.__dict__["allowed_private_packages"]
-    monkeypatch.setattr(
-        AccountClient,
-        "get_account_info",
-        Mock(side_effect=AssertionError("account probe must not run")),
-    )
-
-    client = lib._make_registry_client().get_registry_client_instance()
-
-    assert client.allowed_private_packages() is False
-    assert RegistryClient.__dict__["allowed_private_packages"] is pio_probe
-
-
 def _patch_registry_resolve(monkeypatch: pytest.MonkeyPatch) -> None:
     """Stub the registry lookup so tests never touch the network."""
     monkeypatch.setattr(

tests/unit_tests/test_platformio_prefetch.py

@@ -1225,20 +1225,6 @@ def test_main_runs_prefetch(tmp_path: Path) -> None:
     mock_prefetch.assert_called_once_with(tmp_path, "testenv")
 
 
-def test_main_skips_private_package_probe_before_prefetch(tmp_path: Path) -> None:
-    """The registry probe patch is applied before any package manager runs."""
-    order: list[str] = []
-    with (
-        patch.object(pf, "_prefetch", side_effect=lambda *_: order.append("prefetch")),
-        patch(
-            "esphome.platformio.runner.patch_registry_private_packages",
-            side_effect=lambda: order.append("patch"),
-        ),
-    ):
-        assert pf.main([str(tmp_path), "testenv"]) == 0
-    assert order == ["patch", "prefetch"]
-
-
 def test_main_bad_argv_is_a_distinct_exit(
     caplog: pytest.LogCaptureFixture,
 ) -> None:

tests/unit_tests/test_platformio_runner.py

@@ -6,9 +6,7 @@ from collections.abc import Callable
 import io
 import sys
 from types import ModuleType
-from unittest.mock import Mock
 
-from platformio.registry.client import RegistryClient
 import pytest
 
 from esphome.platformio import runner
@@ -32,7 +30,6 @@ def _prepare_main(
     monkeypatch.setattr(sys, "stderr", stream)
     monkeypatch.setattr(runner, "patch_structhash", lambda: None)
     monkeypatch.setattr(runner, "patch_file_downloader", lambda: None)
-    monkeypatch.setattr(runner, "patch_registry_private_packages", lambda: None)
 
     platformio = ModuleType("platformio")
     platformio_main = ModuleType("platformio.__main__")
@@ -94,40 +91,3 @@ def test_main_still_filters_a_drained_partial_line(
 
     assert runner.main() == 0
     assert buf.getvalue() == b""
-
-
-def test_main_applies_registry_private_packages_patch(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """The probe is patched before PlatformIO runs."""
-    order: list[str] = []
-    _prepare_main(monkeypatch, lambda: order.append("pio") or 0)
-    monkeypatch.setattr(
-        runner, "patch_registry_private_packages", lambda: order.append("patch")
-    )
-
-    assert runner.main() == 0
-    assert order == ["patch", "pio"]
-
-
-# Snapshot PlatformIO's own probe at import, before any test can patch it
-_PIO_PROBE = RegistryClient.__dict__["allowed_private_packages"]
-
-
-def test_patch_registry_private_packages_skips_account_probe(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """Answers False without touching the account client."""
-    from platformio.account.client import AccountClient
-
-    monkeypatch.setattr(RegistryClient, "allowed_private_packages", _PIO_PROBE)
-    monkeypatch.setattr(
-        AccountClient,
-        "get_account_info",
-        Mock(side_effect=AssertionError("account probe must not run")),
-    )
-
-    runner.patch_registry_private_packages()
-
-    assert RegistryClient.allowed_private_packages() is False
-    assert RegistryClient().allowed_private_packages() is False