[rtttl] Use a user provided default constructor for Rtttl

2026-10-15 02:32:49 +00:00 · 2026-09-12 05:35:56 -05:00
1422 changed files with 26821 additions and 47296 deletions
@@ -1,116 +0,0 @@
---
-name: code-review
-description: Review guidance for ESPHome pull requests. Use this when reviewing a pull request that changes ESPHome Python, C++, or component code, to check it against the project's coding conventions, embedded-systems memory rules, testing requirements, and breaking-change policy.
---
-
-# Reviewing ESPHome pull requests
-
-ESPHome parses YAML into C++ firmware for memory-constrained microcontrollers
-(ESP32, ESP8266, RP2040, LibreTiny). Review changes with that in mind: RAM and
-flash are scarce, and code runs unattended for months.
-
-`AGENTS.md` in the repository root is the full contributor guide and the
-authority when it disagrees with this summary. The developer documentation at
-https://developers.esphome.io explains the component lifecycle and the reasoning
-behind these rules. This skill lists the concrete things worth flagging in a
-review; read `AGENTS.md` for the detail behind any item.
-
-Only raise findings that the diff actually introduces or changes. Do not ask for
-drive-by cleanup of pre-existing code the PR did not touch.
-
-## Memory and embedded constraints (highest value)
-
-Heap allocation after `setup()` is treated as a reliability bug, not a
-performance nit, because it fragments a small shared heap. Flag:
-
- New heap allocation on a hot path or after setup that could be avoided.
- `std::vector` where the size is known at compile time (use `std::array`, or
-  `StaticVector<T, N>` when a `push_back` API is needed) or fixed at runtime
-  init (use `FixedVector<T>`).
- Listener / child-entity registration lists stored as `std::vector`; these have
-  a compile-time-known count and should use `cg.slot_counter()` plus
-  `StaticVector`.
- `std::vector<uint8_t>` for a byte buffer that never grows: prefer
-  `std::unique_ptr<uint8_t[]>` or `std::array`.
- `std::map` / `std::set` / `std::unordered_map` for small datasets (1-16
-  elements): a `std::vector` of a small struct with linear search is lighter.
- `std::deque` anywhere: it allocates 512-byte blocks and should be avoided.
- `std::string` storing a value set once from config: prefer `StringRef` (the
-  literal already lives in flash).
- `std::string` / `std::to_string` / string-returning helpers on hot paths where
-  a buffer or view API exists.
-
-## C++ conventions
-
- Include what you use: a file referencing a symbol must include the header that
-  declares it, even if it currently arrives transitively. New or changed uses of
-  a symbol need the matching include.
- Prefix all member access with `this->`.
- Naming: `lower_snake_case` for functions/methods/variables, `UpperCamelCase`
-  for classes/structs/enums, `UPPER_SNAKE_CASE` for namespace-scope constants,
-  trailing underscore on protected/private fields.
- `enum class` values must be prefixed with the enum name in `UPPER_SNAKE_CASE`
-  (e.g. `UARTFlushResult::UART_FLUSH_RESULT_SUCCESS`). Bare names like `SUCCESS`,
-  `FAIL`, or `OK` collide with SDK macros on some platforms and break the build.
- Prefer `const`/`enum` over `#define`; `#define` is only for conditional
-  compilation and code-generation sizes.
- Never call `millis()` in a `loop()` body; use
-  `App.get_loop_component_start_time()`. A rate-limit gate below ~16 ms (the loop
-  period) does nothing.
- Pick the timing primitive by cadence: gated `loop()` under 250 ms,
-  `set_interval` at 500 ms and above.
- Do not override a base method to return the value it already returns (e.g.
-  `get_setup_priority()` returning `setup_priority::DATA`).
- Wrap string literals passed as printf `%s` args in `LOG_STR_LITERAL()`.
- Required, invariant dependencies should be constructor parameters, not setters.
- Callback registration methods must be templated (`template<typename F>`), not
-  typed as `std::function`, so lightweight forwarders avoid a heap allocation.
- Two-space indent, `using` over `typedef`, wrap at 120 columns.
-
-## Python conventions
-
- Type-annotate every new function signature (params and return), new dataclass
-  fields, and new module-level variables. Import `ConfigType` from
-  `esphome.types`.
- Use the walrus operator to avoid a double lookup, e.g.
-  `if (blah := config.get(CONF_BLAH)) is not None:`.
- Reuse existing validators from `config_validation.py` (`cv.rename_key`,
-  `cv.has_exactly_one_key`, etc.) via `cv.All(...)` instead of hand-rolling.
- `esphome/const.py` is frozen: no new `CONF_` constants there. Define them in
-  the component's own `.py`, or in `esphome/components/const/__init__.py` when
-  shared. The same constant defined in three or more component files fails CI.
- State that must persist during code generation goes in `CORE.data` namespaced
-  under the component `DOMAIN` (a `@dataclass`), not module-level mutable globals.
- Prefer callback-based triggers via `build_callback_automation()`; only use a
-  `Trigger<Ts...>` subclass when the forwarder needs mutable state.
-
-## Testing and coverage
-
- New and changed lines and branches need test coverage, including defensive
-  early-returns, error paths, and no-op guards. A mocked-out function is not
-  covered; exercise the real call path too.
- Component YAML tests live in `tests/components/<component>/`. Never define
-  buses (uart, i2c, spi, modbus) directly in a test file: pull them from
-  `tests/test_build_components/common/` through dict-style `packages:` so CI can
-  group builds. List-style packages or top-level merge keys block grouping.
- Config-only checks use the `validate.*.yaml` prefix; compiled checks use
-  `test.*.yaml`.
-
-## Breaking changes and public API
-
- Base classes under `esphome/core/` and documented config options are public
-  API. Undocumented `public` members of a component are internal.
- A breaking change needs justification, a migration path in the PR description,
-  and a deprecation window where feasible (`ESPDEPRECATED` in C++,
-  `cv.rename_key(..., removed_in=...)` in Python). Changing a codegen-injected
-  lambda signature is not a breaking change.
-
-## Process and PR hygiene
-
- PR titles start with a `[tag]` prefix: the component name (e.g. `[uart] ...`)
-  or `[core]` for shared code.
- Prose in docs, comments, and commit messages should be plain English. Keep
-  inline comments short and only where the code is not self-explanatory; do not
-  restate what the code says.
- Verify the PR fills out `.github/PULL_REQUEST_TEMPLATE.md` and adds
-  `CODEOWNERS` entries for a new component.
@@ -1 +0,0 @@
-../.agents/skills
@@ -31,4 +31,7 @@ RUN \
    platformio settings set enable_telemetry No \
    && platformio settings set check_platformio_interval 1000000

+COPY script/platformio_install_deps.py platformio.ini ./
+RUN ./platformio_install_deps.py platformio.ini --libraries --platforms --tools
+
 WORKDIR /workspaces
@@ -9,29 +9,6 @@ body:
        If you have a feature request or enhancement, please [request them here instead][fr].

        [fr]: https://github.com/orgs/esphome/discussions
-  - type: markdown
-    attributes:
-      value: |
-        ## Use of AI in bug reports
-
-        AI tools are good at carrying out well-defined tasks, but they are not good at troubleshooting.
-        Please do NOT paste an AI-generated wall of text into the issue template - if the AI hasn't solved
-        your problem, its wild guesses are not likely to help.
-
-        Please DO include your own words and observations, compile/boot logs, and
-        especially a minimal reproducible example of your YAML configuration that demonstrates the problem.
-
-        It is however quite acceptable to use AI to translate your *own* report,
-        if you aren't a competent English speaker.
-
-        If you really think it will be useful to include an AI's analysis, preferably wrap it in a `<details>` block which will be collapsed by default.
-
-        If you are using AI to help solve a problem, rather than asking it to speculate about what the problem is,
-        it can be more useful to ask it to create a step-by-step troubleshooting procedure.
-        AI is also useful for generating boilerplate code, such as a minimal reproducible example of your YAML
-        configuration that demonstrates the problem.
-
-        Used properly, AI can be a useful tool to help you solve your problem, but don't let it get in the way.
  - type: textarea
    validations:
      required: true
@@ -42,7 +42,7 @@ runs:

    - name: Build and push to ghcr by digest
      id: build-ghcr
-      uses: docker/build-push-action@c3c9e263c25d99ce0380d002d59b67737d91b0dc # v7.4.0
+      uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
      env:
        DOCKER_BUILD_SUMMARY: false
        DOCKER_BUILD_RECORD_UPLOAD: false
@@ -67,7 +67,7 @@ runs:

    - name: Build and push to dockerhub by digest
      id: build-dockerhub
-      uses: docker/build-push-action@c3c9e263c25d99ce0380d002d59b67737d91b0dc # v7.4.0
+      uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
      env:
        DOCKER_BUILD_SUMMARY: false
        DOCKER_BUILD_RECORD_UPLOAD: false
@@ -1,39 +0,0 @@
-name: Cache Arduino ESP8266
-description: >
-  Resolve the pinned Arduino core and xtensa toolchain versions and cache the
-  native ESP8266 install (~110 MB framework + toolchain; no ccache store, the
-  seed job saves before any compile runs). Exports
-  ESPHOME_ARDUINO8266_PREFIX to the job so every later step installs into
-  the cached path; the Python venv must already be restored. Mirrors
-  cache-esp-idf: only dev-branch pushes write the shared cache, everything
-  else restores.
-runs:
-  using: composite
-  steps:
-    - name: Resolve the native toolchain cache key
-      # Versions are pinned in code, not a hashable file; resolve them so a
-      # bump changes the cache key. Assignment form so errexit catches a
-      # resolver failure.
-      id: version
-      shell: bash
-      run: |
-        # One owner for the install prefix: exported here and referenced by
-        # the cache steps below via env, so the caller's install and the
-        # cached path cannot diverge.
-        echo "ESPHOME_ARDUINO8266_PREFIX=$HOME/.esphome-arduino8266" >> "$GITHUB_ENV"
-        . venv/bin/activate
-        key=$(python -c 'from esphome.components.esp8266 import RECOMMENDED_ARDUINO_FRAMEWORK_VERSION as f; from esphome.arduino8266.framework import TOOLCHAIN_VERSION as t; print(f"{f}-{t}")')
-        [ -n "$key" ] || exit 1
-        echo "key=$key" >> "$GITHUB_OUTPUT"
-    - name: Cache the native toolchain (write on dev)
-      if: github.ref == 'refs/heads/dev'
-      uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
-      with:
-        path: ${{ env.ESPHOME_ARDUINO8266_PREFIX }}
-        key: ${{ runner.os }}-esp8266-native-${{ steps.version.outputs.key }}
-    - name: Restore the native toolchain (off dev)
-      if: github.ref != 'refs/heads/dev'
-      uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
-      with:
-        path: ${{ env.ESPHOME_ARDUINO8266_PREFIX }}
-        key: ${{ runner.os }}-esp8266-native-${{ steps.version.outputs.key }}
@@ -32,7 +32,7 @@ runs:
      # detects the activated venv via ``VIRTUAL_ENV`` so the venv layout
      # downstream jobs rely on is preserved.
      if: steps.cache-venv.outputs.cache-hit != 'true'
-      uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
      with:
        enable-cache: true
        # Pull request saves land in per-PR scopes nothing else can
@@ -1 +0,0 @@
-../.agents/skills
@@ -29,7 +29,7 @@ jobs:
      - name: Set up uv
        # ``--system`` (below) installs into the setup-python interpreter;
        # no venv is created or restored by this workflow.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull-request-only workflow: a save could never be shared and
@@ -12,7 +12,9 @@ on:
      - ".github/workflows/ci-docker.yml"
      - "requirements*.txt"
      - "pyproject.toml"
+      - "platformio.ini"
      - "esphome/idf_component.yml"
+      - "script/platformio_install_deps.py"
      # Core, build pipeline, toolchain, and target-platform changes can change
      # how a toolchain is set up or built, so re-run the per-toolchain compile
      # smoke test when they change.
@@ -65,7 +67,7 @@ jobs:
        with:
          python-version: "3.12"
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0

      - name: Determine tag and whether to push
        id: tag
@@ -157,7 +159,7 @@ jobs:
        with:
          python-version: "3.12"
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0

      - name: Log in to the GitHub container registry
        uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
@@ -49,7 +49,7 @@ jobs:
        # detects the activated venv via ``VIRTUAL_ENV`` so downstream jobs
        # that ``. venv/bin/activate`` see an identical layout.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -102,8 +102,6 @@ jobs:
      device-builder: ${{ steps.determine.outputs.device-builder }}
      esp32-platformio: ${{ steps.determine.outputs.esp32-platformio }}
      esp32-platformio-components: ${{ steps.determine.outputs.esp32-platformio-components }}
-      esp8266-native: ${{ steps.determine.outputs.esp8266-native }}
-      esp8266-native-components: ${{ steps.determine.outputs.esp8266-native-components }}
      changed-components: ${{ steps.determine.outputs.changed-components }}
      changed-components-with-tests: ${{ steps.determine.outputs.changed-components-with-tests }}
      directly-changed-components-with-tests: ${{ steps.determine.outputs.directly-changed-components-with-tests }}
@@ -167,8 +165,6 @@ jobs:
          echo "device-builder=$(echo "$output" | jq -r '.device_builder')" >> $GITHUB_OUTPUT
          echo "esp32-platformio=$(echo "$output" | jq -r '.esp32_platformio')" >> $GITHUB_OUTPUT
          echo "esp32-platformio-components=$(echo "$output" | jq -r '.esp32_platformio_components')" >> $GITHUB_OUTPUT
-          echo "esp8266-native=$(echo "$output" | jq -r '.esp8266_native')" >> $GITHUB_OUTPUT
-          echo "esp8266-native-components=$(echo "$output" | jq -r '.esp8266_native_components')" >> $GITHUB_OUTPUT
          echo "changed-components=$(echo "$output" | jq -c '.changed_components')" >> $GITHUB_OUTPUT
          echo "changed-components-with-tests=$(echo "$output" | jq -c '.changed_components_with_tests')" >> $GITHUB_OUTPUT
          echo "directly-changed-components-with-tests=$(echo "$output" | jq -c '.directly_changed_components_with_tests')" >> $GITHUB_OUTPUT
@@ -187,33 +183,6 @@ jobs:
          path: .temp/components_graph.json
          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}

-  seed-esp8266-native-cache:
-    name: Seed the esp8266 native toolchain cache
-    runs-on: ubuntu-24.04
-    needs:
-      - common
-    # PR-branch cache saves are invisible to other PRs, so dev pushes seed
-    # the shared entry the component matrix, the memory impact jobs and
-    # test-esp8266-native restore. Only dev: the composite action saves
-    # nowhere else, so a beta/release push would download the toolchain and
-    # discard it.
-    if: github.event_name == 'push' && github.ref == 'refs/heads/dev'
-    timeout-minutes: 15
-    steps:
-      - name: Check out code from GitHub
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
-      - name: Cache the native toolchain
-        uses: ./.github/actions/cache-arduino8266
-      - name: Install the native toolchain
-        run: |
-          . venv/bin/activate
-          python -c "from esphome.arduino8266.framework import check_and_install; from esphome.components.esp8266 import RECOMMENDED_ARDUINO_FRAMEWORK_VERSION; check_and_install(RECOMMENDED_ARDUINO_FRAMEWORK_VERSION)"
-
  ci-custom:
    name: Run script/ci-custom
    runs-on: ubuntu-24.04
@@ -352,7 +321,7 @@ jobs:
          . venv/bin/activate
          pytest -vv --cov-report=xml --tb=native --durations=30 -n auto tests --ignore=tests/integration/
      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
      - name: Save Python virtual environment cache
        if: github.ref == 'refs/heads/dev'
        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
@@ -381,7 +350,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      - name: Report empty upload to Codecov
-        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
        with:
          run_command: empty-upload
          force: true
@@ -400,9 +369,14 @@ jobs:
      matrix:
        bucket: ${{ fromJson(needs.determine-jobs.outputs.integration-test-buckets) }}
    env:
-      # Registry libraries (noise-c, libsodium, ArduinoJson, lvgl) the host builds
-      # download, shared per xdist worker by tests/integration/conftest.py
-      INTEGRATION_LIBRARY_CACHE_PATH: ~/.esphome-integration-tests/pio_components
+      # What the cache steps persist; libdeps is excluded (keyed per xdist
+      # worker and env, it never crosses runs).
+      INTEGRATION_PIO_CACHE_PATH: |
+        ~/.esphome-integration-tests/platformio/platforms
+        ~/.esphome-integration-tests/platformio/packages
+        ~/.esphome-integration-tests/platformio/appstate.json
+        ~/.esphome-integration-tests/platformio/.cache
+        ~/.esphome-integration-tests/platformio/.esphome.pio.stamp.json
    steps:
      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -422,13 +396,14 @@ jobs:
        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
        with:
          python-version: "3.13"
-      - name: Restore integration library cache
-        # A miss or a changed pin self-heals with a download, so no restore-keys
-        id: library-cache
+      - name: Restore integration PlatformIO cache
+        # Native platform + toolchain installed by shared_platformio_cache in
+        # tests/integration/conftest.py; a miss self-heals, so no restore-keys.
+        id: pio-cache
        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
        with:
-          path: ${{ env.INTEGRATION_LIBRARY_CACHE_PATH }}
-          key: integration-libraries-v1-${{ runner.os }}-${{ hashFiles('esphome/components/json/__init__.py', 'esphome/components/noise/__init__.py', 'esphome/components/lvgl/__init__.py', 'esphome/components/improv_base/__init__.py') }}
+          path: ${{ env.INTEGRATION_PIO_CACHE_PATH }}
+          key: integration-pio-v1-${{ runner.os }}-py${{ steps.python.outputs.python-version }}-${{ hashFiles('requirements.txt', 'tests/integration/fixtures/cache_init.yaml', 'esphome/components/host/__init__.py') }}
      - name: Restore Python virtual environment
        id: cache-venv
        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
@@ -438,7 +413,7 @@ jobs:
      - name: Set up uv
        # Only needed on cache miss to populate the venv.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -496,16 +471,16 @@ jobs:
          # A full cron period of margin for the weekly refresh
          retention-days: 14
      - name: Print ccache statistics
-        # esphome stores the host build's ccache under the machine-global
-        # cache dir (see get_build_env() in esphome/host/toolchain.py).
-        run: CCACHE_DIR="$HOME/.cache/esphome/host/ccache" ccache -s
-      - name: Save integration library cache
+        # esphome stores the PlatformIO ccache under the machine-global cache
+        # dir (see _ccache_env() in esphome/platformio/toolchain.py).
+        run: CCACHE_DIR="$HOME/.cache/esphome/platformio-ccache" ccache -s
+      - name: Save integration PlatformIO cache
        # Bucket 0 only; the others would race the same immutable key.
-        if: success() && (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) && strategy.job-index == 0 && steps.library-cache.outputs.cache-hit != 'true'
+        if: success() && (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) && strategy.job-index == 0 && steps.pio-cache.outputs.cache-hit != 'true'
        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
        with:
-          path: ${{ env.INTEGRATION_LIBRARY_CACHE_PATH }}
-          key: ${{ steps.library-cache.outputs.cache-primary-key }}
+          path: ${{ env.INTEGRATION_PIO_CACHE_PATH }}
+          key: ${{ steps.pio-cache.outputs.cache-primary-key }}

  import-time:
    name: Check import esphome.__main__ time
@@ -1122,11 +1097,6 @@ jobs:
        uses: ./.github/actions/cache-sdk-nrf
        with:
          restore-only: true
-      - name: Cache the native ESP8266 toolchain
-        # Only batches whose test platforms include esp8266; never saves
-        # here, it reuses the install the dev seed job cached.
-        if: matrix.batch.needs_arduino8266
-        uses: ./.github/actions/cache-arduino8266
      - name: Validate and compile components with intelligent grouping
        run: |
          . venv/bin/activate
@@ -1267,7 +1237,7 @@ jobs:

          # compile validates config first, so a separate config pass is
          # redundant for this smoke test. ESP-IDF framework via PlatformIO:
-          python3 script/test_build_components.py -e compile -t esp32-idf -c "$TEST_COMPONENTS" -f --toolchain platformio --fail-on-no-tests
+          python3 script/test_build_components.py -e compile -t esp32-idf -c "$TEST_COMPONENTS" -f --toolchain platformio

          echo ""
          echo "ESP-IDF-via-PlatformIO build passed! Starting Arduino smoke test..."
@@ -1276,40 +1246,6 @@ jobs:
          # Arduino framework via PlatformIO (only components with an esp32-ard test are built):
          python3 script/test_build_components.py -e compile -t esp32-ard -c "$TEST_COMPONENTS" -f --toolchain platformio

-  test-esp8266-native:
-    name: Test esp8266 components with the native toolchain
-    runs-on: ubuntu-24.04
-    needs:
-      - common
-      - determine-jobs
-    if: github.event_name == 'pull_request' && needs.determine-jobs.outputs.esp8266-native == 'true'
-    env:
-      # Computed by script/determine-jobs.py (ESP8266_NATIVE_TEST_COMPONENTS)
-      TEST_COMPONENTS: ${{ needs.determine-jobs.outputs.esp8266-native-components }}
-    steps:
-      - name: Check out code from GitHub
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
-
-      - name: Cache the native toolchain
-        uses: ./.github/actions/cache-arduino8266
-
-      - name: Run native toolchain compile test
-        run: |
-          . venv/bin/activate
-
-          echo "Testing components: $TEST_COMPONENTS"
-          echo ""
-
-          # ESP8266 Arduino built directly (no PlatformIO); compile validates
-          # config first, so a separate config pass is redundant.
-          python3 script/test_build_components.py -e compile -t esp8266-ard -c "$TEST_COMPONENTS" -f --toolchain arduino --fail-on-no-tests
-
  device-builder:
    name: Test downstream esphome/device-builder
    runs-on: ubuntu-24.04
@@ -1338,7 +1274,7 @@ jobs:
        # install step (order-of-magnitude faster on cold boots,
        # with its own wheel cache). actions/setup-python still
        # provides the interpreter.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -1479,9 +1415,12 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}

-      - name: Cache the native ESP8266 toolchain
-        if: steps.check-script.outputs.skip != 'true' && steps.check-tests.outputs.skip != 'true' && steps.cache-memory-analysis.outputs.cache-hit != 'true' && fromJSON(needs.determine-jobs.outputs.memory_impact).needs_arduino8266
-        uses: ./.github/actions/cache-arduino8266
+      - name: Cache platformio
+        if: steps.check-script.outputs.skip != 'true' && steps.check-tests.outputs.skip != 'true' && steps.cache-memory-analysis.outputs.cache-hit != 'true'
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ~/.platformio
+          key: platformio-memory-${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}-${{ hashFiles('platformio.ini') }}

      - name: Build, compile, and analyze memory
        if: steps.check-script.outputs.skip != 'true' && steps.check-tests.outputs.skip != 'true' && steps.cache-memory-analysis.outputs.cache-hit != 'true'
@@ -1566,9 +1505,11 @@ jobs:
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
-      - name: Cache the native ESP8266 toolchain
-        if: fromJSON(needs.determine-jobs.outputs.memory_impact).needs_arduino8266
-        uses: ./.github/actions/cache-arduino8266
+      - name: Cache platformio
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ~/.platformio
+          key: platformio-memory-${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}-${{ hashFiles('platformio.ini') }}
      - name: Build, compile, and analyze memory
        id: extract
        run: |
@@ -1667,7 +1608,6 @@ jobs:
    needs:
      - common
      - seed-apt-cache
-      - seed-esp8266-native-cache
      - determine-jobs
      - ci-custom
      - pylint
@@ -1683,7 +1623,6 @@ jobs:
      - clang-tidy-esp32-variants
      - test-build-components-split
      - test-esp32-platformio
-      - test-esp8266-native
      - device-builder
      - memory-impact-target-branch
      - memory-impact-pr-branch
@@ -56,7 +56,7 @@ jobs:

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
        with:
          languages: ${{ matrix.language }}
          build-mode: ${{ matrix.build-mode }}
@@ -84,6 +84,6 @@ jobs:
          exit 1

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/analyze@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
        with:
          category: "/language:${{matrix.language}}"
@@ -14,4 +14,4 @@ jobs:
    permissions:
      issues: write         # issues.lock on closed issues
      pull-requests: write  # issues.lock on closed pull requests
-    uses: esphome/workflows/.github/workflows/lock.yml@cc3e76de337dc59bc1cba8da58d963cd23b873f1  # 2026.9.0
+    uses: esphome/workflows/.github/workflows/lock.yml@0fdd5e311b7e744069166696072a1a9cbc5fbeb6  # 2026.8.1
@@ -123,7 +123,7 @@ jobs:
          python-version: "3.12"

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0

      - name: Log in to docker hub
        uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
@@ -202,7 +202,7 @@ jobs:
          merge-multiple: true

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0

      - name: Log in to docker hub
        if: matrix.registry == 'dockerhub'
@@ -16,7 +16,7 @@ jobs:
    # No GITHUB_TOKEN permissions: the reusable workflow mints an ESPHome
    # GitHub App token so the labels, comments and closures come from
    # esphome[bot] instead of github-actions[bot].
-    uses: esphome/workflows/.github/workflows/stale.yml@cc3e76de337dc59bc1cba8da58d963cd23b873f1  # main
+    uses: esphome/workflows/.github/workflows/stale.yml@a1c1485ab46ef41a84a6a9d8abd7fa4b7628fd70  # main
    secrets:
      ESPHOME_GITHUB_APP_PRIVATE_KEY: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
    with:
@@ -47,7 +47,7 @@ jobs:
        # setup-python interpreter so subsequent ``prek`` /
        # ``script/run-in-env.py`` steps find the deps without a
        # ``uv run`` prefix.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pin uv version so the action does not have to fetch the
@@ -10,7 +10,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.16.8
+    rev: v0.16.6
    hooks:
      # Run the linter.
      - id: ruff
@@ -322,25 +322,6 @@ file does, and it is the authority when they disagree. The most useful starting
              var = await switch.new_switch(config)
          ```

-        - **Optional child entities of a hub:** bind the config once with `sensor.sub_sensors(config)` (or
-          `sub_binary_sensors`, `sub_text_sensors`, `sub_buttons`, `sub_switches`, `sub_numbers`,
-          `sub_selects` in their domains), adding `parent=hub` for entities that derive from `Parented<T>`,
-          then make one call per key, even when there is only one. A call creates the entity only when its key
-          is configured, passes it to the setter and returns it (or `None`); extra arguments such as
-          `min_value` or `options` go on the call. Always name the setter explicitly on the object that owns
-          it, never with `getattr` and an f-string, and keep that variable short (`var` for the component
-          itself, `hub` for one fetched with `cg.get_variable`) so the calls fit on one line. Loops whose
-          setter also takes an index, such as `set_gate_threshold(x, n)`, stay as they are.
-          ```python
-          async def to_code(config):
-              var = cg.new_Pvariable(config[CONF_ID])
-              sensors = sensor.sub_sensors(config)
-              await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-              await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
-              buttons = button.sub_buttons(config, parent=var)
-              await buttons(CONF_RESTART, var.set_restart_button)
-          ```
-
 *   **Automations (Triggers, Actions, Conditions):**

    Automations have three building blocks: **Triggers** (fire when something happens), **Actions** (do something), and **Conditions** (check if something is true).
@@ -450,31 +431,7 @@ file does, and it is the authority when they disagree. The most useful starting
          MyComponent *parent_;
        };
        ```
-        Register it without writing a builder:
-        ```python
-        automation.register_simple_action(
-            "my_component.do_something", MyAction, schema, synchronous=True
-        )
-        ```
-        The constructor receives the object named by `config[CONF_ID]`. Use `register_bare_action` for a
-        no-argument constructor, `register_parented_action` for a class deriving from `Parented<T>`, and
-        the `@automation.register_action(...)` decorator only when the builder must also set fields.
-
-        Use `synchronous=True` for actions that run to completion inside `play()` without deferring. Use `synchronous=False` if the action may suspend/defer execution (e.g. `delay`, `wait_until`, `script.wait`) or store trigger arguments for later use.
-
-        **Actions that only forward templatable values to their parent need no C++ class.** Register them
-        with `register_apply_action`; do not write a `TEMPLATABLE_VALUE` class or a builder for this shape.
-        ```python
-        automation.register_apply_action(
-            "my_component.set_gains",
-            schema,
-            automation.ApplyField(CONF_KP, "set_kp", cg.float_),
-            automation.ApplyField(CONF_KI, "set_ki", cg.float_),
-        )
-        ```
-        The `ApplyField`, `ApplyCall` and `register_apply_action` docstrings in `esphome/automation.py` cover
-        the rest; `cover.control` and `cover.template.publish` are in-tree examples. `TEMPLATABLE_VALUE` with
-        `cg.templatable` stays for actions whose `play()` has real logic beyond forwarding values.
+        Register with `@automation.register_action("my_component.do_something", MyAction, schema, synchronous=True)`. Use `synchronous=True` for actions that run to completion inside `play()` without deferring. Use `synchronous=False` if the action may suspend/defer execution (e.g. `delay`, `wait_until`, `script.wait`) or store trigger arguments for later use.

    *   **Conditions:**
        ```cpp
@@ -486,21 +443,7 @@ file does, and it is the authority when they disagree. The most useful starting
          MyComponent *parent_;
        };
        ```
-        Register with `automation.register_simple_condition("my_component.is_active", MyCondition, schema)`;
-        `register_bare_condition`, `register_parented_condition` and the decorator follow the action rules.
-
-        **Conditions that only test their parent need no C++ class either.** Register them with
-        `register_apply_condition`; the expression is applied to the parent, and an `ApplyCall` compares
-        against config values.
-        ```python
-        automation.register_apply_condition("my_component.is_active", schema, "is_active()")
-        automation.register_apply_condition(
-            "my_component.state_is",
-            schema,
-            automation.ApplyCall("state == {}", ((CONF_STATE, cg.bool_),)),
-        )
-        ```
-        `cover.is_open`, `rtttl.is_playing` and `component.is_idle` are in-tree examples.
+        Register with `@automation.register_condition("my_component.is_active", MyCondition, schema)`.

 *   **Type Hints:** Type-hint all function signatures, including test functions and config validators (e.g. `def validate_x(config: ConfigType) -> ConfigType:`, `def test_x() -> None:`). Import `ConfigType` from `esphome.types`.

@@ -756,9 +699,7 @@ file does, and it is the authority when they disagree. The most useful starting

        6. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices.

-        7. **Never use `new (std::nothrow)`:** On ESP-IDF exceptions are disabled, so a failed nothrow allocation aborts instead of returning `nullptr`. Use `RAMAllocator` from `esphome/core/helpers.h`; CI rejects `std::nothrow`.
-
-        8. **Detection:** Look for these patterns in compiler output:
+        7. **Detection:** Look for these patterns in compiler output:
           - Large code sections with STL symbols (vector, map, set)
           - `alloc`, `realloc`, `dealloc` in symbol names
           - `_M_realloc_insert`, `_M_default_append` (vector reallocation)
@@ -125,7 +125,6 @@ esphome/components/combination/* @Cat-Ion @kahrendt
 esphome/components/const/* @esphome/core
 esphome/components/coolix/* @glmnet
 esphome/components/copy/* @OttoWinter
-esphome/components/counter/* @clydebarrow
 esphome/components/cover/* @esphome/core
 esphome/components/cs5460a/* @balrog-kun
 esphome/components/cse7761/* @berfenger
@@ -183,6 +182,7 @@ esphome/components/esp32_camera_web_server/* @ayufan
 esphome/components/esp32_can/* @Sympatron
 esphome/components/esp32_hosted/* @swoboda1337
 esphome/components/esp32_hosted/update/* @swoboda1337
+esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
@@ -266,10 +266,8 @@ esphome/components/i2s_audio/* @jesserockz
 esphome/components/i2s_audio/microphone/* @jesserockz
 esphome/components/i2s_audio/speaker/* @jesserockz @kahrendt
 esphome/components/iaqcore/* @yozik04
-esphome/components/icnt86/* @danepowell
 esphome/components/ili9xxx/* @clydebarrow @nielsnl68
 esphome/components/improv_base/* @esphome/core
-esphome/components/improv_ble/* @jesserockz
 esphome/components/improv_serial/* @esphome/core
 esphome/components/ina226/* @latonita @Sergio303
 esphome/components/ina260/* @mreditor97
@@ -423,7 +421,6 @@ esphome/components/pn7150_i2c/* @jesserockz @kbx81
 esphome/components/pn7160/* @jesserockz @kbx81
 esphome/components/pn7160_i2c/* @jesserockz @kbx81
 esphome/components/pn7160_spi/* @jesserockz @kbx81
-esphome/components/pn71xx/* @jesserockz @kbx81
 esphome/components/power_supply/* @esphome/core
 esphome/components/preferences/* @esphome/core
 esphome/components/provisioning/* @esphome/core
@@ -431,7 +428,6 @@ esphome/components/psram/* @esphome/core
 esphome/components/pulse_meter/* @cstaahl @stevebaxter @TrentHouliston
 esphome/components/pvvx_mithermometer/* @pasiz
 esphome/components/pylontech/* @functionpointer
-esphome/components/pzem6l24/* @nuttytree
 esphome/components/qmi8658/* @clydebarrow
 esphome/components/qmp6988/* @andrewpc
 esphome/components/qr_code/* @wjtje
@@ -460,7 +456,6 @@ esphome/components/rtl87xx/* @kuba2k2
 esphome/components/rtttl/* @glmnet @ximex
 esphome/components/runtime_image/* @clydebarrow @guillempages @kahrendt
 esphome/components/runtime_stats/* @bdraco
-esphome/components/rx8025t/* @remcom
 esphome/components/rx8130/* @beormund
 esphome/components/safe_mode/* @jsuanet @kbx81 @paulmonigatti
 esphome/components/scd4x/* @martgras @sjtrny
@@ -482,7 +477,6 @@ esphome/components/sendspin/image/* @kahrendt
 esphome/components/sendspin/media_player/* @kahrendt
 esphome/components/sendspin/media_source/* @kahrendt
 esphome/components/sendspin/sensor/* @kahrendt
-esphome/components/sendspin/switch/* @kahrendt
 esphome/components/sendspin/text_sensor/* @kahrendt
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
@@ -551,9 +545,7 @@ esphome/components/sx126x/* @swoboda1337
 esphome/components/sx127x/* @swoboda1337
 esphome/components/sy6970/* @linkedupbits
 esphome/components/syslog/* @clydebarrow
-esphome/components/systa_bus/* @Mat931
 esphome/components/t6615/* @tylermenezes
-esphome/components/tas2780/* @remcom
 esphome/components/tc74/* @sethgirvan
 esphome/components/tca9548a/* @andreashergert1984
 esphome/components/tca9555/* @mobrembski
@@ -566,7 +558,6 @@ esphome/components/template/datetime/* @rfdarter
 esphome/components/template/event/* @nohat
 esphome/components/template/fan/* @ssieb
 esphome/components/text/* @mauritskorse
-esphome/components/tfluna/* @candrews
 esphome/components/thermopro_ble/* @sittner
 esphome/components/thermostat/* @kbx81
 esphome/components/time/* @esphome/core
@@ -598,7 +589,6 @@ esphome/components/uart/* @esphome/core
 esphome/components/uart/button/* @ssieb
 esphome/components/uart/event/* @eoasmxd
 esphome/components/uart/packet_transport/* @clydebarrow
-esphome/components/uart_mux/* @kbx81
 esphome/components/udp/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli
@@ -643,7 +633,6 @@ esphome/components/wts01/* @alepee
 esphome/components/x9c/* @EtienneMD
 esphome/components/xdb401/* @RT530
 esphome/components/xgzp68xx/* @gcormier
-esphome/components/xiaomi_body_scale/* @dckiller51
 esphome/components/xiaomi_hhccjcy10/* @fariouche
 esphome/components/xiaomi_lywsd02mmc/* @juanluss31
 esphome/components/xiaomi_lywsd03mmc/* @ahpohl
@@ -22,13 +22,16 @@ RUN \
    -r /requirements.txt

 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.17.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.14.7

 RUN \
    platformio settings set enable_telemetry No \
    && platformio settings set check_platformio_interval 1000000 \
    && mkdir -p /piolibs

+COPY script/platformio_install_deps.py platformio.ini /
+RUN /platformio_install_deps.py /platformio.ini --libraries
+
 ARG BUILD_VERSION

 LABEL \
@@ -4,6 +4,7 @@
 # Home Assistant Add-on: ESPHome
 # Sends discovery information to Home Assistant.
 # ==============================================================================
+declare config
 declare port

 # We only disable it when disabled explicitly
@@ -18,17 +19,14 @@ port=$(bashio::addon.ingress_port)
 # Wait for the ESPHome Device Builder to become available
 bashio::net.wait_for "${port}" "127.0.0.1" 300

-# Send one discovery message; the config is a JSON string built with bashio::var.json.
-send_discovery() {
-    local service=$1
-    local config=$2
-    if bashio::discovery "${service}" "${config}" > /dev/null; then
-        bashio::log.info "Successfully send ${service} discovery information to Home Assistant."
-    else
-        bashio::log.error "${service} discovery message to Home Assistant failed!"
-    fi
-}
+config=$(\
+    bashio::var.json \
+        host "127.0.0.1" \
+        port "^${port}" \
+)

-send_discovery "esphome" "$(bashio::var.json host "127.0.0.1" port "^${port}")"
-# The Device Builder MCP server, consumed by Home Assistant's mcp integration.
-send_discovery "mcp" "$(bashio::var.json url "http://127.0.0.1:${port}/api/mcp")"
+if bashio::discovery "esphome" "${config}" > /dev/null; then
+    bashio::log.info "Successfully send discovery information to Home Assistant."
+else
+    bashio::log.error "Discovery message to Home Assistant failed!"
+fi
@@ -5,15 +5,3 @@ bk72xx:
  board: generic-bk7231n-qfn32-tuya

 logger:
-
-wifi:
-  ssid: MySSID
-  password: password1
-  ap:
-
-# mqtt and captive_portal together pull in AsyncTCP and ESPAsyncWebServer;
-# a stray ESP32 AsyncTCP copy on the library search path breaks this build
-captive_portal:
-
-mqtt:
-  broker: 192.168.178.84
@@ -16,7 +16,6 @@ from typing import TYPE_CHECKING, Protocol
 # cause them to be loaded before external components are processed, resulting
 # in the built-in version being used instead of the external component one.
 from esphome import const, platform_hooks
-from esphome.build_helpers.native import analysis_backend, native_backend
 from esphome.const import (
    ALLOWED_NAME_CHARS,
    ARGUMENT_HELP_DEVICE,
@@ -818,9 +817,7 @@ def write_cpp_file() -> int:
        from esphome.build_gen import espidf

        espidf.write_project()
-    elif not CORE.using_native_toolchain:
-        # Other native builds generate their project at compile time;
-        # never write a platformio.ini for them
+    else:
        from esphome.build_gen import platformio

        platformio.write_project()
@@ -862,14 +859,20 @@ def compile_program(args: ArgsProtocol, config: ConfigType) -> int:
        toolchain.create_factory_bin()
        toolchain.create_ota_bin()
        toolchain.create_elf_copy()
-        from esphome.build_helpers.idedata import warn_if_idedata_missing
+        from esphome.build_helpers.idedata import IDEDATA_BEST_EFFORT_ERRORS

-        warn_if_idedata_missing(toolchain.get_idedata)
-    elif CORE.using_native_toolchain:
-        raise EsphomeError(
-            f"Toolchain '{CORE.toolchain.value}' resolved but no platform "
-            "backend claimed the build"
-        )
+        try:
+            if toolchain.get_idedata() is None:
+                _LOGGER.warning("No idedata was generated for this build")
+        except IDEDATA_BEST_EFFORT_ERRORS as err:
+            # The firmware already built; an idedata failure must not fail
+            # a successful build.
+            _LOGGER.warning(
+                "Could not generate idedata: %s (IDE, clang-tidy, and "
+                "memory-analysis data will be unavailable for this build)",
+                err,
+            )
+            _LOGGER.debug("Idedata failure detail", exc_info=True)
    else:
        from esphome.platformio import toolchain

@@ -972,15 +975,12 @@ def upload_using_esptool(

    if file is not None:
        flash_images = [FlashImage(path=file, offset="0x0")]
-    elif (native := native_backend()) is not None:
-        # Every native backend supplies its own 0x0 flash image (bootloader
-        # and partitions included where the target needs them)
-        image = native.get_factory_firmware_path()
-        if not image.is_file():
-            raise EsphomeError(
-                f"{image} does not exist; compile the configuration first"
-            )
-        flash_images = [FlashImage(path=image, offset="0x0")]
+    elif CORE.using_toolchain_esp_idf:
+        from esphome.espidf import toolchain
+
+        flash_images = [
+            FlashImage(path=toolchain.get_factory_firmware_path(), offset="0x0")
+        ]
    else:
        from esphome.platformio import toolchain

@@ -1343,12 +1343,8 @@ def _upload_via_native_api(
    # fall back to a plaintext upload
    noise_psk = None
    plaintext_fallback = False
-    allow_plaintext_upload = False
    if (encryption_conf := ota_conf.get(CONF_ENCRYPTION)) is not None:
        noise_psk = encryption_conf.get(CONF_KEY)
-        allow_plaintext_upload = bool(
-            encryption_conf.get(espota2.CONF_ALLOW_PLAINTEXT_UPLOAD)
-        )
        if not noise_psk:
            raise EsphomeError(
                "OTA encryption is configured but no key was resolved; "
@@ -1399,7 +1395,6 @@ def _upload_via_native_api(
        ota_type,
        noise_psk,
        plaintext_fallback=plaintext_fallback,
-        allow_plaintext_upload=allow_plaintext_upload,
    )


@@ -1714,12 +1709,26 @@ def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
    if exit_code != 0:
        return exit_code
    if CORE.is_host:
-        _LOGGER.info("Successfully compiled program to path '%s'", CORE.firmware_bin)
+        _LOGGER.info(
+            "Successfully compiled program to path '%s'", _host_program_path(config)
+        )
    else:
        _LOGGER.info("Successfully compiled program.")
    return 0


+def _host_program_path(config: ConfigType) -> str:
+    """Return the compiled host ELF path."""
+    if CORE.using_toolchain_esp_idf:
+        from esphome.espidf import toolchain
+
+        return str(toolchain.get_elf_path())
+    from esphome.platformio.toolchain import get_idedata
+
+    # Memoized by compile_program's own call; this is a dict lookup
+    return str(get_idedata(config).firmware_elf_path)
+
+
 def command_upload(args: ArgsProtocol, config: ConfigType) -> int | None:
    # Get devices, resolving special identifiers like OTA
    devices = choose_upload_log_host(
@@ -1764,7 +1773,7 @@ def command_run(args: ArgsProtocol, config: ConfigType) -> int | None:
        return exit_code
    _LOGGER.info("Successfully compiled program.")
    if CORE.is_host:
-        program_path = str(CORE.firmware_bin)
+        program_path = _host_program_path(config)
        _LOGGER.info("Running program from path '%s'", program_path)
        return run_external_process(program_path)

@@ -1956,12 +1965,12 @@ def command_update_all(args: ArgsProtocol) -> int | None:
 def command_idedata(args: ArgsProtocol, config: ConfigType) -> int:
    import json

-    native_toolchain = native_backend()
+    if CORE.using_toolchain_esp_idf:
+        # Native ESP-IDF derives idedata from the build's compile_commands.json,
+        # so the configuration must already be compiled.
+        from esphome.espidf import toolchain as espidf_toolchain

-    if native_toolchain is not None:
-        # Native toolchains derive idedata from the build's
-        # compile_commands.json, so the configuration must already be compiled.
-        idedata = native_toolchain.get_idedata()
+        idedata = espidf_toolchain.get_idedata()
        if idedata is None:
            _LOGGER.error(
                "No idedata available; compile the configuration first",
@@ -2000,22 +2009,6 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:
    from esphome.analyze_memory.cli import MemoryAnalyzerCLI
    from esphome.analyze_memory.ram_strings import RamStringsAnalyzer

-    # Refuse an unsupported toolchain before paying for a full compile
-    analysis_toolchain = analysis_backend()
-    if analysis_toolchain is None and not CORE.using_toolchain_platformio:
-        _LOGGER.error(
-            "analyze-memory is not supported with the '%s' toolchain on %s; "
-            "re-run with --toolchain platformio",
-            CORE.toolchain.value if CORE.toolchain else "unresolved",
-            CORE.target_platform,
-        )
-        return 1
-    if (
-        check_supported := getattr(analysis_toolchain, "check_analysis_supported", None)
-    ) is not None:
-        # Raises with the reason; before the compile, not after it
-        check_supported()
-
    # Always compile to ensure fresh data (fast if no changes - just relinks)
    exit_code = write_cpp(config)
    if exit_code != 0:
@@ -2027,30 +2020,13 @@ def command_analyze_memory(args: ArgsProtocol, config: ConfigType) -> int:

    # Get idedata for analysis
    idedata = None
-    if analysis_toolchain is not None:
-        objdump = analysis_toolchain.get_objdump_path()
-        readelf = analysis_toolchain.get_readelf_path()
-        for tool in (objdump, readelf):
-            if not tool.is_file():
-                # The analyzer would silently fall back to host
-                # binutils, which cannot read the target ELF
-                _LOGGER.error(
-                    "%s is missing; the toolchain install may be incomplete "
-                    "(recompile, or run 'esphome clean-all' if it persists)",
-                    tool,
-                )
-                return 1
-        objdump_path = str(objdump)
-        readelf_path = str(readelf)
+    if CORE.using_toolchain_esp_idf:
+        from esphome.espidf import toolchain

-        firmware_elf = analysis_toolchain.get_elf_path()
-        if not firmware_elf.is_file():
-            # The analyzer swallows tool failures, so a missing ELF would
-            # produce an exit-0 zeroed report
-            _LOGGER.error(
-                "%s is missing; compile the configuration first", firmware_elf
-            )
-            return 1
+        objdump_path = str(toolchain.get_objdump_path())
+        readelf_path = str(toolchain.get_readelf_path())
+
+        firmware_elf = toolchain.get_elf_path()
    else:
        from esphome.platformio import toolchain

@@ -68,16 +68,12 @@ def idedata_candidates(build_path: Path) -> list[Path]:
        The candidate idedata JSON paths, most specific first
    """
    name = build_path.name
-    data_dir = build_path.parent.parent / "idedata"
-    # Native backends suffix the cache by toolchain (<name>.arduino.json)
-    suffixed = sorted(data_dir.glob(f"{name}.*.json")) if data_dir.is_dir() else []
    return [
        # In .pioenvs for test builds
        build_path / ".pioenvs" / name / "idedata.json",
        # Both toolchains cache it in the data dir, which holds this build dir:
        # <data_dir>/idedata/<name>.json next to <data_dir>/build/<name>
        build_path.parent.parent / "idedata" / f"{name}.json",
-        *suffixed,
        # Regular builds, invoked from the config dir or from anywhere
        Path.cwd() / ".esphome" / "idedata" / f"{name}.json",
        Path.home() / ".esphome" / "idedata" / f"{name}.json",
@@ -2,9 +2,7 @@

 Bundled names build straight from the framework tree; everything else goes
 through ``esphome.platformio.library``. Mirrors ``lib_ldf_mode=off``: each
-library builds its own archive; all include dirs join one global path. The
-host build reuses it without a framework tree: nothing is bundled there and
-every name resolves from the registry.
+library builds its own archive; all include dirs join one global path.

 Deviations from PlatformIO: flat-layout libraries get the recursive default
 source filter; ``dot_a_linkage`` is honored; bundled libraries never run a
@@ -344,24 +342,13 @@ def _check_unfulfilled_provides(


 def resolve_libraries(
-    framework_path: Path | None,
-    *,
-    pio_platform: str,
-    board_mcu: str,
-    cache_key: str,
-    framework: str | None = "arduino",
-    manifest_optional: bool = False,
+    framework_path: Path, *, pio_platform: str, board_mcu: str, cache_key: str
 ) -> list[ArduinoLibrary]:
    """Resolve every ``cg.add_library()`` entry into an :class:`ArduinoLibrary`.

    ``pio_platform``/``board_mcu`` filter manifests the way PlatformIO would
    for that core (e.g. ``espressif8266``/``esp8266``); ``cache_key`` keys the
-    shared converter's download cache. ``framework`` is the manifest
-    framework token the compatibility check warns about; None skips it.
-    A None ``framework_path`` means no core-bundled libraries exist (the
-    host build): every name resolves from the registry.
-    ``manifest_optional`` accepts libraries without a manifest, built with
-    PlatformIO's default layout.
+    shared converter's download cache.

    The returned list is not topologically sorted, so the caller must link
    the archives inside one ``--start-group``/``--end-group`` pair (the
@@ -372,22 +359,18 @@ def resolve_libraries(
    # PlatformIO's lib_ignore covers framework-bundled libraries too; the
    # shared converter only filters the registry/git ones.
    lib_ignore = lib_ignore_set()
-    bundled_dir_names: frozenset[str] = frozenset()
-    if framework_path is not None:
-        # Exact directory names keep membership case-sensitive everywhere
-        # (an is_dir() probe would match "wire" on macOS/Windows and build
-        # the bundled Wire twice)
-        libraries_dir = framework_path / "libraries"
-        if not libraries_dir.is_dir():
-            # A registry fallback would fail later with a misleading
-            # package-not-found error per bundled name
-            raise EsphomeError(
-                f"{libraries_dir} is missing; the framework install may be "
-                "incomplete (run 'esphome clean-all')"
-            )
-        bundled_dir_names = frozenset(
-            p.name for p in libraries_dir.iterdir() if p.is_dir()
+    # Exact directory names keep membership case-sensitive everywhere
+    # (an is_dir() probe would match "wire" on macOS/Windows and build
+    # the bundled Wire twice)
+    libraries_dir = framework_path / "libraries"
+    if not libraries_dir.is_dir():
+        # A registry fallback would fail later with a misleading
+        # package-not-found error per bundled name
+        raise EsphomeError(
+            f"{libraries_dir} is missing; the framework install may be "
+            "incomplete (run 'esphome clean-all')"
        )
+    bundled_dir_names = frozenset(p.name for p in libraries_dir.iterdir() if p.is_dir())

    def _provided(name: object) -> bool:
        return _is_safe_library_name(name) and name in bundled_dir_names
@@ -514,13 +497,12 @@ def resolve_libraries(

    backend = LibraryBackend(
        platform=pio_platform,
-        framework=framework,
+        framework="arduino",
        emit=_emit,
        cache_key=cache_key,
        # The walk must not resolve bundled names from the registry;
        # _add_bundled_dependencies adds them after emit
        provides=_provided,
-        manifest_optional=manifest_optional,
    )
    if external:
        convert_libraries(external, backend)
@@ -17,7 +17,7 @@ import os
 from pathlib import Path
 from typing import NamedTuple

-from esphome.build_helpers.ccache import ccache_env
+from esphome.build_helpers.ccache import ccache_defaults_env
 from esphome.build_helpers.ninja import find_ninja
 from esphome.build_helpers.tools_cache import ARDUINO8266_TOOLS_CACHE, tools_cache_path
 from esphome.core import EsphomeError, Version
@@ -143,5 +143,17 @@ def get_build_env(toolchain_path: Path, ccache: str | None) -> dict[str, str]:
        *filter(None, env.get("PATH", "").split(os.pathsep)),
    ]
    env["PATH"] = os.pathsep.join(parts)
-    env.update(ccache_env(ccache, ARDUINO8266_TOOLS_CACHE))
+    env.update(ccache_env(ccache))
    return env
+
+
+def ccache_env(ccache: str | None) -> dict[str, str]:
+    """Return ccache settings for the build subprocess (not os.environ).
+
+    ``ccache`` is the pre-resolved binary (resolve_ccache_path), or None
+    when disabled. Values the user already set in the environment are
+    respected.
+    """
+    if ccache is None:
+        return {}
+    return ccache_defaults_env(get_arduino8266_tools_path() / "ccache")
@@ -1,212 +0,0 @@
-"""Native Arduino ESP8266 build driver (the PlatformIO ``run`` equivalent)."""
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-import subprocess
-from typing import TYPE_CHECKING
-
-from esphome.build_helpers.ccache import resolve_absolute_ccache_path
-from esphome.build_helpers.native import warn_ignored_platformio_options
-from esphome.build_helpers.ninja import refresh_compile_commands
-from esphome.const import (
-    CONF_COMPILE_PROCESS_LIMIT,
-    CONF_ESPHOME,
-    KEY_CORE,
-    KEY_FRAMEWORK_VERSION,
-)
-from esphome.core import CORE
-from esphome.types import ConfigType
-
-if TYPE_CHECKING:
-    from esphome.arduino8266.framework import InstalledPaths
-
-_LOGGER = logging.getLogger(__name__)
-
-# ESP8266 user RAM (matches upload.maximum_ram_size in every board manifest)
-_MAX_RAM_SIZE = 81920
-
-
-_RAM_SECTIONS = (".data", ".rodata", ".bss")
-_FLASH_SECTIONS = (".irom0.text", ".text", ".text1", ".data", ".rodata")
-
-
-def get_build_dir() -> Path:
-    return CORE.relative_pioenvs_path(CORE.name)
-
-
-def get_elf_path() -> Path:
-    return get_build_dir() / "firmware.elf"
-
-
-def _toolchain_tool(name: str) -> Path:
-    # Imported here, not at module scope: the serial upload/logs fast path
-    # resolves this module for its artifact paths alone, and framework
-    # pulls in the whole package-download stack
-    from esphome.arduino8266 import framework
-
-    return framework.toolchain_tool(framework.get_toolchain_path(), name)
-
-
-def get_factory_firmware_path() -> Path:
-    """The image to serial-flash at 0x0 (same bytes as firmware.bin: the
-    8266 factory copy exists for artifact-contract parity, not content)."""
-    return get_build_dir() / "firmware.factory.bin"
-
-
-def get_addr2line_path() -> Path:
-    return _toolchain_tool("addr2line")
-
-
-def get_objdump_path() -> Path:
-    return _toolchain_tool("objdump")
-
-
-def get_readelf_path() -> Path:
-    return _toolchain_tool("readelf")
-
-
-def run_compile(config: ConfigType, verbose: bool) -> int:
-    from esphome.arduino8266 import framework
-    from esphome.build_gen import arduino8266 as build_gen
-    from esphome.core.config import NATIVE_ARDUINO_CONSUMED_PIO_OPTIONS
-
-    warn_ignored_platformio_options(NATIVE_ARDUINO_CONSUMED_PIO_OPTIONS)
-    paths = framework.check_and_install(CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION])
-    # Resolved once: the probe is not free and three consumers need it
-    ccache = resolve_absolute_ccache_path()
-    ninja_changed = build_gen.write_project(paths, ccache)
-
-    build_dir = get_build_dir()
-    env = framework.get_build_env(paths.toolchain, ccache)
-    refresh_compile_commands(paths.ninja, build_dir, env, ninja_changed)
-
-    cmd = [str(paths.ninja)]
-    if verbose:
-        cmd.append("-v")
-    if jobs := config[CONF_ESPHOME].get(CONF_COMPILE_PROCESS_LIMIT):
-        cmd += ["-j", str(jobs)]
-    # Explicit targets: a generator defect that drops them fails loudly
-    # instead of a green no-op run leaving stale artifacts in place
-    targets = ["firmware.factory.bin", "firmware.ota.bin"]
-    cmd += targets
-
-    # cwd, not -C: drops ninja's "Entering directory" banner
-    _LOGGER.debug("Running: %s", " ".join(cmd))
-    rc = subprocess.run(
-        cmd, cwd=build_dir, env=env, check=False, close_fds=False
-    ).returncode
-    if rc != 0:
-        return rc
-
-    # ninja already refused missing targets; existence covers a rule that
-    # ran but wrote elsewhere
-    build_dir_artifacts = (
-        get_elf_path(),
-        build_dir / "firmware.bin",
-        get_factory_firmware_path(),
-        build_dir / "firmware.ota.bin",
-    )
-    for artifact in build_dir_artifacts:
-        if not artifact.is_file():
-            _LOGGER.error("Build produced no %s", artifact)
-            return 1
-
-    if not _print_size_summary(build_dir, paths):
-        # Cause already warned; name the consequence for CI harnesses
-        _LOGGER.warning("Firmware size summary unavailable for this build")
-    from esphome.build_helpers.idedata import warn_if_idedata_missing
-
-    warn_if_idedata_missing(lambda: get_idedata(ccache))
-    return 0
-
-
-def _parse_app_size(build_dir: Path, paths: InstalledPaths) -> int | None:
-    """Read the app flash budget (irom0_0_seg length) from the linker script."""
-    from esphome.build_gen.arduino8266 import get_flash_ld_path
-    from esphome.components.esp8266.build_surgery import segment_length
-
-    # Warnings, not debug: without the app size the Flash summary line is
-    # dropped and CI's memory-impact extraction loses its flash metric.
-    ld_path = get_flash_ld_path(build_dir, paths)
-    try:
-        ld_text = ld_path.read_text(encoding="utf-8")
-    except (OSError, UnicodeDecodeError) as err:
-        # A corrupt script degrades the same way, never aborts the build
-        _LOGGER.warning("Cannot read linker script for the Flash summary: %s", err)
-        return None
-    if not (app_size := segment_length(ld_text, "irom0_0_seg")):
-        _LOGGER.warning("No usable irom0_0_seg in %s; skipping Flash summary", ld_path)
-        return None
-    return app_size
-
-
-def _print_size_summary(build_dir: Path, paths: InstalledPaths) -> bool:
-    """Print the RAM/Flash lines ``ci_memory_impact_extract.py`` parses;
-    False when skipped."""
-    from esphome.arduino8266.framework import toolchain_tool
-    from esphome.build_helpers.size_summary import print_size_line
-
-    try:
-        result = subprocess.run(
-            [
-                str(toolchain_tool(paths.toolchain, "size")),
-                "-A",
-                "-d",
-                str(build_dir / "firmware.elf"),
-            ],
-            capture_output=True,
-            text=True,
-            check=True,
-            close_fds=False,
-        )
-    except (OSError, subprocess.CalledProcessError) as err:
-        # The summary is a bonus artifact like idedata; a truncated
-        # toolchain extraction must not discard an already-linked build
-        _LOGGER.warning("Could not summarize firmware size: %s", err)
-        return False
-    # -d prints decimal sizes; anything else trips the missing-sections guard
-    sections = {
-        parts[0]: int(parts[1])
-        for line in result.stdout.splitlines()
-        if (parts := line.split())[:1] and parts[0].startswith(".") and len(parts) >= 2
-        if parts[1].isdigit()
-    }
-    if missing := set(_RAM_SECTIONS + _FLASH_SECTIONS) - set(sections):
-        # A defaulted 0 would print a confidently wrong total for CI's metric
-        _LOGGER.warning(
-            "Size output is missing section(s) %s; skipping the size summary",
-            ", ".join(sorted(missing)),
-        )
-        return False
-    # Resolve the flash budget before printing: a RAM line without its
-    # Flash line would skew CI's memory-impact extraction
-    app_size = _parse_app_size(build_dir, paths)
-    if not app_size:
-        return False
-    ram = sum(sections[s] for s in _RAM_SECTIONS)
-    flash = sum(sections[s] for s in _FLASH_SECTIONS)
-    print_size_line("RAM", ram, _MAX_RAM_SIZE)
-    print_size_line("Flash", flash, app_size)
-    return True
-
-
-def get_idedata(ccache: str | None = None) -> dict | None:
-    """Derive idedata from the build's compile_commands.json (same
-    contract as ``espidf.toolchain.get_idedata``)."""
-    from esphome.build_helpers.idedata import load_or_build_idedata
-
-    # A disabled ccache resolves to None without spawning anything, so
-    # re-resolving here costs nothing when the caller has no answer
-    launcher = ccache or resolve_absolute_ccache_path()
-    return load_or_build_idedata(
-        get_build_dir() / "compile_commands.json",
-        get_elf_path(),
-        # Suffixed so a platformio->arduino->platformio round trip on one
-        # config never serves the other toolchain's cache shape
-        CORE.relative_internal_path("idedata", f"{CORE.name}.arduino.json"),
-        # The compile DB's commands carry the same ccache prefix the ninja
-        # rules were generated with
-        launcher=str(launcher) if launcher else None,
-    )
@@ -1,8 +1,5 @@
-from collections.abc import Callable
 from dataclasses import dataclass, field
 import logging
-import string
-from typing import Any

 import esphome.codegen as cg
 import esphome.config_validation as cv
@@ -21,17 +18,15 @@ from esphome.const import (
    CONF_TYPE_ID,
    CONF_UPDATE_INTERVAL,
 )
-from esphome.core import CORE, ID, EsphomeError, Lambda
+from esphome.core import ID, Lambda
 from esphome.cpp_generator import (
-    FlashStringLiteral,
    LambdaExpression,
    MockObj,
    MockObjClass,
    TemplateArgsType,
-    call_lambda,
 )
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
-from esphome.types import ConfigType, SafeExpType
+from esphome.types import ConfigType
 from esphome.util import Registry


@@ -62,7 +57,6 @@ def maybe_conf(conf, *validators):
        with cv.remove_prepend_path([conf]):
            return validator({conf: value})

-    validate.inner_schema = validator
    return validate


@@ -108,101 +102,6 @@ def register_condition(name: str, condition_type: MockObjClass, schema: cv.Schem
    return CONDITION_REGISTRY.register(name, condition_type, schema)


-async def _build_with_parent(
-    config: ConfigType,
-    automation_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(automation_id, template_arg, parent)
-
-
-async def _build_without_parent(
-    config: ConfigType,
-    automation_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    return cg.new_Pvariable(automation_id, template_arg)
-
-
-async def _build_parented(
-    config: ConfigType,
-    automation_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(automation_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-def register_simple_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    synchronous: bool,
-) -> None:
-    """Register an action whose constructor takes the object named by ``config[CONF_ID]``.
-
-    Use the ``register_action`` decorator instead when the builder must also set fields.
-    """
-    register_action(name, action_type, schema, synchronous=synchronous)(
-        _build_with_parent
-    )
-
-
-def register_simple_condition(
-    name: str, condition_type: MockObjClass, schema: cv.Schema
-) -> None:
-    """Condition counterpart of ``register_simple_action``."""
-    register_condition(name, condition_type, schema)(_build_with_parent)
-
-
-def register_bare_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    synchronous: bool,
-) -> None:
-    """Register an action whose constructor takes no arguments."""
-    register_action(name, action_type, schema, synchronous=synchronous)(
-        _build_without_parent
-    )
-
-
-def register_bare_condition(
-    name: str, condition_type: MockObjClass, schema: cv.Schema
-) -> None:
-    """Condition counterpart of ``register_bare_action``."""
-    register_condition(name, condition_type, schema)(_build_without_parent)
-
-
-def register_parented_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    synchronous: bool,
-) -> None:
-    """Register an action deriving from ``Parented<T>``.
-
-    The object is constructed without arguments and ``set_parent()`` receives the object
-    named by ``config[CONF_ID]``.
-    """
-    register_action(name, action_type, schema, synchronous=synchronous)(_build_parented)
-
-
-def register_parented_condition(
-    name: str, condition_type: MockObjClass, schema: cv.Schema
-) -> None:
-    """Condition counterpart of ``register_parented_action``."""
-    register_condition(name, condition_type, schema)(_build_parented)
-
-
 Action = cg.esphome_ns.class_("Action")
 Trigger = cg.esphome_ns.class_("Trigger")
 ACTION_REGISTRY = Registry()
@@ -213,308 +112,6 @@ validate_action_list = cv.validate_registry("action", ACTION_REGISTRY)
 validate_condition = cv.validate_registry_entry("condition", CONDITION_REGISTRY)
 validate_condition_list = cv.validate_registry("condition", CONDITION_REGISTRY)

-ApplyAction = cg.esphome_ns.class_("ApplyAction", Action)
-ApplyCondition = cg.esphome_ns.class_("ApplyCondition", Condition)
-
-
-def flash_string(config: ConfigType, value: str) -> str:
-    """Default renderer for ``std::string`` constants; copies the literal out of flash on ESP8266."""
-    if CORE.is_esp8266:
-        return f"progmem_string({FlashStringLiteral(value)})"
-    return str(cg.safe_exp(value))
-
-
-def literal_with_length(config: ConfigType, value: str) -> str:
-    """Renderer for a ``(const char *, size_t)`` target: a plain literal plus its byte length.
-
-    The target compares or copies the bytes in place, so it needs the RAM literal rather than
-    the PROGMEM rendering on ESP8266, and the length saves a strlen.
-    """
-    return f"{cg.safe_exp(value)}, {len(value.encode('utf-8'))}"
-
-
-@dataclass(frozen=True)
-class ApplyCall:
-    """One statement from config keys, e.g. ``"set_range({}, {})"`` with ``((CONF_LOW, cg.float_), ...)``.
-
-    Each arg is ``(conf_key, type_)`` or ``(conf_key, type_, const_fn)``. A ``conf_key`` may be a
-    path into nested sections. A plain ``str`` ``type_`` is raw C++ type text and may use
-    ``{parent}``. ``const_fn(config, value)`` renders a constant's argument text; a lambda or an
-    id bypasses it. The statement is skipped when none of its keys is set, always emitted when it
-    has no keys, and a partial set is a config error.
-    """
-
-    target: str
-    args: tuple[tuple[Any, ...], ...] = ()
-
-    def __post_init__(self) -> None:
-        fields = [
-            f for _, f, _, _ in string.Formatter().parse(self.target) if f is not None
-        ]
-        if any(fields):
-            raise ValueError(
-                f"apply target {self.target!r}: only bare {{}} placeholders"
-            )
-        if len(fields) != len(self.args):
-            raise ValueError(
-                f"apply target {self.target!r} has {len(fields)} "
-                f"placeholder(s) for {len(self.args)} config key(s)"
-            )
-        if any(len(arg) not in (2, 3) for arg in self.args):
-            raise ValueError(
-                f"apply target {self.target!r}: each arg is (conf_key, type_[, const_fn])"
-            )
-
-    @property
-    def members(self) -> list[tuple[Any, Any, Any]]:
-        """Each arg as ``(conf_key, type_, const_fn or None)``."""
-        return [
-            (arg[0], arg[1], arg[2] if len(arg) == 3 else None) for arg in self.args
-        ]
-
-
-@dataclass(frozen=True)
-class ApplyField:
-    """One config key forwarded as ``target(value)``, or as statement ``target`` when it has ``{}``.
-
-    Double a literal brace in a template. ``conf_key`` may be a path into nested sections.
-    ``type_`` may be a C++ type string using ``{parent}`` when the type is only known per
-    instance. ``const_fn(config, value)`` renders a constant's argument text when ``cg.safe_exp``
-    is not the right spelling (unit conversion belongs in the validator); a lambda or an id
-    bypasses it, so the target must also take a plain ``type_``. An absent key emits nothing.
-    """
-
-    conf_key: str | tuple[str, ...]
-    target: str
-    type_: SafeExpType
-    const_fn: Callable[[ConfigType, Any], str] | None = None
-
-    def call(self) -> ApplyCall:
-        target = self.target if "{}" in self.target else f"{self.target}({{}})"
-        return ApplyCall(target, ((self.conf_key, self.type_, self.const_fn),))
-
-
-def _config_lookup(config: ConfigType, key: str | tuple[str, ...]) -> Any:
-    if isinstance(key, str):
-        return config.get(key)
-    for part in key:
-        if (config := config.get(part)) is None:
-            return None
-    return config
-
-
-def _dict_schema(schema: Any) -> Any:
-    """The dict-backed cv.Schema inside cv.All and maybe_* wrappers, or None; cv.Any is not inspected."""
-    if isinstance(schema, dict):
-        return cv.Schema(schema)
-    if isinstance(getattr(schema, "schema", None), dict):
-        return schema
-    if isinstance(schema, cv.All):
-        inner = schema.validators
-    else:
-        inner = (
-            getattr(schema, "inner_schema", None),
-        )  # maybe_conf / maybe_simple_value
-    for candidate in inner:
-        if candidate is not None and (found := _dict_schema(candidate)) is not None:
-            return found
-    return None
-
-
-def _check_key_in_schema(
-    name: str, schema: Any, conf_key: str | tuple[str, ...]
-) -> None:
-    """Reject a key path the schema does not have; a typo would otherwise be a silent no-op.
-
-    Only dict-backed schemas, also inside cv.All and maybe_* wrappers, can be checked.
-    """
-    for part in (conf_key,) if isinstance(conf_key, str) else conf_key:
-        if (schema := _dict_schema(schema)) is None:
-            return
-        markers = {
-            getattr(marker, "schema", marker): marker for marker in schema.schema
-        }
-        if part not in markers:
-            raise ValueError(f"{name}: config key {part!r} is not in the schema")
-        schema = schema.schema[markers[part]]
-
-
-async def _apply_parent(config: ConfigType, id_key: str = CONF_ID) -> str:
-    # Global-scope qualified so a trigger arg named like the id cannot shadow it.
-    return f"::{await cg.get_variable(config[id_key])}"
-
-
-def _apply_lambda_args(args: TemplateArgsType) -> TemplateArgsType:
-    # The generated function's parameters; a std::string arg is never copied.
-    return [
-        (cg.RawExpression(f"const std::remove_cvref_t<{cg.safe_exp(t)}> &"), arg)
-        for t, arg in args
-    ]
-
-
-def _apply_function(
-    id_: ID,
-    return_type: SafeExpType,
-    template_arg: cg.TemplateArguments,
-    lambda_args: TemplateArgsType,
-    statements: list[str],
-) -> MockObj:
-    """Emit the generated function and declare ``id_`` as the ``ApplyAction`` or
-    ``ApplyCondition`` templated on it, so ``play()`` calls it directly."""
-    fn = cg.static_function(
-        f"esphome__{id_.id}__fn", return_type, lambda_args, statements
-    )
-    return cg.new_Pvariable(id_, cg.TemplateArguments(fn, *template_arg))
-
-
-async def _render_values(
-    name: str,
-    target: str,
-    members: list[tuple[Any, Any, Any]],
-    values: list[Any],
-    config: ConfigType,
-    parent: str,
-    lambda_args: TemplateArgsType,
-    compare: bool = False,
-) -> list[str]:
-    """Render the argument text of one statement; every key must be present.
-
-    ``compare``: an inlined lambda expression is parenthesized so it binds as a whole
-    beside an operator.
-    """
-    if any(value is None for value in values):
-        keys = [key for key, _, _ in members]
-        raise EsphomeError(f"{name}: {target!r} needs all of {keys}")
-    exprs: list[str] = []
-    for (_, type_, const_fn), value in zip(members, values, strict=True):
-        if isinstance(value, Lambda):
-            if isinstance(type_, str):
-                type_ = cg.RawExpression(type_.format(parent=parent))
-            inner = await cg.process_lambda(value, lambda_args, return_type=type_)
-            expr = call_lambda(inner)
-            bare = compare and isinstance(expr, cg.RawExpression)
-            exprs.append(f"({expr})" if bare else str(expr))
-        elif isinstance(value, ID):
-            # Qualified like the parent, so a trigger arg named like the id cannot shadow it.
-            exprs.append(f"::{await cg.get_variable(value)}")
-        elif const_fn is not None:
-            exprs.append(const_fn(config, value))
-        else:
-            exprs.append(str(cg.safe_exp(value)))
-    return exprs
-
-
-def _apply_values(config: ConfigType, members: list[tuple[Any, Any, Any]]) -> list[Any]:
-    return [_config_lookup(config, key) for key, _, _ in members]
-
-
-def register_apply_action(
-    name: str,
-    schema: cv.Schema,
-    *fields: ApplyField | ApplyCall,
-    call: str | None = None,
-    id_key: str = CONF_ID,
-) -> None:
-    """Register an action that only forwards config values to its parent, with no C++ class.
-
-    Generates one static function with the parent (read from ``id_key``) and constants baked
-    in, lambdas called inline with the trigger args, and an ``ApplyAction`` templated on it.
-    A constant that is an id (``cv.use_id`` under ``cv.templatable``) is the object it names.
-    With ``call`` every statement targets the call object ``auto apply_call = parent->call()``,
-    and ``apply_call.perform()`` is appended.
-    """
-    # An action stores the value, so a std::string constant stays in flash on ESP8266.
-    statements_spec = [
-        (
-            c.target,
-            [
-                (key, t, fn or (flash_string if t is cg.std_string else None))
-                for key, t, fn in c.members
-            ],
-        )
-        for c in (f if isinstance(f, ApplyCall) else f.call() for f in fields)
-    ]
-    _check_key_in_schema(name, schema, id_key)
-    for _, members in statements_spec:
-        for conf_key, _, _ in members:
-            _check_key_in_schema(name, schema, conf_key)
-
-    async def builder(
-        config: ConfigType,
-        action_id: ID,
-        template_arg: cg.TemplateArguments,
-        args: TemplateArgsType,
-    ) -> MockObj:
-        parent = await _apply_parent(config, id_key)
-        lambda_args = _apply_lambda_args(args)
-        receiver = "apply_call." if call else f"{parent}->"
-        statements: list[str] = []
-        for target, members in statements_spec:
-            values = _apply_values(config, members)
-            if members and all(value is None for value in values):
-                continue
-            exprs = await _render_values(
-                name, target, members, values, config, parent, lambda_args
-            )
-            statements.append(f"{receiver}{target.format(*exprs)};")
-        if call:
-            statements = [
-                f"auto apply_call = {parent}->{call}();",
-                *statements,
-                "apply_call.perform();",
-            ]
-        return _apply_function(
-            action_id, cg.void, template_arg, lambda_args, statements
-        )
-
-    register_action(name, ApplyAction, schema, synchronous=True)(builder)
-
-
-def register_apply_condition(
-    name: str, schema: cv.Schema, check: str | ApplyCall, id_key: str = CONF_ID
-) -> None:
-    """Register a condition that is one expression on its parent, with no C++ class.
-
-    ``check`` is applied to the parent: ``"is_playing()"`` becomes ``parent->is_playing()``; an
-    ``ApplyCall`` such as ``ApplyCall("state == {}", ((CONF_STATE, cg.bool_),))`` compares
-    against config values, all of which must be present. Write ``== false`` to negate.
-    String constants are plain literals, so compare a ``std::string`` or ``StringRef`` member.
-    Generates one static predicate and an ``ApplyCondition`` templated on it.
-    """
-    call = check if isinstance(check, ApplyCall) else ApplyCall(check)
-    members = call.members
-    _check_key_in_schema(name, schema, id_key)
-    for conf_key, _, _ in members:
-        _check_key_in_schema(name, schema, conf_key)
-
-    async def builder(
-        config: ConfigType,
-        condition_id: ID,
-        template_arg: cg.TemplateArguments,
-        args: TemplateArgsType,
-    ) -> MockObj:
-        parent = await _apply_parent(config, id_key)
-        lambda_args = _apply_lambda_args(args)
-        exprs = await _render_values(
-            name,
-            call.target,
-            members,
-            _apply_values(config, members),
-            config,
-            parent,
-            lambda_args,
-            compare=True,
-        )
-        return _apply_function(
-            condition_id,
-            cg.bool_,
-            template_arg,
-            lambda_args,
-            [f"return {parent}->{call.target.format(*exprs)};"],
-        )
-
-    register_condition(name, ApplyCondition, schema)(builder)
-

 def validate_potentially_and_condition(value):
    if isinstance(value, list):
@@ -762,15 +359,28 @@ async def for_condition_to_code(
    return var


-register_apply_condition(
+@register_condition(
    "component.is_idle",
+    LambdaCondition,
    maybe_simple_id(
        {
            cv.Required(CONF_ID): cv.use_id(cg.Component),
        }
    ),
-    "is_idle()",
 )
+async def component_is_idle_condition_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    comp = await cg.get_variable(config[CONF_ID])
+    lambda_ = await cg.process_lambda(
+        Lambda(f"return {comp}->is_idle();"), args, return_type=bool
+    )
+    return new_lambda_pvariable(
+        condition_id, lambda_, StatelessLambdaCondition, template_arg
+    )


@register_action(
@@ -924,20 +534,44 @@ async def lambda_action_to_code(
    return new_lambda_pvariable(action_id, lambda_, StatelessLambdaAction, template_arg)


-register_simple_action(
+@register_action(
    "component.update",
    UpdateComponentAction,
-    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(cg.PollingComponent)}),
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
+        }
+    ),
    synchronous=True,
 )
+async def component_update_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    comp = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, comp)


-register_simple_action(
+@register_action(
    "component.suspend",
    SuspendComponentAction,
-    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(cg.PollingComponent)}),
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
+        }
+    ),
    synchronous=True,
 )
+async def component_suspend_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    comp = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, comp)


@register_action(
@@ -4,14 +4,6 @@ import json
 import logging
 from pathlib import Path

-from esphome.build_helpers import pch
-from esphome.build_helpers.pch import (
-    PCH_DEFAULT_HEADERS,
-    PCH_HEADER_NAME,
-    mark_pch_emitted,
-    pch_enabled,
-    pch_header_text,
-)
 from esphome.components.esp32 import (
    get_esp32_variant,
    get_excluded_builtin_components,
@@ -98,10 +90,9 @@ def get_project_cmakelists(
    """
    idf_target = variant_to_idf_target(get_esp32_variant())

-    # esp_idf_size 2.x (IDF >=6.0) made NG the default and removed --ng;
-    # 1.x (IDF 5.5) needs --ng for --format=json2. 1.x json2 also lacks
-    # total_size, hence the ELF fallback in espidf/size_summary.py; both
-    # go away together when 1.x support is dropped.
+    # esp_idf_size 2.x (bundled with IDF >=6.0) made NG the default and
+    # removed the --ng flag; on 1.x (IDF 5.5) --ng is required to get
+    # --format=raw because the legacy mode doesn't support it.
    size_ng_flag = "--ng" if idf_version() < cv.Version(6, 0, 0) else ""

    # Project-wide compile options: -D defines and -W warning flags (skip
@@ -220,12 +211,10 @@ include($ENV{{IDF_PATH}}/tools/cmake/project.cmake)

 project({CORE.name})

-# Emit per-memory-type JSON size data for ESPHome to read post-build.
-# json2 stays small; raw dumps every symbol (~2s on a large map) and
-# this command runs inside the link edge, blocking everything downstream.
+# Emit raw JSON size data for ESPHome to read post-build.
 add_custom_command(
    TARGET ${{CMAKE_PROJECT_NAME}}.elf POST_BUILD
-    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=json2
+    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=raw
            -o ${{CMAKE_BINARY_DIR}}/esp_idf_size.json
            ${{CMAKE_PROJECT_NAME}}.map
    WORKING_DIRECTORY ${{CMAKE_BINARY_DIR}}
@@ -290,67 +279,9 @@ idf_component_register(
 target_link_options(${{COMPONENT_LIB}} PUBLIC
    {link_opts_str}
 )
-{_pch_cmake()}"""
-
-
-def _pch_cmake() -> str:
-    """The src component's precompiled-header block (C++ TUs only).
-
-    The -include stays relative (resolved from the compiler cwd, the build
-    dir); an absolute path would poison ccache keys.
-    """
-    if not pch_enabled():
-        return ""
-    return f"""
-# ESPHome precompiled header (see esphome/build_helpers/pch.py).
-# OBJECT_DEPENDS is on the header, not the .gch: pch-baked headers drop
-# out of TU depfiles, and prepare_pch() touches the header on rebuild.
-target_compile_options(${{COMPONENT_LIB}} PRIVATE
-    "$<$<COMPILE_LANGUAGE:CXX>:-Winvalid-pch>"
-    "$<$<COMPILE_LANGUAGE:CXX>:-include>"
-    "$<$<COMPILE_LANGUAGE:CXX>:{PCH_HEADER_NAME}>"
-)
-set_source_files_properties(${{app_sources}} PROPERTIES
-    OBJECT_DEPENDS "${{CMAKE_BINARY_DIR}}/{PCH_HEADER_NAME}")
 """


-def discard_pch() -> None:
-    """Drop the pch sidecars in the IDF build dir."""
-    pch.discard_pch(CORE.relative_build_path("build"))
-
-
-def prepare_pch() -> None:
-    """Build the .gch right before ninja, after every reconfigure, so the
-    compile_commands.json flags and the sdkconfig are the settled ones."""
-    if not pch_enabled():
-        # Self-cleaning escape hatch: drop any previously built .gch
-        pch.discard_pch(CORE.relative_build_path("build"))
-        return
-    sdkconfig_path = CORE.relative_build_path(f"sdkconfig.{CORE.name}")
-    try:
-        sdkconfig = sdkconfig_path.read_text(encoding="utf-8")
-    except OSError as err:
-        # Fail closed: the sdkconfig is the .sum's only config identity for
-        # sdkconfig.h-only options; a stand-in marker would collide
-        _LOGGER.warning(
-            "Could not read %s; compiling without the pch: %s", sdkconfig_path, err
-        )
-        pch.discard_pch(CORE.relative_build_path("build"))
-        return
-    pch.prepare_pch(
-        CORE.relative_build_path("build"),
-        PCH_DEFAULT_HEADERS,
-        (
-            str(idf_version()),
-            CORE.cpp_standard or "",
-            sdkconfig,
-            *get_project_compile_flags(),
-            *get_project_cxx_compile_flags(),
-        ),
-    )
-
-
 def write_project(
    minimal: bool = False, builtin_components: list[str] | None = None
 ) -> None:
@@ -370,14 +301,6 @@ def write_project(
        get_component_cmakelists(),
    )

-    if pch_enabled():
-        write_file_if_changed(
-            CORE.relative_build_path("build", PCH_HEADER_NAME),
-            pch_header_text(PCH_DEFAULT_HEADERS),
-        )
-        # Consumers carry the -include; gate the ccache relaxation on it
-        mark_pch_emitted()
-
    # Snapshot the exclusion set so has_outdated_files() can trigger a
    # discovery reconfigure when it changes. Excluded components never
    # register in project_description.json, so re-including one (e.g. a
@@ -1,272 +0,0 @@
-"""Native ninja build generator for the host platform.
-
-Emits ``build.ninja`` under ``.pioenvs/<name>/``: every source in the
-generated ``src/`` tree plus the resolved registry libraries compiles with
-the machine's compiler and links into ``program``, the name PlatformIO's
-native platform produced. Build flags route the way SCons's ``ParseFlags``
-did under PlatformIO: ``-D``/``-I``/``-std=``/``-W`` shapes reach the
-compile lines only, ``-l``/``-L``/``-Wl,`` the link line only, everything
-else both.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-import logging
-import os
-from pathlib import Path
-import sys
-from typing import TYPE_CHECKING
-
-from esphome.build_helpers.ninja import escape as _e, quote_path as _q, shell_token
-from esphome.build_helpers.ninja_gen import (
-    PATH_ARG_FLAGS,
-    Flag,
-    anchor_path_flag,
-    ar_rule_lines,
-    collect_sources,
-    compile_edges,
-    compile_rule_lines,
-    library_edges,
-    tool_lines,
-)
-from esphome.core import CORE, EsphomeError
-from esphome.framework_helpers import get_project_cxx_compile_flags
-from esphome.helpers import mkdir_p, write_file_if_changed
-from esphome.host.toolchain import PROGRAM_NAME, HostCompilers, find_tool, get_build_dir
-from esphome.platformio.library import lex_build_flags
-
-if TYPE_CHECKING:
-    from esphome.arduino.library import ArduinoLibrary
-
-_LOGGER = logging.getLogger(__name__)
-
-# The PlatformIO platform the host built under; registry manifests declare
-# compatibility against it, as lib_compat_mode=strict checked before
-PIO_PLATFORM = "native"
-# Namespaces the shared library download cache (pio_components/host/)
-LIBRARY_CACHE_KEY = "host"
-
-# Flag shapes that only the compiler understands; dropped from the link line
-_COMPILE_ONLY_PREFIXES = ("-D", "-U", "-I", "-std=", "-W", *PATH_ARG_FLAGS)
-# Flag shapes that only the linker consumes; inert on a -c compile line
-_LINK_ONLY_PREFIXES = ("-l", "-L", "-Wl,")
-# Link-only flags whose argument is the next token
-_LINK_ONLY_ARG_FLAGS = ("-framework", "-Xlinker", "-z")
-
-
-def parse_flags(entries: Iterable[str], owner: str) -> list[Flag]:
-    """Lex build flag entries into flags, each with its argument.
-
-    Entries are a set, so their order is not the user's: a flag and the
-    argument it takes as the next token must share one entry.
-    """
-    flags: list[Flag] = []
-    for entry in entries:
-        it = iter(lex_build_flags(entry, owner))
-        for tok in it:
-            if tok not in PATH_ARG_FLAGS and tok not in _LINK_ONLY_ARG_FLAGS:
-                flags.append((tok,))
-                continue
-            arg = next(it, None)
-            # A path never starts with "-"; that is the next flag
-            if arg is None or (tok in PATH_ARG_FLAGS and arg.startswith("-")):
-                raise EsphomeError(
-                    f"{owner} build flags have '{tok}' with no argument; write "
-                    f"the flag and its argument as one entry"
-                )
-            flags.append((tok, arg))
-    return flags
-
-
-def split_flags(flags: list[Flag]) -> tuple[list[Flag], list[Flag]]:
-    """Route build flags to the compile and link lines."""
-    compile_flags: list[Flag] = []
-    link_flags: list[Flag] = []
-    for flag in flags:
-        name = flag[0]
-        if len(flag) > 1:
-            (compile_flags if name in PATH_ARG_FLAGS else link_flags).append(flag)
-        elif name.startswith(_LINK_ONLY_PREFIXES):
-            # Checked before the compile prefixes: -Wl, would match -W
-            link_flags.append(flag)
-        elif name.startswith(_COMPILE_ONLY_PREFIXES):
-            compile_flags.append(flag)
-        else:
-            # -g, -O, -f*, -m*, -pthread, --coverage: both lines, as SCons
-            compile_flags.append(flag)
-            link_flags.append(flag)
-    return compile_flags, link_flags
-
-
-def _is_std(flag: Flag) -> bool:
-    return flag[0].startswith("-std=")
-
-
-def _is_cxx_std(flag: Flag) -> bool:
-    return _is_std(flag) and "++" in flag[0]
-
-
-def _anchored_flags(entries: Iterable[str], owner: str) -> list[Flag]:
-    build_path = Path(CORE.build_path)
-    return [
-        anchor_path_flag(flag, build_path)
-        for flag in parse_flags(sorted(entries), owner)
-    ]
-
-
-def _flag_lists() -> tuple[list[str], list[str], list[str]]:
-    """The C, C++, and link flag lists (raw tokens), build_unflags applied.
-
-    ``cg.set_cpp_standard`` wins over any ``-std=`` in the build flags for
-    C++ compiles, as PlatformIO's unflag of every other standard did; C
-    compiles never see a C++ standard.
-    """
-    # The funnel warns and drops empty glued arguments (-D "") itself
-    compile_flags, link_flags = split_flags(
-        _anchored_flags(CORE.build_flags, "esphome")
-    )
-    cflags = [f for f in compile_flags if not _is_cxx_std(f)]
-    cxx_std = CORE.cpp_standard
-    cxxflags = [f for f in compile_flags if not (cxx_std and _is_std(f))]
-    if cxx_std:
-        cxxflags.insert(0, (f"-std={cxx_std}",))
-    cxxflags += [(tok,) for tok in get_project_cxx_compile_flags()]
-
-    # A flag is removed whole, with its argument, as PlatformIO did
-    unflags = set(_anchored_flags(CORE.build_unflags, "esphome build_unflags"))
-    # An unflag that hits nothing (a typo, or -DUSE_FOO against
-    # -DUSE_FOO=1) must be visible, since the user believes the flag is
-    # gone while it still drives the build
-    if unmatched := sorted(unflags - set(cflags) - set(cxxflags) - set(link_flags)):
-        _LOGGER.warning(
-            "build_unflags entries matched no build flag: %s",
-            ", ".join(" ".join(flag) for flag in unmatched),
-        )
-
-    def keep(flags: list[Flag]) -> list[str]:
-        return [tok for flag in flags if flag not in unflags for tok in flag]
-
-    return keep(cflags), keep(cxxflags), keep(link_flags)
-
-
-def _resolve_host_libraries() -> list[ArduinoLibrary]:
-    """Every ``cg.add_library()`` entry, fetched from the registry.
-
-    The host has no framework, so nothing is bundled and no framework
-    compatibility check applies; the platform check keeps the strict
-    manifest gate PlatformIO's native platform enforced. Manifest-less
-    libraries (a bare git checkout) build with PlatformIO's default
-    layout, as they did under its native platform.
-    """
-    if not CORE.platformio_libraries:
-        return []
-    from esphome.arduino.library import resolve_libraries
-
-    return resolve_libraries(
-        None,
-        pio_platform=PIO_PLATFORM,
-        board_mcu="host",
-        cache_key=LIBRARY_CACHE_KEY,
-        framework=None,
-        manifest_optional=True,
-    )
-
-
-def _file_macro_maps(build_dir: Path) -> list[str]:
-    """Flags that keep ``__FILE__`` relative to the build path.
-
-    PlatformIO compiled ``src/x.cpp`` from the build path, and tools name
-    things after that spelling (CodSpeed's benchmark ids). Here a source
-    reaches the compiler by its absolute path, or relative to the build
-    directory when ccache rewrites it.
-    """
-    build_path = Path(CORE.build_path)
-    prefixes = (build_path, Path(os.path.relpath(build_path, build_dir)))
-    return [
-        shell_token(f"-fmacro-prefix-map={prefix}{os.sep}=", force=True)
-        for prefix in prefixes
-    ]
-
-
-def write_project(compilers: HostCompilers, ccache: str | None) -> bool:
-    """Write the ninja build for the current configuration.
-
-    ``ccache`` is the caller's already-resolved binary (None when disabled).
-    Returns True when ``build.ninja`` changed, so the caller can skip work
-    derived purely from it (the compile database) on unchanged builds.
-    """
-    build_dir = get_build_dir()
-    mkdir_p(build_dir)
-    src_dir = CORE.relative_src_path()
-    if not src_dir.is_dir():
-        # Generated project state, not install state: clean-all would not help
-        raise EsphomeError(f"Generated source directory {src_dir} is missing")
-
-    cflags, cxxflags, link_flags = _flag_lists()
-    libraries = _resolve_host_libraries()
-
-    include_dirs = [src_dir]
-    for lib in libraries:
-        include_dirs += lib.include_dirs
-    includes = [f"-I{_q(d)}" for d in include_dirs]
-    includes += _file_macro_maps(build_dir)
-
-    # SCons's link line: $LINKFLAGS $SOURCES $_LIBDIRFLAGS $_LIBFLAGS, so
-    # -L and -l trail the objects while every other link token leads
-    lib_dirs = [Path(t[2:]) for t in link_flags if t.startswith("-L")]
-    libs = [t for t in link_flags if t.startswith("-l")]
-    linkflags = [shell_token(t) for t in link_flags if not t.startswith(("-L", "-l"))]
-    for lib in libraries:
-        lib_dirs += lib.link_dirs
-        libs += [f"-l{name}" for name in lib.link_libs]
-        linkflags += [shell_token(f) for f in lib.link_flags]
-
-    # PlatformIO's ASPPCOM passes only -D/-I user flags to assembly
-    asflags = [t for t in cflags if t.startswith(("-D", "-I"))]
-
-    lines = [
-        *tool_lines(compilers.cc, compilers.cxx, ccache),
-        *compile_rule_lines(),
-        "rule link",
-        "  command = $cxx -o $out $linkflags @$out.rsp $archives $libdirflags $libflags",
-        "  rspfile = $out.rsp",
-        "  rspfile_content = $in_newline",
-        "  description = LINK $out",
-    ]
-    if any(lib.sources and lib.lib_archive for lib in libraries):
-        # Resolved only when an archive is built, so a system without
-        # binutils still links a library-free configuration
-        lines += ar_rule_lines(find_tool("AR", ("ar",)))
-    lines += [
-        "",
-        f"cflags = {' '.join([*map(shell_token, cflags), *includes])}",
-        f"cxxflags = {' '.join([*map(shell_token, cxxflags), *includes])}",
-        f"asflags = {' '.join([*map(shell_token, asflags), *includes])}",
-        f"linkflags = {' '.join(linkflags)}",
-        f"libdirflags = {' '.join(f'-L{_q(d)}' for d in lib_dirs)}",
-        f"libflags = {' '.join(shell_token(lib) for lib in libs)}",
-        "",
-    ]
-
-    archives, direct_objs = library_edges(lines, libraries)
-
-    src_objs = compile_edges(lines, collect_sources(src_dir), src_dir, "src")
-    if not src_objs:
-        raise EsphomeError(f"No source files found under {src_dir}")
-
-    # Archives are not topologically sorted; GNU ld needs the group to
-    # resolve references between them. ld64 loads archives iteratively and
-    # rejects the option, so macOS lists them bare.
-    archive_tokens = [shell_token(a) for a in archives]
-    if archive_tokens and sys.platform != "darwin":
-        archive_tokens = ["-Wl,--start-group", *archive_tokens, "-Wl,--end-group"]
-    lines.append(
-        f"build {PROGRAM_NAME}: link {' '.join(src_objs + direct_objs)} | "
-        f"{' '.join(_e(a) for a in archives)}"
-    )
-    lines.append(f"  archives = {' '.join(archive_tokens)}")
-    lines.append(f"default {PROGRAM_NAME}")
-    lines.append("")
-
-    return write_file_if_changed(build_dir / "build.ninja", "\n".join(lines))
@@ -68,15 +68,6 @@ def resolve_ccache_path() -> str | None:
    return ccache


-def resolve_absolute_ccache_path() -> str | None:
-    """``resolve_ccache_path`` for the ninja backends, which run their
-    commands from the build directory, where a relative path is lost."""
-    from esphome.build_helpers.ninja import absolute_tool
-
-    ccache = resolve_ccache_path()
-    return absolute_tool(ccache) if ccache else None
-
-
 def ccache_defaults_env(cache_dir: Path) -> dict[str, str]:
    """Default ``CCACHE_*`` values for a build subprocess (not os.environ).

@@ -93,39 +84,9 @@ def ccache_defaults_env(cache_dir: Path) -> dict[str, str]:
            "CORE.build_path must be set before constructing the build environment"
        )
    defaults = {
-        # ccache expands $VAR in its settings; $$ is a literal $
-        "CCACHE_DIR": str(cache_dir).replace("$", "$$"),
+        "CCACHE_DIR": str(cache_dir),
        "CCACHE_NOHASHDIR": "true",
        "CCACHE_DEPEND": "1",
-        "CCACHE_BASEDIR": str(Path(CORE.build_path).resolve()).replace("$", "$$"),
+        "CCACHE_BASEDIR": str(Path(CORE.build_path).resolve()),
    }
    return {k: v for k, v in defaults.items() if k not in os.environ}
-
-
-def effective_ccache_basedir() -> str:
-    """The prefix ccache rewrites out of hashed paths: a user CCACHE_BASEDIR
-    wins, else the resolved build path (matching ccache_defaults_env)."""
-    from esphome.core import CORE
-
-    raw = os.environ.get("CCACHE_BASEDIR")
-    if raw is not None and Path(raw).is_absolute() and len(Path(raw).parts) > 1:
-        return raw
-    # Unset or degenerate ("", "/", relative): fall back to the build path
-    return str(Path(CORE.build_path).resolve())
-
-
-def ccache_env(ccache: str | None, tools_cache: tuple[str, str]) -> dict[str, str]:
-    """The ccache settings for a build subprocess (not os.environ).
-
-    ``ccache`` is the pre-resolved binary (resolve_ccache_path), or None when
-    disabled; ``tools_cache`` is the backend's tools cache spec, which holds
-    its ccache dir.
-    """
-    if ccache is None:
-        return {}
-    from esphome.build_helpers.pch import ccache_pch_env
-    from esphome.build_helpers.tools_cache import tools_cache_path
-
-    env = ccache_defaults_env(tools_cache_path(*tools_cache) / "ccache")
-    env.update(ccache_pch_env())
-    return env
@@ -11,7 +11,6 @@ consumers (IDE integration, clang-tidy) expect:

 from __future__ import annotations

-from collections.abc import Callable
 import json
 import logging
 import os
@@ -22,8 +21,6 @@ import subprocess
 from esphome.core import EsphomeError
 from esphome.helpers import write_file

-_LOGGER = logging.getLogger(__name__)
-
 # Everything idedata generation may raise after a successful link; idedata
 # is a bonus artifact, so consumers warn instead of failing the build
 IDEDATA_BEST_EFFORT_ERRORS = (
@@ -34,27 +31,13 @@ IDEDATA_BEST_EFFORT_ERRORS = (
    ValueError,
 )

+_LOGGER = logging.getLogger(__name__)

-def warn_if_idedata_missing(get_idedata: Callable[[], dict | None]) -> None:
-    """Run an idedata generator, downgrading any failure to a warning:
-    the firmware already built."""
-    try:
-        if get_idedata() is None:
-            _LOGGER.warning("No idedata was generated for this build")
-    except IDEDATA_BEST_EFFORT_ERRORS as err:
-        _LOGGER.warning(
-            "Could not generate idedata: %s (IDE, clang-tidy, and "
-            "memory-analysis data will be unavailable for this build)",
-            err,
-        )
-        _LOGGER.debug("Idedata failure detail", exc_info=True)
-
-
-# C++ translation-unit suffixes.
-CXX_SOURCE_SUFFIXES = (".cpp", ".cc", ".cxx")
+# C++ translation-unit suffixes used to identify ESPHome source files.
+_CXX_SUFFIXES = (".cpp", ".cc")
 # Suffixes of input/output files that appear bare on the command line (and so
 # must not be mistaken for compiler flags).
-_INPUT_FILE_SUFFIXES = (*CXX_SOURCE_SUFFIXES, ".c", ".o", ".S", ".s")
+_INPUT_FILE_SUFFIXES = (*_CXX_SUFFIXES, ".c", ".o", ".S", ".s")
 # Path marker identifying an ESPHome source translation unit.
 _ESPHOME_SRC_MARKER = "/src/esphome/"

@@ -63,11 +46,11 @@ def _is_esphome_src(file: str) -> bool:
    """Whether ``file`` is an ESPHome C++ translation unit; normalized to
    ``/`` first since Windows compile DBs use backslashes."""
    return _ESPHOME_SRC_MARKER in file.replace("\\", "/") and file.endswith(
-        CXX_SOURCE_SUFFIXES
+        _CXX_SUFFIXES
    )


-def split_command(command: str) -> list[str]:
+def _split_command(command: str) -> list[str]:
    r"""Tokenize a compile_commands.json / response-file command string.

    On Windows, tokenize per Windows ``argv`` rules via ``CommandLineToArgvW``.
@@ -103,7 +86,7 @@ def split_command(command: str) -> list[str]:
        ctypes.windll.kernel32.LocalFree(argv)


-def expand_response_files(tokens: list[str], directory: Path) -> list[str]:
+def _expand_response_files(tokens: list[str], directory: Path) -> list[str]:
    """Inline any ``@response-file`` arguments (paths relative to ``directory``).

    GCC response files embed flags that must be expanded so GCC-only flags
@@ -118,8 +101,8 @@ def expand_response_files(tokens: list[str], directory: Path) -> list[str]:
                rf = directory / rf
            try:
                out.extend(
-                    expand_response_files(
-                        split_command(rf.read_text(encoding="utf-8")), directory
+                    _expand_response_files(
+                        _split_command(rf.read_text(encoding="utf-8")), directory
                    )
                )
                continue
@@ -138,7 +121,7 @@ def _pick_entry(entries: list[dict]) -> dict:
        if _is_esphome_src(entry["file"]):
            return entry
    for entry in entries:
-        if entry["file"].endswith(CXX_SOURCE_SUFFIXES):
+        if entry["file"].endswith(_CXX_SUFFIXES):
            return entry
    raise ValueError("no C++ translation unit found in compile_commands.json")

@@ -148,25 +131,16 @@ def _pick_entry(entries: list[dict]) -> dict:
 _LAUNCHER_STEMS = frozenset({"ccache", "sccache", "distcc", "icecc", "buildcache"})


-def is_launcher(token: str) -> bool:
+def _is_launcher(token: str) -> bool:
    return Path(token).stem.lower() in _LAUNCHER_STEMS


-def is_joined_include(tok: str) -> bool:
-    """The joined ``-includefoo.h`` spelling; excludes clang's -include-pch."""
-    return (
-        tok.startswith("-include")
-        and tok != "-include"
-        and not tok.startswith("-include-")
-    )
-
-
 def parse_entry(
    entry: dict, launcher: str | None = None
 ) -> tuple[str, list[str], list[str], list[str]]:
    """Parse one compile_commands entry -> (cxx_path, defines, includes, cxx_flags)."""
    directory = Path(entry["directory"])
-    tokens = expand_response_files(split_command(entry["command"]), directory)
+    tokens = _expand_response_files(_split_command(entry["command"]), directory)

    def _include(raw: str) -> str:
        # Resolve against the entry's ``directory`` so cached idedata works
@@ -182,7 +156,7 @@ def parse_entry(
    if not tokens:
        # An empty command, or one that was only the launcher; fail by name
        raise ValueError(f"empty compile command for {entry.get('file')}")
-    if is_launcher(tokens[0]) and len(tokens) > 1 and not tokens[1].startswith("-"):
+    if _is_launcher(tokens[0]) and len(tokens) > 1 and not tokens[1].startswith("-"):
        # Stale DB built with a launcher this run no longer configures; the
        # real compiler is the next token
        _LOGGER.warning("Stripping unconfigured launcher %s", tokens[0])
@@ -195,23 +169,11 @@ def parse_entry(
    defines: list[str] = []
    includes: list[str] = []
    cxx_flags: list[str] = []
-    unresolved_force_includes: list[str] = []

    it = iter(tokens[1:])
    for tok in it:
        if tok in ("-c", "-o"):
            next(it, None)  # drop the flag and its argument (input/output)
-        elif tok == "-include" or is_joined_include(tok):
-            # Re-anchor only names next to the compile (the pch); a name
-            # meant for the -I chain must stay untouched
-            raw = next(it, "") if tok == "-include" else tok[len("-include") :]
-            if not raw:
-                _LOGGER.warning("Dropping -include with no argument")
-            elif Path(resolved := _include(raw)).is_file():
-                cxx_flags.extend(("-include", resolved))
-            else:
-                unresolved_force_includes.append(raw)
-                cxx_flags.extend(("-include", raw))
        elif tok.startswith("-D"):
            # ``.strip()`` handles tokens like ``-D CONFIGURED=1`` (a single
            # quoted arg with a space after -D) that some flags arrive as.
@@ -230,14 +192,6 @@ def parse_entry(
            pass  # input/output files
        else:
            cxx_flags.append(tok)
-    for raw in unresolved_force_includes:
-        # A deleted build artifact would otherwise surface only downstream
-        if not any((Path(inc) / raw).is_file() for inc in includes):
-            _LOGGER.warning(
-                "-include %s found neither next to the compile nor on the "
-                "include path; cached idedata may not resolve it",
-                raw,
-            )
    return cxx_path, defines, includes, cxx_flags


@@ -302,7 +256,7 @@ def _cache_usable(cached: object) -> bool:
    if not isinstance(cached, dict) or "cc_path" not in cached:
        return False
    cxx_path = cached.get("cxx_path")
-    if not isinstance(cxx_path, str) or is_launcher(cxx_path):
+    if not isinstance(cxx_path, str) or _is_launcher(cxx_path):
        return False
    includes = cached.get("includes")
    return isinstance(includes, dict) and isinstance(includes.get("build"), list)
@@ -350,7 +304,7 @@ def load_or_build_idedata(
 def reject_launcher_compiler(cxx_path: str) -> None:
    """Reject a compile DB naming a launcher (ccache) as the compiler; it
    must never be probed, cached, or consumed."""
-    if is_launcher(cxx_path):
+    if _is_launcher(cxx_path):
        raise EsphomeError(
            f"compile_commands.json names the launcher {cxx_path} as the "
            "compiler; the compile database is unusable"
@@ -1,74 +0,0 @@
-"""Resolution of the native (non-PlatformIO) build backend for a config.
-
-Kept deliberately light: the serial upload and logs fast path resolves a
-backend for its artifact paths alone, so importing this must not pull in a
-platform component package or the backend itself.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Collection
-import importlib
-import logging
-from types import ModuleType
-
-from esphome.const import Toolchain
-from esphome.core import CORE, EsphomeError
-
-_LOGGER = logging.getLogger(__name__)
-
-# Native build backend per (target platform, toolchain)
-NATIVE_TOOLCHAIN_MODULES = {
-    ("esp32", Toolchain.ESP_IDF): "esphome.espidf.toolchain",
-    ("esp8266", Toolchain.ARDUINO): "esphome.arduino8266.toolchain",
-    ("host", Toolchain.HOST): "esphome.host.toolchain",
-}
-
-
-def native_backend() -> ModuleType | None:
-    """The native build backend module for the resolved toolchain."""
-    if not CORE.using_native_toolchain:
-        return None
-    key = (CORE.target_platform, CORE.toolchain)
-    if (module_path := NATIVE_TOOLCHAIN_MODULES.get(key)) is None:
-        # Degrading to the PlatformIO path would build with the wrong backend
-        raise EsphomeError(
-            f"Toolchain '{CORE.toolchain.value}' has no native build backend "
-            f"module for platform {CORE.target_platform}"
-        )
-    return importlib.import_module(module_path)
-
-
-# Binutils and the linked image for memory analysis, for toolchains that build
-# without PlatformIO but have no native build backend (which supplies them)
-ANALYSIS_TOOLCHAIN_MODULES = {
-    ("nrf52", Toolchain.SDK_NRF): "esphome.components.nrf52.toolchain",
-}
-
-
-def analysis_backend() -> ModuleType | None:
-    """The module giving objdump, readelf and the ELF of a non-PlatformIO build.
-
-    None means PlatformIO's idedata supplies them (or nothing can).
-    """
-    if (native := native_backend()) is not None:
-        return native
-    module_path = ANALYSIS_TOOLCHAIN_MODULES.get((CORE.target_platform, CORE.toolchain))
-    return importlib.import_module(module_path) if module_path else None
-
-
-def warn_ignored_platformio_options(consumed: Collection[str]) -> None:
-    """Warn for component-added platformio options a native build drops.
-
-    User-supplied keys were already routed or warned about by
-    ``core/config.py``; what survives into ``CORE.platformio_options`` came
-    from ``cg.add_platformio_option`` calls in components.
-    """
-    for key in sorted(CORE.platformio_options or {}):
-        if key not in consumed:
-            _LOGGER.warning(
-                "platformio_options->%s is ignored when building with the "
-                "native '%s' toolchain",
-                key,
-                CORE.toolchain.value,
-            )
@@ -2,17 +2,14 @@

 from __future__ import annotations

-import json
 import logging
 import os
 from pathlib import Path
 import re
 import shutil
-import subprocess

 from esphome.core import EsphomeError
 from esphome.framework_helpers import strip_win_long_path_prefix, tool_version_runs
-from esphome.helpers import write_file_if_changed

 _LOGGER = logging.getLogger(__name__)

@@ -26,26 +23,11 @@ def _ninja_runs(binary: str) -> bool:
    )


-# Compile rule names the generators emit; ninja's compdb tool is asked for
-# exactly these, so a renamed rule fails the build instead of stranding idedata
-COMPILE_RULES = ("c", "cxx", "aspp", "asm")
-
-
-def absolute_tool(tool: str | Path) -> str:
-    """A tool path that still resolves from the build directory.
-
-    ``shutil.which`` returns a relative path for a relative PATH entry, and
-    ninja runs the commands from ``.pioenvs/<name>``. Symlinks are kept:
-    ccache's compiler links depend on the name they are called by.
-    """
-    return strip_win_long_path_prefix(str(Path(tool).absolute()))
-
-
 def find_ninja() -> Path:
    """Locate the ninja binary: a runnable PATH hit first, else the ninja
    PyPI wheel."""
    if binary := shutil.which("ninja"):
-        binary = absolute_tool(binary)
+        binary = strip_win_long_path_prefix(binary)
        if _ninja_runs(binary):
            return Path(binary)
    import_error: ImportError | None = None
@@ -67,18 +49,8 @@ def find_ninja() -> Path:


 def escape(value: Path | str) -> str:
-    """Escape a path or token for a ninja file.
-
-    ninja has no escape for ``|`` or a line break in a path, so those fail
-    here by name instead of producing a build file ninja misreads.
-    """
-    text = str(value)
-    if bad := next((c for c in "|\r\n" if c in text), None):
-        raise EsphomeError(
-            f"Path {text!r} contains {bad!r}, which a ninja build file cannot "
-            "express; rename the file or directory"
-        )
-    return text.replace("$", "$$").replace(":", "$:").replace(" ", "$ ")
+    """Escape a path or token for a ninja file."""
+    return str(value).replace("$", "$$").replace(":", "$:").replace(" ", "$ ")


 def quote_arg(tok: str) -> str:
@@ -118,65 +90,3 @@ def shell_token(tok: str, force: bool = False) -> str:
 def quote_path(value: Path | str) -> str:
    """Force-quote a path for the ninja command line (shell/CreateProcess)."""
    return shell_token(str(value), force=True)
-
-
-def refresh_compile_commands(
-    ninja_path: Path, build_dir: Path, env: dict[str, str], ninja_changed: bool
-) -> None:
-    """Regenerate the compile DB (a pure function of build.ninja) when stale.
-
-    Freshness rides a stamp: the DB itself is written through
-    write_file_if_changed (its mtime feeds the idedata cache), so a
-    regeneration with identical content would stay "stale" forever. An
-    interrupted previous run may have rewritten the manifest without
-    regenerating the DB, hence the mtime comparison.
-    """
-    compdb = build_dir / "compile_commands.json"
-    compdb_stamp = build_dir / ".compile_commands.stamp"
-    ninja_file = build_dir / "build.ninja"
-    if (
-        ninja_changed
-        or not compdb.is_file()
-        or not compdb_stamp.is_file()
-        or compdb_stamp.stat().st_mtime < ninja_file.stat().st_mtime
-    ):
-        write_compile_commands(ninja_path, build_dir, env)
-        compdb_stamp.touch()
-
-
-def write_compile_commands(
-    ninja_path: Path, build_dir: Path, env: dict[str, str]
-) -> None:
-    compdb = build_dir / "compile_commands.json"
-    result = subprocess.run(
-        [str(ninja_path), "-C", str(build_dir), "-t", "compdb", *COMPILE_RULES],
-        env=env,
-        capture_output=True,
-        text=True,
-        check=False,
-        close_fds=False,
-    )
-    if result.returncode != 0:
-        # Drop any stale database so consumers (IDE integration, clang-tidy,
-        # the memory analyzer) can't silently read outdated data
-        compdb.unlink(missing_ok=True)
-        raise EsphomeError(f"Could not generate compile_commands.json: {result.stderr}")
-    try:
-        entries = json.loads(result.stdout)
-    except ValueError as err:
-        compdb.unlink(missing_ok=True)
-        raise EsphomeError(
-            f"ninja produced an unparsable compile database: {err} "
-            f"(output starts {result.stdout[:120]!r})"
-        ) from err
-    if not entries:
-        # compdb exits 0 with [] for unknown rule names; a renamed compile
-        # rule must fail the build, not silently strand every consumer
-        compdb.unlink(missing_ok=True)
-        raise EsphomeError(
-            "ninja produced an empty compile database; the generator's rule "
-            "names no longer match"
-        )
-    # write_file_if_changed keeps the mtime stable on no-op builds so the
-    # idedata cache stays valid
-    write_file_if_changed(compdb, result.stdout)
@@ -1,309 +0,0 @@
-"""The parts of a ``build.ninja`` every native backend emits the same way.
-
-Rule names match ``SOURCE_KIND_FOR_SUFFIX`` values (c, cxx, asm, aspp) and
-``ninja.COMPILE_RULES``, which the compile database is asked for.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Collection, Sequence
-import logging
-import os
-from pathlib import Path
-import sys
-from typing import TYPE_CHECKING
-
-from esphome.build_helpers.ccache import effective_ccache_basedir
-from esphome.build_helpers.ninja import (
-    escape as _e,
-    quote_path as _q,
-    shell_token as _shell_token,
-)
-from esphome.build_helpers.pch import (
-    PCH_HEADER_NAME,
-    mark_pch_emitted,
-    pch_checksum,
-    pch_enabled,
-    pch_header_text,
-)
-from esphome.core import CORE
-from esphome.framework_helpers import strip_win_long_path_prefix
-from esphome.helpers import write_file_if_changed
-from esphome.platformio.library import SOURCE_KIND_FOR_SUFFIX
-
-if TYPE_CHECKING:
-    from esphome.arduino.library import ArduinoLibrary
-
-_LOGGER = logging.getLogger(__name__)
-
-_BUILD_TOOL = Path(__file__).parent.parent / "build_gen" / "build_tool.py"
-
-
-def collect_sources(root: Path, exclude: Collection[str] = frozenset()) -> list[Path]:
-    return sorted(
-        p
-        for p in root.rglob("*")
-        if p.suffix in SOURCE_KIND_FOR_SUFFIX and p.name not in exclude
-    )
-
-
-def common_parent(paths: list[Path]) -> Path:
-    return Path(os.path.commonpath([str(p.parent) for p in paths]))
-
-
-def _command(words: Sequence[Path | str]) -> str:
-    program, *args = words
-    return " ".join([_q(program), *(_shell_token(str(a)) for a in args)])
-
-
-def tool_lines(
-    cc: Sequence[Path | str], cxx: Sequence[Path | str], ccache: str | None
-) -> list[str]:
-    """The file header: the compilers and the helper tools as variables.
-
-    A compiler is its program followed by any arguments it always takes.
-    """
-    return [
-        "# Auto-generated by ESPHome",
-        "ninja_required_version = 1.5",
-        f"cc = {_command(cc)}",
-        f"cxx = {_command(cxx)}",
-        # The NSIS launcher starts Python with a \\?\ extended-length path
-        # that cmd.exe cannot spawn; same strip every other emitted binary
-        # path gets
-        f"python = {_q(strip_win_long_path_prefix(sys.executable))}",
-        f"buildtool = {_q(_BUILD_TOOL)}",
-        f"ccache = {_q(ccache) if ccache else ''}",
-        "",
-    ]
-
-
-def compile_rule_lines() -> list[str]:
-    """The compile rules; ``$own_includes`` is empty unless an edge sets it."""
-    return [
-        "rule c",
-        "  command = $ccache $cc -MMD -MF $out.d $own_includes $cflags $flags -c $in -o $out",
-        "  depfile = $out.d",
-        "  deps = gcc",
-        "  description = CC $out",
-        "rule cxx",
-        "  command = $ccache $cxx -MMD -MF $out.d $own_includes $cxxflags $flags -c $in -o $out",
-        "  depfile = $out.d",
-        "  deps = gcc",
-        "  description = CXX $out",
-        "rule aspp",
-        "  command = $ccache $cc -MMD -MF $out.d -x assembler-with-cpp $own_includes $asflags $flags -c $in -o $out",
-        "  depfile = $out.d",
-        "  deps = gcc",
-        "  description = AS $out",
-        # Plain assembler, as SCons's ASCOM: no preprocessor, so no
-        # depfile and no $flags (defines/includes) either
-        "rule asm",
-        "  command = $ccache $cc -x assembler $asflags -c $in -o $out",
-        "  description = AS $out",
-    ]
-
-
-def pch_rule_lines() -> list[str]:
-    """The precompiled header rule, for a generator that emits one."""
-    return [
-        # No $ccache: the .gch is compiled once per build dir and ccache
-        # cannot cache it usefully (its bytes embed build-dir paths)
-        "rule pch",
-        "  command = $cxx -MMD -MF $out.d -x c++-header $cxxflags $flags -c $in -o $out",
-        "  depfile = $out.d",
-        "  deps = gcc",
-        "  description = PCH $out",
-    ]
-
-
-def pch_edges(
-    lines: list[str],
-    build_dir: Path,
-    src_dir: Path,
-    headers: Sequence[str],
-    cxxflags: Sequence[str],
-    src_flags: Sequence[str],
-    ccache: str | None,
-    identity: Sequence[str],
-) -> tuple[str, str] | None:
-    """Emit the precompiled header for the C++ src edges.
-
-    ``headers`` are folded into one prefix header, ``src_flags`` are the
-    flags every src edge carries, and ``identity`` names what the compile
-    depends on beyond the headers and flags (versioned install paths).
-    Returns the ``cxx_override`` for ``compile_edges``, or None when the
-    build goes without a precompiled header.
-    """
-    if not pch_enabled():
-        return None
-    if any(tok.startswith("-include") for tok in cxxflags):
-        # $cxxflags expands first, so a user -include there means GCC would
-        # never load the .gch
-        _LOGGER.warning(
-            "A -include in build_flags prevents the precompiled header from "
-            "loading; compiling without it"
-        )
-        return None
-    pch_header = build_dir / PCH_HEADER_NAME
-    pch_text = pch_header_text(headers)
-    checksum = None
-    try:
-        if ccache:
-            # The .sum exists only for CCACHE_PCH_EXTSUM; ninja's depfile
-            # handles staleness. Strip resolved and raw build paths
-            # (symlinks) so identical configs share cache entries
-            flags_id = (
-                " ".join(cxxflags)
-                .replace(effective_ccache_basedir(), "")
-                .replace(str(CORE.build_path), "")
-            )
-            # The header text covers include order
-            checksum = pch_checksum(src_dir, headers, (pch_text, *identity, flags_id))
-    except (OSError, UnicodeError) as err:
-        # Identity unknown: a stale cache entry must never be served
-        _LOGGER.warning(
-            "Could not establish the pch identity; compiling without it: %s", err
-        )
-        return None
-    _LOGGER.info(
-        "Compiling with a precompiled header (set ESPHOME_PCH_ENABLE=0 to disable)"
-    )
-    write_file_if_changed(pch_header, pch_text)
-    sum_path = build_dir / f"{PCH_HEADER_NAME}.gch.sum"
-    if checksum is not None:
-        # Generate-time stamp: a hand-run ninja can rebuild the .gch
-        # while this .sum lags
-        write_file_if_changed(sum_path, checksum + "\n")
-    else:
-        # A stale .sum from an earlier ccache run must not survive
-        sum_path.unlink(missing_ok=True)
-    gch = _e(f"{PCH_HEADER_NAME}.gch")
-    lines.append(f"build {gch}: pch {_e(pch_header)}")
-    if src_flags:
-        lines.append(f"  flags = {' '.join(src_flags)}")
-    # Relative -include: absolute would break cross-device ccache.
-    # -Wno-error keeps a rejected .gch a warning under user -Werror
-    cxx_parts = [
-        *src_flags,
-        f"-Winvalid-pch -Wno-error=invalid-pch -include {PCH_HEADER_NAME}",
-    ]
-    lines.append(f"srccxxflags = {' '.join(cxx_parts)}")
-    mark_pch_emitted()
-    return ("$srccxxflags", gch)
-
-
-def ar_rule_lines(ar: Path | str) -> list[str]:
-    return [
-        "rule ar",
-        f"  command = $python $buildtool ar {_q(ar)} $out $out.rsp",
-        "  rspfile = $out.rsp",
-        "  rspfile_content = $in_newline",
-        "  description = AR $out",
-    ]
-
-
-def compile_edges(
-    lines: list[str],
-    sources: list[Path],
-    root: Path,
-    group: str,
-    flags: str = "",
-    own_includes: str = "",
-    cxx_override: tuple[str, str] | None = None,
-) -> list[str]:
-    """Emit compile edges for ``sources``; return the object paths.
-
-    ``cxx_override`` is a (flags, implicit-dep) pair applied to C++ edges
-    only, replacing ``flags`` (used for the precompiled header).
-    """
-    objects = []
-    for src in sources:
-        rel = src.relative_to(root).as_posix()
-        obj = f"obj/{group}/{rel}.o"
-        escaped_obj = _e(obj)
-        kind = SOURCE_KIND_FOR_SUFFIX[src.suffix]
-        override = cxx_override if kind == "cxx" else None
-        implicit = f" | {override[1]}" if override else ""
-        lines.append(f"build {escaped_obj}: {kind} {_e(src)}{implicit}")
-        if own_includes:
-            lines.append(f"  own_includes = {own_includes}")
-        if edge_flags := override[0] if override else flags:
-            lines.append(f"  flags = {edge_flags}")
-        # Escaped once here: the returned paths only ever appear in build
-        # statements (archive/link inputs), which use ninja escaping
-        objects.append(escaped_obj)
-    return objects
-
-
-def library_edges(
-    lines: list[str], libraries: list[ArduinoLibrary]
-) -> tuple[list[str], list[str]]:
-    """Emit every library's compile and archive edges.
-
-    Returns the archive names and the objects that link directly. A
-    library's own include dirs lead its compile lines, as PlatformIO searched
-    them first: the include path is one global list, so another library's
-    header of the same name would shadow them.
-    """
-    archives: list[str] = []
-    direct_objs: list[str] = []
-    for lib in libraries:
-        if not lib.sources:
-            # Header-only libraries are legitimate; the log makes an empty
-            # srcFilter or broken tree traceable before link errors do
-            _LOGGER.debug(
-                "Library %s has no source files; contributing includes only",
-                lib.name,
-            )
-            continue
-        objs = compile_edges(
-            lines,
-            lib.sources,
-            common_parent(lib.sources),
-            f"lib/{lib.name}",
-            flags=" ".join(_shell_token(f) for f in lib.flags),
-            own_includes=" ".join(f"-I{_q(d)}" for d in lib.include_dirs),
-        )
-        if not lib.lib_archive:
-            # libArchive: false / dot_a_linkage=false: hand the objects to
-            # the linker directly so unreferenced-but-required symbols
-            # (exception handlers, weak overrides) survive
-            direct_objs.extend(objs)
-            continue
-        archive = f"lib{lib.name}.a"
-        lines.append(f"build {_e(archive)}: ar {' '.join(objs)}")
-        archives.append(archive)
-    return archives, direct_objs
-
-
-# One build flag: the flag, plus its argument when that is a separate token
-Flag = tuple[str, ...]
-
-# Flags whose path operand is the next token; gcc also takes it glued on
-PATH_ARG_FLAGS = ("-include", "-imacros", "-isystem", "-iquote", "-idirafter")
-# Flags whose path operand is glued on
-PATH_PREFIXES = ("-I", "-L", *PATH_ARG_FLAGS)
-
-
-def _anchor(path: str, base: Path) -> str:
-    if not path or Path(path).is_absolute():
-        return path
-    return str(base / path)
-
-
-def anchor_path_flag(flag: Flag, base: Path) -> Flag:
-    """Anchor a flag's relative path operand at ``base``.
-
-    PlatformIO ran the compiler from the build path; ninja runs it from
-    ``.pioenvs/<name>``, where a relative operand would point elsewhere.
-    """
-    name, *args = flag
-    if args:
-        if name in PATH_ARG_FLAGS:
-            return (name, _anchor(args[0], base))
-        return flag
-    for prefix in PATH_PREFIXES:
-        if name.startswith(prefix):
-            return (prefix + _anchor(name[len(prefix) :], base),)
-    return flag
@@ -1,423 +0,0 @@
-"""Shared precompiled-header policy for the build backends.
-
-The prefix either mirrors the TUs' own force-includes (ESP8266) or is a
-curated core-header set (ESP-IDF). ``esphome: includes:`` sources receive
-it too; Arduino.h visibility there is intended (esphome#8693).
-"""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-from dataclasses import dataclass
-import hashlib
-import json
-import logging
-import os
-from pathlib import Path
-import posixpath
-import re
-import stat
-import subprocess
-
-from esphome.build_helpers.ccache import effective_ccache_basedir, parse_enable_env
-from esphome.build_helpers.idedata import (
-    CXX_SOURCE_SUFFIXES,
-    expand_response_files,
-    is_launcher,
-    split_command,
-)
-
-_DOMAIN = "pch"
-
-
-@dataclass
-class _PCHData:
-    emitted: bool = False
-
-
-def _pch_data() -> _PCHData:
-    from esphome.core import CORE
-
-    if _DOMAIN not in CORE.data:
-        CORE.data[_DOMAIN] = _PCHData()
-    return CORE.data[_DOMAIN]
-
-
-def mark_pch_emitted() -> None:
-    """Record that this build's consumers reference the pch."""
-    _pch_data().emitted = True
-
-
-_LOGGER = logging.getLogger(__name__)
-
-# The header and its .gch/.sum sidecars live in the build directory.
-PCH_HEADER_NAME = "esphome_pch.h"
-
-# Every artifact the pch machinery can leave behind, for cleanup.
-PCH_ARTIFACT_NAMES = (
-    PCH_HEADER_NAME,
-    f"{PCH_HEADER_NAME}.gch",
-    f"{PCH_HEADER_NAME}.gch.sum",
-    f"{PCH_HEADER_NAME}.gch.failed",
-)
-
-# The core defines header every backend anchors its prefix on.
-PCH_CORE_HEADER = "esphome/core/defines.h"
-
-# Prefix-header contents for backends that inject a curated set (rather
-# than mirroring the TUs' own force-includes), defines.h first so USE_*
-# macros exist for the rest. Deliberately hard-coded: frequency-derived
-# sets measured no better and kept selecting headers that cannot compile
-# standalone (X-macro, platform-variant). Every entry must be safe to
-# include first in an empty TU. Caveat: application.h/automation.h become
-# ambiently visible, so a TU missing those #includes still builds on such
-# backends; ESPHOME_PCH_ENABLE=0 restores the strict view.
-PCH_DEFAULT_HEADERS = (
-    PCH_CORE_HEADER,
-    "esphome/core/component.h",
-    "esphome/core/helpers.h",
-    "esphome/core/log.h",
-    "esphome/core/application.h",
-    "esphome/core/automation.h",
-)
-
-# ccache cannot hash through a .gch; CCACHE_PCH_EXTSUM makes it hash the
-# .sum sidecar instead of the .gch bytes, which are not reproducible.
-# Keep in sync with the literals in platformio/pch.py.script.
-_CCACHE_PCH_ENV = {
-    "CCACHE_SLOPPINESS": "pch_defines,time_macros",
-    "CCACHE_PCH_EXTSUM": "true",
-}
-
-# Both include forms: an angle include resolving under src/ must enter the
-# digest too; ones that do not resolve simply end the walk
-# Compiler failures that clear on their own must not latch the .failed marker
-_TRANSIENT_ERRORS = ("No space left", "Cannot allocate", "Resource temporarily")
-
-_INCLUDE_RE = re.compile(rb'^\s*#\s*include\s+["<]([^">]+)[">]', re.MULTILINE)
-
-
-def pch_enabled() -> bool:
-    """Precompiled-header knob: default on, ``ESPHOME_PCH_ENABLE=0`` opts out."""
-    return parse_enable_env("ESPHOME_PCH_ENABLE") is not False
-
-
-def ccache_pch_env() -> dict[str, str]:
-    """Settings ccache needs to cache compiles that consume the .gch;
-    empty unless this build actually emitted one. User-set values win.
-    Native backends export these process-wide; only time_macros affects
-    non-pch TUs."""
-    if not (pch_enabled() and _pch_data().emitted):
-        return {}
-    extsum = os.environ.get("CCACHE_PCH_EXTSUM")
-    if extsum is not None and extsum.strip().lower() not in ("1", "true", "yes", "on"):
-        # ccache then hashes the non-reproducible .gch bytes: permanent misses
-        _LOGGER.warning("CCACHE_PCH_EXTSUM=%s disables pch caching", extsum)
-    env = {k: v for k, v in _CCACHE_PCH_ENV.items() if k not in os.environ}
-    user_sloppiness = os.environ.get("CCACHE_SLOPPINESS")
-    if user_sloppiness is not None and (
-        missing := [
-            t
-            for t in ("pch_defines", "time_macros")
-            if t not in {tok.strip() for tok in user_sloppiness.split(",")}
-        ]
-    ):
-        # Without these ccache declines every pch-consuming compile
-        env["CCACHE_SLOPPINESS"] = ",".join((user_sloppiness, *missing))
-        _LOGGER.warning(
-            "Adding %s to CCACHE_SLOPPINESS so ccache can cache compiles "
-            "that use the precompiled header",
-            ",".join(missing),
-        )
-    return env
-
-
-def pch_extra_scripts() -> list[str]:
-    """The extra_scripts entries a PlatformIO platform registers for the
-    pch; empty when disabled (the script itself has no enable check)."""
-    return ["post:pch.py"] if pch_enabled() else []
-
-
-def pch_header_text(include_headers: Iterable[str]) -> str:
-    """The prefix-header source: exactly these includes, in order."""
-    return "".join(f'#include "{name}"\n' for name in include_headers)
-
-
-def _resolves(path: Path) -> bool:
-    """False when missing; other stat failures propagate (identity unknown,
-    unlike is_file(), which would silently drop the header)."""
-    try:
-        return stat.S_ISREG(path.stat().st_mode)
-    except (FileNotFoundError, NotADirectoryError):
-        return False
-
-
-def _include_closure(src_dir: Path, roots: Iterable[str]) -> dict[str, bytes]:
-    """Include closure of ``roots``: src-relative name -> contents.
-
-    Resolution mirrors the compiler (includer's dir, then src root); names
-    outside ``src_dir`` end the walk and are versioned by the caller. No
-    #ifdef evaluation: over-approximating is the safe direction.
-    """
-    seen: dict[str, bytes] = {}
-    stack: list[tuple[str, str]] = [(name, "") for name in roots]
-    while stack:
-        name, from_dir = stack.pop()
-        for candidate in (f"{from_dir}/{name}" if from_dir else name, name):
-            rel = posixpath.normpath(candidate)
-            if not rel.startswith("..") and _resolves(src_dir / rel):
-                break
-        else:
-            continue
-        if rel in seen:
-            continue
-        try:
-            data = (src_dir / rel).read_bytes()
-        except OSError as err:
-            # A marker would truncate the transitive walk; fail closed
-            _LOGGER.warning("Could not read %s for the pch checksum: %s", rel, err)
-            raise
-        seen[rel] = data
-        parent = posixpath.dirname(rel)
-        stack.extend(
-            # surrogateescape: a non-UTF-8 name just fails to resolve
-            (inc.decode(errors="surrogateescape"), parent)
-            for inc in _INCLUDE_RE.findall(data)
-        )
-    return seen
-
-
-def pch_checksum(
-    src_dir: Path, include_headers: Iterable[str], extra: Iterable[str]
-) -> str:
-    """Digest standing in for the .gch in ccache's hash: the include closure
-    of the prefix header plus caller-supplied identity strings (versioned
-    install paths, flags). Raises OSError when a header's identity cannot
-    be established at all; callers must then compile without a pch."""
-    digest = hashlib.sha256()
-    closure = _include_closure(src_dir, include_headers)
-    for name in sorted(closure):
-        digest.update(name.encode(errors="surrogateescape"))
-        digest.update(closure[name])
-        digest.update(b"\0")
-    for item in extra:
-        digest.update(item.encode(errors="surrogateescape"))
-        digest.update(b"\0")
-    return digest.hexdigest()
-
-
-# Tokens dropped when retargeting a TU's flags at the prefix header
-# (the pch compile must not touch depfiles)
-_PCH_STRIP_FLAGS_WITH_ARG = frozenset({"-o", "-c", "-MT", "-MF", "-MQ"})
-_PCH_STRIP_FLAGS = frozenset({"-MD", "-MMD", "-MP", "-MM", "-M"})
-
-
-def pch_compile_command(
-    build_dir: Path, header: Path, gch: Path
-) -> tuple[list[str], Path] | None:
-    """The exact src C++ flags from compile_commands.json retargeted at the
-    header, with the directory they resolve against (relative -I paths must
-    be expanded and executed from the same root); None (logged) when no
-    configured C++ TU is available yet."""
-    from esphome.core import CORE
-
-    try:
-        entries = json.loads(
-            (build_dir / "compile_commands.json").read_text(encoding="utf-8")
-        )
-    except (OSError, json.JSONDecodeError) as err:
-        # Configure already succeeded, so an unusable DB is a real anomaly
-        _LOGGER.warning("No usable compile database, skipping pch: %s", err)
-        return None
-    if not isinstance(entries, list):
-        _LOGGER.warning("Malformed compile database, skipping pch")
-        return None
-    # CMake may spell paths through a symlink differently than CORE does
-    # (macOS /tmp vs /private/tmp), so compare resolved paths
-    src_root = Path(CORE.relative_src_path()).resolve()
-    entry = next(
-        (
-            e
-            for e in entries
-            if isinstance(e, dict)
-            and isinstance(e.get("file"), str)
-            and e["file"].endswith(CXX_SOURCE_SUFFIXES)
-            and Path(e["file"]).resolve().is_relative_to(src_root)
-        ),
-        None,
-    )
-    if entry is None:
-        _LOGGER.warning("No src C++ entry in the compile database, skipping pch")
-        return None
-    directory = entry.get("directory")
-    cmd_dir = Path(directory) if isinstance(directory, str) and directory else build_dir
-    command = entry.get("command")
-    tokens = expand_response_files(
-        split_command(command if isinstance(command, str) else ""), cmd_dir
-    )
-    # A DB recorded with ccache enabled prefixes the compiler with the
-    # launcher; the .gch must be compiled directly
-    if tokens and is_launcher(tokens[0]):
-        tokens = tokens[1:]
-    if not tokens:
-        # "arguments"-style or empty entries must skip, not spawn "-x ..."
-        _LOGGER.warning("Compile database entry has no usable command, skipping pch")
-        return None
-    args: list[str] = []
-    arg_it = iter(tokens)
-    for tok in arg_it:
-        if tok in _PCH_STRIP_FLAGS_WITH_ARG:
-            next(arg_it, None)
-            continue
-        if tok in _PCH_STRIP_FLAGS:
-            continue
-        if tok == "-include":
-            # Drop only the injected prefix; user force-includes must reach
-            # the .gch compile or GCC rejects it over the macro mismatch
-            inc = next(arg_it, "")
-            if not inc.endswith(PCH_HEADER_NAME):
-                args.extend(("-include", inc))
-            continue
-        args.append(tok)
-    return [*args, "-x", "c++-header", "-c", str(header), "-o", str(gch)], cmd_dir
-
-
-def _log_pch_in_use() -> None:
-    # The only place a user can discover the knob; emitted only once a
-    # .gch is actually fresh or being built
-    _LOGGER.info(
-        "Compiling with a precompiled header (set ESPHOME_PCH_ENABLE=0 to disable)"
-    )
-
-
-def _read_stamp(path: Path) -> str:
-    """A corrupt sidecar must read as stale, not kill the pch forever."""
-    try:
-        return path.read_text(encoding="utf-8").strip()
-    except (OSError, UnicodeDecodeError):
-        return ""
-
-
-def discard_pch(build_dir: Path) -> None:
-    """Remove the pch sidecars so a stale .gch is never consumed.
-
-    Bumps the header only when a .gch was actually removed: TUs compiled
-    against it have incomplete depfiles, while a repeat failure with no
-    .gch must not force a full rebuild every build.
-    """
-    header = build_dir / PCH_HEADER_NAME
-    gch = Path(f"{header}.gch")
-    had_gch = gch.is_file()
-    gch.unlink(missing_ok=True)
-    Path(f"{gch}.sum").unlink(missing_ok=True)
-    if had_gch and header.is_file():
-        os.utime(header)
-
-
-def prepare_pch(
-    build_dir: Path, include_headers: tuple[str, ...], extra: Iterable[str]
-) -> None:
-    """Compile ``build_dir``'s .gch from compile_commands.json flags and
-    write its ccache .sum.
-
-    The .sum doubles as the freshness stamp and folds in the compile
-    command, so a flag-only change rebuilds the .gch; ``extra`` carries
-    backend identity (framework version, sdkconfig, ...). A failed
-    compile falls back to the plain header include.
-    """
-    from esphome.core import CORE
-
-    header = build_dir / PCH_HEADER_NAME
-    gch = Path(f"{header}.gch")
-    sum_path = Path(f"{gch}.sum")
-    cmd_and_dir = pch_compile_command(build_dir, header, gch)
-    if cmd_and_dir is None:
-        # Freshness cannot be validated; a leftover .gch must not be consumed
-        discard_pch(build_dir)
-        return
-    cmd, cmd_dir = cmd_and_dir
-    # Strip like ccache's rewriting (user CCACHE_BASEDIR wins); the raw
-    # build path covers unresolved (symlinked) spellings
-    cmd_id = (
-        " ".join(cmd)
-        .replace(effective_ccache_basedir(), "")
-        .replace(str(CORE.build_path), "")
-    )
-    try:
-        checksum = pch_checksum(
-            CORE.relative_src_path(),
-            include_headers,
-            (
-                # The closure is sorted, so root order only enters via the text
-                pch_header_text(include_headers),
-                *extra,
-                cmd_id,
-            ),
-        )
-    except (OSError, UnicodeError) as err:
-        # Identity unknown: a stale cache entry must never be served
-        _LOGGER.warning(
-            "Could not establish the pch identity; compiling without it: %s", err
-        )
-        discard_pch(build_dir)
-        return
-    if gch.is_file() and _read_stamp(sum_path) == checksum:
-        _log_pch_in_use()
-        return
-    failed_marker = Path(f"{gch}.failed")
-    if _read_stamp(failed_marker) == checksum:
-        _LOGGER.info(
-            "Precompiled header disabled after an earlier failure; delete %s to retry",
-            failed_marker,
-        )
-        return
-    _log_pch_in_use()
-    try:
-        result = subprocess.run(
-            cmd,
-            cwd=cmd_dir,
-            # C locale keeps diagnostics matchable by _TRANSIENT_ERRORS
-            env={**os.environ, "LC_ALL": "C"},
-            capture_output=True,
-            text=True,
-            check=False,
-            timeout=300,
-        )
-        error = None
-        if result.returncode < 0:
-            # Killed by a signal (OOM, ^C): environmental, do not latch
-            _LOGGER.warning(
-                "Precompiled header compile was killed (signal %d); retrying "
-                "next build",
-                -result.returncode,
-            )
-            discard_pch(build_dir)
-            return
-        if result.returncode != 0:
-            error = result.stderr.strip() or f"exit code {result.returncode}"
-        elif not gch.is_file():
-            error = "compiler produced no .gch"
-    except (OSError, subprocess.SubprocessError) as err:
-        # Transient (timeout, spawn/IO): warn and retry next build, no marker
-        _LOGGER.warning("Precompiled header compile did not run: %s", err)
-        discard_pch(build_dir)
-        return
-    if error is not None:
-        _LOGGER.warning(
-            "Precompiled header failed; compiling without it: %s", error[:400]
-        )
-        # This path latches, so keep the full compiler output recoverable
-        _LOGGER.debug("Full pch compile output: %s", error)
-        discard_pch(build_dir)
-        if any(m in error for m in _TRANSIENT_ERRORS):
-            # Resource exhaustion clears on its own; retry next build
-            return
-        # Skip retries until a header/flag/backend-identity/command change
-        failed_marker.write_text(checksum + "\n", encoding="utf-8")
-        os.utime(header)
-        return
-    failed_marker.unlink(missing_ok=True)
-    sum_path.write_text(checksum + "\n", encoding="utf-8")
-    # Consumers depend on the header (depfiles cannot see through a .gch);
-    # bump it so users of the previous .gch recompile
-    os.utime(header)
@@ -33,11 +33,4 @@ def tools_cache_path(env_var: str, subdir: str) -> Path:
 IDF_TOOLS_CACHE = ("ESPHOME_ESP_IDF_PREFIX", "idf")
 SDK_NRF_TOOLS_CACHE = ("ESPHOME_SDK_NRF_PREFIX", "sdk-nrf")
 ARDUINO8266_TOOLS_CACHE = ("ESPHOME_ARDUINO8266_PREFIX", "arduino8266")
-# The host backend installs nothing; the entry only holds its ccache dir
-HOST_TOOLS_CACHE = ("ESPHOME_HOST_PREFIX", "host")
-TOOLS_CACHE_SPECS = (
-    IDF_TOOLS_CACHE,
-    SDK_NRF_TOOLS_CACHE,
-    ARDUINO8266_TOOLS_CACHE,
-    HOST_TOOLS_CACHE,
-)
+TOOLS_CACHE_SPECS = (IDF_TOOLS_CACHE, SDK_NRF_TOOLS_CACHE, ARDUINO8266_TOOLS_CACHE)
@@ -42,7 +42,6 @@ from esphome.cpp_generator import (  # noqa: F401
    set_cpp_standard,
    statement,
    static_const_array,
-    static_function,
    templatable,
    variable,
    with_local_variable,
@@ -65,6 +64,7 @@ from esphome.cpp_types import (  # noqa: F401
    Application,
    Component,
    ComponentPtr,
+    Controller,
    EntityBase,
    EntityCategory,
    ESPTime,
@@ -6,6 +6,5 @@ See the component-alias section of esphome/loader.py.

 # alias -> (canonical component, removal version or None)
 COMPONENT_ALIASES: dict[str, tuple[str, str | None]] = {
-    "esp32_improv": ("improv_ble", "2027.4.0"),
    "rp2040": ("rp2", "2027.7.0"),
 }
@@ -94,7 +94,7 @@ class ADCSensor final : public sensor::Sensor, public PollingComponent, public v
  ///   - SamplingMode::MIN: Use the lowest sample value
  ///   - SamplingMode::MAX: Use the highest sample value
  /// @param sampling_mode The desired sampling mode to use for aggregating ADC samples.
-  void set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
+  void set_sampling_mode(SamplingMode sampling_mode);

  /// Perform a single ADC sampling operation and return the measured value.
  /// This function handles raw readings, calibration, and averaging as needed.
@@ -76,4 +76,6 @@ void ADCSensor::set_sample_count(uint8_t sample_count) {
  }
 }

+void ADCSensor::set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
+
 }  // namespace esphome::adc
@@ -106,20 +106,6 @@ bool AGS10Component::set_zero_point_with_factory_defaults() { return this->set_z

 bool AGS10Component::set_zero_point_with_current_resistance() { return this->set_zero_point_with(ZP_CURRENT); }

-void AGS10Component::set_zero_point(AGS10SetZeroPointActionMode mode, uint16_t value) {
-  switch (mode) {
-    case FACTORY_DEFAULT:
-      this->set_zero_point_with_factory_defaults();
-      break;
-    case CURRENT_VALUE:
-      this->set_zero_point_with_current_resistance();
-      break;
-    case CUSTOM_VALUE:
-      this->set_zero_point_with(value);
-      break;
-  }
-}
-
 bool AGS10Component::set_zero_point_with(uint16_t value) {
  std::array<uint8_t, 5> data{0x00, 0x0C, (uint8_t) ((value >> 8) & 0xFF), (uint8_t) (value & 0xFF), 0};
  data[4] = crc8(data.data(), 4, 0xFF, 0x31, true);
@@ -2,19 +2,11 @@

 #include "esphome/components/i2c/i2c.h"
 #include "esphome/components/sensor/sensor.h"
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"

 namespace esphome::ags10 {

-enum AGS10SetZeroPointActionMode {
-  // Zero-point reset.
-  FACTORY_DEFAULT,
-  // Zero-point calibration with current resistance.
-  CURRENT_VALUE,
-  // Zero-point calibration with custom resistance.
-  CUSTOM_VALUE,
-};
-
 class AGS10Component final : public PollingComponent, public i2c::I2CDevice {
 public:
  /**
@@ -55,11 +47,6 @@ class AGS10Component final : public PollingComponent, public i2c::I2CDevice {
   */
  bool set_zero_point_with_current_resistance();

-  /**
-   * Sets zero-point by mode; the value is only used for CUSTOM_VALUE.
-   */
-  void set_zero_point(AGS10SetZeroPointActionMode mode, uint16_t value);
-
  /**
   * Sets zero-point with the value.
   */
@@ -113,4 +100,39 @@ class AGS10Component final : public PollingComponent, public i2c::I2CDevice {
  template<size_t N> optional<std::array<uint8_t, N>> read_and_check_(uint8_t a_register);
 };

+template<typename... Ts> class AGS10NewI2cAddressAction final : public Action<Ts...>, public Parented<AGS10Component> {
+ public:
+  TEMPLATABLE_VALUE(uint8_t, new_address)
+
+  void play(const Ts &...x) override { this->parent_->new_i2c_address(this->new_address_.value(x...)); }
+};
+
+enum AGS10SetZeroPointActionMode {
+  // Zero-point reset.
+  FACTORY_DEFAULT,
+  // Zero-point calibration with current resistance.
+  CURRENT_VALUE,
+  // Zero-point calibration with custom resistance.
+  CUSTOM_VALUE,
+};
+
+template<typename... Ts> class AGS10SetZeroPointAction final : public Action<Ts...>, public Parented<AGS10Component> {
+ public:
+  TEMPLATABLE_VALUE(uint16_t, value)
+  TEMPLATABLE_VALUE(AGS10SetZeroPointActionMode, mode)
+
+  void play(const Ts &...x) override {
+    switch (this->mode_.value(x...)) {
+      case FACTORY_DEFAULT:
+        this->parent_->set_zero_point_with_factory_defaults();
+        break;
+      case CURRENT_VALUE:
+        this->parent_->set_zero_point_with_current_resistance();
+        break;
+      case CUSTOM_VALUE:
+        this->parent_->set_zero_point_with(this->value_.value(x...));
+        break;
+    }
+  }
+};
 }  // namespace esphome::ags10
@@ -17,6 +17,8 @@ from esphome.const import (
    UNIT_OHM,
    UNIT_PARTS_PER_BILLION,
 )
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 CONF_RESISTANCE = "resistance"
@@ -26,6 +28,12 @@ DEPENDENCIES = ["i2c"]
 ags10_ns = cg.esphome_ns.namespace("ags10")
 AGS10Component = ags10_ns.class_("AGS10Component", cg.PollingComponent, i2c.I2CDevice)

+# Actions
+AGS10NewI2cAddressAction = ags10_ns.class_(
+    "AGS10NewI2cAddressAction", automation.Action
+)
+AGS10SetZeroPointAction = ags10_ns.class_("AGS10SetZeroPointAction", automation.Action)
+
 CONFIG_SCHEMA = (
    cv.Schema(
        {
@@ -83,11 +91,24 @@ AGS10_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
 )


-automation.register_apply_action(
+@automation.register_action(
    "ags10.new_i2c_address",
+    AGS10NewI2cAddressAction,
    AGS10_NEW_I2C_ADDRESS_SCHEMA,
-    automation.ApplyField(CONF_ADDRESS, "new_i2c_address", cg.uint8),
+    synchronous=True,
 )
+async def ags10newi2caddress_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    address = await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)
+    cg.add(var.set_new_address(address))
+    return var
+

 AGS10SetZeroPointActionMode = ags10_ns.enum("AGS10SetZeroPointActionMode")
 AGS10_SET_ZERO_POINT_ACTION_MODE = {
@@ -107,11 +128,24 @@ AGS10_SET_ZERO_POINT_SCHEMA = cv.Schema(
 )


-automation.register_apply_action(
+@automation.register_action(
    "ags10.set_zero_point",
+    AGS10SetZeroPointAction,
    AGS10_SET_ZERO_POINT_SCHEMA,
-    automation.ApplyCall(
-        "set_zero_point({}, {})",
-        ((CONF_MODE, AGS10SetZeroPointActionMode), (CONF_VALUE, cg.uint16)),
-    ),
+    synchronous=True,
 )
+async def ags10setzeropoint_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    mode = await cg.templatable(
+        config.get(CONF_MODE), args, AGS10SetZeroPointActionMode
+    )
+    cg.add(var.set_mode(mode))
+    value = await cg.templatable(config[CONF_VALUE], args, cg.uint16)
+    cg.add(var.set_value(value))
+    return var
@@ -4,6 +4,8 @@ from esphome.components import i2c
 from esphome.components.audio_dac import AudioDac
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_MODE
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 CODEOWNERS = ["@kbx81"]
@@ -12,6 +14,7 @@ DEPENDENCIES = ["i2c"]
 aic3204_ns = cg.esphome_ns.namespace("aic3204")
 AIC3204 = aic3204_ns.class_("AIC3204", AudioDac, cg.Component, i2c.I2CDevice)

+SetAutoMuteAction = aic3204_ns.class_("SetAutoMuteAction", automation.Action)

 CONFIG_SCHEMA = (
    cv.Schema(
@@ -33,11 +36,25 @@ SET_AUTO_MUTE_ACTION_SCHEMA = cv.maybe_simple_value(
 )


-automation.register_apply_action(
+@automation.register_action(
    "aic3204.set_auto_mute_mode",
+    SetAutoMuteAction,
    SET_AUTO_MUTE_ACTION_SCHEMA,
-    automation.ApplyField(CONF_MODE, "set_auto_mute_mode", cg.uint8),
+    synchronous=True,
 )
+async def aic3204_set_volume_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+
+    template_ = await cg.templatable(config.get(CONF_MODE), args, cg.uint8)
+    cg.add(var.set_auto_mute_mode(template_))
+
+    return var


 async def to_code(config: ConfigType) -> None:
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "aic3204.h"
+
+namespace esphome::aic3204 {
+
+template<typename... Ts> class SetAutoMuteAction final : public Action<Ts...> {
+ public:
+  explicit SetAutoMuteAction(AIC3204 *aic3204) : aic3204_(aic3204) {}
+
+  TEMPLATABLE_VALUE(uint8_t, auto_mute_mode)
+
+  void play(const Ts &...x) override { this->aic3204_->set_auto_mute_mode(this->auto_mute_mode_.value(x...)); }
+
+ protected:
+  AIC3204 *aic3204_;
+};
+
+}  // namespace esphome::aic3204
@@ -85,11 +85,20 @@ async def wave_base_to_code(var: MockObj, config: ConfigType) -> None:

    await ble_client.register_ble_node(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_HUMIDITY, var.set_humidity)
-    await sensors(CONF_TEMPERATURE, var.set_temperature)
-    await sensors(CONF_PRESSURE, var.set_pressure)
-    await sensors(CONF_TVOC, var.set_tvoc)
-    await sensors(CONF_BATTERY_VOLTAGE, var.set_battery_voltage)
+    if config_humidity := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(config_humidity)
+        cg.add(var.set_humidity(sens))
+    if config_temperature := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(config_temperature)
+        cg.add(var.set_temperature(sens))
+    if config_pressure := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(config_pressure)
+        cg.add(var.set_pressure(sens))
+    if config_tvoc := config.get(CONF_TVOC):
+        sens = await sensor.new_sensor(config_tvoc)
+        cg.add(var.set_tvoc(sens))
+    if config_battery_voltage := config.get(CONF_BATTERY_VOLTAGE):
+        sens = await sensor.new_sensor(config_battery_voltage)
+        cg.add(var.set_battery_voltage(sens))
    if config_battery_update_interval := config.get(CONF_BATTERY_UPDATE_INTERVAL):
        cg.add(var.set_battery_update_interval(config_battery_update_interval))
@@ -87,9 +87,16 @@ async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    await airthings_wave_base.wave_base_to_code(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_RADON, var.set_radon)
-    await sensors(CONF_RADON_LONG_TERM, var.set_radon_long_term)
-    await sensors(CONF_CO2, var.set_co2)
-    await sensors(CONF_ILLUMINANCE, var.set_illuminance)
+    if config_radon := config.get(CONF_RADON):
+        sens = await sensor.new_sensor(config_radon)
+        cg.add(var.set_radon(sens))
+    if config_radon_long_term := config.get(CONF_RADON_LONG_TERM):
+        sens = await sensor.new_sensor(config_radon_long_term)
+        cg.add(var.set_radon_long_term(sens))
+    if config_co2 := config.get(CONF_CO2):
+        sens = await sensor.new_sensor(config_co2)
+        cg.add(var.set_co2(sens))
+    if config_illuminance := config.get(CONF_ILLUMINANCE):
+        sens = await sensor.new_sensor(config_illuminance)
+        cg.add(var.set_illuminance(sens))
    cg.add(var.set_device_type(config[CONF_DEVICE_TYPE]))
@@ -41,6 +41,18 @@ StateAnyForwarder = alarm_control_panel_ns.class_("StateAnyForwarder")
 StateEnterForwarder = alarm_control_panel_ns.class_("StateEnterForwarder")
 AlarmControlPanelState = alarm_control_panel_ns.enum("AlarmControlPanelState")

+ArmAwayAction = alarm_control_panel_ns.class_("ArmAwayAction", automation.Action)
+ArmHomeAction = alarm_control_panel_ns.class_("ArmHomeAction", automation.Action)
+ArmNightAction = alarm_control_panel_ns.class_("ArmNightAction", automation.Action)
+DisarmAction = alarm_control_panel_ns.class_("DisarmAction", automation.Action)
+PendingAction = alarm_control_panel_ns.class_("PendingAction", automation.Action)
+TriggeredAction = alarm_control_panel_ns.class_("TriggeredAction", automation.Action)
+ChimeAction = alarm_control_panel_ns.class_("ChimeAction", automation.Action)
+ReadyAction = alarm_control_panel_ns.class_("ReadyAction", automation.Action)
+
+AlarmControlPanelCondition = alarm_control_panel_ns.class_(
+    "AlarmControlPanelCondition", automation.Condition
+)

 _ALARM_CONTROL_PANEL_SCHEMA = (
    cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
@@ -184,38 +196,125 @@ async def new_alarm_control_panel(config, *args):
    return var


-# Mirrors AlarmControlPanel::arm_with_code_: arm first, set the code only when given.
-for _name, _arm in (
-    ("alarm_control_panel.arm_away", "arm_away()"),
-    ("alarm_control_panel.arm_home", "arm_home()"),
-    ("alarm_control_panel.arm_night", "arm_night()"),
-    ("alarm_control_panel.disarm", "disarm()"),
+@automation.register_action(
+    "alarm_control_panel.arm_away",
+    ArmAwayAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_arm_away_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    if code_config := config.get(CONF_CODE):
+        templatable_ = await cg.templatable(code_config, args, cg.std_string)
+        cg.add(var.set_code(templatable_))
+    return var
+
+
+@automation.register_action(
+    "alarm_control_panel.arm_home",
+    ArmHomeAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_arm_home_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    if code_config := config.get(CONF_CODE):
+        templatable_ = await cg.templatable(code_config, args, cg.std_string)
+        cg.add(var.set_code(templatable_))
+    return var
+
+
+@automation.register_action(
+    "alarm_control_panel.arm_night",
+    ArmNightAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_arm_night_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    if CONF_CODE in config:
+        templatable_ = await cg.templatable(config[CONF_CODE], args, cg.std_string)
+        cg.add(var.set_code(templatable_))
+    return var
+
+
+@automation.register_action(
+    "alarm_control_panel.disarm",
+    DisarmAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_disarm_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    if code_config := config.get(CONF_CODE):
+        templatable_ = await cg.templatable(code_config, args, cg.std_string)
+        cg.add(var.set_code(templatable_))
+    return var
+
+
+@automation.register_action(
+    "alarm_control_panel.pending",
+    PendingAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_pending_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@automation.register_action(
+    "alarm_control_panel.triggered",
+    TriggeredAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_trigger_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@automation.register_action(
+    "alarm_control_panel.chime",
+    ChimeAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_chime_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@automation.register_action(
+    "alarm_control_panel.ready",
+    ReadyAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_condition(
+    "alarm_control_panel.ready",
+    AlarmControlPanelCondition,
+    ALARM_CONTROL_PANEL_CONDITION_SCHEMA,
+)
+async def alarm_action_ready_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@automation.register_condition(
+    "alarm_control_panel.is_armed",
+    AlarmControlPanelCondition,
+    ALARM_CONTROL_PANEL_CONDITION_SCHEMA,
+)
+async def alarm_control_panel_is_armed_to_code(
+    config, condition_id, template_arg, args
 ):
-    automation.register_apply_action(
-        _name,
-        ALARM_CONTROL_PANEL_ACTION_SCHEMA,
-        automation.ApplyCall(_arm),
-        automation.ApplyField(CONF_CODE, "set_code", cg.std_string),
-        call="make_call",
-    )
-
-
-for _name, _call in (
-    ("alarm_control_panel.pending", "pending()"),
-    ("alarm_control_panel.triggered", "triggered()"),
-):
-    automation.register_apply_action(
-        _name,
-        ALARM_CONTROL_PANEL_ACTION_SCHEMA,
-        automation.ApplyCall(_call),
-        call="make_call",
-    )
-
-
-for _name in ("alarm_control_panel.ready", "alarm_control_panel.is_armed"):
-    automation.register_apply_condition(
-        _name, ALARM_CONTROL_PANEL_CONDITION_SCHEMA, "is_armed_pending_or_triggered()"
-    )
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren)


@coroutine_with_priority(CoroPriority.CORE)
@@ -130,12 +130,6 @@ class AlarmControlPanel : public EntityBase {

  // is the state one of the armed states
  bool is_state_armed(AlarmControlPanelState state);
-  /// Armed, pending (entry delay) or triggered; not ARMING (exit delay). Backs the is_armed and ready
-  /// conditions.
-  bool is_armed_pending_or_triggered() {
-    auto state = this->get_state();
-    return this->is_state_armed(state) || state == ACP_STATE_PENDING || state == ACP_STATE_TRIGGERED;
-  }

 protected:
  friend AlarmControlPanelCall;
@@ -144,11 +138,11 @@ class AlarmControlPanel : public EntityBase {
  // in order to store last panel state in flash
  ESPPreferenceObject pref_;
  // current state
-  AlarmControlPanelState current_state_{ACP_STATE_DISARMED};
+  AlarmControlPanelState current_state_;
  // the desired (or previous) state
-  AlarmControlPanelState desired_state_{ACP_STATE_DISARMED};
+  AlarmControlPanelState desired_state_;
  // last time the state was updated
-  uint32_t last_update_{0};
+  uint32_t last_update_;
  // the call control function
  virtual void control(const AlarmControlPanelCall &call) = 0;
  // state callback - passes the new state to listeners
@@ -27,4 +27,84 @@ static_assert(std::is_trivially_copyable_v<StateAnyForwarder>);
 static_assert(sizeof(StateEnterForwarder<ACP_STATE_TRIGGERED>) <= sizeof(void *));
 static_assert(std::is_trivially_copyable_v<StateEnterForwarder<ACP_STATE_TRIGGERED>>);

+template<typename... Ts> class ArmAwayAction final : public Action<Ts...> {
+ public:
+  explicit ArmAwayAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  TEMPLATABLE_VALUE(std::string, code)
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->arm_away(this->code_.optional_value(x...)); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class ArmHomeAction final : public Action<Ts...> {
+ public:
+  explicit ArmHomeAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  TEMPLATABLE_VALUE(std::string, code)
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->arm_home(this->code_.optional_value(x...)); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class ArmNightAction final : public Action<Ts...> {
+ public:
+  explicit ArmNightAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  TEMPLATABLE_VALUE(std::string, code)
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->arm_night(this->code_.optional_value(x...)); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class DisarmAction final : public Action<Ts...> {
+ public:
+  explicit DisarmAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  TEMPLATABLE_VALUE(std::string, code)
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->disarm(this->code_.optional_value(x...)); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class PendingAction final : public Action<Ts...> {
+ public:
+  explicit PendingAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->make_call().pending().perform(); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class TriggeredAction final : public Action<Ts...> {
+ public:
+  explicit TriggeredAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->make_call().triggered().perform(); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class AlarmControlPanelCondition final : public Condition<Ts...> {
+ public:
+  AlarmControlPanelCondition(AlarmControlPanel *parent) : parent_(parent) {}
+  bool check(const Ts &...x) override {
+    return this->parent_->is_state_armed(this->parent_->get_state()) ||
+           this->parent_->get_state() == ACP_STATE_PENDING || this->parent_->get_state() == ACP_STATE_TRIGGERED;
+  }
+
+ protected:
+  AlarmControlPanel *parent_;
+};
+
 }  // namespace esphome::alarm_control_panel
@@ -1,6 +1,8 @@
 #pragma once
 #include "esphome/components/image/image.h"

+#include "esphome/core/automation.h"
+
 namespace esphome::animation {

 class Animation final : public image::Image {
@@ -33,4 +35,32 @@ class Animation final : public image::Image {
  int loop_current_iteration_;
 };

+template<typename... Ts> class AnimationNextFrameAction final : public Action<Ts...> {
+ public:
+  AnimationNextFrameAction(Animation *parent) : parent_(parent) {}
+  void play(const Ts &...x) override { this->parent_->next_frame(); }
+
+ protected:
+  Animation *parent_;
+};
+
+template<typename... Ts> class AnimationPrevFrameAction final : public Action<Ts...> {
+ public:
+  AnimationPrevFrameAction(Animation *parent) : parent_(parent) {}
+  void play(const Ts &...x) override { this->parent_->prev_frame(); }
+
+ protected:
+  Animation *parent_;
+};
+
+template<typename... Ts> class AnimationSetFrameAction final : public Action<Ts...> {
+ public:
+  AnimationSetFrameAction(Animation *parent) : parent_(parent) {}
+  TEMPLATABLE_VALUE(uint16_t, frame)
+  void play(const Ts &...x) override { this->parent_->set_frame(this->frame_.value(x...)); }
+
+ protected:
+  Animation *parent_;
+};
+
 }  // namespace esphome::animation
@@ -6,6 +6,8 @@ from esphome.components.file.image import image_schema, write_image
 from esphome.components.image import Image_, validate_settings
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_REPEAT
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 CODEOWNERS = ["@syndlex"]
@@ -24,6 +26,17 @@ animation_ns = cg.esphome_ns.namespace("animation")

 Animation_ = animation_ns.class_("Animation", Image_)

+# Actions
+NextFrameAction = animation_ns.class_(
+    "AnimationNextFrameAction", automation.Action, cg.Parented.template(Animation_)
+)
+PrevFrameAction = animation_ns.class_(
+    "AnimationPrevFrameAction", automation.Action, cg.Parented.template(Animation_)
+)
+SetFrameAction = animation_ns.class_(
+    "AnimationSetFrameAction", automation.Action, cg.Parented.template(Animation_)
+)
+
 ANIMATION_SCHEMA = image_schema(Animation_).extend(
    {
        cv.Optional(CONF_LOOP): cv.All(
@@ -59,17 +72,28 @@ SET_FRAME_SCHEMA = cv.Schema(
 )


-automation.register_apply_action(
-    "animation.next_frame", NEXT_FRAME_SCHEMA, automation.ApplyCall("next_frame()")
+@automation.register_action(
+    "animation.next_frame", NextFrameAction, NEXT_FRAME_SCHEMA, synchronous=True
 )
-automation.register_apply_action(
-    "animation.prev_frame", PREV_FRAME_SCHEMA, automation.ApplyCall("prev_frame()")
+@automation.register_action(
+    "animation.prev_frame", PrevFrameAction, PREV_FRAME_SCHEMA, synchronous=True
 )
-automation.register_apply_action(
-    "animation.set_frame",
-    SET_FRAME_SCHEMA,
-    automation.ApplyField(CONF_FRAME, "set_frame", cg.uint16),
+@automation.register_action(
+    "animation.set_frame", SetFrameAction, SET_FRAME_SCHEMA, synchronous=True
 )
+async def animation_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+
+    if (frame := config.get(CONF_FRAME)) is not None:
+        template_ = await cg.templatable(frame, args, cg.uint16)
+        cg.add(var.set_frame(template_))
+    return var


 async def setup_animation(config: ConfigType) -> None:
@@ -81,7 +81,7 @@ def AUTO_LOAD(config: ConfigType) -> list[str]:


 api_ns = cg.esphome_ns.namespace("api")
-APIServer = api_ns.class_("APIServer", cg.Component)
+APIServer = api_ns.class_("APIServer", cg.Component, cg.Controller)
 HomeAssistantServiceCallAction = api_ns.class_(
    "HomeAssistantServiceCallAction", automation.Action
 )
@@ -136,12 +136,6 @@ CONF_LISTEN_BACKLOG = "listen_backlog"
 CONF_MAX_SEND_QUEUE = "max_send_queue"
 CONF_STATE_SUBSCRIPTION_ONLY = "state_subscription_only"

-# Schema defaults that also match the C++ initializers in api_server.h; codegen
-# skips the setter when the config equals them.
-DEFAULT_PORT = 6053
-DEFAULT_REBOOT_TIMEOUT = "15min"
-DEFAULT_BATCH_DELAY = "100ms"
-

 def _register_provisioning_source(config: ConfigType) -> ConfigType:
    """Register the API as a provisioning source when encryption is enabled.
@@ -298,7 +292,7 @@ CONFIG_SCHEMA = cv.All(
    cv.Schema(
        {
            cv.GenerateID(): cv.declare_id(APIServer),
-            cv.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+            cv.Optional(CONF_PORT, default=6053): cv.port,
            # Removed in 2026.1.0 - kept to provide helpful error message
            cv.Optional(CONF_PASSWORD): cv.invalid(
                "The 'password' option has been removed in ESPHome 2026.1.0.\n"
@@ -311,14 +305,14 @@ CONFIG_SCHEMA = cv.All(
                "Or visit https://esphome.io/components/api/#configuration-variables"
            ),
            cv.Optional(
-                CONF_REBOOT_TIMEOUT, default=DEFAULT_REBOOT_TIMEOUT
+                CONF_REBOOT_TIMEOUT, default="15min"
            ): cv.positive_time_period_milliseconds,
            cv.Exclusive(
                CONF_SERVICES, group_of_exclusion=CONF_ACTIONS
            ): ACTIONS_SCHEMA,
            cv.Exclusive(CONF_ACTIONS, group_of_exclusion=CONF_ACTIONS): ACTIONS_SCHEMA,
            cv.Optional(CONF_ENCRYPTION): encryption_schema,
-            cv.Optional(CONF_BATCH_DELAY, default=DEFAULT_BATCH_DELAY): cv.All(
+            cv.Optional(CONF_BATCH_DELAY, default="100ms"): cv.All(
                cv.positive_time_period_milliseconds,
                cv.Range(max=cv.TimePeriod(milliseconds=65535)),
            ),
@@ -356,9 +350,10 @@ CONFIG_SCHEMA = cv.All(
                ln882x=5,  # Moderate RAM
                nrf52=4,  # ~256KB RAM, BSD sockets, Thread (single HA controller)
            ): cv.int_range(min=1, max=20),
-            # Max queued messages per connection, and 2 KB of backlog per slot up
-            # to 64 KB (a lone message is exempt), before the connection is dropped
+            # Maximum queued send buffers per connection before dropping connection
+            # Each buffer uses ~8-12 bytes overhead plus actual message size
            # Platform defaults based on available RAM and typical message rates:
+            # CONF_MAX_SEND_QUEUE defaults are power of 2 for efficient modulo
            cv.SplitDefault(
                CONF_MAX_SEND_QUEUE,
                esp8266=4,  # Limited RAM, need to fail fast
@@ -462,20 +457,15 @@ async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)

-    CORE.register_controller(var)
+    # Track controller registration for StaticVector sizing
+    CORE.register_controller()

    # Request a log listener slot for API log streaming
    request_log_listener()

-    # Skip the setters when the config matches the C++ initializers (DEFAULT_*).
-    if (port := config[CONF_PORT]) != DEFAULT_PORT:
-        cg.add(var.set_port(port))
-    if (reboot_timeout := config[CONF_REBOOT_TIMEOUT]) != cv.time_period(
-        DEFAULT_REBOOT_TIMEOUT
-    ):
-        cg.add(var.set_reboot_timeout(reboot_timeout))
-    if (batch_delay := config[CONF_BATCH_DELAY]) != cv.time_period(DEFAULT_BATCH_DELAY):
-        cg.add(var.set_batch_delay(batch_delay))
+    cg.add(var.set_port(config[CONF_PORT]))
+    cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
+    cg.add(var.set_batch_delay(config[CONF_BATCH_DELAY]))
    if CONF_LISTEN_BACKLOG in config:
        cg.add(var.set_listen_backlog(config[CONF_LISTEN_BACKLOG]))
    cg.add_define("MAX_API_CONNECTIONS", config[CONF_MAX_CONNECTIONS])
@@ -803,9 +803,6 @@ message SwitchStateResponse {
  fixed32 key = 1 [(force) = true];
  bool state = 2;
  uint32 device_id = 3 [(field_ifdef) = "USE_DEVICES"];
-  // If the switch does not have a valid state yet.
-  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
-  bool missing_state = 4;
 }
 message SwitchCommandRequest {
  option (id) = 33;
@@ -1247,9 +1244,6 @@ message ClimateStateResponse {
  float current_humidity = 14;
  float target_humidity = 15;
  uint32 device_id = 16 [(field_ifdef) = "USE_DEVICES"];
-  // If the climate device does not have a valid state yet.
-  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
-  bool missing_state = 17;
 }
 message ClimateCommandRequest {
  option (id) = 48;
@@ -1336,9 +1330,6 @@ message WaterHeaterStateResponse {
  uint32 state = 6;
  float target_temperature_low = 7;
  float target_temperature_high = 8;
-  // If the water heater does not have a valid state yet.
-  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
-  bool missing_state = 9;
 }

 // Bitmask for WaterHeaterCommandRequest.has_fields
@@ -1,37 +1,20 @@
 #include "api_buffer.h"
-#ifdef ESPHOME_DEBUG_API
-#include "esphome/core/log.h"
-#endif
+#include <new>

 namespace esphome::api {

-#ifdef ESPHOME_DEBUG_API
-void APIBuffer::debug_check_drop_(size_t drop) const {
-  if (drop > this->size_) {
-    ESP_LOGE("api.buffer", "drop_front: drop=%zu size=%u", drop, this->size_);
-    abort();
-  }
-}
-#endif
-
 bool APIBuffer::grow_(size_t n) {
-  if (n > MAX_SIZE)
+  // nothrow (no zero-fill) so OOM is reportable; plain new aborts instead
+  // (NEW_OOM_ABORT on ESP8266 Arduino, exception stub on ESP-IDF).
+  // RAMAllocator is no fit here: unique_ptr needs delete[]-compatible memory.
+  std::unique_ptr<uint8_t[]> new_data(new (std::nothrow) uint8_t[n]);
+  if (new_data == nullptr)
    return false;
-  // realloc extends in place when it can, avoiding the copy
-  uint8_t *grown = RAMAllocator<uint8_t>().reallocate(this->data_.get(), n);
-  if (grown == nullptr)
-    return false;
-  (void) this->data_.release();  // realloc already freed or reused the old block
-  this->data_.reset(grown);
+  if (this->size_)
+    std::memcpy(new_data.get(), this->data_.get(), this->size_);
+  this->data_ = std::move(new_data);
  this->capacity_ = n;
  return true;
 }

-uint8_t *APIBuffer::append(size_t n) {
-  const size_t old_size = this->size_;
-  if (!this->resize(old_size + n))
-    return nullptr;
-  return this->data_.get() + old_size;
-}
-
 }  // namespace esphome::api
@@ -25,7 +25,6 @@ namespace esphome::api {
 /// writes in debug builds.
 class APIBuffer {
 public:
-  static constexpr size_t MAX_SIZE = UINT16_MAX;  // API frames carry 16 bit lengths
  void clear() { this->size_ = 0; }
  /// Returns false if allocation fails; the buffer is left unchanged.
  [[nodiscard]] inline bool reserve(size_t n) ESPHOME_ALWAYS_INLINE { return n <= this->capacity_ || this->grow_(n); }
@@ -37,19 +36,9 @@ class APIBuffer {
  [[nodiscard]] inline bool reserve_and_resize(size_t reserve_size, size_t new_size) ESPHOME_ALWAYS_INLINE {
    if (!this->reserve(std::max(reserve_size, new_size)))
      return false;
-    this->size_ = static_cast<uint16_t>(new_size);
+    this->size_ = new_size;
    return true;
  }
-  /// Grow by n bytes; returns the new bytes, or nullptr on allocation failure.
-  [[nodiscard]] uint8_t *append(size_t n);
-  /// Drop the first `drop` bytes, sliding the rest down. Precondition: drop <= size().
-  void drop_front(size_t drop) {
-#ifdef ESPHOME_DEBUG_API
-    this->debug_check_drop_(drop);
-#endif
-    this->size_ -= drop;
-    std::memmove(this->data_.get(), this->data_.get() + drop, this->size_);
-  }
  uint8_t *data() { return this->data_.get(); }
  const uint8_t *data() const { return this->data_.get(); }
  size_t size() const { return this->size_; }
@@ -66,14 +55,9 @@ class APIBuffer {

 protected:
  bool grow_(size_t n);
-#ifdef ESPHOME_DEBUG_API
-  void debug_check_drop_(size_t drop) const;
-#endif
-  // RAMAllocator: PSRAM when available, and it reports failure where
-  // new (std::nothrow) still aborts on ESP-IDF without exceptions
-  RAMUniquePtr<uint8_t[]> data_;
-  uint16_t size_{0};
-  uint16_t capacity_{0};
+  std::unique_ptr<uint8_t[]> data_;
+  size_t size_{0};
+  size_t capacity_{0};
 };

 }  // namespace esphome::api
@@ -364,10 +364,7 @@ void APIConnection::check_keepalive_(uint32_t now) {
    ESP_LOGVV(TAG, "Sending keepalive PING");
    PingRequest req;
    this->flags_.sent_ping = this->send_message(req);
-    if (this->flags_.sent_ping) {
-      // Quiet for a keepalive period and the ping is on its way: a one-off stall's storage can go
-      this->helper_->release_overflow_buffer();
-    } else {
+    if (!this->flags_.sent_ping) {
      // If we can't send the ping request directly (tx_buffer full),
      // schedule it at the front of the batch so it will be sent with priority
      ESP_LOGW(TAG, "Buffer full, ping queued");
@@ -600,7 +597,7 @@ bool APIConnection::send_light_state(light::LightState *light) {
 uint16_t APIConnection::try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
  auto *light = static_cast<light::LightState *>(entity);
  LightStateResponse resp;
-  auto values = light->get_reported_values();
+  auto values = light->remote_values;
  auto color_mode = values.get_color_mode();
  resp.state = values.is_on();
  resp.color_mode = static_cast<enums::ColorMode>(color_mode);
@@ -709,7 +706,6 @@ uint16_t APIConnection::try_send_switch_state(EntityBase *entity, APIConnection
  auto *a_switch = static_cast<switch_::Switch *>(entity);
  SwitchStateResponse resp;
  resp.state = a_switch->state;
-  resp.missing_state = !a_switch->has_state();
  return fill_and_encode_entity_state(a_switch, resp, conn, remaining_size);
 }

@@ -721,7 +717,12 @@ uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *
 }
 void APIConnection::on_switch_command_request(const SwitchCommandRequest &msg) {
  ENTITY_COMMAND_GET(switch_::Switch, a_switch, switch)
-  a_switch->control(msg.state);
+
+  if (msg.state) {
+    a_switch->turn_on();
+  } else {
+    a_switch->turn_off();
+  }
 }
 #endif

@@ -755,7 +756,6 @@ uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection
  auto traits = climate->get_traits();
  resp.mode = static_cast<enums::ClimateMode>(climate->mode);
  resp.action = static_cast<enums::ClimateAction>(climate->action);
-  resp.missing_state = !climate->has_state();
  if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE))
    resp.current_temperature = climate->current_temperature;
  if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
@@ -1449,7 +1449,6 @@ uint16_t APIConnection::try_send_water_heater_state(EntityBase *entity, APIConne
  auto *wh = static_cast<water_heater::WaterHeater *>(entity);
  WaterHeaterStateResponse resp;
  resp.mode = static_cast<enums::WaterHeaterMode>(wh->get_mode());
-  resp.missing_state = !wh->has_state();
  resp.current_temperature = wh->get_current_temperature();
  resp.target_temperature = wh->get_target_temperature();
  resp.target_temperature_low = wh->get_target_temperature_low();
@@ -2270,12 +2269,7 @@ 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};
-  uint8_t *end = encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
-#ifdef ESPHOME_DEBUG_API
-  proto_check_encode_end(end, shared_buf.data() + shared_buf.size());
-#else
-  (void) end;
-#endif
+  encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
  return this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type);
 }
 // encode_to_buffer is defined inline in api_connection.h (ESPHOME_ALWAYS_INLINE)
@@ -346,7 +346,11 @@ 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) {
-    return this->send_message_(T::calc_size_msg(&msg), T::MESSAGE_TYPE, &T::encode_msg, &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);
+    }
  }

  /// Clear the shared write buffer and reserve space for the first message.
@@ -402,6 +406,16 @@ 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);

@@ -420,7 +434,11 @@ 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) {
-    return encode_to_buffer_slow(T::calc_size_msg(&msg), &T::encode_msg, &msg, conn, 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);
+    }
  }

  // Non-template core — fills state fields and encodes
@@ -432,7 +450,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, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
+    return fill_and_encode_entity_state(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
  }

  // Non-template core — fills info fields, allocates buffers, and encodes
@@ -444,7 +462,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, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
+    return fill_and_encode_entity_info(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
  }

  // Non-template core — fills device_class, then delegates to fill_and_encode_entity_info
@@ -458,8 +476,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, &T::calc_size_msg,
-                                                         &T::encode_msg, conn, 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);
  }

 #ifdef USE_VOICE_ASSISTANT
@@ -46,13 +46,7 @@ inline uint16_t ESPHOME_ALWAYS_INLINE APIConnection::encode_to_buffer(uint32_t c
    return 0;
  }
  ProtoWriteBuffer buffer{&shared_buf, shared_buf.size() - calculated_size};
-  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
-  proto_check_encode_end(end, shared_buf.data() + shared_buf.size());
-#else
-  (void) end;
-#endif
+  encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));

  return total_calculated_size;
 }
@@ -171,7 +171,7 @@ APIError APIFrameHelper::write_raw_iov_(const struct iovec *iov, int iovcnt, uin
    return APIError::OK;

  // Queue unsent data into overflow buffer
-  if (!this->overflow_buf_.enqueue_iov(iov, iovcnt, total_write_len, sent)) {
+  if (!this->overflow_buf_.enqueue_iov(iov, iovcnt, total_write_len, static_cast<uint16_t>(sent))) {
    HELPER_LOG("Overflow buffer full or out of memory, dropping connection");
    this->state_ = State::FAILED;
    return APIError::SOCKET_WRITE_FAILED;
@@ -219,10 +219,7 @@ class APIFrameHelper {
    if (this->rx_buf_len_ == 0) {
      this->rx_buf_.release();
    }
-    this->release_overflow_buffer();
  }
-  // Free the send backlog storage once it has drained
-  void release_overflow_buffer() { this->overflow_buf_.release(); }

 protected:
  // Drain backlogged overflow data to the socket and handle errors.
@@ -5,13 +5,16 @@
 #include "esphome/components/noise/noise.h"
 #include "esphome/core/application.h"
 #include "esphome/core/entity_base.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "proto.h"
 #include <cstring>
 #include <cinttypes>

+#ifdef USE_ESP8266
+#include <pgmspace.h>
+#endif
+
 namespace esphome::api {

 using noise::noise_err_to_logstr;
@@ -23,7 +26,11 @@ static_assert(MAX_HANDSHAKE_SIZE == noise::MAX_HANDSHAKE_SIZE,
              "api and noise component handshake size limits must match");

 static const char *const TAG = "api.noise";
+#ifdef USE_ESP8266
 static constexpr char PROLOGUE_INIT[] PROGMEM = "NoiseAPIInit";
+#else
+static const char *const PROLOGUE_INIT = "NoiseAPIInit";
+#endif
 static constexpr size_t PROLOGUE_INIT_LEN = 12;  // strlen("NoiseAPIInit")

 // Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
@@ -60,12 +67,16 @@ APIError APINoiseFrameHelper::init() {
  }

  // init prologue
-  uint8_t *dst = prologue_.append(PROLOGUE_INIT_LEN);
-  if (dst == nullptr) [[unlikely]] {
+  size_t old_size = prologue_.size();
+  if (!prologue_.resize(old_size + PROLOGUE_INIT_LEN)) [[unlikely]] {
    state_ = State::FAILED;
    return APIError::OUT_OF_MEMORY;
  }
-  progmem_memcpy(dst, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+#ifdef USE_ESP8266
+  memcpy_P(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+#else
+  std::memcpy(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+#endif

  state_ = State::CLIENT_HELLO;
  return APIError::OK;
@@ -261,17 +272,17 @@ APIError APINoiseFrameHelper::state_action_client_hello_() {
    return handle_handshake_frame_error_(aerr);
  }
  // ignore contents, may be used in future for flags
-  // Append 2 size bytes + frame data to the prologue
+  // Resize for: existing prologue + 2 size bytes + frame data
+  size_t old_size = this->prologue_.size();
  size_t rx_size = this->rx_buf_.size();
-  uint8_t *dst = this->prologue_.append(2 + rx_size);
-  if (dst == nullptr) [[unlikely]] {
+  if (!this->prologue_.resize(old_size + 2 + rx_size)) [[unlikely]] {
    state_ = State::FAILED;
    return APIError::OUT_OF_MEMORY;
  }
-  dst[0] = (uint8_t) (rx_size >> 8);
-  dst[1] = (uint8_t) rx_size;
+  this->prologue_[old_size] = (uint8_t) (rx_size >> 8);
+  this->prologue_[old_size + 1] = (uint8_t) rx_size;
  if (rx_size > 0) {
-    std::memcpy(dst + 2, this->rx_buf_.data(), rx_size);
+    std::memcpy(this->prologue_.data() + old_size + 2, this->rx_buf_.data(), rx_size);
  }

  state_ = State::SERVER_HELLO;
@@ -1,91 +1,98 @@
 #include "api_overflow_buffer.h"
 #ifdef USE_API
 #include <cstring>
+#include <new>

 namespace esphome::api {

+APIOverflowBuffer::~APIOverflowBuffer() {
+  for (auto *entry : this->queue_) {
+    if (entry != nullptr)
+      Entry::destroy(entry);
+  }
+}
+
 ssize_t APIOverflowBuffer::try_drain(socket::Socket *socket) {
-  // Nested call from inside socket->write(); see draining_
+  // socket->write() can re-enter this function: a log message emitted from an
+  // lwip callback during the write goes out over the API and lands back in the
+  // frame helper's write/drain path. If a nested drain ran here it would send
+  // and free the entry the outer drain is still holding, causing a double free.
+  // Report "no progress" instead; the outer drain keeps draining, and the
+  // nested send is enqueued behind the existing backlog.
  if (this->draining_)
    return 0;

+  // RAII so the flag is cleared on every return path
  struct DrainGuard {
-    APIOverflowBuffer &owner;
-    ~DrainGuard() { this->owner.draining_ = false; }
-  } guard{*this};
-  this->draining_ = true;
+    explicit DrainGuard(bool &flag) : flag_(flag) { flag_ = true; }
+    ~DrainGuard() { this->flag_ = false; }
+    bool &flag_;
+  } guard(this->draining_);

  while (this->count_ > 0) {
-    uint8_t *msg = this->buf_.data() + this->head_;
-    size_t len = msg[0] | (msg[1] << 8);
+    Entry *front = this->queue_[this->head_];

-    ssize_t sent = socket->write(msg + LEN_PREFIX, len);
-    if (sent <= 0)
-      return sent;
-    if (static_cast<size_t>(sent) < len) {
-      // Step past the sent bytes and rewrite the prefix there; it lands on bytes already sent
-      this->head_ += sent;
-      len -= sent;
-      msg += sent;
-      msg[0] = len;
-      msg[1] = len >> 8;
+    ssize_t sent = socket->write(front->current_data(), front->remaining());
+
+    if (sent <= 0) {
+      // -1 = error (caller checks errno for EWOULDBLOCK vs hard error)
+      // 0 = nothing sent (treat as no progress)
      return sent;
    }
-    this->head_ += LEN_PREFIX + len;
+
+    if (static_cast<uint16_t>(sent) < front->remaining()) {
+      // Partially sent, update offset and stop
+      front->offset += static_cast<uint16_t>(sent);
+      return sent;
+    }
+
+    // Entry fully sent — unlink it before freeing so a freed pointer is never
+    // reachable from the queue
+    this->queue_[this->head_] = nullptr;
+    this->head_ = (this->head_ + 1) % API_MAX_SEND_QUEUE;
    this->count_--;
+    Entry::destroy(front);
  }

-  this->head_ = 0;
-  if (this->release_when_drained_) {
-    this->release_when_drained_ = false;
-    this->buf_.release();
-  } else {
-    this->buf_.clear();
-  }
-  return 0;
+  return 0;  // All drained
 }

-bool APIOverflowBuffer::enqueue_iov(const struct iovec *iov, int iovcnt, size_t total_len, size_t skip) {
+bool APIOverflowBuffer::enqueue_iov(const struct iovec *iov, int iovcnt, uint16_t total_len, uint16_t skip) {
  if (this->count_ >= API_MAX_SEND_QUEUE)
    return false;

-  const size_t new_len = total_len - skip;
-  const size_t new_bytes = LEN_PREFIX + new_len;
-  const size_t live = this->buf_.size() - this->head_;
-  // A lone message is only bound by the buffer; refusing it would just drop the connection
-  if (live + new_bytes > (this->count_ > 0 ? MAX_BYTES : MAX_LONE_BYTES))
+  uint16_t buffer_size = total_len - skip;
+  // nothrow: a failed allocation returns nullptr so the connection is dropped
+  // cleanly instead of plain new's crash or abort on OOM
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
+  auto *data = new (std::nothrow) uint8_t[buffer_size];
+  if (data == nullptr)
+    return false;
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
+  auto *entry = new (std::nothrow) Entry{data, buffer_size, 0};
+  if (entry == nullptr) {
+    delete[] data;
    return false;
-
-  if (this->buf_.size() + new_bytes > this->buf_.capacity()) {
-    // Storage would move under an outer drain's write()
-    if (this->draining_)
-      return false;
-    if (this->head_ > 0) {
-      // Reclaim the sent prefix before growing
-      this->buf_.drop_front(this->head_);
-      this->head_ = 0;
-    }
-    if (!this->buf_.reserve(reserve_for(live + new_bytes)))
-      return false;
  }

-  uint8_t *dst = this->buf_.append(new_bytes);
-  if (dst == nullptr)
-    return false;
-  dst[0] = new_len;
-  dst[1] = new_len >> 8;
-  dst += LEN_PREFIX;
-  for (const struct iovec *end = iov + iovcnt; iov != end; iov++) {
-    if (skip >= iov->iov_len) {
-      skip -= iov->iov_len;
+  uint16_t to_skip = skip;
+  uint16_t write_pos = 0;
+
+  for (int i = 0; i < iovcnt; i++) {
+    if (to_skip >= iov[i].iov_len) {
+      to_skip -= static_cast<uint16_t>(iov[i].iov_len);
    } else {
-      const size_t len = iov->iov_len - skip;
-      std::memcpy(dst, static_cast<const uint8_t *>(iov->iov_base) + skip, len);
-      dst += len;
-      skip = 0;
+      const uint8_t *src = reinterpret_cast<uint8_t *>(iov[i].iov_base) + to_skip;
+      uint16_t len = static_cast<uint16_t>(iov[i].iov_len) - to_skip;
+      std::memcpy(entry->data + write_pos, src, len);
+      write_pos += len;
+      to_skip = 0;
    }
  }

+  // Publish only after the copy completes so a half-built entry is never reachable
+  this->queue_[this->tail_] = entry;
+  this->tail_ = (this->tail_ + 1) % API_MAX_SEND_QUEUE;
  this->count_++;
  return true;
 }
@@ -1,6 +1,5 @@
 #pragma once
-#include <algorithm>
-#include <cstddef>
+#include <array>
 #include <cstdint>
 #include <sys/types.h>

@@ -9,57 +8,71 @@

 #include "esphome/components/socket/headers.h"
 #include "esphome/components/socket/socket.h"
-#include "api_buffer.h"
+#include "esphome/core/helpers.h"

 namespace esphome::api {

-/// TCP send backlog, only used when the socket send buffer is full.
-/// One contiguous buffer per connection, allocated on the first stall and
-/// kept at its high-water mark so a lossy link does not churn the heap.
-/// Messages are stored as a 2 byte length prefix plus payload.
-/// API_MAX_SEND_QUEUE bounds queued messages and, at 2 KB per slot, queued
-/// bytes; exceeding either fails the connection.
+/// Circular queue of heap-allocated byte buffers used as a TCP send backlog.
+///
+/// Under normal operation this buffer is **never used** — data goes straight
+/// from the frame helper to the socket.  It only fills when the LWIP TCP
+/// send buffer is full (slow client, congested network, heavy logging).
+/// The queue drains automatically on subsequent write/loop calls once the
+/// socket becomes writable again.
+///
+/// Capacity is compile-time-fixed via API_MAX_SEND_QUEUE (set from Python
+/// config).  If the queue fills completely the connection is marked failed.
 class APIOverflowBuffer {
 public:
+  /// A single heap-allocated send-backlog entry.
+  /// Lifetime is manually managed — see destroy().
+  struct Entry {
+    uint8_t *data;
+    uint16_t size;    // Total size of the buffer
+    uint16_t offset;  // Current send offset within the buffer
+
+    uint16_t remaining() const { return this->size - this->offset; }
+    const uint8_t *current_data() const { return this->data + this->offset; }
+
+    /// Free this entry and its data buffer.
+    static ESPHOME_ALWAYS_INLINE void destroy(Entry *entry) {
+      delete[] entry->data;
+      delete entry;  // NOLINT(cppcoreguidelines-owning-memory)
+    }
+  };
+
+  ~APIOverflowBuffer();
+
  /// True when no backlogged data is waiting.
  bool empty() const { return this->count_ == 0; }

-  /// Drain queued messages to the socket.
-  /// Returns bytes written, 0 for a re-entrant call, -1 on error (check errno
-  /// for EWOULDBLOCK); callers only need to act on -1.
+  /// True when the queue has no room for another entry.
+  bool full() const { return this->count_ >= API_MAX_SEND_QUEUE; }
+
+  /// Number of entries currently queued.
+  uint8_t count() const { return this->count_; }
+
+  /// Try to drain queued data to the socket.
+  /// Returns bytes-written > 0 on success/partial, 0 if all drained or no progress,
+  /// -1 on error (caller must check errno to distinguish EWOULDBLOCK from hard errors).
+  /// Callers only need to act on -1; 0 and positive values both mean "no error".
+  /// Frees entries as they are fully sent.
  ssize_t try_drain(socket::Socket *socket);

-  /// Queue iov data from byte offset `skip` as one message.
-  /// Returns false when a limit is hit, allocation fails, or storage would move
-  /// during a drain; the caller should fail the connection.
-  bool enqueue_iov(const struct iovec *iov, int iovcnt, size_t total_len, size_t skip);
-
-  /// Free the retained storage, now if empty, otherwise once it has drained.
-  void release() {
-    if (this->count_ == 0) {
-      this->buf_.release();
-    } else {
-      this->release_when_drained_ = true;
-    }
-  }
+  /// Enqueue unsent IOV data into the backlog.
+  /// Copies iov data starting at byte offset `skip` into a new entry.
+  /// Returns false if the queue is full or allocation fails (caller should fail the connection).
+  bool enqueue_iov(const struct iovec *iov, int iovcnt, uint16_t total_len, uint16_t skip);

 protected:
-  static constexpr size_t LEN_PREFIX = 2;
-  static constexpr size_t BYTES_PER_SLOT = 2048;
-  // Reserve in 256 byte steps so a creeping high-water mark settles quickly
-  static constexpr size_t GROW_QUANTUM = 256;
-  // Lone message ceiling, rounded down so reserve_for() never exceeds the buffer limit
-  static constexpr size_t MAX_LONE_BYTES = APIBuffer::MAX_SIZE & ~(GROW_QUANTUM - 1);
-  static constexpr size_t MAX_BYTES = std::min(API_MAX_SEND_QUEUE * BYTES_PER_SLOT, MAX_LONE_BYTES);
-  static constexpr size_t reserve_for(size_t want) { return (want + GROW_QUANTUM - 1) & ~(GROW_QUANTUM - 1); }
-
-  APIBuffer buf_;
-  uint16_t head_{0};  // offset of the front message's length prefix; bytes before it are sent
+  std::array<Entry *, API_MAX_SEND_QUEUE> queue_{};
+  uint8_t head_{0};
+  uint8_t tail_{0};
  uint8_t count_{0};
-  // socket->write() can re-enter the send path (log from an lwip callback):
-  // a nested drain makes no progress and a nested enqueue never moves storage
-  bool draining_ : 1 {false};
-  bool release_when_drained_ : 1 {false};
+  // Guards against re-entrant drains: socket->write() can re-enter the API
+  // send path (e.g. a log message emitted from an lwip callback), and a nested
+  // drain would free the entry the outer drain is still holding.
+  bool draining_{false};
 };

 }  // namespace esphome::api
@@ -1342,7 +1342,6 @@ const char *SwitchStateResponse::dump_to(DumpBuffer &out) const {
 #ifdef USE_DEVICES
  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
  return out.c_str();
 }
 const char *SwitchCommandRequest::dump_to(DumpBuffer &out) const {
@@ -1685,7 +1684,6 @@ const char *ClimateStateResponse::dump_to(DumpBuffer &out) const {
 #ifdef USE_DEVICES
  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
  return out.c_str();
 }
 const char *ClimateCommandRequest::dump_to(DumpBuffer &out) const {
@@ -1753,7 +1751,6 @@ const char *WaterHeaterStateResponse::dump_to(DumpBuffer &out) const {
  dump_field(out, ESPHOME_PSTR("state"), this->state);
  dump_field(out, ESPHOME_PSTR("target_temperature_low"), this->target_temperature_low);
  dump_field(out, ESPHOME_PSTR("target_temperature_high"), this->target_temperature_high);
-  dump_field(out, ESPHOME_PSTR("missing_state"), this->missing_state);
  return out.c_str();
 }
 const char *WaterHeaterCommandRequest::dump_to(DumpBuffer &out) const {
@@ -5,6 +5,7 @@
 #include "api_connection.h"
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
+#include "esphome/core/controller_registry.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
@@ -28,29 +29,6 @@ static const char *const TAG = "api";
 // APIServer
 APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

-#ifdef USE_API_NOISE
-static constexpr uint32_t NOISE_PSK_PREF_HASH = 88491486UL;
-#endif
-
-#if defined(USE_API_NOISE) && defined(USE_OTA_ENCRYPTION_PROVISIONED)
-bool load_saved_noise_psk(noise::psk_t &out) {
-  SavedNoisePsk saved;
-#ifdef USE_PREFERENCE_KEY_LOOKUP
-  const bool loaded =
-      global_preferences->load_from_key(NOISE_PSK_PREF_HASH, reinterpret_cast<uint8_t *>(&saved), sizeof(saved));
-#else
-  // Slot backends need the reservation walk; it only lands on the record when the reservations before
-  // it match a normal boot, otherwise the type checked checksum fails the load
-  const bool loaded = global_preferences->make_preference<SavedNoisePsk>(NOISE_PSK_PREF_HASH, true).load(&saved);
-#endif
-  // The all-zeros record means no key
-  if (!loaded || noise::NoiseContext::is_all_zeros(saved.psk))
-    return false;
-  out = saved.psk;
-  return true;
-}
-#endif
-
 APIServer::APIServer() { global_api_server = this; }

 void APIServer::socket_failed_(const LogString *msg) {
@@ -60,10 +38,13 @@ void APIServer::socket_failed_(const LogString *msg) {
 }

 void APIServer::setup() {
+  ControllerRegistry::register_controller(this);
+
 #ifdef USE_API_NOISE
  // Always reserve the slot: flash preferences are positional on esp8266, so
  // a yaml key build must keep the layout of a runtime key build
-  this->noise_pref_ = global_preferences->make_preference<SavedNoisePsk>(NOISE_PSK_PREF_HASH, true);
+  uint32_t hash = 88491486UL;
+  this->noise_pref_ = global_preferences->make_preference<SavedNoisePsk>(hash, true);
 #ifndef USE_API_NOISE_PSK_FROM_YAML
  // A cleared record loads fine but holds no key
  if (this->load_and_apply_noise_psk_() && this->noise_ctx_.has_psk()) {
@@ -452,9 +433,8 @@ void APIServer::send_homeassistant_action(const HomeassistantActionRequest &call
    // Home Assistant subscribes to actions shortly *after* authenticating, so actions
    // fired right at connection time (on_client_connected, on_time_sync, ...) can
    // arrive before the subscription and are lost - warn instead of failing silently.
-    ESP_LOGW(TAG, "Home Assistant %s '%.*s' dropped; %s",
-             call.is_event ? LOG_STR_LITERAL("event") : LOG_STR_LITERAL("action"),
-             static_cast<int>(call.service.size()), call.service.empty() ? "" : call.service.c_str(),
+    ESP_LOGW(TAG, "Home Assistant %s '%s' dropped; %s",
+             call.is_event ? LOG_STR_LITERAL("event") : LOG_STR_LITERAL("action"), call.service.c_str(),
             this->is_connected() ? LOG_STR_LITERAL("client has not subscribed to actions (yet)")
                                  : LOG_STR_LITERAL("no client connected"));
  }
@@ -14,7 +14,7 @@
 #include "esphome/components/socket/socket.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
-#include "esphome/core/entity_includes.h"
+#include "esphome/core/controller.h"
 #include "esphome/core/log.h"
 #include "esphome/core/string_ref.h"
 #ifdef USE_PROVISIONING
@@ -43,13 +43,9 @@ struct SavedNoisePsk {
  noise::psk_t psk;
 } PACKED;  // NOLINT
 #endif
-#if defined(USE_API_NOISE) && defined(USE_OTA_ENCRYPTION_PROVISIONED)
-/// One-shot read of the provisioned key for a boot without an api server (safe mode); false when
-/// there is no key
-bool load_saved_noise_psk(noise::psk_t &out);
-#endif

-class APIServer final : public Component
+class APIServer final : public Component,
+                        public Controller
 #ifdef USE_CAMERA
    ,
                        public camera::CameraListener
@@ -93,58 +89,58 @@ class APIServer final : public Component

  void handle_disconnect(APIConnection *conn);
 #ifdef USE_BINARY_SENSOR
-  void on_binary_sensor_update(binary_sensor::BinarySensor *obj);
+  void on_binary_sensor_update(binary_sensor::BinarySensor *obj) override;
 #endif
 #ifdef USE_COVER
-  void on_cover_update(cover::Cover *obj);
+  void on_cover_update(cover::Cover *obj) override;
 #endif
 #ifdef USE_FAN
-  void on_fan_update(fan::Fan *obj);
+  void on_fan_update(fan::Fan *obj) override;
 #endif
 #ifdef USE_LIGHT
-  void on_light_update(light::LightState *obj);
+  void on_light_update(light::LightState *obj) override;
 #endif
 #ifdef USE_SENSOR
-  void on_sensor_update(sensor::Sensor *obj);
+  void on_sensor_update(sensor::Sensor *obj) override;
 #endif
 #ifdef USE_SWITCH
-  void on_switch_update(switch_::Switch *obj);
+  void on_switch_update(switch_::Switch *obj) override;
 #endif
 #ifdef USE_TEXT_SENSOR
-  void on_text_sensor_update(text_sensor::TextSensor *obj);
+  void on_text_sensor_update(text_sensor::TextSensor *obj) override;
 #endif
 #ifdef USE_CLIMATE
-  void on_climate_update(climate::Climate *obj);
+  void on_climate_update(climate::Climate *obj) override;
 #endif
 #ifdef USE_NUMBER
-  void on_number_update(number::Number *obj);
+  void on_number_update(number::Number *obj) override;
 #endif
 #ifdef USE_DATETIME_DATE
-  void on_date_update(datetime::DateEntity *obj);
+  void on_date_update(datetime::DateEntity *obj) override;
 #endif
 #ifdef USE_DATETIME_TIME
-  void on_time_update(datetime::TimeEntity *obj);
+  void on_time_update(datetime::TimeEntity *obj) override;
 #endif
 #ifdef USE_DATETIME_DATETIME
-  void on_datetime_update(datetime::DateTimeEntity *obj);
+  void on_datetime_update(datetime::DateTimeEntity *obj) override;
 #endif
 #ifdef USE_TEXT
-  void on_text_update(text::Text *obj);
+  void on_text_update(text::Text *obj) override;
 #endif
 #ifdef USE_SELECT
-  void on_select_update(select::Select *obj);
+  void on_select_update(select::Select *obj) override;
 #endif
 #ifdef USE_LOCK
-  void on_lock_update(lock::Lock *obj);
+  void on_lock_update(lock::Lock *obj) override;
 #endif
 #ifdef USE_VALVE
-  void on_valve_update(valve::Valve *obj);
+  void on_valve_update(valve::Valve *obj) override;
 #endif
 #ifdef USE_MEDIA_PLAYER
-  void on_media_player_update(media_player::MediaPlayer *obj);
+  void on_media_player_update(media_player::MediaPlayer *obj) override;
 #endif
 #ifdef USE_WATER_HEATER
-  void on_water_heater_update(water_heater::WaterHeater *obj);
+  void on_water_heater_update(water_heater::WaterHeater *obj) override;
 #endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
  void send_homeassistant_action(const HomeassistantActionRequest &call);
@@ -187,13 +183,13 @@ class APIServer final : public Component
 #endif

 #ifdef USE_ALARM_CONTROL_PANEL
-  void on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj);
+  void on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj) override;
 #endif
 #ifdef USE_EVENT
-  void on_event(event::Event *obj);
+  void on_event(event::Event *obj) override;
 #endif
 #ifdef USE_UPDATE
-  void on_update(update::UpdateEntity *obj);
+  void on_update(update::UpdateEntity *obj) override;
 #endif
 #ifdef USE_ZWAVE_PROXY
  void on_zwave_proxy_request(const ZWaveProxyRequest &msg);
@@ -318,7 +314,7 @@ class APIServer final : public Component
 #endif

  // 4-byte aligned types
-  uint32_t reboot_timeout_{900000};  // Keep in sync with DEFAULT_REBOOT_TIMEOUT in __init__.py
+  uint32_t reboot_timeout_{300000};
  uint32_t last_connected_{0};

  // Slots [0, api_connection_count_) are populated; trailing slots are always nullptr.
@@ -355,8 +351,8 @@ class APIServer final : public Component
 #endif

  // Group smaller types together
-  uint16_t port_{6053};        // Keep in sync with DEFAULT_PORT in __init__.py
-  uint16_t batch_delay_{100};  // Keep in sync with DEFAULT_BATCH_DELAY in __init__.py
+  uint16_t port_{6053};
+  uint16_t batch_delay_{100};
  // Connection limits - these defaults will be overridden by config values
  // from cv.SplitDefault in __init__.py which sets platform-specific defaults.
  uint8_t listen_backlog_{4};
@@ -195,12 +195,6 @@ void proto_check_bounds_failed(const uint8_t *pos, size_t bytes, const uint8_t *
  ESP_LOGE(TAG, "Proto encode bounds check failed in %s: need %zu bytes, %td available", caller, bytes, end - pos);
  abort();
 }
-void proto_check_encode_end(const uint8_t *end, const uint8_t *expected) {
-  if (end == expected)
-    return;
-  ESP_LOGE(TAG, "Proto encode ended %td bytes off the calculated size", end - expected);
-  abort();
-}
 void ProtoWriteBuffer::debug_check_bounds_(size_t bytes, const char *caller) {
  if (this->pos_ + bytes > this->buffer_->data() + this->buffer_->size()) {
    ESP_LOGE(TAG, "ProtoWriteBuffer bounds check failed in %s: bytes=%zu offset=%td buf_size=%zu", caller, bytes,
@@ -216,78 +210,77 @@ void ProtoWriteBuffer::debug_check_encode_size_(uint32_t field_id, uint32_t expe

 #endif

-void ProtoDecodableMessage::decode_fields(void *msg, const uint8_t *buffer, size_t length, DecodeFieldFn field) {
+void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
  const uint8_t *ptr = buffer;
  const uint8_t *end = buffer + length;

-  // Single-byte varints dominate, so that case advances the cursor inline.
-  auto read_varint = [&](proto_varint_value_t &value) ESPHOME_ALWAYS_INLINE {
-    if (ptr == end)
-      return false;
-    if (*ptr < 0x80) [[likely]] {
-      value = *ptr++;
-      return true;
-    }
-    auto res = ProtoVarInt::parse_non_empty(ptr, end - ptr);
-    if (!res.has_value())
-      return false;
-    value = res.value;
-    ptr += res.consumed;
-    return true;
-  };
-
  while (ptr < end) {
-    proto_varint_value_t tag_value;
-    if (!read_varint(tag_value)) {
+    // Parse field header - ptr < end guarantees len >= 1
+    auto res = ProtoVarInt::parse_non_empty(ptr, end - ptr);
+    if (!res.has_value()) {
      ESP_LOGV(TAG, "Invalid field start at offset %ld", (long) (ptr - buffer));
      return;
    }

-    uint32_t tag = static_cast<uint32_t>(tag_value);
+    uint32_t tag = static_cast<uint32_t>(res.value);
    uint32_t field_type = tag & WIRE_TYPE_MASK;
-    // Length-delimited fields move this past the length prefix
-    const uint8_t *data = ptr;
-    proto_varint_value_t scalar;
+    uint32_t field_id = tag >> 3;
+    ptr += res.consumed;

-    if (field_type == WIRE_TYPE_VARINT) [[likely]] {
-      if (!read_varint(scalar)) {
-        ESP_LOGV(TAG, "Invalid VarInt at offset %ld", (long) (ptr - buffer));
-        return;
-      }
-    } else {
-      switch (field_type) {
-        case WIRE_TYPE_LENGTH_DELIMITED: {
-          proto_varint_value_t length_value;
-          if (!read_varint(length_value)) {
-            ESP_LOGV(TAG, "Invalid Length Delimited at offset %ld", (long) (ptr - buffer));
-            return;
-          }
-          uint32_t field_length = static_cast<uint32_t>(length_value);
-          if (field_length > static_cast<size_t>(end - ptr)) {
-            ESP_LOGV(TAG, "Out-of-bounds Length Delimited at offset %ld", (long) (ptr - buffer));
-            return;
-          }
-          data = ptr;
-          scalar = field_length;
-          ptr += field_length;
-          break;
-        }
-        case WIRE_TYPE_FIXED32: {
-          if (end - ptr < 4) {
-            ESP_LOGV(TAG, "Out-of-bounds Fixed32-bit at offset %ld", (long) (ptr - buffer));
-            return;
-          }
-          // Byte loads instead of memcpy: ESP-IDF passes -fno-builtin-memcpy, which made this a call
-          scalar = encode_uint32(ptr[3], ptr[2], ptr[1], ptr[0]);
-          ptr += 4;
-          break;
-        }
-        default:
-          ESP_LOGV(TAG, "Invalid field type %" PRIu32 " at offset %ld", field_type, (long) (ptr - buffer));
+    switch (field_type) {
+      case WIRE_TYPE_VARINT: {  // VarInt
+        res = ProtoVarInt::parse(ptr, end - ptr);
+        if (!res.has_value()) {
+          ESP_LOGV(TAG, "Invalid VarInt at offset %ld", (long) (ptr - buffer));
          return;
+        }
+        if (!this->decode_varint(field_id, res.value)) {
+          ESP_LOGV(TAG, "Cannot decode VarInt field %" PRIu32 " with value %" PRIu64 "!", field_id,
+                   static_cast<uint64_t>(res.value));
+        }
+        ptr += res.consumed;
+        break;
      }
+      case WIRE_TYPE_LENGTH_DELIMITED: {  // Length-delimited
+        res = ProtoVarInt::parse(ptr, end - ptr);
+        if (!res.has_value()) {
+          ESP_LOGV(TAG, "Invalid Length Delimited at offset %ld", (long) (ptr - buffer));
+          return;
+        }
+        uint32_t field_length = static_cast<uint32_t>(res.value);
+        ptr += res.consumed;
+        if (field_length > static_cast<size_t>(end - ptr)) {
+          ESP_LOGV(TAG, "Out-of-bounds Length Delimited at offset %ld", (long) (ptr - buffer));
+          return;
+        }
+        if (!this->decode_length(field_id, ProtoLengthDelimited(ptr, field_length))) {
+          ESP_LOGV(TAG, "Cannot decode Length Delimited field %" PRIu32 "!", field_id);
+        }
+        ptr += field_length;
+        break;
+      }
+      case WIRE_TYPE_FIXED32: {  // 32-bit
+        if (end - ptr < 4) {
+          ESP_LOGV(TAG, "Out-of-bounds Fixed32-bit at offset %ld", (long) (ptr - buffer));
+          return;
+        }
+        uint32_t val;
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+        // Protobuf fixed32 is little-endian — direct load on LE platforms
+        memcpy(&val, ptr, 4);
+#else
+        val = encode_uint32(ptr[3], ptr[2], ptr[1], ptr[0]);
+#endif
+        if (!this->decode_32bit(field_id, Proto32Bit(val))) {
+          ESP_LOGV(TAG, "Cannot decode 32-bit field %" PRIu32 " with value %" PRIu32 "!", field_id, val);
+        }
+        ptr += 4;
+        break;
+      }
+      default:
+        ESP_LOGV(TAG, "Invalid field type %" PRIu32 " at offset %ld", field_type, (long) (ptr - buffer));
+        return;
    }
-    field(msg, tag, data, scalar);
  }
 }

@@ -10,7 +10,6 @@

 #include <cassert>
 #include <cstring>
-#include <type_traits>
 #include <vector>

 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
@@ -171,43 +170,40 @@ class ProtoVarInt {
 class ProtoMessage;
 class ProtoSize;

-/// Case label for decode_field(): the wire tag of a field, so a field that arrives with another wire
-/// type matches no case.
-constexpr uint32_t proto_tag(uint32_t field_id, uint32_t wire_type) { return (field_id << 3) | wire_type; }
-
-/// One decoded field: the payload pointer and a scalar holding the varint or fixed32 value, or the
-/// length of a length-delimited field. The wire type in the tag says which applies; accessors do not check.
-class ProtoFieldValue {
+class ProtoLengthDelimited {
 public:
-  ProtoFieldValue(const uint8_t *data, proto_varint_value_t scalar) : data_(data), scalar_(scalar) {}
+  explicit ProtoLengthDelimited(const uint8_t *value, size_t length) : value_(value), length_(length) {}
+  std::string as_string() const { return std::string(reinterpret_cast<const char *>(this->value_), this->length_); }

-  proto_varint_value_t as_varint() const { return this->scalar_; }
-  // A bool is sent as 0 or 1, so the low word is enough and saves a second compare with 64 bit varints
-  bool as_bool() const { return static_cast<uint32_t>(this->scalar_) != 0; }
+  // Direct access to raw data without string allocation
+  const uint8_t *data() const { return this->value_; }
+  size_t size() const { return this->length_; }

-  // Length-delimited accessors
-  const uint8_t *data() const { return this->data_; }
-  size_t size() const { return static_cast<size_t>(this->scalar_); }
-  std::string as_string() const { return std::string(reinterpret_cast<const char *>(this->data_), this->size()); }
-  /// Decode the length-delimited payload into a message instance.
+  /// Decode the length-delimited data into a message instance.
  /// Template preserves concrete type so decode() resolves statically.
-  template<typename T> void decode_to_message(T &msg) const { msg.decode(this->data_, this->size()); }
+  template<typename T> void decode_to_message(T &msg) const;

-  // Fixed32 accessors
-  uint32_t as_fixed32() const { return static_cast<uint32_t>(this->scalar_); }
-  int32_t as_sfixed32() const { return static_cast<int32_t>(this->as_fixed32()); }
+ protected:
+  const uint8_t *const value_;
+  const size_t length_;
+};
+
+class Proto32Bit {
+ public:
+  explicit Proto32Bit(uint32_t value) : value_(value) {}
+  uint32_t as_fixed32() const { return this->value_; }
+  int32_t as_sfixed32() const { return static_cast<int32_t>(this->value_); }
  float as_float() const {
    union {
      uint32_t raw;
      float value;
    } s{};
-    s.raw = this->as_fixed32();
+    s.raw = this->value_;
    return s.value;
  }

- private:
-  const uint8_t *data_;
-  proto_varint_value_t scalar_;
+ protected:
+  const uint32_t value_;
 };

 // NOTE: Proto64Bit class removed - wire type 1 (64-bit fixed) not supported
@@ -225,9 +221,6 @@ class ProtoFieldValue {
      proto_check_bounds_failed(pos, n, proto_debug_end_, __builtin_FUNCTION()); \
  } while (0)
 void proto_check_bounds_failed(const uint8_t *pos, size_t bytes, const uint8_t *end, const char *caller);
-/// Aborts unless an encode body ended exactly where calculate_size() promised. A plain check rather than
-/// assert(), so NDEBUG cannot switch it off.
-void proto_check_encode_end(const uint8_t *end, const uint8_t *expected);
 #else
 #define PROTO_ENCODE_DEBUG_PARAM
 #define PROTO_ENCODE_DEBUG_ARG
@@ -259,7 +252,7 @@ class ProtoWriteBuffer {
   *
   * Following https://protobuf.dev/programming-guides/encoding/#structure
   */
-  void encode_field_raw(uint32_t field_id, uint32_t type) { this->encode_varint_raw(proto_tag(field_id, type)); }
+  void encode_field_raw(uint32_t field_id, uint32_t type) { this->encode_varint_raw((field_id << 3) | type); }
  /// Single-pass encode for repeated submessage elements.
  /// Thin template wrapper; all buffer work is in the non-template core.
  template<typename T> void encode_sub_message(uint32_t field_id, const T &value);
@@ -294,31 +287,19 @@ 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 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.
+/// 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.
 class ProtoEncode {
 public:
  /// Write a multi-byte varint directly through a pos pointer.
  template<typename T>
-  [[nodiscard]] static inline uint8_t *encode_varint_raw_loop(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                              T value) {
+  static inline void 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);
@@ -326,49 +307,48 @@ class ProtoEncode {
    } while (value > 0x7F);
    PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
    *pos++ = static_cast<uint8_t>(value);
-    return pos;
  }
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_varint_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t value) {
+  static inline void 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 pos;
+      return;
    }
-    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    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).
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_varint_raw_short(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t value) {
+  static inline void 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 pos;
+      return;
    }
    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 pos;
+      return;
    }
-    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
  }
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_varint_raw_64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint64_t value) {
+  static inline void 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 pos;
+      return;
    }
-    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    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).
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_varint_raw_48bit(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint64_t value) {
+  static inline void 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
@@ -383,39 +363,38 @@ 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);
-      return pos + 7;
+      pos += 7;
+      return;
    }
-    return encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+    encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
  }
-  [[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, proto_tag(field_id, type));
+  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);
  }
  /// Write a single precomputed tag byte. Tag must be < 128.
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  write_raw_byte(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t b) {
+  static inline void 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.
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  reserve_byte(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
+  static inline void ESPHOME_ALWAYS_INLINE reserve_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM) {
    PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
-    return pos + 1;
+    pos++;
  }
  /// Write raw bytes to the buffer (no tag, no length prefix).
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, const void *data, size_t len) {
+  static inline void 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);
-    return pos + len;
+    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).
-  [[nodiscard]] static inline uint8_t *encode_short_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                 uint8_t tag, const StringRef &ref) {
+  static inline void 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
@@ -423,191 +402,137 @@ class ProtoEncode {
    pos[0] = tag;
    pos[1] = static_cast<uint8_t>(ref.size());
    std::memcpy(pos + 2, ref.c_str(), ref.size());
-    return pos + 2 + ref.size();
+    pos += 2 + ref.size();
  }
-  /// 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) {
+  /// 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) {
    PROTO_ENCODE_CHECK_BOUNDS(pos, 5);
    pos[0] = tag;
-    write_fixed32_le(pos + 1, value);
-    return pos + 5;
+#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;
  }
-  [[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
+  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
    // 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 {
-      pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
+      encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
      PROTO_ENCODE_CHECK_BOUNDS(pos, len);
    }
    std::memcpy(pos, string, len);
-    return pos + len;
+    pos += len;
  }
-  [[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 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_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_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(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_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_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_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_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_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_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);
+  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);
    PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
    *pos++ = value ? 0x01 : 0x00;
-    return pos;
  }
-  [[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);
+  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);
    PROTO_ENCODE_CHECK_BOUNDS(pos, 4);
-    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);
+#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
  }
  // 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.
-  [[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_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_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) {
+  static inline void encode_int32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, int32_t value,
+                                  bool force = false) {
    if (value < 0) {
      // negative int32 is always 10 byte long
-      return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
+      encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value), force);
+      return;
    }
-    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint32_t>(value));
+    encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint32_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_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_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_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_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));
+  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_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.
+  /// Sub-message encoding: sync pos to buffer, delegate, get pos from return value.
  template<typename T>
-  [[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) {
+  static inline void 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);
-    return buffer.get_pos();
+    pos = buffer.get_pos();
  }
  template<typename T>
-  [[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) {
+  static inline void 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);
-    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);
-    }
+    pos = buffer.get_pos();
  }
 };
-#undef PROTO_OUTLINE_FOR_SIZE
-#undef PROTO_FIXED32_BYTE_STORES

 #ifdef HAS_PROTO_MESSAGE_DUMP
 /**
@@ -699,12 +624,11 @@ class DumpBuffer {

 class ProtoMessage {
 public:
-  // 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; }
+  // 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.
  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
@@ -724,13 +648,7 @@ class ProtoMessage {
 // Base class for messages that support decoding
 class ProtoDecodableMessage : public ProtoMessage {
 public:
-  /// Stores one decoded field into \p msg; generated per message type. \p scalar is the varint or
-  /// fixed32 value, or the length of the length-delimited payload at \p data. An unknown field or
-  /// wrong wire type matches no case and is skipped.
-  using DecodeFieldFn = void (*)(void *msg, uint32_t tag, const uint8_t *data, proto_varint_value_t scalar);
-  /// Walk \p buffer and hand every field to \p field. The generated decode() passes the message's
-  /// own decode_field, so decodable messages carry no vtable.
-  static void decode_fields(void *msg, const uint8_t *buffer, size_t length, DecodeFieldFn field);
+  void decode(const uint8_t *buffer, size_t length);

  /**
   * Count occurrences of a repeated field in a protobuf buffer.
@@ -742,15 +660,14 @@ class ProtoDecodableMessage : public ProtoMessage {
   * @return Number of times the field appears in the buffer
   */
  static uint32_t count_repeated_field(const uint8_t *buffer, size_t length, uint32_t target_field_id);
-  // The destructor stays accessible on purpose: the generated messages are aggregates that brace
-  // initialise sub message members, which copies a base temporary. That trades away the compile time
-  // guard against deleting through this type; messages are stack locals and never owned through a base
-  // pointer. ProtoMessage keeps its guard for the dump builds.
+
+ protected:
+  ~ProtoDecodableMessage() = default;
+  virtual bool decode_varint(uint32_t field_id, proto_varint_value_t value) { return false; }
+  virtual bool decode_length(uint32_t field_id, ProtoLengthDelimited value) { return false; }
+  virtual bool decode_32bit(uint32_t field_id, Proto32Bit value) { return false; }
+  // NOTE: decode_64bit removed - wire type 1 not supported
 };
-#ifndef HAS_PROTO_MESSAGE_DUMP
-// decode() passes decode_field explicitly, so nothing here may add a vtable
-static_assert(!std::is_polymorphic_v<ProtoDecodableMessage>, "decodable messages carry no vtable");
-#endif

 class ProtoSize {
 public:
@@ -875,7 +792,7 @@ class ProtoSize {
   * @return The number of bytes needed to encode the field ID and wire type
   */
  static constexpr uint32_t field(uint32_t field_id, uint32_t type) {
-    uint32_t tag = proto_tag(field_id, type & WIRE_TYPE_MASK);
+    uint32_t tag = (field_id << 3) | (type & WIRE_TYPE_MASK);
    return varint(tag);
  }

@@ -959,14 +876,24 @@ 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, &T::encode_msg);
+  this->encode_sub_message(field_id, &value, &proto_encode_msg<T>);
 }

 // 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, T::calc_size_msg(&value), &value, &T::encode_msg);
+  this->encode_optional_sub_message(field_id, value.calculate_size(), &value, &proto_encode_msg<T>);
+}
+
+// Template decode_to_message - preserves concrete type so decode() resolves statically
+template<typename T> void ProtoLengthDelimited::decode_to_message(T &msg) const {
+  msg.decode(this->value_, this->length_);
 }

 template<typename T> const char *proto_enum_to_string(T value);
@@ -4,6 +4,7 @@
 #ifdef USE_API
 #include "esphome/core/component.h"
 #include "esphome/core/component_iterator.h"
+#include "esphome/core/controller.h"
 namespace esphome::api {

 class APIConnection;
@@ -1,6 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import i2c, sensor
-from esphome.components.const import UNIT_COUNTS
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_CLEAR,
@@ -34,6 +33,8 @@ CONF_F7 = "f7"
 CONF_F8 = "f8"
 CONF_NIR = "nir"

+UNIT_COUNTS = "#"
+
 AS7341_GAIN = as7341_ns.enum("AS7341Gain")
 GAIN_OPTIONS = {
    "X0.5": AS7341_GAIN.AS7341_GAIN_0_5X,
@@ -6,6 +6,7 @@
 #include "esphome/components/network/util.h"
 #include "esphome/core/log.h"
 #include <cerrno>
+#include <sys/select.h>

 namespace esphome::async_tcp {

@@ -41,15 +42,7 @@ bool AsyncClient::connect(const char *host, uint16_t port) {
    return false;
  }

-  if (socket_->setblocking(false) != 0) {
-    // Capture before the log and close() clobber errno
-    const int saved_errno = errno;
-    ESP_LOGE(TAG, "Failed to set nonblocking: errno %d", saved_errno);
-    close();
-    if (error_cb_)
-      error_cb_(error_arg_, this, saved_errno);
-    return false;
-  }
+  socket_->setblocking(false);

  int err = socket_->connect((struct sockaddr *) &addr, addrlen);
  if (err == 0) {
@@ -104,22 +97,45 @@ void AsyncClient::loop() {
    return;

  if (connecting_) {
-    int err = 0;
-    switch (socket::poll_connect(*socket_, err)) {
-      case socket::ConnectPollResult::CONNECT_POLL_RESULT_PENDING:
-        break;
-      case socket::ConnectPollResult::CONNECT_POLL_RESULT_CONNECTED:
+    // For connecting, we need to check writability, not readability
+    // The Application's select() only monitors read FDs, so we do our own check here
+    // For ESP platforms lwip_select() might be faster, but this code isn't used
+    // on those platforms anyway. If it was, we'd fix the Application select()
+    // to report writability instead of doing it this way.
+    int fd = socket_->get_fd();
+    if (fd < 0) {
+      ESP_LOGW(TAG, "Invalid socket fd");
+      close();
+      return;
+    }
+
+    fd_set writefds;
+    FD_ZERO(&writefds);
+    FD_SET(fd, &writefds);
+
+    struct timeval tv = {0, 0};
+    int ret = select(fd + 1, nullptr, &writefds, nullptr, &tv);
+
+    if (ret > 0 && FD_ISSET(fd, &writefds)) {
+      int error = 0;
+      socklen_t len = sizeof(error);
+      if (socket_->getsockopt(SOL_SOCKET, SO_ERROR, &error, &len) == 0 && error == 0) {
        connecting_ = false;
        connected_ = true;
        if (connect_cb_)
          connect_cb_(connect_arg_, this);
-        break;
-      case socket::ConnectPollResult::CONNECT_POLL_RESULT_ERROR:
-        ESP_LOGW(TAG, "Connection failed: %d", err);
+      } else {
+        ESP_LOGW(TAG, "Connection failed: %d", error);
        close();
        if (error_cb_)
-          error_cb_(error_arg_, this, err);
-        break;
+          error_cb_(error_arg_, this, error);
+      }
+    } else if (ret < 0) {
+      const int err = errno;
+      ESP_LOGE(TAG, "Select error: %d", err);
+      close();
+      if (error_cb_)
+        error_cb_(error_arg_, this, err);
    }
  } else if (connected_) {
    // For connected sockets, use the Application's select() results
@@ -4,6 +4,8 @@ import esphome.codegen as cg
 from esphome.components import i2c
 import esphome.config_validation as cv
 from esphome.const import CONF_FREQUENCY, CONF_ID
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 CODEOWNERS = ["@X-Ryl669"]
@@ -78,21 +80,30 @@ async def to_code(config: ConfigType) -> None:


 # Actions
+AT581XResetAction = at581x_ns.class_("AT581XResetAction", automation.Action)
+AT581XSettingsAction = at581x_ns.class_("AT581XSettingsAction", automation.Action)


-automation.register_apply_action(
+@automation.register_action(
    "at581x.reset",
-    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(AT581XComponent)}),
-    automation.ApplyCall("reset_hardware_frontend()"),
+    AT581XResetAction,
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(AT581XComponent),
+        }
+    ),
+    synchronous=True,
 )
+async def at581x_reset_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])

-
-def _megahertz(value: float) -> int:
-    return int(value / 1000000)
-
-
-def _microamps(value: float) -> int:
-    return int(value * 1000000)
+    return var


 RADAR_SETTINGS_SCHEMA = cv.Schema(
@@ -100,7 +111,7 @@ RADAR_SETTINGS_SCHEMA = cv.Schema(
        cv.Required(CONF_ID): cv.use_id(AT581XComponent),
        cv.Optional(CONF_HW_FRONTEND_RESET): cv.templatable(cv.boolean),
        cv.Optional(CONF_FREQUENCY, default="5800MHz"): cv.templatable(
-            cv.All(cv.frequency, cv.one_of(*RADAR_ALLOWED_FREQ), _megahertz)
+            cv.All(cv.frequency, cv.one_of(*RADAR_ALLOWED_FREQ))
        ),
        cv.Optional(CONF_SENSING_DISTANCE, default=823): cv.templatable(
            cv.int_range(min=0, max=1023)
@@ -112,7 +123,7 @@ RADAR_SETTINGS_SCHEMA = cv.Schema(
            )
        ),
        cv.Optional(CONF_POWER_CONSUMPTION, default="70uA"): cv.templatable(
-            cv.All(cv.current, cv.one_of(*RADAR_ALLOWED_CUR_CONSUMPTION), _microamps)
+            cv.All(cv.current, cv.one_of(*RADAR_ALLOWED_CUR_CONSUMPTION))
        ),
        cv.Optional(CONF_PROTECT_TIME, default="1000ms"): cv.templatable(
            cv.All(
@@ -154,22 +165,60 @@ RADAR_SETTINGS_SCHEMA = cv.Schema(
 )


-# i2c_write_config() must follow the setters: it flushes the staged values.
-automation.register_apply_action(
+@automation.register_action(
    "at581x.settings",
+    AT581XSettingsAction,
    RADAR_SETTINGS_SCHEMA,
-    automation.ApplyField(CONF_FREQUENCY, "set_frequency", cg.int_),
-    automation.ApplyField(CONF_SENSING_DISTANCE, "set_sensing_distance", cg.int_),
-    automation.ApplyField(
-        CONF_POWERON_SELFCHECK_TIME, "set_poweron_selfcheck_time", cg.int_
-    ),
-    automation.ApplyField(CONF_POWER_CONSUMPTION, "set_power_consumption", cg.int_),
-    automation.ApplyField(CONF_PROTECT_TIME, "set_protect_time", cg.int_),
-    automation.ApplyField(CONF_TRIGGER_BASE, "set_trigger_base", cg.int_),
-    automation.ApplyField(CONF_TRIGGER_KEEP, "set_trigger_keep", cg.int_),
-    automation.ApplyField(CONF_STAGE_GAIN, "set_stage_gain", cg.int_),
-    automation.ApplyCall("i2c_write_config()"),
-    automation.ApplyField(
-        CONF_HW_FRONTEND_RESET, "reset_hardware_frontend_if", cg.bool_
-    ),
+    synchronous=True,
 )
+async def at581x_settings_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+
+    # Radar configuration
+    if frontend_reset := config.get(CONF_HW_FRONTEND_RESET):
+        template_ = await cg.templatable(frontend_reset, args, cg.int8)
+        cg.add(var.set_hw_frontend_reset(template_))
+
+    if freq := config.get(CONF_FREQUENCY):
+        if not cg.is_template(freq):
+            freq = int(freq / 1000000)
+        template_ = await cg.templatable(freq, args, cg.int_)
+        cg.add(var.set_frequency(template_))
+
+    if (sens_dist := config.get(CONF_SENSING_DISTANCE)) is not None:
+        template_ = await cg.templatable(sens_dist, args, cg.int_)
+        cg.add(var.set_sensing_distance(template_))
+
+    if selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME):
+        template_ = await cg.templatable(selfcheck, args, cg.int_)
+        cg.add(var.set_poweron_selfcheck_time(template_))
+
+    if protect := config.get(CONF_PROTECT_TIME):
+        template_ = await cg.templatable(protect, args, cg.int_)
+        cg.add(var.set_protect_time(template_))
+
+    if trig_base := config.get(CONF_TRIGGER_BASE):
+        template_ = await cg.templatable(trig_base, args, cg.int_)
+        cg.add(var.set_trigger_base(template_))
+
+    if trig_keep := config.get(CONF_TRIGGER_KEEP):
+        template_ = await cg.templatable(trig_keep, args, cg.int_)
+        cg.add(var.set_trigger_keep(template_))
+
+    if (stage_gain := config.get(CONF_STAGE_GAIN)) is not None:
+        template_ = await cg.templatable(stage_gain, args, cg.int_)
+        cg.add(var.set_stage_gain(template_))
+
+    if power := config.get(CONF_POWER_CONSUMPTION):
+        if not cg.is_template(power):
+            power = int(power * 1000000)
+        template_ = await cg.templatable(power, args, cg.int_)
+        cg.add(var.set_power_consumption(template_))
+
+    return var
@@ -38,10 +38,6 @@ class AT581XComponent final : public Component, public i2c::I2CDevice {

  bool i2c_write_config();
  bool reset_hardware_frontend();
-  void reset_hardware_frontend_if(bool reset) {
-    if (reset)
-      this->reset_hardware_frontend();
-  }
  bool i2c_write_reg(uint8_t addr, uint8_t data);
  bool i2c_write_reg(uint8_t addr, uint32_t data);
  bool i2c_write_reg(uint8_t addr, uint16_t data);
@@ -0,0 +1,69 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
+
+#include "at581x.h"
+
+namespace esphome::at581x {
+
+template<typename... Ts> class AT581XResetAction final : public Action<Ts...>, public Parented<AT581XComponent> {
+ public:
+  void play(const Ts &...x) { this->parent_->reset_hardware_frontend(); }
+};
+
+template<typename... Ts> class AT581XSettingsAction final : public Action<Ts...>, public Parented<AT581XComponent> {
+ public:
+  TEMPLATABLE_VALUE(int8_t, hw_frontend_reset)
+  TEMPLATABLE_VALUE(int, frequency)
+  TEMPLATABLE_VALUE(int, sensing_distance)
+  TEMPLATABLE_VALUE(int, poweron_selfcheck_time)
+  TEMPLATABLE_VALUE(int, power_consumption)
+  TEMPLATABLE_VALUE(int, protect_time)
+  TEMPLATABLE_VALUE(int, trigger_base)
+  TEMPLATABLE_VALUE(int, trigger_keep)
+  TEMPLATABLE_VALUE(int, stage_gain)
+
+  void play(const Ts &...x) {
+    if (this->frequency_.has_value()) {
+      int v = this->frequency_.value(x...);
+      this->parent_->set_frequency(v);
+    }
+    if (this->sensing_distance_.has_value()) {
+      int v = this->sensing_distance_.value(x...);
+      this->parent_->set_sensing_distance(v);
+    }
+    if (this->poweron_selfcheck_time_.has_value()) {
+      int v = this->poweron_selfcheck_time_.value(x...);
+      this->parent_->set_poweron_selfcheck_time(v);
+    }
+    if (this->power_consumption_.has_value()) {
+      int v = this->power_consumption_.value(x...);
+      this->parent_->set_power_consumption(v);
+    }
+    if (this->protect_time_.has_value()) {
+      int v = this->protect_time_.value(x...);
+      this->parent_->set_protect_time(v);
+    }
+    if (this->trigger_base_.has_value()) {
+      int v = this->trigger_base_.value(x...);
+      this->parent_->set_trigger_base(v);
+    }
+    if (this->trigger_keep_.has_value()) {
+      int v = this->trigger_keep_.value(x...);
+      this->parent_->set_trigger_keep(v);
+    }
+    if (this->stage_gain_.has_value()) {
+      int v = this->stage_gain_.value(x...);
+      this->parent_->set_stage_gain(v);
+    }
+
+    // This actually perform all the modification on the system
+    this->parent_->i2c_write_config();
+
+    if (this->hw_frontend_reset_.has_value() && this->hw_frontend_reset_.value(x...) == true) {
+      this->parent_->reset_hardware_frontend();
+    }
+  }
+};
+}  // namespace esphome::at581x
@@ -85,9 +85,18 @@ async def to_code(config: ConfigType) -> None:

    cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature)
-    await sensors(CONF_HUMIDITY, var.set_humidity)
-    await sensors(CONF_BATTERY_LEVEL, var.set_battery_level)
-    await sensors(CONF_BATTERY_VOLTAGE, var.set_battery_voltage)
-    await sensors(CONF_SIGNAL_STRENGTH, var.set_signal_strength)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature(sens))
+    if humidity_config := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity_config)
+        cg.add(var.set_humidity(sens))
+    if battery_level_config := config.get(CONF_BATTERY_LEVEL):
+        sens = await sensor.new_sensor(battery_level_config)
+        cg.add(var.set_battery_level(sens))
+    if battery_voltage_config := config.get(CONF_BATTERY_VOLTAGE):
+        sens = await sensor.new_sensor(battery_voltage_config)
+        cg.add(var.set_battery_voltage(sens))
+    if signal_strength_config := config.get(CONF_SIGNAL_STRENGTH):
+        sens = await sensor.new_sensor(signal_strength_config)
+        cg.add(var.set_signal_strength(sens))
@@ -129,15 +129,30 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await spi.register_spi_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_VOLTAGE, var.set_voltage_sensor)
-    await sensors(CONF_CURRENT, var.set_current_sensor)
-    await sensors(CONF_POWER, var.set_power_sensor)
-    await sensors(CONF_REACTIVE_POWER, var.set_reactive_power_sensor)
-    await sensors(CONF_POWER_FACTOR, var.set_power_factor_sensor)
-    await sensors(CONF_FORWARD_ACTIVE_ENERGY, var.set_forward_active_energy_sensor)
-    await sensors(CONF_REVERSE_ACTIVE_ENERGY, var.set_reverse_active_energy_sensor)
-    await sensors(CONF_FREQUENCY, var.set_freq_sensor)
+    if voltage_config := config.get(CONF_VOLTAGE):
+        sens = await sensor.new_sensor(voltage_config)
+        cg.add(var.set_voltage_sensor(sens))
+    if current_config := config.get(CONF_CURRENT):
+        sens = await sensor.new_sensor(current_config)
+        cg.add(var.set_current_sensor(sens))
+    if power_config := config.get(CONF_POWER):
+        sens = await sensor.new_sensor(power_config)
+        cg.add(var.set_power_sensor(sens))
+    if reactive_power_config := config.get(CONF_REACTIVE_POWER):
+        sens = await sensor.new_sensor(reactive_power_config)
+        cg.add(var.set_reactive_power_sensor(sens))
+    if power_factor_config := config.get(CONF_POWER_FACTOR):
+        sens = await sensor.new_sensor(power_factor_config)
+        cg.add(var.set_power_factor_sensor(sens))
+    if forward_active_energy_config := config.get(CONF_FORWARD_ACTIVE_ENERGY):
+        sens = await sensor.new_sensor(forward_active_energy_config)
+        cg.add(var.set_forward_active_energy_sensor(sens))
+    if reverse_active_energy_config := config.get(CONF_REVERSE_ACTIVE_ENERGY):
+        sens = await sensor.new_sensor(reverse_active_energy_config)
+        cg.add(var.set_reverse_active_energy_sensor(sens))
+    if frequency_config := config.get(CONF_FREQUENCY):
+        sens = await sensor.new_sensor(frequency_config)
+        cg.add(var.set_freq_sensor(sens))
    cg.add(var.set_line_freq(config[CONF_LINE_FREQUENCY]))
    cg.add(var.set_meter_constant(config[CONF_METER_CONSTANT]))
    cg.add(var.set_pl_const(config[CONF_PL_CONST]))
@@ -339,7 +339,10 @@ async def to_code(config: ConfigType) -> None:
    # HTTPS streams verify the server against the root certificate bundle
    require_certificate_bundle()

-    add_idf_component(name="esphome/esp-audio-libs", ref="4.0.1")
+    add_idf_component(
+        name="esphome/esp-audio-libs",
+        ref="3.2.1",
+    )

    data = _get_data()

@@ -1,8 +1,9 @@
 from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.const import CONF_MIC_GAIN
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.const import CONF_ID, CONF_MIC_GAIN
+from esphome.core import ID, CoroPriority, coroutine_with_priority
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 CODEOWNERS = ["@kbx81"]
@@ -11,6 +12,8 @@ IS_PLATFORM_COMPONENT = True
 audio_adc_ns = cg.esphome_ns.namespace("audio_adc")
 AudioAdc = audio_adc_ns.class_("AudioAdc")

+SetMicGainAction = audio_adc_ns.class_("SetMicGainAction", automation.Action)
+

 SET_MIC_GAIN_ACTION_SCHEMA = cv.maybe_simple_value(
    {
@@ -21,11 +24,25 @@ SET_MIC_GAIN_ACTION_SCHEMA = cv.maybe_simple_value(
 )


-automation.register_apply_action(
+@automation.register_action(
    "audio_adc.set_mic_gain",
+    SetMicGainAction,
    SET_MIC_GAIN_ACTION_SCHEMA,
-    automation.ApplyField(CONF_MIC_GAIN, "set_mic_gain", cg.float_),
+    synchronous=True,
 )
+async def audio_adc_set_mic_gain_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+
+    template_ = await cg.templatable(config.get(CONF_MIC_GAIN), args, cg.float_)
+    cg.add(var.set_mic_gain(template_))
+
+    return var


@coroutine_with_priority(CoroPriority.CORE)
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "audio_adc.h"
+
+namespace esphome::audio_adc {
+
+template<typename... Ts> class SetMicGainAction final : public Action<Ts...> {
+ public:
+  explicit SetMicGainAction(AudioAdc *audio_adc) : audio_adc_(audio_adc) {}
+
+  TEMPLATABLE_VALUE(float, mic_gain)
+
+  void play(const Ts &...x) override { this->audio_adc_->set_mic_gain(this->mic_gain_.value(x...)); }
+
+ protected:
+  AudioAdc *audio_adc_;
+};
+
+}  // namespace esphome::audio_adc
@@ -2,8 +2,9 @@ from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.const import CONF_VOLUME
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.const import CONF_ID, CONF_VOLUME
+from esphome.core import ID, CoroPriority, coroutine_with_priority
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 CODEOWNERS = ["@kbx81"]
@@ -12,6 +13,10 @@ IS_PLATFORM_COMPONENT = True
 audio_dac_ns = cg.esphome_ns.namespace("audio_dac")
 AudioDac = audio_dac_ns.class_("AudioDac")

+MuteOffAction = audio_dac_ns.class_("MuteOffAction", automation.Action)
+MuteOnAction = audio_dac_ns.class_("MuteOnAction", automation.Action)
+SetVolumeAction = audio_dac_ns.class_("SetVolumeAction", automation.Action)
+

 MUTE_ACTION_SCHEMA = maybe_simple_id(
    {
@@ -28,19 +33,41 @@ SET_VOLUME_ACTION_SCHEMA = cv.maybe_simple_value(
 )


-for _name, _call in (
-    ("audio_dac.mute_off", "set_mute_off()"),
-    ("audio_dac.mute_on", "set_mute_on()"),
-):
-    automation.register_apply_action(
-        _name, MUTE_ACTION_SCHEMA, automation.ApplyCall(_call)
-    )
-
-automation.register_apply_action(
-    "audio_dac.set_volume",
-    SET_VOLUME_ACTION_SCHEMA,
-    automation.ApplyField(CONF_VOLUME, "set_volume", cg.float_),
+@automation.register_action(
+    "audio_dac.mute_off", MuteOffAction, MUTE_ACTION_SCHEMA, synchronous=True
 )
+@automation.register_action(
+    "audio_dac.mute_on", MuteOnAction, MUTE_ACTION_SCHEMA, synchronous=True
+)
+async def audio_dac_mute_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@automation.register_action(
+    "audio_dac.set_volume",
+    SetVolumeAction,
+    SET_VOLUME_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def audio_dac_set_volume_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+
+    template_ = await cg.templatable(config.get(CONF_VOLUME), args, cg.float_)
+    cg.add(var.set_volume(template_))
+
+    return var


@coroutine_with_priority(CoroPriority.CORE)
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "audio_dac.h"
+
+namespace esphome::audio_dac {
+
+template<typename... Ts> class MuteOffAction final : public Action<Ts...> {
+ public:
+  explicit MuteOffAction(AudioDac *audio_dac) : audio_dac_(audio_dac) {}
+
+  void play(const Ts &...x) override { this->audio_dac_->set_mute_off(); }
+
+ protected:
+  AudioDac *audio_dac_;
+};
+
+template<typename... Ts> class MuteOnAction final : public Action<Ts...> {
+ public:
+  explicit MuteOnAction(AudioDac *audio_dac) : audio_dac_(audio_dac) {}
+
+  void play(const Ts &...x) override { this->audio_dac_->set_mute_on(); }
+
+ protected:
+  AudioDac *audio_dac_;
+};
+
+template<typename... Ts> class SetVolumeAction final : public Action<Ts...> {
+ public:
+  explicit SetVolumeAction(AudioDac *audio_dac) : audio_dac_(audio_dac) {}
+
+  TEMPLATABLE_VALUE(float, volume)
+
+  void play(const Ts &...x) override { this->audio_dac_->set_volume(this->volume_.value(x...)); }
+
+ protected:
+  AudioDac *audio_dac_;
+};
+
+}  // namespace esphome::audio_dac
@@ -203,10 +203,16 @@ void BangBangClimate::set_away_config(const BangBangClimateTargetTempConfig &awa
  this->away_config_ = away_config;
 }

+void BangBangClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
+void BangBangClimate::set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
+
 Trigger<> *BangBangClimate::get_idle_trigger() { return &this->idle_trigger_; }
 Trigger<> *BangBangClimate::get_cool_trigger() { return &this->cool_trigger_; }
 Trigger<> *BangBangClimate::get_heat_trigger() { return &this->heat_trigger_; }

+void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
+void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
+
 void BangBangClimate::dump_config() {
  LOG_CLIMATE("", "Bang Bang Climate", this);
  ESP_LOGCONFIG(TAG,
@@ -22,10 +22,10 @@ class BangBangClimate final : public climate::Climate, public Component {
  void setup() override;
  void dump_config() override;

-  void set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
-  void set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
-  void set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
-  void set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
+  void set_sensor(sensor::Sensor *sensor);
+  void set_humidity_sensor(sensor::Sensor *humidity_sensor);
+  void set_supports_cool(bool supports_cool);
+  void set_supports_heat(bool supports_heat);
  void set_normal_config(const BangBangClimateTargetTempConfig &normal_config);
  void set_away_config(const BangBangClimateTargetTempConfig &away_config);

@@ -17,7 +17,11 @@ class BinaryLightOutput final : public light::LightOutput {
  void write_state(light::LightState *state) override {
    bool binary;
    state->current_values_as_binary(&binary);
-    this->output_->set_state(binary);
+    if (binary) {
+      this->output_->turn_on();
+    } else {
+      this->output_->turn_off();
+    }
  }

 protected:
@@ -1,7 +1,7 @@
 from logging import getLogger

 from esphome import automation, core
-from esphome.automation import maybe_simple_id
+from esphome.automation import Condition, maybe_simple_id
 import esphome.codegen as cg
 from esphome.components import mqtt, web_server, zigbee
 from esphome.components.const import CONF_ON_STATE_CHANGE
@@ -39,7 +39,6 @@ from esphome.const import (
    DEVICE_CLASS_EMPTY,
    DEVICE_CLASS_GARAGE_DOOR,
    DEVICE_CLASS_GAS,
-    DEVICE_CLASS_GLASS_BREAK,
    DEVICE_CLASS_HEAT,
    DEVICE_CLASS_LIGHT,
    DEVICE_CLASS_LOCK,
@@ -61,16 +60,14 @@ from esphome.const import (
    DEVICE_CLASS_VIBRATION,
    DEVICE_CLASS_WINDOW,
 )
-from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
-    SubEntities,
    entity_duplicate_validator,
    queue_entity_register,
    setup_device_class,
    setup_entity,
 )
-from esphome.cpp_generator import MockObj, MockObjClass
-from esphome.types import ConfigType
+from esphome.cpp_generator import MockObjClass
 from esphome.util import Registry

 CODEOWNERS = ["@esphome/core"]
@@ -84,7 +81,6 @@ DEVICE_CLASSES = [
    DEVICE_CLASS_EMPTY,
    DEVICE_CLASS_GARAGE_DOOR,
    DEVICE_CLASS_GAS,
-    DEVICE_CLASS_GLASS_BREAK,
    DEVICE_CLASS_HEAT,
    DEVICE_CLASS_LIGHT,
    DEVICE_CLASS_LOCK,
@@ -136,6 +132,15 @@ MultiClickTriggerBase = binary_sensor_ns.class_(
 MultiClickTrigger = binary_sensor_ns.class_("MultiClickTrigger", MultiClickTriggerBase)
 MultiClickTriggerEvent = binary_sensor_ns.struct("MultiClickTriggerEvent")

+BinarySensorPublishAction = binary_sensor_ns.class_(
+    "BinarySensorPublishAction", automation.Action
+)
+BinarySensorInvalidateAction = binary_sensor_ns.class_(
+    "BinarySensorInvalidateAction", automation.Action
+)
+
+# Condition
+BinarySensorCondition = binary_sensor_ns.class_("BinarySensorCondition", Condition)

 # Filters
 Filter = binary_sensor_ns.class_("Filter")
@@ -447,9 +452,7 @@ _BINARY_SENSOR_SCHEMA = (
            cv.Optional(
                CONF_DEVICE_CLASS, visibility=cv.Visibility.ADVANCED
            ): validate_device_class,
-            cv.Optional(
-                CONF_FILTERS, visibility=cv.Visibility.ADVANCED
-            ): validate_filters,
+            cv.Optional(CONF_FILTERS): validate_filters,
            cv.Optional(CONF_ON_PRESS): automation.validate_automation({}),
            cv.Optional(CONF_ON_RELEASE): automation.validate_automation({}),
            cv.Optional(CONF_ON_CLICK): cv.All(
@@ -634,13 +637,6 @@ async def new_binary_sensor(config, *args):
    return var


-def sub_binary_sensors(
-    config: ConfigType, *, parent: MockObj | ID | None = None
-) -> SubEntities:
-    """Return a SubEntities bound to new_binary_sensor."""
-    return SubEntities(new_binary_sensor, config, parent)
-
-
 BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id(
    {
        cv.Required(CONF_ID): cv.use_id(BinarySensor),
@@ -648,12 +644,20 @@ BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id(
 )


-automation.register_apply_condition(
-    "binary_sensor.is_on", BINARY_SENSOR_CONDITION_SCHEMA, "state"
+@automation.register_condition(
+    "binary_sensor.is_on", BinarySensorCondition, BINARY_SENSOR_CONDITION_SCHEMA
 )
-automation.register_apply_condition(
-    "binary_sensor.is_off", BINARY_SENSOR_CONDITION_SCHEMA, "state == false"
+async def binary_sensor_is_on_to_code(config, condition_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren, True)
+
+
+@automation.register_condition(
+    "binary_sensor.is_off", BinarySensorCondition, BINARY_SENSOR_CONDITION_SCHEMA
 )
+async def binary_sensor_is_off_to_code(config, condition_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren, False)


@coroutine_with_priority(CoroPriority.CORE)
@@ -661,16 +665,20 @@ async def to_code(config):
    cg.add_global(binary_sensor_ns.using)


-automation.register_apply_action(
+@automation.register_action(
    "binary_sensor.invalidate_state",
+    BinarySensorInvalidateAction,
    cv.maybe_simple_value(
        {
            cv.Required(CONF_ID): cv.use_id(BinarySensor),
        },
        key=CONF_ID,
    ),
-    automation.ApplyCall("invalidate_state()"),
+    synchronous=True,
 )
+async def binary_sensor_invalidate_state_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)


 # automation.cpp only implements the click/double_click/multi_click triggers
@@ -18,6 +18,26 @@ struct MultiClickTriggerEvent {
  uint32_t max_length;
 };

+class PressTrigger final : public Trigger<> {
+ public:
+  explicit PressTrigger(BinarySensor *parent) {
+    parent->add_on_state_callback([this](bool state) {
+      if (state)
+        this->trigger();
+    });
+  }
+};
+
+class ReleaseTrigger final : public Trigger<> {
+ public:
+  explicit ReleaseTrigger(BinarySensor *parent) {
+    parent->add_on_state_callback([this](bool state) {
+      if (!state)
+        this->trigger();
+    });
+  }
+};
+
 bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length);

 class ClickTrigger final : public Trigger<> {
@@ -120,4 +140,53 @@ template<size_t N> class MultiClickTrigger final : public MultiClickTriggerBase
  std::array<MultiClickTriggerEvent, N> timing_storage_{};
 };

+class StateTrigger final : public Trigger<bool> {
+ public:
+  explicit StateTrigger(BinarySensor *parent) {
+    parent->add_on_state_callback([this](bool state) { this->trigger(state); });
+  }
+};
+
+class StateChangeTrigger final : public Trigger<optional<bool>, optional<bool> > {
+ public:
+  explicit StateChangeTrigger(BinarySensor *parent) {
+    parent->add_full_state_callback(
+        [this](optional<bool> old_state, optional<bool> state) { this->trigger(old_state, state); });
+  }
+};
+
+template<typename... Ts> class BinarySensorCondition final : public Condition<Ts...> {
+ public:
+  BinarySensorCondition(BinarySensor *parent, bool state) : parent_(parent), state_(state) {}
+  bool check(const Ts &...x) override { return this->parent_->state == this->state_; }
+
+ protected:
+  BinarySensor *parent_;
+  bool state_;
+};
+
+template<typename... Ts> class BinarySensorPublishAction final : public Action<Ts...> {
+ public:
+  explicit BinarySensorPublishAction(BinarySensor *sensor) : sensor_(sensor) {}
+  TEMPLATABLE_VALUE(bool, state)
+
+  void play(const Ts &...x) override {
+    auto val = this->state_.value(x...);
+    this->sensor_->publish_state(val);
+  }
+
+ protected:
+  BinarySensor *sensor_;
+};
+
+template<typename... Ts> class BinarySensorInvalidateAction final : public Action<Ts...> {
+ public:
+  explicit BinarySensorInvalidateAction(BinarySensor *sensor) : sensor_(sensor) {}
+
+  void play(const Ts &...x) override { this->sensor_->invalidate_state(); }
+
+ protected:
+  BinarySensor *sensor_;
+};
+
 }  // namespace esphome::binary_sensor
@@ -32,8 +32,7 @@ void log_binary_sensor(const char *tag, const char *prefix, const char *type, Bi
 */
 class BinarySensor : public StatefulEntityBase<bool> {
 public:
-  // User provided, not "= default": `new(p) BinarySensor()` would zero-fill .bss that is already zero.
-  explicit BinarySensor() {}
+  explicit BinarySensor() = default;

  const bool &get_state() const override { return this->state; }
  void set_trigger_on_initial_state(bool value) { this->trigger_on_initial_state_ = value; }
@@ -53,9 +53,6 @@ class DelayedOnOffFilter final : public Filter {

 class DelayedOnFilter : public Filter {
 public:
-  // User provided, not "= default": `new(p) DelayedOnFilter()` would zero-fill .bss that is already zero.
-  DelayedOnFilter() {}
-
  optional<bool> new_value(bool value) override;

  template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -66,9 +63,6 @@ class DelayedOnFilter : public Filter {

 class DelayedOffFilter : public Filter {
 public:
-  // User provided, not "= default": `new(p) DelayedOffFilter()` would zero-fill .bss that is already zero.
-  DelayedOffFilter() {}
-
  optional<bool> new_value(bool value) override;

  template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -149,8 +143,6 @@ class StatelessLambdaFilter : public Filter {

 class SettleFilter : public Filter {
 public:
-  // User provided, not "= default": `new(p) SettleFilter()` would zero-fill .bss that is already zero.
-  SettleFilter() {}
  optional<bool> new_value(bool value) override;

  template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -23,7 +23,7 @@ public ble_api.h.
 import logging

 import esphome.codegen as cg
-from esphome.components import libretiny, wifi
+from esphome.components import libretiny
 from esphome.components.libretiny.const import (
    FAMILY_BK7231N,
    FAMILY_BK7231Q,
@@ -84,15 +84,6 @@ def _final_validate(config: ConfigType) -> None:
    # which run on a BLE 4.2 board. The hard error is raised at codegen.
    if msg := _unsupported_family_message(libretiny.get_libretiny_family()):
        _LOGGER.warning("%s (this configuration cannot compile)", msg)
-    # Any wifi power_save_mode other than NONE also arms the Beken SDK's MCU
-    # sleep. With the BLE controller running, that sleep never wakes up once the
-    # station is stopped (adapter restart after failed roams, wifi.disable): the
-    # device is dead until a power cycle (esphome#18592). Keep power save off
-    # until LibreTiny ships the SDK-side fix (libretiny-eu/libretiny#414).
-    wifi.force_power_save_off(
-        "with BLE running, the Beken SDK's MCU sleep halts the device once the "
-        "station is stopped (https://github.com/esphome/esphome/issues/18592)"
-    )


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -53,6 +53,7 @@ BK72xxBLETracker = bk72xx_ble_tracker_ns.class_(
 )

 StartScanAction = bk72xx_ble_tracker_ns.class_("StartScanAction", automation.Action)
+StopScanAction = bk72xx_ble_tracker_ns.class_("StopScanAction", automation.Action)

 ESPBTAdvertiseTrigger = ble_automation.ESPBTAdvertiseTrigger
 BLEServiceDataAdvertiseTrigger = ble_automation.BLEServiceDataAdvertiseTrigger
@@ -120,8 +121,9 @@ async def start_scan_action_to_code(
    return var


-automation.register_apply_action(
+@automation.register_action(
    "bk72xx_ble_tracker.stop_scan",
+    StopScanAction,
    automation.maybe_simple_id(
        cv.Schema(
            {
@@ -129,8 +131,17 @@ automation.register_apply_action(
            }
        )
    ),
-    automation.ApplyCall("stop_scan()"),
+    synchronous=True,
 )
+async def stop_scan_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: list,
+) -> cg.MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var


 async def to_code(config: ConfigType) -> None:
@@ -38,6 +38,11 @@ template<typename... Ts> class StartScanAction final : public Action<Ts...>, pub
  }
 };

+template<typename... Ts> class StopScanAction final : public Action<Ts...>, public Parented<BK72xxBLETracker> {
+ public:
+  void play(const Ts &...x) override { this->parent_->stop_scan(); }
+};
+
 }  // namespace esphome::bk72xx_ble_tracker

 #endif  // USE_LIBRETINY
@@ -2,6 +2,7 @@

 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/datatypes.h"

@@ -46,6 +47,8 @@ struct sbe24_t {  // NOLINT(readability-identifier-naming,altera-struct-pack-ali
  int8_t h{0};
 } __attribute__((packed));

+template<typename... Ts> class ResetEnergyAction;
+
 class BL0906;

 using ActionCallbackFuncPtr = void (BL0906::*)();
@@ -82,10 +85,9 @@ class BL0906 final : public PollingComponent, public uart::UARTDevice {
  void setup() override;
  void dump_config() override;

-  /// Queue an energy counter reset for the next poll
-  void reset_energy() { this->enqueue_action_(&BL0906::reset_energy_); }
-
 protected:
+  template<typename... Ts> friend class ResetEnergyAction;
+
  void reset_energy_();

  void read_data_(uint8_t address, float reference, sensor::Sensor *sensor);
@@ -101,4 +103,9 @@ class BL0906 final : public PollingComponent, public uart::UARTDevice {
  std::vector<ActionCallbackFuncPtr> action_queue_{};
 };

+template<typename... Ts> class ResetEnergyAction final : public Action<Ts...>, public Parented<BL0906> {
+ public:
+  void play(const Ts &...x) override { this->parent_->enqueue_action_(&BL0906::reset_energy_); }
+};
+
 }  // namespace esphome::bl0906
@@ -32,6 +32,8 @@ from esphome.const import (
    UNIT_VOLT,
    UNIT_WATT,
 )
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 # Import ICONS not included in esphome's const.py, from the local components const.py
@@ -43,6 +45,7 @@ CONF_TOTAL_ENERGY = "total_energy"

 bl0906_ns = cg.esphome_ns.namespace("bl0906")
 BL0906 = bl0906_ns.class_("BL0906", cg.PollingComponent, uart.UARTDevice)
+ResetEnergyAction = bl0906_ns.class_("ResetEnergyAction", automation.Action)

 CONFIG_SCHEMA = (
    cv.Schema(
@@ -135,25 +138,40 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
 )


-automation.register_apply_action(
+@automation.register_action(
    "bl0906.reset_energy",
+    ResetEnergyAction,
    maybe_simple_id(
        {
            cv.Required(CONF_ID): cv.use_id(BL0906),
        }
    ),
-    automation.ApplyCall("reset_energy()"),
+    synchronous=True,
 )
+async def reset_energy_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var


 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_FREQUENCY, var.set_frequency_sensor)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_VOLTAGE, var.set_voltage_sensor)
+    if frequency_config := config.get(CONF_FREQUENCY):
+        sens = await sensor.new_sensor(frequency_config)
+        cg.add(var.set_frequency_sensor(sens))
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+    if voltage_config := config.get(CONF_VOLTAGE):
+        sens = await sensor.new_sensor(voltage_config)
+        cg.add(var.set_voltage_sensor(sens))

    for i in range(6):
        if channel_config := config.get(f"{CONF_CHANNEL}_{i + 1}"):
@@ -167,5 +185,10 @@ async def to_code(config: ConfigType) -> None:
                sens = await sensor.new_sensor(energy_config)
                cg.add(getattr(var, f"set_energy_{i + 1}_sensor")(sens))

-    await sensors(CONF_TOTAL_POWER, var.set_total_power_sensor)
-    await sensors(CONF_TOTAL_ENERGY, var.set_total_energy_sensor)
+    if total_power_config := config.get(CONF_TOTAL_POWER):
+        sens = await sensor.new_sensor(total_power_config)
+        cg.add(var.set_total_power_sensor(sens))
+
+    if total_energy_config := config.get(CONF_TOTAL_ENERGY):
+        sens = await sensor.new_sensor(total_energy_config)
+        cg.add(var.set_total_energy_sensor(sens))
@@ -94,12 +94,27 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_VOLTAGE, var.set_voltage_sensor)
-    await sensors(CONF_CURRENT_1, var.set_current_sensor_1)
-    await sensors(CONF_CURRENT_2, var.set_current_sensor_2)
-    await sensors(CONF_ACTIVE_POWER_1, var.set_power_sensor_1)
-    await sensors(CONF_ACTIVE_POWER_2, var.set_power_sensor_2)
-    await sensors(CONF_ENERGY_1, var.set_energy_sensor_1)
-    await sensors(CONF_ENERGY_2, var.set_energy_sensor_2)
-    await sensors(CONF_ENERGY_TOTAL, var.set_energy_sensor_sum)
+    if voltage_config := config.get(CONF_VOLTAGE):
+        sens = await sensor.new_sensor(voltage_config)
+        cg.add(var.set_voltage_sensor(sens))
+    if current_1_config := config.get(CONF_CURRENT_1):
+        sens = await sensor.new_sensor(current_1_config)
+        cg.add(var.set_current_sensor_1(sens))
+    if current_2_config := config.get(CONF_CURRENT_2):
+        sens = await sensor.new_sensor(current_2_config)
+        cg.add(var.set_current_sensor_2(sens))
+    if active_power_1_config := config.get(CONF_ACTIVE_POWER_1):
+        sens = await sensor.new_sensor(active_power_1_config)
+        cg.add(var.set_power_sensor_1(sens))
+    if active_power_2_config := config.get(CONF_ACTIVE_POWER_2):
+        sens = await sensor.new_sensor(active_power_2_config)
+        cg.add(var.set_power_sensor_2(sens))
+    if energy_1_config := config.get(CONF_ENERGY_1):
+        sens = await sensor.new_sensor(energy_1_config)
+        cg.add(var.set_energy_sensor_1(sens))
+    if energy_2_config := config.get(CONF_ENERGY_2):
+        sens = await sensor.new_sensor(energy_2_config)
+        cg.add(var.set_energy_sensor_2(sens))
+    if energy_total_config := config.get(CONF_ENERGY_TOTAL):
+        sens = await sensor.new_sensor(energy_total_config)
+        cg.add(var.set_energy_sensor_sum(sens))
--- a/Show More
+++ b/Show More